Changeset 6616 in orxonox.OLD for trunk/src/lib

Timestamp:

Jan 19, 2006, 12:27:45 PM (19 years ago)

Author:

bensch

Message:

orxonox/trunk: taken the quaternion outside of Vector.cc to quaternion.cc/h

Location:

trunk/src/lib

Files:

• Makefile.am (modified) (2 diffs)
• coord/p_node.cc (modified) (6 diffs)
• coord/p_node.h (modified) (2 diffs)
• math/curve.h (modified) (1 diff)
• math/quaternion.cc (copied) (copied from trunk/src/lib/math/vector.cc) (3 diffs)
• math/quaternion.h (copied) (copied from trunk/src/lib/math/vector.h) (3 diffs)
• math/vector.cc (modified) (1 diff)
• math/vector.h (modified) (1 diff)
• math/vector2D.h (modified) (1 diff)
• physics/physics_interface.h (modified) (1 diff)

trunk/src/lib/Makefile.am

@@ -43 +43 @@
                         util/executor/executor.cc \
                         math/vector.cc \
+                        math/quaternion.cc \
                         math/vector2D.cc \
                         math/matrix.cc \
@@ -64 +65 @@
                         util/executor/functor_list.h \
                         math/vector.h \
+                        math/quaternion.h \
                         math/vector2D.h \
                         math/matrix.h \

trunk/src/lib/coord/p_node.cc

@@ -214 +214 @@
 
   *this->toCoordinate = relCoordSoft;
+  this->toStep = 0.0f;
   this->bias = bias;
 }
@@ -299 +300 @@
       *this->toCoordinate = absCoordSoft;
   }
+  this->toStep = 0.0f;
 }
 
@@ -370 +372 @@
   *this->toDirection = relDirSoft;
   this->bias = bias;
+  this->toStep = 0.0f;
   this->bRelDirChanged = true;
 }
@@ -439 +442 @@
 
   this->bias = bias;
+  this->toStep = 0.0f;
   this->bRelDirChanged = true;
 }
@@ -614 +618 @@
   }
   this->bias = bias;
-
+  this->toStep = 0.0f;
 
   Vector tmpV = this->getAbsCoor();
@@ -743 +747 @@
         if (unlikely(this->toDirection != NULL))
         {
-          Quaternion rotQuat = Quaternion::quatSlerp(this->relDirection,*this->toDirection, fabsf(dt)*this->bias);
+          this->toStep += fabs(dt) * bias;
+          printf("%s::%s %f\n", this->getClassName(), this->getName(), this->toStep );
+          Quaternion rotQuat = Quaternion::quatSlerp(this->relDirection,*this->toDirection, toStep);
           if (this->relDirection.distance(rotQuat) >PNODE_ITERATION_DELTA)
           {

trunk/src/lib/coord/p_node.h

@@ -24 +24 @@
 
 #include "vector.h"
+#include "quaternion.h"
 #include <list>
 
@@ -218 +219 @@
   Quaternion*        toDirection;        //!< a direction to which to iterate. (This is used in conjunction with setParentSoft and set*DirSoft)
   float              bias;               //!< how fast to iterate to the given position (default is 1)
+  float              toStep;
 
   PNode*             parent;             //!< a pointer to the parent node.

trunk/src/lib/math/curve.h

@@ -11 +11 @@
 
 #include "vector.h"
+#include "quaternion.h"
 
 template<class T> class tList;

trunk/src/lib/math/quaternion.cc

@@ -21 +21 @@
 #define DEBUG_SPECIAL_MODULE DEBUG_MODULE_MATH
 
-#include "vector.h"
+#include "quaternion.h"
 #ifdef DEBUG
   #include "debug.h"
@@ -30 +30 @@
 
 using namespace std;
-
-/////////////
-/* VECTORS */
-/////////////
-/**
- *  returns the this-vector normalized to length 1.0
- * @todo there is some error in this function, that i could not resolve. it just does not, what it is supposed to do.
- */
-Vector Vector::getNormalized() const
-{
-  float l = this->len();
-  if(unlikely(l == 1.0 || l == 0.0))
-    return *this;
-  else
-    return (*this / l);
-}
-
-/**
- *  Vector is looking in the positive direction on all axes after this
-*/
-Vector Vector::abs()
-{
-  Vector v(fabs(x), fabs(y), fabs(z));
-  return v;
-}
-
-
-
-/**
- *  Outputs the values of the Vector
- */
-void Vector::debug() const
-{
-  PRINT(0)("x: %f; y: %f; z: %f", x, y, z);
-  PRINT(0)(" lenght: %f", len());
-  PRINT(0)("\n");
-}
 
 /////////////////
@@ -274 +237 @@
   PRINT(0)("angle = %f, axis: ax=%f, ay=%f, az=%f\n", this->getSpacialAxisAngle(), axis.x, axis.y, axis.z );
 }
-
-/**
- *  create a rotation from a vector
- * @param v: a vector
-*/
-Rotation::Rotation (const Vector& v)
-{
-  Vector x = Vector( 1, 0, 0);
-  Vector axis = x.cross( v);
-  axis.normalize();
-  float angle = angleRad( x, v);
-  float ca = cos(angle);
-  float sa = sin(angle);
-  m[0] = 1.0f+(1.0f-ca)*(axis.x*axis.x-1.0f);
-  m[1] = -axis.z*sa+(1.0f-ca)*axis.x*axis.y;
-  m[2] = axis.y*sa+(1.0f-ca)*axis.x*axis.z;
-  m[3] = axis.z*sa+(1.0f-ca)*axis.x*axis.y;
-  m[4] = 1.0f+(1.0f-ca)*(axis.y*axis.y-1.0f);
-  m[5] = -axis.x*sa+(1.0f-ca)*axis.y*axis.z;
-  m[6] = -axis.y*sa+(1.0f-ca)*axis.x*axis.z;
-  m[7] = axis.x*sa+(1.0f-ca)*axis.y*axis.z;
-  m[8] = 1.0f+(1.0f-ca)*(axis.z*axis.z-1.0f);
-}
-
-/**
- *  creates a rotation from an axis and an angle (radians!)
- * @param axis: the rotational axis
- * @param angle: the angle in radians
-*/
-Rotation::Rotation (const Vector& axis, float angle)
-{
-  float ca, sa;
-  ca = cos(angle);
-  sa = sin(angle);
-  m[0] = 1.0f+(1.0f-ca)*(axis.x*axis.x-1.0f);
-  m[1] = -axis.z*sa+(1.0f-ca)*axis.x*axis.y;
-  m[2] = axis.y*sa+(1.0f-ca)*axis.x*axis.z;
-  m[3] = axis.z*sa+(1.0f-ca)*axis.x*axis.y;
-  m[4] = 1.0f+(1.0f-ca)*(axis.y*axis.y-1.0f);
-  m[5] = -axis.x*sa+(1.0f-ca)*axis.y*axis.z;
-  m[6] = -axis.y*sa+(1.0f-ca)*axis.x*axis.z;
-  m[7] = axis.x*sa+(1.0f-ca)*axis.y*axis.z;
-  m[8] = 1.0f+(1.0f-ca)*(axis.z*axis.z-1.0f);
-}
-
-/**
- *  creates a rotation from euler angles (pitch/yaw/roll)
- * @param pitch: rotation around z (in radians)
- * @param yaw: rotation around y (in radians)
- * @param roll: rotation around x (in radians)
-*/
-Rotation::Rotation ( float pitch, float yaw, float roll)
-{
-  float cy, sy, cr, sr, cp, sp;
-  cy = cos(yaw);
-  sy = sin(yaw);
-  cr = cos(roll);
-  sr = sin(roll);
-  cp = cos(pitch);
-  sp = sin(pitch);
-  m[0] = cy*cr;
-  m[1] = -cy*sr;
-  m[2] = sy;
-  m[3] = cp*sr+sp*sy*cr;
-  m[4] = cp*cr-sp*sr*sy;
-  m[5] = -sp*cy;
-  m[6] = sp*sr-cp*sy*cr;
-  m[7] = sp*cr+cp*sy*sr;
-  m[8] = cp*cy;
-}
-
-/**
- *  creates a nullrotation (an identity rotation)
-*/
-Rotation::Rotation ()
-{
-  m[0] = 1.0f;
-  m[1] = 0.0f;
-  m[2] = 0.0f;
-  m[3] = 0.0f;
-  m[4] = 1.0f;
-  m[5] = 0.0f;
-  m[6] = 0.0f;
-  m[7] = 0.0f;
-  m[8] = 1.0f;
-}
-
-/**
- *  fills the specified buffer with a 4x4 glmatrix
- * @param buffer: Pointer to an array of 16 floats
-
-   Use this to get the rotation in a gl-compatible format
-*/
-void Rotation::glmatrix (float* buffer)
-{
-        buffer[0] = m[0];
-        buffer[1] = m[3];
-        buffer[2] = m[6];
-        buffer[3] = m[0];
-        buffer[4] = m[1];
-        buffer[5] = m[4];
-        buffer[6] = m[7];
-        buffer[7] = m[0];
-        buffer[8] = m[2];
-        buffer[9] = m[5];
-        buffer[10] = m[8];
-        buffer[11] = m[0];
-        buffer[12] = m[0];
-        buffer[13] = m[0];
-        buffer[14] = m[0];
-        buffer[15] = m[1];
-}
-
-/**
- *  multiplies two rotational matrices
- * @param r: another Rotation
- * @return the matrix product of the Rotations
-
-   Use this to rotate one rotation by another
-*/
-Rotation Rotation::operator* (const Rotation& r)
-{
-        Rotation p;
-
-        p.m[0] = m[0]*r.m[0] + m[1]*r.m[3] + m[2]*r.m[6];
-        p.m[1] = m[0]*r.m[1] + m[1]*r.m[4] + m[2]*r.m[7];
-        p.m[2] = m[0]*r.m[2] + m[1]*r.m[5] + m[2]*r.m[8];
-
-        p.m[3] = m[3]*r.m[0] + m[4]*r.m[3] + m[5]*r.m[6];
-        p.m[4] = m[3]*r.m[1] + m[4]*r.m[4] + m[5]*r.m[7];
-        p.m[5] = m[3]*r.m[2] + m[4]*r.m[5] + m[5]*r.m[8];
-
-        p.m[6] = m[6]*r.m[0] + m[7]*r.m[3] + m[8]*r.m[6];
-        p.m[7] = m[6]*r.m[1] + m[7]*r.m[4] + m[8]*r.m[7];
-        p.m[8] = m[6]*r.m[2] + m[7]*r.m[5] + m[8]*r.m[8];
-
-        return p;
-}
-
-
-/**
- *  rotates the vector by the given rotation
- * @param v: a vector
- * @param r: a rotation
- * @return the rotated vector
-*/
-Vector rotateVector( const Vector& v, const Rotation& r)
-{
-  Vector t;
-
-  t.x = v.x * r.m[0] + v.y * r.m[1] + v.z * r.m[2];
-  t.y = v.x * r.m[3] + v.y * r.m[4] + v.z * r.m[5];
-  t.z = v.x * r.m[6] + v.y * r.m[7] + v.z * r.m[8];
-
-  return t;
-}
-
-/**
- *  calculate the distance between two lines
- * @param l: the other line
- * @return the distance between the lines
-*/
-float Line::distance (const Line& l) const
-{
-  float q, d;
-  Vector n = a.cross(l.a);
-  q = n.dot(r-l.r);
-  d = n.len();
-  if( d == 0.0) return 0.0;
-  return q/d;
-}
-
-/**
- *  calculate the distance between a line and a point
- * @param v: the point
- * @return the distance between the Line and the point
-*/
-float Line::distancePoint (const Vector& v) const
-{
-  Vector d = v-r;
-  Vector u = a * d.dot( a);
-  return (d - u).len();
-}
-
-/**
- *  calculate the distance between a line and a point
- * @param v: the point
- * @return the distance between the Line and the point
- */
-float Line::distancePoint (const sVec3D& v) const
-{
-  Vector s(v[0], v[1], v[2]);
-  Vector d = s - r;
-  Vector u = a * d.dot( a);
-  return (d - u).len();
-}
-
-/**
- *  calculate the two points of minimal distance of two lines
- * @param l: the other line
- * @return a Vector[2] (!has to be deleted after use!) containing the two points of minimal distance
-*/
-Vector* Line::footpoints (const Line& l) const
-{
-  Vector* fp = new Vector[2];
-  Plane p = Plane (r + a.cross(l.a), r, r + a);
-  fp[1] = p.intersectLine (l);
-  p = Plane (fp[1], l.a);
-  fp[0] = p.intersectLine (*this);
-  return fp;
-}
-
-/**
-  \brief calculate the length of a line
-  \return the lenght of the line
-*/
-float Line::len() const
-{
-  return a.len();
-}
-
-/**
- *  rotate the line by given rotation
- * @param rot: a rotation
-*/
-void Line::rotate (const Rotation& rot)
-{
-  Vector t = a + r;
-  t = rotateVector( t, rot);
-  r = rotateVector( r, rot),
-  a = t - r;
-}
-
-/**
- *  create a plane from three points
- * @param a: first point
- * @param b: second point
- * @param c: third point
-*/
-Plane::Plane (const Vector& a, const Vector& b, const Vector& c)
-{
-  n = (a-b).cross(c-b);
-  k = -(n.x*b.x+n.y*b.y+n.z*b.z);
-}
-
-/**
- *  create a plane from anchor point and normal
- * @param norm: normal vector
- * @param p: anchor point
-*/
-Plane::Plane (const Vector& norm, const Vector& p)
-{
-  n = norm;
-  k = -(n.x*p.x+n.y*p.y+n.z*p.z);
-}
-
-
-/**
-  *  create a plane from anchor point and normal
-  * @param norm: normal vector
-  * @param p: anchor point
-*/
-Plane::Plane (const Vector& norm, const sVec3D& g)
-{
-  Vector p(g[0], g[1], g[2]);
-  n = norm;
-  k = -(n.x*p.x+n.y*p.y+n.z*p.z);
-}
-
-
-/**
- *  returns the intersection point between the plane and a line
- * @param l: a line
-*/
-Vector Plane::intersectLine (const Line& l) const
-{
-  if (n.x*l.a.x+n.y*l.a.y+n.z*l.a.z == 0.0) return Vector(0,0,0);
-  float t = (n.x*l.r.x+n.y*l.r.y+n.z*l.r.z+k) / (n.x*l.a.x+n.y*l.a.y+n.z*l.a.z);
-  return l.r + (l.a * t);
-}
-
-/**
- *  returns the distance between the plane and a point
- * @param p: a Point
- * @return the distance between the plane and the point (can be negative)
-*/
-float Plane::distancePoint (const Vector& p) const
-{
-  float l = n.len();
-  if( l == 0.0) return 0.0;
-  return (n.dot(p) + k) / n.len();
-}
-
-
-/**
- *  returns the distance between the plane and a point
- * @param p: a Point
- * @return the distance between the plane and the point (can be negative)
- */
-float Plane::distancePoint (const sVec3D& p) const
-{
-  Vector s(p[0], p[1], p[2]);
-  float l = n.len();
-  if( l == 0.0) return 0.0;
-  return (n.dot(s) + k) / n.len();
-}
-
-
-/**
- *  returns the side a point is located relative to a Plane
- * @param p: a Point
- * @return 0 if the point is contained within the Plane, positive(negative) if the point is in the positive(negative) semi-space of the Plane
-*/
-float Plane::locatePoint (const Vector& p) const
-{
-  return (n.dot(p) + k);
-}
-

trunk/src/lib/math/quaternion.h

@@ -15 +15 @@
 
 /*!
- * @file vector.h
- * A basic 3D math framework
+ * @file quaternion.h
+ * A basic 3D quaternion math framework
  *
  * Contains classes to handle vectors, lines, rotations and planes
 */
 
-#ifndef __VECTOR_H_
-#define __VECTOR_H_
+#ifndef __QUATERNION_H_
+#define __QUATERNION_H_
 
 #include <math.h>
@@ -28 +28 @@
 //! PI the circle-constant
 #define PI 3.14159265359f
-
-
-//! this is a small and performant 3D vector
-typedef float sVec3D[3];
-
-
-//! small and performant 2D vector
-typedef float sVec2D[2];
-
-
-
-//! 3D Vector
-/**
-        Class to handle 3D Vectors
-*/
-class Vector {
- public:
-  Vector (float x, float y, float z) : x(x), y(y), z(z) {}  //!< assignment constructor
-  Vector () : x(0), y(0), z(0) {}
-  ~Vector () {}
-
-  /** @param v: the Vecor to compare with this one @returns true, if the Vecors are the same, false otherwise */
-  inline bool operator== (const Vector& v) const { return (this->x==v.x&&this->y==v.y&&this->z==v.z)?true:false; };
-  /** @param index The index of the "array" @returns the x/y/z coordinate */
-  inline float operator[] (float index) const {if( index == 0) return this->x; if( index == 1) return this->y; if( index == 2) return this->z; }
-  /** @param v The vector to add @returns the addition between two vectors (this + v) */
-  inline Vector operator+ (const Vector& v) const { return Vector(x + v.x, y + v.y, z + v.z); };
-  /** @param v The vector to add @returns the addition between two vectors (this + v) */
-  inline Vector operator+ (const sVec3D& v) const { return Vector(x + v[0], y + v[1], z + v[2]); };
-  /** @param v The vector to add  @returns the addition between two vectors (this += v) */
-  inline const Vector& operator+= (const Vector& v) { this->x += v.x; this->y += v.y; this->z += v.z; return *this; };
-  /** @param v The vector to substract  @returns the substraction between two vectors (this - v) */
-  inline const Vector& operator+= (const sVec3D& v) { this->x += v[0]; this->y += v[1]; this->z += v[2]; return *this; };
-  /** @param v The vector to substract  @returns the substraction between two vectors (this - v) */
-  inline Vector operator- (const Vector& v) const { return Vector(x - v.x, y - v.y, z - v.z); }
-  /** @param v The vector to substract  @returns the substraction between two vectors (this - v) */
-  inline Vector operator- (const sVec3D& v) const { return Vector(x - v[0], y - v[1], z - v[2]); }
-  /** @param v The vector to substract  @returns the substraction between two vectors (this -= v) */
-  inline const Vector& operator-= (const Vector& v) { this->x -= v.x; this->y -= v.y; this->z -= v.z; return *this; };
-  /** @param v The vector to substract  @returns the substraction between two vectors (this -= v) */
-  inline const Vector& operator-= (const sVec3D& v) { this->x -= v[0]; this->y -= v[1]; this->z -= v[2]; return *this; };
-  /** @param v the second vector  @returns The dotProduct between two vector (this (dot) v) */
-  inline float operator* (const Vector& v) const { return x * v.x + y * v.y + z * v.z; };
-  /** @todo strange */
-  inline const Vector& operator*= (const Vector& v) { this->x *= v.x; this->y *= v.y; this->z *= v.z; return *this; };
-  /** @param f a factor to multiply the vector with @returns the vector multiplied by f (this * f) */
-  inline Vector operator* (float f) const { return Vector(x * f, y * f, z * f); };
-  /** @param f a factor to multiply the vector with @returns the vector multiplied by f (this *= f) */
-  inline const Vector& operator*= (float f) { this->x *= f; this->y *= f; this->z *= f; return *this; };
-  /** @param f a factor to divide the vector with @returns the vector divided by f (this / f) */
-  inline Vector operator/ (float f) const { return (unlikely(f == 0.0))?Vector(0,0,0):Vector(this->x / f, this->y / f, this->z / f); };
-  /** @param f a factor to divide the vector with @returns the vector divided by f (this /= f) */
-  inline const Vector& operator/= (float f) {if (unlikely(f == 0.0)) {this->x=0;this->y=0;this->z=0;} else {this->x /= f; this->y /= f; this->z /= f;} return *this; };
-  /**  copy constructor @todo (i do not know it this is faster) @param v the vector to assign to this vector. @returns the vector v */
-  inline const Vector& operator= (const Vector& v) { this->x = v.x; this->y = v.y; this->z = v.z; return *this; };
-  /** copy constructor* @param v the sVec3D to assign to this vector. @returns the vector v */
-  inline const Vector& operator= (const sVec3D& v) { this->x = v[0]; this->y = v[1]; this->z = v[2]; }
-  /** @param v: the other vector \return the dot product of the vectors */
-  float dot (const Vector& v) const { return x*v.x+y*v.y+z*v.z; };
-  /** @param v: the corss-product partner @returns the cross-product between this and v (this (x) v) */
-  inline Vector cross (const Vector& v) const { return Vector(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x ); }
-  /** scales the this vector with v* @param v the vector to scale this with */
-  void scale(const Vector& v) {   x *= v.x;  y *= v.y; z *= v.z; };
-  /** @returns the length of the vector */
-  inline float len() const { return sqrt (x*x+y*y+z*z); }
-  /** normalizes the vector */
-  inline void normalize() { float l = len(); if( unlikely(l == 0.0))return; this->x=this->x/l; this->y=this->y/l; this->z=this->z/l; };
-  Vector getNormalized() const;
-  Vector abs();
-
-  void debug() const;
-
- public:
-  float    x;     //!< The x Coordinate of the Vector.
-  float    y;     //!< The y Coordinate of the Vector.
-  float    z;     //!< The z Coordinate of the Vector.
-};
-
-/**
- *  calculate the angle between two vectors in radiances
- * @param v1: a vector
- * @param v2: another vector
- * @return the angle between the vectors in radians
-*/
-inline float angleDeg (const Vector& v1, const Vector& v2) { return acos( v1 * v2 / (v1.len() * v2.len())); };
-/**
- *  calculate the angle between two vectors in degrees
- * @param v1: a vector
- * @param v2: another vector
- * @return the angle between the vectors in degrees
-*/
-inline float angleRad (const Vector& v1, const Vector& v2) { return acos( v1 * v2 / (v1.len() * v2.len())) * 180/M_PI; };
-
-/** an easy way to create a Random Vector @param sideLength the length of the Vector (x not sqrt(x^2...)) */
-#define VECTOR_RAND(sideLength)  (Vector((float)rand()/RAND_MAX -.5, (float)rand()/RAND_MAX -.5, (float)rand()/RAND_MAX -.5) * sideLength)
-
+#include "vector.h"
 
 //! Quaternion
@@ -205 +110 @@
   Vector    v;        //!< Imaginary Vector
   float     w;        //!< Real part of the number
-
 };
 
 
+#endif /* __QUATERNION_H_ */
 
-
-//! 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;
-  float distancePoint (const sVec3D& 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 (const Vector& a, const Vector& b, const Vector& c);
-  Plane (const Vector& norm, const Vector& p);
-  Plane (const Vector& norm, const sVec3D& p);
-  Plane (const 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 distancePoint (const sVec3D& p) const;
-  float locatePoint (const Vector& p) const;
-};
-
-
-
-//! A class that represents a rectangle, this is needed for SpatialSeparation
-class Rectangle
-{
-
-  public:
-    Rectangle() { this->center = Vector(); }
-    Rectangle(const Vector &center, float len) { this->center = Vector(center.x, center.y, center.z); this->axis[0] = len; this->axis[1] = len; }
-    virtual ~Rectangle() {}
-
-    /** \brief sets the center of the rectangle to a defined vector @param center the new center */
-   inline void setCenter(const Vector &center) { this->center = center;}
-    /** \brief sets the center of the rectangle to a defined vector @param x coord of the center @param y coord of the center @param z coord of the center */
-   inline void setCenter(float x, float y, float z) { this->center.x = x; this->center.y = y; this->center.z = z; }
-   /** \brief returns the center of the rectangle to a defined vector @returns center the new center */
-   inline const Vector& getCenter() const { return this->center; }
-
-   /** \brief sets both axis of the rectangle to a defined vector @param unityLength the new center */
-   inline void setAxis(float unityLength) { this->axis[0] = unityLength; this->axis[1] = unityLength; }
-   /** \brief sets both axis of the rectangle to a defined vector @param v1 the length of the x axis @param v2 the length of the z axis*/
-   inline void setAxis(float v1, float v2) { this->axis[0] = v1; this->axis[1] = v2; }
-   /** \brief gets one axis length of the rectangle  @returns the length of the axis 0 */
-   inline float getAxis() { return this-> axis[0]; }
-
-  private:
-    Vector          center;
-    float           axis[2];
-};
-
-
-#endif /* __VECTOR_H_ */
-

trunk/src/lib/math/vector.cc

@@ -66 +66 @@
   PRINT(0)(" lenght: %f", len());
   PRINT(0)("\n");
-}
-
-/////////////////
-/* QUATERNIONS */
-/////////////////
-/**
- *  calculates a lookAt rotation
- * @param dir: the direction you want to look
- * @param up: specify what direction up should be
-
-   Mathematically this determines the rotation a (0,0,1)-Vector has to undergo to point
-   the same way as dir. If you want to use this with cameras, you'll have to reverse the
-   dir Vector (Vector(0,0,0) - your viewing direction) or you'll point the wrong way. You
-   can use this for meshes as well (then you do not have to reverse the vector), but keep
-   in mind that if you do that, the model's front has to point in +z direction, and left
-   and right should be -x or +x respectively or the mesh wont rotate correctly.
- *
- * @TODO !!! OPTIMIZE THIS !!!
- */
-Quaternion::Quaternion (const Vector& dir, const Vector& up)
-{
-  Vector z = dir.getNormalized();
-  Vector x = up.cross(z).getNormalized();
-  Vector y = z.cross(x);
-
-  float m[4][4];
-  m[0][0] = x.x;
-  m[0][1] = x.y;
-  m[0][2] = x.z;
-  m[0][3] = 0;
-  m[1][0] = y.x;
-  m[1][1] = y.y;
-  m[1][2] = y.z;
-  m[1][3] = 0;
-  m[2][0] = z.x;
-  m[2][1] = z.y;
-  m[2][2] = z.z;
-  m[2][3] = 0;
-  m[3][0] = 0;
-  m[3][1] = 0;
-  m[3][2] = 0;
-  m[3][3] = 1;
-
-  *this = Quaternion (m);
-}
-
-/**
- *  calculates a rotation from euler angles
- * @param roll: the roll in radians
- * @param pitch: the pitch in radians
- * @param yaw: the yaw in radians
- */
-Quaternion::Quaternion (float roll, float pitch, float yaw)
-{
-  float cr, cp, cy, sr, sp, sy, cpcy, spsy;
-
-  // calculate trig identities
-  cr = cos(roll/2);
-  cp = cos(pitch/2);
-  cy = cos(yaw/2);
-
-  sr = sin(roll/2);
-  sp = sin(pitch/2);
-  sy = sin(yaw/2);
-
-  cpcy = cp * cy;
-  spsy = sp * sy;
-
-  w = cr * cpcy + sr * spsy;
-  v.x = sr * cpcy - cr * spsy;
-  v.y = cr * sp * cy + sr * cp * sy;
-  v.z = cr * cp * sy - sr * sp * cy;
-}
-
-/**
- *  convert the Quaternion to a 4x4 rotational glMatrix
- * @param m: a buffer to store the Matrix in
- */
-void Quaternion::matrix (float m[4][4]) const
-{
-  float wx, wy, wz, xx, yy, yz, xy, xz, zz, x2, y2, z2;
-
-  // calculate coefficients
-  x2 = v.x + v.x;
-  y2 = v.y + v.y;
-  z2 = v.z + v.z;
-  xx = v.x * x2; xy = v.x * y2; xz = v.x * z2;
-  yy = v.y * y2; yz = v.y * z2; zz = v.z * z2;
-  wx = w * x2; wy = w * y2; wz = w * z2;
-
-  m[0][0] = 1.0 - (yy + zz); m[1][0] = xy - wz;
-  m[2][0] = xz + wy; m[3][0] = 0.0;
-
-  m[0][1] = xy + wz; m[1][1] = 1.0 - (xx + zz);
-  m[2][1] = yz - wx; m[3][1] = 0.0;
-
-  m[0][2] = xz - wy; m[1][2] = yz + wx;
-  m[2][2] = 1.0 - (xx + yy); m[3][2] = 0.0;
-
-  m[0][3] = 0; m[1][3] = 0;
-  m[2][3] = 0; m[3][3] = 1;
-}
-
-/**
- *  performs a smooth move.
- * @param from  where
- * @param to where
- * @param t the time this transformation should take value [0..1]
- * @returns the Result of the smooth move
- */
-Quaternion Quaternion::quatSlerp(const Quaternion& from, const Quaternion& to, float t)
-{
-  float tol[4];
-  double omega, cosom, sinom, scale0, scale1;
-  //  float DELTA = 0.2;
-
-  cosom = from.v.x * to.v.x + from.v.y * to.v.y + from.v.z * to.v.z + from.w * to.w;
-
-  if( cosom < 0.0 )
-    {
-      cosom = -cosom;
-      tol[0] = -to.v.x;
-      tol[1] = -to.v.y;
-      tol[2] = -to.v.z;
-      tol[3] = -to.w;
-    }
-  else
-    {
-      tol[0] = to.v.x;
-      tol[1] = to.v.y;
-      tol[2] = to.v.z;
-      tol[3] = to.w;
-    }
-
-  omega = acos(cosom);
-  sinom = sin(omega);
-  scale0 = sin((1.0 - t) * omega) / sinom;
-  scale1 = sin(t * omega) / sinom;
-  return Quaternion(Vector(scale0 * from.v.x + scale1 * tol[0],
-                    scale0 * from.v.y + scale1 * tol[1],
-                    scale0 * from.v.z + scale1 * tol[2]),
-                    scale0 * from.w + scale1 * tol[3]);
-}
-
-
-/**
- *  convert a rotational 4x4 glMatrix into a Quaternion
- * @param m: a 4x4 matrix in glMatrix order
- */
-Quaternion::Quaternion (float m[4][4])
-{
-
-  float  tr, s, q[4];
-  int    i, j, k;
-
-  int nxt[3] = {1, 2, 0};
-
-  tr = m[0][0] + m[1][1] + m[2][2];
-
-        // check the diagonal
-  if (tr > 0.0)
-  {
-    s = sqrt (tr + 1.0);
-    w = s / 2.0;
-    s = 0.5 / s;
-    v.x = (m[1][2] - m[2][1]) * s;
-    v.y = (m[2][0] - m[0][2]) * s;
-    v.z = (m[0][1] - m[1][0]) * s;
-        }
-        else
-        {
-                // diagonal is negative
-        i = 0;
-        if (m[1][1] > m[0][0]) i = 1;
-    if (m[2][2] > m[i][i]) i = 2;
-    j = nxt[i];
-    k = nxt[j];
-
-    s = sqrt ((m[i][i] - (m[j][j] + m[k][k])) + 1.0);
-
-    q[i] = s * 0.5;
-
-    if (s != 0.0) s = 0.5 / s;
-
-          q[3] = (m[j][k] - m[k][j]) * s;
-    q[j] = (m[i][j] + m[j][i]) * s;
-    q[k] = (m[i][k] + m[k][i]) * s;
-
-        v.x = q[0];
-        v.y = q[1];
-        v.z = q[2];
-        w = q[3];
-  }
-}
-
-/**
- *  outputs some nice formated debug information about this quaternion
-*/
-void Quaternion::debug()
-{
-  PRINT(0)("real a=%f; imag: x=%f y=%f z=%f\n", w, v.x, v.y, v.z);
-}
-
-void Quaternion::debug2()
-{
-  Vector axis = this->getSpacialAxis();
-  PRINT(0)("angle = %f, axis: ax=%f, ay=%f, az=%f\n", this->getSpacialAxisAngle(), axis.x, axis.y, axis.z );
 }
 

trunk/src/lib/math/vector.h

@@ -125 +125 @@
 
 
-//! Quaternion
-/**
-   Class to handle 3-dimensional rotation efficiently
-*/
-class Quaternion
-{
- public:
-  /** creates a Default quaternion (multiplicational identity Quaternion)*/
-  inline Quaternion () { w = 1; v = Vector(0,0,0); }
-  /** creates a Quaternion looking into the direction v @param v: the direction @param f: the value */
-  inline Quaternion (const Vector& v, float f) { this->w = f; this->v = v; }
-  Quaternion (float m[4][4]);
-  /** turns a rotation along an axis into a Quaternion @param angle: the amount of radians to rotate @param axis: the axis to rotate around */
-  inline Quaternion (float angle, const Vector& axis) { w = cos(angle/2); v = axis * sin(angle/2); }
-  Quaternion (const Vector& dir, const Vector& up);
-  Quaternion (float roll, float pitch, float yaw);
-
-  /** @param q: the Quaternion to compare with this one. @returns true if the Quaternions are the same, false otherwise */
-  inline bool operator== (const Quaternion& q) const { return (unlikely(this->v==q.v&&this->w==q.w))?true:false; };
-  /** @param f: a real value @return a Quaternion containing the quotient */
-  inline Quaternion operator/ (const float& f) const { return (unlikely(f==0.0)) ? Quaternion() : Quaternion(this->v/f, this->w/f); };
-  /** @param f: the value to divide by @returns the quaternion devided by f (this /= f) */
-  inline const Quaternion& operator/= (const float& f) {*this = *this / f; return *this;}
-  /** @param f: a real value @return a Quaternion containing the product */
-  inline Quaternion operator* (const float& f) const { return Quaternion(this->v*f, this->w*f); };
-  /** @param f: the value to multiply by @returns the quaternion multiplied by f (this *= f) */
-  inline const Quaternion& operator*= (const float& f) {*this = *this * f; return *this;}
-  /** @param q: another Quaternion to rotate this by @return a quaternion that represents the first one rotated by the second one (WARUNING: this operation is not commutative! e.g. (A*B) != (B*A)) */
-  Quaternion operator* (const Quaternion& q) const { return Quaternion(Vector(this->w*q.v.x + this->v.x*q.w + this->v.y*q.v.z - this->v.z*q.v.y,
-                                                                         this->w*q.v.y + this->v.y*q.w + this->v.z*q.v.x - this->v.x*q.v.z,
-                                                                         this->w*q.v.z + this->v.z*q.w + this->v.x*q.v.y - this->v.y*q.v.x),
-                                                                         this->w*q.w - this->v.x*q.v.x - this->v.y*q.v.y - this->v.z*q.v.z); };
-  /** @param q: the Quaternion to multiply by @returns the quaternion multiplied by q (this *= q) */
-  inline const Quaternion& operator*= (const Quaternion& q) {*this = *this * q; return *this; };
-  /** @param q the Quaternion by which to devide @returns the division from this by q (this / q) */
-  inline Quaternion operator/ (const Quaternion& q) const { return *this * q.inverse(); };
-  /** @param q the Quaternion by which to devide @returns the division from this by q (this /= q) */
-  inline const Quaternion& operator/= (const Quaternion& q) { *this = *this * q.inverse(); return *this; };
-  /** @param q the Quaternion to add to this @returns the quaternion added with q (this + q) */
-  inline Quaternion operator+ (const Quaternion& q) const { return Quaternion(q.v + v, q.w + w); };
-  /** @param q the Quaternion to add to this @returns the quaternion added with q (this += q) */
-  inline const Quaternion& operator+= (const Quaternion& q) { this->v += q.v; this->w += q.w; return *this; };
-  /** @param q the Quaternion to substrace from this @returns the quaternion substracted by q (this - q) */
-  inline Quaternion operator- (const Quaternion& q) const { return Quaternion(q.v - v, q.w - w); }
-  /** @param q the Quaternion to substrace from this @returns the quaternion substracted by q (this -= q) */
-  inline const Quaternion& operator-= (const Quaternion& q) { this->v -= q.v; this->w -= q.w; return *this; };
-  /** copy constructor @param q: the Quaternion to set this to. @returns the Quaternion q (or this) */
-  inline Quaternion operator= (const Quaternion& q) {this->v = q.v; this->w = q.w; return *this;}
-  /** conjugates this Quaternion @returns the conjugate */
-  inline Quaternion conjugate () const { return Quaternion(Vector(-v.x, -v.y, -v.z), this->w); };
-  /** @returns the norm of The Quaternion */
-  inline float norm () const { return sqrt(w*w + v.x*v.x + v.y*v.y + v.z*v.z); };
-  /** @returns the inverted Quaterntion of this */
-  inline Quaternion inverse () const { return conjugate() / (w*w + v.x*v.x + v.y*v.y + v.z*v.z); };
-  /** @returns the dot Product of a Quaternion */
-  inline float dot (const Quaternion& q) const { return v.x*q.v.x + v.y*q.v.y + v.z*q.v.z + w*q.w; };
-  /** @retuns the Distance between two Quaternions */
-  inline float distance(const Quaternion& q) const { return 2*acos(fabsf(this->dot(q))); };
-  /** @param v: the Vector  @return a new Vector representing v rotated by the Quaternion */
-  inline Vector apply (const Vector& v) const { return (*this * Quaternion(v, 0) * conjugate()).v; };
-  void matrix (float m[4][4]) const;
-  /** @returns the normalized Quaternion (|this|) */
-  inline Quaternion getNormalized() const { float n = this->norm(); return Quaternion(this->v/n, this->w/n); };
-  /** normalizes the current Quaternion */
-  inline void normalize() { float n = this->norm(); this->v /= n; this->w/=n; };
-
-  /** @returns the rotational axis of this Quaternion */
-  inline Vector getSpacialAxis() const { return this->v / sin(acos(w));/*sqrt(v.x*v.x + v.y*v.y + v.z+v.z);*/ };
-  /** @returns the rotational angle of this Quaternion around getSpacialAxis()  !! IN DEGREE !! */
-  inline float getSpacialAxisAngle() const { return 360.0 / M_PI * acos( this->w ); };
-
-  static Quaternion quatSlerp(const Quaternion& from, const Quaternion& to, float t);
-
-  void debug();
-  void debug2();
-
-
- public:
-  Vector    v;        //!< Imaginary Vector
-  float     w;        //!< Real part of the number
-
-};
-
-
-
-
 //! 3D rotation (OBSOLETE)
 /**

trunk/src/lib/math/vector2D.h

@@ -10 +10 @@
 
 ### File Specific:
-   main-programmer: Christian Meyer
+   main-programmer: Benjamin Grauer
    co-programmer: ...
 */
 
 /*!
- * @file vector.h
- * A basic 3D math framework
+ * @file vector2D.h
+ * A basic 2D Vector math framework
  *
  * Contains classes to handle vectors, lines, rotations and planes

trunk/src/lib/physics/physics_interface.h

@@ -10 +10 @@
 
 #include "vector.h"
-
+#include "quaternion.h"
 #ifndef NULL
 #define NULL 0          //!< NULL