---

Quaternion.h

/*
  File: Quaternion.h

  Copyright(C) C. Kotterink, Computed Graphics
*/
#ifndef QUATERNION_H
#define QUATERNION_H

#include<Vertex3.h>
#include<Matrix3.h>

#include<real.h>
#include<iostream.h>

class ObjectFile;

class Quaternion
{
    friend ostream &operator<<(ostream &stream, Quaternion &q);
    friend ObjectFile &operator>>(ObjectFile &f, Quaternion &q);
public:
    // Constructors
    Quaternion() {};
    Quaternion(real xx, real yy, real zz, real ww)
        : x(xx), y(yy), z(zz), w(ww) {}
    Quaternion(const Vertex3 &v, real angle);
    Quaternion(const Quaternion &q) : x(q.x), y(q.y), z(q.z), w(q.w) {}

    void identity();
    void trackball(real px, real py, real qx, real qy);

    // Get/Set
    real &operator [](unsigned int i) {
        ((real*)(this))[i];
    }
    void setRotation(const Vertex3 &v, real angle);
    void getRotation(Vertex3 &v, real &angle);

    // Assignment operators
    Quaternion &operator =(const Quaternion &q) {
        x = q.x;
        y = q.y;
        z = q.z;
        w = q.w;
        return *this;
    }
    void operator -=(const Quaternion &q) {
        x -= q.x;
        y -= q.y;
        z -= q.z;
        w -= q.w;
    }
    void operator += (const Quaternion &q) {
        x += q.x;
        y += q.y;
        z += q.z;
        w += q.w;
    }
    void operator *= (const Quaternion &q) {
        real xx = w*q.x + x*q.w + y*q.z - z*q.y;
        real yy = w*q.y - x*q.z + y*q.w + z*q.x;
        real zz = w*q.z + x*q.y - y*q.x + z*q.w;
        w = w*q.w - x*q.x - y*q.y - z*q.z;
        x = xx;
        y = yy;
        z = zz;
    }
    void operator *=(real r) {
        x *= r;
        y *= r;
        z *= r;
        w *= r;
    }
    void operator /=(Quaternion q) {
        *this *= !q;
    }
    void operator /=(real r) {
        x /= r;
        y /= r;
        z /= r;
        w /= r;
    }

    // Linear interpolation
    void slerp(const Quaternion &p,const Quaternion &q, double t);
    
    // Operators
    Quaternion operator ~() const {             // Conjugate
        Quaternion q(-x, -y, -z, w);
        return q;
    }
    Quaternion operator !() const {             // Multiplicative inverse
        Quaternion q;
        real n = x*x + y*y + z*z + w*w;
        q.x = x/n;
        q.y = y/n;
        q.z = z/n;
        q.w = w/n;
        return q;
    }
    Quaternion operator -(const Quaternion &q) const {
        Quaternion qq(x - q.x, y - q.y, z - q.z, w);
        return qq;
    }
    Quaternion operator +(const Quaternion &q) const {
        Quaternion qq(x + q.x, y + q.y, z + q.z, w + q.w);
        return qq;
    }
    Quaternion operator *(const Quaternion &q) const {
        Quaternion qq;
        qq.x = w*q.x + x*q.w + y*q.z - z*q.y;
        qq.y = w*q.y - x*q.z + y*q.w + z*q.x;
        qq.z = w*q.z + x*q.y - y*q.x + z*q.w;
        qq.w  = w*q.w - x*q.x - y*q.y - z*q.w;
        return qq;
    }
    Quaternion operator *(real r) const {
        Quaternion qq(x * r, y * r, z * r, w * r);
        return qq;
    }
    Quaternion operator /(const Quaternion &q) const {
        Quaternion qq;
        qq = *this * !q;
        return qq;
    }
    Quaternion operator /(real r) const {
        Quaternion qq(x / r, y / r, z / r, w / r);
        return qq;
    }

    real norm() const;
    Quaternion &normalize() {
        *this /= norm();
        return *this;
    }

    real x, y, z, w;
};
#endif

---

This documentation was generated using doxygen. If you have any comments or additions please mail me.