Euler3.hpp

Go to the documentation of this file.

/*
   Copyright (C) 2006
   Rune Myrland, Skalden Studio AS
*/
#ifndef base_vecmath_Euler3_hpp
#define base_vecmath_Euler3_hpp

#include "util_vecmath.hpp"
#include "../error/Log.hpp"
#include "../math/BrayT.hpp"

namespace se_core {

    class _SeCoreExport Euler3 {
    public:
        typedef bray_t value_type;
        typedef short size_type;
        enum { DIMENSION = 3 };

        bray_t yaw_;

        bray_t pitch_;

        bray_t roll_;


        Euler3(bray_t yaw, bray_t pitch, bray_t roll):
                yaw_(yaw & BRAY_MASK), pitch_(pitch & BRAY_MASK), roll_(roll & BRAY_MASK) { 
            set(yaw, pitch, roll);
        }

        Euler3(const bray_t t[]): yaw_(t[0]), pitch_(t[1]), roll_(t[2]) { }

        Euler3() { }



        Euler3(const Quat4& q) { 
            set(q);
        }

        Euler3(const Euler3& a) { 
            set(a);
        }

        void set(bray_t yaw, bray_t pitch, bray_t roll) {
            yaw_ = yaw & BRAY_MASK;
            pitch_ = pitch & BRAY_MASK;
            roll_ = roll & BRAY_MASK;
        }

        void set(const bray_t t[]) {
            yaw_ = t[0] & BRAY_MASK;
            pitch_ = t[1] & BRAY_MASK;
            roll_ = t[2] & BRAY_MASK;
        }

        void set(const Quat4& q1);

        void set(const Euler3& a1) {
            yaw_ = a1.yaw_;
            pitch_ = a1.pitch_;
            roll_ = a1.roll_;
        }


        void setEuler(const Euler3& a1) {
            set(a1);
        }


        void setYaw(bray_t yaw) {
            yaw_ = yaw;
            pitch_ = 0;
            roll_ = 0;
        }

        void setPitch(bray_t yaw) {
            yaw_ = yaw;
            pitch_ = 0;
            roll_ = 0;
        }

        void setRoll(bray_t roll) {
            yaw_ = 0;
            pitch_ = 0;
            roll_ = roll;
        }

        void setYawAndPitch(bray_t yaw, bray_t pitch) {
            yaw_ = yaw;
            pitch_ = pitch;
            roll_ = 0;
        }

        void setEuler(bray_t yaw, bray_t pitch, bray_t roll) {
            yaw_ = yaw;
            pitch_ = pitch;
            roll_ = roll;
        }



        void reset() {
            yaw_ = pitch_ = roll_ = 0;
        }

        void setIdentity() {
            reset();
        }

        void get(bray_t t[]) const {
            t[0] = yaw_;
            t[1] = pitch_;
            t[2] = roll_;
        }

        void get(Euler3* t) const {
            Assert(t);
            t->yaw_ = yaw_;
            t->pitch_ = pitch_;
            t->roll_ = roll_;
        }

        void add(const Euler3& a1, const Euler3& a2) {
            yaw_ = (a1.yaw_ + a2.yaw_) & BRAY_MASK;
            pitch_ = (a1.pitch_ + a2.pitch_) & BRAY_MASK;
            roll_ = (a1.roll_ + a2.roll_) & BRAY_MASK;
        }

        void add(const Euler3& a1) {
            yaw_ = (yaw_ + a1.yaw_) & BRAY_MASK;
            pitch_ = (pitch_ + a1.pitch_) & BRAY_MASK;
            roll_ = (roll_ + a1.roll_) & BRAY_MASK;
        }


        inline void rotate(const Euler3& a1) {
            add(a1);
        }

        inline void rotateInverse(const Euler3& a1) {
            sub(a1);
        }

        void sub(const Euler3& a1, const Euler3& a2) {
            yaw_ = (a1.yaw_ - a2.yaw_) & BRAY_MASK;
            pitch_ = (a1.pitch_ - a2.pitch_) & BRAY_MASK;
            roll_ = (a1.roll_ - a2.roll_) & BRAY_MASK;
        }

        void sub(const Euler3& a1) {
            yaw_ = (yaw_ - a1.yaw_) & BRAY_MASK;
            pitch_ = (pitch_ - a1.pitch_) & BRAY_MASK;
            roll_ = (roll_ - a1.roll_) & BRAY_MASK;
        }

        void invert(const Euler3& a1) {
            yaw_ = BrayT::negate(a1.yaw_);
            pitch_ = BrayT::negate(a1.pitch_);
            roll_ = BrayT::negate(a1.roll_);
        }

        void invert() {
            yaw_ = BrayT::negate(yaw_);
            pitch_ = BrayT::negate(pitch_);
            roll_ = BrayT::negate(roll_);
        }


        void scale(scale_t s, const Euler3& a1) {
            yaw_ = BrayT::scale(s, a1.roll_);
            pitch_ = BrayT::scale(s, a1.pitch_);
            roll_ = BrayT::scale(s, a1.roll_);
        }

        void scale(scale_t s) {
            yaw_ = BrayT::scale(s, yaw_);
            pitch_ = BrayT::scale(s, pitch_);
            roll_ = BrayT::scale(s, roll_);
        }

        inline void normalize() {
            yaw_ &= BRAY_MASK;
            pitch_ &= BRAY_MASK;
            roll_ &= BRAY_MASK;
        }

        void scaleAdd(scale_t s, const Euler3& a1, const Euler3& a2) {
            yaw_ = (BrayT::scale(s, a1.roll_) + a2.yaw_) & BRAY_MASK;
            pitch_ = (BrayT::scale(s, a1.pitch_) + a2.pitch_) & BRAY_MASK;
            roll_ = (BrayT::scale(s, a1.roll_) + a2.roll_) & BRAY_MASK;
        }

        void scaleAdd(scale_t s, const Euler3& a1) {
            yaw_ = BrayT::scale(s, yaw_) + a1.yaw_;
            pitch_ = BrayT::scale(s, pitch_) + a1.pitch_;
            roll_ = BrayT::scale(s, roll_) + a1.roll_;
        }


        bool equals(const Euler3& a1) const {
            return yaw_ == a1.yaw_ && pitch_ == a1.pitch_ && roll_ == a1.roll_;
        }

        bool isIdentity() const {
            return yaw_ == 0 && pitch_ == 0 && roll_ == 0;
        }

        bool epsilonEquals(const Euler3& a1, bray_t epsilon) const;

        void interpolate(const Euler3& a1, const Euler3& a2, scale_t alpha) {
            set(a1);
            interpolate(a2, alpha);
        }

        void interpolate(const Euler3& a1, scale_t alpha);


        char* toString(char* buffer) const;

        // copy constructor and operator = is made by complier

        bool operator==(const Euler3& a1) const {
            return equals(a1);
        }

        bray_t operator[](size_type index) const {
            Assert(index < (size_type)DIMENSION);
            switch (index) {
            case 0:
                return yaw_;
            case 1:
                return pitch_;
            case 2:
                return roll_;
            default:
                // error !
                return 0;
            }
        }
        bray_t& operator[](size_type index) {
            static bray_t dummy;
            Assert(index < (size_type)DIMENSION);
            switch (index) {
            case 0:
                return yaw_;
            case 1:
                return pitch_;
            case 2:
                return roll_;
            default:
                // error !
                return dummy;
            }
        }

        Euler3& operator=(const Euler3& a1) {
            set(a1);
            return *this;
        }

        Euler3& operator+=(const Euler3& a1) {
            add(a1);
            return *this;
        }
        Euler3& operator-=(const Euler3& a1) {
            sub(a1);
            return *this;
        }
        Euler3& operator*=(scale_t s) {
            scale(s);
            return *this;
        }
        Euler3 operator+(const Euler3& a1) const {
            return (Euler3(*this)).operator+=(a1);
        }
        Euler3 operator-(const Euler3& a1) const {
            return (Euler3(*this)).operator-=(a1);
        }
        Euler3 operator*(scale_t s) const {
            return (Euler3(*this)).operator*=(s);
        }

        const char* toLog() const;
    };

    se_err::Log& operator<< (se_err::Log& log, const Euler3& t);

} // Namespace

inline
se_core::Euler3 operator*(scale_t s, const se_core::Euler3& a1) {
    return (se_core::Euler3(a1)).operator*=(s);
}


#endif /* ANGLE4_H */

---

Home Page | SagaEngine trunk (updated nightly) reference generated Sun Dec 2 20:06:13 2007 by Doxygen version 1.3.9.1.