cPlane.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cPlane_H
#define _INC_cPlane_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../Math/cVector.h"
#include "../Math/cMatrix.h"
 
namespace GrayLib
{
        class GRAYLIB_LINK cPlanef : public cVector4f
        {
 
                typedef cVector4f SUPER_t;
 
        public:
                enum REL_TYPE // like COMPARE_TYPE
                {
                        REL_BACK = -1,  
                        REL_PLANAR = 0, 
                        REL_FRONT = 1,  
                };
 
                cPlanef() : SUPER_t(0, 1, 0)
                {
                        RecalculateD(cVector3f(0, 0, 0));
                }
                cPlanef(const SUPER_t& v) noexcept : SUPER_t(v)
                {}
                cPlanef(const DVALUE_t* pVals) noexcept : SUPER_t(pVals)
                {}
                cPlanef(const cVector3f& vNormal, DVALUE_t fDistFromOrigin) : SUPER_t(vNormal, fDistFromOrigin)
                {
                }
                cPlanef(DVALUE_t a, DVALUE_t b, DVALUE_t c, DVALUE_t d) noexcept : SUPER_t(a, b, c, d)
                {}
 
                cPlanef(const cVector3f& v1, const cVector3f& v2, const cVector3f& v3)
                {
                        InitPlanePoints(v1, v2, v3);
                }
                cPlanef(const cVector3f& vPoint, const cVector3f& vNormal)
                {
                        InitPointNormal(vPoint, vNormal);
                }
 
#if defined(USE_DXM) || defined(USE_DX) // ASSUME DVALUE_t = float !!!
                // Cast directly to the DirectX equivalent type.
                cPlanef(const XMFLOAT4& v) : SUPER_t(v)
                {}
#endif
 
                // Init
 
                void InitPlane(const cVector3f& vNormal, float fDistFromOrigin)
                {
                        ref_Normal() = vNormal;
                        m_a[3] = fDistFromOrigin;
                }
                void InitPointNormal(const cVector3f& vPoint, const cVector3f& vNormal)
                {
                        // D3DXPlaneFromPointNormal or XMPlaneFromPointNormal
#ifdef USE_DXM
                        * this = ::XMPlaneFromPointNormal((XMVECTOR)vPoint, (XMVECTOR)vNormal);
#else
                        ref_Normal() = vNormal;
                        RecalculateD(vPoint);
#endif
                }
                void InitPointVector(const cVector3f& vPoint, const cVector3f& vVector)
                {
                        InitPointNormal(vPoint, vVector.get_Normalized());
                }
 
                void InitPlanePoints(const cVector3f& v1, const cVector3f& v2, const cVector3f& v3)
                {
#ifdef USE_DXM
                        ::D3DXPlaneFromPoints((D3DXPLANE*)this, (XMFLOAT3*)&v1, (XMFLOAT3*)&v2, (XMFLOAT3*)&v3);
#else
                        cVector3f vEdge1 = v2 - v1;
                        cVector3f vEdge2 = v3 - v1;
                        cVector3f vNormal1 = vEdge1.GetCross(vEdge2);
                        cVector3f vNormalN = vNormal1.get_Normalized();
                        InitPointNormal(v1, vNormalN);
#endif
                }
                void InitTransformPlane(const cPlanef& plane, const cMatrix4x4f& m1)
                {
#ifdef USE_DXM
                        ::D3DXPlaneTransform((D3DXPLANE*)this, (D3DXPLANE*)&plane, (const XMFLOAT4X4*)&m1);
#else
                        this->m_x = m1.m[0][0] * plane.m_x + m1.m[1][0] * plane.m_y + m1.m[2][0] * plane.m_z + m1.m[3][0] * plane.w;
                        this->m_y = m1.m[0][1] * plane.m_x + m1.m[1][1] * plane.m_y + m1.m[2][1] * plane.m_z + m1.m[3][1] * plane.w;
                        this->m_z = m1.m[0][2] * plane.m_x + m1.m[1][2] * plane.m_y + m1.m[2][2] * plane.m_z + m1.m[3][2] * plane.w;
                        this->m_w = m1.m[0][3] * plane.m_x + m1.m[1][3] * plane.m_y + m1.m[2][3] * plane.m_z + m1.m[3][3] * plane.w;
#endif
                }
                void InitNormalized(const cPlanef& plane)
                {
#ifdef USE_DXM
                        ::D3DXPlaneNormalize((D3DXPLANE*)this, (const D3DXPLANE*)&plane);
#else
                        float nNorm = plane.get_Normal().get_Magnitude(); // [3] ??
                        if (nNorm != 0)
                        {
                                Set(plane.GetScaled(1 / nNorm));
                        }
                        else
                        {
                                SetZero();
                        }
#endif
                }
 
                const cVector3f& get_Normal() const noexcept
                {
                        return (const cVector3f&)get_V3();
                }
                DVALUE_t get_DistFromOrigin() const noexcept
                {
                        return m_a[3];
                }
                cVector3f get_MemberPoint() const noexcept
                {
                        return get_Normal() * -get_DistFromOrigin();
                }
 
                inline DVALUE_t GetDotCoord(const cVector3f& v) const
                {
#ifdef USE_DXM
                        return ::D3DXPlaneDotCoord((D3DXPLANE*)this, (XMFLOAT3*)&v);
#else
                        return get_Normal().GetDot(v) + m_a[3] ;
#endif
                }
                inline cPlanef GetTransformPlane(const cMatrix4x4f& m1) const
                {
                        cPlanef planeRet;
                        planeRet.InitTransformPlane(*this, m1);
                        return planeRet;
                }
                cPlanef get_Normalized() const
                {
                        cPlanef planeRet;
                        planeRet.InitNormalized(*this);
                        return planeRet;
                }
 
                bool IsFrontFacing(const cVector3f& vLookDir) const
                {
                        return(get_Normal().GetDot(vLookDir) <= 0.0f);
                }
 
                float GetDistanceTo(const cVector3f& vPoint) const
                {
                        return vPoint.GetDot(get_Normal()) + get_DistFromOrigin();
                }
 
                REL_TYPE GetPointRelation(const cVector3f& vPoint) const
                {
 
                        float d = get_Normal().GetDot(vPoint) + get_DistFromOrigin();
                        if (d < -k_FLT_MIN2)
                                return REL_FRONT;
                        if (d > k_FLT_MIN2)
                                return REL_BACK;
                        return REL_PLANAR;
                }
 
                // Modify
 
                cVector3f& ref_Normal()
                {
                        return (cVector3f&)ref_V3();
                }
                void RecalculateD(const cVector3f& vMember)
                {
                        m_a[3] = -vMember.GetDot(get_Normal());
                }
                void SetNormalized()
                {
                        InitNormalized(*this);
                }
                void TransformNormals(const cMatrix4x4f& m)
                {
                        ref_Normal() = get_Normal().GetTransNorm(m);
                        // leave a.w;
                }
 
#if 0
                bool GetIntersectionWithPlane(const cPlanef& rPlane2, cVector3f& outLinePoint, cVector3f& outLineVect) const
                {
 
                        float fn00 = m_vNormal.get_Magnitude();
                        float fn01 = m_vNormal.GetDot(rPlane2.m_vNormal);
                        float fn11 = rPlane2.m_vNormal.get_Magnitude();
                        float det = fn00 * fn11 - fn01 * fn01;
 
                        if (CalcI::Abs(det) < 1e-08f)
                                return false;
 
                        det = 1.0f / det;
                        float fc0 = (fn11 * -m_D + fn01 * rPlane2.m_D) * det;
                        float fc1 = (fn00 * -rPlane2.m_D + fn01 * m_D) * det;
 
                        outLineVect = m_vNormal.GetCross(rPlane2.m_vNormal);
                        outLinePoint = m_vNormal * fc0 + rPlane2.m_vNormal * fc1;
                        return true;
                }
#endif
 
                UNITTEST_FRIEND(cPlane);
        };
}
#endif // _INC_cPlanef_H