cVector.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cVector_H
#define _INC_cVector_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "MathDX.h"
#include "Calc.h"
#include "cVecT.h"
#include "GrayCore/include/cHeap.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cVector);
 
        class GRAYLIB_LINK cMatrix4x4f;
 
        enum AXIS_TYPE
        {
                AXIS_X = 0,
                AXIS_Y,
                AXIS_Z,
                AXIS_Trans,     
                AXIS_QTY
        };
 
        class GRAYLIB_LINK cVector2f : public cVecT2<DVALUEDEF_t>
        {
 
                typedef cVecT2<DVALUE_t> SUPER_t;
                typedef cVector2f THIS_t;
 
        public:
                cVector2f() noexcept
                {
                        // ASSUME XMFLOAT2 is un-init
                }
                cVector2f(const SUPER_t& v2) noexcept
                : cVecT2<DVALUE_t>(v2)
                {}
                cVector2f(DVALUE_t _x, DVALUE_t _y) noexcept
                : cVecT2<DVALUE_t>(_x, _y)
                {}
 
#ifdef _WIN32
                // Cast directly to the DirectX equiv type.
                cVector2f(const XMFLOAT2& v) noexcept
                : cVecT2<DVALUE_t>(*reinterpret_cast<const SUPER_t*>(&v))
                {}
 
                inline operator XMFLOAT2&() noexcept
                {
                        return *reinterpret_cast<XMFLOAT2*>(this);
                }
                inline operator const XMFLOAT2&() const noexcept
                {
                        return *reinterpret_cast<const XMFLOAT2*>(this);
                }
 
                inline operator XMFLOAT2*() noexcept
                {
                        return (XMFLOAT2*) this;
                }
                inline operator const XMFLOAT2*() const noexcept
                {
                        return (const XMFLOAT2*) this;
                }
 
                const XMFLOAT4* get_X4() const noexcept
                {
                        return (const XMFLOAT4*) this; // DANGER to SMALL!!
                }
#endif
 
                THIS_t GetProj(const cMatrix4x4f& M) const;
 
                static const cVector2f k_vZero;
                static const cVector2f k_vOne;
        };
 
        typedef cVecT2<double> cVector2d;
 
        class GRAYLIB_LINK cVector3f : public cVecT3<DVALUEDEF_t>
        {
 
                typedef cVecT3<DVALUE_t> SUPER_t;
                typedef cVector3f THIS_t;
 
        public:
 
                static const cVector3f k_vZero;
                static const cVector3f k_vOne;
                static const cVector3f k_vXAxis;
                static const cVector3f k_vYAxis;
                static const cVector3f k_vZAxis;
 
                cVector3f() noexcept
                {
                        // ASSUME XMFLOAT3 is un-init
                }
                cVector3f(const SUPER_t& v) noexcept
                : cVecT3<DVALUE_t>(v)
                {}
                cVector3f(DVALUE_t _x, DVALUE_t _y, DVALUE_t _z) noexcept
                : cVecT3<DVALUE_t>(_x, _y, _z)
                {}
 
#ifdef _WIN32
                // Cast directly to the DirectX equiv type.
                cVector3f(const XMFLOAT3& v)
                : cVecT3<DVALUE_t>(*(const SUPER_t*)&v)
                {}
 
                inline operator XMFLOAT3&()
                {
                        return *((XMFLOAT3*)this);
                }
                inline operator const XMFLOAT3&() const
                {
                        return *((const XMFLOAT3*)this);
                }
 
                inline operator XMFLOAT3*()
                {
                        return (XMFLOAT3*) this;
                }
                inline operator const XMFLOAT3*() const
                {
                        return (const XMFLOAT3*) this;
                }
 
                const XMFLOAT4* get_X4() const
                {
                        return (const XMFLOAT4*) this; // DANGER to SMALL!!
                }
 
                inline DVALUE_t operator[] (int i) const        // should be a UINT version ??
                {
                        return GetElem(i);
                }
                inline DVALUE_t& operator[] (int i)     // should be a UINT version ??
                {
                        return RefElem(i);
                }
#endif
#ifdef USE_DXM
                cVector3f(const XMVECTOR& v)
                {
                        ::XMStoreFloat3((XMFLOAT3*)this, v);
                }
                inline void Set(const XMVECTOR& v)
                {
                        ::XMStoreFloat3((XMFLOAT3*)this, v);
                }
                inline operator XMVECTOR () const
                {
                        return ::XMLoadFloat3((const XMFLOAT3*)this);
                }
#endif
 
                // const tests.
 
                DVALUE_t GetMinAxis(const THIS_t& v2, DVALUE_t fDistMin = k_FLT_MIN2) const
                {
                        DVALUE_t fd = CalcI::Abs(x - v2.x);
                        if (fd > fDistMin)
                                return fd;
                        fd = CalcI::Abs(y - v2.y);
                        if (fd > fDistMin)
                                return fd;
                        fd = CalcI::Abs(z - v2.z);
                        if (fd > fDistMin)
                                return fd;
                        return 0;
                }
 
                bool IsNearHeight(const THIS_t& v2, DVALUE_t fDist = k_FLT_MIN2) const
                {
                        if (!CalcI::IsNear(y, v2.y, fDist))
                                return false;
                        return true;
                }
                bool IsNearXZ(const THIS_t& v2, DVALUE_t fDist = k_FLT_MIN2) const
                {
                        if (!CalcI::IsNear(x, v2.x, fDist))
                                return false;
                        if (!CalcI::IsNear(z, v2.z, fDist))
                                return false;
                        return true;
                }
                DVALUE_t GetDistXZ(const THIS_t& v2) const
                {
                        return Calc::Sqrt(Calc::Sqr(v2.x) + Calc::Sqr(v2.z));
                }
 
                // ----------------------------- HLSL - conformal math goes there
                // Named modifiers (e.g. normalize) here as methods only for MODIFIERS
                // non-modifier named operators (Normalized) implemented as global funcs later
                // that is due to better equation readability and consistency
 
                THIS_t GetProj(const cMatrix4x4f& M) const;
                THIS_t GetProj2(const cMatrix4x4f& M) const;
                THIS_t GetTransNorm(const cMatrix4x4f& M) const;
                THIS_t GetTransNorm2(const cMatrix4x4f& M) const;
 
                THIS_t GetVectorToTarget(const cVector3f& vTarget) const
                {
                        THIS_t v = vTarget - *this;
                        v.SetNormalized();
                        return v;
                }
 
                DVALUE_t GetDistSeg(const THIS_t& v1, const THIS_t& v2) const;
                RADIANf_t GetEulerHeading(const THIS_t& v2) const;
 
                // Change this operators.
 
                void SetMin()
                {
                        m_x = -k_FLT_MAX2; m_y = -k_FLT_MAX2; m_z = -k_FLT_MAX2;
                }
                void SetMax()
                {
                        m_x = k_FLT_MAX2; m_y = k_FLT_MAX2; m_z = k_FLT_MAX2;
                }
 
                //  aliases (most are legacy HLSL)
 
                void SetEulerWrapSigned();
 
                static RADIANf_t GRAYCALL GetVectorAngle(const THIS_t& v1, const THIS_t& v2);
                static RADIANf_t GRAYCALL GetVectorAngleN(const THIS_t& lv1, const THIS_t& lv2); // assumed normalized
 
                UNITTEST2_PREDEF(cVector );
        };
 
        typedef cVecT3<double> cVector3d;
 
        class cVector4f : public cVecT4<float>
        {
 
                typedef cVector4f THIS_t;
                typedef cVecT4<DVALUE_t> SUPER_t;
        public:
                cVector4f()
                {
                }
                cVector4f(const DVALUE_t* pVals) : SUPER_t(pVals)
                {}
                cVector4f(const SUPER_t& v)
                : SUPER_t(v)
                {}
                cVector4f(DVALUE_t _x, DVALUE_t _y, DVALUE_t _z = 0, DVALUE_t _w = 0) noexcept
                : SUPER_t(_x, _y, _z, _w)
                {}
                cVector4f(const cVecT3<DVALUE_t>& v, DVALUE_t w)
                : SUPER_t(v, w)
                {}
 
#if defined(USE_DXM) || defined(USE_DX) // ASSUME DVALUE_t = float !!!
                // Cast directly to the DirectX equiv type.
                cVector4f(const XMFLOAT4& v) : SUPER_t(*(const SUPER_t*)&v)
                {}
 
                inline operator XMFLOAT4&()
                {
                        return *((XMFLOAT4*)this);
                }
                inline operator const XMFLOAT4&() const
                {
                        return *((const XMFLOAT4*)this);
                }
                inline operator XMFLOAT4*()
                {
                        return (XMFLOAT4*) this;
                }
                inline operator const XMFLOAT4*() const
                {
                        return (const XMFLOAT4*) this;
                }
#endif
 
#ifdef USE_DXM
                cVector4f(const XMVECTOR& v)
                {
                        ::XMStoreFloat4((XMFLOAT4*)this, v);
                }
                inline void Set(const XMVECTOR& v)
                {
                        ::XMStoreFloat4((XMFLOAT4*)this, v);
                }
                inline operator XMVECTOR () const
                {
                        return ::XMLoadFloat4((const XMFLOAT4*)this);
                }
#endif
 
                inline void InitCross4(const cVector4f& v1, const cVector4f& v2, const cVector4f& v3)
                {
#ifdef USE_DXM
                        *this = ::XMVector4Cross((XMVECTOR)v1, (XMVECTOR)v2, (XMVECTOR)v3);
#else
                        SUPER_t::InitCross(v1, v2, v3);
#endif
                }
        };
 
#ifdef _WIN32
        // Freely convert from one type to another.
        inline cVector3f& Cvt(XMFLOAT3& v)
        {
                return *((cVector3f*)&v);
        }
        inline const cVector3f& Cvt(const XMFLOAT3& v)
        {
                return *((const cVector3f*)&v);
        }
#endif
 
}
#endif // _INC_cVector_H