Index: /orxonox/trunk/src/Makefile.in
===================================================================
--- /orxonox/trunk/src/Makefile.in	(revision 3236)
+++ /orxonox/trunk/src/Makefile.in	(revision 3237)
@@ -117,4 +117,7 @@
 DEFS = @DEFS@
 DEPDIR = @DEPDIR@
+DOXYGEN = @DOXYGEN@
+DOXYGEN_FALSE = @DOXYGEN_FALSE@
+DOXYGEN_TRUE = @DOXYGEN_TRUE@
 ECHO_C = @ECHO_C@
 ECHO_N = @ECHO_N@
Index: /orxonox/trunk/src/collision.cc
===================================================================
--- /orxonox/trunk/src/collision.cc	(revision 3236)
+++ /orxonox/trunk/src/collision.cc	(revision 3237)
@@ -104,5 +104,5 @@
 	if( (t = a->root) == NULL) return false;
 	
-  return cctreeTrace( pa, t, ahitflags, trace, impactpoint);
+  return ccTreeTrace( pa, t, ahitflags, trace, impactpoint);
 }
 
@@ -124,5 +124,5 @@
   if( (tb = b->root) == NULL) return false;
   
-  return cctreeIterate(pa, ta, ahitflags, pb, tb, bhitflags);
+  return ccTreeIterate(pa, ta, ahitflags, pb, tb, bhitflags);
 }
 
@@ -176,5 +176,5 @@
 }
 
-bool cctreeIterate(const Placement* pa, CCTree* ta, unsigned long* ahitflags, const Placement* pb, CCTree* tb, unsigned long* bhitflags)
+bool ccTreeIterate(const Placement* pa, CCTree* ta, unsigned long* ahitflags, const Placement* pb, CCTree* tb, unsigned long* bhitflags)
 {
   bool r = false;
@@ -203,5 +203,5 @@
         else useB = ta->data.b[ib];
         
-        r = r || cctreeIterate( pa, useA, ahitflags, pb, useB, bhitflags);
+        r = r || ccTreeIterate( pa, useA, ahitflags, pb, useB, bhitflags);
         
         if( tb->n == 0) break;
@@ -329,5 +329,5 @@
 }
 
-bool cctreetrace( const Placement* p, CCTree* t, unsigned long* hitflags, const Line* trace, Vector* impactpoint)
+bool ccTreeTrace( const Placement* p, CCTree* t, unsigned long* hitflags, const Line* trace, Vector* impactpoint)
 {
   bool r = false;
@@ -352,5 +352,5 @@
   		for (i = 0; i < t->n; i++)
   		{
-  			r = r || cctreeTrace (p, t->data.b[i], &(hfs[i]), trace, &(ips[i]));
+  			r = r || ccTreeTrace (p, t->data.b[i], &(hfs[i]), trace, &(ips[i]));
   		}
   		if( r)
Index: /orxonox/trunk/src/collision.h
===================================================================
--- /orxonox/trunk/src/collision.h	(revision 3236)
+++ /orxonox/trunk/src/collision.h	(revision 3237)
@@ -52,6 +52,6 @@
   int store (char* filename);
   
-  friend bool cctreeTrace( const Placement* p, CCTree* t, unsigned long* hitflags, const Line* trace, Vector* impactpoint);
-  friend bool cctreeIterate(const Placement* pa, CCTree* ta, unsigned long* ahitflags, const Placement* pb, CCTree* tb, unsigned long* bhitflags);
+  friend bool ccTreeTrace( const Placement* p, CCTree* t, unsigned long* hitflags, const Line* trace, Vector* impactpoint);
+  friend bool ccTreeIterate(const Placement* pa, CCTree* ta, unsigned long* ahitflags, const Placement* pb, CCTree* tb, unsigned long* bhitflags);
   friend bool checkTrace (const Placement* pa, const CollisionCluster* a, unsigned long* ahitflags, const Line* trace, Vector* impactpoint);
   friend bool checkCollision (const Placement* pa, const CollisionCluster* a, unsigned long* ahitflags, const Placement* pb, const CollisionCluster* b, unsigned long* bhitflags);
Index: /orxonox/trunk/src/importer/framework.cc
===================================================================
--- /orxonox/trunk/src/importer/framework.cc	(revision 3236)
+++ /orxonox/trunk/src/importer/framework.cc	(revision 3237)
@@ -149,5 +149,5 @@
 		//		PRINTF(0)("rotAxis: %f, %f, %f\n", rotAxis.x, rotAxis.y, rotAxis.z, rotAngle);
 				
-		rotAngle = angle_rad (p1, p2);
+		rotAngle = angleRad (p1, p2);
 		rotQ = Quaternion (rotAngle, rotAxis);
 		rotQ = rotQ * rotQlast;
Index: /orxonox/trunk/src/importer/vector.cc
===================================================================
--- /orxonox/trunk/src/importer/vector.cc	(revision 3236)
+++ /orxonox/trunk/src/importer/vector.cc	(revision 3237)
@@ -203,5 +203,5 @@
    \return the angle between the vectors in radians
 */
-float angle_rad (const Vector& v1, const Vector& v2)
+float angleRad (const Vector& v1, const Vector& v2)
 {
   return acos( v1 * v2 / (v1.len() * v2.len()));
@@ -215,5 +215,5 @@
    \return the angle between the vectors in degrees
 */
-float angle_deg (const Vector& v1, const Vector& v2)
+float angleDeg (const Vector& v1, const Vector& v2)
 {
   float f;
@@ -243,5 +243,5 @@
 
 /**
-   \brief calculates a look_at rotation
+   \brief calculates a lookAt rotation
    \param dir: the direction you want to look
    \param up: specify what direction up should be
@@ -578,5 +578,5 @@
   Vector axis = x.cross( v);
   axis.normalize();
-  float angle = angle_rad( x, v);
+  float angle = angleRad( x, v);
   float ca = cos(angle);
   float sa = sin(angle);
@@ -714,5 +714,5 @@
    \return the rotated vector
 */
-Vector rotate_vector( const Vector& v, const Rotation& r)
+Vector rotateVector( const Vector& v, const Rotation& r)
 {
   Vector t;
@@ -745,5 +745,5 @@
    \return the distance between the Line and the point
 */
-float Line::distance_point (const Vector& v) const
+float Line::distancePoint (const Vector& v) const
 {
   Vector d = v-r;
@@ -761,7 +761,7 @@
   Vector* fp = new Vector[2];
   Plane p = Plane (r + a.cross(l.a), r, r + a);
-  fp[1] = p.intersect_line (l);
+  fp[1] = p.intersectLine (l);
   p = Plane (fp[1], l.a);
-  fp[0] = p.intersect_line (*this);
+  fp[0] = p.intersectLine (*this);
   return fp;
 }
@@ -783,6 +783,6 @@
 {
   Vector t = a + r;
-  t = rotate_vector( t, rot);
-  r = rotate_vector( r, rot),
+  t = rotateVector( t, rot);
+  r = rotateVector( r, rot),
   a = t - r;
 }
@@ -815,5 +815,5 @@
    \param l: a line
 */
-Vector Plane::intersect_line (const Line& l) const
+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);
@@ -827,5 +827,5 @@
    \return the distance between the plane and the point (can be negative)
 */
-float Plane::distance_point (const Vector& p) const
+float Plane::distancePoint (const Vector& p) const
 {
   float l = n.len();
@@ -839,6 +839,127 @@
    \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::locate_point (const Vector& p) const
+float Plane::locatePoint (const Vector& p) const
 {
   return (n.dot(p) + k);
 }
+
+
+/**
+   \brief Creates a new BezierCurve
+*/
+BezierCurve::BezierCurve (void)
+{
+  nodeCount = 0;
+  firstNode = new PathNode;
+  currentNode = firstNode;
+
+  firstNode->position = Vector (.0, .0, .0);
+  firstNode->number = 0;
+  firstNode->next = 0; // not sure if this really points to NULL!!
+
+  return;
+}
+
+/**
+   \brief Deletes a BezierCurve.
+   It does this by freeing all the space taken over from the nodes
+*/
+BezierCurve::~BezierCurve (void)
+{
+  PathNode* tmpNode;
+  currentNode = firstNode;
+  while (tmpNode != 0)
+    {
+      tmpNode = currentNode;
+      currentNode = currentNode->next;
+      delete tmpNode;
+    }
+}
+
+/**
+   \brief adds a new Node to the bezier Curve
+   \param newNode a Vector to the position of the new node
+*/
+void BezierCurve::addNode(const Vector& newNode)
+{
+  PathNode* tmpNode;
+  if (nodeCount == 0 )
+    tmpNode = firstNode;
+  else
+    {
+      tmpNode = new PathNode;
+      currentNode = currentNode->next = tmpNode;
+    }
+  tmpNode->position = newNode;
+  tmpNode->next = 0; // not sure if this really points to NULL!!
+  tmpNode->number = (++nodeCount);
+  return;
+}
+
+/**
+   \brief calculates the Position on the curve
+   \param t The position on the Curve (0<=t<=1)
+   \return the Position on the Path
+*/
+Vector BezierCurve::calcPos(float t) 
+{
+  if (nodeCount <=4)
+    {
+      //      if (verbose >= 1)
+      //      printf ("Please define at least 4 nodes, until now you have only defined %i.\n", nodeCount);
+      curvePoint = Vector(0,0,0);
+    }
+  PathNode* tmpNode = firstNode;
+    
+  int k,kn,nn,nkn;
+  double blend,muk,munk;
+  Vector b = Vector(0.0,0.0,0.0);
+  
+  muk = 1;
+  munk = pow(1-t,(double)nodeCount);
+  
+  for (k=0; k<=nodeCount; k++) {
+    nn = nodeCount;
+    kn = k;
+    nkn = nodeCount - k;
+    blend = muk * munk;
+    muk *= t;
+    munk /= (1-t);
+    while (nn >= 1) {
+      blend *= nn;
+      nn--;
+      if (kn > 1) {
+	blend /= (double)kn;
+	kn--;
+      }
+      if (nkn > 1) {
+	blend /= (double)nkn;
+	nkn--;
+      }
+    }
+    b.x += tmpNode->position.x * blend;
+    b.y += tmpNode->position.y * blend;
+    b.z += tmpNode->position.z * blend;
+
+    tmpNode = tmpNode->next;
+  }
+  return b;
+}
+
+Vector BezierCurve::calcDirection (float t)
+{
+  double diff = .00000000001;
+  
+  Vector diffV = ((calcPos(t+diff) - calcPos(t))/diff);
+  diffV.normalize();
+  return diffV;
+}
+
+/**
+  \brief returns the Position of the point calculated on the Curve
+  \return a Vector to the calculated position
+*/
+Vector BezierCurve::getPos() const
+{
+  return curvePoint;
+}
Index: /orxonox/trunk/src/importer/vector.h
===================================================================
--- /orxonox/trunk/src/importer/vector.h	(revision 3236)
+++ /orxonox/trunk/src/importer/vector.h	(revision 3237)
@@ -40,6 +40,6 @@
 };
 
-float angle_deg (const Vector& v1, const Vector& v2);
-float angle_rad (const Vector& v1, const Vector& v2);
+float angleDeg (const Vector& v1, const Vector& v2);
+float angleRad (const Vector& v1, const Vector& v2);
 
 //! Quaternion
@@ -98,5 +98,5 @@
 
 //!< Apply a rotation to a vector
-Vector rotate_vector( const Vector& v, const Rotation& r);
+Vector rotateVector( const Vector& v, const Rotation& r);
 
 //! 3D line
@@ -118,5 +118,5 @@
   
   float distance (const Line& l) const;
-  float distance_point (const Vector& v) const;
+  float distancePoint (const Vector& v) const;
   Vector* footpoints (const Line& l) const;
   float len () const;
@@ -144,8 +144,44 @@
   ~Plane () {}
   
-  Vector intersect_line (const Line& l) const;
-  float distance_point (const Vector& p) const;
-  float locate_point (const Vector& p) const;
+  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 */
