3DPoint.inl

#pragma once
 
BEGIN_MOOTOOLS_NAMESPACE
 
template <class TYPE> inline C3DTPoint<TYPE>::C3DTPoint()
{
    x = (TYPE)0.0f;
    y = (TYPE)0.0f;
    z = (TYPE)0.0f;
}
 
template <class TYPE> inline C3DTPoint<TYPE>::C3DTPoint(TYPE *val)
{
    x = val[0];
    y = val[1];
    z = val[2];
}
 
template <class TYPE> inline C3DTPoint<TYPE>::C3DTPoint(int refx, int refy, int refz)
{
    x = (TYPE)refx;
    y = (TYPE)refy;
    z = (TYPE)refz;
}
 
template <class TYPE> inline C3DTPoint<TYPE>::C3DTPoint(float refx, float refy, float refz)
{
    x = (TYPE)refx;
    y = (TYPE)refy;
    z = (TYPE)refz;
}
 
template <class TYPE> inline C3DTPoint<TYPE>::C3DTPoint(double refx, double refy, double refz)
{
    x = (TYPE)refx;
    y = (TYPE)refy;
    z = (TYPE)refz;
}
 
template <class TYPE> inline C3DTPoint<TYPE>::C3DTPoint(const C3DTPoint<TYPE>& pt)
{
    x = pt.x;
    y = pt.y;
    z = pt.z;
}
 
template <class TYPE> inline C3DTPoint<TYPE>::C3DTPoint(const C3DTPoint<TYPE>& pt, const C3DTVector<TYPE>& vect, bool add)
{
    if (add)
    {
        x = pt.x + vect.x;
        y = pt.y + vect.y;
        z = pt.z + vect.z;
    }
    else
    {
        x = pt.x - vect.x;
        y = pt.y - vect.y;
        z = pt.z - vect.z;
    }
}
 
template <class TYPE> inline TYPE& C3DTPoint<TYPE>::operator[](int i)
{
    return (&x)[i];
}
 
template <class TYPE> inline const TYPE& C3DTPoint<TYPE>::operator[](int i) const
{
    return (&x)[i];
}
 
template <class TYPE> inline unsigned int C3DTPoint<TYPE>::SizeOf() const
{
    return static_cast<unsigned int>(sizeof(TYPE)*3);
}
 
template <class TYPE> inline TYPE* C3DTPoint<TYPE>::ValPtr()
{
    return(&x);
}
 
template <class TYPE> inline const TYPE* C3DTPoint<TYPE>::ValPtr() const
{
    return(&x);
}
 
template <class TYPE> inline void  C3DTPoint<TYPE>::SetValues(const TYPE *val)
{
    x = val[0];
    y = val[1];
    z = val[2];
}
 
template <class TYPE> inline C3DTPoint<TYPE>& C3DTPoint<TYPE>::operator=(const C3DTPoint<TYPE>& src)
{
    CPt::operator=(src);
    x = src.x;
    y = src.y;
    z = src.z;
    return *this;
}
 
template <class TYPE> C3DTPoint<TYPE>& C3DTPoint<TYPE>::operator=(const C3DTVector<TYPE>& vect)
{
    x = vect.x;
    y = vect.y;
    z = vect.z;
    return *this;
}
 
// for a point t = 1.0
// tV1 * V2
template <class TYPE> inline double C3DTPoint<TYPE>::operator *(const C4DTVector<TYPE>& vect) const
{
    return (double(x)*vect.dir.x + double(y)*vect.dir.y + double(z)*vect.dir.z + double(vect.t));
}
 
template <class TYPE> inline C3DTPoint<TYPE> C3DTPoint<TYPE>::operator *(double value) const
{
    return C3DTPoint<TYPE>(x*value, y*value, z*value);
}
 
template <class TYPE> inline C3DTPoint<TYPE> operator *(double value, const C3DTPoint<TYPE>& pt)
{
    return C3DTPoint<TYPE>(pt.x*value, pt.y*value, pt.z*value);
}
 
template <class TYPE> inline double C3DTPoint<TYPE>::Mult(const double& xx, const double& yy, const double& zz) const
{
    return (x*xx + y*yy + z*zz);
}
 
template <class TYPE> inline C3DTPoint<TYPE> C3DTPoint<TYPE>::operator -(const C3DTVector<TYPE>& vect1) const
{
    return C3DTPoint(x - vect1.x, y - vect1.y, z - vect1.z);
}
 
template <class TYPE> inline C3DTPoint<TYPE> C3DTPoint<TYPE>::operator +(const C3DTVector<TYPE>& vect1) const
{
    return C3DTPoint(x + vect1.x, y + vect1.y, z + vect1.z);
}
 
template <class TYPE> inline C3DTPoint<TYPE>& C3DTPoint<TYPE>::operator -=(const C3DTPoint<TYPE>& pt)
{
    x -= pt.x;
    y -= pt.y;
    z -= pt.z;
 
    return *this;
}
 
template <class TYPE> inline void C3DTPoint<TYPE>::SubstractTo(const C3DTPoint<TYPE>& pt)
{
    x = pt.x - x;
    y = pt.y - y;
    z = pt.z - z;
}
 
template <class TYPE> inline C3DTPoint<TYPE>& C3DTPoint<TYPE>::operator +=(const C3DTPoint<TYPE>& pt)
{
    x += pt.x;
    y += pt.y;
    z += pt.z;
 
    return *this;
}
 
template <class TYPE> inline void C3DTPoint<TYPE>::Offset(TYPE value)
{
    x += value;
    y += value;
    z += value;
}
 
 
template <class TYPE> inline bool C3DTPoint<TYPE>::IsAnormal() const
{
    // Do not check fpclassify, and subnormal values
    if (IsInfinite() || const_cast<C3DTPoint<TYPE> *>(this)->IsNan())
        return true;
 
    return false;
}
 
template <class TYPE> inline bool C3DTPoint<TYPE>::IsInfinite() const
{
    if (_finite(x) && _finite(y) && _finite(z))
        return false;
 
    return true;
}
 
template <class TYPE> inline bool C3DTPoint<TYPE>::IsNan(bool resetToZero)
{
    if (resetToZero)
    {
        bool nan = false;
        if (_isnan(x))
        {
            x = 0.0f;
            nan = true;
        }
 
        if (_isnan(y))
        {
            y = 0.0f;
            nan = true;
        }
 
        if (_isnan(z))
        {
            z = 0.0f;
            nan = true;
        }
 
        return nan;
    }
 
    if (_isnan(x) || _isnan(y) || _isnan(z))
        return true;
 
    return false;
}
 
template <class TYPE> inline C3DTPoint<TYPE>& C3DTPoint<TYPE>::operator -=(const C3DTVector<TYPE>& vect)
{
    x -= vect.x;
    y -= vect.y;
    z -= vect.z;
 
    return *this;
}
 
template <class TYPE> inline C3DTPoint<TYPE>& C3DTPoint<TYPE>::operator +=(const C3DTVector<TYPE>& vect)
{
    x += vect.x;
    y += vect.y;
    z += vect.z;
 
    return *this;
}
 
template <class TYPE> inline C3DTPoint<TYPE> C3DTPoint<TYPE>::operator +(const C3DTPoint<TYPE>& pt1) const
{
    return C3DTPoint(x + pt1.x, y + pt1.y, z + pt1.z);
}
 
template <class TYPE> inline C3DTPoint<TYPE> C3DTPoint<TYPE>::operator -(const C3DTPoint<TYPE>& pt1) const
{
    return C3DTPoint(x - pt1.x, y - pt1.y, z - pt1.z);
}
 
template <class TYPE> inline C3DTPoint<TYPE> C3DTPoint<TYPE>::operator +(const C4DTVector<TYPE>& pt1) const
{
    return C3DTPoint(x + pt1.dir.x, y + pt1.dir.y, z + pt1.dir.z);
}
 
template <class TYPE> inline C3DTPoint<TYPE> C3DTPoint<TYPE>::operator /(double weight) const
{
    return C3DTPoint(x/weight, y/weight, z/weight);
}
 
template <class TYPE> inline C3DTPoint<TYPE>& C3DTPoint<TYPE>::operator /=(double weight)
{
    x = (TYPE)(x/weight);
    y = (TYPE)(y/weight);
    z = (TYPE)(z/weight);
    
    return *this;
}
 
template <class TYPE> inline C3DTPoint<TYPE>& C3DTPoint<TYPE>::operator *=(double weight)
{
    x = (TYPE)(x * weight);
    y = (TYPE)(y * weight);
    z = (TYPE)(z * weight);
 
    return *this;
}
 
template <class TYPE> bool C3DTPoint<TYPE>::operator==(const C3DTPoint<TYPE>& src) const
{
    if (x != src.x || y != src.y || z != src.z)
        return false;
 
    return true;
}
 
template <class TYPE> bool C3DTPoint<TYPE>::operator!=(const C3DTPoint<TYPE>& src) const
{
    if (x != src.x || y != src.y || z != src.z)
        return true;
 
    return false;
}
 
template <class TYPE> inline C3DPointI C3DTPoint<TYPE>::Floor() const
{
    return C3DPointI(floor(x), floor(y), floor(z));
}
 
template <class TYPE> inline C3DPointI C3DTPoint<TYPE>::Ceil() const
{
    return C3DPointI(ceil(x), ceil(y), ceil(z));
}
 
template <class TYPE> inline void GetNormal(const C3DTPoint<TYPE>& pt1, const C3DTPoint<TYPE>& pt2, const C3DTPoint<TYPE>& pt3, C3DTVector<TYPE>& normal)
{
    C3DTVector<TYPE> vector;
 
    normal.InitFromPoints(pt1, pt2);
    vector.InitFromPoints(pt1, pt3);
    normal = (normal ^ vector);
 
    if (normal.IsNull())
    {
        normal.x = 1.0f;
        normal.y = 0.0f;
        normal.z = 0.0f;
    }
    else
        normal.Normalize();
}
 
template<class TYPE> inline double Area(const C3DTPoint<TYPE>& v0, const C3DTPoint<TYPE>& v1, const C3DTPoint<TYPE>& v2)
{
    return Area(C3DTVector<TYPE>(v0, v1), C3DTVector<TYPE>(v0, v2));
}
 
template <class TYPE> inline void Min(C3DTPoint<TYPE>& min, const C3DTPoint<TYPE>& point)
{
    if (min.x > point.x)
        min.x = point.x;
    if (min.y > point.y)
        min.y = point.y;
    if (min.z > point.z)
        min.z = point.z;
}
 
template <class TYPE> inline void Max(C3DTPoint<TYPE>& max, const C3DTPoint<TYPE>& point)
{
    if (max.x < point.x)
        max.x = point.x;
    if (max.y < point.y)
        max.y = point.y;
    if (max.z < point.z)
        max.z = point.z;
}
 
END_MOOTOOLS_NAMESPACE