E:/framework - Kopie/src/Vector4.h

#pragma once

#include "common.h"
#include <math.h>


class Vector4
{
public:
        Vector4()
        {
                m_vfElements[0] = 0.0f;
                m_vfElements[1] = 0.0f;
                m_vfElements[2] = 0.0f;
                m_vfElements[3] = 0.0f;
        };

        Vector4(const float fX, const float fY, const float fZ, const float fA)
        {
                m_vfElements[0] = fX;
                m_vfElements[1] = fY;
                m_vfElements[2] = fZ;
                m_vfElements[3] = fA;
        };

        Vector4::Vector4(const float vfValues[])
        {
                m_vfElements[0] = vfValues[0];
                m_vfElements[1] = vfValues[1];
                m_vfElements[2] = vfValues[2];
                m_vfElements[3] = vfValues[3];
        };

        ~Vector4()
        {
        };

        void Set(const float fX, const float fY, const float fZ, const float fA)
        {
                m_vfElements[0] = fX;
                m_vfElements[1] = fY;
                m_vfElements[2] = fZ;
                m_vfElements[3] = fA;
        };

        void SetX(const float fX)
        {
                m_vfElements[0] = fX;
        };

        void SetY(const float fY)
        {
                m_vfElements[1] = fY;
        };

        void SetZ(const float fZ)
        {
                m_vfElements[2] = fZ;
        };

        void SetW(const float fW)
        {
                m_vfElements[3] = fW;
        };

        const float * Get() const
        {
                return m_vfElements;
        };

        const float Get(const unsigned int uIndex) const
        {
                return m_vfElements[uIndex];
        };

        const float GetX() const
        {
                return m_vfElements[0];
        };

        const float GetY() const
        {
                return m_vfElements[1];
        };

        const float GetZ() const
        {
                return m_vfElements[2];
        };

        const float GetW() const
        {
                return m_vfElements[3];
        };

        const float GetMagnitude() const
        {
                return sqrtf(GetX()*GetX() + GetY()*GetY() + GetZ()*GetZ());
        };

        const float GetSquaredMagnitude() const
        {
                return (GetX()*GetX() + GetY()*GetY() + GetZ()*GetZ());
        };

        const float GetDot(const Vector &vecOther) const
        {
                return (GetX() * vecOther.GetX() + GetY()*vecOther.GetY() + GetZ()*vecOther.GetZ());
        };

        const Vector4 GetCross(const Vector &vecOther) const
        {
                return Vector4(GetY()*vecOther.GetZ() - GetZ()*vecOther.GetY(), GetZ()*vecOther.GetX() - GetX() * vecOther.GetZ(), GetX()*vecOther.GetY() - GetY()*vecOther.GetX(),1.0f); 
        };

        const Vector4 GetNormalized() const
        {
                Vector4 vecNew = *this;
                float fMagnitude = vecNew.GetMagnitude();

                if (fMagnitude > 0.0f)
                {
                        vecNew.SetX(vecNew.GetX()/ fMagnitude);
                        vecNew.SetY(vecNew.GetY()/ fMagnitude);
                        vecNew.SetZ(vecNew.GetZ()/ fMagnitude);
                }
                return vecNew;
        };

        const Vector4 GetInverse() const
        {
                return Vector4(1.0f/GetX(),1.0f/GetY(),1.0f/GetZ(),1.0f);
        };

        void normalize()
        {
                (*this) = GetNormalized();
        };

        void invert()
        {
                (*this) = GetInverse();
        };

        const bool operator==(const Vector & vecOther) const
        {
                return (GetX() == vecOther.GetX()) && (GetY() == vecOther.GetY()) && (GetZ() == vecOther.GetZ());
        };

        const bool operator!=(const Vector & vecOther) const
        {
                return !(*this == vecOther);
        };

        float & operator[](const unsigned int uIndex)
        {
                return m_vfElements[uIndex];
        };

        const float operator[](const unsigned int uIndex) const
        {
                return m_vfElements[uIndex];
        };

        const Vector4 & operator+=(const Vector4 & vecOther)
        {
                SetX(GetX()+vecOther.GetX());
                SetY(GetY()+vecOther.GetY());
                SetZ(GetZ()+vecOther.GetZ());
                SetW(GetW()+vecOther.GetW());
                return *this;
        };

        const Vector4 & operator-=(const Vector4 & vecOther)
        {
                SetX(GetX()-vecOther.GetX());
                SetY(GetY()-vecOther.GetY());
                SetZ(GetZ()-vecOther.GetZ());
                SetW(GetW()-vecOther.GetW());
                return *this;
        };

        const Vector4 & operator*=(const Vector4 & vecOther)
        {
                SetX(GetX()*vecOther.GetX());
                SetY(GetY()*vecOther.GetY());
                SetZ(GetZ()*vecOther.GetZ());
                SetW(GetW()*vecOther.GetW());
                return *this;
        };

        const Vector4 & operator*=(const float & fOther)
        {
                SetX(GetX()*fOther);
                SetY(GetY()*fOther);
                SetZ(GetZ()*fOther);
                SetW(GetW()*fOther);
                return *this;
        };

        const Vector4 & operator/=(const Vector4 & vecOther)
        {
                SetX(GetX()/vecOther.GetX());
                SetY(GetY()/vecOther.GetY());
                SetZ(GetZ()/vecOther.GetZ());
                SetW(GetW()/vecOther.GetW());
                return *this;
        };

        const Vector4 & operator/=(const float & fOther)
        {
                SetX(GetX()/fOther);
                SetY(GetY()/fOther);
                SetZ(GetZ()/fOther);
                SetW(GetW()/fOther);
                return *this;
        };

        const Vector4 operator+(const Vector4 & vecOther) const
        {
                Vector4 vecNew = *this;
                vecNew += vecOther;
                return vecNew;
        };

        const Vector4 operator-(const Vector4 & vecOther) const
        {
                Vector4 vecNew = *this;
                vecNew -= vecOther;
                return vecNew;
        };

        const Vector4 operator*(const Vector4 & vecOther) const
        {
                Vector4 vecNew = *this;
                vecNew *= vecOther;
                return vecNew;
        };

        const Vector4 operator*(const float & fOther) const
        {
                Vector4 vecNew = *this;
                vecNew *= fOther;
                return vecNew;
        };

        const Vector4 operator/(const Vector4 & vecOther) const
        {
                Vector4 vecNew = *this;
                vecNew /= vecOther;
                return vecNew;
        };

        const Vector4 operator/(const float & fOther) const
        {
                Vector4 vecNew = *this;
                vecNew /= fOther;
                return vecNew;
        };

        const Vector4 operator-() const
        {
                return Vector4(-GetX(),-GetY(),-GetZ(),-GetW());
        };

private:
        float m_vfElements[4];
};

inline std::ostream & operator<< (std::ostream & os, const Vector4 & vecVector)
{
        os << "(" << vecVector.GetX() << ";" << vecVector.GetY() << ";" << vecVector.GetZ() << ")";
        return os;
}

inline std::istream & operator>> (std::istream & is, Vector4 & vecVector)
{

        float fX,fY,fZ;
        if (is >> eat("(") >> fX >> eat(";") >> fY >> eat(";") >> fZ >> eat(")"))
                vecVector.Set(fX,fY,fZ,1.0f);

        return is;
}