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

#ifndef __LSM_VECTOR2BASE_H__
#define __LSM_VECTOR2BASE_H__

#include "../LSMMathLib.h"

namespace lsm {

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

                // == 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 &_v2bOther ) {
                        x = _v2bOther.x;
                        y = _v2bOther.y;
                        return (*static_cast<_tInher *>(this));
                }

                _tInher LSE_FCALL                                                       operator - () const {
                        return CVector2Base<_tType, _tInher>( -x, -y );
                }

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

                _tType LSE_FCALL                                                        Dot( const CVector2Base<_tType, _tInher> &_v2bOther ) const {
                        return x * _v2bOther.x + y * _v2bOther.y;
                }

                static _tType LSE_FCALL                                         DotProduct( const CVector2Base<_tType, _tInher> &_v2bLeft, const CVector2Base<_tType, _tInher> &_v2bRight ) {
                        return _v2bLeft.x * _v2bRight.x + _v2bLeft.y * _v2bRight.y;
                }

                static CVector2Base<_tType, _tInher> LSE_FCALL
                                                                                                        Lerp( const CVector2Base<_tType, _tInher> &_v2bLeft, const CVector2Base<_tType, _tInher> &_v2bRight, _tType _fFrac ) {
                        return ((_v2bRight - _v2bLeft) * _fFrac) + _v2bLeft;
                }

                static CVector2Base<_tType, _tInher> LSE_FCALL
                                                                                                        Hermite( const CVector2Base<_tType, _tInher> &_v2bLeft, const CVector2Base<_tType, _tInher> &_v2bT0,
                        const CVector2Base<_tType, _tInher> &_v2bRight, const CVector2Base<_tType, _tInher> &_v2bT1,
                        _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 (_v2bLeft * (f2s3 - f3s2 + LSM_ONE)) +
                                (_v2bRight * (-f2s3 + f3s2)) +
                                (_v2bT0 * (fS3 - f2s2 + _fFrac)) +
                                (_v2bT1 * (fS3 - fS2));
                }

                static CVector2Base<_tType, _tInher> LSE_FCALL
                                                                                                        CatmullRom( const CVector2Base<_tType, _tInher> &_v2bV0, const CVector2Base<_tType, _tInher> &_v2bV1,
                        const CVector2Base<_tType, _tInher> &_v2bV2, const CVector2Base<_tType, _tInher> &_v2bV3,
                        _tType _fFrac ) {
                        _tType fS2      = _fFrac * _fFrac;
                        return ((_v2bV1 * static_cast<_tType>(2.0)) +
                                (-_v2bV0 + _v2bV2) * _fFrac +
                                (_v2bV0 * static_cast<_tType>(2.0) - _v2bV1 * static_cast<_tType>(5.0) + _v2bV2 * static_cast<_tType>(4.0) - _v2bV3) * fS2 +
                                (-_v2bV0 + _v2bV1 * static_cast<_tType>(3.0) - _v2bV2 * static_cast<_tType>(3.0) + _v2bV3) * fS2 * _fFrac) * LSM_HALF;
                }


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

                _tType                                                                          x;

                _tType                                                                          y;
#pragma pack( pop )
        };

}       // namespace lsm

#endif  // __LSM_VECTOR2BASE_H__