cVecT.h

Go to the documentation of this file.

//
 
#ifndef _INC_cVecT_H
#define _INC_cVecT_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "Calc.h"
#include "GrayCore/include/cValT.h"
#include "GrayCore/include/cMem.h"
 
namespace GrayLib
{
        enum GINTERSECT_TYPE
        {
                GINTERSECT_None = 0,    
                GINTERSECT_Partial,             
                GINTERSECT_In1,                 
                GINTERSECT_In2,                 
                GINTERSECT_Error,               
        };
 
        typedef float DVALUEDEF_t;      
 
        template<typename TYPE, int _IQTY, class _TYPE_C>
        class GRAYLIB_LINK cVecTC
        {
        public:
                static const int k_nDim = _IQTY;
                typedef TYPE DVALUE_t;  
                typedef cVecTC<TYPE, _IQTY, _TYPE_C> THIS_t;
 
                TYPE* get_T() noexcept
                {
                        return (TYPE*)this;
                }
                const TYPE* get_CT() const noexcept
                {
                        return (const TYPE*)this;
                }
                const _TYPE_C& get_CR() const noexcept
                {
                        return *((_TYPE_C*)this);
                }
 
                operator const TYPE*() const noexcept
                {
                        return get_CT();
                }
                TYPE GetElem(int i) const noexcept
                {
                        DEBUG_CHECK(IS_INDEX_GOOD(i, _IQTY));
                        return get_CT()[i];
                }
                inline TYPE operator[] (int i) const noexcept
                {
                        // just so there is no confusion with auto generated TYPE* []
                        return GetElem(i);
                }
 
                // const get operators.
 
                bool isZero() const noexcept
                {
                        for (int i = 0; i < _IQTY; i++)
                        {
                                if (get_CT()[i] != (TYPE)0)
                                        return false;
                        }
                        return true;
                }
 
                COMPARE_t Compare(const THIS_t& v2) const noexcept
                {
                        return ::memcmp(get_CT(), v2.get_CT(), sizeof(TYPE)*_IQTY);
                }
                bool operator == (const THIS_t& v2) const noexcept
                {
                        return Compare(v2) == 0 ;
                }
                bool operator != (const THIS_t& v2) const noexcept
                {
                        return Compare(v2) != 0 ;
                }
 
                bool IsNear(const THIS_t& v2, TYPE fDist = (TYPE)k_FLT_MIN2) const
                {
                        for (int i = 0; i < _IQTY; i++)
                        {
                                if (!Calc::IsNear(get_CT()[i], v2.get_CT()[i], fDist))
                                        return false;
                        }
                        return true;
                }
 
                inline TYPE get_MagnitudeSq() const noexcept
                {
                        TYPE nMagnitude = 0;
                        for (int i = 0; i < _IQTY; i++)
                        {
                                nMagnitude += Calc::Sqr(GetElem(i));
                        }
                        return nMagnitude;
                }
                inline TYPE get_Magnitude() const noexcept
                {
                        return Calc::Sqrt(get_MagnitudeSq()) ;
                }
 
                _TYPE_C operator -() const
                {
                        _TYPE_C vr;
                        for (int i = 0; i < _IQTY; i++)
                        {
                                vr.RefElem(i) = -GetElem(i);
                        }
                        return vr;
                }
                _TYPE_C get_Abs() const
                {
                        _TYPE_C vr;
                        for (int i = 0; i < _IQTY; i++)
                        {
                                vr.RefElem(i) = Calc::Abs(GetElem(i));
                        }
                        return vr;
                }
                inline _TYPE_C GetSum(const THIS_t& v2) const
                {
                        _TYPE_C vr;
                        for (int i = 0; i < _IQTY; i++)
                        {
                                vr.RefElem(i) = GetElem(i) + v2.GetElem(i);
                        }
                        return vr;
                }
                inline _TYPE_C operator + (const THIS_t& v2) const
                {
                        return GetSum(v2);
                }
                inline _TYPE_C GetDiff(const THIS_t& v2) const
                {
                        _TYPE_C vr;
                        for (int i = 0; i < _IQTY; i++)
                        {
                                vr.RefElem(i) = GetElem(i) - v2.GetElem(i);
                        }
                        return vr;
                }
                inline _TYPE_C operator - (const THIS_t& v2) const
                {
                        return GetDiff(v2);
                }
                inline _TYPE_C GetScaled(TYPE nScale) const
                {
                        _TYPE_C vr;
                        for (int i = 0; i < _IQTY; i++)
                        {
                                vr.RefElem(i) = GetElem(i) * nScale;
                        }
                        return vr;
                }
                inline _TYPE_C operator * (TYPE nScale) const
                {
                        return GetScaled(nScale);
                }
                _TYPE_C operator / (TYPE nScale) const
                {
                        ASSERT(nScale);
                        return GetScaled(((TYPE)1) / nScale);
                }
 
                inline _TYPE_C GetMul(const THIS_t& v2) const
                {
                        _TYPE_C vr;
                        for (int i = 0; i < _IQTY; i++)
                        {
                                vr.RefElem(i) = GetElem(i) * v2.GetElem(i);
                        }
                        return vr;
                }
                inline _TYPE_C GetDiv(const THIS_t& v2) const
                {
                        _TYPE_C vr;
                        for (int i = 0; i < _IQTY; i++)
                        {
                                vr.RefElem(i) = GetElem(i) / v2.GetElem(i);
                        }
                        return vr;
                }
#if 0
                inline _TYPE_C operator * (const THIS_t& v2) const
                {
                        return GetMul(v2);
                }
                inline _TYPE_C operator / (const THIS_t& v2) const
                {
                        return GetDiv(v2);
                }
#endif
 
                TYPE GetDistSq(const THIS_t& v2) const
                {
                        _TYPE_C vd = GetDiff(v2);
                        return vd.get_MagnitudeSq();
                }
                TYPE GetDist(const THIS_t& v2) const
                {
                        return Calc::Sqrt(GetDistSq(v2));
                }
 
                inline TYPE GetDot(const THIS_t& v2) const
                {
                        TYPE nMagnitude = 0;
                        for (int i = 0; i < _IQTY; i++)
                        {
                                nMagnitude += GetElem(i) * v2.GetElem(i);
                        }
                        return nMagnitude;
                }
                static inline TYPE GetDot(const THIS_t& v1, const THIS_t& v2)
                {
                        return v1.GetDot(v2);
                }
#if 0
                inline TYPE operator*(const THIS_t& v2) const
                {
                        return GetDot(v2);
                }
#endif
 
                inline _TYPE_C get_Normalized() const
                {
                        _TYPE_C vr;
                        TYPE nLength = get_Magnitude();
                        if (nLength)
                        {
                                for (int i = 0; i < _IQTY; i++)
                                {
                                        vr.RefElem(i) = GetElem(i) / nLength;
                                }
                        }
                        else
                        {
                                vr.SetZero();
                        }
                        // ASSERT( Calc::IsNear( get_Magnitude(), 1 ));
                        return vr;
                }
 
                // Setters
                operator TYPE*()
                {
                        return (TYPE*) this;
                }
                TYPE& RefElem(int i) noexcept
                {
                        DEBUG_CHECK(IS_INDEX_GOOD(i, _IQTY));
                        return ((TYPE*) this)[i];
                }
                inline TYPE& operator[] (int i)
                {
                        // just so there is no confusion with auto generated TYPE* []
                        return RefElem(i);
                }
 
                void Set(const THIS_t& v)
                {
                        ::memcpy(this, &v, sizeof(TYPE) * _IQTY);
                }
 
                void SetZero() noexcept
                {
                        cMem::Zero(this, sizeof(TYPE)*_IQTY);
                }
 
                TYPE SetNormalized(void) noexcept
                {
                        TYPE nLength = get_Magnitude();
                        if (nLength != 0)
                        {
                                DoScale(((TYPE)1) / nLength);
                                // ASSERT( get_Magnitude() == 1 );
                        }
                        else
                        {
                                SetZero(); // or do nothing ??
                        }
                        return nLength;
                }
                bool put_Magnitude(TYPE nLength)
                {
                        TYPE nLengthOld = get_Magnitude();
                        if (nLengthOld == 0)
                                return false;
                        DoScale(nLength / nLengthOld);
                        // ASSERT( get_Magnitude() == nLength );
                        return true;
                }
                inline void SetLerp(const THIS_t& a, const THIS_t& b, DVALUE_t t)
                {
                        for (int i = 0; i < _IQTY; i++)
                        {
                                RefElem(i) = Calc::Lerp(a.GetElem(i), b.GetElem(i), t);
                        }
                }
 
                // change ops
 
                const _TYPE_C& operator += (const THIS_t& v2)
                {
                        for (int i = 0; i < _IQTY; i++)
                        {
                                RefElem(i) += v2.GetElem(i);
                        }
                        return *((_TYPE_C*)this);
                }
                const _TYPE_C& operator += (TYPE n)
                {
                        for (int i = 0; i < _IQTY; i++)
                        {
                                RefElem(i) += n;
                        }
                        return *((_TYPE_C*)this);
                }
                const _TYPE_C& operator -= (const THIS_t& v2) noexcept
                {
                        for (int i = 0; i < _IQTY; i++)
                        {
                                RefElem(i) -= v2.GetElem(i);
                        }
                        return *((_TYPE_C*)this);
                }
                const _TYPE_C& operator -= (TYPE n) noexcept
                {
                        for (int i = 0; i < _IQTY; i++)
                        {
                                RefElem(i) -= n;
                        }
                        return *((_TYPE_C*)this);
                }
                void DoScale(TYPE n) noexcept
                {
                        for (int i = 0; i < _IQTY; i++)
                        {
                                RefElem(i) *= n;
                        }
                }
                const _TYPE_C& operator *= (TYPE nScale) noexcept
                {
                        DoScale(nScale);
                        return *((_TYPE_C*)this);
                }
                const _TYPE_C& operator /= (TYPE nScale)
                {
                        ASSERT(nScale);
                        DoScale(((TYPE)1) / nScale);
                        return *((_TYPE_C*)this);
                }
                void DoMul(const THIS_t& v2) noexcept
                {
                        for (int i = 0; i < _IQTY; i++)
                        {
                                RefElem(i) *= v2.GetElem(i);
                        }
                }
                _TYPE_C& operator *= (const THIS_t& v2) noexcept
                {
                        DoMul(v2);
                        return *((_TYPE_C*)this);
                }
                void DoDiv(const THIS_t& v2)
                {
                        for (int i = 0; i < _IQTY; i++)
                        {
                                RefElem(i) /= v2.GetElem(i);
                        }
                }
                _TYPE_C& operator /= (const THIS_t& v2)
                {
                        DoDiv(v2);
                        return *((_TYPE_C*)this);
                }
 
        protected:
                cVecTC()        // only used as a base class. may have undefined/uninit data.
                {}
        };
 
        template<typename TYPE, int _IQTY>
        class GRAYLIB_LINK cVecT : public cVecTC<TYPE, _IQTY, cVecT<TYPE, _IQTY> >
        {
                typedef cVecT<TYPE, _IQTY> THIS_t;
                typedef cVecTC<TYPE, _IQTY, THIS_t> SUPER_t;
        public:
                TYPE m_a[_IQTY];
        };
 
#ifdef _MSC_VER
#pragma warning(disable:4201)   // nonstandard extension used : nameless struct / union
#endif
 
        template<typename TYPE = DVALUEDEF_t>
        class GRAYLIB_LINK cVecT2 : public cVecTC<TYPE, 2, cVecT2<TYPE> >
        {
 
        public:
                typedef cVecT2<TYPE> THIS_t;
                typedef cVecTC<TYPE, k_nDim, THIS_t> SUPER_t;
        
                union
                {
                        TYPE m_a[k_nDim];
                        struct { TYPE m_x, m_y; };
                        struct { TYPE x, y; };
                };
 
                cVecT2() noexcept
                {
                }
                cVecT2(const SUPER_t& v) noexcept
                {
                        ::memcpy(m_a, &v, sizeof(m_a));
                }
                cVecT2(const TYPE* pVals)
                {
                        ::memcpy(m_a, pVals, sizeof(m_a));
                }
                cVecT2(TYPE n0, TYPE n1) noexcept
                        : m_x(n0), m_y(n1)
                {
                }
 
                const TYPE& get_X() const noexcept
                {
                        return m_x;
                }
                const TYPE& get_Y() const noexcept
                {
                        return m_y;
                }
        };
        typedef cVecT2<float> cFloat2; // same as HLSL float2
 
        template <typename TYPE>
        inline cVecT2<TYPE> operator*(const TYPE nVal, const cVecT2<TYPE>& v2)
        {
                return v2*nVal;
        }
 
        template<typename TYPE = DVALUEDEF_t>
        class GRAYLIB_LINK cVecT3 : public cVecTC<TYPE, 3, cVecT3<TYPE> >
        {
 
        public:
                typedef cVecT3<TYPE> THIS_t;
                typedef cVecTC<TYPE, k_nDim, THIS_t> SUPER_t;
 
                union
                {
                        TYPE m_a[k_nDim];
                        struct { TYPE m_x, m_y, m_z; }; // point
                        struct { TYPE x, y, z; };               // vector
                        struct { TYPE r, g, b; };               // color (no alpha)
                        // struct { cVecT2<TYPE> m_v2; TYPE m_vz; };
                };
 
                cVecT3() noexcept
                {
                }
                cVecT3(const SUPER_t& v) noexcept
                {
                        ::memcpy(m_a, &v, sizeof(m_a));
                }
                cVecT3(const TYPE* pVals) noexcept
                {
                        if (pVals == nullptr)
                                return;
                        ::memcpy(m_a, pVals, sizeof(m_a));
                }
                cVecT3(TYPE n0, TYPE n1, TYPE n2 = 0) noexcept
                        : m_x(n0), m_y(n1), m_z(n2)
                {
                }
 
                TYPE get_X() const noexcept
                {
                        return m_x;
                }
                TYPE get_Y() const noexcept
                {
                        return m_y;
                }
                TYPE get_Z() const noexcept
                {
                        return m_z;
                }
 
                const cVecT2<TYPE>& get_V2() const noexcept
                {
                        return *reinterpret_cast<const cVecT2<TYPE>*>(m_a);
                }
                bool IsSame2D(const THIS_t& pt) const noexcept
                {
                        return m_x == pt.m_x && m_y == pt.m_y;
                }
 
                TYPE GetDist2DSq(TYPE nX, TYPE nY) const
                {
                        TYPE dx = nX - m_x;
                        TYPE dy = nY - m_y;
                        return(Calc::Sqr(dx) + Calc::Sqr(dy));
                }
                TYPE GetDist2DSq(const THIS_t& pt) const
                {
                        TYPE dx = pt.m_x - m_x;
                        TYPE dy = pt.m_y - m_y;
                        return(Calc::Sqr(dx) + Calc::Sqr(dy));
                }
 
                TYPE GetDist2D(const THIS_t& pt) const // 2D Distance between points
                {
                        return(Calc::Sqrt(GetDist2DSq(pt.m_x, pt.m_y)));
                }
 
                inline void InitCross(const THIS_t& rA, const THIS_t& rB)
                {
                        ASSERT(this != &rA);
                        ASSERT(this != &rB);
                        this->m_x = (rA.m_y * rB.m_z) - (rA.m_z * rB.m_y);
                        this->m_y = (rA.m_z * rB.m_x) - (rA.m_x * rB.m_z);
                        this->m_z = (rA.m_x * rB.m_y) - (rA.m_y * rB.m_x);
                }
                inline THIS_t GetCross(const THIS_t& rB) const
                {
                        THIS_t vRet;
                        vRet.InitCross(*this, rB);
                        return vRet;
                }
                static inline THIS_t GetCross(const THIS_t& rA, const THIS_t& rB)
                {
                        THIS_t vRet;
                        vRet.InitCross(rA, rB);
                        return vRet;
                }
#if 0
                inline THIS_t operator^(const THIS_t& v2) const
                {
                        return GetCross(v2);
                }
#endif
 
                void SetCross(const THIS_t& v2)
                {
                        THIS_t oThis = *this;
                        InitCross(oThis, v2);
                }
        };
        typedef cVecT3<float> cFloat3;  // same as HLSL float3
 
        template <typename TYPE>
        inline cVecT3<TYPE> operator*(const TYPE nVal, const cVecT3<TYPE>& v2)
        {
                return (v2*nVal);
        }
 
        template<typename TYPE = DVALUEDEF_t>
        class GRAYLIB_LINK cVecT4 : public cVecTC<TYPE, 4, cVecT4<TYPE> >
        {
 
                typedef cVecT4<TYPE> THIS_t;
                typedef cVecTC<TYPE, 4, THIS_t> SUPER_t;
        public:
                union
                {
                        TYPE m_a[4];
                        struct { TYPE m_x, m_y, m_z, m_w; };    // quaternion.
                        struct { TYPE x, y, z, w; };                    // quaternion.
                        struct { TYPE r, g, b, a; };                    // color D3DXCOLOR, cColorf
                        // struct { TYPE a,b,c,d; };    // plane
                        // struct { cVecT3<TYPE> m_v3; TYPE m_vw; }; // vector3d + distance = ray.
                };
 
                cVecT4() noexcept
                {
                }
                cVecT4(const SUPER_t& v) noexcept
                {
                        ::memcpy(m_a, &v, sizeof(m_a));
                }
                cVecT4(const TYPE* pVals) noexcept
                {
                        if (pVals == nullptr)
                                return;
                        ::memcpy(m_a, pVals, sizeof(m_a));
                }
                cVecT4(TYPE n0, TYPE n1, TYPE n2 = 0, TYPE n3 = 0) noexcept
                        : m_x(n0), m_y(n1), m_z(n2), m_w(n3)
                {
                }
                cVecT4(const cVecT3<TYPE>& v2, TYPE _w = 0)  
                        : m_x(v2.GetElem(0)), m_y(v2.GetElem(1)), m_z(v2.GetElem(2)), m_w(_w)
                {
                }
 
                const TYPE& get_X() const noexcept
                {
                        return m_x;
                }
                const TYPE& get_Y() const noexcept
                {
                        return m_y;
                }
                const TYPE& get_Z() const noexcept
                {
                        return m_z;
                }
                const TYPE& get_W() const noexcept
                {
                        return m_w;
                }
 
                const cVecT3<TYPE>& get_V3() const noexcept
                {
                        return *reinterpret_cast<const cVecT3<TYPE>*>(m_a);
                }
                cVecT3<TYPE>& ref_V3() noexcept
                {
                        return *reinterpret_cast<cVecT3<TYPE>*>(m_a);
                }
 
                inline void InitCross(const THIS_t& v1, const THIS_t& v2, const THIS_t& v3)
                {
                        this->x = v1.y * (v2.z * v3.w - v3.z * v2.w) - v1.z * (v2.y * v3.w - v3.y * v2.w) + v1.w * (v2.y * v3.z - v2.z *v3.y);
                        this->y = -(v1.x * (v2.z * v3.w - v3.z * v2.w) - v1.z * (v2.x * v3.w - v3.x * v2.w) + v1.w * (v2.x * v3.z - v3.x * v2.z));
                        this->z = v1.x * (v2.y * v3.w - v3.y * v2.w) - v1.y * (v2.x *v3.w - v3.x * v2.w) + v1.w * (v2.x * v3.y - v3.x * v2.y);
                        this->w = -(v1.x * (v2.y * v3.z - v3.y * v2.z) - v1.y * (v2.x * v3.z - v3.x *v2.z) + v1.z * (v2.x * v3.y - v3.x * v2.y));
                }
        };
        typedef cVecT4<float> cFloat4; // same as HLSL float4.
 
        template <typename TYPE>
        inline cVecT4<TYPE> operator*(const TYPE nVal, const cVecT4<TYPE>& v2)
        {
                return (v2*nVal);
        }
 
#ifdef GRAY_DLL // force implementation/instantiate for DLL/SO.
        template class GRAYLIB_LINK cVecT2<float>;
        template class GRAYLIB_LINK cVecTC<float, 2, cVecT2<float> >;
        template class GRAYLIB_LINK cVecT3<float>;
        template class GRAYLIB_LINK cVecTC<float, 3, cVecT3<float> >;
        template class GRAYLIB_LINK cVecT4<float>;
        template class GRAYLIB_LINK cVecTC<float, 4, cVecT4<float> >;
 
        template class GRAYLIB_LINK cVecT3<int>;
        template class GRAYLIB_LINK cVecTC<int, 2, cVecT2<int> >;
 
        template class GRAYLIB_LINK cVecT2<double>;
        template class GRAYLIB_LINK cVecTC<double, 2, cVecT2<double> >;
        template class GRAYLIB_LINK cVecT3<double>;
        template class GRAYLIB_LINK cVecTC<double, 3, cVecT3<double> >;
#endif
 
};
 
#endif // _INC_cVecT_H