F:/My Projects/LSEngine/Modules/LSMathLib/Src/Vector/LSMVector4Base.h

#ifndef __LSM_VECTOR4BASE_H__
#define __LSM_VECTOR4BASE_H__

#include "../LSMMathLib.h"
#include "LSMVector3Base.h"

namespace lsm {

        template <typename _tType, typename _tVec3>
        class CVector4Base {
                // All is public.  This class has no secrets.
        public :
                // == Various constructors.
                LSE_CALLCTOR                                                    CVector4Base() {
                }
                LSE_CALLCTOR                                                    CVector4Base( _tType _fX, _tType _fY, _tType _fZ, _tType _fW ) :
                        x( _fX ),
                        y( _fY ),
                        z( _fZ ),
                        w( _fW ) {
                }
                LSE_CALLCTOR                                                    CVector4Base( _tType * _pfValues ) :
                        x( _pfValues[0] ),
                        y( _pfValues[1] ),
                        z( _pfValues[2] ),
                        w( _pfValues[3] ) {
                }

                // == Operators.
                _tType LSE_FCALL                                                operator [] ( LSUINT32 _ui32Index ) const {
                        return reinterpret_cast<const _tType *>(this)[_ui32Index];
                }

                _tType & LSE_FCALL                                              operator [] ( LSUINT32 _ui32Index ) {
                        return reinterpret_cast<_tType *>(this)[_ui32Index];
                }

                CVector4Base<_tType, _tVec3> LSE_FCALL  operator - () const {
                        return CVector4Base<_tType, _tVec3>( -x, -y, -z, -w );
                }

                CVector4Base<_tType, _tVec3> LSE_FCALL  operator + ( const CVector4Base<_tType, _tVec3> &_v4bOther ) const {
                        return CVector4Base<_tType, _tVec3>( x + _v4bOther.x, y + _v4bOther.y, z + _v4bOther.z, w + _v4bOther.w );
                }

                CVector4Base<_tType, _tVec3> LSE_FCALL  operator - ( const CVector4Base<_tType, _tVec3> &_v4bOther ) const {
                        return CVector4Base<_tType, _tVec3>( x - _v4bOther.x, y - _v4bOther.y, z - _v4bOther.z, w - _v4bOther.w );
                }

                CVector4Base<_tType, _tVec3> LSE_FCALL  operator * ( _tType _tValue ) const {
                        return CVector4Base<_tType, _tVec3>( x * _tValue, y * _tValue, z * _tValue, w * _tValue );
                }

                CVector4Base<_tType, _tVec3> LSE_FCALL  operator / ( _tType _tValue ) const {
                        return (*this) * (_tType( 1.0 ) / _tValue);
                }

                CVector4Base<_tType, _tVec3> & LSE_FCALL
                                                                                                operator += ( const CVector4Base<_tType, _tVec3> &_v4bOther ) {
                        x += _v4bOther.x;
                        y += _v4bOther.y;
                        z += _v4bOther.z;
                        w += _v4bOther.w;
                        return (*this);
                }

                CVector4Base<_tType, _tVec3> & LSE_FCALL
                                                                                                operator -= ( const CVector4Base<_tType, _tVec3> &_v4bOther ) {
                        x -= _v4bOther.x;
                        y -= _v4bOther.y;
                        z -= _v4bOther.z;
                        w -= _v4bOther.w;
                        return (*this);
                }

                CVector4Base<_tType, _tVec3> & LSE_FCALL
                                                                                                operator *= ( _tType _tValue ) {
                        x *= _tValue;
                        y *= _tValue;
                        z *= _tValue;
                        w *= _tValue;
                        return (*this);
                }

                CVector4Base<_tType, _tVec3> & LSE_FCALL
                                                                                                operator /= ( _tType _tValue ) {
                        return (*this) *= (_tType( 1.0 ) / _tValue);
                }

                _tType LSE_FCALL                                                operator * ( const CVector4Base<_tType, _tVec3> &_v4bOther ) const {
                        return x * _v4bOther.x + y * _v4bOther.y + z * _v4bOther.z + w * _v4bOther.w;
                }

                LSBOOL LSE_FCALL                                                operator == ( const CVector4Base<_tType, _tVec3> &_v4bOther ) const {
                        return x == _v4bOther.x && y == _v4bOther.y && z == _v4bOther.z && w == _v4bOther.w;
                }

                LSBOOL LSE_FCALL                                                operator != ( const CVector4Base<_tType, _tVec3> &_v4bOther ) const {
                        return x != _v4bOther.x || y != _v4bOther.y || z != _v4bOther.z || w != _v4bOther.w;
                }


                // == Functions.
                LSVOID LSE_FCALL                                                Set( _tType _fX, _tType _fY, _tType _fZ, _tType _fW ) {
                        x = _fX;
                        y = _fY;
                        z = _fZ;
                        w = _fW;
                }

                LSVOID LSE_FCALL                                                Clear() {
                        x = y = z = w = _tType( 0 );
                }

                LSVOID LSE_FCALL                                                Invert() {
                        x = -x;
                        y = -y;
                        z = -z;
                        w = -w;
                }

                _tType LSE_FCALL                                                Len() const {
                        register LSREAL fSquared = x * x + y * y + z * z + w * w;
                        return fSquared * CMathLib::InvSqrt( fSquared );
                }

                _tType LSE_FCALL                                                LenSq() const {
                        return x * x + y * y + z * z + w * w;
                }

                LSVOID LSE_FCALL                                                Normalize() {
                        LSREAL fInvLen = CMathLib::InvSqrt( x * x + y * y + z * z + w * w );
                        x *= fInvLen;
                        y *= fInvLen;
                        z *= fInvLen;
                        w *= fInvLen;
                }

                _tType LSE_FCALL                                                Dot( const CVector4Base<_tType, _tVec3> &_v4bOther ) const {
                        return x * _v4bOther.x + y * _v4bOther.y + z * _v4bOther.z + w * _v4bOther.w;
                }

                _tVec3 LSE_FCALL                                                Vec3() const {
                        return _tVec3( x, y, z );
                }

                static _tType LSE_FCALL                                 DotProduct( const CVector4Base<_tType, _tVec3> &_v4bLeft, const CVector4Base<_tType, _tVec3> &_v4bRight ) {
                        return _v4bLeft.x * _v4bRight.x + _v4bLeft.y * _v4bRight.y + _v4bLeft.z * _v4bRight.z + _v4bLeft.w * _v4bRight.w;
                }

                static CVector4Base<_tType, _tVec3> LSE_FCALL   Lerp( const CVector4Base<_tType, _tVec3> &_v4bLeft, const CVector4Base<_tType, _tVec3> &_v4bRight, _tType _fFrac ) {
                        return ((_v4bRight - _v4bLeft) * _fFrac) + _v4bLeft;
                }

                static CVector4Base<_tType, _tVec3> LSE_FCALL   Hermite( const CVector4Base<_tType, _tVec3> &_v4bLeft, const CVector4Base<_tType, _tVec3> &_v4bT0,
                        const CVector4Base<_tType, _tVec3> &_v4bRight, const CVector4Base<_tType, _tVec3> &_v4bT1,
                        _tType _fFrac ) {
                        _tType fS2      = _fFrac * _fFrac;
                        _tType fS3      = fS2 * _fFrac;
                        _tType f2s2     = static_cast<_tType>(2.0) * fS2;
                        _tType f2s3     = static_cast<_tType>(2.0) * fS3;
                        _tType f3s2     = static_cast<_tType>(3.0) * fS2;

                        return (_v4bLeft * (f2s3 - f3s2 + LSM_ONE)) +
                                (_v4bRight * (-f2s3 + f3s2)) +
                                (_v4bT0 * (fS3 - f2s2 + _fFrac)) +
                                (_v4bT1 * (fS3 - fS2));
                }

                static CVector4Base<_tType, _tVec3> LSE_FCALL   CatmullRom( const CVector4Base<_tType, _tVec3> &_v4bV0, const CVector4Base<_tType, _tVec3> &_v4bV1,
                        const CVector4Base<_tType, _tVec3> &_v4bV2, const CVector4Base<_tType, _tVec3> &_v4bV3,
                        _tType _fFrac ) {
                        _tType fS2      = _fFrac * _fFrac;
                        return ((_v4bV1 * static_cast<_tType>(2.0)) +
                                (-_v4bV0 + _v4bV2) * _fFrac +
                                (_v4bV0 * static_cast<_tType>(2.0) - _v4bV1 * static_cast<_tType>(5.0) + _v4bV2 * static_cast<_tType>(4.0) - _v4bV3) * fS2 +
                                (-_v4bV0 + _v4bV1 * static_cast<_tType>(3.0) - _v4bV2 * static_cast<_tType>(3.0) + _v4bV3) * fS2 * _fFrac) * LSM_HALF;
                }


                // == Members.
#pragma pack( push, 1 )

                _tType                                                                  x;

                _tType                                                                  y;

                _tType                                                                  z;

                _tType                                                                  w;
#pragma pack( pop )
        };

}       // namespace lsm

#endif  // __LSM_VECTOR4BASE_H__