Open Search
    Vec3< T, STRIDE > Struct Template Reference

    #include <vec.h>

    Detailed Description

    template<typename T, Int STRIDE = 1>
    struct maxon::Vec3< T, STRIDE >

    A vector consisting of three components X, Y and Z.

    Public Types

    template<typename U >
    using Rebind = Vec3< U, STRIDE >
     
    using VectorStrideType = std::integral_constant< Int, STRIDE >
     
    using ValueType = T
     
    using ValueTypeParam = typename ByValueParam< T >::type
     
    using Unstrided = Vec3< T, 1 >
     
    using BoolType = decltype(T()==T())
     

    Public Member Functions

    constexpr Vec3 ()
     
    constexpr Vec3 (ValueTypeParam in)
     
    constexpr Vec3 (ValueTypeParam ix, ValueTypeParam iy, ValueTypeParam iz)
     
    template<typename T2 , Int S2>
    constexpr Vec3 (const Vec3< T2, S2 > &v)
     
    template<typename T2 , Int S2>
    constexpr Vec3 (const Col3< T2, S2 > &v)
     
    template<Int S2>
    constexpr Vec3 (const Vec3< T, S2 > &v)
     
    template<typename T2 , Int S2, typename SPACE2 >
    constexpr Vec3 (const Vec2< T2, S2, SPACE2 > &v, T vz=T())
     
    template<typename T2 , Int S2>
    constexpr Vec3 (const Vec4< T2, S2 > &v)
     
    template<typename T2 , Int S2>
    constexpr Vec3 (const Col4< T2, S2 > &v)
     
    constexpr Vec3 (ENUM_DONT_INITIALIZE v)
     
    constexpr MAXON_IMPLICIT Vec3 (const typename std::conditional< STRIDE==1, DummyParamType, Vec3 >::type &src)
     
    Vec3operator= (const typename std::conditional< STRIDE==1, DummyParamType, Vec3 >::type &src)
     
    T & operator[] (Int l)
     
    ValueTypeParam operator[] (Int l) const
     
    template<typename T2 , Int S2>
    Vec3operator+= (const Vec3< T2, S2 > &v)
     
    Vec3operator+= (const Vec3 &v)
     
    template<typename T2 , Int S2>
    Vec3operator-= (const Vec3< T2, S2 > &v)
     
    Vec3operator-= (const Vec3 &v)
     
    template<typename T2 , Int S2>
    Vec3operator*= (const Vec3< T2, S2 > &v)
     
    Vec3operator*= (const Vec3 &v)
     
    Vec3operator*= (ValueTypeParam s)
     
    Vec3operator/= (ValueTypeParam s)
     
    constexpr Unstrided operator* (ValueTypeParam s) const
     
    template<typename S >
    constexpr Vec3< typename MultiplicativePromotion< T, S, STD_IS_REPLACEMENT(scalar, S)>::type, 1 > operator* (S s) const
     
    constexpr Unstrided operator/ (ValueTypeParam s) const
     
    constexpr Unstrided operator* (const Vec3 &v) const
     
    constexpr Unstrided operator+ (const Vec3 &v) const
     
    constexpr Unstrided operator- (const Vec3 &v) const
     
    constexpr Unstrided operator- () const
     
    template<typename T2 , Int S2>
    constexpr BoolType operator== (const Vec3< T2, S2 > &v) const
     
    constexpr BoolType operator== (const Vec3 &v) const
     
    template<typename T2 , Int S2>
    constexpr BoolType operator!= (const Vec3< T2, S2 > &v) const
     
    constexpr BoolType operator!= (const Vec3 &v) const
     
    constexpr BoolType operator<= (const Vec3 &v) const
     
    constexpr BoolType operator>= (const Vec3 &v) const
     
    constexpr BoolType operator< (const Vec3 &v) const
     
    constexpr BoolType operator> (const Vec3 &v) const
     
    constexpr HashInt GetHashCode () const
     
    UniqueHash GetUniqueHashCode () const
     
    BoolType IsEqual (const Vec3 &other, ValueTypeParam epsilon) const
     
    constexpr BoolType IsZero () const
     
    BoolType IsZero (ValueTypeParam epsilon) const
     
    void SetZero ()
     
    constexpr T GetAverage () const
     
    constexpr T GetSum () const
     
    void ClampMin (const Vec3 &other=Vec3())
     
    void ClampMax (const Vec3 &other)
     
    constexpr Unstrided Clamp01 () const
     
    GetLength () const
     
    constexpr T GetSquaredLength () const
     
    Unstrided GetNormalized () const
     
    Unstrided operator! () const
     
    void Normalize ()
     
    String ToString (const FormatStatement *formatStatement=nullptr) const
     
    constexpr const Col3< T, STRIDE > & GetColor () const
     
    Col3< T, STRIDE > & GetColor ()
     
    constexpr T GetMin () const
     
    constexpr T GetMax () const
     
    constexpr Unstrided GetRightRotated (Int rots) const
     
    template<typename T2 >
    Vec3operator*= (const Mat3< T2 > &m)
     

    Static Public Member Functions

    static MAXON_ATTRIBUTE_FORCE_INLINE const Vec3DefaultValue ()
     

    Public Attributes

    union {
       T   x
     
       T   _xpadding [STRIDE]
     
    }; 
     
    union {
       T   y
     
       T   _ypadding [STRIDE]
     
    }; 
     
    union {
       T   z
     
       T   _zpadding [STRIDE]
     
    }; 
     

    Friends

    constexpr friend Unstrided operator* (ValueTypeParam s, const Vec3 &v)
     
    constexpr friend T Dot (const Vec3 &v1, const Vec3 &v2)
     
    Unstrided Abs (const Vec3 &v1)
     
    template<typename T2 , Int S2>
    constexpr friend MultiplicativePromotion< T, T2 >::type Dot (const Vec3 &v1, const Vec3< T2, S2 > &v2)
     
    constexpr friend Unstrided Min (const Vec3 &a, const Vec3 &other)
     
    constexpr friend Unstrided Max (const Vec3 &a, const Vec3 &other)
     
    void SetMin (Vec3 &a, const Vec3 &other)
     
    void SetMax (Vec3 &a, const Vec3 &other)
     
    GetAngle (const Vec3 &v1, const Vec3 &v2)
     
    constexpr friend Unstrided Cross (const Vec3 &v1, const Vec3 &v2)
     
    template<typename T2 , Int S2>
    constexpr friend Vec3< typename MultiplicativePromotion< T, T2 >::type, 1 > Cross (const Vec3 &v1, const Vec3< T2, S2 > &v2)
     

    Member Typedef Documentation

    ◆ Rebind

    using Rebind = Vec3<U, STRIDE>

    ◆ VectorStrideType

    using VectorStrideType = std::integral_constant<Int, STRIDE>

    ◆ ValueType

    using ValueType = T

    ◆ ValueTypeParam

    using ValueTypeParam = typename ByValueParam<T>::type

    ◆ Unstrided

    using Unstrided = Vec3<T, 1>

    ◆ BoolType

    using BoolType = decltype(T() == T())

    The type returned by comparisons. If the template argument for T is a SIMD type, this will be a SIMD type, too, which contains the per-element results.

    Constructor & Destructor Documentation

    ◆ Vec3() [1/11]

    constexpr Vec3 ( )
    constexpr

    Initializes all vector components with 0.0.

    ◆ Vec3() [2/11]

    constexpr Vec3 ( ValueTypeParam  in)
    explicitconstexpr

    Initializes all vector components with a scalar.

    ◆ Vec3() [3/11]

    constexpr Vec3 ( ValueTypeParam  ix,
    ValueTypeParam  iy,
    ValueTypeParam  iz 
    )
    explicitconstexpr

    Initializes all vector components individually.

    ◆ Vec3() [4/11]

    constexpr Vec3 ( const Vec3< T2, S2 > &  v)
    explicitconstexpr

    Initializes components from another 3d vector.

    ◆ Vec3() [5/11]

    constexpr Vec3 ( const Col3< T2, S2 > &  v)
    explicitconstexpr

    Initializes components from another 3d vector.

    ◆ Vec3() [6/11]

    constexpr Vec3 ( const Vec3< T, S2 > &  v)
    constexpr

    Initializes components from another 3d vector.

    ◆ Vec3() [7/11]

    constexpr Vec3 ( const Vec2< T2, S2, SPACE2 > &  v,
    vz = T() 
    )
    explicitconstexpr

    Initializes components from a 2d vector. The z-component is set to 0.0 unless an extra parameter is passed.

    ◆ Vec3() [8/11]

    constexpr Vec3 ( const Vec4< T2, S2 > &  v)
    explicitconstexpr

    Initializes components from a 4d vector. The w-component is omitted.

    ◆ Vec3() [9/11]

    constexpr Vec3 ( const Col4< T2, S2 > &  v)
    explicitconstexpr

    Initializes components from a 4d vector. The w-component is omitted.

    ◆ Vec3() [10/11]

    constexpr Vec3 ( ENUM_DONT_INITIALIZE  v)
    explicitconstexpr

    Skips initialization of vector (for better speed)

    ◆ Vec3() [11/11]

    constexpr MAXON_IMPLICIT Vec3 ( const typename std::conditional< STRIDE==1, DummyParamType, Vec3< T, STRIDE > >::type src)
    constexpr

    When STRIDE is not 1, we have to provide copy constructor and operator because the default ones would also copy the padding. When STRIDE is 1, we want to avoid to declare them (because then the type wouldn't be trivially copyable any longer), so we use DummyParamType for the parameter in that case.

    Member Function Documentation

    ◆ operator=()

    Vec3& operator= ( const typename std::conditional< STRIDE==1, DummyParamType, Vec3< T, STRIDE > >::type src)

    Copies the source vector.

    Parameters
    [in]srcSource vector.
    Returns
    *this.

    ◆ operator[]() [1/2]

    T& operator[] ( Int  l)

    Accesses vector component: index 0 is 'x', index 1 is 'y', index 2 is 'z'. All other values must not be used and will crash.

    ◆ operator[]() [2/2]

    ValueTypeParam operator[] ( Int  l) const

    Accesses vector component: index 0 is 'x', index 1 is 'y', index 2 is 'z'. All other values must not be used and will crash.

    ◆ operator+=() [1/2]

    Vec3& operator+= ( const Vec3< T2, S2 > &  v)

    Adds two vectors.

    ◆ operator+=() [2/2]

    Vec3& operator+= ( const Vec3< T, STRIDE > &  v)

    Adds a vector. We repeat the function template as non-template function, this allows the usage in contexts where the parameter is not a vector itself, but something with a conversion operator to a vector.

    Parameters
    [in]vVector to be added.
    Returns
    *this.

    ◆ operator-=() [1/2]

    Vec3& operator-= ( const Vec3< T2, S2 > &  v)

    Subtracts two vectors.

    ◆ operator-=() [2/2]

    Vec3& operator-= ( const Vec3< T, STRIDE > &  v)

    Subtracts a vector. We repeat the function template as non-template function, this allows the usage in contexts where the parameter is not a vector itself, but something with a conversion operator to a vector.

    Parameters
    [in]vVector to be substracted from this.
    Returns
    *this.

    ◆ operator*=() [1/4]

    Vec3& operator*= ( const Vec3< T2, S2 > &  v)

    Multiplies two vectors component-wise.

    ◆ operator*=() [2/4]

    Vec3& operator*= ( const Vec3< T, STRIDE > &  v)

    Multiplies with vector component-wise. We repeat the function template as non-template function, this allows the usage in contexts where the parameter is not a vector itself, but something with a conversion operator to a vector.

    Parameters
    [in]vVector to be multiplied with.
    Returns
    *this.

    ◆ operator*=() [3/4]

    Vec3& operator*= ( ValueTypeParam  s)

    Multiplies each vector component by a scalar.

    ◆ operator/=()

    Vec3& operator/= ( ValueTypeParam  s)

    Divides each vector component by a scalar. The passed argument is checked for 0.0.

    ◆ operator*() [1/3]

    constexpr Unstrided operator* ( ValueTypeParam  s) const
    constexpr

    Multiplies each vector component by a scalar.

    ◆ operator*() [2/3]

    constexpr Vec3<typename MultiplicativePromotion<T, S, STD_IS_REPLACEMENT(scalar, S)>::type, 1> operator* ( s) const
    constexpr

    Multiplies each vector component by a scalar.

    ◆ operator/()

    constexpr Unstrided operator/ ( ValueTypeParam  s) const
    constexpr

    Divides each vector component by a scalar. The scalar value is tested for 0.0.

    ◆ operator*() [3/3]

    constexpr Unstrided operator* ( const Vec3< T, STRIDE > &  v) const
    constexpr

    Multiplies two vectors component-wise.

    ◆ operator+()

    constexpr Unstrided operator+ ( const Vec3< T, STRIDE > &  v) const
    constexpr

    Adds two vectors.

    ◆ operator-() [1/2]

    constexpr Unstrided operator- ( const Vec3< T, STRIDE > &  v) const
    constexpr

    Subtracts vector v2 from v1.

    ◆ operator-() [2/2]

    constexpr Unstrided operator- ( ) const
    constexpr

    Negates vector v.

    ◆ operator==() [1/2]

    constexpr BoolType operator== ( const Vec3< T2, S2 > &  v) const
    constexpr

    Equality operator.

    Parameters
    [in]vComparison vector.
    Returns
    True if this and v are equal, otherwise false.

    ◆ operator==() [2/2]

    constexpr BoolType operator== ( const Vec3< T, STRIDE > &  v) const
    constexpr

    Equality operator. We repeat the function template as non-template function, this allows the usage in contexts where the parameter is not a vector itself, but something with a conversion operator to a vector

    Parameters
    [in]vComparison vector.
    Returns
    True if this and v are equal, otherwise false.

    ◆ operator!=() [1/2]

    constexpr BoolType operator!= ( const Vec3< T2, S2 > &  v) const
    constexpr

    Inequality operator.

    Parameters
    [in]vComparison vector.
    Returns
    False if this and v are equal, otherwise true.

    ◆ operator!=() [2/2]

    constexpr BoolType operator!= ( const Vec3< T, STRIDE > &  v) const
    constexpr

    Inequality operator. We repeat the function template as non-template function, this allows the usage in contexts where the parameter is not a vector itself, but something with a conversion operator to a vector

    Parameters
    [in]vComparison vector.
    Returns
    False if this and v are equal, otherwise true.

    ◆ operator<=()

    constexpr BoolType operator<= ( const Vec3< T, STRIDE > &  v) const
    constexpr

    Compares this vector with v. Note that this doesn't define a total order but just a partial order, so for a pair of vectors it can happen that neither {v <= w} nor {v >= w}.

    Parameters
    [in]vComparison vector.
    Returns
    True if this.c <= v.c for all components c of the vectors, false otherwise.

    ◆ operator>=()

    constexpr BoolType operator>= ( const Vec3< T, STRIDE > &  v) const
    constexpr

    Compares this vector with v. Note that this doesn't define a total order but just a partial order, so for a pair of vectors it can happen that neither {v <= w} nor {v >= w}.

    Parameters
    [in]vComparison vector.
    Returns
    True if this.c >= v.c for all components c of the vectors, false otherwise.

    ◆ operator<()

    constexpr BoolType operator< ( const Vec3< T, STRIDE > &  v) const
    constexpr

    Compares this vector with v. Note that this doesn't define a total order but just a partial order, so for a pair of vectors it can happen that neither {v < w} nor {v > w} nor {v == w}. Also note that {v < w} is not the same as {v <= w && v != w}.

    Parameters
    [in]vComparison vector.
    Returns
    True if this.c < v.c for all components c of the vectors, false otherwise.

    ◆ operator>()

    constexpr BoolType operator> ( const Vec3< T, STRIDE > &  v) const
    constexpr

    Compares this vector with v. Note that this doesn't define a total order but just a partial order, so for a pair of vectors it can happen that neither {v < w} nor {v > w} nor {v == w}. Also note that {v > w} is not the same as {v >= w && v != w}.

    Parameters
    [in]vComparison vector.
    Returns
    True if this.c > v.c for all components c of the vectors, false otherwise.

    ◆ GetHashCode()

    constexpr HashInt GetHashCode ( ) const
    constexpr

    Returns the hash code of the vector (used for hash maps and comparisons).

    Returns
    The vector's hash code.

    ◆ GetUniqueHashCode()

    UniqueHash GetUniqueHashCode ( ) const

    ◆ IsEqual()

    BoolType IsEqual ( const Vec3< T, STRIDE > &  other,
    ValueTypeParam  epsilon 
    ) const

    Tests component-wise if the difference is no bigger than 'epsilon'.

    ◆ IsZero() [1/2]

    constexpr BoolType IsZero ( ) const
    constexpr

    Checks if each component is zero.

    ◆ IsZero() [2/2]

    BoolType IsZero ( ValueTypeParam  epsilon) const

    Checks if each component is smaller that epsilon

    Parameters
    [in]epsilonepsilon value
    Returns
    False if one or more component are bigger than epsilon, otherwise true.

    ◆ SetZero()

    void SetZero ( )

    Sets all components to zero.

    ◆ GetAverage()

    constexpr T GetAverage ( ) const
    constexpr

    Calculates the average value of 'x', 'y' and 'z'.

    ◆ GetSum()

    constexpr T GetSum ( ) const
    constexpr

    Calculates the sum of 'x', 'y' and 'z'.

    ◆ ClampMin()

    void ClampMin ( const Vec3< T, STRIDE > &  other = Vec3< T, STRIDE >())

    Set the minimum of each component.

    ◆ ClampMax()

    void ClampMax ( const Vec3< T, STRIDE > &  other)

    Set the maximum of each component.

    ◆ Clamp01()

    constexpr Unstrided Clamp01 ( ) const
    constexpr

    Returns a vector that is clamped to the range [0.0 .. 1.0].

    ◆ GetLength()

    T GetLength ( ) const

    Returns the length of the vector.

    ◆ GetSquaredLength()

    constexpr T GetSquaredLength ( ) const
    constexpr

    Returns the squared length of the vector.

    ◆ GetNormalized()

    Unstrided GetNormalized ( ) const

    Returns a normalized vector, so that GetLength(vector)==1.0.

    ◆ operator!()

    Unstrided operator! ( ) const

    Returns a normalized vector, so that GetLength(vector)==1.0.

    ◆ Normalize()

    void Normalize ( )

    Normalizes this vector, so that GetLength()==1.0.

    ◆ ToString()

    String ToString ( const FormatStatement formatStatement = nullptr) const

    Returns a readable string of the content.

    Parameters
    [in]formatStatementNullptr or additional formatting instruction. See also Formatting Floating point values.
    Returns
    The converted result.

    ◆ GetColor() [1/2]

    constexpr const Col3<T, STRIDE>& GetColor ( ) const
    constexpr

    Reinterprets the vector as color.

    ◆ GetColor() [2/2]

    Col3<T, STRIDE>& GetColor ( )

    ◆ GetMin()

    constexpr T GetMin ( ) const
    constexpr

    Returns the minimum of 'x', 'y' and 'z'.

    ◆ GetMax()

    constexpr T GetMax ( ) const
    constexpr

    Returns the maximum of 'x', 'y' and 'z'.

    ◆ GetRightRotated()

    constexpr Unstrided GetRightRotated ( Int  rots) const
    constexpr

    Returns a vector where the components have been rotated to the right (in the usual (x, y, z)-representation). E.g., with a value of 1 for rots, the result will be (z, x, y).

    Parameters
    [in]rotsNumber of rotations, may be negative. The result depends only on the number modulo 3.
    Returns
    Vector with rotated components.

    ◆ operator*=() [4/4]

    Vec3& operator*= ( const Mat3< T2 > &  m)

    Transforms point by a matrix.

    ◆ DefaultValue()

    static MAXON_ATTRIBUTE_FORCE_INLINE const Vec3& DefaultValue ( )
    static

    Returns a default value of the vector (see defaultvalue.h for more details).

    Returns
    A default value of the vector.

    Friends And Related Function Documentation

    ◆ operator*

    constexpr friend Unstrided operator* ( ValueTypeParam  s,
    const Vec3< T, STRIDE > &  v 
    )
    friend

    Multiplies each vector component by a scalar.

    ◆ Dot [1/2]

    constexpr friend T Dot ( const Vec3< T, STRIDE > &  v1,
    const Vec3< T, STRIDE > &  v2 
    )
    friend

    Calculates dot product of v1 and v2.

    ◆ Abs

    Unstrided Abs ( const Vec3< T, STRIDE > &  v1)
    friend

    returns the vector with absolute value for each entry

    Parameters
    [in]v1input vector to work on
    Returns
    component wise absolute value vector of input vector

    ◆ Dot [2/2]

    constexpr friend MultiplicativePromotion<T, T2>::type Dot ( const Vec3< T, STRIDE > &  v1,
    const Vec3< T2, S2 > &  v2 
    )
    friend

    Calculates dot product of v1 and v2.

    ◆ Min

    constexpr friend Unstrided Min ( const Vec3< T, STRIDE > &  a,
    const Vec3< T, STRIDE > &  other 
    )
    friend

    Calculates the minimum of each component.

    ◆ Max

    constexpr friend Unstrided Max ( const Vec3< T, STRIDE > &  a,
    const Vec3< T, STRIDE > &  other 
    )
    friend

    Calculates the maximum of each component.

    ◆ SetMin

    void SetMin ( Vec3< T, STRIDE > &  a,
    const Vec3< T, STRIDE > &  other 
    )
    friend

    Set the minimum of each component.

    ◆ SetMax

    void SetMax ( Vec3< T, STRIDE > &  a,
    const Vec3< T, STRIDE > &  other 
    )
    friend

    Set the maximum of each component.

    ◆ GetAngle

    T GetAngle ( const Vec3< T, STRIDE > &  v1,
    const Vec3< T, STRIDE > &  v2 
    )
    friend

    Calculates angle (in radians) between v1 and v2.

    ◆ Cross [1/2]

    constexpr friend Unstrided Cross ( const Vec3< T, STRIDE > &  v1,
    const Vec3< T, STRIDE > &  v2 
    )
    friend

    Calculates cross product of v1 and v2.

    ◆ Cross [2/2]

    constexpr friend Vec3<typename MultiplicativePromotion<T, T2>::type, 1> Cross ( const Vec3< T, STRIDE > &  v1,
    const Vec3< T2, S2 > &  v2 
    )
    friend

    Calculates cross product of v1 and v2.

    Member Data Documentation

    ◆ x

    T x

    ◆ _xpadding

    T _xpadding[STRIDE]

    ◆ 

    union { ... }

    ◆ y

    T y

    ◆ _ypadding

    T _ypadding[STRIDE]

    ◆ 

    union { ... }

    ◆ z

    T z

    ◆ _zpadding

    T _zpadding[STRIDE]

    ◆ 

    union { ... }