F:/My Projects/LSEngine/Modules/LSMathLib/Src/Orientation/LSMOrientation.h

#ifndef __LSM_ORIENTATION_H__
#define __LSM_ORIENTATION_H__

#include "../LSMMathLib.h"
#include "../Vector/LSMVector3.h"
#include "../Matrix/LSMMatrix4x4.h"

namespace lsm {

        // == Types.
        enum LSM_ORIENT_DIRTY_FLAGS {
                LSM_ODF_POSITION                                                        = (1 << 0),                     /*< Position is dirty. */
                LSM_ODF_ROTATION                                                        = (1 << 1),                     /*< Rotation is dirty. */
                LSM_ODF_SCALE                                                           = (1 << 2),                     /*< Scale is dirty. */
                LSM_ODF_NORMALIZATION                                           = (1 << 3),                     /*< Vectors need normalizing. */
        };

        class COrientation {
        public :
                // == Various constructors.
                LSE_INLINE LSE_CALLCTOR                                         COrientation();
                LSE_INLINE LSE_CALLCTOR                                         COrientation( const COrientation &_oSrc );


                // == Operators.
                LSE_INLINE COrientation & LSE_FCALL                     operator = ( const COrientation &_oSrc );


                // == Functions.
                LSE_INLINE const CVector3 & LSE_FCALL           GetScale() const;

                LSE_INLINE const CVector3 & LSE_FCALL           GetPos() const;

                LSE_INLINE const CVector3 & LSE_FCALL           GetForward() const;

                LSE_INLINE const CVector3 & LSE_FCALL           GetRight() const;

                LSE_INLINE const CVector3 & LSE_FCALL           GetUp() const;

                LSVOID LSE_FCALL                                                        SetIdentity();

                LSVOID LSE_FCALL                                                        ClearPosition();

                LSVOID LSE_FCALL                                                        ClearRotation();

                LSVOID LSE_FCALL                                                        ClearScale();
                
                LSVOID LSE_FCALL                                                        SetPos( const CVector3 &_vPos );

                LSVOID LSE_FCALL                                                        SetPosU( const CVector3 &_vPos );

                LSVOID LSE_FCALL                                                        AddPos( const CVector3 &_vPos );

                LSVOID LSE_FCALL                                                        SetRelPos( const CVector3 &_vPos );

                LSVOID LSE_FCALL                                                        AddRelPos( const CVector3 &_vPos );

                LSVOID LSE_FCALL                                                        SetRotation( const CMatrix4x4 &_mMat );

                LSVOID LSE_FCALL                                                        AddRotation( const CMatrix4x4 &_mMat );

                LSVOID LSE_FCALL                                                        SetRotation( const CVector3 &_vForward, const CVector3 &_vUp );

                LSVOID LSE_FCALL                                                        SetRotationEasy( const CVector3 &_vForward, const CVector3 &_vUp );

                LSVOID LSE_FCALL                                                        AddRotation( const CVector3 &_vForward, const CVector3 &_vUp );

                LSVOID LSE_FCALL                                                        Yaw( LSREAL _fAmount );

                LSVOID LSE_FCALL                                                        SetYaw( LSREAL _fAmount );

                LSVOID LSE_FCALL                                                        Pitch( LSREAL _fAmount );

                LSVOID LSE_FCALL                                                        Roll( LSREAL _fAmount );

                LSVOID LSE_FCALL                                                        SetRotationYawPitchRoll( LSREAL _fYaw, LSREAL _fPitch, LSREAL _fRoll );

                LSVOID LSE_FCALL                                                        SetScale( const CVector3 &_vScale );

                LSVOID LSE_FCALL                                                        AddScale( const CVector3 &_vScale );

                LSVOID LSE_FCALL                                                        SetScale( LSREAL _fScale );

                LSVOID LSE_FCALL                                                        AddScale( LSREAL _fScale );

                LSVOID LSE_FCALL                                                        BuildMatrix( CMatrix4x4 &_mRet ) const;

                LSBOOL LSE_FCALL                                                        UpdateMatrix( CMatrix4x4 &_mRet, LSBOOL _bClearDirty = true ) const;

                LSE_INLINE LSBOOL LSE_FCALL                                     IsDirty() const;
                
                LSE_INLINE LSVOID LSE_FCALL                                     MakeDirty();

                LSE_INLINE LSVOID LSE_FCALL                                     UndirtyRotations() const;
                
                
        protected :
                // == Members.
                mutable CVector3                                                        m_vRight,
                                                                                                        m_vUp,
                                                                                                        m_vForward;

                CVector3                                                                        m_vPos;

                CVector3                                                                        m_vScale;

                mutable LSUINT32                                                        m_ui32Dirty;
        };


        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // DEFINITIONS
        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // == Various constructors.
        LSE_INLINE LSE_CALLCTOR COrientation::COrientation() :
                m_vRight( LSM_ONE, LSM_ZERO, LSM_ZERO ),
                m_vUp( LSM_ZERO, LSM_ONE, LSM_ZERO ),
                m_vForward( LSM_ZERO, LSM_ZERO, LSM_ONE ),
                m_vPos( LSM_ZERO, LSM_ZERO, LSM_ZERO ),
                m_vScale( LSM_ONE, LSM_ONE, LSM_ONE ),
                m_ui32Dirty( LSM_ODF_POSITION | LSM_ODF_ROTATION | LSM_ODF_SCALE ) {
        }
        LSE_INLINE LSE_CALLCTOR COrientation::COrientation( const COrientation &_oSrc ) :
                m_vRight( _oSrc.m_vRight ),
                m_vUp( _oSrc.m_vUp ),
                m_vForward( _oSrc.m_vForward ),
                m_vPos( _oSrc.m_vPos ),
                m_vScale( _oSrc.m_vScale ),
                m_ui32Dirty( _oSrc.m_ui32Dirty ) {
        }

        // == Operators.
        LSE_INLINE COrientation & LSE_FCALL COrientation::operator = ( const COrientation &_oSrc ) {
                m_vRight = _oSrc.m_vRight;
                m_vUp = _oSrc.m_vUp;
                m_vForward = _oSrc.m_vForward;
                m_vPos = _oSrc.m_vPos;
                m_vScale = _oSrc.m_vScale;
                m_ui32Dirty = LSM_ODF_NORMALIZATION | LSM_ODF_POSITION | LSM_ODF_ROTATION | LSM_ODF_SCALE;
                return (*this);
        }

        // == Functions.
        LSE_INLINE const CVector3 & LSE_FCALL COrientation::GetScale() const            { return m_vScale; }

        LSE_INLINE const CVector3 & LSE_FCALL COrientation::GetPos() const              { return m_vPos; }
        
        LSE_INLINE const CVector3 & LSE_FCALL COrientation::GetForward() const  { const_cast<COrientation *>(this)->UndirtyRotations(); return m_vForward; }
        
        LSE_INLINE const CVector3 & LSE_FCALL COrientation::GetRight() const            { const_cast<COrientation *>(this)->UndirtyRotations(); return m_vRight; }
        
        LSE_INLINE const CVector3 & LSE_FCALL COrientation::GetUp() const               { const_cast<COrientation *>(this)->UndirtyRotations(); return m_vUp; }

        LSE_INLINE LSBOOL LSE_FCALL COrientation::IsDirty() const {
                return m_ui32Dirty != 0;
        }
        
        LSE_INLINE LSVOID LSE_FCALL COrientation::MakeDirty() {
                m_ui32Dirty = LSM_ODF_NORMALIZATION | LSM_ODF_POSITION | LSM_ODF_ROTATION | LSM_ODF_SCALE;
        }

        LSE_INLINE LSVOID LSE_FCALL COrientation::UndirtyRotations() const {
                if ( m_ui32Dirty & LSM_ODF_NORMALIZATION ) {
                        m_vRight.Normalize();
                        m_vUp.Normalize();
                        m_vForward.Normalize();
                        m_ui32Dirty &= ~static_cast<LSUINT32>(LSM_ODF_NORMALIZATION);
                }
        }

}       // namespace lsm

#endif  // __LSM_ORIENTATION_H__