Open Search
    Vec4< T, STRIDE > Struct Template Reference

    #include <vec4.h>

    Detailed Description

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

    A vector consisting of four components X, Y, Z and W.

    Public Types

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

    Public Member Functions

    constexpr Vec4 ()
     
    constexpr Vec4 (ValueTypeParam in)
     
    constexpr Vec4 (ValueTypeParam ix, ValueTypeParam iy, ValueTypeParam iz, ValueTypeParam iw)
     
    template<typename T2 , Int S2>
    constexpr Vec4 (const Vec4< T2, S2 > &v)
     
    template<typename T2 , Int S2>
    constexpr Vec4 (const Col4< T2, S2 > &v)
     
    template<Int S2>
    constexpr Vec4 (const Vec4< T, S2 > &v)
     
    template<typename T2 , Int S2>
    constexpr Vec4 (const Vec3< T2, S2 > &v, T iw=T(1))
     
    constexpr Vec4 (ENUM_DONT_INITIALIZE v)
     
    constexpr const Col4< T, STRIDE > & GetColor () const
     
    Col4< T, STRIDE > & GetColor ()
     
    constexpr const Vec3< T, STRIDE > & GetVector3 () const
     
    Vec3< T, STRIDE > & GetVector3 ()
     
    constexpr MAXON_IMPLICIT Vec4 (const typename std::conditional< STRIDE==1, DummyParamType, Vec4 >::type &src)
     
    Vec4operator= (const typename std::conditional< STRIDE==1, DummyParamType, Vec4 >::type &src)
     
    T & operator[] (Int l)
     
    ValueTypeParam operator[] (Int l) const
     
    template<typename T2 , Int S2>
    Vec4operator+= (const Vec4< T2, S2 > &v)
     
    Vec4operator+= (const Vec4 &v)
     
    template<typename T2 , Int S2>
    Vec4operator-= (const Vec4< T2, S2 > &v)
     
    Vec4operator-= (const Vec4 &v)
     
    template<typename T2 , Int S2>
    Vec4operator*= (const Vec4< T2, S2 > &v)
     
    Vec4operator*= (const Vec4 &v)
     
    Vec4operator*= (ValueTypeParam s)
     
    Vec4operator/= (ValueTypeParam s)
     
    constexpr Unstrided operator* (ValueTypeParam s) const
     
    template<typename S >
    constexpr Vec4< 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 Vec4 &v) const
     
    constexpr Unstrided operator+ (const Vec4 &v) const
     
    constexpr Unstrided operator- (const Vec4 &v) const
     
    constexpr Unstrided operator- () const
     
    template<typename T2 , Int S2>
    constexpr BoolType operator== (const Vec4< T2, S2 > &v) const
     
    constexpr BoolType operator== (const Vec4 &v) const
     
    template<typename T2 , Int S2>
    constexpr BoolType operator!= (const Vec4< T2, S2 > &v) const
     
    constexpr BoolType operator!= (const Vec4 &v) const
     
    constexpr BoolType operator<= (const Vec4 &v) const
     
    constexpr BoolType operator>= (const Vec4 &v) const
     
    constexpr BoolType operator< (const Vec4 &v) const
     
    constexpr BoolType operator> (const Vec4 &v) const
     
    constexpr HashInt GetHashCode () const
     
    UniqueHash GetUniqueHashCode () const
     
    BoolType IsEqual (const Vec4 &other, ValueTypeParam epsilon) const
     
    constexpr BoolType IsZero () const
     
    void SetZero ()
     
    constexpr T GetAverage () const
     
    constexpr T GetSum () const
     
    void ClampMin (const Vec4 &other=Vec4())
     
    void ClampMax (const Vec4 &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 T GetMin () const
     
    constexpr T GetMax () const
     
    constexpr Vec4 GetRightRotated (Int rots) const
     
    void NormalizeW ()
     
    template<typename V >
    Vec4operator*= (const SqrMat4< V > &m)
     

    Static Public Member Functions

    static MAXON_ATTRIBUTE_FORCE_INLINE const Vec4DefaultValue ()
     

    Public Attributes

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

    Friends

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

    Member Typedef Documentation

    ◆ Rebind

    using Rebind = Vec4<U, STRIDE>

    ◆ VectorStrideType

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

    ◆ ValueType

    using ValueType = T

    ◆ ValueTypeParam

    using ValueTypeParam = typename ByValueParam<T>::type

    ◆ Unstrided

    using Unstrided = Vec4<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

    ◆ Vec4() [1/9]

    constexpr Vec4 ( )
    constexpr

    Initializes all vector components with 0.0.

    ◆ Vec4() [2/9]

    constexpr Vec4 ( ValueTypeParam  in)
    explicitconstexpr

    Initializes all vector components with a scalar.

    ◆ Vec4() [3/9]

    constexpr Vec4 ( ValueTypeParam  ix,
    ValueTypeParam  iy,
    ValueTypeParam  iz,
    ValueTypeParam  iw 
    )
    explicitconstexpr

    Initializes all vector components individually.

    ◆ Vec4() [4/9]

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

    Initializes components from another 4d vector.

    ◆ Vec4() [5/9]

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

    Initializes components from another 4d vector.

    ◆ Vec4() [6/9]

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

    Initializes components from another 4d vector.

    ◆ Vec4() [7/9]

    constexpr Vec4 ( const Vec3< T2, S2 > &  v,
    iw = T(1) 
    )
    explicitconstexpr

    Initializes components from a 3d vector and add an additional value for the w-component. The default value for w is 1.0.

    ◆ Vec4() [8/9]

    constexpr Vec4 ( ENUM_DONT_INITIALIZE  v)
    explicitconstexpr

    Skips initialization of vector (for better speed)

    ◆ Vec4() [9/9]

    constexpr MAXON_IMPLICIT Vec4 ( const typename std::conditional< STRIDE==1, DummyParamType, Vec4< 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

    ◆ GetColor() [1/2]

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

    Reinterprets the vector as color.

    ◆ GetColor() [2/2]

    Col4<T, STRIDE>& GetColor ( )

    Reinterprets the vector as color.

    ◆ GetVector3() [1/2]

    constexpr const Vec3<T, STRIDE>& GetVector3 ( ) const
    constexpr

    Gets the x/y/z components without w.

    ◆ GetVector3() [2/2]

    Vec3<T, STRIDE>& GetVector3 ( )

    Gets the writable x/y/z components without w.

    ◆ operator=()

    Vec4& operator= ( const typename std::conditional< STRIDE==1, DummyParamType, Vec4< 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]

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

    Adds two vectors.

    ◆ operator+=() [2/2]

    Vec4& operator+= ( const Vec4< 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]

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

    Subtracts two vectors.

    ◆ operator-=() [2/2]

    Vec4& operator-= ( const Vec4< 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]

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

    Multiplies two vectors component-wise.

    ◆ operator*=() [2/4]

    Vec4& operator*= ( const Vec4< 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]

    Vec4& operator*= ( ValueTypeParam  s)

    Multiplies each vector component by a scalar.

    ◆ operator/=()

    Vec4& 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 Vec4<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 Vec4< T, STRIDE > &  v) const
    constexpr

    Multiplies two vectors component-wise.

    ◆ operator+()

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

    Adds two vectors.

    ◆ operator-() [1/2]

    constexpr Unstrided operator- ( const Vec4< 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 Vec4< 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 Vec4< 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 Vec4< 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 Vec4< 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 Vec4< 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 Vec4< 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 Vec4< 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 Vec4< 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 Vec4< T, STRIDE > &  other,
    ValueTypeParam  epsilon 
    ) const

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

    ◆ IsZero()

    constexpr BoolType IsZero ( ) const
    constexpr

    Checks if each component is zero.

    ◆ SetZero()

    void SetZero ( )

    Sets all components to zero.

    ◆ GetAverage()

    constexpr T GetAverage ( ) const
    constexpr

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

    ◆ GetSum()

    constexpr T GetSum ( ) const
    constexpr

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

    ◆ ClampMin()

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

    Set the minimum of each component.

    ◆ ClampMax()

    void ClampMax ( const Vec4< 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.

    ◆ GetMin()

    constexpr T GetMin ( ) const
    constexpr

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

    ◆ GetMax()

    constexpr T GetMax ( ) const
    constexpr

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

    ◆ GetRightRotated()

    constexpr Vec4 GetRightRotated ( Int  rots) const
    constexpr

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

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

    ◆ NormalizeW()

    void NormalizeW ( )

    Scales this vector such that w equals 1.

    ◆ operator*=() [4/4]

    Vec4& operator*= ( const SqrMat4< V > &  m)

    Multiplies vector by a matrix.

    ◆ DefaultValue()

    static MAXON_ATTRIBUTE_FORCE_INLINE const Vec4& 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 Vec4< T, STRIDE > &  v 
    )
    friend

    Multiplies each vector component by a scalar.

    ◆ Dot [1/2]

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

    Calculates dot product of v1 and v2.

    ◆ Abs

    Unstrided Abs ( const Vec4< 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 Vec4< T, STRIDE > &  v1,
    const Vec4< T2, S2 > &  v2 
    )
    friend

    Calculates dot product of v1 and v2.

    ◆ Min

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

    Calculates the minimum of each component.

    ◆ Max

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

    Calculates the maximum of each component.

    ◆ SetMin

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

    Set the minimum of each component.

    ◆ SetMax

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

    Set the maximum of each component.

    ◆ GetAngle

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

    Calculates angle (in radians) between 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 { ... }

    ◆ w

    T w

    ◆ _wpadding

    T _wpadding[STRIDE]

    ◆ 

    union { ... }