F:/My Projects/LSEngine/Modules/LSMathLib/Src/Plane/LSMPlane3Base.h

#ifndef __LSE_PLANE3BASE_H__
#define __LSE_PLANE3BASE_H__

#include "../LSMMathLib.h"

namespace lsm {

        // == Enumerations.
        enum LSM_PLANE_INTERSECT {
                LSM_PI_FRONT,
                LSM_PI_BACK,
                LSM_PI_INTERSECT,
                LSM_PI_STRADDLING,
                LSM_PI_COPLANAR,
        };

        template <typename _tType, typename _tVec3Type>
        class CPlane3Base {
                // All is public.  This class has no secrets.
        public :
                // == Various constructors.
                LSE_INLINE LSE_CALLCTOR                         CPlane3Base() {
                }
                LSE_INLINE LSE_CALLCTOR                         CPlane3Base( const CPlane3Base<_tType, _tVec3Type> &_pPlane ) {
                        (*this) = _pPlane;
                }
                LSE_INLINE LSE_CALLCTOR                         CPlane3Base( const _tVec3Type &_vPoint0, const _tVec3Type &_vPoint1, const _tVec3Type &_vPoint2 ) {
                        n = (_vPoint1 - _vPoint0) % (_vPoint2 - _vPoint0);
                        n.Normalize();
                        dist = n.Dot( _vPoint0 );
                }
                LSE_INLINE LSE_CALLCTOR                         CPlane3Base( const _tVec3Type &_vNormal, _tType _fDistance ) {
                        n = _vNormal;
                        dist = _fDistance;
                }
                LSE_INLINE LSE_CALLCTOR                         CPlane3Base( const _tVec3Type &_vPoint, const _tVec3Type &_vNormal ) {
                        n = _vNormal;
                        dist = n.Dot( _vPoint );
                }


                // == Operators.
                CPlane3Base<_tType, _tVec3Type> & LSE_FCALL
                                                                                        operator = ( const CPlane3Base<_tType, _tVec3Type> &_pPlane ) {
                        n = _pPlane.n;
                        dist = _pPlane.dist;
                        return (*this);
                }

                LSBOOL LSE_CALL                                         operator == ( const CPlane3Base<_tType, _tVec3Type> &_pOther ) const {
                        return dist == _pOther.dist && n == _pOther.n;
                }

                CPlane3Base<_tType, _tVec3Type> LSE_CALL
                                                                                        operator - () const {
                        return CPlane3Base<_tType, _tVec3Type>( -n, -dist );
                }


                // == Functions.
                LSE_INLINE _tType LSE_FCALL                     SignedDistance( const _tVec3Type &_vPoint ) const {
                        return n.Dot( _vPoint ) - dist;
                }

                LSE_INLINE _tType LSE_FCALL                     SignedDistanceNonNormal( const _tVec3Type &_vPoint ) const {
                        return (n.Dot( _vPoint ) - dist) / n.LenSq();
                }

                LSE_INLINE _tVec3Type LSE_FCALL         ProjectPointToPlane( const _tVec3Type &_vPoint ) const {
                        _tType fDist = -SignedDistance( _vPoint );
                        return CVector3( (n.x * fDist) + _vPoint.x,
                                (n.y * fDist) + _vPoint.y,
                                (n.z * fDist) + _vPoint.z );
                }

                LSE_INLINE _tVec3Type LSE_FCALL         ClosestPointOnPlane( const _tVec3Type &_vPoint ) const {
                        _tType fT = n.Dot( _vPoint ) - dist;
                        return _vPoint - (n * fT);
                }

                LSE_INLINE _tVec3Type LSE_FCALL         ClosestPointOnNonNormalPlane( const _tVec3Type &_vPoint ) const {
                        _tType fT = (n.Dot( _vPoint ) - dist) / n.LenSq();
                        return _vPoint - (n * fT);
                }

                LSE_INLINE LSVOID LSE_FCALL                     Normalize() {
                        _tType fInvMag = static_cast<_tType>(1.0) / n.Len();

                        n.x *= fInvMag;
                        n.y *= fInvMag;
                        n.z *= fInvMag;
                        dist *= fInvMag;
                }

                static LSBOOL LSE_CALL                          PlanesFormConvexEdge( const CPlane3Base<_tType, _tVec3Type> &_pbLeft, const CPlane3Base<_tType, _tVec3Type> &_pbRight,
                        _tType _tEpsilon ) {
                        // Get the direction of the intersecting line.
                        _tVec3Type vDir = _pbLeft.n % _pbRight.n;

                        _tType tDenom = vDir * vDir;
                        if ( tDenom < _tEpsilon ) { return false; }     // Not forming an edge at all.

                        vDir.Normalize();
                        _tVec3Type vDirFromLefToRight = vDir % _pbLeft.n;
                        _tType tInDirFromLeft = vDirFromLefToRight * _pbRight.n;
                        
                        return tInDirFromLeft < _tType( 0 );
                }


                // == Members.
                _tVec3Type                                                      n;

                _tType                                                          dist;

        };

}       // namespace lsm

#endif  // __LSE_PLANE3BASE_H__