OgreEuler.h

Go to the documentation of this file.

 
#ifndef HGUARD_OGRE_MATHS_EULER_H
#define HGUARD_OGRE_MATHS_EULER_H
 
#include <OGRE/OgreMath.h>
#include <OGRE/OgreVector3.h>
#include <OGRE/OgreQuaternion.h>
#include <OGRE/OgreMatrix3.h>
 
namespace Ogre {
 
    class Euler
    {
    public:
        Euler()
            : mYaw(Radian(0.0f)), mPitch(Radian(0.0f)), mRoll(Radian(0.0f)), mChanged(true)
        {
        }
 
        Euler(const Radian& y, const Radian& p = Radian(0.0f), const Radian& r = Radian(0.0f))
            : mYaw(y), mPitch(p), mRoll(r), mChanged(true)
        {
        }
 
        Euler(Real y, Real p = 0.0f, Real r = 0.0f)
            : mYaw(Radian(y)), mPitch(Radian(p)), mRoll(Radian(r)), mChanged(true)
        {
        }
 
        explicit Euler(const Quaternion& quaternion)
        {
            fromQuaternion(quaternion);
        }
 
        explicit Euler(const Matrix3& matrix)
        {
            fromMatrix3(matrix);
        }
 
        inline Radian yaw() const { return mYaw; }
 
        inline Radian pitch() const { return mPitch; }
 
        inline Radian roll() const { return mRoll; }
 
        inline Euler& setYaw(Radian y)
        {
            mYaw = y;
            mChanged = true;
            return *this;
        }
 
        inline Euler& setPitch(Radian p)
        {
            mPitch = p;
            mChanged = true;
            return *this;
        }
 
        inline Euler& setRoll(Radian r)
        {
            mRoll = r;
            mChanged = true;
            return *this;
        }
 
        inline Euler& orientation(const Radian& y, const Radian& p, const Radian& r)
        {
            mYaw = y;
            mPitch = p;
            mRoll = r;
            mChanged = true;
            return *this;
        }
 
        inline Euler& yaw(const Radian& y)
        {
            mYaw += y;
            mChanged = true;
            return *this;
        }
 
        inline Euler& pitch(const Radian& p)
        {
            mPitch += p;
            mChanged = true;
            return *this;
        }
 
        inline Euler& roll(const Radian& r)
        {
            mRoll += r;
            mChanged = true;
            return *this;
        }
 
        inline Euler& rotate(const Radian& y, const Radian& p, const Radian& r)
        {
            mYaw += y;
            mPitch += p;
            mRoll += r;
            mChanged = true;
            return *this;
        }
 
        inline Vector3 forward() const { return toQuaternion() * Vector3::NEGATIVE_UNIT_Z; }
 
        inline Vector3 right() const { return toQuaternion() * Vector3::UNIT_X; }
 
        inline Vector3 up() const { return toQuaternion() * Vector3::UNIT_Y; }
 
        inline Quaternion toQuaternion() const
        {
            if (mChanged)
            {
                mCachedQuaternion = Quaternion(mYaw, Vector3::UNIT_Y) * Quaternion(mPitch, Vector3::UNIT_X) * Quaternion(mRoll, Vector3::UNIT_Z);
                mChanged = false;
            }
            return mCachedQuaternion;
        }
 
        inline operator Quaternion() const
        {
            return toQuaternion();
        }
 
        inline Euler& fromQuaternion(const Quaternion& quaternion)
        {
            Matrix3 rotmat;
            quaternion.ToRotationMatrix(rotmat);
            fromMatrix3(rotmat);
            return *this;
        }
 
        inline Euler& fromMatrix3(const Matrix3& matrix)
        {
            matrix.ToEulerAnglesYXZ(mYaw, mPitch, mRoll);
            mChanged = true;
            return *this;
        }
 
        inline Euler& direction(const Vector3& v, bool setYaw = true, bool setPitch = true)
        {
            Vector3 d(v.normalisedCopy());
            if (setPitch)
                mPitch = Math::ASin(d.y);
            if (setYaw)
                mYaw = Math::ATan2(-d.x, -d.z);
            mChanged = setYaw || setPitch;
            return *this;
        }
 
        inline Euler& normalise(bool normYaw = true, bool normPitch = true, bool normRoll = true)
        {
            if (normYaw)
                wrapAngle(mYaw);
 
            if (normPitch)
                wrapAngle(mPitch);
 
            if (normRoll)
                wrapAngle(mRoll);
 
            return *this;
        }
 
        inline Euler rotationTo(const Vector3& dir, bool setYaw = true, bool setPitch = true, bool shortest = true) const
        {
            Euler t1;
            Euler t2;
            t1.direction(dir, setYaw, setPitch);
            t2 = t1 - *this;
            if (shortest && setYaw)
            {
                t2.normalise();
            }
            return t2;
        }
 
        inline Euler& limitYaw(const Radian& limit)
        {
            limitAngle(mYaw, limit);
            return *this;
        }
 
        inline Euler& limitPitch(const Radian& limit)
        {
            limitAngle(mPitch, limit);
            return *this;
        }
 
        inline Euler& limitRoll(const Radian& limit)
        {
            limitAngle(mRoll, limit);
            return *this;
        }
 
        inline friend std::ostream& operator<<(std::ostream& o, const Euler& e)
        {
            o << "<Y:" << e.mYaw << ", P:" << e.mPitch << ", R:" << e.mRoll << ">";
            return o;
        }
 
        inline Euler operator+(const Euler& rhs) const
        {
            return Euler(mYaw + rhs.mYaw, mPitch + rhs.mPitch, mRoll + rhs.mRoll);
        }
 
        inline Euler operator-(const Euler& rhs) const
        {
            return Euler(mYaw - rhs.mYaw, mPitch - rhs.mPitch, mRoll - rhs.mRoll);
        }
 
        inline Euler operator*(Real rhs) const
        {
            return Euler(mYaw * rhs, mPitch * rhs, mRoll * rhs);
        }
 
        inline friend Euler operator*(Real lhs, const Euler& rhs)
        {
            return Euler(lhs * rhs.mYaw, lhs * rhs.mPitch, lhs * rhs.mRoll);
        }
 
        inline Quaternion operator*(Euler rhs) const
        {
            Euler e1(*this), e2(rhs);
            return e1.toQuaternion() * e2.toQuaternion();
        }
 
 
        inline Vector3 operator*(const Vector3& rhs) const
        {
            return toQuaternion() * rhs;
        }
 
 
        inline Euler& operator=(const Euler& src)
        {
            orientation(src.yaw(), src.pitch(), src.roll());
            return *this;
        }
 
        inline Euler& operator=(const Quaternion& quaternion)
        {
            fromQuaternion(quaternion);
            return *this;
        }
 
        inline Euler& operator=(const Matrix3& matrix)
        {
            fromMatrix3(matrix);
            return *this;
        }
 
        inline friend bool operator==(const Euler& left, const Euler& right)
        {
            return left.mYaw == right.mYaw
                && left.mPitch == right.mPitch
                && left.mRoll == right.mRoll
                ;
        }
 
        inline friend bool operator!=(const Euler& left, const Euler& right)
        {
            return !(left == right);
        }
 
        inline friend bool sameOrientation(const Euler& left, const Euler& right)
        {
            // I'm comparing resulting vectors to avoid having to compare angles that are the same but in different values.
            // Only the resulting oriented vectors really have any meaning in the end.
            return left.forward().positionEquals(right.forward())
                && left.up().positionEquals(right.up())
                ;
        }
 
    protected:
        Radian mYaw;                           
        Radian mPitch;                            
        Radian mRoll;                           
        mutable Quaternion mCachedQuaternion;       
        mutable bool mChanged;                  
 
        inline void wrapAngle(Radian& angle)
        {
            Real rangle = angle.valueRadians();
            if (rangle < -Math::PI)
            {
                rangle = fmod(rangle, -Math::TWO_PI);
                if (rangle < -Math::PI)
                {
                    rangle += Math::TWO_PI;
                }
                angle = rangle;
                mChanged = true;
            }
            else if (rangle > Math::PI)
            {
                rangle = fmod(rangle, Math::TWO_PI);
                if (rangle > Math::PI)
                {
                    rangle -= Math::TWO_PI;
                }
                angle = rangle;
                mChanged = true;
            }
 
        }
 
        inline void limitAngle(Radian& angle, const Radian& limit)
        {
            if (angle > limit)
            {
                angle = limit;
                mChanged = true;
            }
            else if (angle < -limit)
            {
                angle = -limit;
                mChanged = true;
            }
        }
    };
 
}
 
#endif