UT_Vector2.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:        UT_Vector2.h (C++)
 *
 *
 * COMMENTS:
 *      This class handles fpreal vectors of dimension 2.
 *
 * WARNING:
 *      This class should NOT contain any virtual methods, nor should it
 *      define more member data. The size of UT_VectorF2 must always be 
 *      8 bytes (2 floats).
 */

#pragma once

#ifndef __UT_Vector2_h__
#define __UT_Vector2_h__

#include "UT_API.h"
#include "UT_Assert.h"
#include "UT_FixedVectorTraits.h"
#include "UT_Storage.h"
#include "UT_FixedArrayMath.h"
#include "UT_VectorTypes.h" // IWYU pragma: export
#include <SYS/SYS_Deprecated.h>
#include <SYS/SYS_Math.h>
#include <SYS/SYS_Inline.h>
#include <VM/VM_SIMD.h>
#include <iosfwd>
#include <limits>

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

// Free floating functions:

// Operators that involve a UT_Vector2 object:
template <typename T>
constexpr UT_Vector2T<T>        operator+(const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2) noexcept;
template <typename T>
constexpr UT_Vector2T<T>        operator-(const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2) noexcept;
template <typename T>
constexpr bool          operator<(const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2) noexcept;
template <typename T>
constexpr bool          operator<=(const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2) noexcept;
template <typename T>
constexpr bool          operator>(const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2) noexcept;
template <typename T>
constexpr bool          operator>=(const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2) noexcept;
template <typename T, typename S>
inline UT_Vector2T<T>   operator+(const UT_Vector2T<T> &v, S scalar);
template <typename T, typename S>
inline UT_Vector2T<T>   operator-(const UT_Vector2T<T> &v, S scalar);
template <typename T, typename S>
inline UT_Vector2T<T>   operator*(const UT_Vector2T<T> &v, S scalar);
template <typename T, typename S>
inline UT_Vector2T<T>   operator/(const UT_Vector2T<T> &v, S scalar);
template <typename T, typename S>
inline UT_Vector2T<T>   operator+(S scalar, const UT_Vector2T<T> &v);
template <typename T, typename S>
inline UT_Vector2T<T>   operator-(S scalar, const UT_Vector2T<T> &v);
template <typename T, typename S>
constexpr UT_Vector2T<T>        operator*(S scalar, const UT_Vector2T<T> &v) noexcept;
template <typename T, typename S>
inline UT_Vector2T<T>   operator/(S scalar, const UT_Vector2T<T> &v);
template <typename T, typename S>
inline UT_Vector2T<T>   operator*(const UT_Vector2T<T> &v, 
                                  const UT_Matrix2T<S> &mat);

/// The dot product
template <typename T>
constexpr auto dot( const UT_Vector2T< T >& a, const UT_Vector2T< T >& b ) noexcept;
/// Cross product, which for 2d vectors results in a fpreal.
template <typename T>
inline T                cross    (const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2);

/// Componentwise min and maximum
template <typename T>
inline UT_Vector2T<T>   SYSmin  (const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2);
template <typename T>
inline UT_Vector2T<T>   SYSmax  (const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2);
/// Componentwise equality.
template <typename T, typename S>
inline bool             SYSisEqual(const UT_Vector2T<T> &a, const UT_Vector2T<T> &b, S tol);
template <typename T>
inline bool             SYSisEqual(const UT_Vector2T<T> &a, const UT_Vector2T<T> &b)
{ return SYSisEqual(a, b, SYS_FTOLERANCE); }
/// Componentwise integer test
template <typename T>
inline bool SYSisInteger(const UT_Vector2T<T> &v1) 
{ return SYSisInteger(v1.x()) && SYSisInteger(v1.y()); }
/// Componentwise linear interpolation
template <typename T,typename S>
inline UT_Vector2T<T> SYSlerp(const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2, S t);

/// Componentwise inverse linear interpolation
template <typename T>
inline UT_Vector2T<T> SYSinvlerp(const UT_Vector2T<T> &a, const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2);

/// Bilinear interpolation
template <typename T,typename S>
inline UT_Vector2T<T> SYSbilerp(const UT_Vector2T<T> &u0v0, const UT_Vector2T<T> &u1v0,
        const UT_Vector2T<T> &u0v1, const UT_Vector2T<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_Vector2T<T> SYSbarycentric(const UT_Vector2T<T> &v0,
        const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2, S u, S v)
{ return v0 * (1 - u - v) + v1 * u + v2 *v; }

/// The orthogonal projection of a vector u onto a vector v
template <typename T>
inline UT_Vector2T<T>   project  (const UT_Vector2T<T> &u, const UT_Vector2T<T> &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.

template <typename T, typename S>
inline UT_Vector2T<T>   rowVecMult(const UT_Vector2T<T> &v, 
                                   const UT_Matrix2T<S> &m);
template <typename T, typename S>
inline UT_Vector2T<T>   colVecMult(const UT_Matrix2T<S> &m, 
                                   const UT_Vector2T<T> &v);
// @}

template <typename T>
inline T                distance2d(const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2);

/// Given a 2D position, input, and a 2D quad, (p0, p0+du, p0+du+dv+duv, p0+dv),
/// finds the 0, 1, or 2 locations in the parameter space of that quad that correspond
/// with the input position.  Only parameter locations approximately between 0 and 1
/// are accepted.  The return value is the number of accepted parameter locations.
template <typename T>
int UTinverseBilerp(const UT_Vector2T<T> &input,
    const UT_Vector2T<T> &p0,
    const UT_Vector2T<T> &du, const UT_Vector2T<T> &dv,
    const UT_Vector2T<T> &duv,
    UT_Vector2T<T> outputs[2]);

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

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

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

    constexpr SYS_FORCE_INLINE UT_Vector2T(const T vx, const T vy) noexcept :
        vec{ vx, vy }
    {}

    constexpr explicit SYS_FORCE_INLINE UT_Vector2T(T v) noexcept :
        UT_Vector2T( v, v )
    {}

    constexpr explicit SYS_FORCE_INLINE UT_Vector2T(const fpreal16 v[]) noexcept :
        UT_Vector2T( v[0], v[1] )
    {}
    constexpr explicit SYS_FORCE_INLINE UT_Vector2T(const fpreal32 v[]) noexcept :
        UT_Vector2T( v[0], v[1] )
    {}
    constexpr explicit SYS_FORCE_INLINE UT_Vector2T(const fpreal64 v[]) noexcept :
        UT_Vector2T( v[0], v[1] )
    {}
    constexpr explicit SYS_FORCE_INLINE UT_Vector2T(const int32 v[]) noexcept :
        UT_Vector2T( v[0], v[1] )
    {}
    constexpr explicit SYS_FORCE_INLINE UT_Vector2T(const int64 v[]) noexcept :
        UT_Vector2T( v[0], v[1] )
    {}

    constexpr explicit UT_Vector2T(const UT_Vector3T<T> &v) noexcept :
        UT_Vector2T( v.x(), v.y() )
    {}

    constexpr explicit UT_Vector2T(const UT_Vector4T<T> &v) noexcept :
        UT_Vector2T( v.x(), v.y() )
    {}

    /// Our own type of any given value_type.
    template <typename S>
    constexpr SYS_FORCE_INLINE UT_Vector2T(const UT_Vector2T<S>& v) noexcept :
        UT_Vector2T( v[0], v[1] )
    {}
   
    constexpr SYS_FORCE_INLINE UT_Vector2T<T> &operator=(const UT_Vector2T<T> &that) = default;
    constexpr SYS_FORCE_INLINE UT_Vector2T<T> &operator=(UT_Vector2T<T> &&that) = default;

    template <typename S>
    constexpr SYS_FORCE_INLINE UT_Vector2T<T> &operator=(const UT_Vector2T<S> &v)
    { vec[0] = v.x(); vec[1] = v.y();  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_Vector2T& operator+=( const UT_Vector2T& a ) noexcept
    {
        UT::FA::Add< T, tuple_size >{}( vec, a.vec );
        return *this;
    }

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

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

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

    constexpr SYS_FORCE_INLINE UT_Vector2T& operator*=( const T& a ) noexcept
    {
        UT::FA::Scale< T, tuple_size >{}( vec, a );
        return *this;
    }
    
    constexpr SYS_FORCE_INLINE UT_Vector2T& 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_Vector2T& operator*=( const UT_Vector2T& 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_Vector2T& b ) const noexcept
    {
        return UT::FA::Distance2< T, tuple_size >{}( vec, b.vec );
    }

    constexpr SYS_FORCE_INLINE T distance( const UT_Vector2T& 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 isNan() const noexcept
    {
        return UT::FA::AnyOf< T, tuple_size >{}( vec, [ & ]( const T& a ) { return SYSisNan( a ); } );
    }
    
    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 isZero() const noexcept
    {
        return UT::FA::IsUniformZero< T, tuple_size >{}( vec );
    }

    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_Vector2T& 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 );
    }
    
    // TODO: remove these. They should require an explicit UT_Vector2()
    // construction, since they're unsafe.

    /// Assignment operator that truncates a V3 to a V2.
    UT_Vector2T<T>      &operator=(const UT_Vector3T<T> &v);
    /// Assignment operator that truncates a V4 to a V2.
    UT_Vector2T<T>      &operator=(const UT_Vector4T<T> &v);
    
    constexpr SYS_FORCE_INLINE UT_Vector2T& operator=( const T a ) noexcept;

    SYS_FORCE_INLINE  UT_Vector2T<T> operator-() const
    {
        return UT_Vector2T<T>(-vec[0], -vec[1]);
    }
    void        multiplyComponents(const UT_Vector2T<T> &v)
                {
                    vec[0] *= v.vec[0];
                    vec[1] *= v.vec[1];
                }

    /// Given an oriented line from e1 passing through e2, determine on which
    /// side of the line the point p lies.  Alternatively, determine in which
    /// half plane, positive or negative, the point lies.  If the segment
    /// degenerates to a point, then the point is always on it.
    // (Moret and Shapiro 1991)
    T      whichSide(const UT_Vector2T<T> &e1, const UT_Vector2T<T> &e2) const
                { 
                    return (vec[0] - e1.vec[0]) * (e2.vec[1] - e1.vec[1]) -
                           (vec[1] - e1.vec[1]) * (e2.vec[0] - e1.vec[0]);
                }

    template <typename S>
    inline UT_Vector2T<T> &operator*=(const UT_Matrix2T<S> &mat)
                 { return operator=(*this * mat); }

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

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

    /// Calculates the orthogonal projection of a vector u on the *this vector
    UT_Vector2T<T>              project(const UT_Vector2T<T> &u) const;


    /// Vector p (representing a point in 2-space) and vector v define
    /// a line. This member returns the projection of "this" onto the
    /// line (the point on the line that is closest to this point).
    UT_Vector2T<T>              projection(const UT_Vector2T<T> &p, const UT_Vector2T<T> &v) const;

    /// Compute (homogeneous) barycentric co-ordinates of this point
    /// relative to the triangle defined by t0, t1 and t2. (The point is
    /// projected into the triangle's plane.)
    UT_Vector3T<T> getBary(const UT_Vector2T<T> &t0, const UT_Vector2T<T> &t1,
                        const UT_Vector2T<T> &t2, bool *degen = NULL) const;


    /// Return the components of the vector. The () operator does NOT check
    /// for the boundary condition.
    /// @{
    constexpr SYS_FORCE_INLINE T &x() noexcept          { return vec[0]; }
    constexpr SYS_FORCE_INLINE T  x() const noexcept    { return vec[0]; }
    constexpr SYS_FORCE_INLINE T &y() noexcept          { return vec[1]; }
    constexpr SYS_FORCE_INLINE T  y() const noexcept    { return vec[1]; }

    T           &operator()(unsigned i)
                 {
                     UT_ASSERT_P(i < tuple_size);
                     return vec[i];
                 }
    T            operator()(unsigned i) const
                 {
                     UT_ASSERT_P(i < tuple_size);
                     return vec[i];
                 }
    // @}

    /// 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)
                 {
                    vec[0] = xx; vec[1] = yy;
                 }
    /// Set the values of the vector components
    void         assign(const T *v) {vec[0]=v[0]; vec[1]=v[1];}

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

    /// Protected I/O methods
    // @{
    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 2 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_Vector2T& a ) noexcept
    {
        return UT::FA::IsUniformZero< T, tuple_size >{}( a.vec );
    }

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

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

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

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

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

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

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

    friend constexpr bool operator>=( const UT_Vector2T& a, const UT_Vector2T& 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_Vector2T<T> &v)
                        {
                            v.save(os);
                            return os;
                        }
    // @}
};

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

    return *this;
}

#include "UT_Matrix2.h"

// Free floating functions:
template <typename T>
constexpr UT_Vector2T<T>        operator+(const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2) noexcept
{
    return UT_Vector2T<T>(v1.x()+v2.x(), v1.y()+v2.y());
}
template <typename T>
constexpr UT_Vector2T<T>        operator-(const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2) noexcept
{
    return UT_Vector2T<T>(v1.x()-v2.x(), v1.y()-v2.y());
}
template <typename T>
inline UT_Vector2T<T>   operator*(const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2)
{
    return UT_Vector2T<T>(v1.x()*v2.x(), v1.y()*v2.y());
}
template <typename T>
inline UT_Vector2T<T>   operator/(const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2)
{
    return UT_Vector2T<T>(v1.x()/v2.x(), v1.y()/v2.y());
}
template <typename T>
constexpr bool          operator<(const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2) noexcept
{
    return ((v1.x() < v2.x()) || (v1.x() == v2.x() && v1.y() < v2.y()));
}
template <typename T>
constexpr bool          operator<=(const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2) noexcept
{
    return (v1 < v2) || (v1 == v2);
}
template <typename T>
constexpr bool          operator>(const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2) noexcept
{
    return v2 < v1;
}
template <typename T>
constexpr bool          operator>=(const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2) noexcept
{
    return v2 <= v1;
}
template <typename T, typename S>
inline UT_Vector2T<T>   operator+(const UT_Vector2T<T> &v, S scalar)
{
    return UT_Vector2T<T>(v.x()+scalar, v.y()+scalar);
}
template <typename T, typename S>
inline UT_Vector2T<T>   operator+(S scalar, const UT_Vector2T<T> &v)
{
    return UT_Vector2T<T>(v.x()+scalar, v.y()+scalar);
}
template <typename T, typename S>
inline UT_Vector2T<T>   operator-(const UT_Vector2T<T> &v, S scalar)
{
    return UT_Vector2T<T>(v.x()-scalar, v.y()-scalar);
}
template <typename T, typename S>
inline UT_Vector2T<T>   operator-(S scalar, const UT_Vector2T<T> &v)
{
    return UT_Vector2T<T>(scalar-v.x(), scalar-v.y());
}
template <typename T, typename S>
inline UT_Vector2T<T>   operator*(const UT_Vector2T<T> &v, S scalar)
{
    return UT_Vector2T<T>(v.x()*scalar, v.y()*scalar);
}
template <typename T, typename S>
constexpr UT_Vector2T<T>        operator*(S scalar, const UT_Vector2T<T> &v) noexcept
{
    return UT_Vector2T<T>(v.x()*scalar, v.y()*scalar);
}
template <typename T, typename S>
inline UT_Vector2T<T>   operator/(const UT_Vector2T<T> &v, S scalar)
{
    return UT_Vector2T<T>(v.x()/scalar, v.y()/scalar);
}
template <typename T, typename S>
inline UT_Vector2T<T>   operator/(S scalar, const UT_Vector2T<T> &v)
{
    return UT_Vector2T<T>(scalar/v.x(), scalar/v.y());
}

template <typename T>
constexpr auto dot( const UT_Vector2T< T >& a, const UT_Vector2T< T >& b ) noexcept
{
    return UT::FA::Dot< T, 2 >{}( a.vec, b.vec );
}

template <typename T>
inline T                cross(const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2)
{
    return v1.x() * v2.y() - v1.y() * v2.x();
}
template <typename T>
inline
UT_Vector2T<T>  SYSabs(const UT_Vector2T<T> &v)
{
    return UT_Vector2T<T>(SYSabs(v.x()), SYSabs(v.y()));
}


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

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

template <typename T, typename S>
inline bool           
SYSisEqual(const UT_Vector2T<T> &a, const UT_Vector2T<T> &b, S tol)
{
    return a.isEqual(b, tol);
}

template <typename T,typename S>
inline
UT_Vector2T<T> SYSlerp(const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2, S t)
{
    return UT_Vector2T<T>(
            SYSlerp(v1.x(), v2.x(), t),
            SYSlerp(v1.y(), v2.y(), t));
}

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

template <typename T>
inline UT_Vector2T<T>   project(const UT_Vector2T<T> &u, const UT_Vector2T<T> &v)
{
    return dot(u, v) / v.length2() * v;
}
template <typename T, typename S>
inline UT_Vector2T<T>   rowVecMult(const UT_Vector2T<T> &v, const UT_Matrix2T<S> &m)
{
    return UT_Vector2T<T>(v.x()*m(0,0) + v.y()*m(1,0),
                          v.x()*m(0,1) + v.y()*m(1,1));
}
template <>
inline UT_Vector2T<float> rowVecMult(const UT_Vector2T<float> &v, const UT_Matrix2T<float> &m)
{
    const v4uf l(v.x(), v.x(), v.y(), v.y());
    const v4uf r(m.data());
    const v4uf p = l * r;

    return UT_Vector2T<float>(p[0] + p[2], p[1] + p[3]);
}
template <typename T, typename S>
inline UT_Vector2T<T>   colVecMult(const UT_Matrix2T<S> &m, const UT_Vector2T<T> &v)
{
    return UT_Vector2T<T>(m(0,0)*v.x() + m(0,1)*v.y(),
                          m(1,0)*v.x() + m(1,1)*v.y());
}
template <>
inline UT_Vector2T<float> colVecMult(const UT_Matrix2T<float> &m, const UT_Vector2T<float> &v)
{
    const v4uf l(m.data());
    const v4uf r(v.x(), v.y(), v.x(), v.y());
    const v4uf p = l * r;
    return UT_Vector2T<float>(p[0] + p[1], p[2] + p[3]);
}
template <typename T, typename S>
inline UT_Vector2T<T>   operator*(const UT_Vector2T<T> &v, const UT_Matrix2T<S> &m)
{
    return rowVecMult(v, m);
}
template <typename T>
inline T                distance2d(const UT_Vector2T<T> &v1, const UT_Vector2T<T> &v2)
{
    return (v1 - v2).length();
}

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

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

template< typename T, exint D >
class UT_FixedVector;

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

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

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

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

template< typename T > 
struct SYS_FixedArraySizeNoCVRef< UT_Vector2T< T > > : std::integral_constant< std::size_t, 2 > {};


// UT_Vector2TFromUnbounded<T> is a function object that
// creates a UT_Vector2T<T> from an unbounded array-like type 'as'.
// 'as' must have at size at least 2.
template <typename T>
struct UT_Vector2TFromUnbounded
{    
    template< typename TS >
    constexpr SYS_FORCE_INLINE UT_Vector2T<T> operator()(const TS& as) const noexcept
    {                
        return UT_Vector2T<T>( as[0], as[1] );
    }
};

// UT_FromUnbounded<V> creates a V from an unbounded array-like type

// Primary
template <typename V >
struct UT_FromUnbounded;

// Partial specialization for UT_Vector2T
template <typename T>
struct UT_FromUnbounded< UT_Vector2T<T> > : UT_Vector2TFromUnbounded<T> {};


// UT_Vector2TFromFixed<T> is a function object that
// creates a UT_Vector2T<T> from a fixed array-like type TS,
// examples of which include T[2], UT_FixedVector<T,2> and UT_FixedArray<T,2> (AKA std::array<T,2>)
// This version is safer than UT_Vector2TFromUnbounded, but it can be used
// only if the size of 'as' can be deduced at compile time.
template <typename T>
struct UT_Vector2TFromFixed
{    
    template< typename TS >
    constexpr SYS_FORCE_INLINE UT_Vector2T<T> operator()(const TS& as) const noexcept
    {                
        SYS_STATIC_ASSERT( SYS_IsFixedArrayOf_v< TS, T, 2 > );

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

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

    return UT_Vector2TFromFixed< 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_Vector2T
template <typename T>
struct UT_FromFixed< UT_Vector2T<T> > : UT_Vector2TFromFixed<T> {};

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

#endif