cTriangle3.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cTriangle3_H
#define _INC_cTriangle3_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cBounds3.h"
#include "cPlane.h"
#include "cCylinder.h"
#include "../Math/cFloatEst.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cTriangle3);
 
        class GRAYLIB_LINK cTriangle3f
        {
 
        public:
                typedef float DVALUE_t;         
                cVector3f m_aPt[3];             
 
        public:
                cTriangle3f() noexcept
                {
                }
                cTriangle3f(const cVector3f* p)  
                {
                        m_aPt[0] = p[0];
                        m_aPt[1] = p[1];
                        m_aPt[2] = p[2];
                }
                cTriangle3f(const cVector3f& a, const cVector3f& b, const cVector3f& c) noexcept
                {
                        m_aPt[0] = a;
                        m_aPt[1] = b;
                        m_aPt[2] = c;
                }
 
                bool operator==(const cTriangle3f& other) const noexcept
                {
                        return other.m_aPt[0] == m_aPt[0] && other.m_aPt[1] == m_aPt[1] && other.m_aPt[2] == m_aPt[2];
                }
                bool operator!=(const cTriangle3f& other) const noexcept
                {
                        return other.m_aPt[0] != m_aPt[0] || other.m_aPt[1] != m_aPt[1] || other.m_aPt[2] != m_aPt[2];
                }
 
                bool isDegenerate() const noexcept
                {
                        if (m_aPt[1] == m_aPt[0])
                                return true;
                        if (m_aPt[2] == m_aPt[0])
                                return true;
                        if (m_aPt[2] == m_aPt[1])
                                return true;
                        return false;
                }
 
                cPlanef get_Plane() const
                {
                        return cPlanef(m_aPt[0], m_aPt[1], m_aPt[2]);
                }
                cVector3f get_Normal() const
                {
                        cVector3f v1 = m_aPt[1] - m_aPt[0];
                        cVector3f v2 = m_aPt[2] - m_aPt[0];
                        return v1.GetCross(v2);
                }
                cVector3f get_Center() const
                {
                        cVector3f vCenter(
                                (m_aPt[0].x + m_aPt[1].x + m_aPt[2].x) / 3.0f,
                                (m_aPt[0].y + m_aPt[1].y + m_aPt[2].y) / 3.0f,
                                (m_aPt[0].z + m_aPt[1].z + m_aPt[2].z) / 3.0f
                                );
                        return vCenter;
                }
 
                bool isFrontFacing(const cVector3f& vLookDir) const
                {
                        cVector3f vNorm = get_Normal();
                        vNorm.SetNormalized();
                        return vNorm.GetDot(vLookDir) <= 0.0f;
                }
 
                bool isPointInside(const cVector3f& p) const
                {
                        return (isOnSameSide(p, m_aPt[0], m_aPt[1], m_aPt[2]) &&
                                isOnSameSide(p, m_aPt[1], m_aPt[0], m_aPt[2]) &&
                                isOnSameSide(p, m_aPt[2], m_aPt[0], m_aPt[1]));
                }
 
#ifdef USE_FLOAT_IEEE
                bool isPointInsideFast(const cVector3f& p) const
                {
 
                        cVector3f f = m_aPt[1] - m_aPt[0];
                        cVector3f g = m_aPt[2] - m_aPt[0];
 
                        DVALUE_t a = f.GetDot(f);
                        DVALUE_t b = f.GetDot(g);
                        DVALUE_t c = g.GetDot(g);
 
                        DVALUE_t ac_bb = (a*c) - (b*b);
                        cVector3f vp = p - m_aPt[0];
 
                        DVALUE_t d = vp.GetDot(f);
                        DVALUE_t e = vp.GetDot(g);
                        DVALUE_t x = (d*c) - (e*b);
                        DVALUE_t y = (e*a) - (d*b);
                        DVALUE_t z = x + y - ac_bb;
 
                        return ((cFloat32::toBits(z)& ~(cFloat32::toBits(x) | cFloat32::toBits(y))) & cFloat32::k_SIGN_MASK);
                }
#else
                bool isPointInsideFast(const cVector3f& p) const
                {
                        return isPointInside(p);
                }
#endif
 
                bool isOnSameSide(const cVector3f& p1, const cVector3f& p2, const cVector3f& a, const cVector3f& b) const
                {
                        cVector3f bminusa = b - a;
                        cVector3f vTmp1 = p1 - a;
                        cVector3f cp1;
                        cp1 = bminusa.GetCross(vTmp1);
                        cVector3f vTmp2 = p2 - a;
                        cVector3f cp2;
                        cp2 = bminusa.GetCross(vTmp2);
                        return (cp1.GetDot(cp2) > 0.0f);
                }
 
                bool getIntersectionOfPlaneWithLine(const cVector3f& linePoint, const cVector3f& lineVect, cVector3f& outIntersection) const
                {
 
                        cVector3f normal = get_Normal();
                        DVALUE_t t2 = normal.GetDot(lineVect);
                        if (t2 == 0.0f)
                                return false;
 
                        DVALUE_t d = m_aPt[0].GetDot(normal);
                        DVALUE_t t = -(normal.GetDot(linePoint) - d) / t2;
                        outIntersection = linePoint + (lineVect * t);
                        return true;
                }
 
                bool getIntersectionWithLine(const cVector3f& linePoint, const cVector3f& lineVect, cVector3f& outIntersection) const
                {
 
                        if (!getIntersectionOfPlaneWithLine(linePoint, lineVect, outIntersection))
                                return false;
                        return isPointInside(outIntersection);
                }
 
                cVector3f GetBaryCentric(DVALUE_t f, DVALUE_t g) const
                {
                        cVector3f vPos;
#ifdef USE_DXM
                        ::D3DXVec3BaryCentric((XMFLOAT3*)&vPos, (XMFLOAT3*)&m_aPt[0], (XMFLOAT3*)&m_aPt[1], (XMFLOAT3*)&m_aPt[2], f, g);
#else
                        vPos.x = (1.0f - f - g) * (m_aPt[0].x) + f * (m_aPt[1].x) + g * (m_aPt[2].x);
                        vPos.y = (1.0f - f - g) * (m_aPt[0].y) + f * (m_aPt[1].y) + g * (m_aPt[2].y);
                        vPos.z = (1.0f - f - g) * (m_aPt[0].z) + f * (m_aPt[1].z) + g * (m_aPt[2].z);
#endif
                        return vPos;
                }
 
                // Setters
                void setTri(const cVector3f* p)
                {
                        m_aPt[0] = p[0];
                        m_aPt[1] = p[1];
                        m_aPt[2] = p[2];
                }
                void setTri(const cVector3f& a, const cVector3f& b, const cVector3f& c)
                {
                        m_aPt[0] = a;
                        m_aPt[1] = b;
                        m_aPt[2] = c;
                }
 
                void TransformCoords(const cMatrix4x4f& mMatrix)
                {
                        for (int i = 0; i < 3; i++)
                        {
                                m_aPt[i] = m_aPt[i].GetProj(mMatrix);
                        }
                }
                void MultV(const cVector3f vMult)
                {
                        for (int i = 0; i < 3; i++)
                        {
                                m_aPt[i] *= vMult;
                        }
                }
                void DivV(const cVector3f vMult)
                {
                        for (int i = 0; i < 3; i++)
                        {
                                m_aPt[i] /= vMult;
                        }
                }
 
                UNITTEST_FRIEND(cTriangle3);
        };
}
#endif // _INC_cTriangle3_H