Quat4.hpp

Go to the documentation of this file.

/*
   Copyright (C) 1997,1998,1999
   Kenji Hiranabe, Eiwa System Management, Inc.

   This program is free software.
   Implemented by Kenji Hiranabe(hiranabe@esm.co.jp),
   conforming to the Java(TM) 3D API specification by Sun Microsystems.

   Permission to use, copy, modify, distribute and sell this software
   and its documentation for any purpose is hereby granted without fee,
   provided that the above copyright notice appear in all copies and
   that both that copyright notice and this permission notice appear
   in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc.
   makes no representations about the suitability of this software for any
   purpose.  It is provided "AS IS" with NO WARRANTY.

   Copyright (C) 2006
   Rune Myrland, Skalden Studio AS
   SagaEngine adaptions, involving conversion from floating point values to fixed point values.
   Kenji Hiranabe's license apply.
*/
#ifndef util_vecmath_Quat4_hpp
#define util_vecmath_Quat4_hpp

#include "Tuple4.hpp"
#include "../math/CoorT.hpp"
#include "../math/QuatT.hpp"

namespace se_core {
    class _SeCoreExport Quat4 : public Tuple4 {
    public:
        Quat4(coor_t x, coor_t y, coor_t z, coor_t w): Tuple4(x, y, z, w) { }

        Quat4(const coor_t v[]) : Tuple4(v) { }


        Quat4(const Tuple4& t1): Tuple4(t1) { }


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

        Quat4(const AxisAngle4& a1) { 
            set(a1);
        }

        Quat4(): Tuple4() { }

        void set(const Tuple4& t1) {
            Tuple4::set(t1);
        }


        void setIdentity() {
            set(0, 0, 0, 1);
        }

        void set(coor_t x, coor_t y, coor_t z, coor_t w) {
            Tuple4::set(x, y, z, w);
        }


        void conjugate(const Quat4& q1) {
            x_ = -q1.x_;
            y_ = -q1.y_;
            z_ = -q1.z_;
            w_ = q1.w_;
        }

        void conjugate() {
            x_ = -x_;
            y_ = -y_;
            z_ = -z_;
        }

        void mul(const Quat4& q1, const Quat4& q2);

        void mul(const Quat4& q1);


        inline void rotate(const Quat4& q1) {
            mul(q1);
        }

        inline void rotateInverse(const Quat4& q1) {
            mulInverse(q1);
        }


        void mulInverse(const Quat4& q1, const Quat4& q2);

        void mulInverse(const Quat4& q1);

    protected:
        coor_double_t norm() const {
            return QuatT::pow2(x_) + QuatT::pow2(y_) + QuatT::pow2(z_) + QuatT::pow2(w_);
        }

    public:
        void inverse(const Quat4& q1) {
            scale_t n = QuatT::oneOver( q1.norm() );
            // zero-div may occur.
            x_ = -QuatT::scale(n, q1.x_);
            y_ = -QuatT::scale(n, q1.y_);
            z_ = -QuatT::scale(n, q1.z_);
            w_ = QuatT::scale(n, q1.w_);
        }

        void inverse() {
            scale_t n = QuatT::oneOver( norm() );
            // zero-div may occur.

            x_ = -QuatT::scale(n, x_);
            y_ = -QuatT::scale(n, y_);
            z_ = -QuatT::scale(n, z_);
            w_ = QuatT::scale(n, w_);
        }

        void normalize(const Quat4& q1) {
            scale_t n = QuatT::oneOver( CoorT::sqrt( q1.norm() ) );
            // zero-div may occur.
            x_ = QuatT::scale(n, q1.x_);
            y_ = QuatT::scale(n, q1.y_);
            z_ = QuatT::scale(n, q1.z_);
            w_ = QuatT::scale(n, q1.w_);
        }

        void normalize() {
            scale_t n = QuatT::oneOver( CoorT::sqrt( norm() ) );
            // zero-div may occur.

            x_ = QuatT::scale(n, x_);
            y_ = QuatT::scale(n, y_);
            z_ = QuatT::scale(n, z_);
            w_ = QuatT::scale(n, w_);
        }


        bool isNormalized() const {
            #ifdef SE_FIXED_POINT
            LogFatal("Not yet implemented");
            return true;
            #else
            coor_double_t n = norm();
            const coor_double_t EPSILON = 0.00001f;
            return (n + EPSILON > 1 && n - EPSILON < 1);
            #endif
        }

        bool isIdentity() const {
            return x_ == 0 && y_ == 0 && z_ == 0 && w_ == 1;
        }

        void set(const AxisAngle4& a1);

        void set(const Euler3& a1);

        void setYaw(const bray_t yaw);
        void setPitch(const bray_t pitch);
        void setRoll(const bray_t roll);
        void setYawAndPitch(const bray_t yaw, const bray_t pitch);
        void setEuler(const bray_t yaw, const bray_t pitch, const bray_t roll);
        
        void slerp(const Quat4& q1, scale_t alpha, bool findShortestPath = false);

        void slerp(const Quat4& q1, const Quat4& q2, scale_t alpha, bool findShortestPath = false);

        void interpolate(const Quat4& q1, scale_t alpha) {
            slerp(q1, alpha, true);
        }


        void interpolate(const Quat4& q1, const Quat4& q2, scale_t alpha) {
            slerp(q1, q2, alpha, true);
        }


        void scale(scale_t alpha) {
            slerp(Quat4::IDENTITY, 1 - alpha, true);
        }
        // copy constructor and operator = is made by complier

        //Quat4& operator*=(const Quat4& m1);
        //Quat4 operator*(const Quat4& m1) const;

        static const Quat4 IDENTITY;
    };


}



#endif /* QUAT4__H */

---

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