Changeset 4836 for orxonox/trunk/src – Orxonox

orxonox/trunk/src/collision.h

r3474	r4836
1	1	/*!
2	2	\file collision.h
3		~~\brief~~ Basic collision detection
	3	* Basic collision detection
4	4	*/
5	5

orxonox/trunk/src/defs/class_id.h

-                      r4807
+                      r4836
 /*!
     \file class_id.h
     \brief list of orxonox classID's
+  *  list of orxonox classID's
     this File is used to identify an Object with its class and also with its sub/super-classes.
 …
  * The last three entries are for any classes in existence eg. SkyBox and so on
+ *
  * \todo complete this List
+ * @todo complete this List
 */
 typedef enum ClassID
 …
   CL_FONT                 =    0x00000802,
   CL_MATERIAL             =    0x00000803,
   CL_MODEL                =    0x00000804, //!< \todo make this a SUBCLASS maybe
+  CL_MODEL                =    0x00000804, //!< @todo make this a SUBCLASS maybe
   CL_OBJMODEL             =    0x00000805,
   CL_PROMITIVE_MODEL      =    0x00000806,

orxonox/trunk/src/defs/debug.h

r4808	r4836
16	16	/*!
17	17	\file debug.h
18		~~\brief~~ Handles output to console for different Verbose-Modes.
	18	* Handles output to console for different Verbose-Modes.
19	19
20	20	There are two main modes HARD and SOFT. HARD is precessed during compileTime where SOFT is for runtime.

orxonox/trunk/src/defs/error.h

-                      r3475
+                      r4836
 /*!
     \file error.h
     \brief A compendium of Error codes used in the program
+  *  A compendium of Error codes used in the program
 */
 …
 /*!
     \brief Error Definitions:
+  *  Error Definitions:
     Error Classes:

orxonox/trunk/src/glmenu/glmenu_imagescreen.cc

-                      r4834
+                      r4836
 using namespace std;
 /**
    \param root The Element to load the GLMenu from
 */
+ * @param root The Element to load the GLMenu from
+ */
 GLMenuImageScreen::GLMenuImageScreen(const TiXmlElement* root)
+{
 …
 /**
    \brief Loads a GLMenu from an inputElement
    \param root The Element to load the GLMenu from
+ *  Loads a GLMenu from an inputElement
+ * @param root The Element to load the GLMenu from
 */
 void GLMenuImageScreen::loadParams(const TiXmlElement* root)
 …
 /**
    \brief standard deconstructor
    \todo this deconstructor is not jet implemented - do it
+ *  standard deconstructor
+   @todo this deconstructor is not jet implemented - do it
 */
 GLMenuImageScreen::~GLMenuImageScreen()
 …
 /**
     \brief sets the background image name
     \param backImageName name of the backgroun-image
+  *  sets the background image name
+  * @param backImageName name of the backgroun-image
  */
 void GLMenuImageScreen::setBackgroundImage (const char* backImageName)
 …
 /**
    \brief sets position of the ImageScreen
    \param offsetX offset from the top left corner in percent(0-1) of the screensize
    \param offsetY offset from the top left corner in percent(0-1) of the screensize
+ *  sets position of the ImageScreen
+ * @param offsetX offset from the top left corner in percent(0-1) of the screensize
+ * @param offsetY offset from the top left corner in percent(0-1) of the screensize
 */
 void GLMenuImageScreen::setPosition(float offsetX, float offsetY)
 …
 /**
   \brief sets size of the ImageScreen
   \param scaleX the scaleing of the image into the x-direction (in percent (0-1))
   \param scaleY the scaleing of the image into the y-direction (in percent (0-1))
+ * @param scaleX the scaleing of the image into the x-direction (in percent (0-1))
+ * @param scaleY the scaleing of the image into the y-direction (in percent (0-1))
 */
 void GLMenuImageScreen::setScale(float scaleX, float scaleY)
 …
 /**
   \brief sets position and size of the ImageScreen
   \param offsetX offset from the top left corner in percent(0-1) of the screensize
   \param offsetY offset from the top left corner in percent(0-1) of the screensize
   \param scaleX the scaleing of the image into the x-direction (in percent (0-1))
   \param scaleY the scaleing of the image into the y-direction (in percent (0-1))
+* @param offsetX offset from the top left corner in percent(0-1) of the screensize
+* @param offsetY offset from the top left corner in percent(0-1) of the screensize
+* @param scaleX the scaleing of the image into the x-direction (in percent (0-1))
+* @param scaleY the scaleing of the image into the y-direction (in percent (0-1))
 */
 void GLMenuImageScreen::setPosScale(float offsetX, float offsetY, float scaleX, float scaleY)
 …
 /**
    \param barImage An image for the Bar
+ * @param barImage An image for the Bar
 */
 void GLMenuImageScreen::setBarImage(const char* barImage)
 …
 /**
    \brief sets the Position and the Size of the bar
    \param barX The Position in the x-direction in percent of the screen (0-1)
    \param barY The Position in the y-direction in percent of the screen (0-1)
    \param barW The Size in the x-direction in percent of the screen (0-1)
    \param barH The Size in the y-direction in percent of the screen (0-1)
+ *  sets the Position and the Size of the bar
+ * @param barX The Position in the x-direction in percent of the screen (0-1)
+ * @param barY The Position in the y-direction in percent of the screen (0-1)
+ * @param barW The Size in the x-direction in percent of the screen (0-1)
+ * @param barH The Size in the y-direction in percent of the screen (0-1)
 */
 void GLMenuImageScreen::setBarPosScale(float barX, float barY, float barW, float barH)
 …
 /**
    \brief set the maximum of countable steps
    \param maxValue of steps
+ *  set the maximum of countable steps
+ * @param maxValue of steps
 */
 void GLMenuImageScreen::setMaximum(int maxValue)
 …
 /**
    \brief set current value
    \param currentValue value to set
+ *  set current value
+ * @param currentValue value to set
 */
 void GLMenuImageScreen::setValue(int currentValue)
 …
 /**
    \brief get the current value
+ *  get the current value
  */
 int GLMenuImageScreen::getValue()
 …
 /**
     \brief call this to trigger a progress event
+  *  call this to trigger a progress event
     this has to redraw the progress bar and the whole image
 …
 /**
    \brief draws the ImageScreen to the screenbuffer
+ *  draws the ImageScreen to the screenbuffer
 */
 void GLMenuImageScreen::draw ()

orxonox/trunk/src/glmenu/glmenu_imagescreen.h

-                      r4746
+                      r4836
 /*!
     \file glmenu_imagescreen.h
     \brief class to display a LoadScreen
+  *  class to display a LoadScreen
 */
 …
   void setMaximum (int maxValue);
   /** \returns the maximum of countable steps*/
+  /** @returns the maximum of countable steps*/
   inline int GLMenuImageScreen::getMaximum() const { return this->maxValue; };

orxonox/trunk/src/lib/collision_detection/bounding_sphere.cc

-                      r4513
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 BoundingSphere::BoundingSphere ()
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */

orxonox/trunk/src/lib/collision_detection/bounding_sphere.h

r4525	r4836
1	1	/*!
2	2	\file bounding_sphere.h
3		~~\brief~~ Definition of a bounding sphere
	3	* Definition of a bounding sphere
4	4
5	5	*/

orxonox/trunk/src/lib/collision_detection/bounding_volume.cc

-                      r4814
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 BoundingVolume::BoundingVolume ()
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */

orxonox/trunk/src/lib/collision_detection/bounding_volume.h

r4814	r4836
1	1	/*!
2	2	\file bounding_volume.h
3		~~\brief~~ Definition of a bounding volume for collision detection algorithms
	3	* Definition of a bounding volume for collision detection algorithms
4	4
5	5	*/

orxonox/trunk/src/lib/collision_detection/bv_tree.cc

-                      r4528
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 BVTree::BVTree ()
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */

orxonox/trunk/src/lib/collision_detection/bv_tree.h

r4712	r4836
1	1	/*!
2	2	\file bv_tree.h
3		~~\brief~~ Definition of a bounding volume tree
	3	* Definition of a bounding volume tree
4	4
5	5	*/

orxonox/trunk/src/lib/collision_detection/bv_tree_node.cc

-                      r4814
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 BVTreeNode::BVTreeNode ()
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */

orxonox/trunk/src/lib/collision_detection/bv_tree_node.h

r4702	r4836
1	1	/*!
2	2	\file bv_tree.h
3		~~\brief~~ Definition of a bounding volume tree
	3	* Definition of a bounding volume tree
4	4
5	5	*/

orxonox/trunk/src/lib/collision_detection/cd_engine.cc

-                      r4742
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 CDEngine::CDEngine ()
 …
 /**
    \brief the singleton reference to this class
+ *  the singleton reference to this class
 */
 CDEngine* CDEngine::singletonRef = NULL;
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */

orxonox/trunk/src/lib/collision_detection/cd_engine.h

-                      r4746
+                      r4836
 /*!
     \file cd_engine.h
     \brief Definition of the collision detection engine
+  *  Definition of the collision detection engine
 */
 …
  public:
   virtual ~CDEngine();
   /** \returns a Pointer to the only object of this Class */
+  /** @returns a Pointer to the only object of this Class */
   static CDEngine* getInstance() { if (!singletonRef) singletonRef = new CDEngine(); return singletonRef; }
   void init();

orxonox/trunk/src/lib/collision_detection/collision.cc

-                      r4511
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 Collision::Collision ()
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */

orxonox/trunk/src/lib/collision_detection/collision.h

r4544	r4836
1	1	/*!
2	2	\file collision.h
3		~~\brief~~ Definition of a collision event
	3	* Definition of a collision event
4	4
5	5	*/

orxonox/trunk/src/lib/collision_detection/collision_defs.h

r4520	r4836
1	1	/*!
2	2	\file collision_defs.h
3		~~\brief~~ Definition of some global collision data
	3	* Definition of some global collision data
4	4
5	5	*/

orxonox/trunk/src/lib/collision_detection/lin_alg.h

r4746	r4836
1	1	/*!
2	2	\file lin_alg.h
3		~~\brief~~ Definition of some important linear algebra formulas
	3	* Definition of some important linear algebra formulas
4	4
5	5	compute the eigenpairs (eigenvalues and eigenvectors) of a real symmetric matrix "A" by the Jacobi method

orxonox/trunk/src/lib/collision_detection/obb.cc

-                      r4815
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 OBB::OBB ()
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */

orxonox/trunk/src/lib/collision_detection/obb.h

r4814	r4836
1	1	/*!
2	2	\file obb.h
3		~~\brief~~ Definition of an OBB (object Oriented Bounding Box)
	3	* Definition of an OBB (object Oriented Bounding Box)
4	4
5	5	*/

orxonox/trunk/src/lib/collision_detection/obb_tree.cc

-                      r4814
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 OBBTree::OBBTree ()
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */

orxonox/trunk/src/lib/collision_detection/obb_tree.h

r4702	r4836
1	1	/*!
2	2	\file obb_tree.h
3		~~\brief~~ Definition of an obb tree (object oriented Bounding Box)
	3	* Definition of an obb tree (object oriented Bounding Box)
4	4
5	5	*/

orxonox/trunk/src/lib/collision_detection/obb_tree_node.cc

-                      r4815
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
  */
 OBBTreeNode::OBBTreeNode ()
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
  */
 OBBTreeNode::~OBBTreeNode ()
 …
 /**
    \brief creates a new BVTree or BVTree partition
    \param depth: how much more depth-steps to go: if == 1 don't go any deeper!
    \param verticesList: the list of vertices of the object - each vertices triple is interpreted as a triangle
+ *  creates a new BVTree or BVTree partition
+ * @param depth: how much more depth-steps to go: if == 1 don't go any deeper!
+ * @param verticesList: the list of vertices of the object - each vertices triple is interpreted as a triangle
  */
 void OBBTreeNode::spawnBVTree(const int depth, sVec3D *verticesList, const int length)
 …
 /**
   \brief this separates an ob-box in the middle
   \param box: the box to separate
+* @param box: the box to separate
   this will separate the box into to smaller boxes. the separation is done along the middle of the longest axis

orxonox/trunk/src/lib/collision_detection/obb_tree_node.h

-                      r4746
+                      r4836
 /*!
     \file bv_tree.h
     \brief Definition of a bounding volume tree
+  *  Definition of a bounding volume tree
  */
 …
     static OBBTree*     obbTree;                    //!< reference to the obb tree
     Plane*              separationPlane;            //!< the separation plane of the obb
     sVec3D*             sepPlaneCenter;             //!< only needed to draw plane \todo: separationPlane drawing
+    sVec3D*             sepPlaneCenter;             //!< only needed to draw plane @todo: separationPlane drawing
     int                 longestAxisIndex;           //!< only needed to draw plane

orxonox/trunk/src/lib/coord/null_parent.cc

-                      r4448
+                      r4836
 /**
    \returns the Reference to the NullParent
+ * @returns the Reference to the NullParent
 */
 NullParent* NullParent::getInstance ()
 …
 /**
    \brief creates the one and only NullParent
    \param absCoordinate the cordinate of the Parent (normally Vector(0,0,0))
+ *  creates the one and only NullParent
+ * @param absCoordinate the cordinate of the Parent (normally Vector(0,0,0))
 */
 NullParent::NullParent (const Vector& absCoordinate) : PNode (absCoordinate, NULL)
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 NullParent::~NullParent ()

orxonox/trunk/src/lib/coord/null_parent.h

r4448	r4836
1	1	/*!
2	2	\file null_parent.h
3		~~\brief~~ Definition of the NullParent, the higest PNode of them all.
	3	* Definition of the NullParent, the higest PNode of them all.
4	4	*/
5	5

orxonox/trunk/src/lib/coord/p_node.cc

-                      r4785
+                      r4836
    co-programmer:
    \todo Smooth-Parent: delay, speed
+   @todo Smooth-Parent: delay, speed
 */
 …
 /**
    \brief standard constructor
+ *  standard constructor
 */
 PNode::PNode ()
 …
 /**
    \param root the load-Element for the PNode
+ * @param root the load-Element for the PNode
 */
 PNode::PNode(const TiXmlElement* root)
 …
 /**
    \brief constructor with coodinates
    \param absCoordinate the Absolute coordinate of the Object
    \param parent The parent-node of this node.
+ *  constructor with coodinates
+ * @param absCoordinate the Absolute coordinate of the Object
+ * @param parent The parent-node of this node.
 */
 PNode::PNode (const Vector& absCoordinate, PNode* parent )
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 PNode::~PNode ()
 …
 /**
    \brief initializes a PNode
    \param parent the parent for this PNode
+ *  initializes a PNode
+ * @param parent the parent for this PNode
 */
 void PNode::init(PNode* parent)
 …
 /**
    \brief loads parameters of the PNode
    \param root the XML-element to load the properties of
+ *  loads parameters of the PNode
+ * @param root the XML-element to load the properties of
 */
 void PNode::loadParams(const TiXmlElement* root)
 …
 /**
    \brief set relative coordinates
    \param relCoord relative coordinates to its parent
+ *  set relative coordinates
+ * @param relCoord relative coordinates to its parent
    it is very importand, that you use this function, if you want to update the
 …
 /**
    \brief set relative coordinates
    \param x x-relative coordinates to its parent
    \param y y-relative coordinates to its parent
    \param z z-relative coordinates to its parent
+ *  set relative coordinates
+ * @param x x-relative coordinates to its parent
+ * @param y y-relative coordinates to its parent
+ * @param z z-relative coordinates to its parent
    \see  void PNode::setRelCoor (const Vector& relCoord)
 */
 …
 /**
    \param absCoord set absolute coordinate
+ * @param absCoord set absolute coordinate
    it is very importand, that you use this function, if you want to update the
 …
 /**
  * \param x x-coordinate.
  * \param y y-coordinate.
  * \param z z-coordinate.
+ * @param x x-coordinate.
+ * @param y y-coordinate.
+ * @param z z-coordinate.
  * \see void PNode::setAbsCoor (const Vector& absCoord)
  */
 …
 /**
    \brief shift coordinate (abs and rel)
    \param shift shift vector
+ *  shift coordinate (abs and rel)
+ * @param shift shift vector
    this function shifts the current coordinates about the vector shift. this is
 …
 /**
    \brief set relative direction
    \param relDir to its parent
+ *  set relative direction
+ * @param relDir to its parent
    it is very importand, that you use this function, if you want to update the
 …
 /**
    \brief sets the absolute direction (0,0,1)
    \param absDir absolute coordinates
+ *  sets the absolute direction (0,0,1)
+ * @param absDir absolute coordinates
    it is very importand, that you use this function, if you want to update the
 …
 /**
    \brief shift coordinate (abs and rel)
    \param shift vector
+ *  shift coordinate (abs and rel)
+ * @param shift vector
    this function shifts the current coordinates about the vector shift. this is
 …
    yea right... shorter...
    \todo implement this
+   @todo implement this
 */
 void PNode::shiftDir (const Quaternion& shift)
 …
 /**
    \brief adds a child and makes this node to a parent
    \param pNode child reference
    \param parentMode on which changes the child should also change ist state
+ *  adds a child and makes this node to a parent
+ * @param pNode child reference
+ * @param parentMode on which changes the child should also change ist state
    use this to add a child to this node.
 …
 /**
    \brief removes a child from the node
    \param pNode the child to remove from this pNode.
+ *  removes a child from the node
+ * @param pNode the child to remove from this pNode.
    Children from pNode will not be lost, they are referenced to NullPointer
 …
 /**
    \brief remove this pnode from the tree and adds all following to NullParent
+ *  remove this pnode from the tree and adds all following to NullParent
    this can be the case, if an entity in the world is been destroyed.
 …
 /**
    \brief sets the parent of this PNode
    \param parent the Parent to set
+ *  sets the parent of this PNode
+ * @param parent the Parent to set
 */
 void PNode::setParent (PNode* parent)
 …
 /**
    \brief set the mode of this parent manualy
    \param parentMode the mode of the bind-type.
+ *  set the mode of this parent manualy
+ * @param parentMode the mode of the bind-type.
 */
 void PNode::setParentMode (PARENT_MODE parentMode)
 …
 /**
  * @brief sets the mode of this parent manually
+ *  sets the mode of this parent manually
  * @param parentMode a String representing this parentingMode
  */
 …
 /**
    \brief has to be called, if the parent coordinate has changed
+ *  has to be called, if the parent coordinate has changed
    normaly this will be done by the parent itself automaticaly. If you call this, you
 …
 /**
    \brief updates the absCoordinate/absDirection
    \param dt The time passed since the last update
+ *  updates the absCoordinate/absDirection
+ * @param dt The time passed since the last update
    this is used to go through the parent-tree to update all the absolute coordinates
 …
 /**
    \brief displays some information about this pNode
    \param depth The deph into which to debug the children of this PNode to.
+ *  displays some information about this pNode
+ * @param depth The deph into which to debug the children of this PNode to.
   (0: all children will be debugged, 1: only this PNode, 2: this and direct children...)
    \param level The n-th level of the Node we draw (this is internal and only for nice output)
+ * @param level The n-th level of the Node we draw (this is internal and only for nice output)
 */
 void PNode::debug(unsigned int depth, unsigned int level) const
 …
 /**
   @brief displays the PNode at its position with its rotation as a cube.
+   displays the PNode at its position with its rotation as a cube.
 */
 void PNode::debugDraw(float size) const

orxonox/trunk/src/lib/coord/p_node.h

-                      r4771
+                      r4836
 /*!
     \file p_node.h
     \brief Definition of a parenting node
+  *  Definition of a parenting node
     parenting is how coordinates are handled in orxonox, meaning, that all coordinates
 …
   void setRelCoor (const Vector& relCoord);
   void setRelCoor (float x, float y, float z);
   /** \returns the relative position */
+  /** @returns the relative position */
   inline const Vector& getRelCoor () const { return this->relCoordinate; };
   void setAbsCoor (const Vector& absCoord);
   void setAbsCoor (float x, float y, float z);
   /** \returns the absolute position */
+  /** @returns the absolute position */
   inline const Vector& getAbsCoor () const { return this->absCoordinate; };
   void shiftCoor (const Vector& shift);
 …
   void setRelDir (const Quaternion& relDir);
   void setRelDir (float x, float y, float z);
   /** \returns the relative Direction */
+  /** @returns the relative Direction */
   inline const Quaternion& getRelDir () const { return this->relDirection; };
   /** \returns a Vector pointing into the relative Direction */
+  /** @returns a Vector pointing into the relative Direction */
   inline Vector getRelDirV() const { return this->relDirection.apply(Vector(0,1,0)); };
   void setAbsDir (const Quaternion& absDir);
   void setAbsDir (float x, float y, float z);
   /** \returns the absolute Direction */
+  /** @returns the absolute Direction */
   inline const Quaternion& getAbsDir () const { return this->absDirection; };
   /** \returns a Vector pointing into the absolute Direction */
+  /** @returns a Vector pointing into the absolute Direction */
   inline Vector getAbsDirV() const { return this->absDirection.apply(Vector(0,1,0)); };
   void shiftDir (const Quaternion& shift);
   /** \returns the Speed of the Node */
+  /** @returns the Speed of the Node */
   inline float getSpeed() const {return this->velocity.len();}
   /** \returns the Velocity of the Node */
+  /** @returns the Velocity of the Node */
   inline const Vector& getVelocity() const {return this->velocity;}
 …
   void setParentMode (PARENT_MODE parentMode);
   void setParentMode (const char* parentingMode);
   /** \returns the Parenting mode of this node */
+  /** @returns the Parenting mode of this node */
   int getParentMode() const { return this->parentMode; };
 …
   /** \brief tells the child that the parent's Direction has changed */
   inline void parentDirChanged () { this->bRelDirChanged = true; }
   /** \returns the last calculated coordinate */
+  /** @returns the last calculated coordinate */
   inline Vector getLastAbsCoor() {return this->lastAbsCoordinate;}

orxonox/trunk/src/lib/event/event.cc

-                      r4457
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 Event::Event ()
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */

orxonox/trunk/src/lib/event/event.h

r4782	r4836
1	1	/*!
2	2	\file event.h
3		~~\brief~~ an abstract event
	3	* an abstract event
4	4
5	5	*/

orxonox/trunk/src/lib/event/event_def.h

r4782	r4836
1	1	/*!
2	2	\file event_def.h
3		~~\brief~~ some central definitions
	3	* some central definitions
4	4
5	5	*/

orxonox/trunk/src/lib/event/event_handler.cc

-                      r4817
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 EventHandler::EventHandler ()
 …
 /**
    \brief the singleton reference to this class
+ *  the singleton reference to this class
 */
 EventHandler* EventHandler::singletonRef = NULL;
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 …
 /**
    \brief initializes the event handler
+ *  initializes the event handler
    this has to be called before the use of the event handler
 …
 /**
    \brief set the state of the event handler
    \param state: to which the event handler shall change
+ *  set the state of the event handler
+ * @param state: to which the event handler shall change
 */
 void EventHandler::setState(elState state)
 …
 /**
    \brief subscribe to an event
    \param el: the event listener that wants to subscribe itself, the listener that will be called when the evetn occures
    \param state: for which the listener wants to receive events
    \param eventType: the event type that wants to be listened for.
+ *  subscribe to an event
+ * @param el: the event listener that wants to subscribe itself, the listener that will be called when the evetn occures
+ * @param state: for which the listener wants to receive events
+ * @param eventType: the event type that wants to be listened for.
    This is one of the most important function of the EventHandler. If you would like to subscribe for more
 …
    state = ES_ALL, which will subscribe your listener for all states together.
+ *
  * \todo this can also be done with the & operator, and checking for states, just set the esState to 1,2,4,8, and then 15 is equal to ES_ALL
+ * @todo this can also be done with the & operator, and checking for states, just set the esState to 1,2,4,8, and then 15 is equal to ES_ALL
 */
 void EventHandler::subscribe(EventListener* el, elState state, int eventType)
 …
 /**
    \brief unsubscribe from the EventHandler
    \param state: the stat in which it has been subscribed
    \param eventType: the event, that shall be unsubscribed
+ *  unsubscribe from the EventHandler
+ * @param state: the stat in which it has been subscribed
+ * @param eventType: the event, that shall be unsubscribed
    if you want to unsubscribe an event listener from all subscribed events, just use the
 …
 /**
    \brief unsubscribe all events from a specific listener
    \param el: the listener that wants to unsubscribe itself
    \param state: the state in which the events shall be unsubscribed
+ *  unsubscribe all events from a specific listener
+ * @param el: the listener that wants to unsubscribe itself
+ * @param state: the state in which the events shall be unsubscribed
 */
 …
 /**
    \brief flush all registered events
    \param state: a specific state
+ *  flush all registered events
+ * @param state: a specific state
 */
 void EventHandler::flush(elState state)
 …
 /**
    \brief core function of event handler: receives all events from SDL
+ *  core function of event handler: receives all events from SDL
    The event from the SDL framework are collected here and distributed to all listeners.

orxonox/trunk/src/lib/event/event_handler.h

-                      r4834
+                      r4836
 /*!
     \file event_handler.h
     \brief Definition of the EventHandler
+  *  Definition of the EventHandler
 */
 …
  public:
   virtual ~EventHandler();
   /** \returns a Pointer to the only object of this Class */
+  /** @returns a Pointer to the only object of this Class */
   inline static EventHandler* getInstance() { if (!singletonRef) singletonRef = new EventHandler();  return singletonRef; };
   void init();

orxonox/trunk/src/lib/event/event_listener.cc

-                      r4817
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 EventListener::EventListener ()
+{
    this->setClassID(CL_EVENT_LISTENER, "EventListener");
+  this->setClassID(CL_EVENT_LISTENER, "EventListener");
+}
 /**
+   \brief standard deconstructor
+ *  standard deconstructor
 */
 EventListener::~EventListener ()

orxonox/trunk/src/lib/event/event_listener.h

-                      r4457
+                      r4836
 /*!
     \file event_listener.h
     \brief Definition of an event listener base class
+  *  Definition of an event listener base class
 */
 …
   /**
      \brief abstract function that processes events from the handler
      \param event: the event
+   *  abstract function that processes events from the handler
+   * @param event: the event
   */
   virtual void process(const Event &event) = NULL;

orxonox/trunk/src/lib/event/key_mapper.cc

-                      r4834
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 KeyMapper::KeyMapper ()
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 KeyMapper::~KeyMapper ()
 …
 /**
    \brief loads new key bindings from a file
    \param filename: The path and name of the file to load the bindings from
+ *  loads new key bindings from a file
+ * @param filename: The path and name of the file to load the bindings from
 */
 void KeyMapper::loadKeyBindings (const char* fileName)
 …
 /**
    \brief this function looks up name to key index
    \param the name of the button
+ *  this function looks up name to key index
+ * @param the name of the button
 */
 int* KeyMapper::nameToIndex (char* name)
 …
 /**
    \brief the function maps name to key ids
    \param name of the key
    \param id of the key
+ *  the function maps name to key ids
+ * @param name of the key
+ * @param id of the key
 */
 void KeyMapper::mapKeys(char* name, int keyID)
 …
 /**
    \brief this function gives some debug information about the key mapper class
+ *  this function gives some debug information about the key mapper class
 */
 void KeyMapper::debug()

orxonox/trunk/src/lib/event/key_mapper.h

r4457	r4836
1	1	/*!
2	2	\file key_mapper.h
3		~~\brief~~ a construct to map player defined keys to SDL keys
	3	* a construct to map player defined keys to SDL keys
4	4
5	5	*/

orxonox/trunk/src/lib/event/key_names.h

-                      r4780
+                      r4836
 /*!
     \file keynames.h
     \brief Key/button naming functions
+  *  Key/button naming functions
                 Converts strings to SDLK/SDL_BUTTON values and vice versa
 …
 /**
         \brief converts a button name string to a integer representing the corresponding SDL mouse button identifier
         \param name: the name of the mouse button
         \return an int containing the SDL identifier of the mouse button or -1 if the button name is not valid
+      *  converts a button name string to a integer representing the corresponding SDL mouse button identifier
+      * @param name: the name of the mouse button
+      * @return an int containing the SDL identifier of the mouse button or -1 if the button name is not valid
 */
 int buttonnameToSDLB(const char* name);
 /**
         \brief converst a SDL mouse button identifier to a name string
         \param button: an SDL mouse button identifier
         \return a pointer to a string containing the name of the mouse button
+      *  converst a SDL mouse button identifier to a name string
+      * @param button: an SDL mouse button identifier
+      * @return a pointer to a string containing the name of the mouse button
 */
 char* SDLBToButtonname( int button);
 /**
         \brief converts a key name string to a integer representing the corresponding SDLK sym
         \param name: the name of the key
         \return the SDLK sym of the named key or -1 if the key name is not valid
+      *  converts a key name string to a integer representing the corresponding SDLK sym
+      * @param name: the name of the key
+      * @return the SDLK sym of the named key or -1 if the key name is not valid
 */
 int keynameToSDLK(const char* name);
 /**
         \brief converts an SDLK sym to a name string
         \param key: the SDLK sym
         \return a pointer to a string containig the name of the key
+      *  converts an SDLK sym to a name string
+      * @param key: the SDLK sym
+      * @return a pointer to a string containig the name of the key
 */
 char* SDLKToKeyname( int key);

orxonox/trunk/src/lib/graphics/graphics_engine.cc

-                      r4835
+                      r4836
 /**
    \brief standard constructor
    \todo this constructor is not jet implemented - do it
+ *  standard constructor
+   @todo this constructor is not jet implemented - do it
 */
 GraphicsEngine::GraphicsEngine ()
 …
 /**
    \brief The Pointer to this GraphicsEngine
+ *  The Pointer to this GraphicsEngine
 */
 GraphicsEngine* GraphicsEngine::singletonRef = NULL;
 /**
    \brief destructs the graphicsEngine.
+ *  destructs the graphicsEngine.
 */
 GraphicsEngine::~GraphicsEngine ()
 …
 /**
    \brief initializes the Video for openGL.
+ *  initializes the Video for openGL.
    This has to be done only once when starting orxonox.
 …
 /**
    \brief Sets the GL-attributes
+ *  Sets the GL-attributes
 */
 int GraphicsEngine::setGLattribs()
 …
 /**
    \brief sets the Resolution of the Screen to display the Graphics to.
    \param width The width of the window
    \param height The height of the window
    \param bpp bits per pixel
+ *  sets the Resolution of the Screen to display the Graphics to.
+ * @param width The width of the window
+ * @param height The height of the window
+ * @param bpp bits per pixel
 */
 int GraphicsEngine::setResolution(int width, int height, int bpp)
 …
 /**
    \brief sets Fullscreen mode
    \param fullscreen true if fullscreen, false if windowed
+ *  sets Fullscreen mode
+ * @param fullscreen true if fullscreen, false if windowed
 */
 void GraphicsEngine::setFullscreen(bool fullscreen)
 …
 /**
    \brief sets the background color
    \param red the red part of the background
    \param blue the blue part of the background
    \param green the green part of the background
    \param alpha the alpha part of the background
+ *  sets the background color
+ * @param red the red part of the background
+ * @param blue the blue part of the background
+ * @param green the green part of the background
+ * @param alpha the alpha part of the background
 */
 void GraphicsEngine::setBackgroundColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 …
 /**
    \brief Signalhandler, for when the resolution has changed
    \param resizeInfo SDL information about the size of the new screen size
+ *  Signalhandler, for when the resolution has changed
+ * @param resizeInfo SDL information about the size of the new screen size
 */
 int GraphicsEngine::resolutionChanged(const SDL_ResizeEvent& resizeInfo)
 …
 /**
    \brief entering 2D Mode
+ *  entering 2D Mode
    this is a GL-Projection-mode, that is orthogonal, for placing the font in fron of everything else
 …
 /**
    \brief leaves the 2DMode again also \see Font::enter2DMode()
+ *  leaves the 2DMode again also \see Font::enter2DMode()
 */
 void GraphicsEngine::leave2DMode()
 …
 /**
    \brief stores the GL_matrices
+ *  stores the GL_matrices
 */
 void GraphicsEngine::storeMatrices()
 …
 /**
    \brief outputs all the Fullscreen modes.
+ *  outputs all the Fullscreen modes.
 */
 void GraphicsEngine::listModes()
 …
 /**
    \brief ticks the Text
    \param dt the time passed
+ *  ticks the Text
+ * @param dt the time passed
 */
 void GraphicsEngine::tick(float dt)
 …
 /**
    \brief displays the Frames per second
    \param display if the text should be displayed
    \todo this is dangerous
+ *  displays the Frames per second
+ * @param display if the text should be displayed
+   @todo this is dangerous
 */
 void GraphicsEngine::displayFPS(bool display)
 …
 /**
   \brief processes the events for orxonox main class
   \param the event to handle
+* @param the event to handle
  */
 void GraphicsEngine::process(const Event &event)

orxonox/trunk/src/lib/graphics/graphics_engine.h

-                      r4834
+                      r4836
     \file graphics_engine.h
     \brief defines a Interface between orxonox and graphical input
+  *  defines a Interface between orxonox and graphical input
     handles graphical SDL-initialisation, textures, resolutions, and so on
 …
   public:
     virtual ~GraphicsEngine();
     /** \returns a Pointer to the only object of this Class */
+    /** @returns a Pointer to the only object of this Class */
     inline static GraphicsEngine* getInstance() { if (!singletonRef) singletonRef = new GraphicsEngine();  return singletonRef; };
 …
     /** \returns the x resolution */
+    /** @returns the x resolution */
     inline int getResolutionX() const { return this->resolutionX; };
     /** \returns the y resolution */
+    /** @returns the y resolution */
     inline int getResolutionY() const { return this->resolutionY; };
     /** \returns the Bits Per Pixel */
+    /** @returns the Bits Per Pixel */
     inline int getbbp() const { return this->bitsPerPixel; };

orxonox/trunk/src/lib/graphics/importer/abstract_model.h

r4809	r4836
16	16	/*!
17	17	\file abstract_model.h
18		~~\brief~~ Definition of an abstract model. containing all needed for other model
	18	* Definition of an abstract model. containing all needed for other model
19	19	*/
20	20

orxonox/trunk/src/lib/graphics/importer/array.h

-                      r4799
+                      r4836
     void addEntry(T entry0, T entry1, T entry2);
     /** \returns The array */
+    /** @returns The array */
     inline const T* getArray () const { return this->array; };
     /**   \returns The Count of entries in the Array*/
+    /** * @returns The Count of entries in the Array*/
     inline unsigned int getCount()const { return this->entryCount; };
     inline int getIndex(T* entry) const;
 …
 /**
    \brief creates a new Array
+ *  creates a new Array
 */
 template<class T>
 …
 /**
    \brief deletes an Array.
+ *  deletes an Array.
    It does this by first deleting all the array-entries, and then delete the array[] itself
 */
 …
 /**
    \brief finalizes an array.
+ *  finalizes an array.
    This Function creates the array, and makes it ready to be sent to the application.
 */
 …
 /**
    \brief adds a new Entry to the Array
    \param entry Entry to add.
+ *  adds a new Entry to the Array
+ * @param entry Entry to add.
 */
 template<class T>
 …
 /**
    \brief Adds 3 entries at once (convenience)
+ *  Adds 3 entries at once (convenience)
 */
 template<class T>
 …
 /**
    \brief gets back the index of the entry in the array. value check
    \param entry: the entry to look up
    \returns the index in the array, -1 if not found
+ *  gets back the index of the entry in the array. value check
+ * @param entry: the entry to look up
+ * @returns the index in the array, -1 if not found
  */
 template<class T>
 …
 /**
    \brief Simple debug info about the Array
+ *  Simple debug info about the Array
 */
 template<class T>

orxonox/trunk/src/lib/graphics/importer/material.cc

-                      r4834
+                      r4836
 #include <string.h>
 //! \todo check if we are in RESOURCE MANAGER-mode
+//! @todo check if we are in RESOURCE MANAGER-mode
 #include "resource_manager.h"
 …
 /**
    \brief creates a Material.
    \param mtlName Name of the Material to be added to the Material List
+ *  creates a Material.
+ * @param mtlName Name of the Material to be added to the Material List
 */
 Material::Material (const char* mtlName)
 …
 /**
     \brief deletes a Material
+  *  deletes a Material
 */
 Material::~Material()
 …
 /**
    \brief sets the material with which the following Faces will be painted
+ *  sets the material with which the following Faces will be painted
 */
 bool Material::select ()
 …
   // setting illumination Model
   if (this->illumModel == 1) //! \todo make this work, if no vertex-normals are read.
+  if (this->illumModel == 1) //! @todo make this work, if no vertex-normals are read.
     glShadeModel(GL_FLAT);
   else if (this->illumModel >= 2)
 …
 /**
    \brief Sets the Material Illumination Model.
    \brief illu illumination Model in int form
+ *  Sets the Material Illumination Model.
+ *  illu illumination Model in int form
 */
 void Material::setIllum (int illum)
 …
+}
 /**
    \brief Sets the Material Illumination Model.
    \brief illu illumination Model in char* form
+ *  Sets the Material Illumination Model.
+ *  illu illumination Model in char* form
 */void Material::setIllum (char* illum)
+{
 …
 /**
    \brief Sets the Material Diffuse Color.
    \param r Red Color Channel.
    \param g Green Color Channel.
    \param b Blue Color Channel.
+ *  Sets the Material Diffuse Color.
+ * @param r Red Color Channel.
+ * @param g Green Color Channel.
+ * @param b Blue Color Channel.
 */
 void Material::setDiffuse (float r, float g, float b)
 …
+}
 /**
    \brief Sets the Material Diffuse Color.
    \param rgb The red, green, blue channel in char format (with spaces between them)
+ *  Sets the Material Diffuse Color.
+ * @param rgb The red, green, blue channel in char format (with spaces between them)
 */
 void Material::setDiffuse (char* rgb)
 …
 /**
    \brief Sets the Material Ambient Color.
    \param r Red Color Channel.
    \param g Green Color Channel.
    \param b Blue Color Channel.
+ *  Sets the Material Ambient Color.
+ * @param r Red Color Channel.
+ * @param g Green Color Channel.
+ * @param b Blue Color Channel.
 */
 void Material::setAmbient (float r, float g, float b)
 …
+}
 /**
    \brief Sets the Material Ambient Color.
    \param rgb The red, green, blue channel in char format (with spaces between them)
+ *  Sets the Material Ambient Color.
+ * @param rgb The red, green, blue channel in char format (with spaces between them)
 */
 void Material::setAmbient (char* rgb)
 …
 /**
    \brief Sets the Material Specular Color.
    \param r Red Color Channel.
    \param g Green Color Channel.
    \param b Blue Color Channel.
+ *  Sets the Material Specular Color.
+ * @param r Red Color Channel.
+ * @param g Green Color Channel.
+ * @param b Blue Color Channel.
 */
 void Material::setSpecular (float r, float g, float b)
 …
+ }
 /**
    \brief Sets the Material Specular Color.
    \param rgb The red, green, blue channel in char format (with spaces between them)
+ *  Sets the Material Specular Color.
+ * @param rgb The red, green, blue channel in char format (with spaces between them)
 */
 void Material::setSpecular (char* rgb)
 …
 /**
    \brief Sets the Material Shininess.
    \param shini stes the Shininess from float.
+ *  Sets the Material Shininess.
+ * @param shini stes the Shininess from float.
 */
 void Material::setShininess (float shini)
 …
+}
 /**
    \brief Sets the Material Shininess.
    \param shini stes the Shininess from char*.
+ *  Sets the Material Shininess.
+ * @param shini stes the Shininess from char*.
 */
 void Material::setShininess (char* shini)
 …
 /**
    \brief Sets the Material Transparency.
    \param trans stes the Transparency from int.
+ *  Sets the Material Transparency.
+ * @param trans stes the Transparency from int.
 */
 void Material::setTransparency (float trans)
 …
+}
 /**
    \brief Sets the Material Transparency.
    \param trans stes the Transparency from char*.
+ *  Sets the Material Transparency.
+ * @param trans stes the Transparency from char*.
 */
 void Material::setTransparency (char* trans)
 …
 /**
    \brief Adds a Texture Path to the List of already existing Paths
    \param pathName The Path to add.
+ *  Adds a Texture Path to the List of already existing Paths
+ * @param pathName The Path to add.
 */
 void Material::addTexturePath(const char* pathName)
 …
 /**
    \brief Sets the Materials Diffuse Map
    \param dMap the Name of the Image to Use
+ *  Sets the Materials Diffuse Map
+ * @param dMap the Name of the Image to Use
 */
 void Material::setDiffuseMap(const char* dMap)
 …
 /**
    \brief Sets the Materials Ambient Map
    \param aMap the Name of the Image to Use
    \todo implement this
+ *  Sets the Materials Ambient Map
+ * @param aMap the Name of the Image to Use
+   @todo implement this
 */
 void Material::setAmbientMap(const char* aMap)
 …
 /**
    \brief Sets the Materials Specular Map
    \param sMap the Name of the Image to Use
    \todo implement this
+ *  Sets the Materials Specular Map
+ * @param sMap the Name of the Image to Use
+   @todo implement this
 */
 void Material::setSpecularMap(const char* sMap)
 …
 /**
    \brief Sets the Materials Bumpiness
    \param bump the Name of the Image to Use
    \todo implemet this
+ *  Sets the Materials Bumpiness
+ * @param bump the Name of the Image to Use
+   @todo implemet this
 */
 void Material::setBump(const char* bump)

orxonox/trunk/src/lib/graphics/importer/material.h

-                      r4746
+                      r4836
   \file material.h
   \brief Contains the Material Class that handles Material for 3D-Objects.
   \todo free SDL-surface when deleting Material.
   \todo delete imgNameWithPath after use creation.
+  @todo free SDL-surface when deleting Material.
+  @todo delete imgNameWithPath after use creation.
 */

orxonox/trunk/src/lib/graphics/importer/md2Model.cc

-                      r4787
+                      r4836
 /**
    \brief initializes an array of vert with the current frame scaled vertices
    \param verticesList: the list of vertices to interpolate between
+ *  initializes an array of vert with the current frame scaled vertices
+ * @param verticesList: the list of vertices to interpolate between
    we won't use the pVertices array directly, since its much easier and we need
 …
 /**
   \brief sets the animation type
   \param type: animation type
+* @param type: animation type
   the animation types can be looked up in the animationType table
 …
 /**
   \brief sets the time in seconds passed since the last tick
   \param time: in sec
+* @param time: in sec
 */
 void MD2Model::tick(float time)
 …
 /**
   \brief this will load the whole model data (vertices, opengl command list, ...)
   \param fileName: the name of the model file
+* @param fileName: the name of the model file
   \return true if success
 */
 …
 /**
   \brief loads the skin/material stuff
   \param fileName: name of the skin file
+* @param fileName: name of the skin file
   \return true if success
 */

orxonox/trunk/src/lib/graphics/importer/md2Model.h

-                      r4787
+                      r4836
 /*!
     \file md2Model.h
     \brief Definition of an MD2 Model, a model format invented by ID Software.
+  *  Definition of an MD2 Model, a model format invented by ID Software.
     We are deeply thankfull for all the wunderfull things id software made for us gamers!
 …
   void setAnim(int type);
   /**
      \brief scales the current model
      \param scaleFactor: the factor [0..1] to use for scaling
+   *  scales the current model
+   * @param scaleFactor: the factor [0..1] to use for scaling
   */
   void scaleModel(float scaleFactor) { this->scaleFactor = scaleFactor;}

orxonox/trunk/src/lib/graphics/importer/model.cc

-                      r4834
+                      r4836
 ////////////////////
 /**
    \brief creates a new ModelFaceElement
+ *  creates a new ModelFaceElement
 */
 ModelFaceElement::ModelFaceElement()
 …
 /**
    \brief destroys a ModelFaceElement
+ *  destroys a ModelFaceElement
 */
 ModelFaceElement::~ModelFaceElement()
 …
 /**
    \brief creates a new ModelFace
+ *  creates a new ModelFace
 */
 ModelFace::ModelFace()
 …
 /**
    \brief deletes a ModelFace
+ *  deletes a ModelFace
 */
 ModelFace::~ModelFace()
 …
 /**
    \brief Creates a new ModelGroup
+ *  Creates a new ModelGroup
 */
 ModelGroup::ModelGroup()
 …
 /**
    \brief deletes a ModelGroup
+ *  deletes a ModelGroup
 */
 ModelGroup::~ModelGroup()
 …
 /**
    \brief cleans up a ModelGroup
+ *  cleans up a ModelGroup
    actually does the same as the delete Operator, but does not delete the predecessing group
 …
 /////////////
 /**
    \brief Creates a 3D-Model.
+ *  Creates a 3D-Model.
    assigns it a Name and a Type
 …
 /**
    \brief deletes an Model.
+ *  deletes an Model.
    Looks if any from model allocated space is still in use, and if so deleted it.
 …
 /**
    \brief Finalizes an Object. This can be done outside of the Class.
+ *  Finalizes an Object. This can be done outside of the Class.
 */
 void Model::finalize()
 …
 //////////
 /**
    \brief Draws the Models of all Groups.
+ *  Draws the Models of all Groups.
    It does this by just calling the Lists that must have been created earlier.
 */
 …
 /**
    \brief Draws the Model number groupNumber
    \param groupNumber The number of the group that will be displayed.
+ *  Draws the Model number groupNumber
+ * @param groupNumber The number of the group that will be displayed.
    It does this by just calling the List that must have been created earlier.
 …
 /**
    \brief Draws the Model with a specific groupName
    \param groupName The name of the group that will be displayed.
+ *  Draws the Model with a specific groupName
+ * @param groupName The name of the group that will be displayed.
    It does this by just calling the List that must have been created earlier.
 …
 //////////
 /**
    \brief deletes all the arrays
+ *  deletes all the arrays
 */
 bool Model::deleteArrays()
 …
 /**
    \brief finalizes an Model.
+ *  finalizes an Model.
  * This funcion is needed, to delete all the Lists, and arrays that are no more
  * needed because they are already imported into openGL.
 …
 //////////
 /**
    \brief adds a new Material to the Material List
    \param material the Material to add
    \returns the added material
+ *  adds a new Material to the Material List
+ * @param material the Material to add
+ * @returns the added material
+ *
  * this also tells this Model, that all the Materials are handled externally
 …
 /**
    \brief adds a new Material to the Material List
    \param materialName the name of the Material to add
    \returns the added material
+ *  adds a new Material to the Material List
+ * @param materialName the name of the Material to add
+ * @returns the added material
 */
 Material* Model::addMaterial(const char* materialName)
 …
 /**
    \brief finds a Material by its name and returns it
    \param materialName the Name of the material to search for.
    \returns the Material if found, NULL otherwise
+ *  finds a Material by its name and returns it
+ * @param materialName the Name of the material to search for.
+ * @returns the Material if found, NULL otherwise
 */
 Material* Model::findMaterialByName(const char* materialName)
 …
 /**
    \brief parses a group String
    \param groupString the new Group to create
+ *  parses a group String
+ * @param groupString the new Group to create
    This function initializes a new Group.
 …
 /**
    \brief parses a vertex-String
    \param vertexString The String that will be parsed.
+ *  parses a vertex-String
+ * @param vertexString The String that will be parsed.
    If a vertex line is found this function will inject it into the vertex-Array
 …
 /**
    \brief parses a vertex-String
    \param x the X-coordinate of the Vertex to add.
    \param y the Y-coordinate of the Vertex to add.
    \param z the Z-coordinate of the Vertex to add.
+ *  parses a vertex-String
+ * @param x the X-coordinate of the Vertex to add.
+ * @param y the Y-coordinate of the Vertex to add.
+ * @param z the Z-coordinate of the Vertex to add.
 */
 …
 /**
    \brief parses a vertexNormal-String
    \param normalString The String that will be parsed.
+ *  parses a vertexNormal-String
+ * @param normalString The String that will be parsed.
    If a vertexNormal line is found this function will inject it into the vertexNormal-Array
 …
 /**
    \brief adds a VertexNormal.
    \param x The x coordinate of the Normal.
    \param y The y coordinate of the Normal.
    \param z The z coordinate of the Normal.
+ *  adds a VertexNormal.
+ * @param x The x coordinate of the Normal.
+ * @param y The y coordinate of the Normal.
+ * @param z The z coordinate of the Normal.
    If a vertexNormal line is found this function will inject it into the vertexNormal-Array
 …
 /**
    \brief parses a vertexTextureCoordinate-String
    \param vTextureString The String that will be parsed.
+ *  parses a vertexTextureCoordinate-String
+ * @param vTextureString The String that will be parsed.
    If a vertexTextureCoordinate line is found,
 …
 /**
    \brief adds a Texture Coordinate
    \param u The u coordinate of the TextureCoordinate.
    \param v The y coordinate of the TextureCoordinate.
+ *  adds a Texture Coordinate
+ * @param u The u coordinate of the TextureCoordinate.
+ * @param v The y coordinate of the TextureCoordinate.
    If a TextureCoordinate line is found this function will inject it into the TextureCoordinate-Array
 …
 /**
    \brief parses a face-string
    \param faceString The String that will be parsed.
+ *  parses a face-string
+ * @param faceString The String that will be parsed.
    If a face line is found this function will add it to the glList.
 …
 /**
    \brief adds a new Face
    \param faceElemCount the number of Vertices to add to the Face.
    \param type The information Passed with each Vertex
+ *  adds a new Face
+ * @param faceElemCount the number of Vertices to add to the Face.
+ * @param type The information Passed with each Vertex
 */
 bool Model::addFace(int faceElemCount, VERTEX_FORMAT type, ...)
 …
 /**
    \brief Function that selects a material, if changed in the obj file.
    \param matString the Material that will be set.
+ *  Function that selects a material, if changed in the obj file.
+ * @param matString the Material that will be set.
 */
 bool Model::setMaterial(const char* matString)
 …
 /**
    \brief Function that selects a material, if changed in the obj file.
    \param mtl the Material that will be set.
+ *  Function that selects a material, if changed in the obj file.
+ * @param mtl the Material that will be set.
 */
 bool Model::setMaterial(Material* mtl)
 …
 /**
    \brief A routine that is able to create normals.
+ *  A routine that is able to create normals.
    The algorithm does the following:
 …
 ////////////
 /**
    \brief reads and includes the Faces/Materials into the openGL state Machine
+ *  reads and includes the Faces/Materials into the openGL state Machine
 */
 bool Model::importToDisplayList()
 …
 /**
    \brief reads and includes the Faces/Materials into the openGL state Machine
+ *  reads and includes the Faces/Materials into the openGL state Machine
 */
 bool Model::importToVertexArray()
 …
 /**
    \brief builds an array of triangles, that can later on be used for obb separation and octree separation
+ *  builds an array of triangles, that can later on be used for obb separation and octree separation
  */
 bool Model::buildTriangleList()
 …
 /**
    \brief Adds a Face-element (one vertex of a face) with all its information.
    \param elem The FaceElement to add to the OpenGL-environment.
+ *  Adds a Face-element (one vertex of a face) with all its information.
+ * @param elem The FaceElement to add to the OpenGL-environment.
    It does this by searching:
 …
 /**
    \brief Includes a default model
+ *  Includes a default model
    This will inject a Cube, because this is the most basic model.

orxonox/trunk/src/lib/graphics/importer/model.h

-                      r4834
+                      r4836
    MODEL_DISPLAY_LIST means, that a DisplayList will be built out of the model. This model will be STATIC, meaning it cannot be changed after initialisation.
    MODEL_VERTEX_ARRAY means, that a VertexArray will be built out of the model. This moel will be DYNAMIX, meaning that one can change the properties from outside of the model.
  * \todo implement this stuff
+ * @todo implement this stuff
 */
 typedef enum MODEL_TYPE {
 …
   ModelFace*   firstFace;      //!< The first Face in this group.
   ModelFace*   currentFace;    //!< The current Face in this Group (the one we are currently working with.)
   int          faceMode;       //!< The Mode the Face is in: initially -1, 0 for FaceList opened, 1 for Material,  3 for triangle, 4 for Quad, 5+ for Poly \todo ENUM...
+  int          faceMode;       //!< The Mode the Face is in: initially -1, 0 for FaceList opened, 1 for Material,  3 for triangle, 4 for Quad, 5+ for Poly @todo ENUM...
   int          faceCount;      //!< The Number of Faces this Group holds.
 …
   void draw(char* groupName) const;
   /** \returns Count of the Models (Groups) in this File */
+  /** @returns Count of the Models (Groups) in this File */
   inline int getGroupCount() const { return this->groupCount; };
   /** \returns a Pointer to the Vertex-Array, if it was deleted it returns NULL */
+  /** @returns a Pointer to the Vertex-Array, if it was deleted it returns NULL */
   inline const GLfloat* getVertexArray() const { return this->vertices->getArray(); };
   /** \returns the VertexCount of this Model */
+  /** @returns the VertexCount of this Model */
   inline unsigned int getVertexCount() const { return this->vertexCount; };
   /** \returns a Pointer to the Normals-Array, if it was deleted it returns NULL */
+  /** @returns a Pointer to the Normals-Array, if it was deleted it returns NULL */
   inline const GLfloat* getNormalsArray() const { return this->normals->getArray(); };
   /** \returns the NormalsCount of this Model */
+  /** @returns the NormalsCount of this Model */
   inline unsigned int getNormalsCount() const { return this->normalCount; };
   /** \returns a Pointer to the TexCoord-Array, if it was deleted it returns NULL */
+  /** @returns a Pointer to the TexCoord-Array, if it was deleted it returns NULL */
   inline const GLfloat* getTexCoordArray() const { return this->vTexture->getArray(); };
   /** \returns the TexCoord-Count of this Model */
+  /** @returns the TexCoord-Count of this Model */
   inline unsigned int getTexCoordCount() const { return this->texCoordCount; };
   /** \returns the Count of Faces of this Model */
+  /** @returns the Count of Faces of this Model */
   inline unsigned int getFaceCount() const { return this->faceCount; };
 …
  protected:
   float            scaleFactor;     //!< The Factor with which the Model should be scaled. \todo maybe one wants to scale the Model after Initialisation
+  float            scaleFactor;     //!< The Factor with which the Model should be scaled. @todo maybe one wants to scale the Model after Initialisation
  private:

orxonox/trunk/src/lib/graphics/importer/objModel.cc

-                      r4371
+                      r4836
 /**
    \brief Crates a 3D-Model, loads in a File and scales it.
    \param fileName file to parse and load (must be a .obj file)
    \param scaling The factor that the model will be scaled with.
+ *  Crates a 3D-Model, loads in a File and scales it.
+ * @param fileName file to parse and load (must be a .obj file)
+ * @param scaling The factor that the model will be scaled with.
 */
 OBJModel::OBJModel(const char* fileName, float scaling) : Model(fileName)
 …
 /**
    \brief deletes an OBJModel.
+ *  deletes an OBJModel.
    Looks if any from model allocated space is still in use, and if so deleted it.
 …
 /**
    \brief Imports a obj file and handles the the relative location
    \param fileName The file to import
+ *  Imports a obj file and handles the the relative location
+ * @param fileName The file to import
    Splits the FileName from the DirectoryName
 …
 /**
    \brief Reads in the .obj File and sets all the Values.
+ *  Reads in the .obj File and sets all the Values.
    This function does read the file, parses it for the occurence of things like vertices, faces and so on, and executes the specific tasks
 */
 …
           this->addGroup (buffer+2);
+        }
       else if (!strncmp(buffer, "s ", 2)) //! \todo smoothing groups have to be implemented
+      else if (!strncmp(buffer, "s ", 2)) //! @todo smoothing groups have to be implemented
+        {
           PRINTF(2)("smoothing groups not supportet yet. line: %s\n", buffer);
 …
 /**
     \brief Function to read in a mtl File.
     \param mtlFile The .mtl file to read
+  *  Function to read in a mtl File.
+  * @param mtlFile The .mtl file to read
     This Function parses all Lines of an mtl File.

orxonox/trunk/src/lib/graphics/importer/primitive_model.cc

-                      r4678
+                      r4836
 /**
    \brief Creates a 3D-Model of Primitive-Type type
+ *  Creates a 3D-Model of Primitive-Type type
    if you want to just display a Cube/Sphere/Cylinder/... without any material.
    \todo implement Cube/Sphere/Cylinder/...
+   @todo implement Cube/Sphere/Cylinder/...
 */
 PrimitiveModel::PrimitiveModel(PRIMITIVE type, float size, unsigned int detail)
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 …
 /**
    \brief Builds a Sphere into the Model.
    \param size The diameter of the Sphere.
    \param detail The detail of the Sphere.
+ *  Builds a Sphere into the Model.
+ * @param size The diameter of the Sphere.
+ * @param detail The detail of the Sphere.
 */
 void PrimitiveModel::sphereModel(float size, unsigned int detail)
 …
+}
 /**
    \brief Creates a Cylinder.
+ *  Creates a Cylinder.
 */
 void PrimitiveModel::cylinderModel(float size, unsigned int detail)
 …
 /**
    \brief creates a cone inside of this Model
    \param size The size of the cone
    \param detail the Detail-level of this cone
+ *  creates a cone inside of this Model
+ * @param size The size of the cone
+ * @param detail the Detail-level of this cone
 */
 void PrimitiveModel::coneModel(float size, unsigned int detail)
 …
 /**
    \brief creates a Plane inside of this Model
    \param size The size of this plane
    \param detail the Detail-level of this plane.
+ *  creates a Plane inside of this Model
+ * @param size The size of this plane
+ * @param detail the Detail-level of this plane.
 */
 void PrimitiveModel::planeModel(float size, unsigned int detail)

orxonox/trunk/src/lib/graphics/importer/primitive_model.h

r4468	r4836
1	1	/*!
2	2	\file primitive_model.h
3		~~\brief~~ a Class to handle different simple models like planes cubes spheres and so on.
	3	* a Class to handle different simple models like planes cubes spheres and so on.
4	4	(cube is also an option of Model, but is extended here.
5	5	*/

orxonox/trunk/src/lib/graphics/importer/texture.cc

-                      r4746
+                      r4836
 /**
    \brief Constructor for a Texture
+ *  Constructor for a Texture
 */
 Texture::Texture(const char* imageName)
 …
 /**
    \brief Destructor of a Texture
+ *  Destructor of a Texture
    Frees Data, and deletes the textures from GL
 …
 /**
    \brief Loads a Texture to the openGL-environment.
    \param surface the Image to load to openGL
    \returns The ID of the texture.
+ *  Loads a Texture to the openGL-environment.
+ * @param surface the Image to load to openGL
+ * @returns The ID of the texture.
 */
 GLuint Texture::loadTexToGL (SDL_Surface* surface)
 …
 /**
    \brief loads an Image from a file to a Texture
    \param imageName The image to load
+ *  loads an Image from a file to a Texture
+ * @param imageName The image to load
 */
 bool Texture::loadImage(const char* imageName)

orxonox/trunk/src/lib/graphics/importer/texture.h

-                      r4746
+                      r4836
   \brief Contains the texture class, that handles the reading of Images into Texutre-files.
   \todo procedural textures
+  @todo procedural textures
 */
 …
   ~Texture();
   /** \returns The textureID of this texture.  */
+  /** @returns The textureID of this texture.  */
   inline GLuint getTexture() {return this->texture;}
   GLuint loadTexToGL (SDL_Surface* surface);
   /** \returns true if texture has alpha, false otherwise */
+  /** @returns true if texture has alpha, false otherwise */
   inline bool hasAlpha() const {return bAlpha;}

orxonox/trunk/src/lib/graphics/light.cc

-                      r4746
+                      r4836
 /**
  * \param root The XML-element to load the Light from
   \todo what to do, if no Light-Slots are open anymore ???
+ * @param root The XML-element to load the Light from
+  @todo what to do, if no Light-Slots are open anymore ???
  */
  Light::Light(const TiXmlElement* root)
 …
 /**
    \brief destroys a Light
+ *  destroys a Light
 */
 Light::~Light()
 …
 /**
  * \param root The XML-element to load the Light from
+ * @param root The XML-element to load the Light from
  */
 void Light::loadParams(const TiXmlElement* root)
 …
 /**
    \brief sets an emitting Diffuse color of this Light
    \param r red
    \param g green
    \param b blue
+ *  sets an emitting Diffuse color of this Light
+ * @param r red
+ * @param g green
+ * @param b blue
 */
 void Light::setDiffuseColor(GLfloat r, GLfloat g, GLfloat b)
 …
 /**
    \brief sets an emitting Specular color of this Light
    \param r red
    \param g green
    \param b blue
+ *  sets an emitting Specular color of this Light
+ * @param r red
+ * @param g green
+ * @param b blue
 */
 void Light::setSpecularColor(GLfloat r, GLfloat g, GLfloat b)
 …
 /**
    \brief Sets the AttenuationType of this Light Source
    \param constantAttenuation The Constant Attenuation of the Light
    \param linearAttenuation The Linear Attenuation of the Light
    \param quadraticAttenuation The Quadratic Attenuation of the Light
+ *  Sets the AttenuationType of this Light Source
+ * @param constantAttenuation The Constant Attenuation of the Light
+ * @param linearAttenuation The Linear Attenuation of the Light
+ * @param quadraticAttenuation The Quadratic Attenuation of the Light
 */
 void Light::setAttenuation(float constantAttenuation, float linearAttenuation, float quadraticAttenuation)
 …
 /**
    \brief stets the direction of the Spot Light.
    \param direction The direction of the Spot Light.
+ *  stets the direction of the Spot Light.
+ * @param direction The direction of the Spot Light.
 */
 void Light::setSpotDirection(const Vector& direction)
 …
 /**
    \brief sets the cutoff angle of the Light.
    \param cutoff The cutoff angle.
+ *  sets the cutoff angle of the Light.
+ * @param cutoff The cutoff angle.
 */
 void Light::setSpotCutoff(GLfloat cutoff)
 …
 /**
    \brief draws this Light. Being a World-entity the possibility to do this lies at hand.
+ *  draws this Light. Being a World-entity the possibility to do this lies at hand.
 */
 void Light::draw() const
 …
 /**
    \brief Prints out some nice formated debug information about the Light
+ *  Prints out some nice formated debug information about the Light
 */
 void Light::debug() const
 …
 ******************/
 /**
    \brief standard constructor for a Light
+ *  standard constructor for a Light
 */
 LightManager::LightManager ()
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
    first disables Lighting
 …
 /**
    \brief singleton-Reference to the Light-class
+ *  singleton-Reference to the Light-class
 */
 LightManager* LightManager::singletonRef = NULL;
 /**
   \param root the XML-element to load the LightManager's settings from
+* @param root the XML-element to load the LightManager's settings from
  */
 void LightManager::loadParams(const TiXmlElement* root)
 …
 /**
   \param root The XML-element to load Lights from
+* @param root The XML-element to load Lights from
  */
 void LightManager::loadLights(const TiXmlElement* root)
 …
 // set Attributes
 /**
    \brief sets the ambient Color of the Scene
    \param r red
    \param g green
    \param b blue
+ *  sets the ambient Color of the Scene
+ * @param r red
+ * @param g green
+ * @param b blue
 */
 void LightManager::setAmbientColor(GLfloat r, GLfloat g, GLfloat b)
 …
 /**
   \param light the Light to register to the LightManager
+* @param light the Light to register to the LightManager
   This is done explicitely by the constructor of a Light
 …
 /**
   \param light The light to unregister from the LightManager
+* @param light The light to unregister from the LightManager
   This is done every time a Light is destroyed explicitely by the Light-destructor
 …
 /**
    \brief draws all the Lights in their appropriate position
+ *  draws all the Lights in their appropriate position
  */
 void LightManager::draw() const
 …
 /**
    \brief outputs debug information about the Class and its lights
+ *  outputs debug information about the Class and its lights
 */
 void LightManager::debug() const

orxonox/trunk/src/lib/graphics/light.h

-                      r4746
+                      r4836
 /*!
     \file light.h
     \brief Handles Lights.
+  *  Handles Lights.
     A Light is one of the more important things in a 3D-environment,
 …
   void setSpotCutoff(GLfloat cutoff);
   /** \returns the lightNumber*/
+  /** @returns the lightNumber*/
   int getLightNumber() const {return this->lightNumber;}
 …
  public:
   virtual ~LightManager();
   /** \returns a Pointer to the only object of this Class */
+  /** @returns a Pointer to the only object of this Class */
   inline static LightManager* getInstance() { if (!singletonRef) singletonRef = new LightManager();  return singletonRef; };

orxonox/trunk/src/lib/graphics/spatial_separation/quadtree.cc

-                      r4819
+                      r4836
 /**
    \brief standard constructor
    \todo this constructor is not jet implemented - do it
+ *  standard constructor
+   @todo this constructor is not jet implemented - do it
 */
 Quadtree::Quadtree (modelInfo* pModelInfo)
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 …
 /**
    \brief gives the signal to separate the model into a quadtree
+ *  gives the signal to separate the model into a quadtree
  */
 void Quadtree::separate()
 …
 /**
    \brief draws the debug quadtree boxes around the model
+ *  draws the debug quadtree boxes around the model
  */
 void Quadtree::drawTree(int depth, int drawMode) const

orxonox/trunk/src/lib/graphics/spatial_separation/quadtree.h

r4819	r4836
1	1	/*!
2	2	\file quadtree.h
3		~~\brief~~ Definition of a spatial data separation using quadtree
	3	* Definition of a spatial data separation using quadtree
4	4
5	5	*/

orxonox/trunk/src/lib/graphics/spatial_separation/quadtree_node.cc

-                      r4819
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 QuadtreeNode::QuadtreeNode (sTriangleExt* triangles, int numTriangles, Quadtree* quadtree)
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 …
 /**
    \brief gives the signal to separate the model into a quadtree
    \param treeDepth the max depth, the steps to go if treeDept == 0 leaf reached
+ *  gives the signal to separate the model into a quadtree
+ * @param treeDepth the max depth, the steps to go if treeDept == 0 leaf reached
  */
 void QuadtreeNode::separateNode(int treeDepth)
 …
 /**
    \brief gives the signal to separate the model into a quadtree
    \param treeDepth the max depth, the steps to go if treeDept == 0 leaf reached
+ *  gives the signal to separate the model into a quadtree
+ * @param treeDepth the max depth, the steps to go if treeDept == 0 leaf reached
 */
 void QuadtreeNode::separateNode(float minLength)
 …
 /**
    \brief draws the debug quadtree boxes around the model
+ *  draws the debug quadtree boxes around the model
  */
 void QuadtreeNode::drawTree(int depth, int drawMode) const

orxonox/trunk/src/lib/graphics/spatial_separation/quadtree_node.h

r4819	r4836
1	1	/*!
2	2	\file proto_class.h
3		~~\brief~~ Definition of ...
	3	* Definition of ...
4	4
5	5	*/

orxonox/trunk/src/lib/graphics/spatial_separation/spatial_separation.cc

-                      r4819
+                      r4836
 /**
    \brief standard constructor
    \param model the model that is to be separated
    \param overlapSize each box will overlap for a given size
+ *  standard constructor
+ * @param model the model that is to be separated
+ * @param overlapSize each box will overlap for a given size
    The boxes are overlaping because this makes collision detection a lot simpler
 …
 /**
    \brief standard constructor
    \param model the model that is to be separated
    \param overlapSize each box will overlap for a given size
+ *  standard constructor
+ * @param model the model that is to be separated
+ * @param overlapSize each box will overlap for a given size
    The boxes are overlaping because this makes collision detection a lot simpler
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 …
 /**
   \brief creates a quadtree
   \param model the model to do a quadtree on
   \param minLength the minimal length of a quadtree node
+* @param model the model to do a quadtree on
+* @param minLength the minimal length of a quadtree node
   \return the new quadtree
  */
 …
 /**
   \brief creates a quadtree
   \param model the model to do a quadtree on
   \param minLength the minimal length of a quadtree node
+* @param model the model to do a quadtree on
+* @param minLength the minimal length of a quadtree node
   \return the new quadtree
  */
 …
 /**
   \brief creates a quadtree
   \param model the model to do a quadtree on
   \param minLength the minimal length of a quadtree node
+* @param model the model to do a quadtree on
+* @param minLength the minimal length of a quadtree node
   \return the new quadtree
 */
 …
 /**
   \brief gets the maximal dimension of a model
   \param playerModel the model that this measurement is based on
+* @param playerModel the model that this measurement is based on
   \return the maximal dimension of the model
  */

orxonox/trunk/src/lib/graphics/spatial_separation/spatial_separation.h

r4819	r4836
1	1	/*!
2	2	\file spatial_separation.h
3		~~\brief~~ Definition of the generic spatial separation process of model data
	3	* Definition of the generic spatial separation process of model data
4	4
5	5	*/

orxonox/trunk/src/lib/graphics/text_engine.cc

-                      r4834
+                      r4836
 ////////////
 /**
    \brief creates a new Text Element
    \param font the Font to render this text in
    \param type The renderType to display this font in
+ *  creates a new Text Element
+ * @param font the Font to render this text in
+ * @param type The renderType to display this font in
    this constructor is private, because the user should initialize
 …
 /**
    \brief deletes a Text out of memory
+ *  deletes a Text out of memory
    This also ereases the text from the textList of the TextEngine
 …
 /**
    \brief tells the Text, that it should folow a PNode
    \param bindNode: the node to bind this text to
+ *  tells the Text, that it should folow a PNode
+ * @param bindNode: the node to bind this text to
 */
 void Text::setBindNode(PNode* bindNode)
 …
 /**
    \brief sets the Type of this Text
    \param type the type to set.
+ *  sets the Type of this Text
+ * @param type the type to set.
 */
 void Text::setType(int type)
 …
 /**
    \brief Sets a new Text to the font
    \param text the new text to set
+ *  Sets a new Text to the font
+ * @param text the new text to set
 */
 void Text::setText(const char* text)
 …
 /**
    \brief sets a Position.
    \param x the x-position in pixels from the left border
    \param y the y-position in pixels from the top border
+ *  sets a Position.
+ * @param x the x-position in pixels from the left border
+ * @param y the y-position in pixels from the top border
 */
 void Text::setPosition(int x, int y)
 …
 /**
    \brief sets the text-alignment
    \param alignment the alignment to set
+ *  sets the text-alignment
+ * @param alignment the alignment to set
 */
 void Text::setAlignment(TEXT_ALIGNMENT alignment)
 …
 /**
    \brief sets a new color to the font
    \param r Red
    \param g Green
    \param b Blue
+ *  sets a new color to the font
+ * @param r Red
+ * @param g Green
+ * @param b Blue
 */
 void Text::setColor(Uint8 r, Uint8 g, Uint8 b)
 …
 /**
    \brief creates a texture out of the given parameters
+ *  creates a texture out of the given parameters
    this has to be called every time by the user, to if changes were made.
 …
 /**
    \brief draws the Font
+ *  draws the Font
 */
 void Text::draw() const
 …
 /**
    \brief prints out some nice debug information about this text
+ *  prints out some nice debug information about this text
 */
 void Text::debug() const
 …
 ////////////
 /**
    \brief Loads a Font from an SDL_surface into a texture.
    \param surface The surface to make the texture of
    \param texCoord The texture coordinates of the 4 corners of the texture
    \returns the ID of the texture
+ *  Loads a Font from an SDL_surface into a texture.
+ * @param surface The surface to make the texture of
+ * @param texCoord The texture coordinates of the 4 corners of the texture
+ * @returns the ID of the texture
 */
 GLuint Text::loadTexture(SDL_Surface *surface, TexCoord* texCoord)
 …
 /**
    \brief Quick utility function for texture creation
    \param input an integer
    \returns the next bigger 2^n-integer than input
+ *  Quick utility function for texture creation
+ * @param input an integer
+ * @returns the next bigger 2^n-integer than input
 */
 int Text::powerOfTwo(int input)
 …
 ////////////
 /**
    \brief constructs a Font
    \param fontFile the File to load the font from
    \param fontSize the Size of the Font in Pixels
    \param r Red value of the Font.
    \param g Green value of the Font.
    \param b Blue value of the Font.
+ *  constructs a Font
+ * @param fontFile the File to load the font from
+ * @param fontSize the Size of the Font in Pixels
+ * @param r Red value of the Font.
+ * @param g Green value of the Font.
+ * @param b Blue value of the Font.
 */
 Font::Font(const char* fontFile, unsigned int fontSize, Uint8 r, Uint8 g, Uint8 b)
 …
 /**
    \brief destructs a font
+ *  destructs a font
 */
 Font::~Font()
 …
 /**
    \brief sets The Font.
    \param fontFile The file containing the font.
    \returns true if loaded, false if something went wrong, or if a font was loaded before.
+ *  sets The Font.
+ * @param fontFile The file containing the font.
+ * @returns true if loaded, false if something went wrong, or if a font was loaded before.
 */
 bool Font::setFont(const char* fontFile)
 …
 /**
    \brief sets a specific renderStyle
    \param renderStyle the Style to render: a char-array containing:
+ *  sets a specific renderStyle
+ * @param renderStyle the Style to render: a char-array containing:
    i: italic, b: bold, u, underline
 */
 …
 /**
    \brief Sets a new Size to the font
    \param fontSize The new Size in pixels.
+ *  Sets a new Size to the font
+ * @param fontSize The new Size in pixels.
 */
 void Font::setSize(unsigned int fontSize)
 …
 /**
    \brief sets a new color to the font
    \param r Red
    \param g Green
    \param b Blue
+ *  sets a new color to the font
+ * @param r Red
+ * @param g Green
+ * @param b Blue
 */
 void Font::setFastColor(Uint8 r, Uint8 g, Uint8 b)
 …
 /**
    \returns the maximum height of the Font, if the font was initialized, 0 otherwise
+ * @returns the maximum height of the Font, if the font was initialized, 0 otherwise
 */
 int Font::getMaxHeight()
 …
 /**
    \returns the maximum ascent of the Font, if the font was initialized, 0 otherwise
+ * @returns the maximum ascent of the Font, if the font was initialized, 0 otherwise
    the ascent is the pixels of the font above the baseline
 …
 /**
    \returns the maximum descent of the Font, if the font was initialized, 0 otherwise
+ * @returns the maximum descent of the Font, if the font was initialized, 0 otherwise
    the descent is the pixels of the font below the baseline
 …
 /**
    \param character The character to get info about.
    \returns a Glyph struct of a character. This Glyph is a pointer,
+ * @param character The character to get info about.
+ * @returns a Glyph struct of a character. This Glyph is a pointer,
    and MUST be deleted by the user..
 …
   this->initGlyphs(32, numberOfGlyphs);
   this->glyphArray[32]->width = fontSize/3; //!< \todo find out the real size of a Space
+  this->glyphArray[32]->width = fontSize/3; //!< @todo find out the real size of a Space
   int rectSize = this->findOptimalFastTextureSize();
 …
 /**
    \brief stores Glyph Metrics in an Array.
    \param from The Glyph to start from.
    \param count The number of Glyphs to start From.
+ *  stores Glyph Metrics in an Array.
+ * @param from The Glyph to start from.
+ * @param count The number of Glyphs to start From.
 */
 void Font::initGlyphs(Uint16 from, Uint16 count)
 …
 /**
    \returns the optimal size to use as the texture size
    \todo: this algorithm can be a lot more faster, althought it does
+ * @returns the optimal size to use as the texture size
+   @todo: this algorithm can be a lot more faster, althought it does
    not really matter within the init-context, and 128 glyphs.
 …
 /**
    \brief a simple function to get some interesting information about this class
+ *  a simple function to get some interesting information about this class
 */
 void Font::debug()
 …
 ///////////////////
 /**
    \brief standard constructor
+ *  standard constructor
 */
 TextEngine::TextEngine ()
 …
 /**
    \brief the singleton reference to this class
+ *  the singleton reference to this class
 */
 TextEngine* TextEngine::singletonRef = NULL;
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 …
 /**
    \brief function to enable TTF_Fonts
+ *  function to enable TTF_Fonts
 */
 void TextEngine::enableFonts()
 …
 /**
    \brief function to disable TTF_fonts
+ *  function to disable TTF_fonts
 */
 void TextEngine::disableFonts()
 …
 /**
    \brief creates a new Text with a certain font.
+ *  creates a new Text with a certain font.
    \see Font::Font
    \see Text::Text
 …
 /**
    \brief removes a Text from the List
    \param text: the text to delete
+ *  removes a Text from the List
+ * @param text: the text to delete
    this only ereases allocated memory, and removes the text
 …
 /**
    \brief deletes all the Text, and tries to delete all allocated fonts
+ *  deletes all the Text, and tries to delete all allocated fonts
 */
 void TextEngine::flush()
 …
 /**
    \brief draws all the Texts that have been initialized
+ *  draws all the Texts that have been initialized
 */
 void TextEngine::draw() const
 …
 /**
    \brief outputs some nice Debug information
    \todo there should also be something outputted about Font
+ *  outputs some nice Debug information
+   @todo there should also be something outputted about Font
 */
 void TextEngine::debug() const
 …
 /**
    \brief checks if the compiled version and the local version of SDL_ttf match.
    \returns true if match, false otherwise
+ *  checks if the compiled version and the local version of SDL_ttf match.
+ * @returns true if match, false otherwise
 */
 bool TextEngine::checkVersion()

orxonox/trunk/src/lib/graphics/text_engine.h

-                      r4746
+                      r4836
 /*!
     \file text_engine.h
     \brief Definition of textEngine, the Font and the Text
+  *  Definition of textEngine, the Font and the Text
     Text is the text outputed.
 …
   void setPosition(int x, int y);
   void setAlignment(TEXT_ALIGNMENT alignment);
   /** \param blending the blending intensity to set (between 0.0 and 1.0) */
+  /** @param blending the blending intensity to set (between 0.0 and 1.0) */
   inline void setBlending(float blending) {this->blending = blending;}
 …
   // placement in openGL
   GLuint            texture;        //!< A GL-texture to hold the text
   TexCoord          texCoord;       //!< Texture-coordinates \todo fix this to have a struct
+  TexCoord          texCoord;       //!< Texture-coordinates @todo fix this to have a struct
   SDL_Rect          posSize;        //!< An SDL-Rectangle representing the position and size of the Text on the screen.
 …
   void setStyle(const char* renderStyle);
   /** \returns a Pointer to the Array of Glyphs */
+  /** @returns a Pointer to the Array of Glyphs */
   inline Glyph** getGlyphArray() const {return glyphArray;}
   /** \returns the texture to the fast-texture */
+  /** @returns the texture to the fast-texture */
   inline GLuint getFastTextureID() const {return fastTextureID;}
 …
  public:
   virtual ~TextEngine();
   /** \returns a Pointer to the only object of this Class */
+  /** @returns a Pointer to the only object of this Class */
   inline static TextEngine* getInstance() { if (!singletonRef) singletonRef = new TextEngine();  return singletonRef; };

orxonox/trunk/src/lib/gui/gui.cc

-                      r4746
+                      r4836
 /**
    \brief Initializes the Gui
+ *  Initializes the Gui
 */
 Gui::Gui(int argc, char *argv[])
 …
 /**
    \brief starts the OrxonoxGUI
+ *  starts the OrxonoxGUI
 */
 void Gui::startGui()
 …
 /**
    \brief a bool that knows if orxonox should be started
+ *  a bool that knows if orxonox should be started
 */
 bool Gui::startOrxonox = false;
 /**
    \brief Destructor.
+ *  Destructor.
 */
 Gui::~Gui()

orxonox/trunk/src/lib/gui/gui.h

-                      r4746
+                      r4836
  \brief Creation of the Gui
  \todo way to start gui without GTK (textmode) AND IMPROOVE
  \todo curl interface to Download cool stuff
+ @todo way to start gui without GTK (textmode) AND IMPROOVE
+ @todo curl interface to Download cool stuff
  \todo widgets save themselves
  \todo good way to step through all the Widgets
  \todo label -> protected : getlabel function
+ @todo widgets save themselves
+ @todo good way to step through all the Widgets
+ @todo label -> protected : getlabel function
 */

orxonox/trunk/src/lib/gui/gui_audio.cc

-                      r4746
+                      r4836
 /**
    \brief Creates an Audio-Frame
+ *  Creates an Audio-Frame
 */
 GuiAudio::GuiAudio()
 …
 /**
     \brief Destructs the Audio-Stuff
+  *  Destructs the Audio-Stuff
 */
 GuiAudio::~GuiAudio()

orxonox/trunk/src/lib/gui/gui_banner.cc

-                      r4746
+                      r4836
 /**
    \brief Creates a new BannerEventBox and its content.
+ *  Creates a new BannerEventBox and its content.
 */
 GuiBanner::GuiBanner()
 …
     logoBox->fill(logoImage);
     //! \todo add the names of all the guys working on orxonox
+    //! @todo add the names of all the guys working on orxonox
     orxIsLabel = new Label("           " PACKAGE_NAME " is:\n" ORXONOX_STAFF);
     logoBox->fill(orxIsLabel);
 …
 /**
    \brief Destructs it.
+ *  Destructs it.
 */
 GuiBanner::~GuiBanner()

orxonox/trunk/src/lib/gui/gui_element.cc

-                      r4427
+                      r4836
 /**
    \brief standard constructor
    \todo this constructor is not jet implemented - do it
+ *  standard constructor
+   @todo this constructor is not jet implemented - do it
 */
 GuiElement::GuiElement ()
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 …
 /**
    \brief Every GuiElement should set this, or it could result in a SegFault.
+ *  Every GuiElement should set this, or it could result in a SegFault.
 */
 void GuiElement::setMainWidget(Widget* widget)

orxonox/trunk/src/lib/gui/gui_element.h

-                      r4746
+                      r4836
 /*!
     \file gui_element.h
     \brief Definition of ...
+  *  Definition of ...
 */
 …
   virtual ~GuiElement();
   /** \returns the main Widget of this GuiElement. */
+  /** @returns the main Widget of this GuiElement. */
   Widget* getWidget() {return this->mainWidget;}
  protected:

orxonox/trunk/src/lib/gui/gui_exec.cc

-                      r4830
+                      r4836
 /**
     \brief Creates the Exec-Frame
+  *  Creates the Exec-Frame
 */
 GuiExec::GuiExec()
 …
+    {
       Button* start;               //!< The start Button of orxonox.
       Menu* verboseMode;           //!< A Menu for setting the verbose-Mode. \todo setting up a verbose-class.
+      Menu* verboseMode;           //!< A Menu for setting the verbose-Mode. @todo setting up a verbose-class.
       CheckButton* alwaysShow;     //!< A CheckButton, for if orxonox should start with or without gui.
       Button* quit;                //!< A Button to quit the Gui without starting orxonox.
 …
 /**
    \brief Destructs the Execution-stuff
+ *  Destructs the Execution-stuff
 */
 GuiExec::~GuiExec()
 …
 /**
    \brief sets the Directory of the configuration files
    \param confDir the Directory for the configuration files
+ *  sets the Directory of the configuration files
+ * @param confDir the Directory for the configuration files
 */
 void GuiExec::setConfDir(const char* confDir)
 …
 /**
    \brief Sets the location of the configuration File.
    \param fileName the location of the configFile
+ *  Sets the location of the configuration File.
+ * @param fileName the location of the configFile
    The name will be parsed from ~/ to /home/[username] on unix and c:/Documents and Settings/username/Settings/ on Windows
 …
 /**
    \returns The name of the Configuration-File
+ * @returns The name of the Configuration-File
 */
 const char* GuiExec::getConfigFile() const
 …
 /**
    \brief checks if a option should be saved.
    \return 1 if it should 0 if not/
+ *  checks if a option should be saved.
+ * @return 1 if it should 0 if not/
 */
 int GuiExec::shouldsave()
 …
 /**
     \brief Saves the configuration-file to the Disk.\n
     \param widget from which Widget on should be saved.
+  *  Saves the configuration-file to the Disk.\n
+  * @param widget from which Widget on should be saved.
     this Function only opens and closes the file, in between GuiExec::writeFileText(Widget* widget) will execute the real writing process.
 …
 /**
    \brief Actually writes into the configuration file to the disk.
    \param widget from which Widget on should be saved.
    \param depth initially "0", and grows higher, while new Groups are bundeled.
+ *  Actually writes into the configuration file to the disk.
+ * @param widget from which Widget on should be saved.
+ * @param depth initially "0", and grows higher, while new Groups are bundeled.
 */
 void GuiExec::writeFileText(Widget* widget, int depth)
 …
 /**
    \brief Reads in Configuration Data.
    \param widget from which Widget on should be saved.
+ *  Reads in Configuration Data.
+ * @param widget from which Widget on should be saved.
 */
 void GuiExec::readFromFile(Widget* widget)
 …
 /**
    \brief Maps Confugurations to the Options.
    \param widget which widget downwards
    \param varInfo Information about the Variable to read
+ *  Maps Confugurations to the Options.
+ * @param widget which widget downwards
+ * @param varInfo Information about the Variable to read
 */
 void GuiExec::readFileText(Widget* widget, void* varInfo)
 …
 /**
    \brief Locates a Group.
    \param widget The Widget from where to search from
    \param groupName The GroupName for which to search.
    \param depth The Depth of the search seen from the first widget we searched from.
    \returns The Widget that holds the Group, or the NULL if the Group wasn't found.
    \todo do this in gui-gtk.
+ *  Locates a Group.
+ * @param widget The Widget from where to search from
+ * @param groupName The GroupName for which to search.
+ * @param depth The Depth of the search seen from the first widget we searched from.
+ * @returns The Widget that holds the Group, or the NULL if the Group wasn't found.
+   @todo do this in gui-gtk.
 */
 Widget* GuiExec::locateGroup(Widget* widget, char* groupName, int depth)
 …
 /**
    \brief Starts ORXONOX.(not really implemented yet, but the function is there.\n
    \param widget the widget that executed the start command
    \param data additional data
+ *  Starts ORXONOX.(not really implemented yet, but the function is there.\n
+ * @param widget the widget that executed the start command
+ * @param data additional data
    This is a Signal and can be executed through Widget::signal_connect
 …
 /**
    \brief Starts ORXONOX.(not really implemented yet, but the function is there.\n
    \param widget the widget that executed the start command
    \param data additional data
+ *  Starts ORXONOX.(not really implemented yet, but the function is there.\n
+ * @param widget the widget that executed the start command
+ * @param data additional data
    This is a Signal and can be executed through Widget::signal_connect

orxonox/trunk/src/lib/gui/gui_flags.cc

-                      r4746
+                      r4836
 /**
    \brief Creates the Flags-Frame
+ *  Creates the Flags-Frame
 */
 GuiFlags::GuiFlags()
 …
 /**
    \brief Destructs the Flags-stuff
+ *  Destructs the Flags-stuff
 */
 GuiFlags::~GuiFlags()
 …
 /**
    \brief Sets the Flags from widget downwards.
    \param widget the Widget from which on to scan for deeper Options and their settings.
+ *  Sets the Flags from widget downwards.
+ * @param widget the Widget from which on to scan for deeper Options and their settings.
 */
 void GuiFlags::setTextFromFlags(Widget* widget)
 …
 /**
     \brief this actually sets the flagtext, and appends it to flagText
     \param widget like GuiFlags::setTextFromFlags(widget)
     \param flagInfo Information aboout the Flag that should be updated.
+  *  this actually sets the flagtext, and appends it to flagText
+  * @param widget like GuiFlags::setTextFromFlags(widget)
+  * @param flagInfo Information aboout the Flag that should be updated.
 */
 void GuiFlags::flagsText(Widget* widget, void* flagInfo)

orxonox/trunk/src/lib/gui/gui_flags.h

r4746	r4836
17	17	Frame* flagsFrame; //!< The Frame that holds the flagsDisplay.
18	18	Box* flagsBox; //!< The Box that holds the flagsDisplay.
19		CheckButton* shortFlags; //!< CheckButton to change the display of short and long flags \todo show long if long not availible...
	19	CheckButton* shortFlags; //!< CheckButton to change the display of short and long flags @todo show long if long not availible...
20	20	Label* flagsLabel; //!< The Label of the Flags
21	21

orxonox/trunk/src/lib/gui/gui_gtk.cc

-                      r4746
+                      r4836
 /**
    \brief Initializes the Guis GTK-stuff.
    \param argc the argument count.
    \param argv The Argument strings.
+ *  Initializes the Guis GTK-stuff.
+ * @param argc the argument count.
+ * @param argv The Argument strings.
 */
 bool initGUI(int argc, char *argv[])
 …
 /**
    \brief enters the GUI's main-loop
+ *  enters the GUI's main-loop
 */
 bool mainloopGUI()
 …
       // here follows the rest.... this will be nasty.
       //! \todo finish it.
       //! \todo memory leek at save(); and save is a BAD word, use saveString instead, or something like it.
+      //! @todo finish it.
+      //! @todo memory leek at save(); and save is a BAD word, use saveString instead, or something like it.
+    }
 #endif /* HAVE_GTK2 */
 …
 ////////////
 /**
    \brief constructs a Widget
+ *  constructs a Widget
 */
 Widget::Widget()
 …
 /**
    \brief deletes any given Widget
+ *  deletes any given Widget
    This is still pretty crappy.
 */
 …
   this->next = NULL;
   //!  \todo not hiding widget, deleting.
+  //!  @todo not hiding widget, deleting.
   //  this->hide();
   // gtk_destroy_widget(this->widget);
 …
 /**
    \brief sets a new Title to a Widget
    \param title The new Title to set to the Widget
+ *  sets a new Title to a Widget
+ * @param title The new Title to set to the Widget
 */
 void Widget::setTitle(const char* title)
 …
 /**
    \brief makes the widget visible.
+ *  makes the widget visible.
 */
 void Widget::show()
 …
 /**
    \brief hides the widget.
+ *  hides the widget.
 */
 void Widget::hide()
 …
 /**
    \brief Sets the resolution of a specific widget to the given size.
    \param width the width of the widget to set.
    \param height the height of the widget to set.
+ *  Sets the resolution of a specific widget to the given size.
+ * @param width the width of the widget to set.
+ * @param height the height of the widget to set.
 */
 void Widget::setSize(int width, int height)
 …
 /**
    \brief searches through widgets for a Name.
+ *  searches through widgets for a Name.
 */
 Widget* Widget::findWidgetByName(char* name, unsigned int depth)
 …
 /**
    \brief Moves through all the Widgets downwards from this and executes the function on them.
    \param function must be of type void and takes a Widget* as an Input.
    \param depth the current depth. if > 0 then the next Widget will also be walked through.
+ *  Moves through all the Widgets downwards from this and executes the function on them.
+ * @param function must be of type void and takes a Widget* as an Input.
+ * @param depth the current depth. if > 0 then the next Widget will also be walked through.
 */
 void Widget::walkThrough(void(*function)(Widget*), unsigned int depth)
 …
 /**
    \brief Moves through all the Widgets downwards from this and executes the function on them.
    \param function must be of type void and takes a Widget* as an Input.
    \param data Additional Data you want to pass to the function.
    \param depth the current depth. if > 0 then the next Widget will also be walked through.
+ *  Moves through all the Widgets downwards from this and executes the function on them.
+ * @param function must be of type void and takes a Widget* as an Input.
+ * @param data Additional Data you want to pass to the function.
+ * @param depth the current depth. if > 0 then the next Widget will also be walked through.
 */
 void Widget::walkThrough(void(*function)(Widget*, void*), void* data, unsigned int depth)
 …
 /**
     \brief This is for listing the options of "widget"
     \param widget specifies the widget that should be listed
+  *  This is for listing the options of "widget"
+  * @param widget specifies the widget that should be listed
 */
 void Widget::listOptionsAndGroups(Widget* widget)
 …
 /**
     \brief This is for listing the options of "widget"
     \param widget specifies the widget that should be listed
+  *  This is for listing the options of "widget"
+  * @param widget specifies the widget that should be listed
 */
 void Widget::listOptions(Widget* widget)
 …
 /**
     \brief This is for listing the options of "widget"
     \param widget specifies the widget that should be listed
     \param data A Counter, that always knows how many Options have been found yet.
+  *  This is for listing the options of "widget"
+  * @param widget specifies the widget that should be listed
+  * @param data A Counter, that always knows how many Options have been found yet.
 */
 void Widget::listOptions(Widget* widget, void* data)
 …
 /**
     \brief This is for listing the options of "widget"
     \param widget specifies the widget that should be listed
     \param data A Counter, that always knows how many Options have been found yet.
+  *  This is for listing the options of "widget"
+  * @param widget specifies the widget that should be listed
+  * @param data A Counter, that always knows how many Options have been found yet.
 */
 void Widget::printHelp(Widget* widget)
 …
 /**
     \brief Finds an Option by a given number(the n'th option found away from this Widget)
     \param number The Count of options to wait(by reference)
     \param depth The depth of the sarch. if 0 it will not search next pointer
+  *  Finds an Option by a given number(the n'th option found away from this Widget)
+  * @param number The Count of options to wait(by reference)
+  * @param depth The depth of the sarch. if 0 it will not search next pointer
     \todo should return Option* would be much sexier.
+    @todo should return Option* would be much sexier.
 */
 Widget* Widget::findOptionByNumber(int* number, unsigned int depth)
 …
 /**
     \brief This is for listing the groups of "widget"
     \param widget specifies the widget that should be listed
+  *  This is for listing the groups of "widget"
+  * @param widget specifies the widget that should be listed
 */
 void Widget::listGroups(Widget* widget)
 …
 /**
     \brief This is for listing the Groups of "widget". It also displays the n'th number found.
     \param widget specifies the widget that should be listed
     \param data the Counter, that will show the number(this function will raise it by one if a Group is fount.
+  *  This is for listing the Groups of "widget". It also displays the n'th number found.
+  * @param widget specifies the widget that should be listed
+  * @param data the Counter, that will show the number(this function will raise it by one if a Group is fount.
 */
 void Widget::listGroups(Widget* widget, void* data)
 …
 /**
     \brief Finds a Group by a given number(the n'th Group found away from this Widget)
     \param number The Count of options to wait(by reference)
     \param depth The depth of the sarch. if 0 it will not search next pointer
+  *  Finds a Group by a given number(the n'th Group found away from this Widget)
+  * @param number The Count of options to wait(by reference)
+  * @param depth The depth of the sarch. if 0 it will not search next pointer
 */
 Widget* Widget::findGroupByNumber(int* number, unsigned int depth)
 …
 /**
     \brief This is for setting the option of "widget"
     \param widget specifies the widget that should be set.
+  *  This is for setting the option of "widget"
+  * @param widget specifies the widget that should be set.
 */
 void Widget::setOptions(Widget* widget)
 …
 /**
    \brief redraws all the Widgets down from widget
    \param widget The topmost Widget
    \param data ...
+ *  redraws all the Widgets down from widget
+ * @param widget The topmost Widget
+ * @param data ...
 */
 void Widget::redrawOptions(Widget* widget)
 …
 /**
    \brief Walks through all the Flags given at startuptime.
+ *  Walks through all the Flags given at startuptime.
 */
 void Widget::flagCheck(Widget* widget, void* flagName)
 …
 #ifdef HAVE_GTK2
 /**
     \brief Connect any signal to any given Sub-widget
+  *  Connect any signal to any given Sub-widget
 */
 gulong Widget::connectSignal(char* event, gint(*signal)(GtkWidget*, GdkEvent*, void *))
 …
 /**
    \brief Connect a signal with additionally passing the whole Object
+ *  Connect a signal with additionally passing the whole Object
 */
 gulong Widget::connectSignal(char* event, gint(*signal)( GtkWidget*, Widget *))
 …
 /**
    \brief Connect a signal with additionally passing a whole external Object
+ *  Connect a signal with additionally passing a whole external Object
 */
 gulong Widget::connectSignal(char* event, void* extObj, gint(*signal)(GtkWidget*, GdkEvent*, void *))
 …
 /**
    \brief Connect a signal with additionally passing a whole external Object
+ *  Connect a signal with additionally passing a whole external Object
 */
 gulong Widget::connectSignal(char* event, void* extObj, gint(*signal)(GtkWidget*, void *))
 …
 /**
    \brief Connect a signal with additionally passing a whole external Object
+ *  Connect a signal with additionally passing a whole external Object
 */
 gulong Widget::connectSignal(char* event, void* extObj, gint(*signal)(GtkWidget*, GdkEventKey*, void *))
 …
 /**
    \brief Signal that does absolutely nothing
    \param widget The widget that initiated the Signal
    \param event The event-type.
    \param nothing nothin.
+ *  Signal that does absolutely nothing
+ * @param widget The widget that initiated the Signal
+ * @param event The event-type.
+ * @param nothing nothin.
 */
 gint Widget::doNothingSignal(GtkWidget *widget, GdkEvent* event, void* nothing)
 …
 /////////////
 /**
    \brief Constructs a Packer
+ *  Constructs a Packer
 */
 Packer::Packer()
 …
 /**
    \brief Destroys a Packer.
+ *  Destroys a Packer.
 */
 Packer::~Packer()
 …
 /**
    \brief Sets the group name under which all the lower widgets of this will be saved.
    \param name The name of the group.
+ *  Sets the group name under which all the lower widgets of this will be saved.
+ * @param name The name of the group.
 */
 void Packer::setGroupName(const char* name)
 …
 ////////////////
 /**
    \brief Initializes a Container.
+ *  Initializes a Container.
    sets the Container-Specific defaults.
 …
 /**
    \brief Destroys a Container.
+ *  Destroys a Container.
 */
 Container::~Container()
 …
 /**
    \briefFills a Container with lowerWidget.
    \param lowerWidget the Widget that should be filled into the Container.
+ * Fills a Container with lowerWidget.
+ * @param lowerWidget the Widget that should be filled into the Container.
    It does this by filling up the down pointer only if down points to NULL.
 …
 /**
    \param borderwidth sets the Width of the border
+ * @param borderwidth sets the Width of the border
 */
 void Container::setBorderWidth(int borderwidth)
 …
 /**
    \brief The main Window of Th Gui
+ *  The main Window of Th Gui
 */
 Window* Window::mainWindow = NULL;
 /**
    \brief Creating a Window with a name
    \param windowName the name the window should get.
+ *  Creating a Window with a name
+ * @param windowName the name the window should get.
 */
 Window::Window(const char* windowName)
 …
 /**
    \brief Destructs a Window.
+ *  Destructs a Window.
 */
 Window::~Window()
 …
 /**
    \brief Adds a new Window Windows to the List of Windows.
    \param windowToAdd The Windows that should be added to the List
    \todo this instead of windowToAdd(possibly)
+ *  Adds a new Window Windows to the List of Windows.
+ * @param windowToAdd The Windows that should be added to the List
+   @todo this instead of windowToAdd(possibly)
 */
 void Window::addWindow(Window* windowToAdd)
 …
 /**
    \brief Shows all Widgets that are included within this->widget.
+ *  Shows all Widgets that are included within this->widget.
 */
 void Window::showall()
 …
 /**
    \brief Set The Window-title to title
    \param title title the Window should get.
+ *  Set The Window-title to title
+ * @param title title the Window should get.
 */
 void Window::setTitle(const char* title)
 …
 /**
    \brief opens up a Window and fixes the Focus to it
+ *  opens up a Window and fixes the Focus to it
 */
 void Window::open()
 …
 /**
    \brief closes up a Window and removes the Focus from it
+ *  closes up a Window and removes the Focus from it
 */
 void Window::close()
 …
 /**
    \brief opens up a window(not topmost Window).
+ *  opens up a window(not topmost Window).
    this is the Signal that does it. !!SIGNALS ARE STATIC!!
    \param widget the widget that did it.
    \param event the event that did it.
    \param window the Window that should be opened
+ * @param widget the widget that did it.
+ * @param event the event that did it.
+ * @param window the Window that should be opened
 */
 #ifdef HAVE_GTK2
 …
 /**
    \brief closes a window(not topmost Window).
+ *  closes a window(not topmost Window).
    this is the Signal that does it. !!SIGNALS ARE STATIC!!
    \param widget the widget that did it!
    \param event the event that did it!
    \param window the Window that should be closed
+ * @param widget the widget that did it!
+ * @param event the event that did it!
+ * @param window the Window that should be closed
 */
 #ifdef HAVE_GTK2
 …
 ///////////
 /**
    \brief Creates a new Frame with name title
+ *  Creates a new Frame with name title
 */
 Frame::Frame(const char* frameName)
 …
 /**
    \brief destrcucts a Frame
+ *  destrcucts a Frame
 */
 Frame::~Frame()
 …
 /**
    \brief Sets the Frames name to title
    \param title The title the Frame should get.
+ *  Sets the Frames name to title
+ * @param title The title the Frame should get.
 */
 void Frame::setTitle(const char* title)
 …
 //////////////
 /**
    \brief Creates a new EventBox with name title
    \param eventBoxName title the Eventbox should get(only data-structure-internal)
+ *  Creates a new EventBox with name title
+ * @param eventBoxName title the Eventbox should get(only data-structure-internal)
 */
 EventBox::EventBox(const char* eventBoxName)
 …
 /**
    \brief destructs an EventBox.
+ *  destructs an EventBox.
 */
 EventBox::~EventBox()
 …
 /////////
 /**
    \brief Creates a new Box of type boxtype
    \param boxtype if 'v' the Box will be vertically, if 'h' the Box will be horizontally
+ *  Creates a new Box of type boxtype
+ * @param boxtype if 'v' the Box will be vertically, if 'h' the Box will be horizontally
 */
 Box::Box(char boxtype)
 …
 /**
    \brief destructs a Box.
+ *  destructs a Box.
 */
 Box::~Box()
 …
 /**
     \brief Fills a box with a given Widget.
     \param lowerWidget the next Widget that should be appendet to this Box
+  *  Fills a box with a given Widget.
+  * @param lowerWidget the next Widget that should be appendet to this Box
     It does this by apending the first one to its down-pointer and all its following ones to the preceding next-pointer. The last one will receive a NULL pointer as Next
 …
 ////////////
 /**
    \brief Initializes a new Option.
+ *  Initializes a new Option.
    sets all Option-Specific-Values to their defaults.
 */
 …
 /**
    \brief Destroys an Option.
+ *  Destroys an Option.
 */
 Option::~Option()
 …
 /**
    \param defaultValue new defaultValue for this option
+ * @param defaultValue new defaultValue for this option
 */
 void Option::setDefaultValue(int defaultValue)
 …
 /**
    \brief This sets The FlagName of an Option and defines its default Values
+ *  This sets The FlagName of an Option and defines its default Values
    !! Options will be saved if flagname is different from NULL !!
    \param flagname the Name that will be displayed in the output
    \param defaultvalue the default Value for this Option(see definition of defaultvalue
+ * @param flagname the Name that will be displayed in the output
+ * @param defaultvalue the default Value for this Option(see definition of defaultvalue
 */
 void Option::setFlagName(const char* flagname, int defaultvalue)
 …
 /**
     \brief see Option::setFlagName(char* flagname, int defaultvalue)
     \param flagname the Name that will be displayed in the output
     \param defaultvalue the default Value for this Option(see definition of defaultvalue
     \param flagnameshort a short flagname to be displayed in the output
+  *  see Option::setFlagName(char* flagname, int defaultvalue)
+  * @param flagname the Name that will be displayed in the output
+  * @param defaultvalue the default Value for this Option(see definition of defaultvalue
+  * @param flagnameshort a short flagname to be displayed in the output
 */
 void Option::setFlagName(const char* flagname, const char* flagnameshort,  int defaultvalue)
 …
 /**
    \brief Sets the saveable-state of the option.
    \param isSaveable the saveable-state to set.
+ *  Sets the saveable-state of the option.
+ * @param isSaveable the saveable-state to set.
 */
 void Option::saveability(bool isSaveable)
 …
 /**
    \brief saves an Option
    \returns the String that should be saved. (this string __should__ be deleted)
+ *  saves an Option
+ * @returns the String that should be saved. (this string __should__ be deleted)
    this is a default Option save
 …
 /**
    \brief loads an Option from of its loadString
    \param loadString the string from which to load the data from
+ *  loads an Option from of its loadString
+ * @param loadString the string from which to load the data from
 */
 void Option::load(char* loadString)
 …
 /**
    \returns The saveable-state.
+ * @returns The saveable-state.
 */
 bool Option::isSaveable()
 …
 #ifdef HAVE_GTK2
 /**
     \brief Signal OptionChange writes the Value from the Option to its Object-Database.
     \param widget The widget(Option) that has a changed Value
     \param option the Option-Object that should receive the change.
+  *  Signal OptionChange writes the Value from the Option to its Object-Database.
+  * @param widget The widget(Option) that has a changed Value
+  * @param option the Option-Object that should receive the change.
 */
 gint Option::OptionChange(GtkWidget *widget, Widget* option)
 …
 ////////////
 /**
    \brief Creates a new Button with a buttonname
    \param buttonName sets the Name of the Button
+ *  Creates a new Button with a buttonname
+ * @param buttonName sets the Name of the Button
 */
 Button::Button(const char* buttonName)
 …
 /**
    \brief destructs a Button.
+ *  destructs a Button.
 */
 Button::~Button()
 …
 /**
    \brief Sets a new name to the Button
    \param title The name the Button should get
+ *  Sets a new name to the Button
+ * @param title The name the Button should get
 */
 void Button::setTitle(const char *title)
 …
 /**
    \brief redraws the Button
    \todo not implemented yet
+ *  redraws the Button
+   @todo not implemented yet
 */
 void Button::redraw()
 …
 /**
    \brief Button can not be changed, optionChange is empty)
    \todo Actions for non-GTK-mode
+ *  Button can not be changed, optionChange is empty)
+   @todo Actions for non-GTK-mode
 */
 void Button::changeOption()
 …
 /////////////////
 /**
    \brief Creates a new CheckButton with an ame
    \param buttonName The name the CheckButton should display.
+ *  Creates a new CheckButton with an ame
+ * @param buttonName The name the CheckButton should display.
 */
 CheckButton::CheckButton(const char* buttonName)
 …
 /**
    \brief destructs a CheckButton.
+ *  destructs a CheckButton.
 */
 CheckButton::~CheckButton()
 …
 /**
    \brief Sets a new Title to a CheckButton
    \param title The new Name the CheckButton should display.
+ *  Sets a new Title to a CheckButton
+ * @param title The new Name the CheckButton should display.
 */
 void CheckButton::setTitle(const char* title)
 …
 /**
    \returns the Active state of the checkButton
+ * @returns the Active state of the checkButton
 */
 bool CheckButton::isActive()
 …
 /**
    \brief Changed the Option, call this Function
+ *  Changed the Option, call this Function
 */
 void CheckButton::changeOption()
 …
 /**
    \brief Redraws the CheckButton(if option has changed).
+ *  Redraws the CheckButton(if option has changed).
    Example: if new settings are loaded the Button must be redrawn for the GUI to display that Change
 */
 …
 ////////////
 /**
    \brief Creates a new Slider
    \param slidername The data-structure-name of the slider.
    \param start The minimal Value of the slider.
    \param end The maximal Value of the slider.
+ *  Creates a new Slider
+ * @param slidername The data-structure-name of the slider.
+ * @param start The minimal Value of the slider.
+ * @param end The maximal Value of the slider.
 */
 Slider::Slider(const char* slidername, float start, float end)
 …
 /**
    \brief destructs a Slider.
+ *  destructs a Slider.
 */
 Slider::~Slider()
 …
 /**
    \brief sets the exactness of the widget
    \param exactness count of digits after the dot
+ *  sets the exactness of the widget
+ * @param exactness count of digits after the dot
 */
 void Slider::setExactness(int exactness)
 …
 /**
    \brief Setting a new value to the Slider.
+ *  Setting a new value to the Slider.
    Maybe you also require a Slider::redraw() for this to display
 */
 …
 /**
    \brief Redraws the widget
+ *  Redraws the widget
    Example: see void CheckButton::redraw()
 */
 …
 /**
    \brief Changed the Option, call this Function
+ *  Changed the Option, call this Function
 */
 void Slider::changeOption()
 …
 //////////
 /**
    \brief constructs a new Menu, without adding any items to it.
    \param menuName the Name the Menu gets.
+ *  constructs a new Menu, without adding any items to it.
+ * @param menuName the Name the Menu gets.
 */
 Menu::Menu(const char* menuName)
 …
 /**
     \brief Creates a Menu-Item-list out of multiple input.
+  *  Creates a Menu-Item-list out of multiple input.
     !! Consider, that the last input argument has to be "lastItem" for this to work!!
     \param menuname The Database-Name of this Menu
     \param ... items to be added to this Menu. !! Consider, that the last input argument has to be "lastItem" for this to work!!
+  * @param menuname The Database-Name of this Menu
+  * @param ... items to be added to this Menu. !! Consider, that the last input argument has to be "lastItem" for this to work!!
 */
 Menu::Menu(char* menuname, ...)
 …
 /**
    \brief destructs a Menu.
+ *  destructs a Menu.
 */
 Menu::~Menu()
 …
+    {
       delete []this->currItem->name;
       //! \todo destroy menu
+      //! @todo destroy menu
       /*
         #ifdef HAVE_GTK2
 …
 /**
    \brief Initializes a new Menu with no items
+ *  Initializes a new Menu with no items
 */
 void Menu::init()
 …
 /**
    \brief saves the Label of the Menu
    \returns the name of the selected Menu-Item
+ *  saves the Label of the Menu
+ * @returns the name of the selected Menu-Item
 */
 char* Menu::save()
 …
 /**
    \brief loads a Menu from of its loadString
    \param loadString the string from which to load the data from
+ *  loads a Menu from of its loadString
+ * @param loadString the string from which to load the data from
 */
 void Menu::load(char* loadString)
 …
 /**
    \brief appends a new Item to the Menu-List.
    \param itemName the itemName to be appendet.
+ *  appends a new Item to the Menu-List.
+ * @param itemName the itemName to be appendet.
 */
 void Menu::addItem(char* itemName)
 …
 /**
    \brief Redraws the widget
+ *  Redraws the widget
    Example: see void CheckButton::redraw()
 */
 …
 /**
    \brief Changed the Option, call this Function
+ *  Changed the Option, call this Function
 */
 void Menu::changeOption()
 …
 /**
    \brief Creates a new OptionLabel with a LabelName and a Value.
    \param label The name of the OptionLabel.
    \param value The Value of the OptionLabel(what will be displayed).
+ *  Creates a new OptionLabel with a LabelName and a Value.
+ * @param label The name of the OptionLabel.
+ * @param value The Value of the OptionLabel(what will be displayed).
 */
 OptionLabel::OptionLabel(const char* label, const char* value)
 …
 /**
    \brief destructs an OptionLabel.
+ *  destructs an OptionLabel.
 */
 OptionLabel::~OptionLabel()
 …
 /**
    \brief Updates the value of an OptionLabel
    \param newValue The new Name that should be displayed.
+ *  Updates the value of an OptionLabel
+ * @param newValue The new Name that should be displayed.
 */
 void OptionLabel::setValue(const char* newValue)
 …
 /**
    \brief Redraws an OptionLabel(not implemented yet, but it works).
+ *  Redraws an OptionLabel(not implemented yet, but it works).
 */
 void OptionLabel::redraw()
 …
 /**
    \brief Changed the Option, call this Function
+ *  Changed the Option, call this Function
 */
 void OptionLabel::changeOption()
 …
 /**
    \brief creates the Optionlabel save-string
    \returns the String to save.
+ *  creates the Optionlabel save-string
+ * @returns the String to save.
 */
 char* OptionLabel::save()
 …
 /**
    \brief loads an Option from of its loadString
    \param loadString the string from which to load the data from
+ *  loads an Option from of its loadString
+ * @param loadString the string from which to load the data from
 */
 void OptionLabel::load(char* loadString)
 …
 ///////////
 /**
    \brief Creates a new Label with a Text.
    \param text The text to be displayed.
+ *  Creates a new Label with a Text.
+ * @param text The text to be displayed.
 */
 Label:: Label(const char* text)
 …
 /**
    \brief destructs a Label.
+ *  destructs a Label.
 */
 Label::~Label()
 …
 /**
    \brief Sets a new Text to a Label.
    \param text The text to be inserted into the Label.
+ *  Sets a new Text to a Label.
+ * @param text The text to be inserted into the Label.
 */
 void Label::setTitle(const char* text)
 …
 /**
    \brief ereases the Text of a Label
+ *  ereases the Text of a Label
 */
 void Label::ereaseText()
 …
 /**
     \brief appends some Text to a Label
     \param textToAppend The text that will be appended to this Label
+  *  appends some Text to a Label
+  * @param textToAppend The text that will be appended to this Label
 */
 void Label::appendText(char* textToAppend)
 …
 /**
     \brief Appends some integer to the Label
     \param intToAppend The Int that will be added.
+  *  Appends some integer to the Label
+  * @param intToAppend The Int that will be added.
     it does this by just converting the int into a char* and send it to appendText
 …
 /**
    \brief get the Text of a Label
    \return The Text the Label holds.
+ *  get the Text of a Label
+ * @return The Text the Label holds.
 */
 const char* Label::getText()
 …
 //////////////////
 /**
    \brief Creates a new ProgressBar.
    \param label The name you want to get the ProgressBar.
+ *  Creates a new ProgressBar.
+ * @param label The name you want to get the ProgressBar.
 */
 ProgressBar::ProgressBar(const char* label)
 …
 /**
    \brief destructs a ProgressBar
+ *  destructs a ProgressBar
 */
 ProgressBar::~ProgressBar()
 …
 /**
    \brief Sets the Total size of the Bar.(ex. The maximum one can download)
+ *  Sets the Total size of the Bar.(ex. The maximum one can download)
 */
 void ProgressBar::setTotalSize(double totalSize)
 …
 /**
    \brief Sets the progress maximum is this->totalSize
+ *  Sets the progress maximum is this->totalSize
 */
 void ProgressBar::setProgress(double progress)
 …
 /**
     \brief returns the Progress Status
+  *  returns the Progress Status
 */
 double ProgressBar::getProgress()
 …
 ///////////
 /**
    \brief Creates a new Image
    \param imageName the location of the Image on the Hard Disc
+ *  Creates a new Image
+ * @param imageName the location of the Image on the Hard Disc
 */
 Image::Image(const char* imageName)
 …
 /**
    \brief Creates a new Image
    \param imageData data to the PixBuff
+ *  Creates a new Image
+ * @param imageData data to the PixBuff
 */
 Image::Image(char** imageData)
 …
 /**
    \brief destructs an Image.
+ *  destructs an Image.
 */
 Image::~Image()
 …
 /**
     \brief Initializes a new Image
     \param name the name to set to the Image
+  *  Initializes a new Image
+  * @param name the name to set to the Image
 */
 void Image::init(const char* name)
 …
 /////////////////
 /**
    \brief Creates a new FileDialog
    \param fileDialogName a Name for the Dialog
+ *  Creates a new FileDialog
+ * @param fileDialogName a Name for the Dialog
 */
 FileDialog::FileDialog(const char* fileDialogName)
 …
 /**
    \brief destructs a FileDialog
+ *  destructs a FileDialog
 */
 FileDialog::~FileDialog()
 …
 /**
    \brief disables the File Operator Buttons
+ *  disables the File Operator Buttons
 */
 void FileDialog::disableFileOpts()
 …
 /**
    \brief The ok-button has been pressed
+ *  The ok-button has been pressed
 */
 void FileDialog::okEvent()

orxonox/trunk/src/lib/gui/gui_gtk.h

-                      r4746
+                      r4836
   void setGroupName(const char* name);
   /** \returns the GroupName if existent NULL otherwise */
+  /** @returns the GroupName if existent NULL otherwise */
   inline const char* getGroupName() const {return this->groupName;}
 …
   virtual void changeOption();
   char* cValue;                          //!< The Value the Label will have. \todo make private
+  char* cValue;                          //!< The Value the Label will have. @todo make private
 };

orxonox/trunk/src/lib/gui/gui_keys.cc

-                      r4746
+                      r4836
 /**
    \brief Creates an Keyboard-Frame
+ *  Creates an Keyboard-Frame
 */
 GuiKeys::GuiKeys()
 …
 /**
    \brief Destructs the Keys-stuff
+ *  Destructs the Keys-stuff
 */
 GuiKeys::~GuiKeys()
 …
 ////////////
 /**
    \brief Creates new inputs for a player
    \param player the name of the Player
+ *  Creates new inputs for a player
+ * @param player the name of the Player
 */
 PlayerKeys::PlayerKeys(char* player)
 …
 /**
    \returns the OpenButton of a Player
+ * @returns the OpenButton of a Player
 */
 Button* PlayerKeys::getOpenButton()
 …
 //////////////////
 /**
    \brief Creates new inputs for a misc
    \param player the name of the Misc
+ *  Creates new inputs for a misc
+ * @param player the name of the Misc
 */
 MiscKeys::MiscKeys()
 …
 /**
    \returns the OpenButton of a Misc
+ * @returns the OpenButton of a Misc
 */
 Button* MiscKeys::getOpenButton()
 …
 /**
    \brief adds a new Key.
    \param key the number of the Key
    \param name The name of the new Key.
    \returns A widget that has the Key-Box
+ *  adds a new Key.
+ * @param key the number of the Key
+ * @param name The name of the new Key.
+ * @returns A widget that has the Key-Box
 */
 Widget* addKey(const char* name, const char* defaultVal)
 …
 /**
    \brief Function which gets keystrokes
    \param w the widget that released the Function.
    \param event The event that happened.
    \param Widget the Widget which will be applied.
    \returns Nothing
+ *  Function which gets keystrokes
+ * @param w the widget that released the Function.
+ * @param event The event that happened.
+ * @param Widget the Widget which will be applied.
+ * @returns Nothing
 */
 gint key_cb(GtkWidget* w, GdkEventKey* event, void* inputKey)

orxonox/trunk/src/lib/gui/gui_update.cc

-                      r4774
+                      r4836
 /**
    \brief Creates an Update-Frame
+ *  Creates an Update-Frame
 */
 GuiUpdate::GuiUpdate()
 …
 /**
    \brief Destructs the Update-stuff
+ *  Destructs the Update-stuff
 */
 GuiUpdate::~GuiUpdate()
 …
 /**
    \brief checks if the Folder containing selected File is data.oxd, and if so sets it.
    \param
+ *  checks if the Folder containing selected File is data.oxd, and if so sets it.
+ * @param
 */
 bool GuiUpdate::checkDataDir(const char* fileName, void* object)
 …
 /**
     \brief Look what info we can get from this system
+  *  Look what info we can get from this system
 */
 bool GuiUpdate::getSystemInfo()
 …
 /**
    \brief Creates a window, and all it contains for the Data-update.
+ *  Creates a window, and all it contains for the Data-update.
 */
 void GuiUpdate::updateDataWindowCreate()
 …
 /**
    \returns A Pointer to the Button of the UpdaterDataWindow
+ * @returns A Pointer to the Button of the UpdaterDataWindow
 */
 Button* GuiUpdate::updateDataWindowGetButton()
 …
 /**
    \brief Creates a window, and all it contains for the Source-update.
+ *  Creates a window, and all it contains for the Source-update.
 */
 void GuiUpdate::updateSourceWindowCreate()
 …
 /**
    \returns A Pointer to the Button of the UpdaterSourceWindow
+ * @returns A Pointer to the Button of the UpdaterSourceWindow
 */
 Button* GuiUpdate::updateSourceWindowGetButton()
 …
 #ifdef HAVE_GTK2
 /**
    \brief updates the Data of orxonox.
    \param w The widget, that executed this Function.
    \param event The event that trigered this Function.
    \param button The Button, that triggered this event.
+ *  updates the Data of orxonox.
+ * @param w The widget, that executed this Function.
+ * @param event The event that trigered this Function.
+ * @param button The Button, that triggered this event.
 */
 gint GuiUpdate::updateDataFunc(GtkWidget* w, GdkEventKey* event, void* info)
 …
 /**
    \brief updates the source of orxonox.
    \param w The widget, that executed this Function.
    \param event The event that trigered this Function.
    \param button The Button, that triggered this event.
+ *  updates the source of orxonox.
+ * @param w The widget, that executed this Function.
+ * @param event The event that trigered this Function.
+ * @param button The Button, that triggered this event.
 */
 gint GuiUpdate::updateSourceFunc(GtkWidget* w, GdkEventKey* event, void* bar)
 …
 /**
    \brief The Function Curl calls to write out the File.
    \param ptr A Pointer to the date to write.
    \param size The size in bytes of one nmemb to write.
    \param nmemb The Count of size to write.
    \param stream Filehandler to write to.
+ *  The Function Curl calls to write out the File.
+ * @param ptr A Pointer to the date to write.
+ * @param size The size in bytes of one nmemb to write.
+ * @param nmemb The Count of size to write.
+ * @param stream Filehandler to write to.
 */
 size_t GuiUpdate::curlWriteFunc(void* ptr, size_t size, size_t nmemb, FILE* stream)
 …
 /**
    \brief The Function Curl calls to write out the File.
    \param ptr A Pointer to the date to write to.
    \param size The size in bytes of one nmemb to write.
    \param nmemb The Count of size to write.
    \param stream Filehandler to get data from.
+ *  The Function Curl calls to write out the File.
+ * @param ptr A Pointer to the date to write to.
+ * @param size The size in bytes of one nmemb to write.
+ * @param nmemb The Count of size to write.
+ * @param stream Filehandler to get data from.
 */
 size_t GuiUpdate::curlReadFunc(void* ptr, size_t size, size_t nmemb, FILE* stream)
 …
 /**
    \brief An update Function for the GUI, to show the progress.
    \param Bar th ProgressBar to update
    \param totalSize The total size of the download in bytes.
    \param progress The current Progress of the download in bytes.
    \param upTotal not needed
    \param upProgress not needed
+ *  An update Function for the GUI, to show the progress.
+ * @param Bar th ProgressBar to update
+ * @param totalSize The total size of the download in bytes.
+ * @param progress The current Progress of the download in bytes.
+ * @param upTotal not needed
+ * @param upProgress not needed
 */
 int GuiUpdate::curlProgressFunc(ProgressBar* bar, double totalSize, double progress, double upTotal, double upProgress)
 …
 /**
    \brief The Curl handle for only one CURL(static).
+ *  The Curl handle for only one CURL(static).
 */
 CURL* GuiUpdate::curlHandle = NULL;
 …
 /**
    \brief Initializes a Download without displaying it.
    \param fileInfo the FileInfo.
+ *  Initializes a Download without displaying it.
+ * @param fileInfo the FileInfo.
    !! BE AWARE THIS WILL NOT BE THREADED. !!
 …
   char* fileOnNet = new char [strlen(info->webRoot)+strlen(info->fileName)+2];
   strcpy(fileOnNet, info->webRoot);
   if(fileOnNet[strlen(fileOnNet)] != '/') //!< \todo windows-shit
+  if(fileOnNet[strlen(fileOnNet)] != '/') //!< @todo windows-shit
     strcat(fileOnNet, "/");
   strcat(fileOnNet, info->fileName);
   char* fileOnDisk = new char [strlen(info->localRoot)+strlen(info->fileName)+2];
   strcpy(fileOnDisk, info->localRoot);
   if(fileOnDisk[strlen(fileOnDisk)] != '/') //!< \todo windows-shit
+  if(fileOnDisk[strlen(fileOnDisk)] != '/') //!< @todo windows-shit
     strcat(fileOnDisk, "/");
   strcat(fileOnDisk, info->fileName);
 …
 /**
    \brief Initializes a Download with some style.
    \param fileInfo the FileInfo.
    \todo release thread-lock.
+ *  Initializes a Download with some style.
+ * @param fileInfo the FileInfo.
+   @todo release thread-lock.
    Downloading with a Button that gets a different Name while downloading, and a Bar, that gets to be updated. More to be followed
 …
 /**
    \brief The downloading process(either threaded or not).
    \param fileInfo the FileInfo.
    \todo Threads get locked, if the cancel button is pressed in to small intervals.
+ *  The downloading process(either threaded or not).
+ * @param fileInfo the FileInfo.
+   @todo Threads get locked, if the cancel button is pressed in to small intervals.
 */
 void* GuiUpdate::downloadThread(void* fileInfo)
 …
 /**
    \brief Finishes a downloading process.
    \param fileInfo the FileInfo.
+ *  Finishes a downloading process.
+ * @param fileInfo the FileInfo.
 */
 void* GuiUpdate::downloadThreadFinished(void* fileInfo)
 …
 #ifdef HAVE_GTK2
 /**
    \brief canceles a downloading session.
    \param w The widget, that executed this Function.
    \param event The event that trigered this Function.
    \param bar The Bar, that triggered this event.
    \todo canceling a session in non-threaded mode.
+ *  canceles a downloading session.
+ * @param w The widget, that executed this Function.
+ * @param event The event that trigered this Function.
+ * @param bar The Bar, that triggered this event.
+   @todo canceling a session in non-threaded mode.
 */
 gint GuiUpdate::cancelDownload(GtkWidget* w, GdkEventKey* event, void* bar)

orxonox/trunk/src/lib/gui/gui_update.h

r4746	r4836
51	51	Button* updateDataBegin; //!< A Button to start the process.
52	52
53		Button* updateSourceWindowButton; //!< A Button to update the Source of orxonox. \todo tricky
	53	Button* updateSourceWindowButton; //!< A Button to update the Source of orxonox. @todo tricky
54	54	Window* updateSourceWindow; //!< A Window for the Source-update.
55	55	Box* updateSourceBox; //!< A Box for the Window for the Source-update.

orxonox/trunk/src/lib/gui/gui_video.cc

-                      r4777
+                      r4836
 /**
    \brief Creates the Video-Option-Frame
+ *  Creates the Video-Option-Frame
 */
 GuiVideo::GuiVideo()
 …
 /**
    \brief Destructs the Video-stuff
+ *  Destructs the Video-stuff
 */
 GuiVideo::~GuiVideo()
 …
 /**
    \brief Creates a window, and all it contains for the Source-update.
+ *  Creates a window, and all it contains for the Source-update.
 */
 Widget* GuiVideo::advancedWindowCreate()
 …
 /**
    \brief sets all resolutions to the menu
    \param menu the Menu to set The resolutions to.
+ *  sets all resolutions to the menu
+ * @param menu the Menu to set The resolutions to.
 */
 void GuiVideo::getResolutions(Menu* menu)

orxonox/trunk/src/lib/lang/base_object.cc

-                      r4815
+                      r4836
 /**
    \brief sets the name from a LoadXML-Element
    \param root the element to load from
+ *  sets the name from a LoadXML-Element
+ * @param root the element to load from
 */
 BaseObject::BaseObject(const TiXmlElement* root)
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 BaseObject::~BaseObject ()
 …
 /**
    \brief loads parameters
    \param root the element to load from
+ *  loads parameters
+ * @param root the element to load from
 */
 void BaseObject::loadParams(const TiXmlElement* root)
 …
 /**
    \brief sets the class identifiers
    \param id a number for the class from class_id.h enumeration
    \param className the class name
+ *  sets the class identifiers
+ * @param id a number for the class from class_id.h enumeration
+ * @param className the class name
 */
 void BaseObject::setClassID(long classID, const char* className)
 …
 /**
    \brief checks if the class is a classID
    \param classID the Identifier to check for
    \returns true if it is, false otherwise
+ *  checks if the class is a classID
+ * @param classID the Identifier to check for
+ * @returns true if it is, false otherwise
 */
 bool BaseObject::isA (long classID) const
 …
 /**
  * @brief displays everything this class is
+ *  displays everything this class is
  */
 void BaseObject::whatIs() const

orxonox/trunk/src/lib/lang/base_object.h

-                      r4747
+                      r4836
 /*!
     \file base_object.h
     \brief Definition of the base object class.
+  *  Definition of the base object class.
     This is a global handler for all classes.
 …
   inline const char* getName ()const { return this->objectName; };
   /** \returns the className of the corresponding Object */
+  /** @returns the className of the corresponding Object */
   inline const char* getClassName() const { return this->className; };
   /** \returns the classID of the corresponding Object */
+  /** @returns the classID of the corresponding Object */
   inline int getClassID() const { return this->classID; }
 …
   void whatIs() const;
   /** \returns if the object is finalized */
+  /** @returns if the object is finalized */
   inline bool isFinalized() { return this->finalized; }

orxonox/trunk/src/lib/lang/class_list.cc

-                      r4815
+                      r4836
 /**
    \brief Creates a new ClassList
+ *  Creates a new ClassList
 */
 ClassList::ClassList(const long& classID, const char* className)
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 ClassList::~ClassList ()

orxonox/trunk/src/lib/lang/class_list.h

r4782	r4836
1	1	/*!
2	2	\file class_list.h
3		~~\brief~~ Definition of the Class List, that handles a Class-Specific-Control structure
	3	* Definition of the Class List, that handles a Class-Specific-Control structure
4	4
5	5	*/

orxonox/trunk/src/lib/math/curve.cc

-                      r4746
+                      r4836
 /**
     \brief default constructor for a Curve
+  *  default constructor for a Curve
 */
 Curve::Curve()
 …
 /**
    \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)
 …
 /**
    \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)
 …
 /**
    \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)
 …
 /**
    \brief Outputs information about the state of this Curve
+ *  Outputs information about the state of this Curve
 */
 void Curve::debug()
 …
 /**
    \brief Creates a new BezierCurve
+ *  Creates a new BezierCurve
 */
 BezierCurve::BezierCurve ()
 …
 /**
    \brief Creates a new BezierCurve-Derivation-Curve
+ *  Creates a new BezierCurve-Derivation-Curve
 */
 BezierCurve::BezierCurve (int derivation)
 …
 /**
    \brief Deletes a BezierCurve.
+ *  Deletes a BezierCurve.
    It does this by freeing all the space taken over from the nodes
 …
 /**
    \brief Rebuilds a Curve
+ *  Rebuilds a Curve
 */
 void BezierCurve::rebuild()
 …
 /**
    \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)
 …
 /**
    \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)
 …
 /**
    \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)
 …
 /**
    \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)

orxonox/trunk/src/lib/math/curve.h

-                      r4746
+                      r4836
 /*!
     \file curve.h
     \brief A basic 3D curve framework
+  *  A basic 3D curve framework
     Contains classes to handle curves
 …
   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;

orxonox/trunk/src/lib/math/vector.cc

-                      r4746
+                      r4836
 /////////////
 /**
    \brief returns the this-vector normalized to length 1.0
+ *  returns the this-vector normalized to length 1.0
 */
 Vector Vector::getNormalized() const
 …
 /**
    \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()
 …
 /**
    \brief Outputs the values of the Vector
+ *  Outputs the values of the Vector
 */
 void Vector::debug() const
 …
 /////////////////
 /**
    \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
 …
 /**
    \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)
 …
 /**
    \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
 …
 /**
    \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
 */
 …
 /**
    \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
 …
 /**
    \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
 …
 /**
    \brief calculate the conjugate value of the Quaternion
    \return the conjugate Quaternion
+ *  calculate the conjugate value of the Quaternion
+ * @return the conjugate Quaternion
 */
 /*
 …
 /**
    \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
 …
 /**
    \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
 …
 /**
    \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
 …
 /**
    \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)
 …
 /**
    \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])
 …
 /**
    \brief outputs some nice formated debug information about this quaternion
+ *  outputs some nice formated debug information about this quaternion
 */
 void Quaternion::debug()
 …
 /**
    \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)
 …
 /**
    \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)
 …
 /**
    \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)
 …
 /**
    \brief creates a nullrotation (an identity rotation)
+ *  creates a nullrotation (an identity rotation)
 */
 Rotation::Rotation ()
 …
 /**
    \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
 …
 /**
    \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
 …
 /**
    \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)
 …
 /**
    \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
 …
 /**
    \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
 …
 /**
    \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
 …
 /**
    \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
 …
 /**
    \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)
 …
 /**
    \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)
 …
 /**
    \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)
 …
 /**
     \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)
 …
 /**
    \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
 …
 /**
    \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
 …
 /**
    \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
 …
 /**
    \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

orxonox/trunk/src/lib/math/vector.h

-                      r4611
+                      r4836
 /*!
     \file vector.h
     \brief A basic 3D math framework
+  *  A basic 3D math framework
     Contains classes to handle vectors, lines, rotations and planes
 …
   ~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 */
 …
 /**
    \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; };
 …
   /** \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;

orxonox/trunk/src/lib/particles/particle_emitter.cc

-                      r4746
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 ParticleEmitter::ParticleEmitter(const Vector& direction, float angle, float emissionRate,
 …
 /**
    \brief constructs and loads a ParticleEmitter from a XML-element
    \param root the XML-element to load from
+ *  constructs and loads a ParticleEmitter from a XML-element
+ * @param root the XML-element to load from
 */
 ParticleEmitter::ParticleEmitter(const TiXmlElement* root)
 …
 /**
    \brief standard destructor
+ *  standard destructor
    removes the EmitterSystem from the ParticleEngine
 …
 /**
    \brief loads a ParticleEmitter from a XML-element
    \param root the XML-element to load from
+ *  loads a ParticleEmitter from a XML-element
+ * @param root the XML-element to load from
 */
 void ParticleEmitter::loadParams(const TiXmlElement* root)
 …
 /**
    \brief this start the emitter
+ *  this start the emitter
 */
 void ParticleEmitter::start() {}
 …
 /**
    \brief this stops the emitter
+ *  this stops the emitter
 */
 void ParticleEmitter::stop() {}
 …
 /**
    \param type the new Type of this emitter
+ * @param type the new Type of this emitter
 */
 void ParticleEmitter::setType(EMITTER_TYPE type)
 …
 /**
    \brief sets the type of emitter
    \param type the type as a const char*
+ *  sets the type of emitter
+ * @param type the type as a const char*
    dot: EMITTER_DOT, plane: EMITTER_PLANE, cube: EMITTER_CUBE, sphere, EMITTER_SPHERE;
 */
 …
 /**
    \brief sets a new size to the emitter
+ *  sets a new size to the emitter
 */
 void ParticleEmitter::setSize(float emitterSize)
 …
 /**
    \brief set the emission rate
    \param emissionRate: sets the number of particles emitted per second
+ *  set the emission rate
+ * @param emissionRate: sets the number of particles emitted per second
    if you want to change the value of this variable during emission time (to make it more dynamic)
 …
 /**
    \brief how much of the speed from the ParticleEmitter should flow onto the ParticleSystem
    \param value a Value between zero and one
+ *  how much of the speed from the ParticleEmitter should flow onto the ParticleSystem
+ * @param value a Value between zero and one
    if you want to change the value of this variable during emission time (to make it more dynamic)
 …
 /**
    \brief set the angle of the emitter
    \param angle around the direction in which there are particles to be emitted
    \param randomAngle A random spread-angle, the +- randomness of this option
+ *  set the angle of the emitter
+ * @param angle around the direction in which there are particles to be emitted
+ * @param randomAngle A random spread-angle, the +- randomness of this option
    if you want to change the value of this variable during emission time (to make it more dynamic)
 …
 /**
    \brief sets the initial velocity of all particles emitted
    \param velocity The starting velocity of the emitted particles
    \param randomVelocity A random starting velocity, the +- randomness of this option
+ *  sets the initial velocity of all particles emitted
+ * @param velocity The starting velocity of the emitted particles
+ * @param randomVelocity A random starting velocity, the +- randomness of this option
    if you want to change the value of this variable during emission time (to make it more dynamic)
 …
 /**
    \brief sets the initial Momentum of all particles emitted
    \param momentum the new Momentum (just a float for being not too complicated).
    \param randomMomentum variation from the given value.
+ *  sets the initial Momentum of all particles emitted
+ * @param momentum the new Momentum (just a float for being not too complicated).
+ * @param randomMomentum variation from the given value.
  */
 void ParticleEmitter::setEmissionMomentum(float momentum, float randomMomentum)
 …
 /**
    \brief this set the time to life of a particle, after which it will die
    \param dt: the time to live in seconds
    \param system: the system into which to emitt
+ *  this set the time to life of a particle, after which it will die
+ * @param dt: the time to live in seconds
+ * @param system: the system into which to emitt
    if you want to change the value of this variable during emission time (to make it more dynamic)
 …
 /**
    \brief outputs some nice debug information
+ *  outputs some nice debug information
 */
 void ParticleEmitter::debug() const

orxonox/trunk/src/lib/particles/particle_emitter.h

-                      r4746
+                      r4836
 /*!
     \file particle_emitter.h
     \brief Definition of a ParticleEmitter
+  *  Definition of a ParticleEmitter
 */
 …
   void setDirection(float x, float y, float z) { this->direction = Vector(x,y,z); }; //!< todo this should be done via PNODE
   /** \returns the type of the emitter */
+  /** @returns the type of the emitter */
   inline EMITTER_TYPE getType() const { return this->type; };
   /** \returns the Type as a const char * */
+  /** @returns the Type as a const char * */
   const char* getTypeC() const;
   /** \returns the Size of the emitter */
+  /** @returns the Size of the emitter */
   inline float getSize() const { return this->emitterSize; };
   /** \returns the emissionRate */
+  /** @returns the emissionRate */
   inline float getEmissionRate() const { return this->emissionRate; };
   /** \returns the inherit-speed-factor */
+  /** @returns the inherit-speed-factor */
   inline float getInheritSpeed() const { return this->inheritSpeed; };
   /** \returns the SpreadAngle of the emitter */
+  /** @returns the SpreadAngle of the emitter */
   inline float getSpread() const { return this->angle; };
   /** \returns the EmissionVelocity of the emitter */
+  /** @returns the EmissionVelocity of the emitter */
   inline float getEmissionVelocity() const { return this->velocity; };
   /** \returns the EmissionMomentum of this emitter */
+  /** @returns the EmissionMomentum of this emitter */
   inline float getEmissionMomentum() const { return this->momentum; };

orxonox/trunk/src/lib/particles/particle_engine.cc

-                      r4834
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 ParticleEngine::ParticleEngine ()
 …
 /**
    \brief the singleton reference to this class
+ *  the singleton reference to this class
 */
 ParticleEngine* ParticleEngine::singletonRef = NULL;
 /**
    \brief deletes all the system, emitters, connections and Lists
+ *  deletes all the system, emitters, connections and Lists
 */
 ParticleEngine::~ParticleEngine ()
 …
 /**
   \brief loads the ParticleEngines settings and connections between particles and emitters
   \param root the XML-element to load this from.
+* @param root the XML-element to load this from.
  */
 void ParticleEngine::loadParams(const TiXmlElement* root)
 …
 /**
    \brief Adds a System to the System list.
+ *  Adds a System to the System list.
    this is done automatically when creating a ParticleSystem
 …
 /**
    \brief Adds an emitter to the emitterList
+ *  Adds an emitter to the emitterList
    this is done automatically when creating a ParticleEmitter
 …
 /**
   \brief Connects a ParticleSystem to a ParticleSystem thus emitting Particles.
   \param emitter the Emitter to connect to the System
   \param system the System to connect to the Emitter
+* @param emitter the Emitter to connect to the System
+* @param system the System to connect to the Emitter
 */
 void ParticleEngine::addConnection(const char* emitter, const char* system)
 …
 /**
    \brief Connects a ParticleSystem to a ParticleSystem thus emitting Particles.
    \param emitter the Emitter to connect to the System
    \param system the System to connect to the Emitter
+ *  Connects a ParticleSystem to a ParticleSystem thus emitting Particles.
+ * @param emitter the Emitter to connect to the System
+ * @param system the System to connect to the Emitter
 */
 void ParticleEngine::addConnection(ParticleEmitter* emitter, ParticleSystem* system)
 …
 /**
    \brief Removes a system from the systemList and also removes all Connections to the System
    \param system The ParticleSystem to delete
+ *  Removes a system from the systemList and also removes all Connections to the System
+ * @param system The ParticleSystem to delete
 */
 bool ParticleEngine::removeSystem(ParticleSystem* system)
 …
 /**
    \brief removes an emitter from the emitterList and also from all Connections it is attached to.
    \param emitter the ParticleEmitter to remove.
+ *  removes an emitter from the emitterList and also from all Connections it is attached to.
+ * @param emitter the ParticleEmitter to remove.
 */
 bool ParticleEngine::removeEmitter(ParticleEmitter* emitter)
 …
 /**
    \brief removes a Connection between an Emitter and a System
    \param emitter The emitter of the connection to remove
    \param system The system of the connection to remove
    \returns true, if the connection was broken, false if the conntection was not found
+ *  removes a Connection between an Emitter and a System
+ * @param emitter The emitter of the connection to remove
+ * @param system The system of the connection to remove
+ * @returns true, if the connection was broken, false if the conntection was not found
    only if both system and emitter are in the connection the Connection will be broken
 …
 /**
    \brief removes a Connection between an Emitter and a System
    \param connection the connection to remove
+ *  removes a Connection between an Emitter and a System
+ * @param connection the connection to remove
    \see bool ParticleEngine::breakConnection(ParticleEmitter* emitter, ParticleSystem* system)
 …
 /**
    \brief this function ticks all the ParticleSystems, so an animation will flow
    \param dt passed since last tick
+ *  this function ticks all the ParticleSystems, so an animation will flow
+ * @param dt passed since last tick
 */
 void ParticleEngine::tick(float dt)
 …
 /**
    \brief draws all the systems and their Particles.
+ *  draws all the systems and their Particles.
 */
 void ParticleEngine::draw() const
 …
 /**
    \param systemName the name of the system to search for
    \returns the system called by systemName or NULL if not found
+ * @param systemName the name of the system to search for
+ * @returns the system called by systemName or NULL if not found
 */
 ParticleSystem* ParticleEngine::getSystemByName(const char* systemName) const
 …
 /**
    \param number the n-th system to return
    \returns the system called by number or NULL if not found
+ * @param number the n-th system to return
+ * @returns the system called by number or NULL if not found
 */
 ParticleSystem* ParticleEngine::getSystemByNumber(unsigned int number) const
 …
 /**
    \param emitterName the name of the emitter to search for
    \returns the emitter called by emitterName or NULL if not found
+ * @param emitterName the name of the emitter to search for
+ * @returns the emitter called by emitterName or NULL if not found
 */
 ParticleEmitter* ParticleEngine::getEmitterByName(const char* emitterName) const
 …
 /**
    \param number the n-th emitter to return
    \returns the emitter called by number or NULL if not found
+ * @param number the n-th emitter to return
+ * @returns the emitter called by number or NULL if not found
 */
 ParticleEmitter* ParticleEngine::getEmitterByNumber(unsigned int number) const
 …
 /**
    \brief outputs some nice debug information
+ *  outputs some nice debug information
 */
 void ParticleEngine::debug()

orxonox/trunk/src/lib/particles/particle_engine.h

-                      r4746
+                      r4836
 /*!
     \file particle_engine.h
     \brief Definition of the ParticleEngine
+  *  Definition of the ParticleEngine
 */
 …
  public:
   virtual ~ParticleEngine();
   /** \returns a Pointer to the only object of this Class */
+  /** @returns a Pointer to the only object of this Class */
   inline static ParticleEngine* getInstance() { if (!singletonRef) singletonRef = new ParticleEngine();  return singletonRef; };

orxonox/trunk/src/lib/particles/particle_system.cc

-                      r4827
+                      r4836
 /**
    \brief standard constructor
    \param maxCount the Count of particles in the System
    \param type The Type of the ParticleSystem
+ *  standard constructor
+ * @param maxCount the Count of particles in the System
+ * @param type The Type of the ParticleSystem
 */
 ParticleSystem::ParticleSystem (unsigned int maxCount, PARTICLE_TYPE type)
 …
 /**
   \brief creates a Particle System out of a XML-element
   \param root: the XML-element to load from
+* @param root: the XML-element to load from
  */
 ParticleSystem::ParticleSystem(const TiXmlElement* root)
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 ParticleSystem::~ParticleSystem()
 …
 /**
   \param maxCount the maximum count of particles that can be emitted
+* @param maxCount the maximum count of particles that can be emitted
  */
 void ParticleSystem::setMaxCount(int maxCount)
 …
 /**
    \param particleType the type of particles in this System
    \param count how many particles (in PARTICLE_MULTI-mode)
    \todo this will be different
+ * @param particleType the type of particles in this System
+ * @param count how many particles (in PARTICLE_MULTI-mode)
+   @todo this will be different
 */
 void ParticleSystem::setType(const char* particleType)
 …
 /**
    \param particleType the type of particles in this System
    \param count how many particles (in PARTICLE_MULTI-mode)
    \todo this will be different
+ * @param particleType the type of particles in this System
+ * @param count how many particles (in PARTICLE_MULTI-mode)
+   @todo this will be different
 */
 void ParticleSystem::setType(PARTICLE_TYPE particleType, int count)
 …
 // setting properties
 /**
    \brief sets the material to an external material
    \param material: the material to set this material to.
+ *  sets the material to an external material
+ * @param material: the material to set this material to.
    !! important if the extern material gets deleted it MUST be unregistered here or segfault !!
 …
 /**
    \brief Sets the lifespan of newly created particles
+ *  Sets the lifespan of newly created particles
 */
 void ParticleSystem::setLifeSpan(float lifeSpan, float randomLifeSpan)
 …
 /**
    \brief sets the conserve Factor of newly created particles
+ *  sets the conserve Factor of newly created particles
 */
 void ParticleSystem::setConserve(float conserve)
 …
 /////////////////////////////
 /**
    \brief sets a key in the radius-animation on a per-particle basis
    \param lifeCycleTime the time (partilceLifeTime/particleAge) [0-1]
    \param radius the radius at this position
    \param randRadius the randRadius at this position
+ *  sets a key in the radius-animation on a per-particle basis
+ * @param lifeCycleTime the time (partilceLifeTime/particleAge) [0-1]
+ * @param radius the radius at this position
+ * @param randRadius the randRadius at this position
 */
 void ParticleSystem::setRadius(float lifeCycleTime, float radius, float randRadius)
 …
 /**
    \brief sets a key in the mass-animation on a per-particle basis
    \param lifeCycleTime the time (partilceLifeTime/particleAge) [0-1]
    \param mass the mass at this position
    \param randMass the randomMass at this position
+ *  sets a key in the mass-animation on a per-particle basis
+ * @param lifeCycleTime the time (partilceLifeTime/particleAge) [0-1]
+ * @param mass the mass at this position
+ * @param randMass the randomMass at this position
 */
 void ParticleSystem::setMass(float lifeCycleTime, float mass, float randMass)
 …
 /**
    \brief sets a key in the color-animation on a per-particle basis
    \param lifeCycleTime: the time (partilceLifeTime/particleAge) [0-1]
    \param red: red
    \param green: green
    \param blue: blue
    \param alpha: alpha
+ *  sets a key in the color-animation on a per-particle basis
+ * @param lifeCycleTime: the time (partilceLifeTime/particleAge) [0-1]
+ * @param red: red
+ * @param green: green
+ * @param blue: blue
+ * @param alpha: alpha
 */
 void ParticleSystem::setColor(float lifeCycleTime, float red, float green, float blue, float alpha)
 …
 /**
    \brief ticks the system.
    \param dt the time to tick all the Particles of the System
+ *  ticks the system.
+ * @param dt the time to tick all the Particles of the System
    this is used to get all the particles some motion
 …
 /**
     \brief applies some force to a Particle.
     \param field the Field to apply.
+  *  applies some force to a Particle.
+  * @param field the Field to apply.
  */
 void ParticleSystem::applyField(Field* field)
 …
 /**
  * \returns the count of Faces of this ParticleSystem
+ * @returns the count of Faces of this ParticleSystem
  */
 unsigned int ParticleSystem::getFaceCount() const
 …
 /**
    \brief draws all the Particles of this System
+ *  draws all the Particles of this System
    The Cases in this Function all do the same:
 …
+      {
         glColor4fv(drawPart->color);
           //! \todo implement a faster code for the look-at Camera algorithm.
         const PNode* camera = State::getCamera();  //!< \todo MUST be different
+          //! @todo implement a faster code for the look-at Camera algorithm.
+        const PNode* camera = State::getCamera();  //!< @todo MUST be different
         Vector cameraPos = camera->getAbsCoor();
         Vector cameraTargetPos = State::getCameraTarget()->getAbsCoor();
 …
 /**
    \brief adds a new Particle to the System
    \param position the initial position, where the particle gets emitted.
    \param velocity the initial velocity of the particle.
    \param orientation the initial orientation of the Paritcle.
    \param momentum the initial momentum of the Particle (the speed of its rotation).
    \param data some more data given by the emitter
+ *  adds a new Particle to the System
+ * @param position the initial position, where the particle gets emitted.
+ * @param velocity the initial velocity of the particle.
+ * @param orientation the initial orientation of the Paritcle.
+ * @param momentum the initial momentum of the Particle (the speed of its rotation).
+ * @param data some more data given by the emitter
 */
 void ParticleSystem::addParticle(const Vector& position, const Vector& velocity, const Quaternion& orientation, const Quaternion& momentum, unsigned int data)
 …
       particles->momentum = momentum;
       //  particle->rotation = ; //! \todo rotation is once again something to be done.
+      //  particle->rotation = ; //! @todo rotation is once again something to be done.
       particles->massRand = 2*(float)rand()/RAND_MAX -1;
       particles->radiusRand = 2* (float)rand()/RAND_MAX -1;
 …
 /**
    \brief outputs some nice debug information
+ *  outputs some nice debug information
 */
 void ParticleSystem::debug() const

orxonox/trunk/src/lib/particles/particle_system.h

-                      r4746
+                      r4836
   void setColor(float lifeCycleTime, float red, float green, float blue, float alpha);
   /** \returns the Type of the particles */
+  /** @returns the Type of the particles */
   inline PARTICLE_TYPE getType() const { return this->particleType; };
   /** \returns the Material that lies on this particles */
+  /** @returns the Material that lies on this particles */
   inline const Material* getMaterial() const { return this->material; };
   /** \returns the lifespan of the particles */
+  /** @returns the lifespan of the particles */
   inline float getLifeSpan() const { return this->lifeSpan; };
   /** \returns the starting-radius of the particles */
+  /** @returns the starting-radius of the particles */
   inline float getStartRadius() { return this->radiusAnim.getValue(0.0); };
   /** \returns the end-radius of the particles */
+  /** @returns the end-radius of the particles */
   inline float getEndRadius() { return this->radiusAnim.getValue(1.0); };
   /** \returns the conserve-factor of the particles */
+  /** @returns the conserve-factor of the particles */
   inline float getConserve() const { return this->conserve; };
   /** \returns the initial mass of the particles */
+  /** @returns the initial mass of the particles */
   inline float getMass() const { return this->initialMass; };
 …
   virtual void applyField(Field* field);
   /** \brief this is an empty function, because the Physics are implemented in tick \param dt: useless here */
+  /** \brief this is an empty function, because the Physics are implemented in tick @param dt: useless here */
   virtual void tickPhys(float dt) {};

orxonox/trunk/src/lib/particles/quick_animation.cc

-                      r4746
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 QuickAnimation::QuickAnimation ()
 …
 /**
    \brief deletes all the deconstructor stuff
+ *  deletes all the deconstructor stuff
 */
 QuickAnimation::~QuickAnimation ()
 …
 /**
    \brief adds a new entry to the list of keyframes
    \param position the position to add the key to
    \param value the Value to set for the position
    \returns false if the key existed already for a given position
+ *  adds a new entry to the list of keyframes
+ * @param position the position to add the key to
+ * @param value the Value to set for the position
+ * @returns false if the key existed already for a given position
 */
 void QuickAnimation::addEntry(float position, float value)
 …
 /**
    \brief changes an entry in the region of position
    \param position the Position of an existing keyframe
    \param region a deviation of the existing keyframe (like a delta in witch to search for
    \param value the new Value
+ *  changes an entry in the region of position
+ * @param position the Position of an existing keyframe
+ * @param region a deviation of the existing keyframe (like a delta in witch to search for
+ * @param value the new Value
    if the Entry at the in the region of the specified position is found, it will be changed.
     Otherwise a new KeyFrame will be created with value at position.
    \todo rimplement
+   @todo rimplement
 */
 void QuickAnimation::changeEntry(float position, float value, float region)
 …
 /**
    \brief returns the value of the animation at a certain position
    \param position the position to get the value from :)
+ *  returns the value of the animation at a certain position
+ * @param position the position to get the value from :)
 */
 float QuickAnimation::getValue(float position)
 …
 /**
    \brief outputs some nice information about this class
+ *  outputs some nice information about this class
 */
 void QuickAnimation::debug()

orxonox/trunk/src/lib/particles/quick_animation.h

-                      r4746
+                      r4836
 /*!
     \file quick_animation.h
     \brief Definition of the QuickAnimation-class
+  *  Definition of the QuickAnimation-class
 */
 …
   void removeEntry(float position);
   /** \todo implemente those functions
+  /** @todo implemente those functions
       bool moveEntry(float position);
   */

orxonox/trunk/src/lib/physics/fields/field.cc

-                      r4746
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 Field::Field ()
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 …
 /**
   \param root The XML-element to load settings from
+* @param root The XML-element to load settings from
  */
 void Field::loadParams(const TiXmlElement* root)
 …
 /**
    \param magnitude the magnitude of the Field.
+ * @param magnitude the magnitude of the Field.
 */
 void Field::setMagnitude(float magnitude)
 …
 /**
    \param attenuation The attenuation of the Field (the bigger the smaller the region of influence)
+ * @param attenuation The attenuation of the Field (the bigger the smaller the region of influence)
 */
 void Field::setAttenuation(float attenuation)

orxonox/trunk/src/lib/physics/fields/field.h

-                      r4746
+                      r4836
 /*!
     \file field.h
     \brief abstract definition of a Physical Field
+  *  abstract definition of a Physical Field
     This is a totally abstract class, that only enables different Physical Fields to
 …
   /**
       \param data This is the data given to this force, to calculate the ForceVector
       \returns The Force Vector
+    * @param data This is the data given to this force, to calculate the ForceVector
+    * @returns The Force Vector
   */
   virtual Vector calcForce(const Vector& data) const = 0;
   void setMagnitude(float magnitude);
   /** \returns The Magnitude of the Field */
+  /** @returns The Magnitude of the Field */
   inline const float& getMagnitude() const {return this->magnitude;}
   void setAttenuation(float attenuation);
   /** \returns The Attenuation of the Fiels */
+  /** @returns The Attenuation of the Fiels */
   inline const float& getAttenuation() const {return this->attenuation;}

orxonox/trunk/src/lib/physics/fields/fields.h

r4338	r4836
16	16	/*!
17	17	\file fields.h
18		~~\brief~~ collection of all Headers of all the different fileds there are in the
	18	* collection of all Headers of all the different fileds there are in the
19	19	PhysicsEngine
20	20	*/

orxonox/trunk/src/lib/physics/fields/gravity.cc

-                      r4742
+                      r4836
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 …
 /**
    \brief calculates the Gravity on any point in space
    \param data The Position of the Point in space to attache gravity to.
    \returns The force.
+ *  calculates the Gravity on any point in space
+ * @param data The Position of the Point in space to attache gravity to.
+ * @returns The force.
 */
 Vector Gravity::calcForce(const Vector& data) const

orxonox/trunk/src/lib/physics/fields/gravity.h

r4742	r4836
1	1	/*!
2	2	\file gravity.h
3		~~\brief~~ Definition of ...
	3	* Definition of ...
4	4
5	5	*/

orxonox/trunk/src/lib/physics/fields/point_gravity.cc

-                      r4742
+                      r4836
 /**
    \brief standard constructor
    \todo this constructor is not jet implemented - do it
+ *  standard constructor
+   @todo this constructor is not jet implemented - do it
 */
 PointGravity::PointGravity ()
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 …
 /**
    \brief calculates the PointGravity on any point in space
    \param data The Position of the Point in space to attache PointGravity to.
    \returns The force.
+ *  calculates the PointGravity on any point in space
+ * @param data The Position of the Point in space to attache PointGravity to.
+ * @returns The force.
 */
 Vector PointGravity::calcForce(const Vector& data) const

orxonox/trunk/src/lib/physics/fields/point_gravity.h

r4395	r4836
1	1	/*!
2	2	\file point_gravity.h
3		~~\brief~~ Definition of ...
	3	* Definition of ...
4	4
5	5	*/

orxonox/trunk/src/lib/physics/fields/twirl.cc

-                      r4742
+                      r4836
 /**
    \brief standard constructor
    \todo this constructor is not jet implemented - do it
+ *  standard constructor
+   @todo this constructor is not jet implemented - do it
 */
 Twirl::Twirl ()
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 …
 /**
    \brief calculates the Twirl on any point in space
    \param data The Position of the Point in space to attache twirl to.
    \returns The force.
+ *  calculates the Twirl on any point in space
+ * @param data The Position of the Point in space to attache twirl to.
+ * @returns The force.
 */
 Vector Twirl::calcForce(const Vector& data) const

orxonox/trunk/src/lib/physics/fields/twirl.h

r4395	r4836
1	1	/*!
2	2	\file twirl.h
3		~~\brief~~ Definition of ...
	3	* Definition of ...
4	4
5	5	*/

orxonox/trunk/src/lib/physics/physics_connection.cc

-                      r4746
+                      r4836
 /**
    \brief creates a PhysicsConnection
+ *  creates a PhysicsConnection
 */
 PhysicsConnection::PhysicsConnection(PhysicsInterface* subject, Field* field)
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 …
 /**
    \param subjectName the name of the Subject for this PhysicsConnection
+ * @param subjectName the name of the Subject for this PhysicsConnection
 */
 void PhysicsConnection::setSubject(const char* subjectName)
 …
 /**
   \param fieldName the Name of the Field for this connection
+* @param fieldName the Name of the Field for this connection
 */
 void PhysicsConnection::setField(const char* fieldName)
 …
 /**
     \brief applies the Force to some Object.
+  *  applies the Force to some Object.
 */
 void PhysicsConnection::apply() const

orxonox/trunk/src/lib/physics/physics_connection.h

r4746	r4836
1	1	/*!
2	2	\file physics_connection.h
3		~~\brief~~ Definition of The Physical Connection Class.
	3	* Definition of The Physical Connection Class.
4	4	*/
5	5

orxonox/trunk/src/lib/physics/physics_engine.cc

-                      r4749
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 PhysicsEngine::PhysicsEngine()
 …
 /**
    \brief the singleton reference to this class
+ *  the singleton reference to this class
 */
 PhysicsEngine* PhysicsEngine::singletonRef = NULL;
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 …
 /**
   \param root the XML-element to load settings from
+* @param root the XML-element to load settings from
  */
 void PhysicsEngine::loadParams(const TiXmlElement* root)
 …
 /**
  * \param root the XML-element to Load the PhysicsField from
+ * @param root the XML-element to Load the PhysicsField from
  */
 void PhysicsEngine::loadFields(const TiXmlElement* root)
 …
 /**
  * \param root the XML-element to load the PhysicsConnection from
+ * @param root the XML-element to load the PhysicsConnection from
  */
 void PhysicsEngine::loadConnections(const TiXmlElement* root)
 …
 /**
    \brief adds a PhysicsInterface to the list of handeled physicsInterfaces
    \param physicsInterface the interface to add
+ *  adds a PhysicsInterface to the list of handeled physicsInterfaces
+ * @param physicsInterface the interface to add
    this is normally done in the constructor of any PhysicsInterface
 …
 /**
    \brief removes a PhysicsInterface from the list of handeled physicsInterfaces
    \param physicsInterface the interface to remove
+ *  removes a PhysicsInterface from the list of handeled physicsInterfaces
+ * @param physicsInterface the interface to remove
    this is normally done in the destructor of any PhysicsInterface
 …
 /**
   \param physicsInterfaceName the Name of the PhysicsInterface to search for
   \returns the PhysicsInterface if found, or NULL if not
+* @param physicsInterfaceName the Name of the PhysicsInterface to search for
+  @returns the PhysicsInterface if found, or NULL if not
  */
 PhysicsInterface* PhysicsEngine::getPhysicsInterfaceByName(const char* physicsInterfaceName) const
 …
 /**
    \brief adds a Field to the list of handeled fields
    \param field the field to add
+ *  adds a Field to the list of handeled fields
+ * @param field the field to add
    this is normally done in the constructor of any Field
 …
 /**
    \brief removes a Field from the list of handeled fields
    \param field the field to remove
+ *  removes a Field from the list of handeled fields
+ * @param field the field to remove
    this is normally done in the destructor of any Field
 …
 /**
   \param FieldName the Name of the PhysicsInterface to search for
   \returns the Field if found, or NULL if not
+* @param FieldName the Name of the PhysicsInterface to search for
+  @returns the Field if found, or NULL if not
  */
 Field* PhysicsEngine::getFieldByName(const char* FieldName) const
 …
 /**
    \brief adds A Physical Connection to the List of Connections
    \param connection the Connection to add
+ *  adds A Physical Connection to the List of Connections
+ * @param connection the Connection to add
    Usually this is done through the constructor of PhysicshConnections
 …
 /**
    \brief removes A Physical Connection from the List of Connections
    \param connection the Connection to remove
+ *  removes A Physical Connection from the List of Connections
+ * @param connection the Connection to remove
    Usually this is done through the destructor of PhysicsConnections
 …
 /**
   \param physicsConnectionName the Name of the PhysicsInterface to search for
   \returns the PhysicsConnection if found, or NULL if not
+* @param physicsConnectionName the Name of the PhysicsInterface to search for
+  @returns the PhysicsConnection if found, or NULL if not
  */
 PhysicsConnection* PhysicsEngine::getPhysicsConnectionByName(const char* physicsConnectionName) const
 …
 /**
    \brief Steps through all the Connections and Ticks them
    \param dt The time Passed in Seconds
+ *  Steps through all the Connections and Ticks them
+ * @param dt The time Passed in Seconds
    This function brings a flow into the whole animation
 …
 /**
    \brief print out interesting debug information of this class
+ *  print out interesting debug information of this class
 */
 void PhysicsEngine::debug() const

orxonox/trunk/src/lib/physics/physics_engine.h

-                      r4746
+                      r4836
 /*!
     \file physics_engine.h
     \brief Definition of the PhysicsEngine-singleton Class
+  *  Definition of the PhysicsEngine-singleton Class
 */
 …
  public:
   virtual ~PhysicsEngine();
   /** \returns a Pointer to the only object of this Class */
+  /** @returns a Pointer to the only object of this Class */
   inline static PhysicsEngine* getInstance() { if (!singletonRef) singletonRef = new PhysicsEngine();  return singletonRef; };

orxonox/trunk/src/lib/physics/physics_interface.cc

-                      r4762
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
  */
 PhysicsInterface::PhysicsInterface ()
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 PhysicsInterface::~PhysicsInterface ()
 …
 /**
    \brief recalculates the total mass of all the children of this node
+ *  recalculates the total mass of all the children of this node
    (only availiable for PNodes)
 …
+{
   /*
     PNode* massCalcPNode = dynamic_cast<PNode*>(this);  //! \todo not sure if this will work ....
+    PNode* massCalcPNode = dynamic_cast<PNode*>(this);  //! @todo not sure if this will work ....
     float massSum = 0;
 …
 /**
    \brief applyes a field to this Object
    \param field the field to apply
+ *  applyes a field to this Object
+ * @param field the field to apply
 */
 void PhysicsInterface::applyField(Field* field)
 …
 /**
    \brief ticks the PhysicsEffect
    \param dt: the value about which to tick
+ *  ticks the PhysicsEffect
+ * @param dt: the value about which to tick
 */
 void PhysicsInterface::tickPhys( float dt )

orxonox/trunk/src/lib/physics/physics_interface.h

-                      r4762
+                      r4836
 /*!
     \file physics_interface.h
     \brief a physics interface simulating a body with a mass
+  *  a physics interface simulating a body with a mass
 */
 …
   PhysicsInterface();
   virtual ~PhysicsInterface();
   /** \param mass the mass to set for this node. */
+  /** @param mass the mass to set for this node. */
   inline void setMass( float mass ) { this->mass = mass; };
   /** \returns the mass of the node. */
+  /** @returns the mass of the node. */
   inline float getMass( void ) const { return mass; };
   /** \returns the mass of this node plus all its children (only valid for PNodes). */
+  /** @returns the mass of this node plus all its children (only valid for PNodes). */
   inline float getTotalMass( void ) const { return mass + massChildren; };

orxonox/trunk/src/lib/sound/ogg_player.h

r4750	r4836
1	1	/*!
2	2	* @file ogg_player.h
3		* ~~@brief~~ Ogg-Player definition
	3	* Ogg-Player definition
4	4	*/
5	5

orxonox/trunk/src/lib/sound/sound_engine.cc

-                      r4830
+                      r4836
 //////////////////
 /**
    \brief Creates a Soundbuffer out of an inputfile
    \param fileName The name of the File
+ *  Creates a Soundbuffer out of an inputfile
+ * @param fileName The name of the File
 */
 SoundBuffer::SoundBuffer(const char* fileName)
 …
 //////////////////
 /**
    \brief creates a SoundSource at position sourceNode with the SoundBuffer buffer
+ *  creates a SoundSource at position sourceNode with the SoundBuffer buffer
 */
 SoundSource::SoundSource(SoundBuffer* buffer, PNode* sourceNode)
 …
 /**
    \brief deletes a SoundSource
+ *  deletes a SoundSource
 */
 SoundSource::~SoundSource()
 …
 /**
    \brief Plays back a SoundSource
+ *  Plays back a SoundSource
 */
 void SoundSource::play()
 …
 /**
    \brief Stops playback of a SoundSource
+ *  Stops playback of a SoundSource
 */
 void SoundSource::stop()
 …
 /**
    \brief Pauses Playback of a SoundSource
+ *  Pauses Playback of a SoundSource
 */
 void SoundSource::pause()
 …
 /**
    \brief Rewinds Playback of a SoundSource
+ *  Rewinds Playback of a SoundSource
 */
 void SoundSource::rewind()
 …
 /**
    \brief sets the RolloffFactor of the Sound emitted from the SoundSource
    \param rolloffFactor The Factor described
+ *  sets the RolloffFactor of the Sound emitted from the SoundSource
+ * @param rolloffFactor The Factor described
    this tells openAL how fast the Sounds decay outward from the Source
 …
 //////////////////
 /**
    \brief standard constructor
+ *  standard constructor
 */
 SoundEngine::SoundEngine ()
 …
 /**
    \brief the singleton reference to this class
+ *  the singleton reference to this class
 */
 SoundEngine* SoundEngine::singletonRef = NULL;
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 …
 /**
    \brief creates a new SoundSource.
    \param fileName The Name to load the SoundBuffer from
    \param sourceNode The sourceNode to bind this SoundSource to.
    \returns The newly created SoundSource
+ *  creates a new SoundSource.
+ * @param fileName The Name to load the SoundBuffer from
+ * @param sourceNode The sourceNode to bind this SoundSource to.
+ * @returns The newly created SoundSource
    acctualy this is nothing more than a wrapper around the ResourceManager.
 …
 /**
    \brief sets The listener (normaly the Camera)
+ *  sets The listener (normaly the Camera)
 */
 void SoundEngine::setListener(PNode* listener)
 …
 /**
    \brief Sets the doppler values of openAL
    \param dopplerFactor the extent of the doppler-effect
    \param dopplerVelocity the Speed the sound travels
+ *  Sets the doppler values of openAL
+ * @param dopplerFactor the extent of the doppler-effect
+ * @param dopplerVelocity the Speed the sound travels
 */
 void SoundEngine::setDopplerValues(ALfloat dopplerFactor, ALfloat dopplerVelocity)
 …
 /**
    \brief adds a SoundBuffer to the bufferList of the SoundEngine
    \param buffer The buffer to add to the bufferList
+ *  adds a SoundBuffer to the bufferList of the SoundEngine
+ * @param buffer The buffer to add to the bufferList
 */
 void SoundEngine::addBuffer(SoundBuffer* buffer)
 …
 /**
    \brief removes a SoundBuffer from the bufferList of the SoundEngine
    \param buffer The buffer to delete from the SoundEngine
+ *  removes a SoundBuffer from the bufferList of the SoundEngine
+ * @param buffer The buffer to delete from the SoundEngine
 */
 void SoundEngine::removeBuffer(SoundBuffer* buffer)
 …
 /**
    \brief adds a SoundSource to the sourceList of the SoundEngine
    \param source The source to add to the sourceList
+ *  adds a SoundSource to the sourceList of the SoundEngine
+ * @param source The source to add to the sourceList
 */
 void SoundEngine::addSource(SoundSource* source)
 …
 /**
    \brief removes a SoundSource from the sourceList of the SoundEngine
    \param source The source to delete from the SoundEngine
+ *  removes a SoundSource from the sourceList of the SoundEngine
+ * @param source The source to delete from the SoundEngine
 */
 void SoundEngine::removeSource(SoundSource* source)
 …
 /**
    \brief updates all The positions, Directions and Velocities of all Sounds
+ *  updates all The positions, Directions and Velocities of all Sounds
 */
 void SoundEngine::update()
 …
 /**
    \brief Removes all the Buffers that are not anymore needed by any Sources
+ *  Removes all the Buffers that are not anymore needed by any Sources
 */
 void SoundEngine::flushUnusedBuffers()
 …
 /**
    \brief SourceEngine::flushAllBuffers
+ *  SourceEngine::flushAllBuffers
 */
 void SoundEngine::flushAllBuffers()
 …
 /**
   * @brief SourceEngine::flushAllBuffers
+  *  SourceEngine::flushAllBuffers
  */
 void SoundEngine::flushAllSources()
 …
 /**
    \brief initializes Audio in general
+ *  initializes Audio in general
 */
 bool SoundEngine::initAudio()
 …
 /**
    \brief Transforms AL-errors into something readable
    \param err The error found
+ *  Transforms AL-errors into something readable
+ * @param err The error found
 */
 void SoundEngine::PrintALErrorString(ALenum err)

orxonox/trunk/src/lib/sound/sound_engine.h

-                      r4830
+                      r4836
 /*!
     \file sound_engine.h
     \brief Definition of the SoundEngine singleton Class
+  *  Definition of the SoundEngine singleton Class
 */
 …
   ~SoundBuffer();
   /** \returns the ID of the buffer used in this SoundBuffer */
+  /** @returns the ID of the buffer used in this SoundBuffer */
   inline ALuint getID() { return this->bufferID; }
 …
   // development functions
   /** \returns The ID of this Source */
+  /** @returns The ID of this Source */
   inline ALuint getID() const { return this->sourceID; }
   /** \returns the SoundBuffer of this Source */
+  /** @returns the SoundBuffer of this Source */
   inline SoundBuffer* getBuffer() const { return this->buffer; }
   /** \returns the SourceNode of this Source */
+  /** @returns the SourceNode of this Source */
   inline PNode* getNode() const { return this->sourceNode;}
 …
  public:
   virtual ~SoundEngine();
   /** \returns a Pointer to the only object of this Class */
+  /** @returns a Pointer to the only object of this Class */
   inline static SoundEngine* getInstance() { if (!singletonRef) singletonRef = new SoundEngine();  return singletonRef; };

orxonox/trunk/src/lib/util/ini_parser.cc

-                      r4767
+                      r4836
 /**
    \brief constructs an IniParser using a file
    \param filename: the path and name of the file to parse
+ *  constructs an IniParser using a file
+ * @param filename: the path and name of the file to parse
 */
 IniParser::IniParser (const char* filename)
 …
 /**
    \brief removes the IniParser from memory
+ *  removes the IniParser from memory
 */
 IniParser::~IniParser ()
 …
 /**
    \brief opens another file to parse
    \param filename: path and name of the new file to parse
    \return zero on success or -1 if an error occured;
+ *  opens another file to parse
+ * @param filename: path and name of the new file to parse
+ * @return zero on success or -1 if an error occured;
 */
 int IniParser::openFile(const char* filename)
 …
 /**
    \brief set the parsing cursor to the specified section
    \param section: the name of the section to set the cursor to
    \return zero on success or -1 if the section could not be found
+ *  set the parsing cursor to the specified section
+ * @param section: the name of the section to set the cursor to
+ * @return zero on success or -1 if the section could not be found
 */
 int IniParser::getSection( const char* section)
 …
 /**
    \brief gets the next VarName=VarValue pair from the parsing stream
    \param name: a pointer to a buffer to store the name of the entry
    \param value: a pointer to a buffer to store the value of the entry
    \return zero if the buffers have been filled with data or -1 if there are no entries left in the current section
+ *  gets the next VarName=VarValue pair from the parsing stream
+ * @param name: a pointer to a buffer to store the name of the entry
+ * @param value: a pointer to a buffer to store the value of the entry
+ * @return zero if the buffers have been filled with data or -1 if there are no entries left in the current section
 */
 int IniParser::nextVar( const char* name, const char* value)
 …
 /**
    \brief directly acesses an entry in a section
    \param name: the name of the entry to find
    \param section: the section where the entry is to be found
    \param defvalue: what should be returned in case the entry cannot be found
    \return a pointer to a buffer conatining the value of the specified entry. This buffer will contain the data specified in defvalue in case the entry wasn't found
+ *  directly acesses an entry in a section
+ * @param name: the name of the entry to find
+ * @param section: the section where the entry is to be found
+ * @param defvalue: what should be returned in case the entry cannot be found
+ * @return a pointer to a buffer conatining the value of the specified entry. This buffer will contain the data specified in defvalue in case the entry wasn't found
    The returned pointer points to an internal buffer, so do not free it on your own. Do not give a NULL pointer to defvalue, this will certainly

orxonox/trunk/src/lib/util/ini_parser.h

r4767	r4836
1	1	/*!
2	2	\file ini_parser.h
3		~~\brief~~ A small ini file parser
	3	* A small ini file parser
4	4
5	5	Can be used to find a defined [Section] in an ini file and get the VarName=Value entries

orxonox/trunk/src/lib/util/list.h

-                      r4694
+                      r4836
 /**
    \brief an iterator class
+ *  an iterator class
    this enables the user to iterate through a list very easely
 …
 /**
    \brief iterator constructor
    \param startElement:  the first list element from the tList
+ *  iterator constructor
+ * @param startElement:  the first list element from the tList
    normaly you will use it like this:
 …
 /**
    \brief the destructor
+ *  the destructor
 */
 template<class T>
 …
 /**
    \brief use it to iterate through the list
    \returns next list element
+ *  use it to iterate through the list
+ * @returns next list element
 */
 template<class T>
 …
 /**
    \brief gets the element after the selected one, sets the iterator to this point in the list
    \param element the element to seek
    \returns next list element
+ *  gets the element after the selected one, sets the iterator to this point in the list
+ * @param element the element to seek
+ * @returns next list element
   Attention: if you seek an element, the iterator pointer will point to the NEXT listelement after the argument!
 …
 /**
    \brief the list template class
+ *  the list template class
    you will use this as a generic list for all type of objects
 …
 /**
    \brief the constructor
+ *  the constructor
 */
 template<class T>
 …
 /**
    \brief the deconstructor
+ *  the deconstructor
    this will delete only the list. ATTENTION: the list is deleted, but the objects in the list will
 …
 /**
    \brief add an entity to the list
    \param entity: the entity to add
+ *  add an entity to the list
+ * @param entity: the entity to add
 */
 template<class T>
 …
 /**
    \brief remove an entity from the list
    \param entity: the entity to be removed
+ *  remove an entity from the list
+ * @param entity: the entity to be removed
 */
 template<class T>
 …
 /**
    \brief this will deletes the objects from the list
+ *  this will deletes the objects from the list
 */
 template<class T>
 …
 /**
    \brief returns the first element of the list
    \returns first element
+ *  returns the first element of the list
+ * @returns first element
 */
 template<class T>
 …
 /**
    \brief function returns the last element of the list
    \returns the last element
+ *  function returns the last element of the list
+ * @returns the last element
 */
 template<class T>
 …
 /**
    \brief returns true if the list is empty
    \returns true if the list is empty
+ *  returns true if the list is empty
+ * @returns true if the list is empty
 */
 template<class T>
 …
 /**
    \brief checks if an entity is in the List
    \param entity The entity to check for in the entire List.
    \returns true if it is, false otherwise
+ *  checks if an entity is in the List
+ * @param entity The entity to check for in the entire List.
+ * @returns true if it is, false otherwise
 */
 template<class T>
 …
 /**
    \brief this returns the number of elements in the list
    \returns number of elements
+ *  this returns the number of elements in the list
+ * @returns number of elements
 */
 template<class T>
 …
 /**
    \brief creates an itereator object and returns it
    \returns the iterator object to this list
+ *  creates an itereator object and returns it
+ * @returns the iterator object to this list
    You will use this, if you want to iterate through the list
 …
 /**
    \brief this returns the next element after toEntity or the first if toEntity is last
    \param toEntity: the entity after which is an entity, that has to be returned, sorry, terrible phrase
    \returns the element after toEntity
+ *  this returns the next element after toEntity or the first if toEntity is last
+ * @param toEntity: the entity after which is an entity, that has to be returned, sorry, terrible phrase
+ * @returns the element after toEntity
 */
 template<class T>
 …
 /**
    \brief creates an array out of the list (ATTENTION: not implemented)
    \returns pointer to the array beginning
+ *  creates an array out of the list (ATTENTION: not implemented)
+ * @returns pointer to the array beginning
    ATTENTION: function is not implemented and wont do anything

orxonox/trunk/src/lib/util/substring.cc

-                      r4833
+                      r4836
 /**
    \brief breaks a string into parts that were initially seperated by comma
    \param string the string to break into substrings
+ *  breaks a string into parts that were initially seperated by comma
+ * @param string the string to break into substrings
 */
 …
 /**
    \brief removes the object from memory
+ *  removes the object from memory
 */
 SubString::~SubString()
 …
 /**
    \brief get a particular substring
    \param i the ID of the substring to return
    \returns the designated substring or NULL if an invalid ID was given
+ *  get a particular substring
+ * @param i the ID of the substring to return
+ * @returns the designated substring or NULL if an invalid ID was given
 */
 const char* SubString::getString( int i)

orxonox/trunk/src/orxonox.cc

-                      r4833
+                      r4836
 /**
    \brief create a new Orxonox
+ *  create a new Orxonox
    In this funcitons only global values are set. The game will not be started here.
 …
 /**
    \brief remove Orxonox from memory
+ *  remove Orxonox from memory
 */
 Orxonox::~Orxonox ()
 …
 /**
  * @brief this is a singleton class to prevent duplicates
+ *  this is a singleton class to prevent duplicates
  */
 Orxonox* Orxonox::singletonRef = NULL;
 /**
  * @brief this finds the config file
+ *  this finds the config file
  * @returns the new config-fileName
  * Since the config file varies from user to user and since one may want to specify different config files
 …
     exit(-1);
+  }
    //! \todo this is a hack and should be loadable
+   //! @todo this is a hack and should be loadable
   ResourceManager::getInstance()->addImageDir(ResourceManager::getInstance()->getFullName("maps/"));
   ResourceManager::getInstance()->debug();
 …
 /**
+ *
+ * @brief starts the orxonox game or menu
+ *  starts the orxonox game or menu
  * here is the central orxonox state manager. There are currently two states
  * - menu
 …
 /**
+ *
  * @brief main function
+ *  main function
+ *
  * here the journey begins

orxonox/trunk/src/orxonox.h

-                      r4830
+                      r4836
 /*!
     \file orxonox.h
     \brief Orxonox core functions
+  *  Orxonox core functions
 */
 …
  public:
   virtual ~Orxonox ();
   /** \returns a Pointer to the only object of this Class */
+  /** @returns a Pointer to the only object of this Class */
   inline static Orxonox* getInstance() { if (!singletonRef) singletonRef = new Orxonox();  return singletonRef; };

orxonox/trunk/src/story_entities/campaign.cc

-                      r4816
+                      r4836
 /**
   \brief loads the Parameters of a Campaign
   \param root: The XML-element to load from
+* @param root: The XML-element to load from
  */
 void Campaign::loadParams(const TiXmlElement* root)
 …
 /**
   \brief loads a WorldList
   \param root: the XML-element to load from
+* @param root: the XML-element to load from
  */
 void Campaign::loadWorldListParams(const TiXmlElement* root)
 …
 /**
     \brief adds an game stroy entity to the campaign
     \param se: The entity
     \param storyID: The number that identifies the entity in the campaign. Each ID only used once in a Campaign
+  *  adds an game stroy entity to the campaign
+  * @param se: The entity
+  * @param storyID: The number that identifies the entity in the campaign. Each ID only used once in a Campaign
     An entity can be a world (playable), a cinematic, a shop, sounds, whatever you
 …
 /*
   \brief lookup a entity with a given id
   \param story id to be lookuped
   \returns the entity found or NULL if search ended without match
+* @param story id to be lookuped
+  @returns the entity found or NULL if search ended without match
 */
 StoryEntity* Campaign::getStoryEntity(int storyID)

orxonox/trunk/src/story_entities/story_entity.cc

-                      r4597
+                      r4836
 /**
     \brief sets the story ID
+  *  sets the story ID
     sets the story id of the current entity, this enables it to be identified in a
 …
 /**
     \brief this reads the story id of the current entity
     \returns the story entity id
+  *  this reads the story id of the current entity
+  * @returns the story entity id
 */
 int StoryEntity::getStoryID()
 …
 /**
     \brief sets the id of the next story entity
+  *  sets the id of the next story entity
     StoryEntities can choose their following entity themselfs. the entity id defined here
 …
 /**
     \brief gets the story id of the current entity
     \returns story id
+  *  gets the story id of the current entity
+  * @returns story id
 */
 int StoryEntity::getNextStoryID()
 …
 /**
    \brief stuff that will have to be initialized before load
+ *  stuff that will have to be initialized before load
    this gives all storyentities the possibility to init stuff before the
 …
 /**
     \brief loads the current entity
+  *  loads the current entity
     this is here to enable you loading maps into the entities. for all other actions you
 …
 /**
     \brief initialize the entity before use.
     \returns an error code if not able to apply.
+  *  initialize the entity before use.
+  * @returns an error code if not able to apply.
     After execution of this function, the Entity is ready to be played/executed,
 …
 /**
     \brief starts the entity with the choosen id. only for entities with lists.
     \param story id
     \returns error code if this action has caused a error
+  *  starts the entity with the choosen id. only for entities with lists.
+  * @param story id
+  * @returns error code if this action has caused a error
     this simply starts the story with the id storyID. the story with the choosen id has
 …
 /**
     \brief starts the current entity
     \returns error code if this action has caused a error
+  *  starts the current entity
+  * @returns error code if this action has caused a error
 */
 ErrorMessage StoryEntity::start()
 …
 /**
     \brief pause the current entity
     \returns error code if this action has caused a error
+  *  pause the current entity
+  * @returns error code if this action has caused a error
     this pauses the current entity or passes this call forth to the running entity.
 …
 /**
     \brief resumes a pause
     \returns error code if this action has caused a error
+  *  resumes a pause
+  * @returns error code if this action has caused a error
     this resumess the current entity or passes this call forth to the running entity.
 …
 /**
     \brief stops the current entity
     \returns error code if this action has caused a error
+  *  stops the current entity
+  * @returns error code if this action has caused a error
     ATTENTION: this function shouldn't call other functions, or if so, they must return
 …
 /**
     \brief destroys and cleans up the current entity.
+  *  destroys and cleans up the current entity.
     this cleans up ressources before the deconstructor is called. for terminating
 …
 /**
     \brief this displays the load screen
+  *  this displays the load screen
     it will need some time to load maps or things like that. to inform the user about
 …
 /**
     \brief undisplay the load screen
+  *  undisplay the load screen
     the load process has terminated, you now can release the load screen and start this

orxonox/trunk/src/story_entities/story_entity.h

r4597	r4836
1	1	/*!
2	2	\file story_entity.h
3		~~\brief~~ holds the base class of everything that is playable - that is part of the story
	3	* holds the base class of everything that is playable - that is part of the story
4	4	*/
5	5

orxonox/trunk/src/story_entities/world.cc

-                      r4834
+                      r4836
 /**
    \brief private constructor because of singleton
+ *  private constructor because of singleton
 */
 WorldInterface::WorldInterface()
 …
 /**
    \brief public deconstructor
+ *  public deconstructor
 */
 WorldInterface::~WorldInterface()
 …
 /**
    \brief gets the singleton instance
    \returns singleton instance
+ *  gets the singleton instance
+ * @returns singleton instance
 */
 WorldInterface* WorldInterface::getInstance()
 …
 /**
    \brief initializes the interface
    \param reference to the world
+ *  initializes the interface
+ * @param reference to the world
    if the worldinterface is not initilizes, there wont be any
 …
 /**
    \brief gets the entity list from the world
    \return entity list
+ *  gets the entity list from the world
+ * @return entity list
 */
 tList<WorldEntity>* WorldInterface::getEntityList()
 …
 /**
     \brief create a new World
+  *  create a new World
     This creates a new empty world!
 …
 /**
    \brief creates a new World...
    \param worldID with this ID
+ *  creates a new World...
+ * @param worldID with this ID
 */
 World::World (int worldID)
 …
 /**
     \brief remove the World from memory
+  *  remove the World from memory
     delete everything explicitly, that isn't contained in the parenting tree!
 …
 /**
    \brief initializes the world.
+ *  initializes the world.
    set all stuff here that is world generic and does not use to much memory
 …
 /**
    \brief this is executed before load
+ *  this is executed before load
    since the load function sometimes needs data, that has been init before
 …
 /**
    \brief loads the World by initializing all resources, and set their default values.
+ *  loads the World by initializing all resources, and set their default values.
 */
 ErrorMessage World::load()
 …
           if( element->Value() != NULL && !strcmp( element->Value(), "Terrain")) terrain = (Terrain*) created;
           element = element->NextSiblingElement();
           glmis->step(); //! \todo temporary
+          glmis->step(); //! @todo temporary
+        }
       PRINTF(4)("Done loading WorldEntities\n");
 …
 /**
    \brief loads the debug world: only for experimental stuff
+ *  loads the debug world: only for experimental stuff
 */
 void World::loadDebugWorld(int worldID)
 …
 /**
    \brief initializes a new World shortly before start
+ *  initializes a new World shortly before start
    this is the function, that will be loaded shortly before the world is
 …
 /**
    \brief starts the World
+ *  starts the World
 */
 ErrorMessage World::start()
 …
 /**
    \brief stops the world.
+ *  stops the world.
    This happens, when the player decides to end the Level.
 …
 /**
    \brief pauses the Game
+ *  pauses the Game
 */
 ErrorMessage World::pause()
 …
 /**
    \brief ends the pause Phase
+ *  ends the pause Phase
 */
 ErrorMessage World::resume()
 …
 /**
    \brief destroys the World
+ *  destroys the World
 */
 ErrorMessage World::destroy()
 …
 /**
    \brief shows the loading screen
+ *  shows the loading screen
 */
 void World::displayLoadScreen ()
 …
 /**
    \brief removes the loadscreen, and changes over to the game
    \todo take out the delay
+ *  removes the loadscreen, and changes over to the game
+   @todo take out the delay
 */
 void World::releaseLoadScreen ()
 …
 /**
    \brief gets the list of entities from the world
    \returns entity list
+ *  gets the list of entities from the world
+ * @returns entity list
 */
 tList<WorldEntity>* World::getEntities()
 …
 /**
    \brief this returns the current game time
    \returns elapsed game time
+ *  this returns the current game time
+ * @returns elapsed game time
 */
 double World::getGameTime()
 …
 /**
     \brief checks for collisions
+  *  checks for collisions
     This method runs through all WorldEntities known to the world and checks for collisions
 …
 /**
     \brief runs through all entities calling their draw() methods
+  *  runs through all entities calling their draw() methods
 */
 void World::draw ()
 …
 /**
    \brief function to put your own debug stuff into it. it can display informations about
+ *  function to put your own debug stuff into it. it can display informations about
    the current class/procedure
 */
 …
   this->lastFrame = SDL_GetTicks ();
   PRINTF(3)("World::mainLoop() - Entering main loop\n");
   while( !this->bQuitOrxonox && !this->bQuitCurrentGame) /* \todo implement pause */
+  while( !this->bQuitOrxonox && !this->bQuitCurrentGame) /* @todo implement pause */
+    {
       ++this->cycle;
 …
       //      for( int i = 0; i < 5000000; i++) {}
       /* \todo this is to slow down the program for openGl Software emulator computers, reimplement*/
+      /* @todo this is to slow down the program for openGl Software emulator computers, reimplement*/
+    }
   PRINTF(3)("World::mainLoop() - Exiting the main loop\n");
 …
 /**
    \brief synchronize local data with remote data
+ *  synchronize local data with remote data
 */
 void World::synchronize ()
 …
 /**
    \brief run all input processing
+ *  run all input processing
    the command node is the central input event dispatcher. the node uses the even-queue from
 …
 /**
    \brief advance the timeline
+ *  advance the timeline
    this calculates the time used to process one frame (with all input handling, drawing, etc)
 …
          but since we like the things not too complicated we got it this way around
          until there is need or time to do it the other way around.
          \todo: GraphicsEngine ticks world: separation of processes and data...
+         @todo: GraphicsEngine ticks world: separation of processes and data...
         bensch: in my opinion the GraphicsEngine could draw the world, but not tick it,
 …
 /**
    \brief this function gives the world a consistant state
+ *  this function gives the world a consistant state
    after ticking (updating the world state) this will give a constistant
 …
 /**
    \brief render the current frame
+ *  render the current frame
    clear all buffers and draw the world
 …
   this->draw();
   // draw HUD
   /* \todo draw HUD */
+  /* @todo draw HUD */
   // flip buffers
   GraphicsEngine::swapBuffers();
 …
 /**
    \brief add and spawn a new entity to this world
    \param entity to be added
+ *  add and spawn a new entity to this world
+ * @param entity to be added
 */
 void World::spawn(WorldEntity* entity)
 …
 /**
    \brief add and spawn a new entity to this world
    \param entity to be added
    \param absCoor At what coordinates to add this entity.
    \param absDir In which direction should it look.
+ *  add and spawn a new entity to this world
+ * @param entity to be added
+ * @param absCoor At what coordinates to add this entity.
+ * @param absDir In which direction should it look.
 */
 void World::spawn(WorldEntity* entity, Vector* absCoor, Quaternion* absDir)
 …
 /**
    \brief add and spawn a new entity to this world
    \param entity to be added
    \param entity to be added to (PNode)
    \param At what relative  coordinates to add this entity.
    \param In which relative direction should it look.
+ *  add and spawn a new entity to this world
+ * @param entity to be added
+ * @param entity to be added to (PNode)
+ * @param At what relative  coordinates to add this entity.
+ * @param In which relative direction should it look.
 */
 void World::spawn(WorldEntity* entity, PNode* parentNode,
 …
 /**
   \brief commands that the world must catch
   \returns false if not used by the world
+  @returns false if not used by the world
 */
 bool World::command(Command* cmd)

orxonox/trunk/src/story_entities/world.h

-                      r4822
+                      r4836
 /*!
     \file world.h
     \brief Holds and manages all game data
+  *  Holds and manages all game data
 */
 …
   PNode* nullParent;                  //!< The zero-point, that everything has as its parent.
   Camera* localCamera;                //!< The current Camera
   WorldEntity* sky;                   //!< The Environmental Heaven of orxonox \todo insert this to environment insted
+  WorldEntity* sky;                   //!< The Environmental Heaven of orxonox @todo insert this to environment insted
   Terrain* terrain;                   //!< The Terrain of the World.
   GLuint objectList;                  //!< temporary: \todo this will be ereased soon
+  GLuint objectList;                  //!< temporary: @todo this will be ereased soon
   tList<WorldEntity>* entities;       //!< A template List of all entities. Every moving thing should be included here, and world automatically updates them.
   Player* localPlayer;                //!< The Player, you fly through the level.

orxonox/trunk/src/subprojects/benchmark.h

r4746	r4836
1	1	/*!
2	2	\file benchmark.h
3		~~\brief~~ benchmark functions
	3	* benchmark functions
4	4	*/
5	5

orxonox/trunk/src/util/animation/animation.cc

-                      r4746
+                      r4836
 /**
    \brief creates a new Animation
+ *  creates a new Animation
    This also adds the Animation automatically to the AnimationPlayer's list
 …
 /**
    \brief destructs the Animation
+ *  destructs the Animation
    this also takes the animation out of the AnimationPlayer's list (if it is there)
 …
 /**
    \brief tells the AnimationPlayer, that we do not wish to  handle this animation
+ *  tells the AnimationPlayer, that we do not wish to  handle this animation
    automatically.
 …
 /**
    \brief Sets the infinitymode
    \param postInfinity How the Animation should advance after the last Keyframe
+ *  Sets the infinitymode
+ * @param postInfinity How the Animation should advance after the last Keyframe
 */
 void Animation::setInfinity(ANIM_INFINITY postInfinity)
 …
 /**
    \brief handles the Animation if it gets out of boundraries eg. if animation is finished.
+ *  handles the Animation if it gets out of boundraries eg. if animation is finished.
 */
 void Animation::handleInfinity()
 …
 /**
    \brief plays the animation back from the current Time forward
+ *  plays the animation back from the current Time forward
 */
 void Animation::play()
 …
 /**
    \brief plays the Next n keyframes
    \param n the Count of keyFrames to play.
+ *  plays the Next n keyframes
+ * @param n the Count of keyFrames to play.
 */
 void Animation::playNextKeyframes(int n)
 …
 /**
    \brief Stops the animation. eg. pause(); rewind();
+ *  Stops the animation. eg. pause(); rewind();
 */
 void Animation::stop()
 …
 /**
    \brief Pauses the animation. Stays at the current Time
+ *  Pauses the animation. Stays at the current Time
 */
 void Animation::pause()
 …
 /**
    \brief replays the animation, eg. rewind();play();
+ *  replays the animation, eg. rewind();play();
 */
 void Animation::replay()

orxonox/trunk/src/util/animation/animation.h

-                      r4746
+                      r4836
 //! An enumerator of Functions to describe the flow of the Animation
 /**
    \todo check with Patrick it of
+   @todo check with Patrick it of
    description in speed to the next keyframe:
 …
   virtual void rewind() = 0;
   /** \brief A virtual function that ticks the animation \param dt the time passed */
+  /** \brief A virtual function that ticks the animation @param dt the time passed */
   virtual void tick(float dt) = 0;
   /** \returns the BaseObject, this animation operates on */
+  /** @returns the BaseObject, this animation operates on */
   BaseObject* getBaseObject() const { return this->baseObject; };
   /** \returns if the Animation should be deleted */
+  /** @returns if the Animation should be deleted */
   inline bool ifDelete() { return bDelete; };
 …
  public:
   inline aTest() { last = 0.0;}
   /** \brief a little debug information to show the results of this class \param f new value */
+  /** \brief a little debug information to show the results of this class @param f new value */
   inline void littleDebug(float f) {  diff = f - last; printf("f=%f, diff=%f\n", f,diff); last = f;}
  private:

orxonox/trunk/src/util/animation/animation3d.cc

-                      r4746
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 Animation3D::Animation3D(PNode* object)
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
    deletes all the Keyframes
 …
 /**
    \brief rewinds the Animation to the beginning (first KeyFrame and time == 0)
+ *  rewinds the Animation to the beginning (first KeyFrame and time == 0)
 */
 void Animation3D::rewind()
 …
 /**
    \brief Appends a new Keyframe
    \param position The position of the new Keyframe
    \param direction The direction of the new Keyframe.
    \param duration The duration from the new KeyFrame to the next one
    \param animFuncMov The function to animate position between this keyFrame and the next one
    \param animFuncRot The function to animate rotation between this keyFrame and the next one
+ *  Appends a new Keyframe
+ * @param position The position of the new Keyframe
+ * @param direction The direction of the new Keyframe.
+ * @param duration The duration from the new KeyFrame to the next one
+ * @param animFuncMov The function to animate position between this keyFrame and the next one
+ * @param animFuncRot The function to animate rotation between this keyFrame and the next one
 */
 void Animation3D::addKeyFrame(Vector position, Quaternion direction, float duration,
 …
 /**
    \brief ticks the Animation
    \param dt how much time to tick
+ *  ticks the Animation
+ * @param dt how much time to tick
 */
 void Animation3D::tick(float dt)
 …
 /**
    \brief Sets The kind of movment Animation between this keyframe and the next one
    \param animFuncMov: The Type of Animation to set
+ *  Sets The kind of movment Animation between this keyframe and the next one
+ * @param animFuncMov: The Type of Animation to set
 */
 void Animation3D::setAnimFuncMov(ANIM_FUNCTION animFuncMov)
 …
 /**
    \brief stays at the value of the currentKeyFrame
    \param timePassed The time passed since this Keyframe began
+ *  stays at the value of the currentKeyFrame
+ * @param timePassed The time passed since this Keyframe began
 */
 void Animation3D::mConstant(float timePassed) const
 …
 /**
    \brief linear interpolation between this keyframe and the next one
    \param timePassed The time passed since this Keyframe began
    \todo implement also do this for direction
+ *  linear interpolation between this keyframe and the next one
+ * @param timePassed The time passed since this Keyframe began
+   @todo implement also do this for direction
 */
 void Animation3D::mLinear(float timePassed) const
 …
 /**
    \brief a Sinusodial Interpolation between this keyframe and the next one
    \param timePassed The time passed since this Keyframe began
    \todo implement
+ *  a Sinusodial Interpolation between this keyframe and the next one
+ * @param timePassed The time passed since this Keyframe began
+   @todo implement
 */
 void Animation3D::mSine(float timePassed) const
 …
 /**
    \brief a cosine interpolation between this keyframe and the next one
    \param timePassed The time passed since this Keyframe began
    \todo implement
+ *  a cosine interpolation between this keyframe and the next one
+ * @param timePassed The time passed since this Keyframe began
+   @todo implement
 */
 void Animation3D::mCosine(float timePassed) const
 …
 /**
    \brief an exponential interpolation between this keyframe and the next one
    \param timePassed The time passed since this Keyframe began
+ *  an exponential interpolation between this keyframe and the next one
+ * @param timePassed The time passed since this Keyframe began
 */
 void Animation3D::mExp(float timePassed) const
 …
 /**
    \brief a negative exponential interpolation between this keyframe and the next one
    \param timePassed The time passed since this Keyframe began
+ *  a negative exponential interpolation between this keyframe and the next one
+ * @param timePassed The time passed since this Keyframe began
 */
 void Animation3D::mNegExp(float timePassed) const
 …
 /**
    \brief a quadratic interpolation between this keyframe and the next one
    \param timePassed The time passed since this Keyframe began
    \todo implement
+ *  a quadratic interpolation between this keyframe and the next one
+ * @param timePassed The time passed since this Keyframe began
+   @todo implement
 */
 void Animation3D::mQuadratic(float timePassed) const
 …
 /**
    \brief some random animation (fluctuating)
    \param timePassed The time passed since this Keyframe began
+ *  some random animation (fluctuating)
+ * @param timePassed The time passed since this Keyframe began
 */
 void Animation3D::mRandom(float timePassed) const
 …
 /**
    \brief Sets The kind of rotation Animation between this keyframe and the next one
    \param animFuncRot: The Type of Animation to set
+ *  Sets The kind of rotation Animation between this keyframe and the next one
+ * @param animFuncRot: The Type of Animation to set
 */
 void Animation3D::setAnimFuncRot(ANIM_FUNCTION animFuncRot)
 …
 /**
    \brief stays at the value of the currentKeyFrame
    \param timePassed The time passed since this Keyframe began
+ *  stays at the value of the currentKeyFrame
+ * @param timePassed The time passed since this Keyframe began
 */
 void Animation3D::rConstant(float timePassed) const
 …
 /**
    \brief linear interpolation between this keyframe and the next one
    \param timePassed The time passed since this Keyframe began
    \todo implement also do this for direction
+ *  linear interpolation between this keyframe and the next one
+ * @param timePassed The time passed since this Keyframe began
+   @todo implement also do this for direction
 */
 void Animation3D::rLinear(float timePassed) const
 …
 /**
    \brief a Sinusodial Interpolation between this keyframe and the next one
    \param timePassed The time passed since this Keyframe began
    \todo implement
+ *  a Sinusodial Interpolation between this keyframe and the next one
+ * @param timePassed The time passed since this Keyframe began
+   @todo implement
 */
 void Animation3D::rSine(float timePassed) const
 …
 /**
    \brief a cosine interpolation between this keyframe and the next one
    \param timePassed The time passed since this Keyframe began
    \todo implement
+ *  a cosine interpolation between this keyframe and the next one
+ * @param timePassed The time passed since this Keyframe began
+   @todo implement
 */
 void Animation3D::rCosine(float timePassed) const
 …
 /**
    \brief an exponential interpolation between this keyframe and the next one
    \param timePassed The time passed since this Keyframe began
+ *  an exponential interpolation between this keyframe and the next one
+ * @param timePassed The time passed since this Keyframe began
 */
 void Animation3D::rExp(float timePassed) const
 …
 /**
    \brief a negative exponential interpolation between this keyframe and the next one
    \param timePassed The time passed since this Keyframe began
+ *  a negative exponential interpolation between this keyframe and the next one
+ * @param timePassed The time passed since this Keyframe began
 */
 void Animation3D::rNegExp(float timePassed) const
 …
 /**
    \brief a quadratic interpolation between this keyframe and the next one
    \param timePassed The time passed since this Keyframe began
    \todo implement
+ *  a quadratic interpolation between this keyframe and the next one
+ * @param timePassed The time passed since this Keyframe began
+   @todo implement
 */
 void Animation3D::rQuadratic(float timePassed) const
 …
 /**
    \brief some random animation (fluctuating)
    \param timePassed The time passed since this Keyframe began
+ *  some random animation (fluctuating)
+ * @param timePassed The time passed since this Keyframe began
 */
 void Animation3D::rRandom(float timePassed) const

orxonox/trunk/src/util/animation/animation_player.cc

-                      r4746
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 AnimationPlayer::AnimationPlayer ()
 …
 /**
    \brief the singleton reference to this class
+ *  the singleton reference to this class
 */
 AnimationPlayer* AnimationPlayer::singletonRef = NULL;
 /**
    \brief standard deconstructor
+ *  standard deconstructor
    !! DANGER !! when unloading the AnimationPlayer no other Function
 …
 /**
    \brief adds an Animation to the AnimationList.
    \param animation the Animation to handle
+ *  adds an Animation to the AnimationList.
+ * @param animation the Animation to handle
    when adding a Animation the Animation will too be deleted when
 …
 /**
    \brief removes an Animation from the Animation List, WITHOUT deleting it.
    \param animation the Anmination to remove from the List
+ *  removes an Animation from the Animation List, WITHOUT deleting it.
+ * @param animation the Anmination to remove from the List
 */
 void AnimationPlayer::removeAnimation(Animation* animation)
 …
 /**
    \brief empties the list AND deletes all the Animations
+ *  empties the list AND deletes all the Animations
 */
 void AnimationPlayer::flush()
 …
 /**
    \brief Ticks all the animations in animationList
    \param timePassed the time passed since the last tick.
+ *  Ticks all the animations in animationList
+ * @param timePassed the time passed since the last tick.
 */
 void AnimationPlayer::tick(float timePassed)
 …
+}
 /**
    \brief starts playing the AnimationPlayer
+ *  starts playing the AnimationPlayer
 */
 void AnimationPlayer::play()
 …
 /**
    \brief pauses playing of the AnimationPlayer
+ *  pauses playing of the AnimationPlayer
 */
 void AnimationPlayer::pause()
 …
 /**
    \returns the animation from a certain baseobject
+ * @returns the animation from a certain baseobject
    if multiple are found, it just retruns the first one
    if none is found it returns NULL
 …
 /**
    \brief Outputs some nice debug-information
+ *  Outputs some nice debug-information
 */
 void AnimationPlayer::debug()

orxonox/trunk/src/util/animation/animation_player.h

r4746	r4836
29	29
30	30	public:
31		/** \returns a Pointer to the only object of this Class */
	31	/** @returns a Pointer to the only object of this Class */
32	32	inline static AnimationPlayer* getInstance() { if (!singletonRef) singletonRef = new AnimationPlayer(); return singletonRef; };
33	33

orxonox/trunk/src/util/animation/t_animation.h

-                      r4746
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 template<class T>
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
    deletes all the Keyframes
 …
 /**
    \brief rewinds the Animation to the beginning (first KeyFrame and time == 0)
+ *  rewinds the Animation to the beginning (first KeyFrame and time == 0)
 */
 template<class T>
 …
 /**
    \brief sets the Function we want to animate
    \param object from what object do we want to animate
    \param funcToAnim which function
+ *  sets the Function we want to animate
+ * @param object from what object do we want to animate
+ * @param funcToAnim which function
 */
 template<class T>
 …
 /**
    \brief Appends a new Keyframe
    \param value the value of the new KeyFrame
    \param duration The duration from the new KeyFrame to the next one
    \param animFunc The function to animate between this keyFrame and the next one
+ *  Appends a new Keyframe
+ * @param value the value of the new KeyFrame
+ * @param duration The duration from the new KeyFrame to the next one
+ * @param animFunc The function to animate between this keyFrame and the next one
 */
 template<class T>
 …
 /**
    \brief ticks the Animation
    \param dt how much time to tick
+ *  ticks the Animation
+ * @param dt how much time to tick
 */
 template<class T>
 …
 /**
    \brief Sets The kind of Animation between this keyframe and the next one
    \param animFunc The Type of Animation to set
+ *  Sets The kind of Animation between this keyframe and the next one
+ * @param animFunc The Type of Animation to set
 */
 template<class T>
 …
 // animation functions
 /**
    \brief stays at the value of the currentKeyFrame
    \param timePassed The time passed since this Keyframe began
+ *  stays at the value of the currentKeyFrame
+ * @param timePassed The time passed since this Keyframe began
 */
 template<class T>
 …
 /**
    \brief linear interpolation between this keyframe and the next one
    \param timePassed The time passed since this Keyframe began
+ *  linear interpolation between this keyframe and the next one
+ * @param timePassed The time passed since this Keyframe began
 */
 template<class T>
 …
 /**
    \brief a Sinusodial Interpolation between this keyframe and the next one
    \param timePassed The time passed since this Keyframe began
+ *  a Sinusodial Interpolation between this keyframe and the next one
+ * @param timePassed The time passed since this Keyframe began
 */
 template<class T>
 …
 /**
    \brief a cosine interpolation between this keyframe and the next one
    \param timePassed The time passed since this Keyframe began
+ *  a cosine interpolation between this keyframe and the next one
+ * @param timePassed The time passed since this Keyframe began
 */
 template<class T>
 …
 /**
    \brief an exponential interpolation between this keyframe and the next one
    \param timePassed The time passed since this Keyframe began
+ *  an exponential interpolation between this keyframe and the next one
+ * @param timePassed The time passed since this Keyframe began
 */
 template<class T>
 …
 /**
    \brief a negative exponential interpolation between this keyframe and the next one
    \param timePassed The time passed since this Keyframe began
+ *  a negative exponential interpolation between this keyframe and the next one
+ * @param timePassed The time passed since this Keyframe began
 */
 template<class T>
 …
 /**
    \brief a quadratic interpolation between this keyframe and the next one
    \param timePassed The time passed since this Keyframe began
+ *  a quadratic interpolation between this keyframe and the next one
+ * @param timePassed The time passed since this Keyframe began
 */
 template<class T>
 …
 /**
    \brief some random animation (fluctuating)
    \param timePassed The time passed since this Keyframe began
+ *  some random animation (fluctuating)
+ * @param timePassed The time passed since this Keyframe began
 */
 template<class T>

orxonox/trunk/src/util/garbage_collector.cc

-                      r4652
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 GarbageCollector::GarbageCollector ()
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 GarbageCollector::~GarbageCollector ()
 …
 /**
    \brief this sets the collection delay
    \param delay: the delay
+ *  this sets the collection delay
+ * @param delay: the delay
    after this delay, the garbage collector starts its work and begins to collect unused object
 …
 /**
    \brief this foreces a garbage collection
+ *  this foreces a garbage collection
    if this function is called, the gc tries to initiate the garbage collection routines. actually
 …
 /**
    \brief this ticks the GarbageCollector to give it the time pulse
    \param time: the time passed since last tick
+ *  this ticks the GarbageCollector to give it the time pulse
+ * @param time: the time passed since last tick
    like every other tick function eg. worldentity
 …
 /**
    \brief this updated the gargabe collection, if the time is ready
+ *  this updated the gargabe collection, if the time is ready
 */
 void GarbageCollector::update()

orxonox/trunk/src/util/garbage_collector.h

-                      r4746
+                      r4836
 /*!
+/*!
     \file garbage_collector.h
     \brief Definition of the proto class template, used quickly start work
     \todo Example: this shows how to use simply add a Marker that here has to be done something.
+  *  Definition of the proto class template, used quickly start work
+    @todo Example: this shows how to use simply add a Marker that here has to be done something.
     The Protoclass exists, to help you quikly getting the run for how to develop in orxonox.
 …
 //! this class maintains the garbage collection.
 /**
    the class is been ticked by the world.cc and goes through the
+   the class is been ticked by the world.cc and goes through the
    world_entity list to clean out all unused entities.
 */
 …
  public:
   virtual ~GarbageCollector();
   /** \returns a Pointer to the only object of this Class */
+  /** @returns a Pointer to the only object of this Class */
   inline static GarbageCollector* getInstance() { if (!singletonRef) singletonRef = new GarbageCollector();  return singletonRef; };

orxonox/trunk/src/util/loading/factory.cc

-                      r4739
+                      r4836
 /**
    \brief constructor
+ *  constructor
    set everything to zero and define factoryName
 …
 /**
    \brief destructor
+ *  destructor
    clear the Q
 …
 /**
    \brief add a Factory to the Factory Queue
    \param factory a Factory to be registered
+ *  add a Factory to the Factory Queue
+ * @param factory a Factory to be registered
 */
 void Factory::registerFactory( Factory* factory)

orxonox/trunk/src/util/loading/factory.h

-                      r4746
+                      r4836
     Creates a factory to a Loadable Class.
     this should be used at the beginning of all the Classes that should be loadable (in the cc-file)
   \todo make factoryName a BaseObject-parameter. (else it would be redundant)
+  @todo make factoryName a BaseObject-parameter. (else it would be redundant)
 */
 #define CREATE_FACTORY(CLASS_NAME) tFactory<CLASS_NAME>* global_##CLASS_NAME##_Factory = new tFactory<CLASS_NAME>(#CLASS_NAME)
 …
   static void registerFactory( Factory* factory);
   /** \brief sets the Next factory in the list \param nextFactory the next factory */
+  /** \brief sets the Next factory in the list @param nextFactory the next factory */
   inline void setNext( Factory* nextFactory) { this->next = nextFactory; };
   /** \returns the first factory */
+  /** @returns the first factory */
   static Factory* getFirst() { return Factory::first; };
   /** \returns the next factory */
+  /** @returns the next factory */
   Factory* getNext() const { return this->next; };
 …
 /**
    \brief a factory that is able to load any kind of Object
+ *  a factory that is able to load any kind of Object
    (this is a Functor)
 */
 …
 /**
    \brief construnts a factory with
    \param factoryName the name of the factory
+ *  construnts a factory with
+ * @param factoryName the name of the factory
 */
 template<class T>

orxonox/trunk/src/util/loading/game_loader.cc

-                      r4817
+                      r4836
 /**
    \brief simple constructor
+ *  simple constructor
 */
 GameLoader::GameLoader ()
 …
 /**
    \brief simple deconstructor
+ *  simple deconstructor
 */
 GameLoader::~GameLoader ()
 …
 /**
    \brief this class is a singleton class
    \returns an instance of itself
+ *  this class is a singleton class
+ * @returns an instance of itself
    if you are unsure about singleton classes, check the theory out on the internet :)
 …
 /**
    \brief initializes the GameLoader
+ *  initializes the GameLoader
 */
 ErrorMessage GameLoader::init()
 …
 /**
    \brief reads a campaign definition file into a campaign class
    \param fileName to be loaded
    \returns the loaded campaign
+ *  reads a campaign definition file into a campaign class
+ * @param fileName to be loaded
+ * @returns the loaded campaign
    this will interprete the map/campaign files and recursivly load a tree of worlds/campaigns
 …
 /**
    \brief loads a debug campaign for test purposes only.
    \param campaignID the identifier of the campaign.
    \returns error message if not able to do so.
+ *  loads a debug campaign for test purposes only.
+ * @param campaignID the identifier of the campaign.
+ * @returns error message if not able to do so.
 */
 ErrorMessage GameLoader::loadDebugCampaign(Uint32 campaignID)
 …
 /**
     \brief starts the current entity
     \returns error code if this action has caused a error
+  *  starts the current entity
+  * @returns error code if this action has caused a error
 */
 ErrorMessage GameLoader::start()
 …
 /**
     \brief stops the current entity
     \returns error code if this action has caused a error
+  *  stops the current entity
+  * @returns error code if this action has caused a error
     ATTENTION: this function shouldn't call other functions, or if so, they must return
 …
 /**
     \brief pause the current entity
     \returns error code if this action has caused a error
+  *  pause the current entity
+  * @returns error code if this action has caused a error
     this pauses the current entity or passes this call forth to the running entity.
 …
 /**
     \brief resumes a pause
     \returns error code if this action has caused a error
+  *  resumes a pause
+  * @returns error code if this action has caused a error
     this resumess the current entity or passes this call forth to the running entity.
 …
 /**
    \brief release the mem ATTENTION: not implemented
+ *  release the mem ATTENTION: not implemented
  */
 ErrorMessage GameLoader::destroy()
 …
 /**
    \brief reads a campaign definition file into a campaign class
    \param fileName to be loaded
    \returns the loaded campaign
+ *  reads a campaign definition file into a campaign class
+ * @param fileName to be loaded
+ * @returns the loaded campaign
    this will interprete the map/campaign files and recursivly load a tree of worlds/campaigns
 …
 /**
    \brief handle keyboard commands
    \param event the event to handle
+ *  handle keyboard commands
+ * @param event the event to handle
 */
 void GameLoader::process(const Event& event)
 …
 /**
    \brief load a StoryEntity
    \param element a XMLElement containing all the needed info
+ *  load a StoryEntity
+ * @param element a XMLElement containing all the needed info
 */
 BaseObject* GameLoader::fabricate(const TiXmlElement* element)

orxonox/trunk/src/util/loading/game_loader.h

-                      r4739
+                      r4836
 /*!
     \file game_loader.h
     \brief loads campaigns, worlds and all other story_entities
+  *  loads campaigns, worlds and all other story_entities
 */
 …
   void previousLevel();
   /** \brief a world command to send to the GameLoader \param cmd the command */
+  /** \brief a world command to send to the GameLoader @param cmd the command */
   bool worldCommand(Command* cmd);
   ErrorMessage loadDebugCampaign(Uint32 campaignID);

orxonox/trunk/src/util/loading/load_param.cc

-                      r4746
+                      r4836
 /**
    \param object The object this Parameter is loaded too.
    \param root: the XML-element to load this option from.
    \param paramName: The name of the parameter loaded.
    \param paramCount: how many parameters this loading-function takes
    \param multi: if false LoadParam assumes only one occurence of this parameter in root, if true it assumes multiple occurences.
    \param ...: the parameter information (1. Parameter, 2. Default Value for the Parameter, ...)
+ * @param object The object this Parameter is loaded too.
+ * @param root: the XML-element to load this option from.
+ * @param paramName: The name of the parameter loaded.
+ * @param paramCount: how many parameters this loading-function takes
+ * @param multi: if false LoadParam assumes only one occurence of this parameter in root, if true it assumes multiple occurences.
+ * @param ...: the parameter information (1. Parameter, 2. Default Value for the Parameter, ...)
 */
 BaseLoadParam::BaseLoadParam(const TiXmlElement* root, BaseObject* object, const char* paramName,
 …
 /**
    \param descriptionText The text to set as a description for this Parameter
    \returns a pointer to itself.
+ * @param descriptionText The text to set as a description for this Parameter
+ * @returns a pointer to itself.
 */
 BaseLoadParam* BaseLoadParam::describe(const char* descriptionText)
 …
 /**
    \param paramName the name of the parameter to load
+ * @param paramName the name of the parameter to load
 */
 LoadParamDescription::LoadParamDescription(const char* paramName)
 …
 /**
    \brief removes all the alocated memory
+ *  removes all the alocated memory
 */
 LoadParamDescription::~LoadParamDescription()
 …
 /**
    \param descriptionText The text to set as a description for this Parameter
+ * @param descriptionText The text to set as a description for this Parameter
 */
 void LoadParamDescription::setDescription(const char* descriptionText)
 …
 /**
    \brief prints out this parameter, its input method and the description (if availiable)
+ *  prints out this parameter, its input method and the description (if availiable)
 */
 void LoadParamDescription::print() const
 …
 /**
    \brief A list, that holds all the classes that are loadable (classes not objects!!)
+ *  A list, that holds all the classes that are loadable (classes not objects!!)
 */
 tList<LoadClassDescription>* LoadClassDescription::classList = new tList<LoadClassDescription>;
 /**
    \brief if the description of Parameters should be executed
+ *  if the description of Parameters should be executed
 */
 bool LoadClassDescription::parametersDescription = true;
 /**
    \param className the name of the class to be loadable
+ * @param className the name of the class to be loadable
 */
 LoadClassDescription::LoadClassDescription(const char* className)
 …
 /**
    \brief deletes a classDescription (deletes all the parameterDescriptions as well
+ *  deletes a classDescription (deletes all the parameterDescriptions as well
 */
 LoadClassDescription::~LoadClassDescription()
 …
 /**
    \brief adds a class to the list of loadable classes
    \param className The name of the class to add
+ *  adds a class to the list of loadable classes
+ * @param className The name of the class to add
    this function searches for the className string, and if found just returns the appropriate Class.
 …
 /**
    \brief does the same as addClass(const char* className), but with params
    \param paramName the name of the parameter to add.
+ *  does the same as addClass(const char* className), but with params
+ * @param paramName the name of the parameter to add.
 */
 LoadParamDescription* LoadClassDescription::addParam(const char* paramName)
 …
 /**
    \brief prints out all loadable Classes, and their parameters
+ *  prints out all loadable Classes, and their parameters
 */
 void LoadClassDescription::printAll(const char* fileName)
 …
 /**
    \param root: The XML-element to grab a parameter from
    \param parameterName: the parameter to grab
    \returns the Value of the parameter if found, NULL otherwise
+ * @param root: The XML-element to grab a parameter from
+ * @param parameterName: the parameter to grab
+ * @returns the Value of the parameter if found, NULL otherwise
 */
 const char* grabParameter(const TiXmlElement* root, const char* parameterName)

orxonox/trunk/src/util/loading/load_param.h

-                      r4834
+                      r4836
 /*!
     \file load_param.h
     \brief A Class and macro-functions, that makes our lives easy to load-in parameters
+  *  A Class and macro-functions, that makes our lives easy to load-in parameters
 */
 …
 // 1. TYPE
 /**
    \brief a Macro to easily implement many different Constructors for the LoadParam-Class with 1 argument
    \param type1 The type of the first functionParameter
+ *  a Macro to easily implement many different Constructors for the LoadParam-Class with 1 argument
+ * @param type1 The type of the first functionParameter
 */
 #define LoadParam1(type1) \
 …
 // 2. TYPES
 /**
    \brief a Macro to easily implement many different Constructors for the LoadParam-Class with 2 arguments
    \param type1 The type of the first functionParameter
    \param type2 The type of the second functionParameter
+ *  a Macro to easily implement many different Constructors for the LoadParam-Class with 2 arguments
+ * @param type1 The type of the first functionParameter
+ * @param type2 The type of the second functionParameter
 */
 #define LoadParam2(type1, type2) \
 …
 // 3. TYPES
 /**
    \brief a Macro to easily implement many different Constructors for the LoadParam-Class with 3 arguments
    \param type1 The type of the first functionParameter
    \param type2 The type of the second functionParameter
    \param type3 The type of the third functionParameter
+ *  a Macro to easily implement many different Constructors for the LoadParam-Class with 3 arguments
+ * @param type1 The type of the first functionParameter
+ * @param type2 The type of the second functionParameter
+ * @param type3 The type of the third functionParameter
 */
 #define LoadParam3(type1, type2, type3) \
 …
 // 4. TYPES
 /**
    \brief a Macro to easily implement many different Constructors for the LoadParam-Class with 4 arguments
    \param type1 The type of the first functionParameter
    \param type2 The type of the second functionParameter
    \param type3 The type of the third functionParameter
    \param type4 The type of the forth functionParameter
+ *  a Macro to easily implement many different Constructors for the LoadParam-Class with 4 arguments
+ * @param type1 The type of the first functionParameter
+ * @param type2 The type of the second functionParameter
+ * @param type3 The type of the third functionParameter
+ * @param type4 The type of the forth functionParameter
 */
 #define LoadParam4(type1, type2, type3, type4) \
 …
 // 5. TYPES
 /**
    \brief a Macro to easily implement many different Constructors for the LoadParam-Class with 5 arguments
    \param type1 The type of the first functionParameter
    \param type2 The type of the second functionParameter
    \param type3 The type of the third functionParameter
    \param type4 The type of the forth functionParameter
    \param type5 The type of the fifth functionParameter
+ *  a Macro to easily implement many different Constructors for the LoadParam-Class with 5 arguments
+ * @param type1 The type of the first functionParameter
+ * @param type2 The type of the second functionParameter
+ * @param type3 The type of the third functionParameter
+ * @param type4 The type of the forth functionParameter
+ * @param type5 The type of the fifth functionParameter
 */
 #define LoadParam5(type1, type2, type3, type4, type5) \
 …
 // Pointer TYPE
 /**
    \brief a Macro to easily implement many different Constructors for the LoadParam-Class with one Pointer argument
    \param type1 The type of the Pointer
+ *  a Macro to easily implement many different Constructors for the LoadParam-Class with one Pointer argument
+ * @param type1 The type of the Pointer
  */
 #define LoadParamPT(type1) \
 …
   void setDescription(const char* descriptionText);
   /** \returns the descriptionString */
+  /** @returns the descriptionString */
   const char* getDescription() { return this->description; };

orxonox/trunk/src/util/object_manager.cc

-                      r4746
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 ObjectManager::ObjectManager ()
 …
 /**
    \brief the singleton reference to this class
+ *  the singleton reference to this class
 */
 ObjectManager* ObjectManager::singletonRef = NULL;
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 ObjectManager::~ObjectManager ()
 …
 /**
    \brief adds an element to the list of dead objects
    \param index: The type of object to add
    \param object: pointer to the object at hand
+ *  adds an element to the list of dead objects
+ * @param index: The type of object to add
+ * @param object: pointer to the object at hand
 */
 void ObjectManager::addToDeadList(int index, BaseObject* object)
 …
 /**
    \brief resurects an object
    \param index: the type of resource to load
    \param number: how many of them
+ *  resurects an object
+ * @param index: the type of resource to load
+ * @param number: how many of them
    \todo if it is unable to get an object from the deadList, it should create it
+   @todo if it is unable to get an object from the deadList, it should create it
 */
 BaseObject* ObjectManager::getFromDeadList(int index, int number)
 …
 /**
    \brief outputs some simple debug information about the ObjectManage
+ *  outputs some simple debug information about the ObjectManage
 */
 void ObjectManager::debug() const

orxonox/trunk/src/util/object_manager.h

-                      r4746
+                      r4836
 /*!
     \file object_manager.h
     \brief this manager will ceep track of the objects  in the world
+  *  this manager will ceep track of the objects  in the world
     This is specially designed to:
 …
  public:
   virtual ~ObjectManager();
   /** \returns a Pointer to the only object of this Class */
+  /** @returns a Pointer to the only object of this Class */
   inline static ObjectManager* getInstance() { if (!singletonRef) singletonRef = new ObjectManager();  return singletonRef; };

orxonox/trunk/src/util/resource_manager.cc

-                      r4746
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 ResourceManager::ResourceManager ()
 …
 /**
    \brief standard destructor
+ *  standard destructor
 */
 ResourceManager::~ResourceManager ()
 …
 /**
    \brief sets the data main directory
    \param dataDir the DataDirectory.
+ *  sets the data main directory
+ * @param dataDir the DataDirectory.
 */
 bool ResourceManager::setDataDir(const char* dataDir)
 …
 /**
    \brief checks for the DataDirectory, by looking if
    \param fileInside is inisde??
+ *  checks for the DataDirectory, by looking if
+ * @param fileInside is inisde??
 */
 bool ResourceManager::checkDataDir(const char* fileInside)
 …
 #ifndef NO_TEXTURES
 /**
    \brief adds a new Path for Images
    \param imageDir The path to insert
    \returns true, if the Path was well and injected (or already existent within the list)
+ *  adds a new Path for Images
+ * @param imageDir The path to insert
+ * @returns true, if the Path was well and injected (or already existent within the list)
    false otherwise
 */
 …
 /**
    \brief loads resources
    \param fileName: The fileName of the resource to load
    \param prio: The ResourcePriority of this resource (will only be increased)
    \param param1: an additional option to parse (see the constuctors for more help)
    \param param2: an additional option to parse (see the constuctors for more help)
    \param param3: an additional option to parse (see the constuctors for more help)
    \returns a pointer to a desired Resource.
+ *  loads resources
+ * @param fileName: The fileName of the resource to load
+ * @param prio: The ResourcePriority of this resource (will only be increased)
+ * @param param1: an additional option to parse (see the constuctors for more help)
+ * @param param2: an additional option to parse (see the constuctors for more help)
+ * @param param3: an additional option to parse (see the constuctors for more help)
+ * @returns a pointer to a desired Resource.
 */
 void* ResourceManager::load(const char* fileName, ResourcePriority prio, void* param1, void* param2, void* param3)
 …
 /**
    \brief loads resources
    \param fileName: The fileName of the resource to load
    \param type: The Type of Resource to load (\see ResourceType)
    \param prio: The ResourcePriority of this resource (will only be increased)
    \param param1: an additional option to parse (see the constuctors for more help)
    \param param2: an additional option to parse (see the constuctors for more help)
    \param param3: an additional option to parse (see the constuctors for more help)
    \returns a pointer to a desired Resource.
+ *  loads resources
+ * @param fileName: The fileName of the resource to load
+ * @param type: The Type of Resource to load (\see ResourceType)
+ * @param prio: The ResourcePriority of this resource (will only be increased)
+ * @param param1: an additional option to parse (see the constuctors for more help)
+ * @param param2: an additional option to parse (see the constuctors for more help)
+ * @param param3: an additional option to parse (see the constuctors for more help)
+ * @returns a pointer to a desired Resource.
 */
 void* ResourceManager::load(const char* fileName, ResourceType type, ResourcePriority prio,
 …
 /**
    \brief unloads a Resource
    \param pointer: The pointer to free
    \param prio: the PriorityLevel to unload this resource
    \returns true if successful (pointer found, and deleted), false otherwise
+ *  unloads a Resource
+ * @param pointer: The pointer to free
+ * @param prio: the PriorityLevel to unload this resource
+ * @returns true if successful (pointer found, and deleted), false otherwise
 */
 bool ResourceManager::unload(void* pointer, ResourcePriority prio)
 …
 /**
    \brief unloads a Resource
    \param resource: The resource to unloade
    \param prio the PriorityLevel to unload this resource
+ *  unloads a Resource
+ * @param resource: The resource to unloade
+ * @param prio the PriorityLevel to unload this resource
 */
 bool ResourceManager::unload(Resource* resource, ResourcePriority prio)
 …
 /**
    \brief unloads all alocated Memory of Resources with a pririty lower than prio
    \param prio The priority to delete
+ *  unloads all alocated Memory of Resources with a pririty lower than prio
+ * @param prio The priority to delete
 */
 bool ResourceManager::unloadAllByPriority(ResourcePriority prio)
 …
 /**
    \brief Searches for a Resource by some information
    \param fileName: The name to look for
    \param type the Type of resource to locate.
    \param param1: an additional option to parse (see the constuctors for more help)
    \param param2: an additional option to parse (see the constuctors for more help)
    \param param3: an additional option to parse (see the constuctors for more help)
    \returns a Pointer to the Resource if found, NULL otherwise.
+ *  Searches for a Resource by some information
+ * @param fileName: The name to look for
+ * @param type the Type of resource to locate.
+ * @param param1: an additional option to parse (see the constuctors for more help)
+ * @param param2: an additional option to parse (see the constuctors for more help)
+ * @param param3: an additional option to parse (see the constuctors for more help)
+ * @returns a Pointer to the Resource if found, NULL otherwise.
 */
 Resource* ResourceManager::locateResourceByInfo(const char* fileName, ResourceType type,
 …
 /**
    \brief Searches for a Resource by Pointer
    \param pointer the Pointer to search for
    \returns a Pointer to the Resource if found, NULL otherwise.
+ *  Searches for a Resource by Pointer
+ * @param pointer the Pointer to search for
+ * @returns a Pointer to the Resource if found, NULL otherwise.
 */
 Resource* ResourceManager::locateResourceByPointer(const void* pointer)
 …
 /**
    \brief Checks if it is a Directory
    \param directoryName the Directory to check for
    \returns true if it is a directory/symlink false otherwise
+ *  Checks if it is a Directory
+ * @param directoryName the Directory to check for
+ * @returns true if it is a directory/symlink false otherwise
 */
 bool ResourceManager::isDir(const char* directoryName)
 …
 /**
    \brief Checks if the file is either a Regular file or a Symlink
    \param fileName the File to check for
    \returns true if it is a regular file/symlink, false otherwise
+ *  Checks if the file is either a Regular file or a Symlink
+ * @param fileName the File to check for
+ * @returns true if it is a regular file/symlink, false otherwise
 */
 bool ResourceManager::isFile(const char* fileName)
 …
 /**
    \brief touches a File on the disk (thereby creating it)
    \param fileName The file to touch
+ *  touches a File on the disk (thereby creating it)
+ * @param fileName The file to touch
 */
 bool ResourceManager::touchFile(const char* fileName)
 …
 /**
    \brief deletes a File from disk
    \param fileName the File to delete
+ *  deletes a File from disk
+ * @param fileName the File to delete
 */
 bool ResourceManager::deleteFile(const char* fileName)
 …
 /**
     \param name the Name of the file to check
     \returns The name of the file, including the HomeDir
+  * @param name the Name of the file to check
+  * @returns The name of the file, including the HomeDir
     IMPORTANT: this has to be deleted from the outside
 */
 …
 /**
     \param fileName the Name of the File to check
     \returns The full name of the file, including the DataDir, and NULL if the file does not exist
+  * @param fileName the Name of the File to check
+  * @returns The full name of the file, including the DataDir, and NULL if the file does not exist
     IMPORTANT: this has to be deleted from the outside
 */
 …
 /**
    \brief outputs debug information about the ResourceManager
+ *  outputs debug information about the ResourceManager
 */
 void ResourceManager::debug() const

orxonox/trunk/src/util/resource_manager.h

-                      r4746
+                      r4836
 /*!
     \file resource_manager.h
     \brief The Resource Manager checks if a file/resource is loaded.
+  *  The Resource Manager checks if a file/resource is loaded.
     If a file/resource was already loaded the resourceManager will
 …
  public:
   virtual ~ResourceManager();
   /** \returns a Pointer to the only object of this Class */
+  /** @returns a Pointer to the only object of this Class */
   inline static ResourceManager* getInstance() { if (!singletonRef) singletonRef = new ResourceManager();  return singletonRef; };
   bool setDataDir(const char* dataDir);
   /** \returns the Name of the data directory */
+  /** @returns the Name of the data directory */
   inline const char* getDataDir() const {return this->dataDir;}

orxonox/trunk/src/util/state.cc

r4827	r4836
32	32
33	33	/**
34		~~\brief~~ sets camera and target of the current Camera
	34	* sets camera and target of the current Camera
35	35	*/
36	36	void State::setCamera(const PNode* camera, const PNode* cameraTarget)

orxonox/trunk/src/util/state.h

r4827	r4836
1	1	/*!
2	2	\file state.h
3		~~\brief~~ Definition of the States-singleton Class
	3	* Definition of the States-singleton Class
4	4	*/
5	5

orxonox/trunk/src/util/track/pilot_node.cc

-                      r4597
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 PilotNode::PilotNode ()
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 PilotNode::~PilotNode ()
 …
 /**
     \brief ticks the node
     \param time the time about whitch to tick                                           \
+  *  ticks the node
+  * @param time the time about whitch to tick                                           \
 */
 void PilotNode::tick(float time)
 …
 /**
    \brief action if player moves
    \param time the timeslice since the last frame
+ *  action if player moves
+ * @param time the timeslice since the last frame
 */
 void PilotNode::move (float time)
 …
 /**
    \brief handles events
    \param event the event that occured
+ *  handles events
+ * @param event the event that occured
 */
 void PilotNode::process( const Event &event)

orxonox/trunk/src/util/track/pilot_node.h

r4597	r4836
1	1	/*!
2	2	\file pilot_node.h
3		~~\brief~~ Definition of a PilotNode
	3	* Definition of a PilotNode
4	4	*/
5	5

orxonox/trunk/src/util/track/track_manager.cc

-                      r4834
+                      r4836
 /**
    \brief initializes a TrackElement (sets the default values)
+ *  initializes a TrackElement (sets the default values)
 */
 TrackElement::TrackElement()
 …
 /**
     \brief destroys all alocated memory)
     \todo eventually when deleting a TrackElement you would not like to delete all its preceding TrackElements
+  *  destroys all alocated memory)
+    @todo eventually when deleting a TrackElement you would not like to delete all its preceding TrackElements
 */
 TrackElement::~TrackElement()
 …
 /**
    \brief Searches through all the TrackElements for trackID.
    \param trackID The ID to search for.
    \returns The TrackElement if Found, NULL otherwise.
+ *  Searches through all the TrackElements for trackID.
+ * @param trackID The ID to search for.
+ * @returns The TrackElement if Found, NULL otherwise.
 */
 TrackElement* TrackElement::findByID(unsigned int trackID)
 …
 /**
    \brief Searches through all the TrackElements for a trackName
    \param trackName The name to search for.
    \returns The TrackElement if Found, NULL otherwise.
+ *  Searches through all the TrackElements for a trackName
+ * @param trackName The name to search for.
+ * @returns The TrackElement if Found, NULL otherwise.
 */
 TrackElement* TrackElement::findByName(const char* trackName)
 …
 /**
    \brief checks if there are any BackLoops in the Track
    \returns true if NO loop was found, false Otherwise
+ *  checks if there are any BackLoops in the Track
+ * @returns true if NO loop was found, false Otherwise
    You actually have to act on false!!
 */
 …
 /**
    \brief checks if there are any BackLoops in the Track.
    \param trackList A list of stored tracks, to search in.
    \returns true if NO loop was found, false Otherwise
+ *  checks if there are any BackLoops in the Track.
+ * @param trackList A list of stored tracks, to search in.
+ * @returns true if NO loop was found, false Otherwise
    You actually have to act on false!!
 */
 …
 /**
    \param childCount which child to return
    \returns the n-the children (starting at 0).
+ * @param childCount which child to return
+ * @returns the n-the children (starting at 0).
    Be aware, that when the trackElement has no Children, NULL will be returned
 */
 …
 /**
    \brief prints out debug information about this TrackElement
+ *  prints out debug information about this TrackElement
 */
 void TrackElement::debug() const
 …
 /**
    \brief CONDITION that chooses the first child for the decision (static)
    \param nothing Nothing in this function
    \returns the chosen child
+ *  CONDITION that chooses the first child for the decision (static)
+ * @param nothing Nothing in this function
+ * @returns the chosen child
 */
 int TrackElement::lowest(const void* nothing) const
 …
 /**
    \brief CONDITION that chooses the last child for the decision (static)
    \param nothing Nothing in this function
    \returns the chosen child
+ *  CONDITION that chooses the last child for the decision (static)
+ * @param nothing Nothing in this function
+ * @returns the chosen child
 */
 int TrackElement::highest(const void* nothing) const
 …
 /**
    \brief CONDITION that chooses a random child for the decision (static)
    \param nothing Nothing in this function
    \returns the chosen child
+ *  CONDITION that chooses a random child for the decision (static)
+ * @param nothing Nothing in this function
+ * @returns the chosen child
 */
 int TrackElement::random(const void* nothing) const
 …
 /**
    \brief CONDITION that chooses child 0, if the node(probably Player)
+ *  CONDITION that chooses child 0, if the node(probably Player)
    is left of its parent (z<0)) and 1/right otherwise.
    \param node The node to act upon.
    \returns the chosen child
+ * @param node The node to act upon.
+ * @returns the chosen child
 */
 int TrackElement::leftRight(const void* node) const
 …
 /**
    \brief CONDITION that chooses the child, that has the nearest distance to the node (probably player).
    \param node The node to act upon.
    \returns the chosen child
+ *  CONDITION that chooses the child, that has the nearest distance to the node (probably player).
+ * @param node The node to act upon.
+ * @returns the chosen child
    This is rather dangerous, because one must carefully set the points on the curve.
 …
 ////////////////////////
 /**
    \brief standard constructor
+ *  standard constructor
 */
 …
 /**
    \brief loads a trackElement from a TiXmlElement
    \param root the TiXmlElement to load the Data from
+ *  loads a trackElement from a TiXmlElement
+ * @param root the TiXmlElement to load the Data from
 */
 bool TrackManager::loadParams(const TiXmlElement* root)
 …
 /**
    \brief standard destructor
+ *  standard destructor
 */
 TrackManager::~TrackManager()
 …
 // INITIALIZE //
 /**
    \brief reserves Space for childCount children
    \param childCount The Count of children to make space for.
    \param trackElem The TrackElement to appy this to. (if NULL chose this->currentTrackElement)
+ *  reserves Space for childCount children
+ * @param childCount The Count of children to make space for.
+ * @param trackElem The TrackElement to appy this to. (if NULL chose this->currentTrackElement)
 */
 void TrackManager::initChildren(unsigned int childCount, TrackElement* trackElem)
 …
 /**
    \brief Sets the trackID we are working on.
    \param trackID the trackID we are working on
+ *  Sets the trackID we are working on.
+ * @param trackID the trackID we are working on
 */
 void TrackManager::workOn(unsigned int trackID)
 …
 /**
    \brief Sets the TrackElement to work on
    \param trackName the Name of the Track to work on
+ *  Sets the TrackElement to work on
+ * @param trackName the Name of the Track to work on
 */
 void TrackManager::workOnS(const char* trackName)
 …
 /**
    \brief Sets the Type of the Curve
    \param curveType The Type to set
    \param trackElem the TrackElement that should get a new Curve.
    \brief this will possibly get obsolete during the process.
+ *  Sets the Type of the Curve
+ * @param curveType The Type to set
+ * @param trackElem the TrackElement that should get a new Curve.
+ *  this will possibly get obsolete during the process.
 */
 void TrackManager::setCurveType(CurveType curveType, TrackElement* trackElem)
 …
 /**
    \param duration the duration of the TrackElement
+ * @param duration the duration of the TrackElement
    \see void TrackManager::setDuration(float duration, TrackElement* trackElem)
 */
 …
 /**
    \brief Sets the duration of the current path in seconds.
    \param duration The duration in seconds.
    \param trackElem The TrackElement to apply this to.
+ *  Sets the duration of the current path in seconds.
+ * @param duration The duration in seconds.
+ * @param trackElem The TrackElement to apply this to.
 */
 void TrackManager::setDuration(float duration, TrackElement* trackElem)
 …
 /**
    \brief adds a point to trackElem
    \param x x coord
    \param y y coord
    \param z z coord
    \param trackElem The TrackElement to add the Point to
+ *  adds a point to trackElem
+ * @param x x coord
+ * @param y y coord
+ * @param z z coord
+ * @param trackElem The TrackElement to add the Point to
 */
 void TrackManager::addPoint(float x, float y, float z)
 …
 /**
    \brief adds a point to trackElem
    \param newPoint The point to add.
    \param trackElem The TrackElement to add the Point to
+ *  adds a point to trackElem
+ * @param newPoint The point to add.
+ * @param trackElem The TrackElement to add the Point to
 */
 void TrackManager::addPointV(Vector newPoint, TrackElement* trackElem)
 …
 /**
    \brief adds a new Hot Point
    \param x: the x coordinate of the hotpoint
    \param y: the y coordinate of the hotpoint
    \param z: the z coordinate of the hotpoint
+ *  adds a new Hot Point
+ * @param x: the x coordinate of the hotpoint
+ * @param y: the y coordinate of the hotpoint
+ * @param z: the z coordinate of the hotpoint
    \see int TrackManager::addHotPointV(Vector newPoint, TrackElement* trackElem)
 */
 …
 /**
    \brief adds save/splitpoint.
    \param newPoint The point to add.
    \param trackElem if supplied it will add a hotpoint on this TrackElement
    \returns A Pointer to a newly appended Curve
+ *  adds save/splitpoint.
+ * @param newPoint The point to add.
+ * @param trackElem if supplied it will add a hotpoint on this TrackElement
+ * @returns A Pointer to a newly appended Curve
 */
 int TrackManager::addHotPointV(Vector newPoint, TrackElement* trackElem)
 …
+    }
   // \todo HotPoint Handling.
+  // @todo HotPoint Handling.
   trackElem->curve->addNode(newPoint);
   trackElem->nodeCount++;
 …
 /**
    \todo this must be better
+   @todo this must be better
 */
 void TrackManager::setSavePointS(const char* nextElementName)
 …
 /**
    \brief Sets the last HotPoint into a savePoint.
    \param trackElem The TrackElement to appy this to. (if NULL chose this->currentTrackElement)
    \returns A Pointer to a newly appended Curve
+ *  Sets the last HotPoint into a savePoint.
+ * @param trackElem The TrackElement to appy this to. (if NULL chose this->currentTrackElement)
+ * @returns A Pointer to a newly appended Curve
    If no HotPoint was defined the last added Point will be rendered into a savePoint. \n
 …
 /**
    \brief adds some interessting non-linear movments through the level.
    \param count The Count of children the fork will produce
+ *  adds some interessting non-linear movments through the level.
+ * @param count The Count of children the fork will produce
    If no HotPoint was defined the last added Point will be rendered into a fork. \n
 …
 /**
    \param count how many children to produce
    \param ... the information on the children (these are the Stings of their names
+ * @param count how many children to produce
+ * @param ... the information on the children (these are the Stings of their names
    \see TrackManager::fork(unsigned int count, ...)
 …
 /**
    \brief adds some interessting non-linear movments through the level.
    \param count The Count of childrens the current HotPoint will have.
    \param trackIDs A Pointer to an Array of ints which will hold the trackID's (the user will have to reserve space for this).
    \param trackNames the names for the tracks as a char-arrey-array
    \param trackElem The TrackElement to appy this to. (if NULL choose this->currentTrackElement)
+ *  adds some interessting non-linear movments through the level.
+ * @param count The Count of childrens the current HotPoint will have.
+ * @param trackIDs A Pointer to an Array of ints which will hold the trackID's (the user will have to reserve space for this).
+ * @param trackNames the names for the tracks as a char-arrey-array
+ * @param trackElem The TrackElement to appy this to. (if NULL choose this->currentTrackElement)
    \see TrackManager::fork(unsigned int count, ...)
 */
 …
 /**
    \brief decides under what condition a certain Path will be chosen.
    \param trackID the trackID to apply this to.
    \param cond the CONDITION of the decision
    \param subject the Subject that will be decided upon with CONDITION cond.
+ *  decides under what condition a certain Path will be chosen.
+ * @param trackID the trackID to apply this to.
+ * @param cond the CONDITION of the decision
+ * @param subject the Subject that will be decided upon with CONDITION cond.
 */
 void TrackManager::condition(unsigned int trackID, CONDITION cond, void* subject)
 …
 /**
    \brief decides under what condition a certain Path will be chosen.
    \param cond the CONDITION of the decision
    \param subject the Subject that will be decided upon with CONDITION cond.
    \param trackElem The TrackElement to appy this to. (if NULL chose this->currentTrackElement)
+ *  decides under what condition a certain Path will be chosen.
+ * @param cond the CONDITION of the decision
+ * @param subject the Subject that will be decided upon with CONDITION cond.
+ * @param trackElem The TrackElement to appy this to. (if NULL chose this->currentTrackElement)
 */
 void TrackManager::condition(CONDITION cond, void* subject, TrackElement* trackElem)
 …
 /**
    \brief joins some tracks together again.
    \param count The count of Paths to join.
+ *  joins some tracks together again.
+ * @param count The count of Paths to join.
    Join will set the localTime to the longest time a Path has to get to this Point. \n
 …
 /**
    \brief Joins some Tracks together again.
    \param count The count of trackElements to join
+ *  Joins some Tracks together again.
+ * @param count The count of trackElements to join
    \see void TrackManager::join(unsigned int count, ...)
 …
 /**
    \brief joins some tracks together again.
    \param count The count of Paths to join.
    \param trackIDs an Array with the trackID's to join
+ *  joins some tracks together again.
+ * @param count The count of Paths to join.
+ * @param trackIDs an Array with the trackID's to join
    \see void TrackManager::join(unsigned int count, ...)
 …
 /**
    \brief finalizes the TrackSystem. after this it will not be editable anymore
    \todo check for any inconsistencies, output errors
+ *  finalizes the TrackSystem. after this it will not be editable anymore
+   @todo check for any inconsistencies, output errors
 */
 void TrackManager::finalize()
 …
 /**
    \brief calculates the Position for the localTime of the Track.
    \returns the calculated Position
+ *  calculates the Position for the localTime of the Track.
+ * @returns the calculated Position
 */
 Vector TrackManager::calcPos() const
 …
 /**
    \brief calculates the Rotation for the localTime of the Track.
    \returns the calculated Rotation
+ *  calculates the Rotation for the localTime of the Track.
+ * @returns the calculated Rotation
 */
 Vector TrackManager::calcDir() const
 …
 /**
    \returns the current Width of the track
+ * @returns the current Width of the track
 */
 float TrackManager::getWidth() const
 …
 /**
    \brief Advances the local-time of the Track around dt
    \param dt The time about which to advance.
+ *  Advances the local-time of the Track around dt
+ * @param dt The time about which to advance.
    This function also checks, if the TrackElement has to be changed.
 …
 /**
    \brief Jumps to a certain point on the Track.
    \param time The time on the Track to jump to.
+ *  Jumps to a certain point on the Track.
+ * @param time The time on the Track to jump to.
    This should be used to Jump backwards on a Track, because moving forward means to change between the Path. (it then tries to choose the default.)
 …
 /**
    \brief a Function that decides which Path we should follow.
    \param trackElem The Path to choose.
+ *  a Function that decides which Path we should follow.
+ * @param trackElem The Path to choose.
 */
 …
 /**
    \brief Sets the PNode, that should be moved along the Tack
    \param bindSlave the PNode to set
+ *  Sets the PNode, that should be moved along the Tack
+ * @param bindSlave the PNode to set
 */
 void TrackManager::setBindSlave(PNode* bindSlave)
 …
 /**
    \returns the main TrackNode
+ * @returns the main TrackNode
 */
 PNode* TrackManager::getTrackNode()
 …
 /**
    \brief Imports a model of the Graph into the OpenGL-environment.
    \param dt The Iterator used in seconds for Painting the Graph.
+ *  Imports a model of the Graph into the OpenGL-environment.
+ * @param dt The Iterator used in seconds for Painting the Graph.
    This is for testing facility only. Do this if you want to see the Path inside the Level.
 …
 /**
    \brief outputs debug information about the trackManager
    \param level how much debug
+ *  outputs debug information about the trackManager
+ * @param level how much debug
 */
 void TrackManager::debug(unsigned int level) const

orxonox/trunk/src/util/track/track_manager.h

-                      r4834
+                      r4836
 /*!
     \file track_manager.h
     \brief manages all tracks defined in the world and the path the player takes
+  *  manages all tracks defined in the world and the path the player takes
     it is a container for all tracks and all track-nodes. it manages the movement of
 …
  public:
   virtual ~TrackManager();
   /** \returns a Pointer to the only object of this Class */
+  /** @returns a Pointer to the only object of this Class */
   inline static TrackManager* getInstance() { if (!singletonRef) singletonRef = new TrackManager();  return singletonRef; };
 …
   void workOnS(const char* trackName);
   /** \see setCurveType(CurveType curveType, TrackElement* trackElem); \param curveType the type of the Curve */
+  /** \see setCurveType(CurveType curveType, TrackElement* trackElem); @param curveType the type of the Curve */
   inline void setCurveType(CurveType curveType) { this->setCurveType (curveType, this->currentTrackElem);};
   void setCurveType(CurveType curveType, TrackElement* trackElem);

orxonox/trunk/src/util/track/track_node.cc

-                      r4597
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 TrackNode::TrackNode ()
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 TrackNode::~TrackNode ()

orxonox/trunk/src/util/track/track_node.h

r4489	r4836
1	1	/*!
2	2	\file track_node.h
3		~~\brief~~ Definition of the TrackNode are located here
	3	* Definition of the TrackNode are located here
4	4
5	5	the TrackNode is the node, that follows the Track (and the TrackManager)

orxonox/trunk/src/world_entities/camera.cc

-                      r4832
+                      r4836
 /**
    \brief creates a Camera
+ *  creates a Camera
 */
 Camera::Camera()
 …
 /**
    \brief default destructor
+ *  default destructor
 */
 Camera::~Camera()
 …
 /**
    \brief focuses the Camera onto a Target
    \param target the new PNode the Camera should look at.
+ *  focuses the Camera onto a Target
+ * @param target the new PNode the Camera should look at.
 */
 void Camera::lookAt(PNode* target)
 …
 /**
    \returns The PNode of the Target (from there you can get position and so on
+ * @returns The PNode of the Target (from there you can get position and so on
 */
 PNode* Camera::getTarget()
 …
 /**
    \brief sets a new AspectRatio
    \param aspectRatio the new aspect ratio to set (width / height)
+ *  sets a new AspectRatio
+ * @param aspectRatio the new aspect ratio to set (width / height)
 */
 void Camera::setAspectRatio(float aspectRatio)
 …
 /**
    \brief sets the Field of View to fofy
    \param fovy new field of view factor (in degrees)
+ *  sets the Field of View to fofy
+ * @param fovy new field of view factor (in degrees)
 */
 void Camera::setFovy(float fovy)
 …
 /**
   \brief Sets a new clipping region
   \param nearClip The near clip plane
   \param farClip The far clip plane
+* @param nearClip The near clip plane
+* @param farClip The far clip plane
 */
 void Camera::setClipRegion(float nearClip, float farClip)
 …
 /**
    \brief sets the new VideoMode and initializes iteration to it.
    \param mode the mode to change to.
+ *  sets the new VideoMode and initializes iteration to it.
+ * @param mode the mode to change to.
 */
 void Camera::setViewMode(ViewMode mode)
 …
 /**
    \brief Updates the position of the camera.
    \param dt: The time that elapsed.
+ *  Updates the position of the camera.
+ * @param dt: The time that elapsed.
 */
 void Camera::tick(float dt)
 …
 /**
    \brief initialize rendering perspective according to this camera
+ *  initialize rendering perspective according to this camera
    This is called immediately before the rendering cycle starts, it sets all global
 …
 /**
    \brief processes an event
    \param event: the event to process
+ *  processes an event
+ * @param event: the event to process
 */
 void Camera::process(const Event &event)

orxonox/trunk/src/world_entities/camera.h

r4746	r4836
1	1	/*!
2	2	\file camera.h
3		~~\brief~~ Viewpoint controlling class definitions
	3	* Viewpoint controlling class definitions
4	4	*/
5	5

orxonox/trunk/src/world_entities/character_attributes.cc

-                      r4320
+                      r4836
 /**
    \brief standard constructor
    \todo this constructor is not jet implemented - do it
+ *  standard constructor
+   @todo this constructor is not jet implemented - do it
 */
 CharacterAttributes::CharacterAttributes ()
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 …
 /**
    \brief sets the health of the character
    \param helath
+ *  sets the health of the character
+ * @param helath
  */
 void CharacterAttributes::setHealth(int health)
 …
 /**
    \brief adds health to the charater
    \param health
    \returns health that couldnt be added due to healt limit, 0 if everything worked as normal
+ *  adds health to the charater
+ * @param health
+ * @returns health that couldnt be added due to healt limit, 0 if everything worked as normal
  */
 int CharacterAttributes::addHealth(int health)
 …
 /**
    \brief remove health due to damager for example
    \param amount of health
    \returns false if health is zero -> dead
+ *  remove health due to damager for example
+ * @param amount of health
+ * @returns false if health is zero -> dead
  */
 bool CharacterAttributes::substractHealth(int health)
 …
 /**
    \brief gets the current amount of health
    \returns health
+ *  gets the current amount of health
+ * @returns health
  */
 int CharacterAttributes::getHealth()
 …
 /**
    \brief sets maximum health
    \param health
+ *  sets maximum health
+ * @param health
    if healthMax = 0 -> unlimited
 …
 /**
    \brief gets health maximium
    \returns the health maximum
+ *  gets health maximium
+ * @returns the health maximum
  */
 int CharacterAttributes::getHealthMax()
 …
 /*======================armor/ shields===================== */
 /**
    \brief sets the shild strength
    \param strength
+ *  sets the shild strength
+ * @param strength
  */
 void CharacterAttributes::setShieldStrength(int shieldStrength)
 …
 /**
    \brief adds shield strength
    \param strength
+ *  adds shield strength
+ * @param strength
    there is currently no limit to shieldstrength
 …
 /**
    \brief substracts shield strength
    \param strength
    \returns amount of shield strength below zero after substraction. Magic: Troumble. if everything works allright, it returns 0
+ *  substracts shield strength
+ * @param strength
+ * @returns amount of shield strength below zero after substraction. Magic: Troumble. if everything works allright, it returns 0
  */
 int CharacterAttributes::substractShieldStrength(int shieldStrength)
 …
 /**
    \brief gets shield strength
    \returns the shield strength
+ *  gets shield strength
+ * @returns the shield strength
  */
 int CharacterAttributes::getShieldStrength()
 …
 /*=====================damage=====================*/
 /**
    \brief sets the amount of base damage dealt to all aircrafts
    \param damage
+ *  sets the amount of base damage dealt to all aircrafts
+ * @param damage
    There can be a difference between arms that hit a ground/air craft. Eg.
 …
 /**
    \brief gets the amount of base damage
    \returns base damage to aircrafts
+ *  gets the amount of base damage
+ * @returns base damage to aircrafts
    There can be a difference between arms that hit a ground/air craft. Eg.
 …
 /**
    \brief sets the amount of base damage dealt to all groundcrafts
    \param damage
+ *  sets the amount of base damage dealt to all groundcrafts
+ * @param damage
    There can be a difference between arms that hit a ground/air craft. Eg.
 …
 /**
    \briefgets the amount of base damage
    \returns base damage to groundcrafts
+ * gets the amount of base damage
+ * @returns base damage to groundcrafts
    There can be a difference between arms that hit a ground/air craft. Eg.
 …
 /**
    \brief sets the damage modifier to the damage that is dealed via laser weapons
    \param modifier [0..1]
+ *  sets the damage modifier to the damage that is dealed via laser weapons
+ * @param modifier [0..1]
    eg. the damage is calculated after: damage = modifier * damageToGroundCraft
 …
 /**
    \brief gets the damage modifier to the damage that is dealed via laser weapons
    \returns damage modifier
+ *  gets the damage modifier to the damage that is dealed via laser weapons
+ * @returns damage modifier
    eg. the damage is calculated after: damage = modifier * damageToGroundCraft
 …
 /**
    \brief sets the damage modifier to the damage that is dealed via plasma weapons
    \param damage modifier
+ *  sets the damage modifier to the damage that is dealed via plasma weapons
+ * @param damage modifier
    eg. the damage is calculated after: damage = modifier * damageToGroundCraft
 …
 /**
    \brief gets the damage modifier to the damage that is dealed plasma weapons
    \returns damage modifier
+ *  gets the damage modifier to the damage that is dealed plasma weapons
+ * @returns damage modifier
    eg. the damage is calculated after: damage = modifier * damageToGroundCraft
 …
 /**
    \brief sets the damage modifier to the damage that is dealed via explosives
    \param damage modifier
+ *  sets the damage modifier to the damage that is dealed via explosives
+ * @param damage modifier
    eg. the damage is calculated after: damage = modifier * damageToGroundCraft
 …
 /**
    \brief sets the damage modifier to the damage that is dealed via explosives
    \returns damage modifier
+ *  sets the damage modifier to the damage that is dealed via explosives
+ * @returns damage modifier
    eg. the damage is calculated after: damage = modifier * damageToGroundCraft
 …
 /*=====================energy=====================*/
 /**
    \brief sets the amount of energy
    \param energy
+ *  sets the amount of energy
+ * @param energy
  */
 void CharacterAttributes::setEnergy(int energy)
 …
 /**
    \brief adds energy to the system
    \param amount of energy
    \returns amount of energy that is too much due to energy limit
+ *  adds energy to the system
+ * @param amount of energy
+ * @returns amount of energy that is too much due to energy limit
  */
 int CharacterAttributes::addEnergy(int addEnergy)
 …
 /**
    \brief substracts energy from a system
    \param amount of energy
    \returns false if there is no energy anymore
+ *  substracts energy from a system
+ * @param amount of energy
+ * @returns false if there is no energy anymore
  */
 bool CharacterAttributes::substractEnergy(int subEnergy)
 …
 /**
    \brief gets the amount of energy
    \returns energy
+ *  gets the amount of energy
+ * @returns energy
  */
 int CharacterAttributes::getEnergy()
 …
 /**
    \brief sets the energy consumption
    \param amount of energy
+ *  sets the energy consumption
+ * @param amount of energy
 */
 void CharacterAttributes::setEnergyConsumption(int energy)
 …
 /**
    \brief gets the energy consumption
    \returns amount of energy
+ *  gets the energy consumption
+ * @returns amount of energy
 */
 int CharacterAttributes::getEnergyConsumption()
 …
 /**
    \brief sets the maximum energy level
    \param amount of energy
+ *  sets the maximum energy level
+ * @param amount of energy
 */
 void CharacterAttributes::setEnergyMax(int energy)
 …
 /**
    \brief gets the max energy level
    \returns amount of energy
+ *  gets the max energy level
+ * @returns amount of energy
 */
 int CharacterAttributes::getEnergyMax()

orxonox/trunk/src/world_entities/character_attributes.h

r3583	r4836
1	1	/*!
2	2	\file character_attributes.h
3		~~\brief~~ Definition of the attributes of a character (healt, armor,.. ) whatever is important to the character
	3	* Definition of the attributes of a character (healt, armor,.. ) whatever is important to the character
4	4	*/
5	5

orxonox/trunk/src/world_entities/environment.cc

-                      r4724
+                      r4836
 /**
    \brief creates an environment
+ *  creates an environment
 */
 Environment::Environment () : WorldEntity()
 …
 /**
    \brief deletes an environment
+ *  deletes an environment
 */
 Environment::~Environment ()
 …
 /**
    \brief ticks the environment
    \param time the time about which to tick
+ *  ticks the environment
+ * @param time the time about which to tick
 */
 void Environment::tick (float time) {}
 /**
    \brief if a hit occures
+ *  if a hit occures
 */
 void Environment::hit (WorldEntity* weapon, Vector* loc) {}
 /**
    \brief destroys an Environment
+ *  destroys an Environment
 */
 void Environment::destroy () {}
 /**
    \brief a collision with some ship
+ *  a collision with some ship
 */
 void Environment::collide (WorldEntity* other,  Uint32 ownhitflags, Uint32 otherhitflags) {}
 /**
    \brief draws the Environment
+ *  draws the Environment
 */
 void Environment::draw ()

orxonox/trunk/src/world_entities/player.cc

-                      r4834
+                      r4836
 /**
    \brief creates a new Player
    \param isFree if the player is free
+ *  creates a new Player
+ * @param isFree if the player is free
 */
 Player::Player()
 …
 /**
    \brief destructs the player, deletes alocated memory
+ *  destructs the player, deletes alocated memory
 */
 Player::~Player ()
 …
 /**
    \brief creates a new Player from Xml Data
    \param root the xml element containing player data
    \todo add more parameters to load
+ *  creates a new Player from Xml Data
+ * @param root the xml element containing player data
+   @todo add more parameters to load
 */
 Player::Player(const TiXmlElement* root)
 …
 /**
    \brief adds a weapon to the weapon list of player
    \param weapon to add
+ *  adds a weapon to the weapon list of player
+ * @param weapon to add
 */
 void Player::addWeapon(Weapon* weapon)
 …
 /**
    \brief removes a weapon from the player
    \param weapon to remove
+ *  removes a weapon from the player
+ * @param weapon to remove
 */
 void Player::removeWeapon(Weapon* weapon)
 …
 /**
    \brief effect that occurs after the player is spawned
+ *  effect that occurs after the player is spawned
 */
 void Player::postSpawn ()
 …
 /**
    \brief the action occuring if the player left the game
+ *  the action occuring if the player left the game
 */
 void Player::leftWorld ()
 …
 /**
    \brief if the player is hit, call this function
    \param weapon hit by this weapon
    \param loc ??
+ *  if the player is hit, call this function
+ * @param weapon hit by this weapon
+ * @param loc ??
 */
 void Player::hit (WorldEntity* weapon, Vector* loc)
 …
 /**
     \brief Collision with another Entity has this effect
     \param other the other colider
     \param ownhitflags ??
     \param otherhitflags ??
+  *  Collision with another Entity has this effect
+  * @param other the other colider
+  * @param ownhitflags ??
+  * @param otherhitflags ??
 */
 void Player::collide (WorldEntity* other, Uint32 ownhitflags, Uint32 otherhitflags)
 …
 /**
    \brief draws the player after transforming him.
+ *  draws the player after transforming him.
 */
 void Player::draw ()
 …
 /**
    \brief the function called for each passing timeSnap
    \param time The timespan passed since last update
+ *  the function called for each passing timeSnap
+ * @param time The timespan passed since last update
 */
 void Player::tick (float time)
 …
 /**
    \brief action if player moves
    \param time the timeslice since the last frame
+ *  action if player moves
+ * @param time the timeslice since the last frame
 */
 void Player::move (float time)
 …
     accel = accel + (orthDirection*acceleration);
   if( this->bAscend )
   if( this->bDescend) {/* FIXME */} /* \todo up and down player movement */
+  if( this->bDescend) {/* FIXME */} /* @todo up and down player movement */
   Vector move = accel * time;
 …
 /**
    \brief weapon manipulation by the player
+ *  weapon manipulation by the player
 */
 void Player::weapon()
 …
 /**
    \brief The connection to the command node
    \param cmd the Command unit from witch to map
+ *  The connection to the command node
+ * @param cmd the Command unit from witch to map
    here the commands are mapped to the players movement/weaponary

orxonox/trunk/src/world_entities/player.h

r4834	r4836
1	1	/*!
2	2	\file player.h
3		~~\brief~~ Implements a basic controllable WorldEntity
	3	* Implements a basic controllable WorldEntity
4	4	*/
5	5

orxonox/trunk/src/world_entities/power_up.h

r3544	r4836
1	1	/*!
2	2	\file power_up.h
3		~~\brief~~ A class representing a PowerUp in the world.
	3	* A class representing a PowerUp in the world.
4	4	*/
5	5

orxonox/trunk/src/world_entities/satellite.cc

-                      r4597
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 Satellite::Satellite (Vector axis, float speed)
 …
 /**
    \brief standard destructor
+ *  standard destructor
 */
 Satellite::~Satellite ()
 …
 /**
    \brief this method is called every frame
    \param time: the time in seconds that has passed since the last tick
+ *  this method is called every frame
+ * @param time: the time in seconds that has passed since the last tick
    Handle all stuff that should update with time inside this method (movement, animation, etc.)
 …
 /**
    \brief the entity is drawn onto the screen with this function
+ *  the entity is drawn onto the screen with this function
    This is a central function of an entity: call it to let the entity painted to the screen. Just override this function with whatever you want to be drawn.

orxonox/trunk/src/world_entities/satellite.h

r4597	r4836
1	1	/*!
2	2	\file world_entity.h
3		~~\brief~~ Definition of the basic WorldEntity
	3	* Definition of the basic WorldEntity
4	4	*/
5	5

orxonox/trunk/src/world_entities/skybox.cc

-                      r4746
+                      r4836
 /**
    \brief Constructs a SkyBox and takes fileName as a map.
    \param fileName the file to take as input for the SkyBox
+ *  Constructs a SkyBox and takes fileName as a map.
+ * @param fileName the file to take as input for the SkyBox
 */
 SkyBox::SkyBox(const char* fileName)
 …
 /**
    \brief initializes a skybox from a XmlElement
+ *  initializes a skybox from a XmlElement
 */
 SkyBox::SkyBox(const TiXmlElement* root)
 …
 /**
    \brief default destructor
+ *  default destructor
 */
 SkyBox::~SkyBox()
 …
 /**
    \brief sets A set of textures when just giving a Name and an extension:
+ *  sets A set of textures when just giving a Name and an extension:
    usage: give this function an argument like
 …
 /**
    \brief Defines which textures should be loaded onto the SkyBox.
    \param top the top texture.
    \param bottom the bottom texture.
    \param left the left texture.
    \param right the right texture.
    \param front the front texture.
    \param back the back texture.
+ *  Defines which textures should be loaded onto the SkyBox.
+ * @param top the top texture.
+ * @param bottom the bottom texture.
+ * @param left the left texture.
+ * @param right the right texture.
+ * @param front the front texture.
+ * @param back the back texture.
 */
 void SkyBox::setTextures(const char* top, const char* bottom, const char* left, const char* right, const char* front, const char* back)
 …
 /**
    \param size The new size of the SkyBox
+ * @param size The new size of the SkyBox
  * do not forget to rebuild the SkyBox after this.
 …
 /**
    \brief draws the SkyBox
+ *  draws the SkyBox
 */
 void SkyBox::draw()
 …
 /**
    \brief rebuilds the SkyBox
+ *  rebuilds the SkyBox
    this must be done, when changing the Size of the Skybox (runtime-efficency)

orxonox/trunk/src/world_entities/skybox.h

r4746	r4836
1	1	/*!
2	2	\file skybox.h
3		~~\brief~~ Definition of the SkyBox, that handles the Display of an atmosphere for orxonox.
	3	* Definition of the SkyBox, that handles the Display of an atmosphere for orxonox.
4	4
5	5	A SkyBox is always centered at the current working Camera, and will only obey the cameras

orxonox/trunk/src/world_entities/skysphere.cc

-                      r4597
+                      r4836
 /**
    \brief Constructs a SkySphere and takes fileName as a map.
    \param fileName the file to take as input for the skysphere
+ *  Constructs a SkySphere and takes fileName as a map.
+ * @param fileName the file to take as input for the skysphere
 */
 Skysphere::Skysphere(char* fileName)
 …
 /**
    \brief default destructor
+ *  default destructor
 */
 Skysphere::~Skysphere()
 …
 /**
    \brief initializes the Skysphere.
    \param fileName the file to take as input for the skysphere
+ *  initializes the Skysphere.
+ * @param fileName the file to take as input for the skysphere
 */
 void Skysphere::initialize(char* fileName)
 …
 /**
    \brief Defines which texture should be loaded onto the skysphere.
    \param fileName The filename of the Texture
+ *  Defines which texture should be loaded onto the skysphere.
+ * @param fileName The filename of the Texture
 */
 void Skysphere::setTexture(char* fileName)
 …
 /**
    \brief draws the Skysphere
+ *  draws the Skysphere
    This part is normally precessed in the "Painting Phase".
 …
 /**
    \brief sets the Radius of the Sphere.
    \param radius The Radius of The Sphere
+ *  sets the Radius of the Sphere.
+ * @param radius The Radius of The Sphere
 */
 void Skysphere::setRadius(float radius)

orxonox/trunk/src/world_entities/skysphere.h

-                      r4597
+                      r4836
 /*!
     \file skysphere.h
     \brief Definition of the Skysphere, that handles the Display of an atmosphere of orxonox.
+  *  Definition of the Skysphere, that handles the Display of an atmosphere of orxonox.
     A SkySphere is always centered at the current working Camera, and will only obey the cameras
     movment but not its rotation.
     \todo self-rotation
     \todo handle reference to parent-object
+    @todo self-rotation
+    @todo handle reference to parent-object
 */

orxonox/trunk/src/world_entities/terrain.cc

-                      r4746
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 …
 /**
    \brief Constructor for loading a Terrain out of a file
    \param fileName The file to load data from.
+ *  Constructor for loading a Terrain out of a file
+ * @param fileName The file to load data from.
    this either loads out of an OBJ-file, or loads a heightmap if no .obj-extension is found.
 …
 /**
    \brief a Constructor for the Debug-Worlds
    \todo make it not compileable when not in debug-mode
+ *  a Constructor for the Debug-Worlds
+   @todo make it not compileable when not in debug-mode
 */
 Terrain::Terrain(DebugTerrain debugTerrain)
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */

orxonox/trunk/src/world_entities/terrain.h

-                      r4746
+                      r4836
 /*!
     \file terrain.h
     \brief Defines and handles the terrain of the World
+  *  Defines and handles the terrain of the World
     \todo implement it
+    @todo implement it
     The terrain should either be build from a Model a OBJModel or from a HeightMap.

orxonox/trunk/src/world_entities/weapons/crosshair.h

r4832	r4836
1	1	/*!
2	2	\file crosshair.h
3		~~\brief~~ Definition of ...
	3	* Definition of ...
4	4
5	5	*/

orxonox/trunk/src/world_entities/weapons/projectile.cc

-                      r4758
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 Projectile::Projectile (Weapon* weapon) : WorldEntity()
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 Projectile::~Projectile ()
 …
 /**
    \brief this sets the flight direction of the projectile
    \param directin in which to flight
+ *  this sets the flight direction of the projectile
+ * @param directin in which to flight
    this function will calculate a vector out of this to be used in the
 …
 /**
    \brief this sets the time to life of the projectile
    \param ttl in second
+ *  this sets the time to life of the projectile
+ * @param ttl in second
    after this life time, the projectile will garbage collect itself
 …
 /**
    \brief sets the speed of the projectile
+ *  sets the speed of the projectile
 */
 void Projectile::setSpeed(float speed)
 …
 /**
    \brief sets the velocity vector to a spec speed
    \param velocity: vector of the velocity
+ *  sets the velocity vector to a spec speed
+ * @param velocity: vector of the velocity
 */
 void Projectile::setVelocity(const Vector &velocity)
 …
 /**
    \brief signal tick, time dependent things will be handled here
    \param time since last tick
+ *  signal tick, time dependent things will be handled here
+ * @param time since last tick
 */
 void Projectile::tick (float time)
 …
 /**
    \brief the projectile gets hit by another entity
    \param the other entity
    \param place where it is hit
+ *  the projectile gets hit by another entity
+ * @param the other entity
+ * @param place where it is hit
 */
 void Projectile::hit (WorldEntity* entity, Vector* place)
 …
 /**
    \brief the function gets called, when the projectile is destroyed
+ *  the function gets called, when the projectile is destroyed
 */
 void Projectile::destroy ()

orxonox/trunk/src/world_entities/weapons/projectile.h

r4758	r4836
1	1	/*!
2	2	\projectile.h
3		~~\brief~~ a projectile, that is been shooted by a weapon
	3	* a projectile, that is been shooted by a weapon
4	4
5	5	You can use this class to make some shoots, but this isn't the real idea. If you want to just test, if the

orxonox/trunk/src/world_entities/weapons/test_bullet.cc

-                      r4758
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
 */
 TestBullet::TestBullet (Weapon* weapon) : Projectile(weapon)
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 TestBullet::~TestBullet ()
 …
 /**
    \brief signal tick, time dependent things will be handled here
    \param time since last tick
+ *  signal tick, time dependent things will be handled here
+ * @param time since last tick
 */
 void TestBullet::tick (float time)
 …
 /**
    \brief the projectile gets hit by another entity
    \param the other entity
    \param place where it is hit
+ *  the projectile gets hit by another entity
+ * @param the other entity
+ * @param place where it is hit
 */
 void TestBullet::hit (WorldEntity* entity, Vector* place)
 …
 /**
    \brief the function gets called, when the projectile is destroyed
+ *  the function gets called, when the projectile is destroyed
 */
 void TestBullet::destroy ()

orxonox/trunk/src/world_entities/weapons/test_bullet.h

r4758	r4836
1	1	/*!
2	2	\projectile.h
3		~~\brief~~ a projectile, that is been shooted by a weapon
	3	* a projectile, that is been shooted by a weapon
4	4	*/
5	5

orxonox/trunk/src/world_entities/weapons/test_gun.cc

-                      r4829
+                      r4836
    \todo: direction in which the projectile flights
    \todo: a target to set/hit
+   @todo: direction in which the projectile flights
+   @todo: a target to set/hit
 */
 …
 /**
    \brief standard constructor
+ *  standard constructor
    creates a new weapon
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 TestGun::~TestGun ()
 …
 /**
    \brief this activates the weapon
+ *  this activates the weapon
    This is needed, since there can be more than one weapon on a ship. the
 …
 /**
    \brief this deactivates the weapon
+ *  this deactivates the weapon
    This is needed, since there can be more than one weapon on a ship. the
 …
 /**
    \brief fires the weapon
+ *  fires the weapon
    this is called from the player.cc, when fire-button is been pushed
    \todo: the ObjectManager deliveres Projectiles not TestBullets! this should be diffrent
+   @todo: the ObjectManager deliveres Projectiles not TestBullets! this should be diffrent
 */
 void TestGun::fire()
 …
 /**
    \brief is called, when the weapon gets hit (=collide with something)
    \param from which entity it is been hit
    \param where it is been hit
+ *  is called, when the weapon gets hit (=collide with something)
+ * @param from which entity it is been hit
+ * @param where it is been hit
    this may not be used, since it would make the game relay complicated when one
 …
 /**
    \brief is called, when the weapon is destroyed
+ *  is called, when the weapon is destroyed
    this is in conjunction with the hit function, so when a weapon is able to get
 …
 /**
    \brief tick signal for time dependent/driven stuff
+ *  tick signal for time dependent/driven stuff
 */
 void TestGun::tick (float time)
 …
 /**
    \brief is called, when there is no fire button pressed
+ *  is called, when there is no fire button pressed
 */
 void TestGun::weaponIdle()
 …
 /**
    \brief this will draw the weapon
+ *  this will draw the weapon
 */
 void TestGun::draw ()

orxonox/trunk/src/world_entities/weapons/test_gun.h

r4827	r4836
1	1	/*!
2	2	\file weapon.h
3		~~\brief~~ a weapon that a player can use
	3	* a weapon that a player can use
4	4
5	5	A Player has a list of weapons, that can be choosen to shoot projectiles

orxonox/trunk/src/world_entities/weapons/weapon.cc

-                      r4834
+                      r4836
 /**
    \brief standard constructor
+ *  standard constructor
    creates a new weapon
 …
 /**
    \brief standard deconstructor
+ *  standard deconstructor
 */
 Weapon::~Weapon ()
 …
 /**
     \brief enables the weapon
+  *  enables the weapon
     a weapon can be enabled/disabled because of various reasons. if a weapon is
 …
 /**
     \brief disables the weapon
+  *  disables the weapon
     a weapon can be enabled/disabled because of various reasons. if a weapon is
 …
 /**
     \brief checks if the weapon is enabled
     \returns true if enabled
+  *  checks if the weapon is enabled
+  * @returns true if enabled
     a weapon can be ebabled/disabled because of various reasons. if a weapon is
 …
 /**
    \brief sets a new projectile to the weapon
    \param new projectile for this weapon
+ *  sets a new projectile to the weapon
+ * @param new projectile for this weapon
    weapon an projectile are independent, so you can combine them as you want
 …
 /**
    \brief sets a new projectile to the weapon
    \returns the current projectile of this weapon
+ *  sets a new projectile to the weapon
+ * @returns the current projectile of this weapon
    weapon an projectile are independent, so you can combine them as you want
 …
 /**
    \brief this activates the weapon
+ *  this activates the weapon
    This is needed, since there can be more than one weapon on a ship. the
 …
 /**
    \brief this deactivates the weapon
+ *  this deactivates the weapon
    This is needed, since there can be more than one weapon on a ship. the
 …
 /**
    \brief asks if the current weapon is active
    \returns true if it the weapon is active
+ *  asks if the current weapon is active
+ * @returns true if it the weapon is active
 */
 bool Weapon::isActive()
 …
 /**
    \brief is called, when the weapon gets hit (=collide with something)
    \param from which entity it is been hit
    \param where it is been hit
+ *  is called, when the weapon gets hit (=collide with something)
+ * @param from which entity it is been hit
+ * @param where it is been hit
    this may not be used, since it would make the game relay complicated when one
 …
 /**
    \brief is called, when the weapon is destroyed
+ *  is called, when the weapon is destroyed
    this is in conjunction with the hit function, so when a weapon is able to get
 …
 /**
    \brief tick signal for time dependent/driven stuff
+ *  tick signal for time dependent/driven stuff
 */
 void Weapon::tick (float time)
 …
 /**
    \brief is called, when there is no fire button pressed
+ *  is called, when there is no fire button pressed
 */
 void Weapon::weaponIdle()
 …
 /**
    \brief this will draw the weapon
+ *  this will draw the weapon
 */
 void Weapon::draw ()

orxonox/trunk/src/world_entities/weapons/weapon.h

-                      r4832
+                      r4836
 /*!
     \file weapon.h
     \brief a weapon that a  can use
+  *  a weapon that a  can use
 …
   inline bool hasWeaponIdleTimeElapsed() const { return (this->localTime>this->idleTime)?true:false; };
   /** @brief fires the weapon */
+  /**  fires the weapon */
   virtual void fire() = 0;
   virtual void hit (WorldEntity* weapon, const Vector& loc);

orxonox/trunk/src/world_entities/weapons/weapon_manager.h

r4834	r4836
1	1	/*!
2	2	\file weapon.h
3		~~\brief~~ a weapon that a player can use
	3	* a weapon that a player can use
4	4
5	5	A Player has a list of weapons, that can be choosen to shoot projectiles

orxonox/trunk/src/world_entities/world_entity.cc

-                      r4814
+                      r4836
 /**
    \brief Loads the WordEntity-specific Part of any derived Class
+ *  Loads the WordEntity-specific Part of any derived Class
 */
 WorldEntity::WorldEntity(const TiXmlElement* root)
 …
 /**
    \brief standard destructor
+ *  standard destructor
 */
 WorldEntity::~WorldEntity ()
 …
 /**
    \brief loads a Model onto a WorldEntity
    \param fileName the name of the model to load
+ *  loads a Model onto a WorldEntity
+ * @param fileName the name of the model to load
 */
 void WorldEntity::loadModel(const char* fileName)
 …
 /**
    \brief sets the character attributes of a worldentity
    \param character attributes
+ *  sets the character attributes of a worldentity
+ * @param character attributes
    these attributes don't have to be set, only use them, if you need them
 …
 /**
    \brief gets the Character attributes of this worldentity
    \returns character attributes
+ *  gets the Character attributes of this worldentity
+ * @returns character attributes
 */
 CharacterAttributes* WorldEntity::getCharacterAttributes()
 …
 /**
    \brief set the WorldEntity's collision hull
    \param newhull: a pointer to a completely assembled CollisionCluster
+ *  set the WorldEntity's collision hull
+ * @param newhull: a pointer to a completely assembled CollisionCluster
    Any previously assigned collision hull will be deleted on reassignment
 …
 /**
     \brief process draw function
+  *  process draw function
 */
 void WorldEntity::processDraw ()
 …
 /**
    \brief sets the drawable state of this entity.
    \param bDraw TRUE if draweable, FALSE otherwise
+ *  sets the drawable state of this entity.
+ * @param bDraw TRUE if draweable, FALSE otherwise
 */
 void WorldEntity::setDrawable (bool bDraw)
 …
 /**
    \brief this function is called, when two entities collide
    \param entity: the world entity with whom it collides
+ *  this function is called, when two entities collide
+ * @param entity: the world entity with whom it collides
    Implement behaviour like damage application or other miscellaneous collision stuff in this function
 …
 /**
    \brief this function is called, when the ship is hit by a waepon
    \param weapon: the laser/rocket/shoot that hits.
    \param loc: place where it is hit
+ *  this function is called, when the ship is hit by a waepon
+ * @param weapon: the laser/rocket/shoot that hits.
+ * @param loc: place where it is hit
    calculate the damage depending
 …
 /**
    \brief this is called immediately after the Entity has been constructed and initialized
+ *  this is called immediately after the Entity has been constructed and initialized
    Put any initialisation code that requires knowledge of location (placement if the Entity is free) and owner of the entity here.
 …
 /**
    \brief this method is called by the world if the WorldEntity leaves valid gamespace
+ *  this method is called by the world if the WorldEntity leaves valid gamespace
    For free entities this means it left the Track boundaries. With bound entities it means its Location adresses a
 …
 /**
    \brief this method is called every frame
    \param time: the time in seconds that has passed since the last tick
+ *  this method is called every frame
+ * @param time: the time in seconds that has passed since the last tick
    Handle all stuff that should update with time inside this method (movement, animation, etc.)
 …
 /**
    \brief the entity is drawn onto the screen with this function
+ *  the entity is drawn onto the screen with this function
    This is a central function of an entity: call it to let the entity painted to the screen. Just override this function with whatever you want to be drawn.
 …
 /**
    \brief this handles incoming command messages
    \param cmd: a pointer to the incoming Command structure
+ *  this handles incoming command messages
+ * @param cmd: a pointer to the incoming Command structure
    Put all code that handles Command messages here, this will mainly be called by the assigned CommandNode but can also be used

orxonox/trunk/src/world_entities/world_entity.h

-                      r4746
+                      r4836
 /*!
     \file world_entity.h
     \brief Definition of the basic WorldEntity
+  *  Definition of the basic WorldEntity
 */
 …
   virtual void command (Command* cmd);
   /** \returns the Count of Faces on this WorldEntity */
+  /** @returns the Count of Faces on this WorldEntity */
   virtual unsigned int getFaceCount () const { if (this->model) return this->model->getFaceCount(); else return 0; };

Context Navigation

Changeset 4836 in orxonox.OLD for orxonox/trunk/src

Legend: