Eigene Dateien/FlowVis/src/VQuaternion.h

Go to the documentation of this file.

#pragma once

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

// Unit quaternion class
class VQuaternion
{
public:

        static VVector WORLD_X_AXIS;
        static VVector WORLD_Y_AXIS;
        static VVector WORLD_Z_AXIS;
        static VVector FORWARD_VECTOR;

        VQuaternion()
        {
                set(VVector(0.0f,0.0f,0.0f),1.0f);
        };

        VQuaternion(const VVector &vecV, const float fS)
        {
                set(vecV,fS);
        };

        VQuaternion(const VVector &vecV)
        {
                set(vecV,0.0f);
        };

        VQuaternion(const float fAngle, const VVector &vecAxis)
        {
                float fD = fAngle * 0.5f;
                set(vecAxis.getNormalized() * sinf(fD),cosf(fD));
        };

        VQuaternion(const VVector &vecFrom, const VVector &vecTo)
        {
                const float fAngle = acosf(vecFrom.getNormalized().getDot(vecTo.getNormalized()));
                const VVector vecAxis = vecFrom.getNormalized().getCross(vecTo.getNormalized());
                (*this) = VQuaternion(fAngle,vecAxis);
        };

        ~VQuaternion()
        {
        };

        void set(const VVector &vecV, const float fS)
        {
                m_vecVector = vecV;
                m_fScalar = fS;
                normalize();
        };

        void setVector(const VVector &vecV)
        {
                set(vecV,getScalar());
        };

        void setScalar(const float fS)
        {
                set(getVector(),fS);
        };

        const VVector & getVector() const
        {
                return m_vecVector;
        };

        const float & getScalar() const
        {
                return m_fScalar;
        };

        const float getMagnitude() const
        {
                return sqrtf( getScalar()*getScalar() + getVector().getMagnitude() * getVector().getMagnitude());
        };

        const VQuaternion getNormalized() const
        {
                VQuaternion quaNew = *this;
                float fMagnitude = quaNew.getMagnitude();

                if (fMagnitude > 0.0f)
                {
                        quaNew.m_vecVector /= fMagnitude;
                        quaNew.m_fScalar /= fMagnitude;
                }

                return quaNew;
        };

        const VQuaternion getInverse() const
        {
                return VQuaternion(getVector()*-1.0f,getScalar()).getNormalized();
        };

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

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

        VVector getForwardVector()
        {
                return (*this) * FORWARD_VECTOR;
        }

        VVector getUpVector()
        {
                return (*this) * WORLD_Y_AXIS;
        }

        VVector getRightVector()
        {
                return (*this) * WORLD_X_AXIS;
        }

        static VQuaternion generateRotationX(float mdegrees)
        {
                return VQuaternion(WORLD_X_AXIS, mdegrees);
        }

        static VQuaternion generateRotationY(float mdegrees)
        {
                return VQuaternion(WORLD_Y_AXIS, mdegrees);
        }

        static VQuaternion generateRotationZ(float mdegrees)
        {
                return VQuaternion (WORLD_Z_AXIS, mdegrees);
        }

        void applyRotationX(float mdegrees)
        {
                VQuaternion tmp = generateRotationX(mdegrees);
                (*this) = (*this) * tmp;
        }

        void applyRotationY(float mdegrees)
        {
                VQuaternion tmp = generateRotationY(mdegrees);
                (*this) = (*this) * tmp;
        }

        void applyRotationZ(float mdegrees)
        {
                VQuaternion tmp = generateRotationZ(mdegrees);
                (*this) = (*this) * tmp;
        }

        const bool operator==(const VQuaternion & quaOther) const
        {
                return (getVector() == quaOther.getVector()) && (getScalar() == quaOther.getScalar());
        };

        const bool operator!=(const VQuaternion & quaOther) const
        {
                return !(*this == quaOther);
        };

        const VQuaternion & operator*=(const float & fOther)
        {
                set(getVector() * fOther,getScalar() * fOther);
                return *this;
        };

        const VQuaternion & operator/=(const float & fOther)
        {
                set(getVector() / fOther,getScalar() / fOther);
                return *this;
        };

        const VQuaternion & operator+=(const VQuaternion & quaOther)
        {
                set(getVector() + quaOther.getVector(),getScalar() + quaOther.getScalar());
                return *this;
        };

        const VQuaternion & operator-=(const VQuaternion & quaOther)
        {
                set(getVector() - quaOther.getVector(),getScalar() - quaOther.getScalar());
                return *this;
        };

        const VQuaternion & operator*=(const VQuaternion& quaOther)
        {
                set(
                        getVector().getCross(quaOther.getVector()) + getVector() * quaOther.getScalar()  + quaOther.getVector() * getScalar(),
                        getScalar() * quaOther.getScalar() - getVector().getDot(quaOther.getVector()));
                return *this;
        };

        const VQuaternion operator*(const float fOther) const
        {
                VQuaternion quaNew = *this;
                quaNew *= fOther;
                return quaNew;
        };

        const VQuaternion operator/(const float fOther) const
        {
                VQuaternion quaNew = *this;
                quaNew *= fOther;
                return quaNew;
        };

        const VQuaternion operator+(const VQuaternion & quaOther) const
        {
                VQuaternion quaNew = *this;
                quaNew += quaOther;
                return quaNew;
        };

        const VQuaternion operator-(const VQuaternion & quaOther) const
        {
                VQuaternion quaNew = *this;
                quaNew += quaOther;
                return quaNew;
        };

        const VQuaternion operator*(const VQuaternion & quaOther) const
        {
                VQuaternion quaNew = *this;
                quaNew *= quaOther;
                return quaNew;
        };

        const VVector operator*(const VVector &vecOther) const
        {
                VQuaternion quaRotated = (*this * VQuaternion(vecOther) * getInverse());
                return quaRotated.getVector() * vecOther.getMagnitude();
        };

private:
        VVector m_vecVector;
        float m_fScalar;
};


inline std::ostream & operator << (std::ostream & os, const VQuaternion & quaQuaternion)
{
        os << "(" << quaQuaternion.getVector() << ";" << quaQuaternion.getScalar() << ")";
        return os;
}

inline std::istream & operator>> (std::istream & is, VQuaternion & quaQuaternion)
{
        VVector vecV;
        float fS;

        if (is >> eat("(") >> vecV >> eat(";") >> fS >> eat(")"))
                quaQuaternion.set(vecV,fS);

        return is;
}

---