F:/My Projects/LSEngine/Modules/LSMathLib/Src/Matrix/LSMMatrix4x4.h

#ifndef __LSM_MATRIX4X4_H__
#define __LSM_MATRIX4X4_H__

#include "../LSMMathLib.h"
#include "../Vector/LSMVector3.h"
#include "../Vector/LSMVector4.h"
#include "LSMMatrix3x3.h"
#include "LSMMatrix4x4Base.h"

namespace lsm {

        class CMatrix4x4 : public CMatrix4x4Base<LSREAL, CVector3, CVector4> {
                // All is public.  This class has no secrets.
        public :
                // == Various constructors.
                LSE_CALLCTOR                                                                            CMatrix4x4();
                LSE_CALLCTOR                                                                            CMatrix4x4( const CMatrix4x4 &_mOther );
                LSE_CALLCTOR                                                                            CMatrix4x4( LSREAL _t11, LSREAL _t12, LSREAL _13, LSREAL _14,
                        LSREAL _t21, LSREAL _t22, LSREAL _23, LSREAL _24,
                        LSREAL _t31, LSREAL _t32, LSREAL _33, LSREAL _34,
                        LSREAL _t41, LSREAL _t42, LSREAL _43, LSREAL _44 );
                LSE_CALLCTOR                                                                            CMatrix4x4( const CMatrix4x4Base<LSREAL, CVector3, CVector4> &_mOther );
                LSE_CALLCTOR                                                                            CMatrix4x4( const CMatrix4x4 &_mOther, LSBOOL _bTranspose );
                explicit LSE_CALLCTOR                                                           CMatrix4x4( const LSREAL * _pfArray );


                // == Operators.
#if (LSM_BASETYPE == LSM_FLOAT)

                LSE_INLINE CMatrix4x4 & LSE_FCALL                                       operator = ( const CMatrix4x4 &_mOther );
#endif  // #if (LSM_BASETYPE == LSM_FLOAT)


                // == Functions.
                LSE_INLINE CMatrix3x3 LSE_CALL                                          Get3x3Matrix() const;

                LSE_INLINE CMatrix3x3 LSE_CALL                                          Get3x3MatrixTranspose() const;

#if defined( LSE_X86 ) && (LSM_BASETYPE == LSM_FLOAT)
#if LSM_PERFORMANCE <= 0

                static LSVOID LSE_FCALL                                                         MultiplyVec3Batch( const CMatrix4x4 &_mMat,
                        const CVector3 * _pvIn, LSUINT32 _ui32Total,
                        CVector3 * _pvOut );
#endif  // #if LSM_PERFORMANCE <= 0

                static LSVOID LSE_FCALL                                                         MultiplyVec4Batch( const CMatrix4x4 &_mMat,
                        const CVector4 * _pvIn, LSUINT32 _ui32Total,
                        CVector4 * _pvOut );
#endif  // #if defined( LSE_X86 ) && (LSM_BASETYPE == LSM_FLOAT)


                // == Members.
                static const CMatrix4x4                                                         m_mIdentity;

        private :
                typedef CMatrix4x4Base<LSREAL, CVector3, CVector4>      Parent;
        };


        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // DEFINITIONS
        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // == Various constructors.
        LSE_INLINE LSE_CALLCTOR CMatrix4x4::CMatrix4x4( const CMatrix4x4Base<LSREAL, CVector3, CVector4> &_mOther ) :
                Parent( _mOther ) {
        }
        LSE_INLINE LSE_CALLCTOR CMatrix4x4::CMatrix4x4( LSREAL _t11, LSREAL _t12, LSREAL _t13, LSREAL _t14,
                LSREAL _t21, LSREAL _t22, LSREAL _t23, LSREAL _t24,
                LSREAL _t31, LSREAL _t32, LSREAL _t33, LSREAL _t34,
                LSREAL _t41, LSREAL _t42, LSREAL _t43, LSREAL _t44 ) :
                Parent( _t11, _t12, _t13, _t14,
                        _t21, _t22, _t23, _t24,
                        _t31, _t32, _t33, _t34,
                        _t41, _t42, _t43, _t44 ) {
        }

        // == Operators.
#if (LSM_BASETYPE == LSM_FLOAT)

        LSE_INLINE CMatrix4x4 & LSE_FCALL CMatrix4x4::operator = ( const CMatrix4x4 &_mOther ) {
                // Copy in pairs.
                LSUINT64 * pui64This = reinterpret_cast<LSUINT64 *>(this);
                const LSUINT64 * pui64That = reinterpret_cast<const LSUINT64 *>(&_mOther);
                (*pui64This++) = (*pui64That++);
                (*pui64This++) = (*pui64That++);

                (*pui64This++) = (*pui64That++);
                (*pui64This++) = (*pui64That++);

                (*pui64This++) = (*pui64That++);
                (*pui64This++) = (*pui64That++);

                (*pui64This++) = (*pui64That++);
                (*pui64This) = (*pui64That);
                return (*this);
        }
#endif  // #if (LSM_BASETYPE == LSM_FLOAT)

        // == Functions.
        LSE_INLINE CMatrix3x3 LSE_CALL CMatrix4x4::Get3x3Matrix() const {
                CMatrix3x3 mRet;
                mRet._11 = _11;
                mRet._12 = _12;
                mRet._13 = _13;

                mRet._21 = _21;
                mRet._22 = _22;
                mRet._23 = _23;

                mRet._31 = _31;
                mRet._32 = _32;
                mRet._33 = _33;

                return mRet;
        }

        LSE_INLINE CMatrix3x3 LSE_CALL CMatrix4x4::Get3x3MatrixTranspose() const {
                CMatrix3x3 mRet;
                mRet._11 = _11;
                mRet._12 = _21;
                mRet._13 = _31;

                mRet._21 = _12;
                mRet._22 = _22;
                mRet._23 = _32;

                mRet._31 = _13;
                mRet._32 = _23;
                mRet._33 = _33;

                return mRet;
        }

#if defined( LSE_X86 ) && (LSM_BASETYPE == LSM_FLOAT)
#if LSM_PERFORMANCE <= 0

        LSE_INLINE LSVOID LSE_FCALL CMatrix4x4::MultiplyVec3Batch( const CMatrix4x4 &_mMat,
                const CVector3 * _pvIn, LSUINT32 _ui32Total,
                CVector3 * _pvOut ) {
                // When using LSM_PERFORMANCE at 0, the CVector3 class actually has 4 members, making it a CVector4 for alignment
                //      purposes.
                MultiplyVec4Batch( _mMat, reinterpret_cast<const CVector4 *>(_pvIn), _ui32Total, reinterpret_cast<CVector4 *>(_pvOut) );
        }
#endif  // #if LSM_PERFORMANCE <= 0
#endif  // #if defined( LSE_X86 ) && (LSM_BASETYPE == LSM_FLOAT)

}       // namespace lsm

#endif  // __LSM_MATRIX4X4_H__