3DVector.h

// 3DVector.h: interface for the C3DVector class.
//
//////////////////////////////////////////////////////////////////////
 
#if !defined(AFX_3DVECTOR_H__CA6BC2A2_FAC2_11D1_A0DE_000000000000__INCLUDED_)
#define AFX_3DVECTOR_H__CA6BC2A2_FAC2_11D1_A0DE_000000000000__INCLUDED_
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "Point.h"
#include "Quaternion.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
// C3DVector class is used to compute normal
// It used with with C3DVectorList : CPointList.
template<class TYPE> class C3DTVector : public CPt
{
public:
    TYPE x, y, z;
 
    C3DTVector();
    C3DTVector(TYPE *val);
    C3DTVector(float x, float y, float z);
    C3DTVector(double x, double y, double z);
    C3DTVector(const C3DTPoint<TYPE>& point1, const C3DTPoint<TYPE>& point2);
    C3DTVector(const C3DTVector<TYPE>& vector);
    C3DTVector(const C3DTPoint<TYPE>& point);
    C3DTVector(const CQuaternion& quat);
 
    //! @name Access functions
    //! Get access to the vector x, y, z values
    //!
    //! @{
    TYPE& operator[](int i);
    const TYPE& operator[](int i) const;
    TYPE* ValPtr();
    const TYPE* ValPtr() const;
 
    //! @}
 
    unsigned int SizeOf() const;
 
    void Init(float x = 0.0f, float y = 0.0f, float z = 0.0f);
    void Init(double x = 0.0, double y = 0.0, double z = 0.0);
    void InitFromPoint(const C3DTPoint<TYPE>& point);
    void InitFromPoints(const C3DTPoint<TYPE>& point1, const C3DTPoint<TYPE>& point2);
    void Swap(unsigned int swapMode);
    void SubstractTo(const C3DTVector& vect); //!< return this = vect-this, instead this = this-vect. This can be used for fast computation (using the standard operator return a C3DPointT)
    void Offset(TYPE value); //!< Add value to x, y, z
 
    // Check value
    bool IsAnormal() const; //!< either infinite or nan. Zero and denormalized value are allowed.
    bool IsInfinite() const; //!< Check if one of the coordinate has inf value.
    bool IsNan(bool resetToZero = false); //!< Check if one of the coordinate has nan value. resetToZero nan = true, reset coordinates to zero if any.
 
    void SelfNegate(); //!< / operator - : negate each component (-x, -y, -z)
    void SelfInvert(); //!< / operator / : invert each component (1/x, 1/y, 1/z)
    C3DTVector& SelfMult(const C3DTVector& vector); //!< Self multiply each component (x, y, z) with vect(x, y, z). This is not the scalar product !. No operation is done on a component if checkZero = true and one component is zero, otherwise division by zero will result in +/-inf
    C3DTVector& SelfDiv(const C3DTVector& vector, bool checkZero = true); //!< Self divide each component (x, y, z) with vect(x, y, z). This is not the scalar product !
 
    C3DTVector Mult(const C3DTVector& vector) const; //!< Multiply each component (x, y, z) with vect(x, y, z). This is not the scalar product !
    C3DTVector Div(const C3DTVector& vector, bool checkZero = true) const; //!< Divide each component (x, y, z) with vect(x, y, z). This is not the scalar product !
    C3DTVector Negate() const; //!< / operator - : return negate of each component (-x, -y, -z)
    C3DTVector NegateCheckZeroSign() const; //!< / operator - : return negate of each component (-x, -y, -z). If a component is 0, it return a +0, never -0.
    C3DTVector Invert() const; //!< / operator / : return invert each component (1/x, 1/y, 1/z)
    C3DTVector InvertCheckZeroSign() const; //!< / operator / : return invert each component (1/x, 1/y, 1/z). If a component is -0, it does return +inf, never -inf. Use in some special circumstance, ie C3DTBBox::RayIntersect.
    C3DTVector& operator=(const C3DTVector& vect);
    C3DTVector& operator=(const C3DTPoint<TYPE>& pt);
    bool operator==(const C3DTVector& src) const;
    bool operator!=(const C3DTVector& src) const;
    C3DTVector operator^(const C3DTVector& vect) const;
    C3DTVector operator+(const C3DTVector& vect) const;
    C3DTVector operator-(const C3DTVector& vect) const;
    C3DTVector operator-() const;
    C3DTVector operator*(double weight) const;
    double operator*(const C3DTVector& vect) const;
    C3DTVector operator/(double weight) const;
    void operator-=(const C3DTPoint<TYPE>& pt);
    void operator+=(const C3DTPoint<TYPE>& pt);
    void operator-=(const C3DTVector& vect);
    void operator+=(const C3DTVector& vect);
    C3DTVector& operator*=(double weight);
    C3DTVector& operator/=(double weight);
 
    C3DVectorI Floor() const;
    C3DVectorI Ceil() const;
 
    //////////////////////
    // Mix type conversion (C3DTVector<float> to C3DTVector<double> for example)
    template <class TYPE2> C3DTVector(const C3DTVector<TYPE2>& vect);
    template <class TYPE2> C3DTVector(const C3DTPoint<TYPE2>& pt);
    template <class TYPE2> C3DTVector& operator=(const C3DTVector<TYPE2>& vect);
    template <class TYPE2> C3DTVector(const C3DTPoint<TYPE2>& pt1, const C3DTPoint<TYPE2>& pt2);
 
    bool Normalize(); //!< Return false if vector length is null
    double Length() const;
    double Length2() const;
    bool IsNull(double precision = PRECISION_LIMIT) const; //!< Compare vector to (0.0, 0.0, 0.0). Return true if equal, false otherwise
    bool IsUnit(double precision = PRECISION_LIMIT) const; //!< Compare vector to (1.0, 1.0, 1.0). Return true if equal, false otherwise
    bool IsNormalized(double precision = FLOAT_EPSILON) const; //!< Check if vector normalized. Return true if normalized, false otherwise
 
    virtual void To4DPoint(C4DPoint& pt) const;
    virtual CPt& operator=(const C4DPoint& pt);
    template <class TYPE2> void SetValues(const TYPE2 *values3t); //!< Set vector from 3 TYPE
    void GetFloat(float *values3f) const; //!< Get vector and fill 3 floats
    void SetFloat(const float *values3f); //!< Set vector from 3 floats
    void GetDouble(double *values3d) const; //!< Get vector and fill 3 doubles
    void SetDouble(const double *values3d); //!< Set vector from 3 doubles
 
    virtual CPt& operator=(const CPt& refpoint);
    virtual void Serialize(CXArchive& ar);
 
#ifdef _DEBUG
    void Dump() const;
    virtual bool IsKindOf(unsigned int classid) const;
    virtual unsigned int ClassID() const;
#endif
};
 
END_MOOTOOLS_NAMESPACE
 
#include "3DPoint.h"
#include "3DVector.inl"
 
BEGIN_MOOTOOLS_NAMESPACE
 
// Access operators
template <class TYPE>
inline TYPE& C3DTVector<TYPE>::operator[](int i)
{
    return (&x)[i];
}
 
template <class TYPE>
inline const TYPE& C3DTVector<TYPE>::operator[](int i) const
{
    return (&x)[i];
}
 
template <class TYPE>
inline TYPE* C3DTVector<TYPE>::ValPtr()
{
    return(&x);
}
 
template <class TYPE>
inline const TYPE* C3DTVector<TYPE>::ValPtr() const
{
    return(&x);
}
 
template <class TYPE>
inline unsigned int C3DTVector<TYPE>::SizeOf() const
{
    return static_cast<unsigned int>(sizeof(TYPE) * 3);
};
 
//////////////////////
// Mix type conversion (C3DTVector<float> to C3DTVector<double> for example)
template <class TYPE>
template <class TYPE2> C3DTVector<TYPE>::C3DTVector(const C3DTVector<TYPE2>& vect)
{
    XASSERT(ClassID() != vect.ClassID()); // (the default operator should be called if same type)
 
    x = (TYPE)vect.x;
    y = (TYPE)vect.y;
    z = (TYPE)vect.z;
}
 
template <class TYPE>
template <class TYPE2> C3DTVector<TYPE>::C3DTVector(const C3DTPoint<TYPE2>& pt)
{
    x = (TYPE)pt.x;
    y = (TYPE)pt.y;
    z = (TYPE)pt.z;
}
 
template <class TYPE>
template <class TYPE2> C3DTVector<TYPE>::C3DTVector(const C3DTPoint<TYPE2>& point1, const C3DTPoint<TYPE2>& point2)
{
    x = (TYPE)(point2.x - point1.x);
    y = (TYPE)(point2.y - point1.y);
    z = (TYPE)(point2.z - point1.z);
}
 
template <class TYPE>
template <class TYPE2> C3DTVector<TYPE>& C3DTVector<TYPE>::operator=(const C3DTVector<TYPE2>& vect)
{
    XASSERT(ClassID() != vect.ClassID()); // (the default operator should be called if same type)
 
    x = (TYPE)vect.x;
    y = (TYPE)vect.y;
    z = (TYPE)vect.z;
 
    CPt::operator=(vect);
 
    return *this;
}
 
/////////////////////////////////////////////////////////////////////
// Specialization
//////////////////////////////////////////////////////////////////////
 
#ifdef _DEBUG
template<> inline unsigned int C3DTVector<int>::ClassID() const
{
    return MAKE_CUSTOM_ID('V', 'E', 'C', 'I');
}
 
template<> inline unsigned int C3DTVector<float>::ClassID() const
{
    return MAKE_CUSTOM_ID('V', 'E', 'C', 'F');
}
 
template<> inline unsigned int C3DTVector<double>::ClassID() const
{
    return MAKE_CUSTOM_ID('V', 'E', 'C', 'D');
}
 
template<> inline bool C3DTVector<float>::IsKindOf(unsigned int classid) const
{
    if (C3DTVector<float>::ClassID() == classid)
        return true;
 
    return CPt::IsKindOf(classid);
}
 
template<> inline bool C3DTVector<double>::IsKindOf(unsigned int classid) const
{
    if (C3DTVector<double>::ClassID() == classid)
        return true;
 
    return CPt::IsKindOf(classid);
}
 
//template unsigned int C3DTVector<float>::ClassID() const;
//template unsigned int C3DTVector<double>::ClassID() const;
//template bool C3DTVector<float>::IsKindOf(unsigned int classid) const;
//template bool C3DTVector<double>::IsKindOf(unsigned int classid) const;
#endif
 
/////////////////////////////////////////////////////////////////////
// Implementation
//////////////////////////////////////////////////////////////////////
template <class TYPE> void C3DTVector<TYPE>::Serialize(CXArchive& ar)
{
    CPt::Serialize(ar);
 
    if (ar.IsStoring())
    {
        ar << x;
        ar << y;
        ar << z;
    }
    else
    {
        ar >> x;
        ar >> y;
        ar >> z;
    }
}
 
template <class TYPE> void C3DTVector<TYPE>::To4DPoint(C4DPoint& pt) const
{
    pt.size = 3;
    pt.value[0] = x;
    pt.value[1] = y;
    pt.value[2] = z;
}
 
template <class TYPE> CPt& C3DTVector<TYPE>::operator=(const C4DPoint& pt)
{
    XASSERT(pt.size == 3);
    x = (TYPE)pt.value[0];
    y = (TYPE)pt.value[1];
    z = (TYPE)pt.value[2];
    return *this;
}
 
template<class TYPE> void C3DTVector<TYPE>::Swap(unsigned int swapMode)
{
    // The order of inversion is important (swap before invert)
    if (swapMode & SWAP_AXIS_FLAGS)
    {
        TYPE tmp;
        switch (swapMode & SWAP_AXIS_FLAGS)
        {
            default:
                XASSERT(0);
                break;
 
            case SWAP_XY:
                SWAP_VALUES(x, y, tmp);
                break;
            case SWAP_XZ:
                SWAP_VALUES(x, z, tmp);
                break;
            case SWAP_YZ:
                SWAP_VALUES(y, z, tmp);
                break;
        }
    }
 
    if (swapMode & SWAP_INVERT_FLAGS)
    {
        switch (swapMode & SWAP_INVERT_FLAGS)
        {
            default:
                XASSERT(0);
                break;
 
            case SWAP_INVERT_X:
                x = -x;
                break;
            case SWAP_INVERT_Y:
                y = -y;
                break;
            case SWAP_INVERT_Z:
                z = -z;
                break;
        }
    }
}
 
template <class TYPE> inline void  C3DTVector<TYPE>::SetFloat(const float *values)
{
    x = (TYPE)values[0];
    y = (TYPE)values[1];
    z = (TYPE)values[2];
}
 
template <class TYPE> void C3DTVector<TYPE>::GetFloat(float *values) const
{
    values[0] = x;
    values[1] = y;
    values[2] = z;
}
 
template <class TYPE> void C3DTVector<TYPE>::GetDouble(double *values) const
{
    values[0] = x;
    values[1] = y;
    values[2] = z;
}
 
template <class TYPE> void C3DTVector<TYPE>::SetDouble(const double *values)
{
    x = (TYPE)values[0];
    y = (TYPE)values[1];
    z = (TYPE)values[2];
}
 
template <class TYPE> C3DTVector<TYPE>::C3DTVector(const CQuaternion& quat)
{
    x = quat.val[0];
    y = quat.val[1];
    z = quat.val[2];
}
 
template <class TYPE> CPt& C3DTVector<TYPE>::operator=(const CPt& refpoint)
{
    XASSERT(refpoint.IsKindOf(C3DTVector<TYPE>::ClassID()));
 
    x = ((C3DTVector<TYPE>&)refpoint).x;
    y = ((C3DTVector<TYPE>&)refpoint).y;
    z = ((C3DTVector<TYPE>&)refpoint).z;
 
    return CPt::operator=(refpoint);
}
 
template <typename TYPE> class CHashMethods<C3DTVector<TYPE> > // Keep space between > > for Linux C98
{
public:
    static inline bool HashCompare(const C3DTVector<TYPE>& pt1, const C3DTVector<TYPE>& pt2)
    {
        if (pt1.x != pt2.x || pt1.y != pt2.y || pt1.z != pt2.z)
            return false;
 
        return true;
    }
 
    static inline unsigned int HashValue(const C3DTVector<TYPE>& hash)
    {
        return CHashMethods<TYPE>::HashValue(hash.x + hash.y + hash.z);
    }
};
 
template <> inline unsigned int CHashMethods<C3DTVector<int> >::HashValue(const C3DTVector<int>& hash)  // Keep space between > > for Linux C98
{
    return HashMixValue(hash.x + HashMixValue(hash.y)) + hash.z;
}
 
#ifdef _DEBUG
#include "StringTools.h"
template <class TYPE> void C3DTVector<TYPE>::Dump() const
{
    XTRACE(_T("Vector : %.5f %.5f %.5f\n"), x, y, z);
    CPt::Dump();
}
 
template <> inline void C3DTVector<int>::Dump() const
{
    XTRACE(_T("Vector : %d %d %d\n"), x, y, z);
    CPt::Dump();
}
 
template <class TYPE> bool C3DTVector<TYPE>::IsKindOf(unsigned int classid) const
{
    if (C3DTVector::ClassID() == classid)
        return true;
 
    return CPt::IsKindOf(classid);
}
 
template <class TYPE> unsigned int C3DTVector<TYPE>::ClassID() const
{
    return MAKE_CUSTOM_ID('V', 'E', 'C', 'T');
}
 
#endif
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(AFX_3DVECTOR_H__CA6BC2A2_FAC2_11D1_A0DE_000000000000__INCLUDED_)