F:/My Projects/LSEngine/Modules/LSPhysicsLib/Src/Intersections/LSPClassify.h

#ifndef __LSP_CLASSIFY_H__
#define __LSP_CLASSIFY_H__

#include "../LSPPhysicsLib.h"
#include "../BoundingBoxes/LSPAabb.h"
#include "Plane/LSMPlane3.h"

namespace lsp {

        class CClassify {
                // All is public.  This class has no secrets.
        public :
                // == Functions.
                static LSE_INLINE LSM_PLANE_INTERSECT LSE_CALL                          Aabb( const CAabb &_aAabb, const CPlane3 &_pPlane );

                template <typename _tType, typename _tVec3Type, typename _tPlane3Type>
                static LSE_INLINE LSM_PLANE_INTERSECT LSE_CALL                          Point( const _tVec3Type &_vPoint, const _tPlane3Type &_pPlane, _tType _fThickness = static_cast<_tType>(LSM_PLANE_THICKNESS) ) {
                        _tType fDist = (_pPlane.n * _vPoint) - _pPlane.dist;
                        if ( fDist > _fThickness ) { return LSM_PI_FRONT; }
                        if ( fDist < -_fThickness ) { return LSM_PI_BACK; }
                        return LSM_PI_COPLANAR;
                }

                template <typename _tType, typename _tPoly3Type, typename _tPlane3Type>
                static LSE_INLINE LSM_PLANE_INTERSECT LSE_CALL                          Polygon( const _tPoly3Type &_pPoly, const _tPlane3Type &_pPlane, _tType _fThickness = static_cast<_tType>(LSM_PLANE_THICKNESS) ) {
                        LSUINT32 ui32Front = 0UL, ui32Back = 0UL;

                        // Easy as pie.  Loop over vertices and determine if all are on one side or not.
                        for ( LSUINT32 I = _pPoly.TotalSegments(); I--; ) {
                                switch ( Point<_tType>( _pPoly[I]->p, _pPlane, _fThickness ) ) {
                                        case LSM_PI_FRONT : {
                                                // This one is in front.  If any are in back then we are straddling.
                                                if ( ui32Back ) { return LSM_PI_INTERSECT; }
                                                ++ui32Front;
                                                break;
                                        }
                                        case LSM_PI_BACK : {
                                                // This one is in back.  If any are in front then we are straddling.
                                                if ( ui32Front ) { return LSM_PI_INTERSECT; }
                                                ++ui32Back;
                                                break;
                                        }
                                }
                        }
                        // We are not straddling.  Then we must be fully in front, fully behind, or coplanar.
                        if ( ui32Front ) { return LSM_PI_FRONT; }
                        return ui32Back ? LSM_PI_BACK : LSM_PI_COPLANAR;
                }

        };


        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // DEFINITIONS
        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // == Functions.
        LSE_INLINE LSM_PLANE_INTERSECT LSE_CALL CClassify::Aabb( const CAabb &_aAabb, const CPlane3 &_pPlane ) {
                // Center of the AABB.
                CVector3 vC = (_aAabb.m_vMax + _aAabb.m_vMin) * LSM_HALF;
                // Positive extents.
                CVector3 vE = _aAabb.m_vMax - vC;

                // Compute the projected interval radius of _aAabb onto L(t) = _aAabb.c + t * _pPlane.n.
                LSREAL fR = vE[0] * CMathLib::Abs( _pPlane.n[0] ) +
                        vE[1] * CMathLib::Abs( _pPlane.n[1] ) +
                        vE[2] * CMathLib::Abs( _pPlane.n[2] );

                // Distance from box center to plane.
                LSREAL fS = _pPlane.n.Dot( vC ) - _pPlane.dist;

                // If less than R, return overlap.
                if ( CMathLib::Abs( fS ) <= fR ) { return LSM_PI_INTERSECT; }
                // Otherwise it is in front or back of the plane.
                return fS > fR ? LSM_PI_FRONT : LSM_PI_BACK;
        }

}       // namespace lsp

#endif  // __LSP_CLASSIFY_H__