F:/My Projects/LSEngine/Modules/LSPhysicsLib/Src/Misc/LSPPhysUtils.h

#ifndef __LSP_PHYSUTILS_H__
#define __LSP_PHYSUTILS_H__

#include "../LSPPhysicsLib.h"
#include "../BoundingBoxes/LSPObb.h"
#include "../Intersections/LSPClassify.h"
#include "../Intersections/LSPIntersect.h"
#include "Frustum/LSMFrustum.h"
#include "Matrix/LSMMatrix3x3.h"
#include "Plane/LSMPlane3.h"
#include "Sphere/LSMSphere.h"
#include "Vector/LSMVector3.h"
#include "Vector/LSTLVector.h"

namespace lsp {

        class CPhysUtils {
                // All is public.  This class has no secrets.
        public :
                // == Functions.
                static LSVOID LSE_CALL                          ExtremePointsAlongDirection( const CVector3 &_vDir, const CVector3 * _pvPoints,
                        LSUINT32 _ui32TotalPoints, LSUINT32 &_ui32Min, LSUINT32 &_ui32Max );

                static LSVOID LSE_CALL                          ExtremeValuesAlongDirection( const CVector3 &_vDir, const CVector3 * _pvPoints,
                        LSUINT32 _ui32TotalPoints, LSREAL &_fMin, LSREAL &_fMax );

                static CSphere & LSE_CALL                       SphereOfSphereAndPoint( CSphere &_sSphere, const CVector3 &_vPoint );

                static LSVOID LSE_CALL                          SymSchur2( const CMatrix3x3 &_mMat, LSINT32 _i32P, LSINT32 _i32Q,
                        LSREALHP &_fCos, LSREALHP &_fSin );

                static LSVOID LSE_CALL                          Jacobi( CMatrix3x3 &_mA, CMatrix3x3 &_mV );

                static CSphere LSE_CALL                         EigenSphere( const CVector3 * _pvPoints, LSUINT32 _ui32TotalPoints );

                static CSphere LSE_CALL                         RitterEigenSphere( const CVector3 * _pvPoints, LSUINT32 _ui32TotalPoints );

                static LSVOID LSE_CALL                          FrustumCorners( const CFrustum &_fFrustum, CVector3 _vRet[8] );

                static CVector3 LSE_CALL                        MajorAxis( const CVector3 &_vVector );

                template <typename _tType, typename _tVecType, typename _tPolyType, typename _tPlaneType>
                static LSVOID LSE_CALL                          Split( const _tPolyType &_pPoly, const _tPlaneType &_pPlane,
                        LSUINT32 * _pui32LeftSides, _tPolyType * _ppLeftRet,
                        LSUINT32 * _pui32RightSides, _tPolyType * _ppRightRet,
                        _tType _fThickness = static_cast<_tType>(LSM_PLANE_THICKNESS) ) {
                        // No way to split a polygon with fewer than 3 vertices.
                        assert( _pPoly.TotalSegments() >= 3UL );

                        LSUINT32 ui32FrontCount = 0UL;
                        LSUINT32 ui32BackCount = 0UL;

                        _tVecType vA = _pPoly[_pPoly.TotalSegments()-1]->p;
                        LSM_PLANE_INTERSECT piSide = CClassify::Point<_tType, _tVecType, _tPlaneType>( vA, _pPlane, _fThickness );
                        LSUINT32 ui32Total = _pPoly.TotalSegments();

                        _tVecType vSplitPoint;
#define LSP_PUSHFRONT( VEC )    if ( _ppLeftRet ) { (*_ppLeftRet).Segments()[ui32FrontCount].p = VEC; } ++ui32FrontCount
#define LSP_PUSHBACK( VEC )             if ( _ppRightRet ) { (*_ppRightRet).Segments()[ui32BackCount].p = VEC; } ++ui32BackCount

                        // Run over all edges of the polygon.
                        for ( LSUINT32 N = 0; N < ui32Total; ++N ) {
                                _tVecType vB = _pPoly[N]->p;
                                LSM_PLANE_INTERSECT piSide2 = CClassify::Point<_tType>( vB, _pPlane, _fThickness );
                                switch ( piSide2 ) {
                                        case LSM_PI_FRONT : {
                                                if ( piSide == LSM_PI_BACK ) {
                                                        // Edge (A, B) crosses plane.
                                                        CIntersect::LineSegPlaneFast<_tType, _tVecType, _tPlaneType>( vB, vA, _pPlane, vSplitPoint );
                                                        LSP_PUSHFRONT( vSplitPoint );
                                                        //if ( !vFrontVerts.Push( vSplitPoint ) ) { return false; }

                                                        LSP_PUSHBACK( vSplitPoint );
                                                        //if ( !vBackVerts.Push( vSplitPoint ) ) { return false; }
                                                }
                                                // Always put B on the front side.
                                                LSP_PUSHFRONT( vB );
                                                //if ( !vFrontVerts.Push( vB ) ) { return false; }
                                                break;
                                        }
                                        case LSM_PI_BACK : {
                                                if ( piSide == LSM_PI_FRONT ) {
                                                        // Edge (A, B) crosses plane.
                                                        CIntersect::LineSegPlaneFast<_tType, _tVecType, _tPlaneType>( vA, vB, _pPlane, vSplitPoint );
                                                        LSP_PUSHFRONT( vSplitPoint );
                                                        //if ( !vFrontVerts.Push( vSplitPoint ) ) { return false; }

                                                        LSP_PUSHBACK( vSplitPoint );
                                                        //if ( !vBackVerts.Push( vSplitPoint ) ) { return false; }
                                                }
                                                else if ( piSide == LSM_PI_COPLANAR ) {
                                                        // Output A when edge goes from on to behind the plane.
                                                        LSP_PUSHBACK( vA );
                                                        //if ( !vBackVerts.Push( vA ) ) { return false; }
                                                }
                                                // Always put B on the back side.
                                                LSP_PUSHBACK( vB );
                                                //if ( !vBackVerts.Push( vB ) ) { return false; }
                                                break;
                                        }
                                        default : {
                                                // B is on the plane.  Always pass it to the front side.
                                                LSP_PUSHFRONT( vB );
                                                //if ( !vFrontVerts.Push( vB ) ) { return false; }
                                                // If A is behind the plane, also put B on the back side.
                                                if ( piSide == LSM_PI_BACK ) {
                                                        LSP_PUSHBACK( vB );
                                                        //if ( !vBackVerts.Push( vB ) ) { return false; }
                                                }
                                        }
                                }

                                // Next edge will be from B to the next.
                                vA = vB;
                                piSide = piSide2;
                        }
#undef LSP_PUSHBACK
#undef LSP_PUSHFRONT

                        if ( _pui32LeftSides ) {
                                (*_pui32LeftSides) = ui32FrontCount;
                        }
                        if ( _pui32RightSides ) {
                                (*_pui32RightSides) = ui32BackCount;
                        }
                        if ( _ppLeftRet ) {
                                for ( LSUINT32 I = ui32FrontCount; I--; ) {
                                        (*_ppLeftRet)[I]->q = (*_ppLeftRet)[(I+1)%ui32FrontCount]->p;
                                }
                                (*_ppLeftRet).Plane() = _pPoly.Plane();
                                (*_ppLeftRet).SetUser( _pPoly.GetUser() );
                        }
                        if ( _ppRightRet ) {
                                for ( LSUINT32 I = ui32BackCount; I--; ) {
                                        (*_ppRightRet)[I]->q = (*_ppRightRet)[(I+1)%ui32BackCount]->p;
                                }
                                (*_ppRightRet).Plane() = _pPoly.Plane();
                                (*_ppRightRet).SetUser( _pPoly.GetUser() );
                        }
                }

                /*template <typename _tType, typename _tVecType, typename _tPolyType, typename _tPlaneType>
                static LSVOID LSE_CALL                          Carve( const _tPolyType &_pPoly, const _tPolyType &_pSplitterPoly,
                        LSUINT32 * _pui32LeftSides, _tPolyType * _ppLeftRet,
                        _tType _fThickness = static_cast<_tType>(LSM_PLANE_THICKNESS) ) {
                }*/


        protected :
                // == Members.
        };


        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // DEFINITIONS
        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

}       // namespace lsp

#endif  // __LSP_PHYSUTILS_H__