F:/My Projects/LSEngine/Modules/LSPhysicsLib/Src/Polygon/LSPPolygon3Base.h

#ifndef __LSP_POLYGON3BASE_H__
#define __LSP_POLYGON3BASE_H__

#include "../LSPPhysicsLib.h"
#include "Allocators/LSAStackAllocator.h"

#include <cassert>

namespace lsp {

        template <typename _tType, typename _tSeg3Type, typename _tPlane3Type>
        class CPolygon3Base {
        public :
                // == Various constructors.
                LSE_CALLCTOR                                                    CPolygon3Base() :
                        m_ptSegs( NULL ),
                        m_psaAllocator( NULL ),
                        m_uiptrUser( 0UL ),
                        m_ui32Total( 0UL ),
                        m_bSplitter( false ) {
                }
                LSE_CALLCTOR                                                    ~CPolygon3Base() {
                        Reset();
                }


                // == Operators.
                _tSeg3Type * LSE_CALL                                   operator [] ( LSUINT32 _ui32Index ) {
                        return &Segments()[_ui32Index];
                }

                const _tSeg3Type * LSE_CALL                             operator [] ( LSUINT32 _ui32Index ) const {
                        return &Segments()[_ui32Index];
                }

                CPolygon3Base<_tType, _tSeg3Type, _tPlane3Type> & LSE_CALL
                                                                                                operator = ( const CPolygon3Base<_tType, _tSeg3Type, _tPlane3Type> &_pSrc ) {
                        Reset();
                        Copy( _pSrc, _pSrc.m_psaAllocator );
                        return (*this);
                }


                // == Functions.
                LSVOID LSE_CALL                                                 Reset() {
                        for ( ; m_ui32Total--; ) {
                                m_ptSegs[m_ui32Total].~_tSeg3Type();    // Destroy, don't delete.
                        }
                        m_ptSegs = NULL;
                        m_ui32Total = 0UL;
                        m_psaAllocator = NULL;
                        m_uiptrUser = 0UL;
                        m_bSplitter = false;
                }

                LSBOOL LSE_CALL                                                 Copy( const CPolygon3Base<_tType, _tSeg3Type, _tPlane3Type> &_p3bSrc, CStackAllocator * _psaAllocator ) {
                        Reset();
                        if ( !SetTotalSides( _p3bSrc.TotalSegments(), _psaAllocator ) ) { return false; }
                        for ( LSUINT32 I = _p3bSrc.TotalSegments(); I--; ) {
                                m_ptSegs[I] = _p3bSrc.Segments()[I];
                        }
                        m_pPlane = _p3bSrc.m_pPlane;
                        m_uiptrUser = _p3bSrc.m_uiptrUser;
                        m_bSplitter = _p3bSrc.m_bSplitter;
                        return true;
                }

                LSBOOL LSE_CALL                                                 SetTotalSides( LSUINT32 _ui32Total, CStackAllocator * _psaAllocator ) {
                        Reset();
                        m_psaAllocator = _psaAllocator;
                        if ( _ui32Total < 3UL ) { return false; }
                        if ( (m_ptSegs = static_cast<_tSeg3Type *>(_psaAllocator->Alloc( sizeof( _tSeg3Type ) * _ui32Total, 4UL ))) ) {
                                m_ui32Total = _ui32Total;
                                for ( ; _ui32Total--; ) {
                                        new( &m_ptSegs[_ui32Total] ) _tSeg3Type();
                                }
                                return true;
                        }
                        return false;
                }

                LSUINT32 LSE_CALL                                               TotalSegments() const {
                        return m_ui32Total;
                }

                _tSeg3Type * LSE_CALL                                   Segments() {
                        return m_ptSegs;
                }

                const _tSeg3Type * LSE_CALL                             Segments() const {
                        return m_ptSegs;
                }

                const _tPlane3Type & LSE_CALL                   Plane() const {
                        return m_pPlane;
                }

                _tPlane3Type & LSE_CALL                                 Plane() {
                        return m_pPlane;
                }

                LSVOID LSE_CALL                                                 SetUser( LSUINTPTR _uiptrValue ) {
                        m_uiptrUser = _uiptrValue;
                }

                LSUINTPTR LSE_CALL                                              GetUser() const {
                        return m_uiptrUser;
                }

                LSBOOL LSE_CALL                                                 Finalize( _tType _tEpsilon ) {
                        assert( m_ui32Total >= 3UL );
                        _tSeg3Type tTemp;
                        // Remove any segments that have any missing connections.
                        for ( LSUINT32 I = 0UL; I < m_ui32Total; ) {
                                // Check P against Q.
                                LSBOOL bHasP = false, bHasQ = false;
                                _tType tLen = (m_ptSegs[I].q - m_ptSegs[I].p).LenSq();
                                if ( tLen >= _tEpsilon * _tEpsilon ) {
                                        for ( LSUINT32 J = 0UL; J < m_ui32Total; ++J ) {
                                                if ( J == I ) { continue; }
                                                _tType tDist = (m_ptSegs[I].p - m_ptSegs[J].q).Len();
                                                if ( tDist <= _tEpsilon ) {
                                                        bHasP = true;
                                                        break;
                                                }
                                        }
                                        if ( bHasP ) {
                                                // Check its Q.
                                                for ( LSUINT32 J = 0UL; J < m_ui32Total; ++J ) {
                                                        if ( J == I ) { continue; }
                                                        _tType tDist = (m_ptSegs[I].q - m_ptSegs[J].p).Len();
                                                        if ( tDist <= _tEpsilon ) {
                                                                bHasQ = true;
                                                                break;
                                                        }
                                                }
                                        }
                                }

                                if ( !bHasP || !bHasQ ) {
                                        Remove( I );
                                        if ( m_ui32Total <= 2UL ) {
                                                return false;
                                        }
                                }
                                else {
                                        ++I;
                                }
                        }
                        for ( LSUINT32 I = 0UL; I < m_ui32Total; ++I ) {
                                // Find the starting point that connects to the end point of the Ith edge.
                                for ( LSUINT32 J = I + 1UL; J < m_ui32Total; ++J ) {
                                        _tType tDist = (m_ptSegs[J].p - m_ptSegs[I].q).Len();
                                        if ( tDist <= _tEpsilon ) {
                                                if ( J != I + 1UL ) {   // No need to swap here.
                                                        tTemp = m_ptSegs[I+1];
                                                        m_ptSegs[I+1] = m_ptSegs[J];
                                                        m_ptSegs[J] = tTemp;
                                                }
                                                break;
                                        }
                                }
                        }

                        // Return true if we came full circle.
                        return (m_ptSegs[0].p - m_ptSegs[m_ui32Total-1].q).Len() <= _tEpsilon;
                }

                LSVOID LSE_CALL                                                 Remove( LSUINT32 _ui32Index ) {
                        if ( _ui32Index < m_ui32Total ) {
                                m_ptSegs[_ui32Index].~_tSeg3Type();             // Destroy, don't delete.
                                for ( LSUINT32 J = _ui32Index + 1UL; J < m_ui32Total; ++J ) {
                                        m_ptSegs[J-1] = m_ptSegs[J];
                                }
                                --m_ui32Total;
                        }
                }

                LSBOOL LSE_CALL                                                 IsSplitter() const {
                        return m_bSplitter;
                }

                LSVOID LSE_CALL                                                 SetAsSplitter( LSBOOL _bVal ) {
                        m_bSplitter = _bVal;
                }


        protected :
                // == Members.
                _tSeg3Type *                                                    m_ptSegs;

                CStackAllocator *                                               m_psaAllocator;

                LSUINTPTR                                                               m_uiptrUser;

                LSUINT32                                                                m_ui32Total;

                _tPlane3Type                                                    m_pPlane;

                LSBOOL                                                                  m_bSplitter;

        };

}       // namespace lsp

#endif  // __LSP_POLYGON3BASE_H__