godot/thirdparty/vhacd/inc/vhacdVector.inl

#pragma once
#ifndef VHACD_VECTOR_INL
#define VHACD_VECTOR_INL
namespace VHACD
{
    template <typename T> 
    inline Vec3<T> operator*(T lhs, const Vec3<T> & rhs)
    { … }
    template <typename T> 
    inline T & Vec3<T>::X() 
    { … }
    template <typename T> 
    inline  T &    Vec3<T>::Y() 
    { … }
    template <typename T>    
    inline  T &    Vec3<T>::Z() 
    { … }
    template <typename T> 
    inline  const T & Vec3<T>::X() const 
    { … }
    template <typename T> 
    inline  const T & Vec3<T>::Y() const 
    { … }
    template <typename T> 
    inline  const T & Vec3<T>::Z() const 
    { … }
    template <typename T> 
    inline  void Vec3<T>::Normalize()
    { … }
    template <typename T> 
    inline  T Vec3<T>::GetNorm() const 
    { … }
    template <typename T> 
    inline  void Vec3<T>::operator= (const Vec3 & rhs)
    { … }
    template <typename T> 
    inline  void Vec3<T>::operator+=(const Vec3 & rhs)
    { … }     
    template <typename T>  
    inline void Vec3<T>::operator-=(const Vec3 & rhs)
    { … }
    template <typename T> 
    inline void Vec3<T>::operator-=(T a)
    { … }
    template <typename T> 
    inline void Vec3<T>::operator+=(T a)
    { … }
    template <typename T> 
    inline void Vec3<T>::operator/=(T a)
    { … }
    template <typename T>  
    inline void Vec3<T>::operator*=(T a)
    { … }  
    template <typename T> 
    inline Vec3<T> Vec3<T>::operator^ (const Vec3<T> & rhs) const
    { … }
    template <typename T>
    inline T Vec3<T>::operator*(const Vec3<T> & rhs) const
    { … }        
    template <typename T>
    inline Vec3<T> Vec3<T>::operator+(const Vec3<T> & rhs) const
    { … }
    template <typename T> 
    inline  Vec3<T> Vec3<T>::operator-(const Vec3<T> & rhs) const
    { … }     
    template <typename T> 
    inline  Vec3<T> Vec3<T>::operator-() const
    { … }     

    template <typename T> 
    inline Vec3<T> Vec3<T>::operator*(T rhs) const
    { … }
    template <typename T>
    inline Vec3<T> Vec3<T>::operator/ (T rhs) const
    { … }
    template <typename T>
    inline Vec3<T>::Vec3(T a) 
    { … }
    template <typename T>
    inline Vec3<T>::Vec3(T x, T y, T z)
    { … }
    template <typename T>
    inline Vec3<T>::Vec3(const Vec3 & rhs)
    { … }
    template <typename T>
    inline Vec3<T>::~Vec3(void){};

    template <typename T>
    inline Vec3<T>::Vec3() { … }
    
    template<typename T>
    inline const bool Colinear(const Vec3<T> & a, const Vec3<T> & b, const Vec3<T> & c)
    { … }
    
    template<typename T>
    inline const T ComputeVolume4(const Vec3<T> & a, const Vec3<T> & b, const Vec3<T> & c, const Vec3<T> & d)
    { … }

    template <typename T> 
    inline bool Vec3<T>::operator<(const Vec3 & rhs) const
    { … }
    template <typename T> 
    inline  bool Vec3<T>::operator>(const Vec3 & rhs) const
    { … } 
    template <typename T> 
    inline Vec2<T> operator*(T lhs, const Vec2<T> & rhs)
    { … }
    template <typename T> 
    inline T & Vec2<T>::X() 
    { … }
    template <typename T>    
    inline  T &    Vec2<T>::Y() 
    { … }
    template <typename T>    
    inline  const T & Vec2<T>::X() const 
    { … }
    template <typename T>    
    inline  const T & Vec2<T>::Y() const 
    { … }
    template <typename T>    
    inline  void Vec2<T>::Normalize()
    { … }
    template <typename T>    
    inline  T Vec2<T>::GetNorm() const 
    { … }
    template <typename T>    
    inline  void Vec2<T>::operator= (const Vec2 & rhs)
    { … }
    template <typename T>    
    inline  void Vec2<T>::operator+=(const Vec2 & rhs)
    { … }     
    template <typename T>  
    inline void Vec2<T>::operator-=(const Vec2 & rhs)
    { … }
    template <typename T>  
    inline void Vec2<T>::operator-=(T a)
    { … }
    template <typename T>  
    inline void Vec2<T>::operator+=(T a)
    { … }
    template <typename T>  
    inline void Vec2<T>::operator/=(T a)
    { … }
    template <typename T>  
    inline void Vec2<T>::operator*=(T a)
    { … }  
    template <typename T> 
    inline T Vec2<T>::operator^ (const Vec2<T> & rhs) const
    { … }
    template <typename T>
    inline T Vec2<T>::operator*(const Vec2<T> & rhs) const
    { … }        
    template <typename T>
    inline Vec2<T> Vec2<T>::operator+(const Vec2<T> & rhs) const
    { … }
    template <typename T> 
    inline  Vec2<T> Vec2<T>::operator-(const Vec2<T> & rhs) const
    { … }     
    template <typename T> 
    inline  Vec2<T> Vec2<T>::operator-() const
    { … }     

    template <typename T> 
    inline Vec2<T> Vec2<T>::operator*(T rhs) const
    { … }
    template <typename T>
    inline Vec2<T> Vec2<T>::operator/ (T rhs) const
    { … }
    template <typename T>
    inline Vec2<T>::Vec2(T a) 
    { … }
    template <typename T>
    inline Vec2<T>::Vec2(T x, T y)
    { … }
    template <typename T>
    inline Vec2<T>::Vec2(const Vec2 & rhs)
    { … }
    template <typename T>
    inline Vec2<T>::~Vec2(void){};

    template <typename T>
    inline Vec2<T>::Vec2() { … }

   /*
     InsideTriangle decides if a point P is Inside of the triangle
     defined by A, B, C.
   */
    template<typename T>
    inline const bool InsideTriangle(const Vec2<T> & a, const Vec2<T> & b, const Vec2<T> & c, const Vec2<T> & p)
    { … }
}
#endif //VHACD_VECTOR_INL