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

#ifndef __LSM_VECTOR3BASE_H__
#define __LSM_VECTOR3BASE_H__

#include "../LSMMathLib.h"

namespace lsm {

        template <typename _tType, typename _tInher>
        class CVector3Base {
                // All is public.  This class has no secrets.
        public :
                // == Various constructors.
                LSE_CALLCTOR                                                    CVector3Base() {
                }
                LSE_CALLCTOR                                                    CVector3Base( const _tInher &_v3bOther ) :
                        x( _v3bOther.x ),
                        y( _v3bOther.y ),
                        z( _v3bOther.z ) {
                }
                LSE_CALLCTOR                                                    CVector3Base( _tType _fX, _tType _fY, _tType _fZ ) :
                        x( _fX ),
                        y( _fY ),
                        z( _fZ ) {
                }
                LSE_CALLCTOR                                                    CVector3Base( _tType * _pfValues ) :
                        x( _pfValues[0] ),
                        y( _pfValues[1] ),
                        z( _pfValues[2] ) {
                }

                // == 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];
                }

                _tInher & LSE_FCALL                                             operator = ( const _tInher &_v3bOther ) {
                        x = _v3bOther.x;
                        y = _v3bOther.y;
                        z = _v3bOther.z;
                        return (*static_cast<_tInher *>(this));
                }

                LSBOOL LSE_FCALL                                                operator == ( const _tInher &_v3bOther ) const {
                        return x == _v3bOther.x && y == _v3bOther.y && z == _v3bOther.z;
                }

                LSBOOL LSE_FCALL                                                operator != ( const _tInher &_v3bOther ) const {
                        return x != _v3bOther.x || y != _v3bOther.y || z != _v3bOther.z;
                }

                _tInher LSE_FCALL                                               operator - () const {
                        return _tInher( -x, -y, -z );
                }

                _tInher LSE_FCALL                                               operator + ( const _tInher &_v3bOther ) const {
                        return _tInher( x + _v3bOther.x, y + _v3bOther.y, z + _v3bOther.z );
                }

                _tInher LSE_FCALL                                               operator - ( const _tInher &_v3bOther ) const {
                        return _tInher( x - _v3bOther.x, y - _v3bOther.y, z - _v3bOther.z );
                }

                _tInher LSE_FCALL                                               operator * ( _tType _tValue ) const {
                        return _tInher( x * _tValue, y * _tValue, z * _tValue );
                }

                _tInher LSE_FCALL                                               operator / ( _tType _tValue ) const {
                        return (*static_cast<const _tInher *>(this)) * (_tType( 1 ) / _tValue);
                }

                _tInher & LSE_FCALL                                             operator += ( const _tInher &_v3bOther ) {
                        x += _v3bOther.x;
                        y += _v3bOther.y;
                        z += _v3bOther.z;
                        return (*static_cast<_tInher *>(this));
                }

                _tInher & LSE_FCALL                                             operator += ( _tType _tValue ) {
                        x += _tValue;
                        y += _tValue;
                        z += _tValue;
                        return (*static_cast<_tInher *>(this));
                }

                _tInher & LSE_FCALL                                             operator -= ( const _tInher &_v3bOther ) {
                        x -= _v3bOther.x;
                        y -= _v3bOther.y;
                        z -= _v3bOther.z;
                        return (*static_cast<_tInher *>(this));
                }

                _tInher & LSE_FCALL                                             operator -= ( _tType _tValue ) {
                        x -= _tValue;
                        y -= _tValue;
                        z -= _tValue;
                        return (*static_cast<_tInher *>(this));
                }

                _tInher & LSE_FCALL                                             operator *= ( _tType _tValue ) {
                        x *= _tValue;
                        y *= _tValue;
                        z *= _tValue;
                        return (*static_cast<_tInher *>(this));
                }

                _tInher & LSE_FCALL                                             operator /= ( _tType _tValue ) {
                        return (*static_cast<_tInher *>(this)) *= (_tType( 1 ) / _tValue);
                }

                _tType LSE_FCALL                                                operator * ( const _tInher &_v3bOther ) const {
                        return x * _v3bOther.x + y * _v3bOther.y + z * _v3bOther.z;
                }

                _tInher LSE_FCALL                                               operator % ( const _tInher &_v3bOther ) const {
                        return _tInher( y * _v3bOther.z - z * _v3bOther.y,
                                z * _v3bOther.x - x * _v3bOther.z,
                                x * _v3bOther.y - y * _v3bOther.x );
                }


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

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

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

                _tType LSE_FCALL                                                Len() const {
                        return static_cast<_tType>(::sqrt( static_cast<LSDOUBLE>(x * x + y * y + z * z) ));
                }

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

                LSVOID LSE_FCALL                                                Normalize() {
                        _tType fInvLen = static_cast<_tType>(1.0 / ::sqrt( static_cast<LSDOUBLE>(x * x + y * y + z * z) ));
                        x *= fInvLen;
                        y *= fInvLen;
                        z *= fInvLen;
                }

                _tType LSE_FCALL                                                Dot( const _tInher &_v3bOther ) const {
                        return x * _v3bOther.x + y * _v3bOther.y + z * _v3bOther.z;
                }

                _tInher LSE_FCALL                                               Cross( const _tInher &_v3bOther ) const {
                        return _tInher( y * _v3bOther.z - z * _v3bOther.y,
                                z * _v3bOther.x - x * _v3bOther.z,
                                x * _v3bOther.y - y * _v3bOther.x );
                }

                static _tType LSE_FCALL                                 DotProduct( const _tInher &_v3bLeft, const _tInher &_v3bRight ) {
                        return _v3bLeft.x * _v3bRight.x + _v3bLeft.y * _v3bRight.y + _v3bLeft.z * _v3bRight.z;
                }

                static _tInher LSE_FCALL                                CrossProduct( const _tInher &_v3bLeft, const _tInher &_v3bRight ) {
                        return _tInher( _v3bLeft.y * _v3bRight.z - _v3bLeft.z * _v3bRight.y,
                                _v3bLeft.z * _v3bRight.x - _v3bLeft.x * _v3bRight.z,
                                _v3bLeft.x * _v3bRight.y - _v3bLeft.y * _v3bRight.x );
                }

                static _tInher LSE_FCALL                                Lerp( const _tInher &_v3bLeft, const _tInher &_v3bRight, _tType _fFrac ) {
                        return ((_v3bRight - _v3bLeft) * _fFrac) + _v3bLeft;
                }

                static _tInher LSE_FCALL                                Hermite( const _tInher &_v3bLeft, const _tInher &_v3bT0,
                        const _tInher &_v3bRight, const _tInher &_v3bT1,
                        _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 (_v3bLeft * (f2s3 - f3s2 + LSM_ONE)) +
                                (_v3bRight * (-f2s3 + f3s2)) +
                                (_v3bT0 * (fS3 - f2s2 + _fFrac)) +
                                (_v3bT1 * (fS3 - fS2));
                }

                static _tInher LSE_FCALL                                CatmullRom( const _tInher &_v3bV0, const _tInher &_v3bV1,
                        const _tInher &_v3bV2, const _tInher &_v3bV3,
                        _tType _fFrac ) {
                        _tType fS2      = _fFrac * _fFrac;
                        return ((_v3bV1 * static_cast<_tType>(2.0)) +
                                (-_v3bV0 + _v3bV2) * _fFrac +
                                (_v3bV0 * static_cast<_tType>(2.0) - _v3bV1 * static_cast<_tType>(5.0) + _v3bV2 * static_cast<_tType>(4.0) - _v3bV3) * fS2 +
                                (-_v3bV0 + _v3bV1 * static_cast<_tType>(3.0) - _v3bV2 * static_cast<_tType>(3.0) + _v3bV3) * fS2 * _fFrac) * LSM_HALF;
                }


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

                _tType                                                                  x;

                _tType                                                                  y;

                _tType                                                                  z;
#pragma pack( pop )
        };

}       // namespace lsm

#endif  // __LSM_VECTOR3BASE_H__