Changeset 4836 for orxonox/trunk/src/lib – Orxonox

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)

Context Navigation

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

Legend:

Download in other formats: