VRS - The Virtual Rendering System

version 3.3

quat.h

Go to the documentation of this file.

// quat.h
// Haik Lorenz, HPI, July 2005
//
// DESCRIPTION: a Quaternion class for VRS
// 
//
// $Date: 2005/09/28 10:55:12 $
// $Revision: 1.1 $
// $State: Exp $
// $Author: lorenz $


#ifndef _QUAT_H_
#define _QUAT_H_

#include <vrs/vertexdata.h>
#include <vrs/vector.h>
#include <vrs/matrix.h>

namespace VRS {

    typedef VertexData<4, double> Vector4d;

    class VRS_CORE_API Quat : public VertexData<4, double>
{

    public:

        //double  data_[4];    // a four-vector

        inline Quat() : Vector4d(0.0, 0.0, 0.0, 1.0) {}

        inline Quat( double x, double y, double z, double w ) : Vector4d(x, y, z, w) {}

        inline Quat( const Vector4d &v ) : Vector4d(v) {}

        inline Quat( double angle, const Vector& axis)
        {
            makeRotate(angle,axis);
        }

        inline Quat( double angle1, const Vector& axis1, 
                     double angle2, const Vector& axis2,
                     double angle3, const Vector& axis3)
        {
            makeRotate(angle1,axis1,angle2,axis2,angle3,axis3);
        }

        inline bool operator == (const Quat& v) const { return Vector4d::operator==(v); }

        inline bool operator != (const Quat& v) const { return Vector4d::operator!=(v); }

        inline bool operator <  (const Quat& v) const { return Vector4d::operator<(v); }

        /* ----------------------------------
           Methods to access data members
        ---------------------------------- */

        inline Vector toVec3d() const
        {
            return Vector(data_[0], data_[1], data_[2]);
        }

        inline void set(double x, double y, double z, double w)
        {
            data_[0] = x;
            data_[1] = y;
            data_[2] = z;
            data_[3] = w;
        }
        
        void set(const Matrix &matrix);
        void get(Matrix &matrix) const;

        void set(const Vector &dir, const Vector &up);
        void get(Vector &dir, Vector &up) const;
        
        inline double & x() { return data_[0]; }
        inline double & y() { return data_[1]; }
        inline double & z() { return data_[2]; }
        inline double & w() { return data_[3]; }

        inline double x() const { return data_[0]; }
        inline double y() const { return data_[1]; }
        inline double z() const { return data_[2]; }
        inline double w() const { return data_[3]; }

        bool zeroRotation() const { return data_[0]==0.0 && data_[1]==0.0 && data_[2]==0.0 && data_[3]==1.0; } 


         /* ------------------------------------------------------------- 
                   BASIC ARITHMETIC METHODS            
        Implemented in terms of Vec4s.  Some Vec4 operators, e.g.
        operator* are not appropriate for quaternions (as
        mathematical objects) so they are implemented differently.
        Also define methods for conjugate and the multiplicative inverse.            
        ------------------------------------------------------------- */
        inline const Quat operator * (double rhs) const
        {
            return Quat(data_[0]*rhs, data_[1]*rhs, data_[2]*rhs, data_[3]*rhs);
        }

        inline Quat& operator *= (double rhs)
        {
            data_[0] *= rhs;
            data_[1] *= rhs;
            data_[2] *= rhs;
            data_[3] *= rhs;
            return *this;        // enable nesting
        }

        inline const Quat operator*(const Quat& rhs) const
        {
            return Quat( rhs.data_[3]*data_[0] + rhs.data_[0]*data_[3] + rhs.data_[1]*data_[2] - rhs.data_[2]*data_[1],
                 rhs.data_[3]*data_[1] - rhs.data_[0]*data_[2] + rhs.data_[1]*data_[3] + rhs.data_[2]*data_[0],
                 rhs.data_[3]*data_[2] + rhs.data_[0]*data_[1] - rhs.data_[1]*data_[0] + rhs.data_[2]*data_[3],
                 rhs.data_[3]*data_[3] - rhs.data_[0]*data_[0] - rhs.data_[1]*data_[1] - rhs.data_[2]*data_[2] );
        }

        inline Quat& operator*=(const Quat& rhs)
        {
            double x = rhs.data_[3]*data_[0] + rhs.data_[0]*data_[3] + rhs.data_[1]*data_[2] - rhs.data_[2]*data_[1];
            double y = rhs.data_[3]*data_[1] - rhs.data_[0]*data_[2] + rhs.data_[1]*data_[3] + rhs.data_[2]*data_[0];
            double z = rhs.data_[3]*data_[2] + rhs.data_[0]*data_[1] - rhs.data_[1]*data_[0] + rhs.data_[2]*data_[3];
            data_[3]   = rhs.data_[3]*data_[3] - rhs.data_[0]*data_[0] - rhs.data_[1]*data_[1] - rhs.data_[2]*data_[2];

            data_[2] = z;
            data_[1] = y;
            data_[0] = x;

            return (*this);            // enable nesting
        }

        inline Quat operator / (double rhs) const
        {
            double div = 1.0/rhs;
            return Quat(data_[0]*div, data_[1]*div, data_[2]*div, data_[3]*div);
        }

        inline Quat& operator /= (double rhs)
        {
            double div = 1.0/rhs;
            data_[0] *= div;
            data_[1] *= div;
            data_[2] *= div;
            data_[3] *= div;
            return *this;
        }

        inline const Quat operator/(const Quat& denom) const
        {
            return ( (*this) * denom.inverse() );
        }

        inline Quat& operator/=(const Quat& denom)
        {
            (*this) = (*this) * denom.inverse();
            return (*this);            // enable nesting
        }

        inline const Quat operator + (const Quat& rhs) const
        {
            return Quat(data_[0]+rhs.data_[0], data_[1]+rhs.data_[1],
                data_[2]+rhs.data_[2], data_[3]+rhs.data_[3]);
        }

        inline Quat& operator += (const Quat& rhs)
        {
            data_[0] += rhs.data_[0];
            data_[1] += rhs.data_[1];
            data_[2] += rhs.data_[2];
            data_[3] += rhs.data_[3];
            return *this;            // enable nesting
        }

        inline const Quat operator - (const Quat& rhs) const
        {
            return Quat(data_[0]-rhs.data_[0], data_[1]-rhs.data_[1],
                data_[2]-rhs.data_[2], data_[3]-rhs.data_[3] );
        }

        inline Quat& operator -= (const Quat& rhs)
        {
            data_[0] -= rhs.data_[0];
            data_[1] -= rhs.data_[1];
            data_[2] -= rhs.data_[2];
            data_[3] -= rhs.data_[3];
            return *this;            // enable nesting
        }

        inline const Quat operator - () const
        {
            return Quat (-data_[0], -data_[1], -data_[2], -data_[3]);
        }

        double abs() const
        {
            return sqrt( data_[0]*data_[0] + data_[1]*data_[1] + data_[2]*data_[2] + data_[3]*data_[3]);
        }

        double abs2() const
        {
            return data_[0]*data_[0] + data_[1]*data_[1] + data_[2]*data_[2] + data_[3]*data_[3];
        }

        inline Quat conj() const
        { 
             return Quat( -data_[0], -data_[1], -data_[2], data_[3] );
        }

        inline const Quat inverse () const
        {
             return conj() / abs2();
         }

      /* -------------------------------------------------------- 
               METHODS RELATED TO ROTATIONS
        Set a quaternion which will perform a rotation of an
        angle around the axis given by the vector (x,y,z).
        Should be written to also accept an angle and a Vec3?

        Define Spherical Linear interpolation method also

        Not inlined - see the Quat.cpp file for implementation
        -------------------------------------------------------- */
        void makeRotate( double  angle, 
                          double  x, double  y, double  z );
        void makeRotate ( double  angle, const Vector& vec );

        void makeRotate ( double  angle1, const Vector& axis1, 
                          double  angle2, const Vector& axis2,
                          double  angle3, const Vector& axis3);

        void makeRotate(const Vector &vec1, const Vector &vec2 );
    
        void getRotate(double &angle, double &x, double &y, double &z ) const;

        void getRotate(double &angle, Vector &vec ) const;

        void slerp(double t, const Quat &from, const Quat &to);
               
        Vector operator*(const Vector& v) const
        {
            // nVidia SDK implementation
            Vector uv, uuv; 
            Vector qvec(data_[0], data_[1], data_[2]);
            uv = qvec * v;
            uuv = qvec * uv; 
            uv *= ( 2.0f * data_[3] ); 
            uuv *= 2.0f; 
            return v + uv + uuv;
        }
               
        friend inline std::ostream& operator << (std::ostream& output, const Quat& vec);
        
        VRS_SERIALIZABLE_NO_SO_CLASS(Quat);

    protected:
    
};    // end of class prototype

inline std::ostream& operator << (std::ostream& output, const Quat& vec)
{
    output << vec.data_[0] << " "
       << vec.data_[1] << " "
       << vec.data_[2] << " "
       << vec.data_[3];
    return output;     // to enable cascading
}

}    // end of namespace

#endif 

---

Generated on Wed May 23 06:00:13 2012 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact