Eigene Dateien/FlowVis/src/VVector.h

Go to the documentation of this file.

#pragma once


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

// 3-Vector class
class VVector
{
public:
        VVector()
        {
                m_vfElements[0] = 0.0f;
                m_vfElements[1] = 0.0f;
                m_vfElements[2] = 0.0f;
        };

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

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

        ~VVector()
        {
        };

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

        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;
        };

        float * getPtr()
        {
                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 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 VVector &vecOther) const
        {
                return (getX() * vecOther.getX() + getY()*vecOther.getY() + getZ()*vecOther.getZ());
        };

        const VVector getCross(const VVector &vecOther) const
        {
                return VVector(getY()*vecOther.getZ() - getZ()*vecOther.getY(), getZ()*vecOther.getX() - getX() * vecOther.getZ(), getX()*vecOther.getY() - getY()*vecOther.getX()); 
        };

        const VVector getNormalized() const
        {
                VVector vecNew = *this;
                float fMagnitude = vecNew.getMagnitude();

                if (fMagnitude > 0.0f)
                        vecNew /= fMagnitude;

                return vecNew;
        };

        const VVector getInverse() const
        {
                return VVector(1.0f/getX(),1.0f/getY(),1.0f/getZ());
        };

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

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

        const bool operator==(const VVector & vecOther) const
        {
                return (getX() == vecOther.getX()) && (getY() == vecOther.getY()) && (getZ() == vecOther.getZ());
        };

        const bool operator!=(const VVector & 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 VVector & operator+=(const VVector & vecOther)
        {
                setX(getX()+vecOther.getX());
                setY(getY()+vecOther.getY());
                setZ(getZ()+vecOther.getZ());
                return *this;
        };

        const VVector & operator-=(const VVector & vecOther)
        {
                setX(getX()-vecOther.getX());
                setY(getY()-vecOther.getY());
                setZ(getZ()-vecOther.getZ());
                return *this;
        };

        const VVector & operator*=(const VVector & vecOther)
        {
                setX(getX()*vecOther.getX());
                setY(getY()*vecOther.getY());
                setZ(getZ()*vecOther.getZ());
                return *this;
        };

        const VVector & operator*=(const float & fOther)
        {
                setX(getX()*fOther);
                setY(getY()*fOther);
                setZ(getZ()*fOther);
                return *this;
        };

        const VVector & operator/=(const VVector & vecOther)
        {
                setX(getX()/vecOther.getX());
                setY(getY()/vecOther.getY());
                setZ(getZ()/vecOther.getZ());
                return *this;
        };

        const VVector & operator/=(const float & fOther)
        {
                setX(getX()/fOther);
                setY(getY()/fOther);
                setZ(getZ()/fOther);
                return *this;
        };

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

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

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

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

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

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

        const VVector operator-() const
        {
                return VVector(-getX(),-getY(),-getZ());
        };

private:
        float m_vfElements[3];
};

inline std::ostream & operator<< (std::ostream & os, const VVector & vecVector)
{
        os << "(" << vecVector.getX() << ";" << vecVector.getY() << ";" << vecVector.getZ() << ")";
        return os;
}

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

        float fX,fY,fZ;
        if (is >> eat("(") >> fX >> eat(";") >> fY >> eat(";") >> fZ >> eat(")"))
                vecVector.set(fX,fY,fZ);

        return is;
}

---