Index: orxonox/trunk/src/lib/math/curve.cc
===================================================================
--- orxonox/trunk/src/lib/math/curve.cc	(revision 4746)
+++ orxonox/trunk/src/lib/math/curve.cc	(revision 4836)
@@ -34,5 +34,5 @@
 
 /** 
-    \brief default constructor for a Curve
+  *  default constructor for a Curve
 */
 Curve::Curve()
@@ -48,6 +48,6 @@
 
 /**
-   \brief adds a new Node to the bezier Curve
-   \param newNode a Vector to the position of the new node
+ *  adds a new Node to the bezier Curve
+ * @param newNode a Vector to the position of the new node
 */
 void Curve::addNode(const Vector& newNode)
@@ -65,7 +65,7 @@
 
 /**
-   \brief adds a new Node to the bezier Curve
-   \param newNode a Vector to the position of the new node
-   \param insertPosition after the n-th node the new node will be inserted
+ *  adds a new Node to the bezier Curve
+ * @param newNode a Vector to the position of the new node
+ * @param insertPosition after the n-th node the new node will be inserted
 */
 void Curve::addNode(const Vector& newNode, unsigned int insertPosition)
@@ -111,7 +111,7 @@
 
 /**
-   \brief Finds a Node by its Number, and returns its Position
-   \param nodeToFind the n'th node in the List of nodes
-   \returns A Vector to the Position of the Node.
+ *  Finds a Node by its Number, and returns its Position
+ * @param nodeToFind the n'th node in the List of nodes
+ * @returns A Vector to the Position of the Node.
 */
 Vector Curve::getNode(unsigned int nodeToFind)
@@ -126,5 +126,5 @@
 
 /**
-   \brief Outputs information about the state of this Curve
+ *  Outputs information about the state of this Curve
 */
 void Curve::debug()
@@ -148,5 +148,5 @@
 
 /**
-   \brief Creates a new BezierCurve
+ *  Creates a new BezierCurve
 */
 BezierCurve::BezierCurve ()
@@ -157,5 +157,5 @@
 
 /**
-   \brief Creates a new BezierCurve-Derivation-Curve
+ *  Creates a new BezierCurve-Derivation-Curve
 */
 BezierCurve::BezierCurve (int derivation)
@@ -166,5 +166,5 @@
 
 /**
-   \brief Deletes a BezierCurve.
+ *  Deletes a BezierCurve.
 
    It does this by freeing all the space taken over from the nodes
@@ -185,5 +185,5 @@
 
 /**
-   \brief Rebuilds a Curve
+ *  Rebuilds a Curve
 */
 void BezierCurve::rebuild()
@@ -225,7 +225,7 @@
 
 /**
-   \brief calculates the Position on the curve
-   \param t The position on the Curve (0<=t<=1)
-   \return the Position on the Path
+ *  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) 
@@ -257,7 +257,7 @@
 
 /**
-   \brief Calulates the direction of the Curve at time t.
-   \param t The time at which to evaluate the curve.
-   \returns The valuated Vector.
+ *  Calulates the direction of the Curve at time t.
+ * @param t The time at which to evaluate the curve.
+ * @returns The valuated Vector.
 */
 Vector BezierCurve::calcDir (float t)
@@ -267,7 +267,7 @@
 
 /**
-   \brief Calulates the acceleration (second derivate) of the Curve at time t.
-   \param t The time at which to evaluate the curve.
-   \returns The valuated Vector.
+ *  Calulates the acceleration (second derivate) of the Curve at time t.
+ * @param t The time at which to evaluate the curve.
+ * @returns The valuated Vector.
 */
 Vector BezierCurve::calcAcc (float t)
@@ -277,7 +277,7 @@
 
 /**
-   \brief Calculates the Quaternion needed for our rotations
-   \param t The time at which to evaluate the cuve.
-   \returns The evaluated Quaternion.
+ *  Calculates the Quaternion needed for our rotations
+ * @param t The time at which to evaluate the cuve.
+ * @returns The evaluated Quaternion.
 */
 Quaternion BezierCurve::calcQuat (float t)
Index: orxonox/trunk/src/lib/math/curve.h
===================================================================
--- orxonox/trunk/src/lib/math/curve.h	(revision 4746)
+++ orxonox/trunk/src/lib/math/curve.h	(revision 4836)
@@ -2,5 +2,5 @@
 /*!
     \file curve.h
-    \brief A basic 3D curve framework
+  *  A basic 3D curve framework
 
     Contains classes to handle curves
@@ -36,16 +36,16 @@
   void addNode(const Vector& newNode, unsigned int insertPosition);
   Vector getNode(unsigned int nodeToFind);
-  /** \returns the count of nodes in this curve */
+  /** @returns the count of nodes in this curve */
   inline int getNodeCount() const { return this->nodeCount; };
-  /** \returns the directional Curve */
+  /** @returns the directional Curve */
   Curve* getDirCurve() const { return this->dirCurve; };
 
-  /** \param t the value on the curve [0-1] \returns Vector to the position */
+  /** @param t the value on the curve [0-1] @returns Vector to the position */
   virtual Vector calcPos(float t) = 0;
-  /** \param t the value on the curve [0-1] \returns the direction */
+  /** @param t the value on the curve [0-1] @returns the direction */
   virtual Vector calcDir(float t) = 0;
-  /** \param t the value on the curve [0-1] \returns the acceleration */
+  /** @param t the value on the curve [0-1] @returns the acceleration */
   virtual Vector calcAcc(float t) = 0;
-  /** \param t the value on the curve [0-1] \returns quaternion of the rotation */
+  /** @param t the value on the curve [0-1] @returns quaternion of the rotation */
   virtual Quaternion calcQuat(float t) = 0;
 
Index: orxonox/trunk/src/lib/math/vector.cc
===================================================================
--- orxonox/trunk/src/lib/math/vector.cc	(revision 4746)
+++ orxonox/trunk/src/lib/math/vector.cc	(revision 4836)
@@ -28,5 +28,5 @@
 /////////////
 /**
-   \brief returns the this-vector normalized to length 1.0
+ *  returns the this-vector normalized to length 1.0
 */
 Vector Vector::getNormalized() const
@@ -46,5 +46,5 @@
 
 /**
-   \brief Vector is looking in the positive direction on all axes after this
+ *  Vector is looking in the positive direction on all axes after this
 */
 Vector Vector::abs()
@@ -57,5 +57,5 @@
 
 /**
-   \brief Outputs the values of the Vector
+ *  Outputs the values of the Vector
 */
 void Vector::debug() const
@@ -71,7 +71,7 @@
 /////////////////
 /**
-   \brief calculates a lookAt rotation
-   \param dir: the direction you want to look
-   \param up: specify what direction up should be
+ *  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
@@ -112,8 +112,8 @@
 
 /**
-   \brief calculates a rotation from euler angles
-   \param roll: the roll in radians
-   \param pitch: the pitch in radians
-   \param yaw: the yaw in radians
+ *  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)
@@ -140,7 +140,7 @@
 
 /**
-   \brief rotates one Quaternion by another
-   \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))
+ *  rotates one Quaternion by another
+ * @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 Quaternion::operator*(const Quaternion& q) const
@@ -167,7 +167,7 @@
 
 /**
-   \brief rotate a Vector by a Quaternion
-   \param v: the Vector
-   \return a new Vector representing v rotated by the Quaternion
+ *  rotate a Vector by a Quaternion
+ * @param v: the Vector
+ * @return a new Vector representing v rotated by the Quaternion
 */
 
@@ -183,7 +183,7 @@
 
 /**
-   \brief multiply a Quaternion with a real value
-   \param f: a real value
-   \return a new Quaternion containing the product
+ *  multiply a Quaternion with a real value
+ * @param f: a real value
+ * @return a new Quaternion containing the product
 */
 Quaternion Quaternion::operator*(const float& f) const
@@ -196,7 +196,7 @@
 
 /**
-   \brief divide a Quaternion by a real value
-   \param f: a real value
-   \return a new Quaternion containing the quotient
+ *  divide a Quaternion by a real value
+ * @param f: a real value
+ * @return a new Quaternion containing the quotient
 */
 Quaternion Quaternion::operator/(const float& f) const
@@ -210,6 +210,6 @@
 
 /**
-   \brief calculate the conjugate value of the Quaternion
-   \return the conjugate Quaternion
+ *  calculate the conjugate value of the Quaternion
+ * @return the conjugate Quaternion
 */
 /*
@@ -223,6 +223,6 @@
 
 /**
-   \brief calculate the norm of the Quaternion
-   \return the norm of The Quaternion
+ *  calculate the norm of the Quaternion
+ * @return the norm of The Quaternion
 */
 float Quaternion::norm() const
@@ -232,6 +232,6 @@
 
 /**
-   \brief calculate the inverse value of the Quaternion
-   \return the inverse Quaternion
+ *  calculate the inverse value of the Quaternion
+ * @return the inverse Quaternion
 
         Note that this is equal to conjugate() if the Quaternion's norm is 1
@@ -248,6 +248,6 @@
 
 /**
-   \brief convert the Quaternion to a 4x4 rotational glMatrix
-   \param m: a buffer to store the Matrix in
+ *  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
@@ -277,10 +277,10 @@
 
 /**
-   \brief 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
+ *  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 quatSlerp(const Quaternion& from, const Quaternion& to, float t)
@@ -339,6 +339,6 @@
 
 /**
-   \brief convert a rotational 4x4 glMatrix into a Quaternion
-   \param m: a 4x4 matrix in glMatrix order
+ *  convert a rotational 4x4 glMatrix into a Quaternion
+ * @param m: a 4x4 matrix in glMatrix order
 */
 Quaternion::Quaternion (float m[4][4])
@@ -389,5 +389,5 @@
 
 /**
-   \brief outputs some nice formated debug information about this quaternion
+ *  outputs some nice formated debug information about this quaternion
 */
 void Quaternion::debug()
@@ -398,6 +398,6 @@
 
 /**
-   \brief create a rotation from a vector
-   \param v: a vector
+ *  create a rotation from a vector
+ * @param v: a vector
 */
 Rotation::Rotation (const Vector& v)
@@ -421,7 +421,7 @@
 
 /**
-   \brief creates a rotation from an axis and an angle (radians!)
-   \param axis: the rotational axis
-   \param angle: the angle in radians
+ *  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)
@@ -442,8 +442,8 @@
 
 /**
-   \brief 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)
+ *  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)
@@ -468,5 +468,5 @@
 
 /**
-   \brief creates a nullrotation (an identity rotation)
+ *  creates a nullrotation (an identity rotation)
 */
 Rotation::Rotation ()
@@ -484,6 +484,6 @@
 
 /**
-   \brief fills the specified buffer with a 4x4 glmatrix
-   \param buffer: Pointer to an array of 16 floats
+ *  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
@@ -510,7 +510,7 @@
 
 /**
-   \brief multiplies two rotational matrices
-   \param r: another Rotation
-   \return the matrix product of the Rotations
+ *  multiplies two rotational matrices
+ * @param r: another Rotation
+ * @return the matrix product of the Rotations
 
    Use this to rotate one rotation by another
@@ -537,8 +537,8 @@
 
 /**
-   \brief rotates the vector by the given rotation
-   \param v: a vector
-   \param r: a rotation
-   \return the rotated vector
+ *  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)
@@ -554,7 +554,7 @@
 
 /**
-   \brief calculate the distance between two lines
-   \param l: the other line
-   \return the distance between the lines
+ *  calculate the distance between two lines
+ * @param l: the other line
+ * @return the distance between the lines
 */
 float Line::distance (const Line& l) const
@@ -569,7 +569,7 @@
 
 /**
-   \brief calculate the distance between a line and a point
-   \param v: the point
-   \return the distance between the Line and the point
+ *  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
@@ -581,7 +581,7 @@
 
 /**
-   \brief calculate the distance between a line and a point
-   \param v: the point
-   \return the distance between the Line and the point
+ *  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
@@ -594,7 +594,7 @@
 
 /**
-   \brief 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
+ *  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
@@ -618,6 +618,6 @@
 
 /**
-   \brief rotate the line by given rotation
-   \param rot: a rotation
+ *  rotate the line by given rotation
+ * @param rot: a rotation
 */
 void Line::rotate (const Rotation& rot)
@@ -630,8 +630,8 @@
 
 /**
-   \brief create a plane from three points
-   \param a: first point
-   \param b: second point
-   \param c: third point
+ *  create a plane from three points
+ * @param a: first point
+ * @param b: second point
+ * @param c: third point
 */
 Plane::Plane (Vector a, Vector b, Vector c)
@@ -642,7 +642,7 @@
 
 /**
-   \brief create a plane from anchor point and normal
-   \param norm: normal vector
-   \param p: anchor point
+ *  create a plane from anchor point and normal
+ * @param norm: normal vector
+ * @param p: anchor point
 */
 Plane::Plane (Vector norm, Vector p)
@@ -654,7 +654,7 @@
 
 /**
-    \brief create a plane from anchor point and normal
-    \param norm: normal vector
-    \param p: anchor point
+  *  create a plane from anchor point and normal
+  * @param norm: normal vector
+  * @param p: anchor point
 */
 Plane::Plane (Vector norm, sVec3D g)
@@ -667,6 +667,6 @@
 
 /**
-   \brief returns the intersection point between the plane and a line
-   \param l: a line
+ *  returns the intersection point between the plane and a line
+ * @param l: a line
 */
 Vector Plane::intersectLine (const Line& l) const
@@ -678,7 +678,7 @@
 
 /**
-   \brief 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)
+ *  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
@@ -691,7 +691,7 @@
 
 /**
-   \brief 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)
+ *  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
@@ -705,7 +705,7 @@
 
 /**
-   \brief 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
+ *  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
Index: orxonox/trunk/src/lib/math/vector.h
===================================================================
--- orxonox/trunk/src/lib/math/vector.h	(revision 4746)
+++ orxonox/trunk/src/lib/math/vector.h	(revision 4836)
@@ -1,5 +1,5 @@
 /*!
     \file vector.h
-    \brief A basic 3D math framework
+  *  A basic 3D math framework
 
     Contains classes to handle vectors, lines, rotations and planes
@@ -27,45 +27,45 @@
   ~Vector () {}
 
-  /** \param index The index of the "array" \returns the x/y/z coordinate */
+  /** @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) */
+  /*** @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) */
+  /*** @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) */
+  /** @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) */
+  /** @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) */
+  /** @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) */
+  /** @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) */
+  /** @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) */
+  /** @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) */
+  /** @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 */
+  /** @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) */
+  /** @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) */
+  /** @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) */
+  /** @param f a factor to divide the vector with @returns the vector divided by f (this / f) */
   inline Vector operator/ (float f) const {if (unlikely(f == 0.0)) return Vector(0,0,0); else return 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) */
+  /** @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; };
-  /** \brief copy constructor \todo (i do not know it this is faster) \param v the vector to assign to this vector. \returns the vector v */
+  /** \brief 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; };
-  /** \brief copy constructor  \param v the sVec3D to assign to this vector. \returns the vector v */
+  /** \brief 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 */
+  /** @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) */
+  /** @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 ); }
-  /** \brief scales the this vector with v  \param v the vector to scale this with */
+  /** \brief 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 */
+  /** @returns the length of the vector */
   inline float len() const { return sqrt (x*x+y*y+z*z); }
   /** \brief normalizes the vector */
@@ -93,15 +93,15 @@
 
 /**
-   \brief calculate the angle between two vectors in radiances
-   \param v1: a vector
-   \param v2: another vector
-   \return the angle between the vectors in radians
+ *  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())); };
 /**
-   \brief calculate the angle between two vectors in degrees
-   \param v1: a vector
-   \param v2: another vector
-   \return the angle between the vectors in degrees
+ *  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; };
@@ -117,31 +117,31 @@
   /** \brief creates a Default quaternion (multiplicational identity Quaternion)*/
   inline Quaternion () { w = 1; v = Vector(0,0,0); }
-  /** \brief creates a Quaternion looking into the direction v \param v: the direction \param f: the value */
+  /** \brief 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]);
-  /** \brief turns a rotation along an axis into a Quaternion \param angle: the amount of radians to rotate \param axis: the axis to rotate around */
+  /** \brief 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);
   Quaternion operator/ (const float& f) const;
-  /** \param f: the value to divide by \returns the quaternion devided by f (this /= 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;}
   Quaternion operator* (const float& f) const;
-  /** \param f: the value to multiply by \returns the quaternion multiplied by f (this *= 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;}
   Quaternion operator* (const Quaternion& q) const;
-  /** \param q: the Quaternion to multiply by \returns the quaternion multiplied by q (this *= q) */
+  /** @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 to add to this \returns the quaternion added with q (this + q) */
+  /** @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) */
+  /** @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) */
+  /** @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) */
+  /** @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; };
-  /** \brief copy constructor \param q: the Quaternion to set this to. \returns the Quaternion q (or this) */
+  /** \brief 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;}
-  /** \brief conjugates this Quaternion \returns the conjugate */
+  /** \brief conjugates this Quaternion @returns the conjugate */
   inline Quaternion conjugate () const {  Quaternion r(*this);  r.v = Vector() - r.v;  return r;}
   Quaternion inverse () const;
