UT_Vector4.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        Utility Library (C++)
 *
 * COMMENTS:
 *      This class handles fpreal vectors of dimension 4.
 *
 * WARNING:
 *      This class should NOT contain any virtual methods, nor should it
 *      define more member data. The size of UT_Vector4 must always be 
 *      16 bytes (4 floats).
 *
 */

#pragma once

#ifndef __UT_Vector4_h__
#define __UT_Vector4_h__

#include "UT_API.h"
#include "UT_Assert.h"
#include "UT_FixedVector.h"
#include "UT_FixedVectorTraits.h"
#include "UT_Storage.h"
#include "UT_FixedArrayMath.h"
#include "UT_VectorTypes.h"
#include <SYS/SYS_Deprecated.h>
#include <SYS/SYS_Inline.h>
#include <SYS/SYS_Math.h>
#include <iosfwd>
#include <limits>

#ifndef UT_DISABLE_VECTORIZE_MATRIX
#include <VM/VM_SIMD.h>
#endif

class UT_IStream;
class UT_JSONWriter;
class UT_JSONValue;
class UT_JSONParser;

// Free floating functions:

// Right-multiply operators (M*v) have been removed. They had previously
// been defined to return v*M, which was too counterintuitive. Once HDK
// etc. users have a chance to update their code (post 7.0) we could
// reintroduce a right-multiply operator that does a colVecMult.

template <typename T, typename S>
inline UT_Vector4T<T>   operator*(const UT_Vector4T<T> &v, const UT_Matrix4T<S> &m);
template <typename T>
constexpr UT_Vector4T<T>        operator+(const UT_Vector4T<T> &v1, const UT_Vector4T<T> &v2) noexcept;
template <typename T>
constexpr UT_Vector4T<T>        operator-(const UT_Vector4T<T> &v1, const UT_Vector4T<T> &v2) noexcept;
template <typename T, typename S>
inline UT_Vector4T<T>   operator+(const UT_Vector4T<T> &v, S scalar);
template <typename T, typename S>
inline UT_Vector4T<T>   operator-(const UT_Vector4T<T> &v, S scalar);
template <typename T, typename S>
inline UT_Vector4T<T>   operator*(const UT_Vector4T<T> &v, S scalar);
template <typename T, typename S>
inline UT_Vector4T<T>   operator/(const UT_Vector4T<T> &v, S scalar);
template <typename T, typename S>
inline UT_Vector4T<T>   operator+(S scalar, const UT_Vector4T<T> &v);
template <typename T, typename S>
inline UT_Vector4T<T>   operator-(S scalar, const UT_Vector4T<T> &v);
template <typename T, typename S>
constexpr UT_Vector4T<T>        operator*(S scalar, const UT_Vector4T<T> &v) noexcept;
template <typename T, typename S>
inline UT_Vector4T<T>   operator/(S scalar, const UT_Vector4T<T> &v);

/// Although the cross product is undefined for 4D vectors, we believe it's
/// useful in practice to define a function that takes two 4D vectors and
/// computes the cross-product of their first 3 components
template <typename T>
UT_API UT_Vector3T<T>   cross(const UT_Vector4T<T> &v1, const UT_Vector4T<T> &v2);
template <typename T>
UT_API UT_Vector3T<T>   cross(const UT_Vector3T<T> &v1, const UT_Vector4T<T> &v2);
template <typename T>
UT_API UT_Vector3T<T>   cross(const UT_Vector4T<T> &v1, const UT_Vector3T<T> &v2);

/// The dot product between two vectors
// @{
template <typename T>
inline T                dot(const UT_Vector4T<T> &v1, const UT_Vector3T<T> &v2);
template <typename T>
inline T                dot(const UT_Vector3T<T> &v1, const UT_Vector4T<T> &v2);
// @}

/// Componentwise min and maximum
template <typename T>
inline UT_Vector4T<T>   SYSmin  (const UT_Vector4T<T> &v1, const UT_Vector4T<T> &v2);
template <typename T>
inline UT_Vector4T<T>   SYSmax  (const UT_Vector4T<T> &v1, const UT_Vector4T<T> &v2);

/// Componentwise integer test
template <typename T>
inline bool SYSisInteger(const UT_Vector4T<T> &v1) 
{ return SYSisInteger(v1.x()) && SYSisInteger(v1.y()) && SYSisInteger(v1.z()) && SYSisInteger(v1.w()); }

/// Componentwise linear interpolation
template <typename T,typename S>
inline UT_Vector4T<T> SYSlerp(const UT_Vector4T<T> &v1, const UT_Vector4T<T> &v2, S t);

template <typename T>
inline UT_Vector4T<T> SYSinvlerp(const UT_Vector4T<T> &a, const UT_Vector4T<T> &v1, const UT_Vector4T<T> &v2);

/// Bilinear interpolation
template <typename T,typename S>
inline UT_Vector4T<T> SYSbilerp(const UT_Vector4T<T> &u0v0, const UT_Vector4T<T> &u1v0,
                                  const UT_Vector4T<T> &u0v1, const UT_Vector4T<T> &u1v1,
                                  S u, S v)
{ return SYSlerp(SYSlerp(u0v0, u0v1, v), SYSlerp(u1v0, u1v1, v), u); }

/// Barycentric interpolation
template <typename T, typename S>
inline UT_Vector4T<T> SYSbarycentric(const UT_Vector4T<T> &v0,
        const UT_Vector4T<T> &v1, const UT_Vector4T<T> &v2, S u, S v)
{ return v0 * (1 - u - v) + v1 * u + v2 *v; }


/// Multiplication of a row or column vector by a matrix (ie. right vs. left
/// multiplication respectively). The operator*() declared above is an alias 
/// for rowVecMult().
// @{
//
// Notes on optimisation of matrix/vector multiplies:
// - multiply(dest, mat) functions have been deprecated in favour of
// rowVecMult/colVecMult routines, which produce temporaries. For these to
// offer comparable performance, the compiler has to optimize away the
// temporary, but most modern compilers can do this. Performance tests with
// gcc3.3 indicate that this is a realistic expectation for modern
// compilers.
// - since matrix/vector multiplies cannot be done without temporary data,
// the "primary" functions are the global matrix/vector
// rowVecMult/colVecMult routines, rather than the member functions.
// - inlining is explicitly requested only for functions involving the
// native types (UT_Vector4 and UT_Matrix4)
template <typename T, typename S>
UT_API UT_Vector4T<T>   rowVecMult(const UT_Vector4T<T> &v, const UT_Matrix4T<S> &m);
template <typename T, typename S>
UT_API UT_Vector4T<T>   colVecMult(const UT_Matrix4T<S> &m, const UT_Vector4T<T> &v);

template <typename T, typename S>
UT_API UT_Vector4T<T>   rowVecMult3(const UT_Vector4T<T> &v, const UT_Matrix4T<S> &m);
template <typename T, typename S>
UT_API UT_Vector4T<T>   colVecMult3(const UT_Matrix4T<S> &m, const UT_Vector4T<T> &v);
// @}

/// Compute the distance between two points
// @{
template <typename T>
inline T                distance4(const UT_Vector4T<T> &p1, const UT_Vector4T<T> &p2);
template <typename T>
inline T                distance3(const UT_Vector4T<T> &p1, const UT_Vector4T<T> &p2);
template <typename T>
inline T                distance3d(const UT_Vector4T<T> &p1, const UT_Vector4T<T> &p2)
{ return distance3(p1, p2); }
template <typename T>
inline T                distance3d(const UT_Vector3T<T> &p1, const UT_Vector4T<T> &p2)
{ return distance3d(p1, UT_Vector3T<T>(p2)); }
template <typename T>
inline T                distance3d(const UT_Vector4T<T> &p1, const UT_Vector3T<T> &p2)
{ return distance3d(UT_Vector3T<T>(p1), p2); }
// @}

/// 4D Vector class.
template <typename T>
class UT_API UT_Vector4T
{
public:
    typedef T value_type;
    static constexpr int tuple_size = 4;

    /// Default constructor.
    /// No data is initialized! Use it for extra speed.
    constexpr SYS_FORCE_INLINE UT_Vector4T() = default;

    constexpr SYS_FORCE_INLINE UT_Vector4T(const UT_Vector4T<T> &that) = default;
    constexpr SYS_FORCE_INLINE UT_Vector4T(UT_Vector4T<T> &&that) = default;

    constexpr SYS_FORCE_INLINE UT_Vector4T(const T vx, const T vy, const T vz, const T vw = 1.0f) :
        vec{ vx, vy, vz, vw }
    {}

    constexpr SYS_FORCE_INLINE UT_Vector4T(const fpreal32 v[]) noexcept :
        UT_Vector4T( v[0], v[1], v[2], v[3] )
    {}
    constexpr SYS_FORCE_INLINE UT_Vector4T(const fpreal64 v[]) noexcept :
        UT_Vector4T( v[0], v[1], v[2], v[3] )
    {}
    constexpr SYS_FORCE_INLINE UT_Vector4T(const int32 v[]) noexcept :
        UT_Vector4T( v[0], v[1], v[2], v[3] )
    {}
    constexpr SYS_FORCE_INLINE UT_Vector4T(const int64 v[]) noexcept :
        UT_Vector4T( v[0], v[1], v[2], v[3] )
    {}
    
    // Initialises the vector as [x,y,0,1]
    SYS_FORCE_INLINE
    constexpr explicit UT_Vector4T(const UT_Vector2T<T> &v) noexcept;
    
    constexpr explicit UT_Vector4T(const UT_Vector3T<T> &v, T w = 1.f) noexcept;

    /// Our own type of any given value_type.
    template <typename S>
    constexpr SYS_FORCE_INLINE UT_Vector4T(const UT_Vector4T<S>& v) noexcept :
        UT_Vector4T( v[0], v[1], v[2], v[3] )
    {}
    
    /// UT_FixedVector of the same size
    constexpr explicit SYS_FORCE_INLINE UT_Vector4T(const UT_FixedVector<T,tuple_size>& v) noexcept :
        UT_Vector4T( v[0], v[1], v[2], v[3] )
    {}

    SYS_FORCE_INLINE UT_Vector4T<T> &operator=(const UT_Vector4T<T> &that) = default;
    SYS_FORCE_INLINE UT_Vector4T<T> &operator=(UT_Vector4T<T> &&that) = default;

    template <typename S>
    SYS_FORCE_INLINE UT_Vector4T<T> &operator=(const UT_Vector4T<S> &v)
    { vec[0] = v[0]; vec[1] = v[1]; vec[2] = v[2]; vec[3] = v[3];
      return *this; }

    constexpr SYS_FORCE_INLINE const T* data() const noexcept
    {
        return vec;
    }

    constexpr SYS_FORCE_INLINE T* data() noexcept
    {
        return vec;
    }
    
    constexpr SYS_FORCE_INLINE const T& operator[]( exint i ) const noexcept
    {
        UT_ASSERT_P( ( 0 <= i ) && ( i < tuple_size ) );

        return vec[ i ];
    }
    
    constexpr SYS_FORCE_INLINE T& operator[]( exint i ) noexcept
    {
        UT_ASSERT_P( ( 0 <= i ) && ( i < tuple_size ) );

        return vec[ i ];
    }
  
    constexpr SYS_FORCE_INLINE UT_Vector4T& operator+=( const UT_Vector4T& a ) noexcept
    {
        UT::FA::Add< T, tuple_size >{}( vec, a.vec );
        return *this;
    }

    constexpr SYS_FORCE_INLINE UT_Vector4T& operator-=( const UT_Vector4T& a ) noexcept
    {
        UT::FA::Subtract< T, tuple_size >{}( vec, a.vec );
        return *this;
    }

    constexpr SYS_FORCE_INLINE UT_Vector4T& operator*=( const T& a ) noexcept
    {
        UT::FA::Scale< T, tuple_size >{}( vec, a );
        return *this;
    }
    
    constexpr SYS_FORCE_INLINE UT_Vector4T& operator/=( const T& a ) noexcept
    {
        using MF = UT_StorageMathFloat_t< T >;
        UT::FA::Scale< T, tuple_size, MF >{}( vec, MF{1} / a );
        return *this;
    }

    constexpr SYS_FORCE_INLINE UT_Vector4T& operator*=( const UT_Vector4T& a ) noexcept
    {
        UT::FA::ScaleComponentwise< T, tuple_size >{}( vec, a.vec );
        return *this;
    }

    constexpr SYS_FORCE_INLINE void negate() noexcept
    {
        UT::FA::Negate< T, tuple_size >{}( vec );
    }
    
    constexpr SYS_FORCE_INLINE T length2() const noexcept
    {
        return UT::FA::Length2< T, tuple_size >{}( vec );
    }

    constexpr SYS_FORCE_INLINE T length() const noexcept
    {
        return SYSsqrt( length2() );
    }

    constexpr SYS_FORCE_INLINE T distance2( const UT_Vector4T& b ) const noexcept
    {
        return UT::FA::Distance2< T, tuple_size >{}( vec, b.vec );
    }

    constexpr SYS_FORCE_INLINE T distance( const UT_Vector4T& b ) const noexcept
    {
        return SYSsqrt( distance2( b ) );
    }

    SYS_FORCE_INLINE UT_StorageMathFloat_t< T > normalize() noexcept
    {
        using MF = UT_StorageMathFloat_t< T >;
        using U = UT_StorageAtLeast32Bit_t<T,T>;
        return UT::FA::Normalize< T, tuple_size, MF, U >{}( vec, std::numeric_limits< MF >::min() );
    }

    constexpr SYS_FORCE_INLINE bool isZero() const noexcept
    {
        return UT::FA::IsUniformZero< T, tuple_size >{}( vec );
    }

    constexpr SYS_FORCE_INLINE UT_Vector4T& operator=( const T a ) noexcept;

    // TODO: We could remove this. It's not as error-prone as some other
    // conversions, but it might still be better to force the user to do
    // an explicit cast i.e., v4 = UT_Vector4(v3)

    /// Assignment operator that creates a V4 from a V3 by adding a '1' 
    /// element.
    SYS_DEPRECATED_HDK_REPLACE(16.0,explicit UT_Vector4 constructor to avoid implicit conversion from UT_Vector3)
    UT_Vector4T<T>      &operator=(const UT_Vector3T<T> &v);

    int          equalZero3(T tol = 0.00001f) const
                 {
                    return (vec[0] >= -tol && vec[0] <= tol) &&
                           (vec[1] >= -tol && vec[1] <= tol) &&
                           (vec[2] >= -tol && vec[2] <= tol);
                 }

    void         clampZero(T tol = 0.00001f) 
                 {
                    if (vec[0] >= -tol && vec[0] <= tol) vec[0] = 0;
                    if (vec[1] >= -tol && vec[1] <= tol) vec[1] = 0;
                    if (vec[2] >= -tol && vec[2] <= tol) vec[2] = 0;
                    if (vec[3] >= -tol && vec[3] <= tol) vec[3] = 0;
                 }

    void         clampZero3(T tol = 0.00001f) 
                 {
                    if (vec[0] >= -tol && vec[0] <= tol) vec[0] = 0;
                    if (vec[1] >= -tol && vec[1] <= tol) vec[1] = 0;
                    if (vec[2] >= -tol && vec[2] <= tol) vec[2] = 0;
                 }

    void         negate3()
                 { vec[0]= -vec[0]; vec[1]= -vec[1]; vec[2]= -vec[2]; }

    void         multiplyComponents(const UT_Vector4T<T> &v)
                 {
                     vec[0] *= v.vec[0];
                     vec[1] *= v.vec[1];
                     vec[2] *= v.vec[2];
                     vec[3] *= v.vec[3];
                 }

    constexpr SYS_FORCE_INLINE bool isFinite() const noexcept
    {
        return UT::FA::AllOf< T, tuple_size >{}( vec, [ & ]( const T& a ) { return SYSisFinite( a ); } );
    }
    
    constexpr SYS_FORCE_INLINE bool equalZero( const T tolerance = SYS_FTOLERANCE ) const noexcept
    {
        return UT::FA::MaxNormIsLEQ< T, tuple_size >{}( vec, tolerance );
    }
    
    constexpr SYS_FORCE_INLINE bool isEqual( const UT_Vector4T& b, const T tolerance = SYS_FTOLERANCE ) const noexcept
    {
        return UT::FA::MaxMetricIsLEQ< T, tuple_size >{}( vec, b.vec, tolerance );
    }
    
    constexpr SYS_FORCE_INLINE T maxComponent() const noexcept
    {
        return UT::FA::Max< T, tuple_size >{}( vec );
    }
    
    constexpr SYS_FORCE_INLINE T minComponent() const noexcept
    {
        return UT::FA::Min< T, tuple_size >{}( vec );
    }
    
    constexpr SYS_FORCE_INLINE T avgComponent() const noexcept
    {
        return UT::FA::Sum< T, tuple_size >{}( vec ) / T{ tuple_size };
    }
    
    SYS_DEPRECATED_HDK_REPLACE(16.0,explicit conversion to UT_Vector3 followed by isEqual)
    inline int           isEqual(const UT_Vector3T<T> &vect, T tol = 0.00001f) const;

    /// If you need a multiplication operator that left multiplies the vector
    /// by a matrix (M * v), use the following colVecMult() functions. If
    /// you'd rather not use operator*=() for right-multiplications (v * M),
    /// use the following rowVecMult() functions.
    // @{
    template <typename S>
    inline void  rowVecMult(const UT_Matrix4T<S> &m)
                 { operator=(::rowVecMult(*this, m)); }
    template <typename S>
    inline void  colVecMult(const UT_Matrix4T<S> &m)
                 { operator=(::colVecMult(m, *this)); }
    // @}

    /// This multiply will ignore the 4th component both in the vector an in
    /// the matrix. This helps when you want to avoid affecting the 'w'
    /// component. This in turns annihilates the translation components (row 4)
    /// in mat, so be careful.
    // @{
    template <typename S>
    void          rowVecMult3(const UT_Matrix4T<S> &m)
                  { operator=(::rowVecMult3(*this, m)); }
    // @}

    // The *= and multiply3 routines are provided for
    // legacy reasons. They all assume that *this is a row vector. Generally,
    // the rowVecMult and colVecMult methods are preferred, since they're
    // more explicit about the row vector assumption.
    // @{
    template <typename S>
    inline
    UT_Vector4T<T>      &operator*=(const UT_Matrix4T<S> &mat)
                 { rowVecMult(mat); return *this; }

    template <typename S>
    inline void  multiply3(const UT_Matrix4T<S> &mat)
                 { rowVecMult3(mat); }
    template <typename S>
    inline void  multiply3(UT_Vector4T<T> &dest, const UT_Matrix4T<S> &mat) const
                 { dest = ::rowVecMult3(*this, mat); }
    // @}

    /// These allow you to find out what indices to use for different axes
    // @{
    int          findMinAbsAxis() const
                 {
                    if (SYSabs(x()) < SYSabs(y()))
                        if (SYSabs(z()) < SYSabs(x()))
                            if (SYSabs(w()) < SYSabs(z()))
                                return 3;
                            else
                                return 2;
                        else
                            if (SYSabs(w()) < SYSabs(x()))
                                return 3;
                            else
                                return 0;
                    else
                        if (SYSabs(z()) < SYSabs(y()))
                            if (SYSabs(w()) < SYSabs(z()))
                                return 3;
                            else
                                return 2;
                        else
                            if (SYSabs(w()) < SYSabs(y()))
                                return 3;
                            else
                                return 1;
                 }
    int          findMaxAbsAxis() const
                 {
                    if (SYSabs(x()) >= SYSabs(y()))
                        if (SYSabs(z()) >= SYSabs(x()))
                            if (SYSabs(w()) >= SYSabs(z()))
                                return 3;
                            else
                                return 2;
                        else
                            if (SYSabs(w()) >= SYSabs(x()))
                                return 3;
                            else
                                return 0;
                    else
                        if (SYSabs(z()) >= SYSabs(y()))
                            if (SYSabs(w()) >= SYSabs(z()))
                                return 3;
                            else
                                return 2;
                        else
                            if (SYSabs(w()) >= SYSabs(y()))
                                return 3;
                            else
                                return 1;
                 }
    // @}

    /// Return the components of the vector. The () operator does NOT check
    /// for the boundary condition.
    // @{
    inline T    &x()                    { return vec[0]; } 
    constexpr T  x() const noexcept             { return vec[0]; } 
    inline T    &y()                    { return vec[1]; } 
    constexpr T  y() const noexcept             { return vec[1]; } 
    inline T    &z()                    { return vec[2]; } 
    constexpr T  z() const noexcept             { return vec[2]; } 
    inline T    &w()                    { return vec[3]; } 
    constexpr T  w() const noexcept             { return vec[3]; } 
    inline T    &operator()(unsigned i)
                 {
                     UT_ASSERT_P(i < tuple_size);
                     return vec[i];
                 }
    inline T     operator()(unsigned i) const
                 {
                     UT_ASSERT_P(i < tuple_size);
                     return vec[i];
                 }
    // @}

    constexpr SYS_FORCE_INLINE T dot( const UT_Vector4T& b ) const noexcept
    {       
        return UT::FA::Dot< T, tuple_size >{}( vec, b.vec );
    }

    /// Compute a hash
    unsigned    hash() const    { return SYSvector_hash(data(), tuple_size); }

    // TODO: eliminate these methods. They're redundant, given good inline
    // constructors.
    /// Set the values of the vector components
    void         assign(T xx = 0.0f, T yy = 0.0f, T zz = 0.0f, 
                        T ww = 1.0f)
                 {
                     vec[0] = xx; vec[1] = yy; vec[2] = zz; vec[3] = ww;
                 }
    /// Set the values of the vector components
    void         assign(const T *v, int size = tuple_size)
                 {
                     vec[0] = v[0];
                     vec[1] = v[1];
                     vec[2] = v[2];
                     if (size == tuple_size) vec[3] = v[3];
                 }

    /// Express the point in homogeneous coordinates or vice-versa
    // @{
    void         homogenize()
                 {
                     vec[0] *= vec[3];
                     vec[1] *= vec[3];
                     vec[2] *= vec[3];
                 }
    void         dehomogenize()
                 {
                     if (vec[3] != 0)
                     {
                         T denom = 1.0f / vec[3];
                         vec[0] *= denom;
                         vec[1] *= denom;
                         vec[2] *= denom;
                     }
                 }
    // @}

    void        save(std::ostream &os, int binary=0) const;
    bool        load(UT_IStream &is);

    /// @{
    /// Methods to serialize to a JSON stream.  The vector is stored as an
    /// array of 4 reals.
    bool                save(UT_JSONWriter &w) const;
    bool                save(UT_JSONValue &v) const;
    bool                load(UT_JSONParser &p);
    /// @}

    /// Returns the vector size
    static int          entries()       { return tuple_size; }

    T vec[tuple_size];
    
private:
    
    friend constexpr bool isZero( const UT_Vector4T& a ) noexcept
    {
        return UT::FA::IsUniformZero< T, tuple_size >{}( a.vec );
    }

    friend constexpr T dot( const UT_Vector4T& a, const UT_Vector4T& b ) noexcept
    {
#ifndef UT_DISABLE_VECTORIZE_MATRIX
        if constexpr( SYS_IsSame_v< T, float > )
        {
            return dot4( v4uf( a.data() ), v4uf( b.data() ) );
        }
        else // constexpr
        {
            return UT::FA::Dot< T, tuple_size >{}( a.vec, b.vec );
        }
#else
        return UT::FA::Dot< T, tuple_size >{}( a.vec, b.vec );
#endif
    }

    friend constexpr T length2( const UT_Vector4T& a ) noexcept
    {
        return UT::FA::Length2< T, tuple_size >{}( a.vec );
    }

    friend constexpr T distance2( const UT_Vector4T& a, const UT_Vector4T& b ) noexcept
    {
        return UT::FA::Distance2< T, tuple_size >{}( a.vec, b.vec );
    }

    friend constexpr bool operator==( const UT_Vector4T& a, const UT_Vector4T& b ) noexcept
    {
        return UT::FA::AreEqual< T, tuple_size >{}( a.vec, b.vec );
    }

    friend constexpr bool operator!=( const UT_Vector4T& a, const UT_Vector4T& b ) noexcept
    {
        return ! UT::FA::AreEqual< T, tuple_size >{}( a.vec, b.vec );
    }

    /// Lexicographic order comparison operators
    /// @{
    friend constexpr bool operator<( const UT_Vector4T& a, const UT_Vector4T& b ) noexcept
    {
        return UT::FA::TernaryOrder< T, tuple_size >{}( a.vec, b.vec ) < 0;
    }

    friend constexpr bool operator<=( const UT_Vector4T& a, const UT_Vector4T& b ) noexcept
    {
        return UT::FA::TernaryOrder< T, tuple_size >{}( a.vec, b.vec ) <= 0;
    }

    friend constexpr bool operator>( const UT_Vector4T& a, const UT_Vector4T& b ) noexcept
    {
        return UT::FA::TernaryOrder< T, tuple_size >{}( a.vec, b.vec ) > 0;
    }

    friend constexpr bool operator>=( const UT_Vector4T& a, const UT_Vector4T& b ) noexcept
    {
        return UT::FA::TernaryOrder< T, tuple_size >{}( a.vec, b.vec ) >= 0;
    }
    /// @}
    
    /// I/O friends
    // @{
    friend std::ostream &operator<<(std::ostream &os, const UT_Vector4T<T> &v)
                        {
                            v.save(os);
                            return os;
                        }
    // @}

    /// The negate operator is not provided, because of potentially
    /// unintuitive behaviour: you very rarely actually want to negate the
    /// w component.
    UT_Vector4T<T> operator-() const
    {
        UT_ASSERT(0);
        UT_Vector4T a(*this);
        a.negate();
        return a;
    }
};

#include "UT_Vector2.h"
#include "UT_Vector3.h"

template <typename T>
constexpr UT_Vector4T<T>::UT_Vector4T(const UT_Vector2T<T> &v) noexcept
{
    vec[0] = v.x();
    vec[1] = v.y();
    vec[2] = T(0);
    vec[3] = T(1);
}
template <typename T>
constexpr UT_Vector4T<T>::UT_Vector4T(const UT_Vector3T<T> &v, T vw) noexcept
{
    vec[0] = v.x();
    vec[1] = v.y();
    vec[2] = v.z();
    vec[3] = vw;
}

template <typename T>
constexpr SYS_FORCE_INLINE UT_Vector4T< T >& UT_Vector4T< T >::operator=( const T a ) noexcept
{
    for ( int i = 0; i != tuple_size; ++i )
    {
        vec[i] = a;
    }

    return *this;
}

#ifndef UT_DISABLE_VECTORIZE_MATRIX
template <> inline void
UT_Vector4T<float>::multiplyComponents(const UT_Vector4T<float>& v)
{
    v4uf l(this->data());
    const v4uf r(v.data());
    l *= r;

    vm_store(this->data(), l.vector);
}
#endif

template <typename T>
inline int
UT_Vector4T<T>::isEqual(const UT_Vector3T<T> &vect, T tol) const
{
    return ((vec[0]>=vect.x()-tol) && (vec[0]<=vect.x()+tol) &&
            (vec[1]>=vect.y()-tol) && (vec[1]<=vect.y()+tol) &&
            (vec[2]>=vect.z()-tol) && (vec[2]<=vect.z()+tol));
}

// Free floating functions:
template <typename T>
constexpr UT_Vector4T<T>        operator+(const UT_Vector4T<T> &v1, const UT_Vector4T<T> &v2) noexcept
{
    return UT_Vector4T<T>(v1.x()+v2.x(), v1.y()+v2.y(),
                      v1.z()+v2.z(), v1.w()+v2.w());
}
template <typename T>
inline UT_Vector3T<T>   operator+(const UT_Vector4T<T> &v1, const UT_Vector3T<T> &v2)
{
    return UT_Vector3T<T>(v1.x()+v2.x(), v1.y()+v2.y(),
                      v1.z()+v2.z());
}
template <typename T>
inline UT_Vector3T<T>   operator+(const UT_Vector3T<T> &v1, const UT_Vector4T<T> &v2)
{
    return UT_Vector3T<T>(v1.x()+v2.x(), v1.y()+v2.y(),
                      v1.z()+v2.z());
}
template <typename T>
constexpr UT_Vector4T<T>        operator-(const UT_Vector4T<T> &v1, const UT_Vector4T<T> &v2) noexcept
{
    return UT_Vector4T<T>(v1.x()-v2.x(), v1.y()-v2.y(),
                      v1.z()-v2.z(), v1.w()-v2.w());
}
template <typename T>
inline UT_Vector3T<T>   operator-(const UT_Vector4T<T> &v1, const UT_Vector3T<T> &v2)
{
    return UT_Vector3T<T>(v1.x()-v2.x(), v1.y()-v2.y(),
                      v1.z()-v2.z());
}
template <typename T>
inline UT_Vector3T<T>   operator-(const UT_Vector3T<T> &v1, const UT_Vector4T<T> &v2)
{
    return UT_Vector3T<T>(v1.x()-v2.x(), v1.y()-v2.y(),
                      v1.z()-v2.z());
}
template <typename T>
inline UT_Vector4T<T>   operator*(const UT_Vector4T<T> &v1, const UT_Vector4T<T> &v2)
{
    return UT_Vector4T<T>(v1.x()*v2.x(), v1.y()*v2.y(), v1.z()*v2.z(), v1.w()*v2.w());
}

template <typename T>
inline UT_Vector4T<T>   operator/(const UT_Vector4T<T> &v1, const UT_Vector4T<T> &v2)
{
    return UT_Vector4T<T>(v1.x()/v2.x(), v1.y()/v2.y(), v1.z()/v2.z(), v1.w()/v2.w());
}
#ifndef UT_DISABLE_VECTORIZE_MATRIX
template <>
inline UT_Vector4T<float> operator*(const UT_Vector4T<float> &v1, const UT_Vector4T<float> &v2)
{
    const v4uf l(v1.data());
    const v4uf r(v2.data());
    const v4uf result = l * r;
    return UT_Vector4T<float>((float*) &result);
}
template <>
inline UT_Vector4T<float> operator/(const UT_Vector4T<float> &v1, const UT_Vector4T<float> &v2)
{
    const v4uf l(v1.data());
    const v4uf r(v2.data());
    const v4uf result = l / r;
    return UT_Vector4T<float>((float*) &result);
}
#endif

template <typename T, typename S>
inline UT_Vector4T<T>   operator+(const UT_Vector4T<T> &v, S scalar)
{
    return UT_Vector4T<T>(v.x()+scalar, v.y()+scalar, v.z()+scalar, v.w()+scalar);
}
template <typename T, typename S>
inline UT_Vector4T<T>   operator+(S scalar, const UT_Vector4T<T> &v)
{
    return UT_Vector4T<T>(v.x()+scalar, v.y()+scalar, v.z()+scalar, v.w()+scalar);
}
template <typename T, typename S>
inline UT_Vector4T<T>   operator-(const UT_Vector4T<T> &v, S scalar)
{
    return UT_Vector4T<T>(v.x()-scalar, v.y()-scalar, v.z()-scalar, v.w()-scalar);
}
template <typename T, typename S>
inline UT_Vector4T<T>   operator-(S scalar, const UT_Vector4T<T> &v)
{
    return UT_Vector4T<T>(scalar-v.x(), scalar-v.y(), scalar-v.z(), v.w()-scalar);
}
template <typename T, typename S>
inline UT_Vector4T<T>   operator*(const UT_Vector4T<T> &v, S scalar)
{
    return UT_Vector4T<T>(v.x()*scalar, v.y()*scalar, v.z()*scalar, v.w()*scalar);
}
template <typename T, typename S>
constexpr UT_Vector4T<T>        operator*(S scalar, const UT_Vector4T<T> &v) noexcept
{
    return UT_Vector4T<T>(v.x()*scalar, v.y()*scalar, v.z()*scalar, v.w()*scalar);
}
template <typename T, typename S>
inline UT_Vector4T<T>   operator/(const UT_Vector4T<T> &v, S scalar)
{
    // This has to be T because S may be int for "v = v/2" code
    // For the same reason we must cast the 1
    T           inv = ((T)1) / scalar;
    return UT_Vector4T<T>(v.x()*inv, v.y()*inv, v.z()*inv, v.w()*inv);
}
template <typename T, typename S>
inline UT_Vector4T<T>   operator/(S scalar, const UT_Vector4T<T> &v)
{
    return UT_Vector4T<T>(scalar/v.x(), scalar/v.y(), scalar/v.z(), scalar/v.w());
}

template <typename T>
inline T                dot(const UT_Vector4T<T> &v1, const UT_Vector3T<T> &v2)
{
    return v1.x()*v2.x() + v1.y()*v2.y() + v1.z()*v2.z();
}
template <typename T>
inline T                dot(const UT_Vector3T<T> &v1, const UT_Vector4T<T> &v2)
{
    return v1.x()*v2.x() + v1.y()*v2.y() + v1.z()*v2.z();
}
template <typename T>
inline
UT_Vector4T<T>  SYSabs(const UT_Vector4T<T> &v)
{
    return UT_Vector4T<T>(
            SYSabs(v.x()),
            SYSabs(v.y()),
            SYSabs(v.z()),
            SYSabs(v.w())
    );
}

template <typename T>
inline
UT_Vector4T<T>  SYSmin(const UT_Vector4T<T> &v1, const UT_Vector4T<T> &v2)
{
    return UT_Vector4T<T>(
            SYSmin(v1.x(), v2.x()),
            SYSmin(v1.y(), v2.y()),
            SYSmin(v1.z(), v2.z()),
            SYSmin(v1.w(), v2.w())
    );
}

template <typename T>
inline
UT_Vector4T<T>  SYSmax(const UT_Vector4T<T> &v1, const UT_Vector4T<T> &v2)
{
    return UT_Vector4T<T>(
            SYSmax(v1.x(), v2.x()),
            SYSmax(v1.y(), v2.y()),
            SYSmax(v1.z(), v2.z()),
            SYSmax(v1.w(), v2.w())
    );
}

template <typename T,typename S>
inline
UT_Vector4T<T> SYSlerp(const UT_Vector4T<T> &v1, const UT_Vector4T<T> &v2, S t)
{
    return UT_Vector4T<T>(
            SYSlerp(v1.x(), v2.x(), t),
            SYSlerp(v1.y(), v2.y(), t),
            SYSlerp(v1.z(), v2.z(), t),
            SYSlerp(v1.w(), v2.w(), t));
}
#ifndef UT_DISABLE_VECTORIZE_MATRIX
template <>
inline
UT_Vector4T<float> SYSlerp(const UT_Vector4T<float> &v1, const UT_Vector4T<float> &v2, float t)
{
    const v4uf l(v1.data());
    const v4uf r(v2.data());
    const v4uf result = SYSlerp(l, r, t);
    return UT_Vector4T<float>((float*) &result);
}
#endif

template <typename T>
inline
UT_Vector4T<T> SYSinvlerp(const UT_Vector4T<T> &a,
             const UT_Vector4T<T> &v1,
             const UT_Vector4T<T> &v2)
{
    return UT_Vector4T<T>(
            SYSinvlerp(a.x(), v1.x(), v2.x()),
            SYSinvlerp(a.y(), v1.y(), v2.y()),
            SYSinvlerp(a.z(), v1.z(), v2.z()),
            SYSinvlerp(a.w(), v1.w(), v2.w()));
}


template <typename T, typename S>
inline UT_Vector4T<T>   operator*(const UT_Vector4T<T> &v, const UT_Matrix4T<S> &m)
{
    return rowVecMult(v, m);
}
template <typename T>
inline T                distance(const UT_Vector4T<T> &v1, const UT_Vector4T<T> &v2)
{
    T   x = v1.x()-v2.x();
    T   y = v1.y()-v2.y();
    T   z = v1.z()-v2.z();
    T   w = v1.w()-v2.w();
    return SYSsqrt(x*x + y*y + z*z + w*w);
}
template <typename T>
inline T                distance3(const UT_Vector4T<T> &v1, const UT_Vector4T<T> &v2)
{
    T   x = v1.x()-v2.x();
    T   y = v1.y()-v2.y();
    T   z = v1.z()-v2.z();
    return SYSsqrt(x*x + y*y + z*z);
}

#ifndef UT_DISABLE_VECTORIZE_MATRIX
template <>
inline float distance(const UT_Vector4T<float> &v1, const UT_Vector4T<float> &v2)
{
    const v4uf l(v1.data());
    const v4uf r(v2.data());
    v4uf result = l - r;
    result *= result;

    return SYSsqrt(result[0] + result[1] + result[2] + result[3]);
}
template <>
inline float distance3(const UT_Vector4T<float> &v1, const UT_Vector4T<float> &v2)
{
    const v4uf l(v1.data());
    const v4uf r(v2.data());
    v4uf result = l - r;
    result *= result;

    return SYSsqrt(result[0] + result[1] + result[2]);
}
#endif

template <typename T>
inline size_t hash_value(const UT_Vector4T<T> &val)
{
    return val.hash();
}

// Overload for custom formatting of UT_Vector4T<T> with UTformat.
template<typename T>
UT_API size_t format(char *buffer, size_t buffer_size, const UT_Vector4T<T> &v);

template< typename T, exint D >
class UT_FixedVector;

template<typename T>
struct UT_FixedVectorTraits<UT_Vector4T<T> >
{
    typedef UT_FixedVector<T,4> FixedVectorType;
    typedef T DataType;
    static const exint TupleSize = 4;
    static const bool isVectorType = true;
};

// UT_Vector4T in the role of a fixed array-like type.

template< typename T >
struct SYS_IsFixedArrayNoCVRef< UT_Vector4T< T > > : SYS_TrueType {};

template< typename T >
struct SYS_FixedArrayElementNoCVRef< UT_Vector4T< T > > : SYS_TypeIdentity< T > {};

template< typename T >
struct SYS_FixedArraySizeNoCVRef< UT_Vector4T< T > > : std::integral_constant< std::size_t, 4 > {};

// UT_Vector4TFromFixed<T> is a function object that
// creates a UT_Vector4T<T> from a fixed array-like type TS,
// examples of which include T[3], UT_FixedVector<T,3> and UT_FixedArray<T,3> (AKA std::array<T,3>)
template <typename T>
struct UT_Vector4TFromFixed
{    
    template< typename TS >
    constexpr SYS_FORCE_INLINE UT_Vector4T<T> operator()(const TS& as) const noexcept
    {        
        SYS_STATIC_ASSERT( SYS_IsFixedArrayOf_v< TS, T, 4 > );

        return UT_Vector4T<T>{as[0], as[1], as[2], as[3]};
    }
};

// Convert a fixed array-like type TS into a UT_Vector4T< T >.
// This allows conversion to UT_Vector4T without fixing T.
// Instead, the element type of TS determines the type T.
template< typename TS >
constexpr UT_Vector4T< SYS_FixedArrayElement_t< TS > >
UTmakeVector4T( const TS& as ) noexcept
{
    using T = SYS_FixedArrayElement_t< TS >;

    return UT_Vector4TFromFixed< T >{}( as );
}

// UT_FromFixed<V> creates a V from a flat, fixed array-like representation

// Primary
template <typename V >
struct UT_FromFixed;

// Partial specialization for UT_Vector4T
template <typename T>
struct UT_FromFixed< UT_Vector4T<T> > : UT_Vector4TFromFixed<T> {};

// Relocation traits for UT_Vector4T are defined in UT_VectorTypes.h

#endif