SO3Euler.h

Go to the documentation of this file.

 
#ifndef OGREEULER_H
#define OGREEULER_H
 
#include <Ogre.h>
 
namespace Ogre
{
 
class Euler
{
public:
        Euler()
                : mYaw(Ogre::Radian(0.0f)), mPitch(Ogre::Radian(0.0f)), mRoll(Ogre::Radian(0.0f)), mChanged(true) 
        {
        }
 
        Euler(const Ogre::Radian &y, const Ogre::Radian &p = Ogre::Radian(0.0f), const Ogre::Radian &r = Ogre::Radian(0.0f))
                : mYaw(y), mPitch(p), mRoll(r), mChanged(true) 
        {
        }
 
        Euler(Ogre::Real y, Ogre::Real p = 0.0f, Ogre::Real r = 0.0f)
                : mYaw(Ogre::Radian(y)), mPitch(Ogre::Radian(p)), mRoll(Ogre::Radian(r)), mChanged(true) 
        {
        }
 
        explicit Euler(const Ogre::Quaternion &quaternion)
        {
                fromQuaternion(quaternion);
        }
 
        explicit Euler(const Ogre::Matrix3 &matrix)
        {
                fromMatrix3(matrix);
        }
 
        inline Ogre::Radian getYaw() const { return mYaw; }
 
        inline Ogre::Radian getPitch() const { return mPitch; }
 
        inline Ogre::Radian getRoll() const { return mRoll; }
 
        inline Euler &setYaw(Ogre::Radian y)
        {
                mYaw = y; 
                mChanged = true; 
                return *this;
        }
 
        inline Euler &setPitch(Ogre::Radian p) 
        {
                mPitch = p; 
                mChanged = true; 
                return *this;
        }
 
        inline Euler &setRoll(Ogre::Radian r) 
        {
                mRoll = r; 
                mChanged = true; 
                return *this;
        }
 
        inline Euler &setRotation(const Ogre::Radian &y, const Ogre::Radian &p, const Ogre::Radian &r)
        {
                mYaw = y;
                mPitch = p;
                mRoll = r; 
                mChanged = true; 
                return *this;
        }
 
        inline Euler &yaw(const Ogre::Radian &y) 
        {
                mYaw += y; 
                mChanged = true; 
                return *this;
        }
 
        inline Euler &pitch(const Ogre::Radian &p) 
        {
                mPitch += p; 
                mChanged = true; 
                return *this;
        }
 
        inline Euler &roll(const Ogre::Radian &r) 
        {
                mRoll += r; 
                mChanged = true; 
                return *this;
        }
 
        inline Euler &rotate(const Ogre::Radian &y, const Ogre::Radian &p, const Ogre::Radian &r)
        {
                mYaw += y;
                mPitch += p;
                mRoll += r; 
                mChanged = true; 
                return *this;
        }
 
        inline Ogre::Vector3 getForward() { return toQuaternion() * Ogre::Vector3::NEGATIVE_UNIT_Z; }
 
        inline Ogre::Vector3 getRight() { return toQuaternion() * Ogre::Vector3::UNIT_X; }
 
        inline Ogre::Vector3 getUp() { return toQuaternion() * Ogre::Vector3::UNIT_Y; }
 
        inline Ogre::Quaternion toQuaternion() 
        {
                if(mChanged) 
                {
                        mCachedQuaternion = Ogre::Quaternion(mYaw, Ogre::Vector3::UNIT_Y) * Ogre::Quaternion(mPitch, Ogre::Vector3::UNIT_X) * Ogre::Quaternion(mRoll, Ogre::Vector3::UNIT_Z); 
                        mChanged = false;
                }
                return mCachedQuaternion;
        }
 
        inline operator Ogre::Quaternion() 
        {
                return toQuaternion();
        }
 
        inline Euler &fromQuaternion(const Ogre::Quaternion &quaternion)
        {
                Ogre::Matrix3 rotmat;
                quaternion.ToRotationMatrix(rotmat);
                fromMatrix3(rotmat);
                return *this;
        }
 
        inline Euler &fromMatrix3(const Ogre::Matrix3 &matrix)
        {
                matrix.ToEulerAnglesYXZ(mYaw,mPitch,mRoll);
                mChanged = true;
                return *this;
        }
 
        inline Euler &setDirection(const Ogre::Vector3 &v, bool setYaw = true, bool setPitch = true)
        {
                Ogre::Vector3 d(v.normalisedCopy());
                if(setPitch)
                        mPitch = Ogre::Math::ASin(d.y);
                if(setYaw)
                        mYaw = Ogre::Math::ATan2(-d.x, -d.z);//+Ogre::Math::PI/2.0;
                mChanged = setYaw||setPitch;
                return *this;
        }
 
        inline Euler &normalise(bool normYaw = true, bool normPitch = true, bool normRoll = true)
        {
                if(normYaw)
                {
                        Ogre::Real yaw = mYaw.valueRadians();
                        if(yaw < -Ogre::Math::PI)
                        {
                                yaw = fmod(yaw, Ogre::Math::PI * 2.0f);
                                if(yaw < -Ogre::Math::PI)
                                {
                                        yaw += Ogre::Math::PI * 2.0f;
                                }
                                mYaw = yaw;
                                mChanged = true;
                        }
                        else if(yaw > Ogre::Math::PI)
                        {
                                yaw = fmod(yaw, Ogre::Math::PI * 2.0f);
                                if(yaw > Ogre::Math::PI)
                                {
                                        yaw -= Ogre::Math::PI * 2.0f;
                                }
                                mYaw = yaw;
                                mChanged = true;
                        }
                }
                if(normPitch)
                {
                        Ogre::Real pitch = mPitch.valueRadians();
                        if(pitch < -Ogre::Math::PI)
                        {
                                pitch = fmod(pitch, Ogre::Math::PI * 2.0f);
                                if(pitch < -Ogre::Math::PI)
                                {
                                        pitch += Ogre::Math::PI * 2.0f;
                                }
                                mPitch = pitch;
                                mChanged = true;
                        }
                        else if(pitch > Ogre::Math::PI)
                        {
                                pitch = fmod(pitch, Ogre::Math::PI * 2.0f);
                                if(pitch > Ogre::Math::PI)
                                {
                                        pitch -= Ogre::Math::PI * 2.0f;
                                }
                                mPitch = pitch;
                                mChanged = true;
                        }
                }
                if(normRoll)
                {
                        Ogre::Real roll= mRoll.valueRadians();
                        if(roll < -Ogre::Math::PI)
                        {
                                roll = fmod(roll, Ogre::Math::PI * 2.0f);
                                if(roll < -Ogre::Math::PI)
                                {
                                        roll += Ogre::Math::PI * 2.0f;
                                }
                                mRoll = roll;
                                mChanged = true;
                        }
                        else if(roll > Ogre::Math::PI)
                        {
                                roll = fmod(roll, Ogre::Math::PI * 2.0f);
                                if(roll > Ogre::Math::PI)
                                {
                                        roll -= Ogre::Math::PI * 2.0f;
                                }
                                mRoll = roll;
                                mChanged = true;
                        }
                }
                return *this;
        }
 
        inline Euler getRotationTo(const Ogre::Vector3 &dir, bool setYaw = true, bool setPitch = true, bool shortest = true)
        {
                Euler t1;
                Euler t2;
                t1.setDirection(dir, setYaw, setPitch);
                t2 = t1 - *this;
                if(shortest && setYaw)
                {
                        t2.normalise();
                }
                return t2;
        }
 
        inline Euler &limitYaw(const Ogre::Radian &limit)
        {
                if(mYaw > limit)
                {
                        mYaw = limit;
                        mChanged = true;
                }
                else if(mYaw < -limit)
                {
                        mYaw = -limit;
                        mChanged = true;
                }
                return *this;
        }
 
        inline Euler &limitPitch(const Ogre::Radian &limit)
        {
                if(mPitch > limit)
                {
                        mPitch = limit;
                        mChanged = true;
                }
                else if(mPitch < -limit)
                {
                        mPitch = -limit;
                        mChanged = true;
                }
                return *this;
        }
 
        inline Euler &limitRoll(const Ogre::Radian &limit)
        {
                if(mRoll > limit)
                {
                        mRoll = limit;
                        mChanged = true;
                }
                else if(mRoll < -limit)
                {
                        mRoll = -limit;
                        mChanged = true;
                }
                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*(Ogre::Real rhs) const 
        { 
                return Euler(mYaw * rhs, mPitch * rhs, mRoll * rhs); 
        }
 
        inline friend Euler operator*(Ogre::Real lhs, const Euler &rhs) 
        { 
                return Euler(lhs * rhs.mYaw, lhs * rhs.mPitch, lhs * rhs.mRoll); 
        }
 
        inline Ogre::Quaternion operator*(const Euler &rhs) const
        {
                Euler e1(*this), e2(rhs);
                return e1.toQuaternion()*e2.toQuaternion();
        }
 
        inline Ogre::Vector3 operator*(const Ogre::Vector3 &rhs) 
        { 
                return toQuaternion() * rhs; 
        }
 
        inline Euler& operator=(const Euler& src)
        {
                setRotation(src.getYaw(), src.getPitch(), src.getRoll());
                return *this;
        }
 
        inline Euler& operator=(const Ogre::Quaternion &quaternion)
        {
                fromQuaternion(quaternion);
                return *this;
        }
 
        inline Euler& operator=(const Ogre::Matrix3 &matrix)
        {
                fromMatrix3(matrix);
                return *this;
        }
 
protected:
        Ogre::Radian mYaw;                                      
        Ogre::Radian mPitch;                            
        Ogre::Radian mRoll;                                     
        Ogre::Quaternion mCachedQuaternion;     
        bool mChanged;                                          
};
 
}
 
#endif