source: orxonox.OLD/orxonox/branches/shadows/src/importer/vector.h @ 3965

/*! 
    \file vector.h
    \brief A basic 3D math framework
    
    Contains classes to handle vectors, lines, rotations and planes
*/ 

#ifndef _VECTOR_H
#define _VECTOR_H

#include <math.h>
#define PI 3.14159265359f

//! 3D Vector
/**
        Class to handle 3D Vectors
*/
class Vector {

  public:
 
  float x, y, z;

  Vector (float x, float y, float z) : x(x), y(y), z(z) {}  //!< assignment constructor
  Vector () : x(0), y(0), z(0) {}
  ~Vector () {}

  Vector operator+ (const Vector& v) const;
  Vector operator- (const Vector& v) const;
  float operator* (const Vector& v) const;
  Vector operator* (float f) const;
  Vector operator/ (float f) const;
  float dot (const Vector& v) const;
  Vector cross (const Vector& v) const;
  void scale(const Vector& v);
  float len() const;
  void normalize();
  Vector* getNormalized();
  Vector abs();
};

float angleDeg (const Vector& v1, const Vector& v2);
float angleRad (const Vector& v1, const Vector& v2);

//! Quaternion
/**
        Class to handle 3-dimensional rotation efficiently
*/
class Quaternion
{
 public:
        Vector v;       //!< Imaginary Vector
        float w; //!< Real part of the number

        Quaternion ();
        Quaternion (float m[4][4]);
        Quaternion (float angle, const Vector& axis);
        Quaternion (const Vector& dir, const Vector& up);
        Quaternion (float roll, float pitch, float yaw);
        
        Quaternion operator/ (const float& f) const;
        Quaternion operator* (const float& f) const;
        Quaternion operator* (const Quaternion& q) const;
        Quaternion operator+ (const Quaternion& q) const;
        Quaternion operator- (const Quaternion& q) const;
        Quaternion conjugate () const;
        Quaternion inverse () const;
        Vector apply (Vector& f) const;
        float norm () const;
        void matrix (float m[4][4]) const;
        void quatSlerp(const Quaternion* from, const Quaternion* to, const float t, Quaternion* res);

 private:
        float DELTA;

};

//! 3D rotation (OBSOLETE)
/**
  Class to handle 3-dimensional rotations.
  Can create a rotation from several inputs, currently stores rotation using a 3x3 Matrix
*/
class Rotation {
  public:
  
  float m[9]; //!< 3x3 Rotation Matrix
  
  Rotation ( const Vector& v);
  Rotation ( const Vector& axis, float angle);
  Rotation ( float pitch, float yaw, float roll);
  Rotation ();
  ~Rotation () {}
  
  Rotation operator* (const Rotation& r);
  
  void glmatrix (float* buffer);
};

//!< Apply a rotation to a vector
Vector rotateVector( const Vector& v, const Rotation& r);

//! 3D line
/**
  Class to store Lines in 3-dimensional space

  Supports line-to-line distance measurements and rotation
*/
class Line
{
  public:
  
  Vector r;   //!< Offset
  Vector a;   //!< Direction
  
  Line ( Vector r, Vector a) : r(r), a(a) {}  //!< assignment constructor
  Line () : r(Vector(0,0,0)), a(Vector (1,1,1)) {}
  ~Line () {}
  
  float distance (const Line& l) const;
  float distancePoint (const Vector& v) const;
  Vector* footpoints (const Line& l) const;
  float len () const;
  
  void rotate(const Rotation& rot);
};

//! 3D plane
/**
  Class to handle planes in 3-dimensional space
  
  Critical for polygon-based collision detection
*/
class Plane
{
  public:
  
  Vector n;   //!< Normal vector
  float k;    //!< Offset constant
  
  Plane (Vector a, Vector b, Vector c);
  Plane (Vector norm, Vector p);
  Plane (Vector n, float k) : n(n), k(k) {} //!< assignment constructor
  Plane () : n(Vector(1,1,1)), k(0) {}
  ~Plane () {}
  
  Vector intersectLine (const Line& l) const;
  float distancePoint (const Vector& p) const;
  float locatePoint (const Vector& p) const;
};



//! Bezier Curve
/**
   Class to handle bezier curves in 3-dimesnsional space
   
   needed for  the Tracking system in OrxOnoX.
*/
class BezierCurve
{
 private:
  int nodeCount;
  Vector curvePoint;
  
  struct PathNode
  {
    int number;
    Vector position;
    PathNode* next;
  };

  PathNode* firstNode; 
  PathNode* currentNode; 

 public:
  BezierCurve (void);
  ~BezierCurve (void);
  void addNode (const Vector& newNode);
  Vector calcPos (float t);
  Vector calcDirection (float t);
  
  Vector getPos () const;
};



#endif /* _VECTOR_H */