Changeset 9869 for trunk/src/lib – Orxonox

trunk/src/lib/BuildLibs.am

-                      r9668
+                      r9869
 libORXlibs_a_LIBRARIES_ = \
-                $(LIB_PREFIX)/util/libORXlibutil.a \
-                $(LIB_PREFIX)/shell/libORXshell.a \
                 $(LIB_PREFIX)/event/libORXevent.a \
                 $(LIB_PREFIX)/gui/qt/libORXqtgui.a \
                 $(LIB_PREFIX)/gui/gl/libORXglgui.a \
                 $(LIB_PREFIX)/gui/libORXbasegui.a \
-                $(LIB_PREFIX)/script_engine/libORXscript.a \
-                $(LIB_PREFIX)/graphics/importer/libORXimporter.a \
                 $(LIB_PREFIX)/graphics/libORXgraphics.a \
-                $(LIB_PREFIX)/graphics/importer/libtc.a \
-                $(LIB_PREFIX)/sound/libORXsound.a \
-                $(LIB_PREFIX)/particles/libORXparticles.a \
                 $(LIB_PREFIX)/collision_detection/libORXcd.a \
                 $(LIB_PREFIX)/collision_reaction/libORXcr.a \
 …
                 $(LIB_PREFIX)/physics/libORXphysics.a \
                 $(LIB_PREFIX)/gui/gl/libORXglgui.a \
+                \
+                $(LIB_PREFIX)/graphics/importer/libORXimporter.a \
+                $(LIB_PREFIX)/graphics/importer/libtc.a \
+                $(LIB_PREFIX)/sound/libORXsound.a \
                 $(LIB_PREFIX)/shell/libORXshell.a \
+                $(LIB_PREFIX)/math/libORXmath.a \
+                $(LIB_PREFIX)/script_engine/libORXscript.a \
+                $(LIB_PREFIX)/util/libORXexecutor.a \
                 $(LIB_PREFIX)/util/libORXlibutil.a \
                 $(LIB_PREFIX)/lang/libORXlang.a \
+                $(LIB_PREFIX)/libORXlibs.a
+                $(LIB_PREFIX)/libORXlibs.a \
+                $(LIB_PREFIX)/math/libORXmath.a

trunk/src/lib/Makefile.am

-                      r9668
+                      r9869
         event \
         physics \
-        particles \
         collision_detection \
         collision_reaction \
         gui \
         network \
+        shell \
         parser \
-        shell \
         script_engine

trunk/src/lib/collision_detection/aabb.cc

-                      r9406
+                      r9869
+ObjectListDefinition(AABB);
 /**
  *  standard constructor
 …
 AABB::AABB ()
+{
    this->setClassID(CL_OBB, "AABB");
+  this->registerObject(this, AABB::_objectList);
    this->halfLength[0] = this->halfLength[1] = this->halfLength[2] = 0.0f;
    this->bCollided = false;

trunk/src/lib/collision_detection/aabb.h

-                      r8724
+                      r9869
 #include "bounding_volume.h"
-template<class T> class tList;
 //! A class representing an extended bounding volume tree: an obb tree
 class AABB : public BoundingVolume {
+  ObjectListDeclaration(AABB);
  public:

trunk/src/lib/collision_detection/aabb_tree_node.cc

-                      r9494
+                      r9869
 #include "debug.h"
 GLUquadricObj* AABBTreeNode_sphereObj = NULL;
+ObjectListDefinition(AABBTreeNode);
 /**
  *  standard constructor
 …
     : BVTreeNode()
+{
   this->setClassID(CL_OBB_TREE_NODE, "AABBTreeNode");
+  this->registerObject(this, AABBTreeNode::_objectList);
   this->obbTree = &tree;

trunk/src/lib/collision_detection/aabb_tree_node.h

r8724	r9869
21	21	class AABBTreeNode : public BVTreeNode
22	22	{
	23	ObjectListDeclaration(AABBTreeNode);
23	24
24	25

trunk/src/lib/collision_detection/bounding_sphere.cc

-                      r9406
+                      r9869
+ObjectListDefinition(BoundingSphere);
 /**
  *  standard constructor
 …
 BoundingSphere::BoundingSphere ()
+{
    this->setClassID(CL_BOUNDING_SPHERE, "BoundingSphere");
+  this->registerObject(this, BoundingSphere::_objectList);
+}

trunk/src/lib/collision_detection/bounding_sphere.h

-                      r5039
+                      r9869
 /*!
+/*!
  * @file bounding_sphere.h
   *  Definition of a bounding sphere
 …
 //! A class representing an extended bounding volume tree: an sphere
 class BoundingSphere : public BoundingVolume {
+  ObjectListDeclaration(BoundingSphere);
  public:

trunk/src/lib/collision_detection/bounding_volume.cc

-                      r9406
+                      r9869
+ObjectListDefinition(BoundingVolume);
 /**
  *  standard constructor
 …
 BoundingVolume::BoundingVolume ()
+{
   this->setClassID(CL_BOUNDING_VOLUME, "BoundingVolume");
+  this->registerObject(this, BoundingVolume::_objectList);
   this->modelInf = NULL;
   this->triangleIndexes = NULL;

trunk/src/lib/collision_detection/bounding_volume.h

r9008	r9869
17	17	//! An abstract class representing a bounding volume
18	18	class BoundingVolume : public BaseObject {
	19	ObjectListDeclaration(BoundingVolume);
19	20
20	21	public:

trunk/src/lib/collision_detection/bv_tree.cc

-                      r9406
+                      r9869
+ObjectListDefinition(BVTree);
 /**
  *  standard constructor
 …
 BVTree::BVTree ()
+{
    this->setClassID(CL_BV_TREE, "BVTree");
+  this->registerObject(this, BVTree::_objectList);
+}

trunk/src/lib/collision_detection/bv_tree.h

r7711	r9869
36	36	class BVTree : public BaseObject
37	37	{
	38	ObjectListDeclaration(BVTree);
38	39
39	40	public:

trunk/src/lib/collision_detection/bv_tree_node.cc

-                      r9406
+                      r9869
+ObjectListDefinition(BVTreeNode);
 /**
  *  standard constructor
 …
 BVTreeNode::BVTreeNode ()
+{
    this->setClassID(CL_BV_TREE_NODE, "BVTreeNode");
+  this->registerObject(this, BVTreeNode::_objectList);
+}

trunk/src/lib/collision_detection/bv_tree_node.h

r7732	r9869
24	24	//! A class that represents a bounding volume tree
25	25	class BVTreeNode : public BaseObject {
	26	ObjectListDeclaration(BVTreeNode);
26	27
27	28

trunk/src/lib/collision_detection/cd_engine.cc

-                      r9406
+                      r9869
 #include "debug.h"
-#include "class_list.h"
 #include "model.h"
 #include "world_entity.h"
 …
+ObjectListDefinition(CDEngine);
 /**
  *  standard constructor
+ * @brief standard constructor
  */
 CDEngine::CDEngine ()
+{
   this->setClassID(CL_CD_ENGINE, "CDEngine");
+  this->registerObject(this, CDEngine::_objectList);
   this->bAbordOnFirstCollision = false;
 …
 void CDEngine::checkCollisionGround(std::list<WorldEntity*>& list1)
+{
-  std::list<BaseObject*>::const_iterator bspIterator;
   std::list<WorldEntity*>::iterator entityIterator;
-  const std::list<BaseObject*>* bspList = ClassList::getList(CL_BSP_ENTITY);
-  if( bspList == NULL)
-    return;
   // for all bsp managers check all entities
+  for( bspIterator = bspList->begin(); bspIterator != bspList->end(); bspIterator++) {
+  for( ObjectList<BspEntity>::const_iterator bspIterator = BspEntity::objectList().begin();
+       bspIterator != BspEntity::objectList().end();
+       bspIterator++) {
       for(entityIterator = list1.begin(); entityIterator != list1.end(); entityIterator++)
+      {

trunk/src/lib/collision_detection/cd_engine.h

r8186	r9869
36	36	//! The class representing the collision detection system of orxonox
37	37	class CDEngine : public BaseObject {
	38	ObjectListDeclaration(CDEngine);
38	39
39	40	friend class WorldEntity;

trunk/src/lib/collision_detection/obb.cc

-                      r9406
+                      r9869
+ObjectListDefinition(OBB);
 /**
  *  standard constructor
 …
 OBB::OBB ()
+{
    this->setClassID(CL_OBB, "OBB");
+  this->registerObject(this, OBB::_objectList);
    this->halfLength[0] = this->halfLength[1] = this->halfLength[2] = 0.0f;
    this->bCollided = false;

trunk/src/lib/collision_detection/obb.h

r7711	r9869
15	15	//! A class representing an extended bounding volume tree: an obb tree
16	16	class OBB : public BoundingVolume {
	17	ObjectListDeclaration(OBB);
17	18
18	19	public:

trunk/src/lib/collision_detection/obb_tree.cc

-                      r9406
+                      r9869
+ObjectListDefinition(OBBTree);
 /**
  *  standard constructor
 …
 void OBBTree::init()
+{
   this->setClassID(CL_OBB_TREE, "OBBTree");
+  this->registerObject(this, OBBTree::_objectList);
   this->rootNode = NULL;
   this->id = 0;

trunk/src/lib/collision_detection/obb_tree.h

r9235	r9869
20	20	class OBBTree : public BVTree
21	21	{
	22	ObjectListDeclaration(OBBTree);
22	23
23	24	public:

trunk/src/lib/collision_detection/obb_tree_node.cc

-                      r9406
+                      r9869
 GLUquadricObj* OBBTreeNode_sphereObj = NULL;
+ObjectListDefinition(OBBTreeNode);
 /**
  *  standard constructor
 …
     : BVTreeNode()
+{
   this->setClassID(CL_OBB_TREE_NODE, "OBBTreeNode");
+  this->registerObject(this, OBBTreeNode::_objectList);
   this->obbTree = &tree;
 …
 /**
  *  calculate the eigenvectors for the object oriented box
+ * @brief calculate the eigenvectors for the object oriented box
  * @param box: reference to the box
  * @param modelInf: the model info structure of the model
 …
 /**
  *  this separates an ob-box in the middle
+ * @brief this separates an ob-box in the middle
  * @param box: the box to separate
+ *

trunk/src/lib/collision_detection/obb_tree_node.h

-                      r9235
+                      r9869
 class PNode;
 //! A class that represents a bounding volume tree
 class OBBTreeNode : public BVTreeNode
+{
+  ObjectListDeclaration(OBBTreeNode);
   public:
     OBBTreeNode(const OBBTree& tree, OBBTreeNode* prev, int depth);

trunk/src/lib/collision_reaction/collision.cc

-                      r9406
+                      r9869
 #include "collision.h"
 #include "debug.h"
 /**

trunk/src/lib/collision_reaction/collision.h

r8490	r9869
21	21	class Collision
22	22	{
23
24	23	public:
25	24	Collision();

trunk/src/lib/collision_reaction/collision_event.cc

-                      r9406
+                      r9869
 #include "collision_event.h"
 #include "debug.h"
 /**

trunk/src/lib/collision_reaction/collision_event.h

r8894	r9869
20	20	//! A class representing a simple collision
21	21	class CollisionEvent {
22
23	22	public:
24	23	CollisionEvent();

trunk/src/lib/collision_reaction/collision_handle.cc

-                      r9406
+                      r9869
+ObjectListDefinition(CollisionHandle);
 /**
 …
 CollisionHandle::CollisionHandle (WorldEntity* owner, CREngine::CRType type)
+{
   this->setClassID(CL_COLLISION_HANDLE, "CollisionHandle");
+  this->registerObject(this, CollisionHandle::_objectList);
   this->owner = owner;
 …
  *  @param classID the classid to look for
  */
 void CollisionHandle::addTarget(long target)
+void CollisionHandle::addTarget(const ClassID& target)
+{
   // make sure there is no dublicate
   std::vector<long>::iterator it = this->targetList.begin();
+  std::vector<ClassID>::iterator it = this->targetList.begin();
   for( ; it < this->targetList.end(); it++)
     if( (*it) == target)
       return;
   // add element
+   PRINTF(5)("addTarget: %i \n", target);
+   this->targetList.push_back(target);
+  this->targetList.push_back(target);
+   PRINTF(5)("addTarget: %i \n", target.id());
+}
 …
 bool CollisionHandle::filterCollisionEvent(CollisionEvent* collisionEvent)
+{
   std::vector<long>::iterator it = this->targetList.begin();
+  std::vector<ClassID>::iterator it = this->targetList.begin();
   for(; it < this->targetList.end(); it++)
+  {
 …
     if( collisionEvent->getEntityA() == this->owner) {
       if( collisionEvent->getEntityB()->isA((ClassID)(*it))) {
+      if( collisionEvent->getEntityB()->isA((*it))) {
         PRINTF(5)("I am: %s colliding with: %s is a %i filter ok\n", owner->getClassCName(),
                   collisionEvent->getEntityB()->getClassCName(), *it);
+        collisionEvent->getEntityB()->getClassCName(), (*it).id());
         return true; }
+    }
     else {
       if( collisionEvent->getEntityA()->isA((ClassID)(*it))) {
+      if( collisionEvent->getEntityA()->isA((*it))) {
         PRINTF(5)("I am: %s colliding with: %s is a %i filter ok\n", owner->getClassCName(),
                   collisionEvent->getEntityA()->getClassCName(), *it);
+        collisionEvent->getEntityA()->getClassCName(), (*it).id());
       return true; }
+    }
 …
 bool CollisionHandle::filterCollision(Collision* collision)
+{
   std::vector<long>::iterator it = this->targetList.begin();
+  std::vector<ClassID>::iterator it = this->targetList.begin();
   for(; it < this->targetList.end(); it++)
+  {
 …
     if( collision->getEntityA() == this->owner) {
       if( collision->getEntityA()->isA((ClassID)(*it)))
+      if( collision->getEntityA()->isA(*it))
         return true; }
       else {
         if( collision->getEntityB()->isA((ClassID)(*it)))
+        if( collision->getEntityB()->isA(*it))
           return true; }
+  }

trunk/src/lib/collision_reaction/collision_handle.h

-                      r8490
+                      r9869
 class CollisionHandle : public BaseObject
+{
+  ObjectListDeclaration(CollisionHandle);
   public:
     CollisionHandle(WorldEntity* owner, CREngine::CRType type);
 …
     void reset();
     void addTarget(long target);
+    void addTarget(const ClassID& target);
     Collision* registerCollision(WorldEntity* entityA, WorldEntity* entityB);
     void registerSharedCollision(Collision* collision);
 …
     std::vector<Collision*>       collisionList;           //!< a list full of collisions
+    std::vector<long>             targetList;              //!< a list of target classes for filtering
+    /// TODO Take a std::set here!
+    std::vector<ClassID>          targetList;              //!< a list of target classes for filtering @TODO TAKE SET INSTEAD OF VECTOR HERE
     CollisionReaction*            collisionReaction;       //!< reference to the collision reaction object

trunk/src/lib/collision_reaction/collision_reaction.cc

r9406	r9869
20	20
21	21
22
	22	ObjectListDefinition(CollisionReaction);
23	23
24	24	/**
…	…
28	28	: BaseObject()
29	29	{
30		this->~~setClassID(CL_COLLISION_REACTION, "CollisionReaction"~~);
	30	this->registerObject(this, CollisionReaction::_objectList);
31	31	}
32	32

trunk/src/lib/collision_reaction/collision_reaction.h

r8490	r9869
18	18	class CollisionReaction : public BaseObject
19	19	{
20
	20	ObjectListDeclaration(CollisionReaction);
21	21	public:
22	22	CollisionReaction();

trunk/src/lib/collision_reaction/cr_engine.cc

-                      r9406
+                      r9869
+ObjectListDefinition(CREngine);
 /**
  * standard constructor
 …
   : BaseObject()
+{
    this->setClassID(CL_CR_ENGINE, "CREngine");
+  this->registerObject(this, CREngine::_objectList);
    this->setName("CREngine");

trunk/src/lib/collision_reaction/cr_engine.h

r9235	r9869
25	25	class CREngine : public BaseObject
26	26	{
	27	ObjectListDeclaration(CREngine);
27	28
28	29	public:

trunk/src/lib/collision_reaction/cr_object_damage.cc

-                      r9406
+                      r9869
+ObjectListDefinition(CRObjectDamage);
 /**
  *  standard constructor
 …
   : CollisionReaction()
+{
+  this->setClassID(CL_CR_OBJECT_DAMAGE, "CRObjectDamage");
+  this->registerObject(this, CRObjectDamage::_objectList);
+}

trunk/src/lib/collision_reaction/cr_object_damage.h

r8190	r9869
15	15	class CRObjectDamage : public CollisionReaction
16	16	{
	17	ObjectListDeclaration(CRObjectDamage);
17	18	public:
18	19	CRObjectDamage();

trunk/src/lib/collision_reaction/cr_physics_full_walk.cc

-                      r9406
+                      r9869
+ObjectListDefinition(CRPhysicsFullWalk);
 /**
  *  standard constructor
 …
     : CollisionReaction()
+{
   this->setClassID(CL_CR_PHYSICS_FULL_WALK, "CRPhysicsFullWalk");
+  this->registerObject(this, CRPhysicsFullWalk::_objectList);
+}

trunk/src/lib/collision_reaction/cr_physics_full_walk.h

r9235	r9869
15	15	class CRPhysicsFullWalk : public CollisionReaction
16	16	{
	17	ObjectListDeclaration(CRPhysicsFullWalk);
17	18	public:
18	19	CRPhysicsFullWalk();

trunk/src/lib/collision_reaction/cr_physics_ground_walk.cc

-                      r9406
+                      r9869
+ObjectListDefinition(CRPhysicsGroundWalk);
 /**
  *  standard constructor
 …
     : CollisionReaction()
+{
   this->setClassID(CL_CR_PHYSICS_GROUND_WALK, "CRPhysicsGroundWalk");
+  this->registerObject(this, CRPhysicsGroundWalk::_objectList);
+}

trunk/src/lib/collision_reaction/cr_physics_ground_walk.h

r8894	r9869
15	15	class CRPhysicsGroundWalk : public CollisionReaction
16	16	{
	17	ObjectListDeclaration(CRPhysicsGroundWalk);
17	18	public:
18	19	CRPhysicsGroundWalk();

trunk/src/lib/coord/p_node.cc

-                      r9656
+                      r9869
 #include "util/loading/load_param.h"
-#include "class_list.h"
 #include "netdefs.h"
 …
 #include "color.h"
+ObjectListDefinition(PNode);
 /**
  * @brief standard constructor
 …
   : BaseObject(), Synchronizeable()
+{
   this->setClassID(CL_PARENT_NODE, "PNode");
+  this->registerObject(this, PNode::_objectList);
   this->bRelCoorChanged = true;
 …
   PRINTF(4)("delete %s::%s\n", this->getClassCName(), this->getCName());
   // remove the Node, delete it's children (if required).
+  std::list<PNode*>::iterator deleteNode;
+  unsigned int size;
+  PNode* last = NULL;
+  //this->debugNode(0);
   while(!this->children.empty())
+  {
+    deleteNode = this->children.begin();
+    size = this->children.size();
+    PNode* deleteNode = this->children.front();
+    if (deleteNode == last)
+    {
+      PRINTF(1)("Node same as last that was tried to be deleted. FORCE reparent to NULL of %p\n", deleteNode);
+      (deleteNode->setParent( NULL));
+      continue;
+    }
     if ((this->parentMode & PNODE_PROHIBIT_CHILD_DELETE) ||
         ((*deleteNode)->parentMode & PNODE_PROHIBIT_DELETE_WITH_PARENT))
+        (deleteNode->parentMode & PNODE_PROHIBIT_DELETE_WITH_PARENT))
+    {
       if (this == PNode::nullParent && (*deleteNode)->parentMode & PNODE_REPARENT_TO_NULL)
+      if (this == PNode::nullParent && deleteNode->parentMode & PNODE_REPARENT_TO_NULL)
+      {
         PRINTF(4)("%s::%s deletes %s::%s\n",
                   this->getClassCName(), this->getCName(),
                   (*deleteNode)->getClassCName(), (*deleteNode)->getCName());
         delete (*deleteNode);
+                  deleteNode->getClassCName(), deleteNode->getCName());
+        delete deleteNode;
+      }
       else
 …
         PRINTF(4)("%s::%s reparents %s::%s\n",
                   this->getClassCName(), this->getCName(),
                   (*deleteNode)->getClassCName(), (*deleteNode)->getCName());
         (*deleteNode)->reparent();
+                  deleteNode->getClassCName(), deleteNode->getCName());
+        deleteNode->reparent();
+      }
+    }
 …
       PRINTF(4)("%s::%s deletes PNode: %s::%s\n",
                 this->getClassCName(), this->getCName(),
                 (*deleteNode)->getClassCName(), (*deleteNode)->getCName());
       delete (*deleteNode);
+                deleteNode->getClassCName(), deleteNode->getCName());
+      delete deleteNode;
+    }
+    last = deleteNode;
+  }
 …
 void PNode::addChild (const std::string& childName)
+{
   PNode* childNode = dynamic_cast<PNode*>(ClassList::getObject(childName, CL_PARENT_NODE));
+  PNode* childNode = PNode::objectList().getObject(childName);
   //  PRINTF(0)("Adding the Child: %s to: %s\n", childName, this->getName());
   //  assert( childNode != NULL );
 …
 void PNode::setParent (const std::string& parentName)
+{
   PNode* parentNode = dynamic_cast<PNode*>(ClassList::getObject(parentName, CL_PARENT_NODE));
+  PNode* parentNode = PNode::objectList().getObject(parentName);
   if (parentNode != NULL)
     parentNode->addChild(this);
 …
 void PNode::setParentSoft(const std::string& parentName, float bias)
+{
   PNode* parentNode = dynamic_cast<PNode*>(ClassList::getObject(parentName, CL_PARENT_NODE));
+  PNode* parentNode = PNode::objectList().getObject(parentName);
   if (parentNode != NULL)
     this->setParentSoft(parentNode, bias);
 …
   if (likely(PNode::nullParent == NULL))
+  {
     PNode::nullParent = new PNode(NULL, PNODE_PARENT_MODE_DEFAULT | PNODE_REPARENT_TO_NULL);
     PNode::nullParent->setClassID(CL_NULL_PARENT, "NullParent");
+    PNode::nullParent = new NullParent();
+    //PNode::nullParent->registerObject(, CL_NULL_PARENT);
     PNode::nullParent->setName("NullParent");
     PNode::nullParent->setSynchronized(true);
 …
   int childNodeCount = 0;
   this->countChildNodes(childNodeCount);
+  printf("%p:", this);
   PRINT(0)("PNode(%s::%s) - absCoord: (%0.2f, %0.2f, %0.2f), relCoord(%0.2f, %0.2f, %0.2f), direction(%0.2f, %0.2f, %0.2f) - %s - %d childs\n",
            this->getClassCName(),
 …
+}
+ObjectListDefinition(NullParent);
+NullParent::NullParent()
+  : PNode(NULL, PNODE_PARENT_MODE_DEFAULT | PNODE_REPARENT_TO_NULL)
+{
+  this->registerObject(this, NullParent::_objectList);
+}

trunk/src/lib/coord/p_node.h

-                      r9406
+                      r9869
   PNODE_REPARENT_DELETE_CHILDREN       = 0x0040,    //!< Deletes the Children of the node when This Node is Removed. (Use with care).
   /// FIXME
    PNODE_REPARENT_KEEP_POSITION         = 0x0080,    //!< Tries to keep the Position if the Node is reparented.
+  PNODE_REPARENT_KEEP_POSITION         = 0x0080,    //!< Tries to keep the Position if the Node is reparented.
 …
 //! Patent Node is a Engine to calculate the position of an Object in respect to the position of its parent.
+class PNode : virtual public BaseObject, virtual public Synchronizeable {
+ public:
+class PNode : virtual public BaseObject, virtual public Synchronizeable
+{
+  ObjectListDeclaration(PNode);
+public:
   PNode (PNode* parent = PNode::getNullParent(), long nodeFlags = PNODE_PARENT_MODE_DEFAULT);
   virtual ~PNode ();
 …
   inline const Vector& getRelCoor () const { return this->prevRelCoordinate; };
   /** @returns the Relative Coordinate Destination */
   inline const Vector& getRelCoorSoft2D() const { return (this->toCoordinate)? *this->toCoordinate : this->relCoordinate; };
+inline const Vector& getRelCoorSoft2D() const { return (this->toCoordinate)? *this->toCoordinate : this->relCoordinate; };
   void setAbsCoor (const Vector& absCoord);
   void setAbsCoor (float x, float y, float z);
 …
   inline const Quaternion& getRelDir () const { return this->prevRelDirection; };
   /** @returns the Relative Directional Destination */
   inline const Quaternion& getRelDirSoft2D() const { return (this->toDirection)? *this->toDirection : this->relDirection; };
+inline const Quaternion& getRelDirSoft2D() const { return (this->toDirection)? *this->toDirection : this->relDirection; };
   /** @returns a Vector pointing into the relative Direction */
   inline Vector getRelDirV() const { return this->prevRelDirection.apply(Vector(0,1,0)); };
 …
   void removeNodeFlags(unsigned short nodeFlags);
-  // NULL_PARENT //
   /** @returns the NullParent, the (main) ROOT of the PNode Tree. If it does not yet exist, it will be created. */
   static PNode* getNullParent()  { return (PNode::nullParent != NULL)? PNode::nullParent : PNode::createNullParent(); };
+static PNode* getNullParent()  { return (PNode::nullParent != NULL) ? PNode::nullParent : PNode::createNullParent(); };
   // UPDATING //
 …
   float distance(const PNode* node) const { return (this->getAbsCoor() - node->getAbsCoor()).len(); };
  private:
+private:
   /** tells the child that the parent's Coordinate has changed */
   inline void parentCoorChanged () { this->bRelCoorChanged = true; }
   /** tells the child that the parent's Direction has changed */
   inline void parentDirChanged () { this->bRelDirChanged = true; }
  public:
+public:
   /** @returns the last calculated coordinate */
   inline Vector getLastAbsCoor() { return this->lastAbsCoordinate; }
  private:
+private:
   static PNode* createNullParent();
   void reparent();
 …
   void eraseChild(PNode* child);
  private:
+private:
   bool               bRelCoorChanged;    //!< If Relative Coordinate has changed since last time we checked
   bool               bRelDirChanged;     //!< If Relative Direction has changed since last time we checked
 …
   Vector             lastAbsCoordinate;  //!< this is used for speedcalculation, it stores the last coordinate
   Quaternion         prevRelDirection;   //!< The last Relative Direciton from the last update-Cycle.
 //  Quaternion         lastAbsDirection;
+  //  Quaternion         lastAbsDirection;
   Vector             velocity;           //!< Saves the velocity.
 …
   static PNode*      nullParent;         //!< The ROOT of the main PNode Tree.
   private:
     float coorx;
     float coory;
     float coorz;
     float rotw;
     float rotx;
     float roty;
     float rotz;
   private:
     int relCoordinate_handle;
     int relDirection_handle;
     Vector relCoordinate_write;
     Quaternion relDirection_write;
   public:
     virtual void varChangeHandler( std::list<int> & id );
+private:
+  float coorx;
+  float coory;
+  float coorz;
+  float rotw;
+  float rotx;
+  float roty;
+  float rotz;
+private:
+  int relCoordinate_handle;
+  int relDirection_handle;
+  Vector relCoordinate_write;
+  Quaternion relDirection_write;
+public:
+  virtual void varChangeHandler( std::list<int> & id );
 };
+// NULL_PARENT //
+class NullParent : public PNode
+{
+  ObjectListDeclaration(NullParent);
+  friend class PNode;
+  NullParent();
+};
 #endif /* _P_NODE_H */

trunk/src/lib/event/event_handler.cc

-                      r9656
+                      r9869
 #include <algorithm>
+ObjectListDefinition(EventHandler);
 /**
  * @brief standard constructor
 …
 EventHandler::EventHandler ()
+{
   this->setClassID(CL_EVENT_HANDLER, "EventHandler");
+  this->registerObject(this, EventHandler::_objectList);
   this->setName("EventHandler");

trunk/src/lib/event/event_handler.h

r8743	r9869
21	21	class EventHandler : public BaseObject
22	22	{
23
	23	ObjectListDeclaration(EventHandler);
24	24	public:
25	25	virtual ~EventHandler();

trunk/src/lib/event/event_listener.cc

-                      r7868
+                      r9869
 #include "event_handler.h"
+ObjectListDefinition(EventListener);
 /**
  * @brief standard constructor
 …
 EventListener::EventListener ()
+{
   this->setClassID(CL_EVENT_LISTENER, "EventListener");
+  this->registerObject(this, EventListener::_objectList);
+}

trunk/src/lib/event/event_listener.h

-                      r7868
+                      r9869
 //! A class for event listener
+class EventListener : virtual public BaseObject {
+ public:
+class EventListener : virtual public BaseObject
+{
+  ObjectListDeclaration(EventListener);
+public:
   EventListener();
   virtual ~EventListener();

trunk/src/lib/event/key_mapper.cc

-                      r9406
+                      r9869
 #include "globals.h"
 #include "parser/ini_parser/ini_parser.h"
 #include "util/preferences.h"
+#include "parser/preferences/preferences.h"
 #include "key_names.h"
 #include "event_def.h"
 …
+ObjectListDefinition(KeyMapper);
 /* initialize all variables to a reasonable value*/
 …
 KeyMapper::KeyMapper ()
+{
    this->setClassID(CL_KEY_MAPPER, "KeyMapper");
+  this->registerObject(this, KeyMapper::_objectList);
+}

trunk/src/lib/event/key_mapper.h

r8724	r9869
16	16	class KeyMapper : public BaseObject
17	17	{
	18	ObjectListDeclaration(KeyMapper);
18	19	public:
19	20	//! A mapping from key-name to key-id

trunk/src/lib/graphics/Makefile.am

-                      r9006
+                      r9869
 libORXgraphics_a_SOURCES = \
                 graphics_engine.cc \
+                graphics_effect.cc \
                 light.cc \
                 shader.cc \
+                shader_data.cc \
+                resource_shader.cc \
+                \
                 render2D/render_2d.cc \
 …
                 text_engine/font.cc \
                 text_engine/font_data.cc \
+                \
+                effects/graphics_effect.cc \
+                effects/atmospheric_engine.cc \
+                effects/weather_effect.cc \
+                effects/sun_effect.cc \
+                effects/fog_effect.cc \
+                effects/volfog_effect.cc \
+                effects/rain_effect.cc \
+                effects/snow_effect.cc \
+                effects/cloud_effect.cc \
+                effects/lightning_effect.cc \
+                effects/lense_flare.cc
+                text_engine/resource_font.cc
 noinst_HEADERS =\
                 graphics_engine.h \
+                graphics_effect.h \
                 light.h \
                 shader.h \
+                shader_data.h \
+                resource_shader.h \
+                \
                 render2D/render_2d.h \
 …
                 text_engine/font.h \
                 text_engine/font_data.h \
+                text_engine/default_font.xpm \
+                \
+                effects/graphics_effect.h \
+                effects/atmospheric_engine.h \
+                effects/weather_effect.h \
+                effects/sun_effect.h \
+                effects/fog_effect.h \
+                effects/volfog_effect.h \
+                effects/rain_effect.h \
+                effects/snow_effect.h \
+                effects/cloud_effect.h \
+                effects/lightning_effect.h \
+                effects/lense_flare.h
+                text_engine/resource_font.h \
+                text_engine/default_font.xpm

trunk/src/lib/graphics/graphics_engine.cc

-                      r9406
+                      r9869
 #include "graphics_engine.h"
-#include "util/loading/resource_manager.h"
 #include "state.h"
 …
 #include "debug.h"
 #include "util/preferences.h"
+#include "parser/preferences/preferences.h"
 #include "substring.h"
 #include "text.h"
 …
 #include "texture.h"
+#include "effects/graphics_effect.h"
+#include "effects/fog_effect.h"
+#include "effects/lense_flare.h"
+#include "graphics_effect.h"
 #include "shell_command.h"
+#include "loading/load_param_xml.h"
 #include "parser/tinyxml/tinyxml.h"
 #include "util/loading/load_param.h"
 #include "util/loading/factory.h"
-#include "class_list.h"
 #ifdef __WIN32__
 …
 SHELL_COMMAND(fps, GraphicsEngine, toggleFPSdisplay);
+ObjectListDefinition(GraphicsEngine);
 /**
  * @brief standard constructor
 …
 GraphicsEngine::GraphicsEngine ()
+{
   this->setClassID(CL_GRAPHICS_ENGINE, "GraphicsEngine");
+  this->registerObject(this, GraphicsEngine::_objectList);
   this->setName("GraphicsEngine");
 …
+{
   LoadParamXML(root, "GraphicsEffect", this, GraphicsEngine, loadGraphicsEffects)
   .describe("loads a graphics effect");
+   .describe("loads a graphics effect");
+}
 …
   // tick the graphics effects
+  if (this->graphicsEffects != NULL || (this->graphicsEffects = ClassList::getList(CL_GRAPHICS_EFFECT)) != NULL)
+  {
+    std::list<BaseObject*>::const_iterator it;
+    for (it = this->graphicsEffects->begin(); it != this->graphicsEffects->end(); it++)
+      dynamic_cast<GraphicsEffect*>(*it)->tick(dt);
+  }
+  for (ObjectList<GraphicsEffect>::const_iterator it = GraphicsEffect::objectList().begin();
+       it != GraphicsEffect::objectList().end();
+       ++it)
+    (*it)->tick(dt);
+}
 …
+  {
     case EV_VIDEO_RESIZE:
       this->resolutionChanged(event.resize);
       break;
+  }
+}
+    this->resolutionChanged(event.resize);
+    break;
+  }
+}

trunk/src/lib/graphics/graphics_engine.h

r9406	r9869
30	30	class GraphicsEngine : public EventListener
31	31	{
	32	ObjectListDeclaration(GraphicsEngine);
32	33	public:
33	34	virtual ~GraphicsEngine();

trunk/src/lib/graphics/importer/Makefile.am

-                      r8724
+                      r9869
 noinst_LIBRARIES = libORXimporter.a libtc.a
+libORXimporter_a_SOURCES = model.cc \
+                           interactive_model.cc \
+                           md_model_structure.cc \
+                           vertex_array_model.cc \
+                           grid.cc \
+                           static_model.cc \
+                           objModel.cc \
+                           primitive_model.cc \
+                           height_map.cc \
+                           bsp_manager.cc \
+                           bsp_file.cc \
+                           bsp_tree_node.cc \
+                           bsp_tree_leaf.cc \
+                           \
+                           material.cc \
+                           texture.cc \
+                           texture_data.cc \
+                           texture_sequence.cc \
+                           media_container.cc \
+                           movie_player.cc \
+                           \
+                           bsp_manager.cc \
+                           bsp_file.cc \
+                           bsp_tree_node.cc \
+                           bsp_tree_leaf.cc \
+                           \
+                           md2/md2Model.cc \
+                           \
+                           md3/md3_model.cc \
+                           md3/md3_animation.cc \
+                           md3/md3_animation_cfg.cc \
+                           md3/md3_bone_frame.cc \
+                           md3/md3_mesh.cc \
+                           md3/md3_data.cc \
+                           md3/md3_tag.cc
+libORXimporter_a_SOURCES = \
+                model.cc \
+                interactive_model.cc \
+                md_model_structure.cc \
+                vertex_array_model.cc \
+                grid.cc \
+                static_model.cc \
+                static_model_data.cc \
+                objModel.cc \
+                resource_obj.cc \
+                primitive_model.cc \
+                height_map.cc \
+                bsp_manager.cc \
+                bsp_file.cc \
+                bsp_tree_node.cc \
+                bsp_tree_leaf.cc \
+                \
+                material.cc \
+                texture.cc \
+                texture_data.cc \
+                resource_texture.cc \
+                texture_sequence.cc \
+                media_container.cc \
+                movie_player.cc \
+                \
+                bsp_manager.cc \
+                bsp_file.cc \
+                bsp_tree_node.cc \
+                bsp_tree_leaf.cc \
+                \
+                md2/md2Model.cc \
+                md2/resource_md2.cc
+#               \
+                md3/md3_model.cc \
+                md3/md3_animation.cc \
+                md3/md3_animation_cfg.cc \
+                md3/md3_bone_frame.cc \
+                md3/md3_mesh.cc \
+                md3/md3_data.cc \
+                md3/md3_tag.cc
 …
                 grid.h \
                 static_model.h \
+                static_model_data.h \
                 objModel.h \
+                resource_obj.h \
                 primitive_model.h \
                 anorms.h \
 …
                 texture.h \
                 texture_data.h \
+                resource_texture.h \
                 texture_sequence.h \
+                \
 …
+                \
                 md2/md2Model.h \
+                md2/resource_md2.h \
+                \
                 md3/md3_model.h \

trunk/src/lib/graphics/importer/bsp_file.cc

-                      r9406
+                      r9869
     PRINTF(4)("BSP FILE: Name %s . \n", fileName);
     absFileName = ResourceManager::getFullName(fileName);
+    absFileName = Resources::ResourceManager::getInstance()->prependAbsoluteMainPath(fileName);
     if(File(absFileName).exists()) {
 …
     strncat (fileName, ext, strlen(fileName));
     absFileName = ResourceManager::getFullName(fileName);
+    absFileName = Resources::ResourceManager::getInstance()->prependAbsoluteMainPath(fileName);
     if(File(absFileName).exists()) {
 …
     strncat (fileName, ext, strlen(fileName));
     absFileName = ResourceManager::getFullName(fileName);
+    absFileName = Resources::ResourceManager::getInstance()->prependAbsoluteMainPath(fileName);
     if(File(absFileName).exists()) {
 …
     strncat (fileName, ext, strlen(fileName));
     absFileName = ResourceManager::getFullName(fileName);
+    absFileName = Resources::ResourceManager::getInstance()->prependAbsoluteMainPath(fileName);
     if(File(absFileName).exists()) {
 …
     strcpy(ext, ".TGA");
     strncat (fileName, ext, strlen(fileName));
     absFileName = ResourceManager::getFullName(fileName);
+    absFileName = Resources::ResourceManager::getInstance()->prependAbsoluteMainPath(fileName);
     if(File(absFileName).exists()/*stat( absFileName.c_str() , &results) == 0*/) {
 …
     strcpy(ext, ".jpg");
     strncat (fileName, ext, strlen(fileName));
     absFileName = ResourceManager::getFullName(fileName);
+    absFileName = Resources::ResourceManager::getInstance()->prependAbsoluteMainPath(fileName);
     if(File(absFileName).exists()) {
       PRINTF(4)("BSP FILE: gefunden . \n");
 …
     strcpy(ext, ".JPG");
     strncat (fileName, ext, strlen(fileName));
     absFileName = ResourceManager::getFullName(fileName);
+    absFileName = Resources::ResourceManager::getInstance()->prependAbsoluteMainPath(fileName);
     if(File(absFileName).exists()) {
       PRINTF(4)("BSP FILE: gefunden . \n");
 …
     strcpy(ext, ".bmp");
     strncat (fileName, ext, strlen(fileName));
     absFileName = ResourceManager::getFullName(fileName);
+    absFileName = Resources::ResourceManager::getInstance()->prependAbsoluteMainPath(fileName);
     if(File(absFileName).exists()) {
 …
     strcpy(ext, ".BMP");
     strncat (fileName, ext, strlen(fileName));
     absFileName = ResourceManager::getFullName(fileName);
+    absFileName = Resources::ResourceManager::getInstance()->prependAbsoluteMainPath(fileName);
     if(File(absFileName).exists()) {
 …
   this->testSurf = NULL;
   this->testSurf = IMG_Load(ResourceManager::getFullName(mat).c_str());
+  this->testSurf = IMG_Load(Resources::ResourceManager::getInstance()->prependAbsoluteMainPath(mat).c_str());
   if(this->testSurf != NULL) {
     if(this->testSurf->format->Amask != 0 ) tmpAMat.alpha = true;

trunk/src/lib/graphics/importer/bsp_manager.cc

-                      r9235
+                      r9869
 #include "world_entities/player.h"
 #include "world_entities/playable.h"
+#include "util/loading/resource_manager.h"
 // STL Containers
 #include <vector>
 …
 #include "world_entity.h"
+#include "util/loading/resource_manager.h"
 #include "util/loading/load_param.h"
 #include "util/loading/factory.h"
 …
   this->bspFile = new BspFile();
   this->bspFile->scale =  scale;
   if(this->bspFile->read(ResourceManager::getFullName(fileName).c_str()) == -1)
+  if(this->bspFile->read(Resources::ResourceManager::getInstance()->prependAbsoluteMainPath(fileName).c_str()) == -1)
     return -1;
 …
     if( this->outputFraction == 1.0f) // No collision Detected
+    {
       if( this->outputAllSolid )
+      if( this->outputAllSolid )
+      {
         this->collPlane = new plane;

trunk/src/lib/graphics/importer/height_map.cc

-                      r8316
+                      r9869
 #include "p_node.h"
 #include "state.h"
-#include "util/loading/resource_manager.h"
 #include "debug.h"
 …
+ObjectListDefinition(HeightMap);
 …
 void HeightMap::init(const std::string& heightMapName)
+{
   this->setClassID(CL_HEIGHT_MAP, "HeightMap");
+  this->registerObject(this, HeightMap::_objectList);
   this->shiftX = 0;

trunk/src/lib/graphics/importer/height_map.h

-                      r7526
+                      r9869
 class SDL_Surface;
-class Vector;
 class Material;
-class PNode;
 class Texture;
 class HeightMap;
 …
 //!< the height map representation itself
 class HeightMap : public VertexArrayModel
+{
+  ObjectListDeclaration(HeightMap);
   friend class Tile;

trunk/src/lib/graphics/importer/interactive_model.cc

-                      r9406
+                      r9869
+ObjectListDefinition(InteractiveModel);
 /**
  * standard constructor
 …
 InteractiveModel::InteractiveModel()
+{
   this->setClassID(CL_INTERACTIVE_MODEL, "InteractiveModel");
+  this->registerObject(this, InteractiveModel::_objectList);
+}

trunk/src/lib/graphics/importer/interactive_model.h

-                      r9003
+                      r9869
 class InteractiveModel : public Model
+{
+  ObjectListDeclaration(InteractiveModel);
   public:
     InteractiveModel();
 …
     virtual void setAnimation(int animNum, int playbackMode = 0) = 0;
     virtual void setAnimation(int firstFrame, int lastFrame, int fps, int bStoppable, int animPlayback) {}
     virtual int getAnimation() = 0;
+    virtual int getAnimation() const = 0;
     virtual bool isAnimationFinished() { return false; }

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

-                      r9406
+                      r9869
 #include "loading/load_param.h"
+#include "util/loading/resource_manager.h"
+#include "resource_texture.h"
+ObjectListDefinition(Material);
 /**
 …
 Material::Material (const std::string& mtlName)
+{
   this->setClassID(CL_MATERIAL, "Material");
+  this->registerObject(this, Material::_objectList);
   this->setIllum(3);
 …
   PRINTF(5)("delete Material %s.\n", this->getCName());
-  if (this->ambientTexture != NULL)
-    ResourceManager::getInstance()->unload(this->ambientTexture);
-  if (this->specularTexture != NULL)
-    ResourceManager::getInstance()->unload(this->specularTexture);
   if (this == Material::selectedMaterial)
     Material::selectedMaterial = NULL;
 …
 const Material* Material::selectedMaterial = NULL;
-/// TODO FIX THIS
-// Material& Material::operator=(const Material& m)
-// {
-//   this->setIllum(m.illumModel);
-//   this->setDiffuse(m.diffuse[0],m.diffuse[1],m.diffuse[2]);
-//   this->setAmbient(m.ambient[0],m.ambient[1],m.ambient[2]);
-//   this->setSpecular(m.specular[0],m.specular[1],m.specular[2]);
-//   this->setShininess(m.shininess);
-//   this->setTransparency(m.transparency);
-//
-//   if (this->diffuseTexture != NULL)
-//     ResourceManager::getInstance()->unload(this->diffuseTexture);
-//   if (m.diffuseTexture != NULL)
-//     this->diffuseTexture = (Texture*)ResourceManager::getInstance()->copy(m.diffuseTexture);
-//   this->ambientTexture = NULL; /// FIXME
-//   this->specularTexture = NULL; /// FIXME
-//
-//   this->setName(m.getName());
-// }
 /**
 …
-/**
- * @brief Adds a Texture Path to the List of already existing Paths
- * @param pathName The Path to add.
-*/
-void Material::addTexturePath(const std::string& pathName)
+{
-  ResourceManager::getInstance()->addImageDir(pathName);
+}
-// MAPPING //
 /**
  * @brief Sets the Diffuse map of this Texture.
 …
  * @param textureNumber The Texture-Number from 0 to GL_MAX_TEXTURE_UNITS
  */
 void Material::setDiffuseMap(const TextureDataPointer& textureDataPointer, unsigned int textureNumber)
+void Material::setDiffuseMap(const TextureData::Pointer& textureDataPointer, unsigned int textureNumber)
+{
   assert(textureNumber < Material::getMaxTextureUnits());
 …
   if (!dMap.empty())
+  {
+    Texture* tex = dynamic_cast<Texture*>(ResourceManager::getInstance()->load(dMap, IMAGE, RP_GAME, (int)target));
+    if (tex != NULL)
+      this->textures[textureNumber] = *tex;
+    this->textures[textureNumber] = ResourceTexture(dMap);
+        //dynamic_cast<Texture*>(ResourceManager::getInstance()->load(dMap, IMAGE, RP_GAME, (int)target));
+/*    if (tex != NULL)
+      this->textures[textureNumber] = tex;
     else
       this->textures[textureNumber] = Texture();
+      this->textures[textureNumber] = Texture();*/
+  }
   else

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

-                      r8761
+                      r9869
 class Material : public BaseObject
+{
+  ObjectListDeclaration(Material);
 public:
   Material (const std::string& mtlName = "");
   virtual ~Material ();
+  Material& operator=(const Material& material);
   void loadParams(const TiXmlElement* root);
-  Material& operator=(const Material& material);
   bool select () const;
 …
   // MAPPING //
   void setDiffuseMap(const Texture& texture, unsigned int textureNumber = 0);
   void setDiffuseMap(const TextureDataPointer& texturePointer, unsigned int textureNumber = 0);
+  void setDiffuseMap(const TextureData::Pointer& texturePointer, unsigned int textureNumber = 0);
   void setDiffuseMap(const std::string& dMap, GLenum target = GL_TEXTURE_2D, unsigned int textureNumber = 0);
   void setSDLDiffuseMap(SDL_Surface *surface, GLenum target = GL_TEXTURE_2D, unsigned int textureNumber = 0);
 …
   const Texture& diffuseTexture(unsigned int i = 0) const { return this->textures[i]; };
-  static void addTexturePath(const std::string& pathName);
   static const std::string& blendFuncToString(GLenum blendFunc);

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

-                      r9406
+                      r9869
 #include "debug.h"
 #include "util/loading/resource_manager.h"
+#include "resource_md2.h"
+ObjectListDefinition(MD2Model);
 //! the model anorms
 sVec3D MD2Model::anorms[NUM_VERTEX_NORMALS] = {
  #include "anorms.h"
 };
+#include "anorms.h"
+    };
 //! anormal dots, no idea of how this shall work, but it does
 float MD2Model::anormsDots[SHADEDOT_QUANT][256] = {
   #include "anormtab.h"
 };
+#include "anormtab.h"
+    };
 …
 sAnim MD2Model::animationList[22] =
+  {
  // begin, end, fps, interruptable
+    // begin, end, fps, interruptable
     {   0,  39,  9, 1 },   //!< STAND
     {  40,  45, 10, 1 },   //!< RUN
 …
  ********************************************************************************/
+MD2Model::MD2Model()
+  : data(new MD2Data())
+{
+  this->init();
+}
+#include "resource_md2.h"
 /**
   \brief simple constructor initializing all variables
 */
 MD2Model::MD2Model(const std::string& modelFileName, const std::string& skinFileName, float scale)
+{
+  this->setClassID(CL_MD2_MODEL, "MD2Model");
+  /* this creates the data container via ressource manager */
+  if (!modelFileName.empty())
+    this->data = (MD2Data*)ResourceManager::getInstance()->load(modelFileName, MD2, RP_GAME, skinFileName, scale);
+  if( unlikely(this->data == NULL))
+    PRINTF(0)("The model was not found, MD2Model Loader finished abnormaly. Update the data-repos\n");
+    : data(new MD2Data())
+{
+  this->init();
   this->scaleFactor = scale;
+  this->animationSpeed = 1.0f;
+  shadeDots = MD2Model::anormsDots[0];
+  /* set the animation stat mannualy */
+  this->animationState.type = STAND;
+  this->animationState.numPlays = 1;
+  this->setAnimation(STAND);
+  this->debug();
+    //write the modelinfo information
+  this->data = ResourceMD2(modelFileName, skinFileName, scale).data;
+  rebuildInfo();
+  //this->debug();
+}
+MD2Model::MD2Model(const MD2Model& model)
+  : data(model.data)
+{
+  this->init();
+  this->rebuildInfo();
+}
+MD2Model& MD2Model::operator=(const MD2Model& md2model)
+{
+  this->data = md2model.data;
+  this->rebuildInfo();
+  return *this;
+}
+void MD2Model::rebuildInfo()
+{
+  //write the modelinfo information
   this->pModelInfo.numVertices = this->data->numVertices;
   this->pModelInfo.numTriangles = this->data->numTriangles;
 …
   // triangle conversion
+  if (this->pModelInfo.pTriangles != NULL)
+    delete[] this->pModelInfo.pTriangles;
   this->pModelInfo.pTriangles = new sTriangleExt[this->data->numTriangles];
   for( int i = 0; i < this->data->numTriangles; i++)
 …
     this->pModelInfo.pTriangles[i].indexToTexCoor[2] = this->data->pTriangles[i].indexToTexCoor[2];
+  }
+}
+bool MD2Model::load(const std::string& modelFileName, const std::string& skinFileName, float scale)
+{
+  this->data = MD2Data::Pointer(new MD2Data(modelFileName, skinFileName, scale));
+  this->rebuildInfo();
+}
 …
   this->pModelInfo.pTexCoor = NULL;
   this->pModelInfo.pTriangles = NULL;
+  ResourceManager::getInstance()->unload(this->data);
+}
+}
+void MD2Model::init()
+{
+  this->registerObject(this, MD2Model::_objectList);
+  /* this creates the data container via ressource manager */
+  if( unlikely(this->data.isNull()))
+    PRINTF(0)("The model was not found, MD2Model Loader finished abnormaly. Update the data-repos\n");
+  this->scaleFactor = 1.0f;
+  this->animationSpeed = 1.0f;
+  shadeDots = MD2Model::anormsDots[0];
+  /* set the animation stat mannualy */
+  this->animationState.type = STAND;
+  this->animationState.numPlays = 1;
+  this->setAnimation(STAND);
+}
 /**
 …
   for( int i = 0; i < this->data->numVertices; ++i)
+    {
       this->verticesList[i][0] = currVec[i][0] + this->animationState.interpolationState * (nextVec[i][0] - currVec[i][0]);
       this->verticesList[i][1] = currVec[i][1] + this->animationState.interpolationState * (nextVec[i][1] - currVec[i][1]);
       this->verticesList[i][2] = currVec[i][2] + this->animationState.interpolationState * (nextVec[i][2] - currVec[i][2]);
+    }
+  {
+    this->verticesList[i][0] = currVec[i][0] + this->animationState.interpolationState * (nextVec[i][0] - currVec[i][0]);
+    this->verticesList[i][1] = currVec[i][1] + this->animationState.interpolationState * (nextVec[i][1] - currVec[i][1]);
+    this->verticesList[i][2] = currVec[i][2] + this->animationState.interpolationState * (nextVec[i][2] - currVec[i][2]);
+  }
+}
 …
   /* draw the triangles */
   while( int i = *(pCommands++)) /* strange looking while loop for maximum performance */
+  {
+    if( i < 0)
+    {
+      if( i < 0)
+        {
+          glBegin(GL_TRIANGLE_FAN);
+          i = -i;
+        }
+      else
+        {
+          glBegin(GL_TRIANGLE_STRIP);
+        }
+      for(; i > 0; i--, pCommands += 3) /* down counting for loop, next 3 gl commands */
+        {
+          glTexCoord2f( ((float *)pCommands)[0], ((float *)pCommands)[1] );
+          glNormal3fv(anorms[this->data->pLightNormals[pCommands[2]]]);
+          glVertex3fv(this->verticesList[pCommands[2]]);
+        }
+      glEnd();
+      glBegin(GL_TRIANGLE_FAN);
+      i = -i;
+    }
+    else
+    {
+      glBegin(GL_TRIANGLE_STRIP);
+    }
+    for(; i > 0; i--, pCommands += 3) /* down counting for loop, next 3 gl commands */
+    {
+      glTexCoord2f( ((float *)pCommands)[0], ((float *)pCommands)[1] );
+      glNormal3fv(anorms[this->data->pLightNormals[pCommands[2]]]);
+      glVertex3fv(this->verticesList[pCommands[2]]);
+    }
+    glEnd();
+  }
   glDisable(GL_CULL_FACE);
   glPopAttrib();
 …
   int* pCommands = this->data->pGLCommands;
   /* some face culling stuff */
 //   glPushAttrib(GL_POLYGON_BIT);
 //   glFrontFace(GL_CW);
 //   glEnable(GL_CULL_FACE);
 //   glCullFace(GL_BACK);
 //
 //   this->processLighting();
 //   this->interpolate(/*this->verticesList*/);
+  //   glPushAttrib(GL_POLYGON_BIT);
+  //   glFrontFace(GL_CW);
+  //   glEnable(GL_CULL_FACE);
+  //   glCullFace(GL_BACK);
+  //
+  //   this->processLighting();
+  //   this->interpolate(/*this->verticesList*/);
   this->data->material.select();
 …
   if( this->animationState.localTime - this->animationState.lastTime > (1.0f / this->animationState.fps))
+  {
+    this->animationState.currentFrame = this->animationState.nextFrame;
+    this->animationState.nextFrame++;
+    if( this->animationState.nextFrame > this->animationState.endFrame )
+    {
+      this->animationState.currentFrame = this->animationState.nextFrame;
+      this->animationState.nextFrame++;
+      if( this->animationState.nextFrame > this->animationState.endFrame )
+      if( this->animationState.animPlaybackMode == MD2_ANIM_LOOP)
+      {
+        if( this->animationState.animPlaybackMode == MD2_ANIM_LOOP)
+        {
+          this->animationState.nextFrame = this->animationState.startFrame;
+          this->animationState.numPlays++;
+        }
+        else
+        {
+          this->animationState.nextFrame = this->animationState.endFrame;
+        }
+        this->animationState.nextFrame = this->animationState.startFrame;
+        this->animationState.numPlays++;
+      }
+      this->animationState.lastTime = this->animationState.localTime;
+      else
+      {
+        this->animationState.nextFrame = this->animationState.endFrame;
+      }
+    }
+//     if( this->animationState.currentFrame > (this->data->numFrames - 1) )
+//       this->animationState.currentFrame = 0;
+//     if( (this->animationState.nextFrame > (this->data->numFrames - 1)) && this->animationState.animPlaybackMode == MD2_ANIM_LOOP)
+//     this->animationState.nextFrame = 0;
+    this->animationState.lastTime = this->animationState.localTime;
+  }
+  //     if( this->animationState.currentFrame > (this->data->numFrames - 1) )
+  //       this->animationState.currentFrame = 0;
+  //     if( (this->animationState.nextFrame > (this->data->numFrames - 1)) && this->animationState.animPlaybackMode == MD2_ANIM_LOOP)
+  //     this->animationState.nextFrame = 0;
   this->animationState.interpolationState = this->animationState.fps *
     (this->animationState.localTime - this->animationState.lastTime);
+      (this->animationState.localTime - this->animationState.lastTime);
+}
 …
   PRINT(0)("=  Number of Frames: \t%i\n", this->data->header->numFrames);
   PRINT(0)("=  Height, Width:\t%i, %i\n", this->data->header->skinHeight, this->data->header->skinWidth);
   PRINT(0)("=  Pointer to the data object: %p\n", this->data);
+  //PRINT(0)("=  Pointer to the data object: %p\n", this->data);
   PRINT(0)("===================================================\n\n");
+}
 …
  ********************************************************************************/
+MD2Data::MD2Data()
+{
+  this->init();
+}
 /**
   \brief simple constructor
 …
 MD2Data::MD2Data(const std::string& modelFileName, const std::string& skinFileName, float scale)
+{
+  scale *= 0.1f;
+  this->init();
+  this->scaleFactor = scale * .1;
+  this->loadModel(modelFileName);
+  this->loadSkin(skinFileName);
+}
+void MD2Data::init()
+{
+  this->scaleFactor = 1.0;
   this->pVertices = NULL;
   this->pGLCommands = NULL;
   this->pLightNormals = NULL;
   this->pTexCoor = NULL;
+  this->header = NULL;
   this->numFrames = 0;
 …
   this->numGLCommands = 0;
   this->numTexCoor = 0;
+//   this->scaleFactor = 1.0f;
+  this->scaleFactor = scale;
+  this->fileName = "";
+  this->skinFileName = "";
+  this->loadModel(modelFileName);
+  this->loadSkin(skinFileName);
+}
+}
 /**
 …
   pFile = fopen(fileName.c_str(), "rb");
   if( unlikely(!pFile))
+    {
       PRINTF(1)("Couldn't open the MD2 File for loading. Exiting.\n");
       return false;
+    }
+  {
+    PRINTF(1)("Couldn't open the MD2 File for loading. Exiting.\n");
+    return false;
+  }
   this->header = new MD2Header;
   fread(this->header, 1, sizeof(MD2Header), pFile);
   /* check for the header version: make sure its a md2 file :) */
   if( unlikely(this->header->version != MD2_VERSION) && unlikely(this->header->ident != MD2_IDENT))
+    {
       PRINTF(1)("Couldn't load file %s: invalid file format: stop loading\n", fileName.c_str());
       return false;
+    }
+  {
+    PRINTF(1)("Couldn't load file %s: invalid file format: stop loading\n", fileName.c_str());
+    return false;
+  }
   this->fileName =fileName;
 …
   for(int i = 0; i < this->numFrames; ++i)
+  {
+    frame = (sFrame*)(buffer + this->header->frameSize * i);
+    pVertex = this->pVertices + this->numVertices  * i;
+    pNormals = this->pLightNormals + this->numVertices * i;
+    for(int j = 0; j < this->numVertices; ++j)
+    {
+      frame = (sFrame*)(buffer + this->header->frameSize * i);
+      pVertex = this->pVertices + this->numVertices  * i;
+      pNormals = this->pLightNormals + this->numVertices * i;
+      for(int j = 0; j < this->numVertices; ++j)
+        {
+          /* SPEEDUP: *(pVerts + i + 0) = (*(frame->pVertices + i + 0)...  */
+           pVertex[j][0] = ((frame->pVertices[j].v[0] * frame->scale[0] ) + frame->translate[0] )* this->scaleFactor;
+           pVertex[j][1] = ((frame->pVertices[j].v[2] * frame->scale[2]) + frame->translate[2]) * this->scaleFactor;
+           pVertex[j][2] = (-1.0 * (frame->pVertices[j].v[1] * frame->scale[1] + frame->translate[1])) * this->scaleFactor;
+          //printf("vertex %i/%i: (%f, %f, %f)\n", j, this->numVertices, pVertex[j][0], pVertex[j][1], pVertex[j][2]);
+          pNormals[j] = frame->pVertices[j].lightNormalIndex;
+        }
+      /* SPEEDUP: *(pVerts + i + 0) = (*(frame->pVertices + i + 0)...  */
+      pVertex[j][0] = ((frame->pVertices[j].v[0] * frame->scale[0] ) + frame->translate[0] )* this->scaleFactor;
+      pVertex[j][1] = ((frame->pVertices[j].v[2] * frame->scale[2]) + frame->translate[2]) * this->scaleFactor;
+      pVertex[j][2] = (-1.0 * (frame->pVertices[j].v[1] * frame->scale[1] + frame->translate[1])) * this->scaleFactor;
+      //printf("vertex %i/%i: (%f, %f, %f)\n", j, this->numVertices, pVertex[j][0], pVertex[j][1], pVertex[j][2]);
+      pNormals[j] = frame->pVertices[j].lightNormalIndex;
+    }
+    PRINTF(4)("Finished loading the md2 file\n");
+  }
+  PRINTF(4)("Finished loading the md2 file\n");
   delete [] buffer;
 …
+{
   if( fileName.empty())
+    {
       this->skinFileName = "";
       return false;
+    }
+  {
+    this->skinFileName = "";
+    return false;
+  }
   this->skinFileName = fileName;

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

-                      r9235
+                      r9869
 #include "base_object.h"
+#include "count_pointer.h"
 #include "interactive_model.h"
 …
 struct MD2Header
+{
    int ident;                           //!< This is used to identify the file
    int version;                         //!< The version number of the file (Must be 8)
    int skinWidth;                       //!< The skin width in pixels
    int skinHeight;                      //!< The skin height in pixels
    int frameSize;                       //!< The size in bytes the frames are
    int numSkins;                        //!< The number of skins associated with the model
    int numVertices;                     //!< The number of vertices (constant for each frame)
    int numTexCoords;                    //!< The number of texture coordinates
    int numTriangles;                    //!< The number of faces (polygons)
    int numGlCommands;                   //!< The number of gl commands
    int numFrames;                       //!< The number of animation frames
    int offsetSkins;                     //!< The offset in the file for the skin data
    int offsetTexCoords;                 //!< The offset in the file for the texture data
    int offsetTriangles;                 //!< The offset in the file for the face data
    int offsetFrames;                    //!< The offset in the file for the frames data
    int offsetGlCommands;                //!< The offset in the file for the gl commands data
    int offsetEnd;                       //!< The end of the file offset
+  int ident;                           //!< This is used to identify the file
+  int version;                         //!< The version number of the file (Must be 8)
+  int skinWidth;                       //!< The skin width in pixels
+  int skinHeight;                      //!< The skin height in pixels
+  int frameSize;                       //!< The size in bytes the frames are
+  int numSkins;                        //!< The number of skins associated with the model
+  int numVertices;                     //!< The number of vertices (constant for each frame)
+  int numTexCoords;                    //!< The number of texture coordinates
+  int numTriangles;                    //!< The number of faces (polygons)
+  int numGlCommands;                   //!< The number of gl commands
+  int numFrames;                       //!< The number of animation frames
+  int offsetSkins;                     //!< The offset in the file for the skin data
+  int offsetTexCoords;                 //!< The offset in the file for the texture data
+  int offsetTriangles;                 //!< The offset in the file for the face data
+  int offsetFrames;                    //!< The offset in the file for the frames data
+  int offsetGlCommands;                //!< The offset in the file for the gl commands data
+  int offsetEnd;                       //!< The end of the file offset
 };
 …
 //! animation names enumeration
 typedef enum MD2animType
+  {
     STAND,                       //0
     RUN,                         //1
     ATTACK,                      //2
     PAIN_A,                      //3
     PAIN_B,                      //4
     PAIN_C,          //5
     JUMP,            //6
     FLIP,            //7
     SALUTE,          //8
     FALLBACK,        //9
     WAVE,            //10
     POINT,           //11
     CROUCH_STAND,
     CROUCH_WALK,
     CROUCH_ATTACK,
     CROUCH_PAIN,
     CROUCH_DEATH,
     DEATH_FALLBACK,
     DEATH_FALLFORWARD,
     DEATH_FALLBACKSLOW,
     BOOM,
     WALK,
     MAX_ANIMATIONS
   };
+{
+  STAND,                       //0
+  RUN,                         //1
+  ATTACK,                      //2
+  PAIN_A,                      //3
+  PAIN_B,                      //4
+  PAIN_C,          //5
+  JUMP,            //6
+  FLIP,            //7
+  SALUTE,          //8
+  FALLBACK,        //9
+  WAVE,            //10
+  POINT,           //11
+  CROUCH_STAND,
+  CROUCH_WALK,
+  CROUCH_ATTACK,
+  CROUCH_PAIN,
+  CROUCH_DEATH,
+  DEATH_FALLBACK,
+  DEATH_FALLFORWARD,
+  DEATH_FALLBACKSLOW,
+  BOOM,
+  WALK,
+  MAX_ANIMATIONS
+};
 …
 class MD2Data : public BaseObject
+{
+ public:
+   MD2Data(const std::string& modelFileName, const std::string& skinFileName, float scale = 1.0f);
+public:
+  typedef CountPointer<MD2Data>    Pointer;
+public:
+  MD2Data();
+  MD2Data(const std::string& modelFileName, const std::string& skinFileName, float scale = 1.0f);
   virtual ~MD2Data();
+ private:
+   bool loadModel(const std::string& fileName);
+   bool loadSkin(const std::string& fileName = "");
+ public:
+private:
+  void init();
+  bool loadModel(const std::string& fileName);
+  bool loadSkin(const std::string& fileName = "");
+public:
   int                numFrames;             //!< number of frames
   int                numVertices;           //!< number of vertices
 …
 //! This is a MD2 Model class
+class MD2Model : public InteractiveModel {
+public:
+class MD2Model : public InteractiveModel
+{
+  ObjectListDeclaration(MD2Model);
+public:
+  MD2Model();
   MD2Model(const std::string& modelFileName, const std::string& skinFileName = "", float scale = 1.0f);
+  MD2Model(const MD2Model& model);
   virtual ~MD2Model();
+  MD2Model& operator=(const MD2Model& md2model);
+  bool load(const std::string& modelFileName, const std::string& skinFileName = "", float scale = 1.0f);
   virtual void draw() const;
 …
   virtual void setAnimation(int firstFrame, int lastFrame, int fps, int bStoppable, int animPlayback);
   /**  returns the current animation @returns animation type */
   inline int MD2Model::getAnimation() { return this->animationState.type; }
+  inline int getAnimation() const { return this->animationState.type; }
   virtual void setAnimationSpeed(float speed) { this->animationSpeed = speed; }
   virtual bool isAnimationFinished() { return (this->animationState.currentFrame == this->animationState.endFrame )?true:false; }
+virtual bool isAnimationFinished() const { return (this->animationState.currentFrame == this->animationState.endFrame )?true:false; }
   /**  scales the current model @param scaleFactor: the factor [0..1] to use for scaling */
   void scaleModel(float scaleFactor) { this->scaleFactor = scaleFactor;}
+  void acquireData(const MD2Data::Pointer& data) { this->data = data; rebuildInfo(); };
+  const MD2Data::Pointer& dataPointer() const { return this->data; };
   virtual void tick(float dtS);
   void debug();
 …
 private:
+  void init();
+  void rebuildInfo();
   void animate(float time);
   void processLighting();
 …
  public:
+public:
   /* these variables are static, because they are all the same for every model */
   static sVec3D       anorms[NUM_VERTEX_NORMALS];       //!< the anormals
   static float        anormsDots[SHADEDOT_QUANT][256];  //!< the anormals dot products
   static sAnim        animationList[22];                //!< the anomation list
    //! again one of these strange id software parts
   float*              shadeDots;
   MD2Data*            data;                             //!< the md2 data pointer
  private:
   float               scaleFactor;                      //!< the scale factor (individual)
   float               animationSpeed;                   //!< the speed of the animation (factor for the time)
   sAnimState          animationState;                   //!< animation state of the model
   sVec3D              verticesList[MD2_MAX_VERTICES];   //!< place to temp sav the vert
+  static sVec3D         anorms[NUM_VERTEX_NORMALS];       //!< the anormals
+  static float          anormsDots[SHADEDOT_QUANT][256];  //!< the anormals dot products
+  static sAnim          animationList[22];                //!< the anomation list
+  //! again one of these strange id software parts
+  float*                shadeDots;
+  CountPointer<MD2Data> data;                           //!< the md2 data pointer
+private:
+  float                 scaleFactor;                      //!< the scale factor (individual)
+  float                 animationSpeed;                   //!< the speed of the animation (factor for the time)
+  sAnimState            animationState;                   //!< animation state of the model
+  sVec3D                verticesList[MD2_MAX_VERTICES];   //!< place to temp sav the vert
 };

trunk/src/lib/graphics/importer/md3/md3_model.h

r8724	r9869
45	45
46	46	virtual void setAnimation(int animNum, int playbackMode = 0) {}
47		virtual int getAnimation() { return 0;}
	47	virtual int getAnimation() const { return 0;}
48	48
49	49	virtual void tick(float dt);

trunk/src/lib/graphics/importer/media_container.cc

-                      r8316
+                      r9869
 #include "util/loading/resource_manager.h"
 /* header for debug output */
 #include "debug.h"
+ObjectListDefinition(MediaContainer);
 /**
 …
+{
   // set the class id for the base object
   this->setClassID(CL_MEDIA_CONTAINER, "MediaContainer");
+  this->registerObject(this, MediaContainer::_objectList);
   fps = 0;
 …
     return false;
   // check whether file exists
   if(!ResourceManager::isInDataDir(filename))
+  if(!Resources::ResourceManager::getInstance()->checkFileInMainPath(filename))
+  {
     PRINTF(1)("Could not find %s\n", filename.c_str());
 …
   // Open video file
   if (av_open_input_file(&format_context, ResourceManager::getFullName(filename).c_str(), NULL, 0, NULL) !=0 )
+  {
     PRINTF(1)("Could not open %s\n", ResourceManager::getFullName(filename).c_str());
+  if (av_open_input_file(&format_context, Resources::ResourceManager::getInstance()->prependAbsoluteMainPath(filename).c_str(), NULL, 0, NULL) !=0 )
+  {
+    PRINTF(1)("Could not open %s\n", Resources::ResourceManager::getInstance()->prependAbsoluteMainPath(filename).c_str());
     return false;
+  }
 …
   if (av_find_stream_info(format_context) < 0)
+  {
     PRINTF(1)("Could not find stream information in %s\n", ResourceManager::getFullName(filename).c_str());
+    PRINTF(1)("Could not find stream information in %s\n", Resources::ResourceManager::getInstance()->prependAbsoluteMainPath(filename).c_str());
     return false;
+  }
 …
   if(video_stream == -1)
+  {
     PRINTF(1)("Could not find a video stream in %s\n", ResourceManager::getFullName(filename).c_str());
+    PRINTF(1)("Could not find a video stream in %s\n", Resources::ResourceManager::getInstance()->prependAbsoluteMainPath(filename).c_str());
     return false;
+  }

trunk/src/lib/graphics/importer/media_container.h

r7221	r9869
24	24	class MediaContainer : public TextureSequence
25	25	{
26
	26	ObjectListDeclaration(MediaContainer);
27	27	private:
28	28

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

-                      r9406
+                      r9869
 #include "glincl.h"
+ObjectListDefinition(Model);
 /**
 …
 Model::Model()
+{
   this->setClassID(CL_MODEL, "Model");
+  this->registerObject(this, Model::_objectList);
   this->pModelInfo.numVertices = 0;
   this->pModelInfo.numTriangles = 0;

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

r8035	r9869
54	54	//! This class defines the basic components of a model
55	55	class Model : virtual public BaseObject {
	56	ObjectListDeclaration(Model);
56	57
57	58	public:

trunk/src/lib/graphics/importer/movie_player.cc

-                      r7221
+                      r9869
 // include your own header
 #include "movie_player.h"
 #include "util/loading/resource_manager.h"
 …
 #include "debug.h"
+ObjectListDefinition(MoviePlayer);
 MoviePlayer::MoviePlayer(const std::string& filename)
+{
   // set the class id for the base object
+  this->setClassID(CL_MOVIE_PLAYER, "MoviePlayer");
+  this->registerObject(this, MoviePlayer::_objectList);
   status = STOP;
   timer = 0;
 …
     return false;
   // check whether file exists
   if(!ResourceManager::isInDataDir(filename))
+  if(!Resources::ResourceManager::getInstance()->checkFileInMainPath(filename))
+  {
     PRINTF(1)("Could not find %s\n", filename.c_str());
 …
   // Open video file
   if (av_open_input_file(&format_context, ResourceManager::getFullName(filename).c_str(), NULL, 0, NULL) !=0 )
+  {
     PRINTF(1)("Could not open %s\n", ResourceManager::getFullName(filename).c_str());
+  if (av_open_input_file(&format_context, Resources::ResourceManager::getInstance()->prependAbsoluteMainPath(filename).c_str(), NULL, 0, NULL) !=0 )
+  {
+    PRINTF(1)("Could not open %s\n", Resources::ResourceManager::getInstance()->prependAbsoluteMainPath(filename).c_str());
     return false;
+  }
 …
   if (av_find_stream_info(format_context) < 0)
+  {
     PRINTF(1)("Could not find stream information in %s\n", ResourceManager::getFullName(filename).c_str());
+    PRINTF(1)("Could not find stream information in %s\n", Resources::ResourceManager::getInstance()->prependAbsoluteMainPath(filename).c_str());
     return false;
+  }
 …
   if(video_stream == -1)
+  {
     PRINTF(1)("Could not find a video stream in %s\n", ResourceManager::getFullName(filename).c_str());
+    PRINTF(1)("Could not find a video stream in %s\n", Resources::ResourceManager::getInstance()->prependAbsoluteMainPath(filename).c_str());
     return false;
+  }

trunk/src/lib/graphics/importer/movie_player.h

r7221	r9869
31	31	class MoviePlayer : public BaseObject
32	32	{
	33	ObjectListDeclaration(MoviePlayer);
33	34
34	35	private:

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

-                      r8369
+                      r9869
 #include "objModel.h"
-#include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
+#include "loading/resource_manager.h"
 #define PARSELINELENGTH 8192
 …
 #include "compiler.h"
+ObjectListDefinition(OBJModel);
 /**
  * @brief Crates a 3D-Model, loads in a File and scales it.
 …
   : StaticModel(fileName)
+{
   this->setClassID(CL_OBJ_MODEL, "OBJModel");
+  this->registerObject(this, OBJModel::_objectList);
   this->objPath = "./";
   this->scaleFactor = scaling;
+  this->setScaleFactor(scaling);
   this->importFile (fileName);
 …
   else
     this->objPath = "./";
   Material::addTexturePath(this->objPath);
+  Resources::ResourceManager::getInstance()->addResourcePath("Texture", this->objPath);
   this->readFromObjFile (fileName);

trunk/src/lib/graphics/importer/objModel.h

-                      r8369
+                      r9869
 class OBJModel : public StaticModel
+{
+ public:
+   OBJModel(const std::string& fileName, float scaling = 1.0);
+  ObjectListDeclaration(OBJModel);
+public:
+  OBJModel(const std::string& fileName, float scaling = 1.0);
   virtual ~OBJModel();
  private:
+private:
   ///// readin /////
    bool importFile (const std::string& fileName);
    bool readFromObjFile (const std::string& fileName);
    bool readMtlLib (const std::string& matFile);
+  bool importFile (const std::string& fileName);
+  bool readFromObjFile (const std::string& fileName);
+  bool readMtlLib (const std::string& matFile);
   private:
    void setIllum (Material* material, const char* illum);
    void setDiffuse (Material* material, const char* rgb);
    void setAmbient (Material* material, const char* rgb);
    void setSpecular (Material* material, const char* rgb);
    void setShininess (Material* material, const char* shini);
    void setTransparency (Material* material, const char* trans);
+private:
+  void setIllum (Material* material, const char* illum);
+  void setDiffuse (Material* material, const char* rgb);
+  void setAmbient (Material* material, const char* rgb);
+  void setSpecular (Material* material, const char* rgb);
+  void setShininess (Material* material, const char* shini);
+  void setTransparency (Material* material, const char* trans);
  private:
    std::string       objPath;     //!< The Path where the obj and mtl-file are located.
+private:
+  std::string       objPath;     //!< The Path where the obj and mtl-file are located.
 };

trunk/src/lib/graphics/importer/static_model.cc

-                      r9406
+                      r9869
-////////////////////
-/// SUB-Elements ///
-////////////////////
-/**
- * @brief creates a new ModelFaceElement
- */
-ModelFaceElement::ModelFaceElement()
+{
-  this->vertexNumber = -1;
-  this->normalNumber = -1;
-  this->texCoordNumber = -1;
-  this->next = NULL;
+}
-/**
- * @brief destroys a ModelFaceElement
- */
-ModelFaceElement::~ModelFaceElement()
+{
-  if (this->next)
-    delete this->next;
+}
-/**
- * @brief creates a new ModelFace
- */
-ModelFace::ModelFace()
+{
-  this->vertexCount = 0;
-  this->firstElem = NULL;
-  this->material = NULL;
-  this->next = NULL;
+}
-/**
- *  deletes a ModelFace
-*/
-ModelFace::~ModelFace()
+{
-  PRINTF(5)("Cleaning up Face\n");
-  if (this->firstElem != NULL)
-    delete this->firstElem;
-  if (this->next != NULL)
-    delete this->next;
+}
-/**
- * @brief Creates a new ModelGroup
- */
-ModelGroup::ModelGroup()
+{
-  PRINTF(4)("Adding new Group\n");
-  this->name = "";
-  this->faceMode = -1;
-  this->faceCount = 0;
-  this->next = NULL;
-  this->listNumber = 0;
-  this->indices = NULL;
-  this->firstFace = new ModelFace;
-  this->currentFace = this->firstFace;
+}
-/**
- * @brief deletes a ModelGroup
- */
-ModelGroup::~ModelGroup()
+{
-  PRINTF(5)("Cleaning up group\n");
-  if (this->firstFace != NULL)
-    delete this->firstFace;
-  // deleting the glList
-  if (this->listNumber != 0)
-    glDeleteLists(this->listNumber, 1);
-  if (this->next !=NULL)
-    delete this->next;
+}
-/**
- * @brief cleans up a ModelGroup
+ *
- * actually does the same as the delete Operator, but does not delete the predecessing group
- */
-void ModelGroup::cleanup()
+{
-  PRINTF(5)("Cleaning up group\n");
-  if (this->firstFace)
-    delete this->firstFace;
-  this->firstFace = NULL;
-  if (this->next)
-    this->next->cleanup();
+}
 /////////////
 /// MODEL ///
 /////////////
+ObjectListDefinition(StaticModel);
 /**
  * @brief Creates a 3D-Model.
 …
  */
 StaticModel::StaticModel(const std::string& modelName)
+    : data(new StaticModelData(modelName))
+{
   this->setClassID(CL_STATIC_MODEL, "StaticModel");
+  this->registerObject(this, StaticModel::_objectList);
   PRINTF(4)("new 3D-Model is being created\n");
   this->setName(modelName);
+}
+  this->finalized = false;
+StaticModel::StaticModel(const StaticModel& staticModel)
+  : data(staticModel.data)
+{
+  this->registerObject(this, StaticModel::_objectList);
+  this->setName(staticModel.getName());
+  this->updateBase();
+}
-  // setting the start group;
-  this->currentGroup = this->firstGroup = new ModelGroup;
-  this->groupCount = 0;
-  this->faceCount = 0;
-  this->scaleFactor = 1.0f;
+}
 /**
 …
+{
   PRINTF(4)("Deleting Model ");
-  if (!this->getName().empty())
+  {
-    PRINT(4)("%s\n", this->getCName());
+  }
-  else
+  {
-    PRINT(4)("\n");
+  }
-  this->cleanup();
-  PRINTF(5)("Deleting display Lists.\n");
-  delete this->firstGroup;
-  // deleting the MaterialList
-  PRINTF(5)("Deleting Materials.\n");
-  //! @todo do we really have to delete this material??
-  std::list<ModelMaterial*>::iterator modMat;
-  for(modMat = this->materialList.begin(); modMat != this->materialList.end(); modMat++)
+  {
-    if (!(*modMat)->external)
-      delete (*modMat)->material;
-    delete (*modMat);
+  }
   // mark this stuff as beeing deleted
 …
   this->pModelInfo.pNormals = NULL;
   this->pModelInfo.pTexCoor = NULL;
+  this->pModelInfo.pTriangles = NULL;
+}
+StaticModel& StaticModel::operator=(const StaticModel& model)
+{
+  this->data = model.data;
+  this->updateBase();
+  return *this;
+};
 /**
 …
 void StaticModel::finalize()
+{
+  // this creates the display List.
+  this->importToDisplayList();
+  this->buildTriangleList();
+  // write out the modelInfo data used for the collision detection!
+  this->pModelInfo.pVertices = &this->vertices[0];
+  this->pModelInfo.pNormals = &this->normals[0];
+  this->pModelInfo.pTexCoor = &this->vTexture[0];
+  this->finalized = true;
+  data->finalize();
+  this->updateBase();
+}
+/**
+ * @brief rebuild the Model from the Information we got.
+ */
+void StaticModel::rebuild()
+void StaticModel::acquireData(const StaticModelData::Pointer& data)
+{
+  PRINTF(3)("Rebuilding Model '%s'\n", this->getCName());
+  this->finalize();
+}
+//////////
+// DRAW //
+//////////
+/**
+ * @brief Draws the Models of all Groups.
+ *
+ * It does this by just calling the Lists that must have been created earlier.
+ */
+void StaticModel::draw () const
+{
+  PRINTF(4)("drawing the 3D-Models\n");
+  ModelGroup* tmpGroup = this->firstGroup;
+  while (tmpGroup != NULL)
+  {
+    PRINTF(5)("Drawing model %s\n", tmpGroup->name.c_str());
+    glCallList (tmpGroup->listNumber);
+    tmpGroup = tmpGroup->next;
+  }
+}
+/**
+ * @brief 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.
+ */
+void StaticModel::draw (int groupNumber) const
+{
+  if (unlikely(groupNumber >= this->groupCount))
+  {
+    PRINTF(2)("You requested model number %i, but this File only contains of %i Models.\n", groupNumber-1, this->groupCount);
+    return;
+  }
+  PRINTF(4)("drawing the requested 3D-Models if found.\n");
+  ModelGroup* tmpGroup = this->firstGroup;
+  int counter = 0;
+  while (tmpGroup != NULL)
+  {
+    if (counter == groupNumber)
+    {
+      PRINTF(4)("Drawing model number %i named %s\n", counter, tmpGroup->name.c_str());
+      glCallList (tmpGroup->listNumber);
+      return;
+    }
+    ++counter;
+    tmpGroup = tmpGroup->next;
+  }
+  PRINTF(2)("Model number %i in %s not Found.\n", groupNumber, this->getCName());
+  return;
+}
+/**
+ * @brief 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.
+ */
+void StaticModel::draw (const std::string& groupName) const
+{
+  PRINTF(4)("drawing the requested 3D-Models if found.\n");
+  ModelGroup* tmpGroup = this->firstGroup;
+  while (tmpGroup != NULL)
+  {
+    if (tmpGroup->name == groupName)
+    {
+      PRINTF(4)("Drawing model %s\n", tmpGroup->name.c_str());
+      glCallList (tmpGroup->listNumber);
+      return;
+    }
+    tmpGroup = tmpGroup->next;
+  }
+  PRINTF(2)("Model Named %s in %s not Found.\n", groupName.c_str(), this->getCName());
+  return;
+}
+//////////
+// INIT //
+//////////
+/**
+ * @brief 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.
+ * This will be applied at the end of the importing Process.
+*/
+bool StaticModel::cleanup()
+{
+  PRINTF(4)("cleaning up the 3D-Model to save Memory.\n");
+  this->firstGroup->cleanup();
+  return true;
+}
+//////////
+// MESH //
+//////////
+/**
+ * @brief 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
+ * with this option set the Materials will not be deleted with the Model.
+ */
+Material* StaticModel::addMaterial(Material* material)
+{
+  if (material == NULL)
+    return NULL;
+  ModelMaterial* modMat = new ModelMaterial;
+  modMat->external = true;
+  modMat->material = material;
+  this->materialList.push_back(modMat);
+  return modMat->material;
+}
+/**
+ * @brief adds a new Material to the Material List
+ * @param materialName the name of the Material to add
+ * @returns the added material
+ */
+Material* StaticModel::addMaterial(const std::string& materialName)
+{
+  ModelMaterial* modMat = new ModelMaterial;
+  modMat->external = false;
+  modMat->material = new Material(materialName);
+  // adding material to the List of materials
+  this->materialList.push_back(modMat);
+  return modMat->material;
+}
+/**
+ * @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
+ */
+Material* StaticModel::findMaterialByName(const std::string& materialName)
+{
+  std::list<ModelMaterial*>::iterator modMat;
+  for  (modMat = this->materialList.begin(); modMat != this->materialList.end(); modMat++)
+    if (materialName == (*modMat)->material->getName())
+      return (*modMat)->material;
+  return NULL;
+}
+/**
+ * @brief parses a group String
+ * @param groupString the new Group to create
+ *
+ * This function initializes a new Group.
+ * With it you should be able to create Models with more than one SubModel inside
+ */
+bool StaticModel::addGroup(const std::string& groupString)
+{
+  PRINTF(5)("Read Group: %s.\n", groupString.c_str());
+  if (this->groupCount != 0 && this->currentGroup->faceCount > 0)
+  {
+    // finalizeGroup(currentGroup);
+    this->currentGroup = this->currentGroup->next = new ModelGroup;
+  }
+  // setting the group name if not default.
+  if (groupString == "default")
+  {
+    this->currentGroup->name = groupString;
+  }
+  ++this->groupCount;
+  return true;
+}
+/**
+ * @brief 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
+ */
+bool StaticModel::addVertex (const std::string& vertexString)
+{
+  float subbuffer1;
+  float subbuffer2;
+  float subbuffer3;
+  sscanf (vertexString.c_str(), "%f %f %f", &subbuffer1, &subbuffer2, &subbuffer3);
+  this->vertices.push_back(subbuffer1*scaleFactor);
+  this->vertices.push_back(subbuffer2*scaleFactor);
+  this->vertices.push_back(subbuffer3*scaleFactor);
+  this->pModelInfo.numVertices++;
+  return true;
+}
+/**
+ * @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.
+ */
+bool StaticModel::addVertex(float x, float y, float z)
+{
+  PRINTF(5)("reading in a vertex: %f %f %f\n", x, y, z);
+  this->vertices.push_back(x*scaleFactor);
+  this->vertices.push_back(y*scaleFactor);
+  this->vertices.push_back(z*scaleFactor);
+  this->pModelInfo.numVertices++;
+  return true;
+}
+/**
+ * @brief 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
+ */
+bool StaticModel::addVertexNormal (const std::string& normalString)
+{
+  float subbuffer1;
+  float subbuffer2;
+  float subbuffer3;
+  sscanf (normalString.c_str(), "%f %f %f", &subbuffer1, &subbuffer2, &subbuffer3);
+  this->normals.push_back(subbuffer1);
+  this->normals.push_back(subbuffer2);
+  this->normals.push_back(subbuffer3);
+  this->pModelInfo.numNormals++;
+  return true;
+}
+/**
+ * @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.
+ *
+ * If a vertexNormal line is found this function will inject it into the vertexNormal-Array
+ */
+bool StaticModel::addVertexNormal(float x, float y, float z)
+{
+  PRINTF(5)("found vertex-Normal %f, %f, %f\n", x, y, z);
+  this->normals.push_back(x);
+  this->normals.push_back(y);
+  this->normals.push_back(z);
+  this->pModelInfo.numNormals++;
+  return true;
+}
+/**
+ * @brief parses a vertexTextureCoordinate-String
+ * @param vTextureString The String that will be parsed.
+ *
+ * If a vertexTextureCoordinate line is found,
+ * this function will inject it into the vertexTexture-Array
+ *
+ * !! WARNING THIS IS DIFFERNT FROM addVervexTexture(float, float); because it changes the second entry to 1-v !!
+ */
+bool StaticModel::addVertexTexture (const std::string& vTextureString)
+{
+  float subbuffer1;
+  float subbuffer2;
+  sscanf (vTextureString.c_str(), "%f %f", &subbuffer1, &subbuffer2);
+  this->vTexture.push_back(subbuffer1);
+  this->vTexture.push_back(1 - subbuffer2);
+  this->pModelInfo.numTexCoor++;
+  return true;
+}
+/**
+ * @brief 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
+ */
+bool StaticModel::addVertexTexture(float u, float v)
+{
+  PRINTF(5)("found vertex-Texture %f, %f\n", u, v);
+  this->vTexture.push_back(u);
+  this->vTexture.push_back(v);
+  this->pModelInfo.numTexCoor++;
+  return true;
+}
+/**
+ * @brief 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.
+ *
+ * String is different from the argument addFace,
+ * in this, that the first Vertex/Normal/Texcoord is 1 instead of 0
+ *
+ * @TODO make it std::string conform
+ */
+bool StaticModel::addFace (const std::string& faceStringInput)
+{
+  const char* faceString = faceStringInput.c_str();
+  if (this->currentGroup->faceCount >0)
+    this->currentGroup->currentFace = this->currentGroup->currentFace->next = new ModelFace;
+  ModelFaceElement* tmpElem = this->currentGroup->currentFace->firstElem = new ModelFaceElement;
+  tmpElem->next = NULL;
+  while(strcmp (faceString, "\0"))
+  {
+    if (this->currentGroup->currentFace->vertexCount>0)
+      tmpElem = tmpElem->next = new ModelFaceElement;
+    tmpElem->next = NULL;
+    char tmpValue [50];
+    int tmpLen;
+    char* vertex = NULL;
+    char* texture = NULL;
+    char* normal = NULL;
+    sscanf (faceString, "%s", tmpValue);
+    tmpLen = strlen(tmpValue);
+    vertex = tmpValue;
+    if ((texture = strstr (vertex, "/")) != NULL)
+    {
+      texture[0] = '\0';
+      texture ++;
+      if ((normal = strstr (texture, "/")) !=NULL)
+      {
+        normal[0] = '\0';
+        normal ++;
+      }
+    }
+    if (vertex)
+      tmpElem->vertexNumber = atoi(vertex)-1;
+    if (texture)
+      tmpElem->texCoordNumber = atoi(texture)-1;
+    if (normal)
+      tmpElem->normalNumber = atoi(normal)-1;
+    faceString += tmpLen;
+    if (strcmp (faceString, "\0"))
+      faceString++;
+    this->currentGroup->currentFace->vertexCount++;
+  }
+  this->currentGroup->faceCount += this->currentGroup->currentFace->vertexCount -2;
+  this->faceCount += this->currentGroup->currentFace->vertexCount -2;
+  return true;
+  this->data = data;
+  this->updateBase();
+}
 …
 bool StaticModel::addFace(int faceElemCount, VERTEX_FORMAT type, ...)
+{
-  if (this->currentGroup->faceCount > 0)
-    this->currentGroup->currentFace = this->currentGroup->currentFace->next = new ModelFace;
-  ModelFaceElement* tmpElem = this->currentGroup->currentFace->firstElem = new ModelFaceElement;
   va_list itemlist;
   va_start (itemlist, type);
+  for (int i = 0; i < faceElemCount; i++)
+  {
+    if (this->currentGroup->currentFace->vertexCount > 0)
+      tmpElem = tmpElem->next = new ModelFaceElement;
+    tmpElem->vertexNumber = va_arg (itemlist, int);
+    if (type & TEXCOORD)
+      tmpElem->texCoordNumber = va_arg (itemlist, int);
+    if (type & NORMAL)
+      tmpElem->normalNumber = va_arg(itemlist, int);
+    this->currentGroup->currentFace->vertexCount++;
+  }
+  bool retVal = this->data->addFace(faceElemCount, type, itemlist);
   va_end(itemlist);
+  this->currentGroup->faceCount += this->currentGroup->currentFace->vertexCount - 2;
+  this->faceCount += this->currentGroup->currentFace->vertexCount -2;
+  return true;
+  return retVal;
+}
+/**
+ * Function that selects a material, if changed in the obj file.
+ * @param matString the Material that will be set.
+*/
+bool StaticModel::setMaterial(const std::string& matString)
+void StaticModel::updateBase()
+{
+  if (this->currentGroup->faceCount > 0)
+    this->currentGroup->currentFace = this->currentGroup->currentFace->next = new ModelFace;
+  // write out the modelInfo data used for the collision detection!
+  this->pModelInfo.pVertices = &this->data->getVertices()[0];
+  this->pModelInfo.numVertices = this->data->getVertices().size();
+  this->pModelInfo.pNormals = &this->data->getNormals()[0];
+  this->pModelInfo.numNormals = this->data->getNormals().size();
+  this->pModelInfo.pTexCoor = &this->data->getTexCoords()[0];
+  this->pModelInfo.numTexCoor = this->data->getTexCoords().size();
+  this->currentGroup->currentFace->material = this->findMaterialByName(matString);
+  if (this->currentGroup->faceCount == 0)
+    this->currentGroup->faceCount++;
+  return true;
+}
+/**
+ * Function that selects a material, if changed in the obj file.
+ * @param mtl the Material that will be set.
+*/
+bool StaticModel::setMaterial(Material* mtl)
+{
+  if (this->currentGroup->faceCount > 0)
+    this->currentGroup->currentFace = this->currentGroup->currentFace->next = new ModelFace;
+  this->currentGroup->currentFace->material = mtl;
+  if (this->currentGroup->faceCount == 0)
+    this->currentGroup->faceCount++;
+  return true;
+}
+/**
+ * @brief A routine that is able to create normals.
+ *
+ * The algorithm does the following:
+ * 1. It calculates creates Vectors for each normale, and sets them to zero.
+ * 2. It then Walks through a) all the Groups b) all the Faces c) all the FaceElements
+ * 3. It searches for a points two neighbours per Face, takes Vecotrs to them calculates FaceNormals and adds it to the Points Normal.
+ * 4. It goes through all the normale-Points and calculates the VertexNormale and includes it in the normals-Array.
+ */
+bool StaticModel::buildVertexNormals ()
+{
+  PRINTF(4)("Normals are being calculated.\n");
+  Vector* normArray = new Vector [vertices.size()/3];
+  for (unsigned int i=0; i<vertices.size()/3;i++)
+    normArray[i] = Vector(.0,.0,.0);
+  Vector prevV;
+  Vector nextV;
+  Vector curV;
+  ModelGroup* tmpGroup = firstGroup;
+  while (tmpGroup != NULL)
+  {
+    ModelFace* tmpFace = tmpGroup->firstFace;
+    while (tmpFace != NULL)
+    {
+      if (tmpFace->firstElem != NULL)
+      {
+        ModelFaceElement* firstElem = tmpFace->firstElem;
+        ModelFaceElement* prevElem;
+        ModelFaceElement* curElem = firstElem;
+        ModelFaceElement* nextElem;
+        ModelFaceElement* lastElem;
+        // find last Element of the Chain. !! IMPORTANT:the last Element of the Chain must point to NULL, or it will resolv into an infinity-loop.
+        while (curElem != NULL)
+        {
+          prevElem = curElem;
+          curElem = curElem->next;
+        }
+        lastElem = prevElem;
+        curElem = firstElem;
+        for (unsigned int j = 0; j < tmpFace->vertexCount; j++)
+        {
+          if (!(nextElem = curElem->next))
+            nextElem = firstElem;
+          curElem->normalNumber = curElem->vertexNumber;
+          curV = Vector (this->vertices[curElem->vertexNumber*3],
+                         this->vertices[curElem->vertexNumber*3+1],
+                         this->vertices[curElem->vertexNumber*3+2]);
+          prevV = Vector (this->vertices[prevElem->vertexNumber*3],
+                          this->vertices[prevElem->vertexNumber*3+1],
+                          this->vertices[prevElem->vertexNumber*3+2]) - curV;
+          nextV = Vector (this->vertices[nextElem->vertexNumber*3],
+                          this->vertices[nextElem->vertexNumber*3+1],
+                          this->vertices[nextElem->vertexNumber*3+2]) - curV;
+          normArray[curElem->vertexNumber] = normArray[curElem->vertexNumber] + nextV.cross(prevV);
+          prevElem = curElem;
+          curElem = curElem->next;
+        }
+      }
+      tmpFace = tmpFace->next;
+    }
+    tmpGroup = tmpGroup->next;
+  }
+  for (unsigned int i=0; i < this->vertices.size()/3;i++)
+  {
+    normArray[i].normalize();
+    PRINTF(5)("Found Normale number %d: (%f; %f, %f).\n", i, normArray[i].x, normArray[i].y, normArray[i].z);
+    this->addVertexNormal(normArray[i].x, normArray[i].y, normArray[i].z);
+  }
+  delete[] normArray;
+  return true;
+}
+////////////
+// openGL //
+////////////
+/**
+ *  reads and includes the Faces/Materials into the openGL state Machine
+*/
+bool StaticModel::importToDisplayList()
+{
+  // finalize the Arrays
+  if (normals.size() == 0) // vertices-Array must be built for this
+    this->buildVertexNormals();
+  this->currentGroup = this->firstGroup;
+  while (this->currentGroup != NULL)
+  {
+    // creating a glList for the Group
+    if ((this->currentGroup->listNumber = glGenLists(1)) == 0)
+    {
+      PRINTF(2)("glList could not be created for this Model\n");
+      return false;
+    }
+    glNewList (this->currentGroup->listNumber, GL_COMPILE);
+    // Putting Faces to GL
+    ModelFace* tmpFace = this->currentGroup->firstFace;
+    while (tmpFace != NULL)
+    {
+      if (tmpFace->vertexCount == 0 && tmpFace->material != NULL)
+      {
+        if (this->currentGroup->faceMode != -1)
+          glEnd();
+        this->currentGroup->faceMode = 0;
+        if (tmpFace->material != NULL)
+        {
+          tmpFace->material->select();
+          PRINTF(5)("using material %s for coming Faces.\n", tmpFace->material->getCName());
+        }
+      }
+      else if (tmpFace->vertexCount == 3)
+      {
+        if (this->currentGroup->faceMode != 3)
+        {
+          if (this->currentGroup->faceMode != -1)
+            glEnd();
+          glBegin(GL_TRIANGLES);
+        }
+        this->currentGroup->faceMode = 3;
+        PRINTF(5)("found triag.\n");
+      }
+      else if (tmpFace->vertexCount == 4)
+      {
+        if (this->currentGroup->faceMode != 4)
+        {
+          if (this->currentGroup->faceMode != -1)
+            glEnd();
+          glBegin(GL_QUADS);
+        }
+        this->currentGroup->faceMode = 4;
+        PRINTF(5)("found quad.\n");
+      }
+      else if (tmpFace->vertexCount > 4)
+      {
+        if (this->currentGroup->faceMode != -1)
+          glEnd();
+        glBegin(GL_POLYGON);
+        PRINTF(5)("Polygon with %i faces found.", tmpFace->vertexCount);
+        this->currentGroup->faceMode = tmpFace->vertexCount;
+      }
+      ModelFaceElement* tmpElem = tmpFace->firstElem;
+      while (tmpElem != NULL)
+      {
+        //      PRINTF(2)("%s\n", tmpElem->value);
+        this->addGLElement(tmpElem);
+        tmpElem = tmpElem->next;
+      }
+      tmpFace = tmpFace->next;
+    }
+    glEnd();
+    glEndList();
+    this->currentGroup = this->currentGroup->next;
+  }
+  return true;
+  this->pModelInfo.pTriangles = this->data->getTrianglesExt();
+  this->pModelInfo.numTriangles = this->data->getTriangles().size();
+}
 /**
+ *  builds an array of triangles, that can later on be used for obb separation and octree separation
+ *  Includes a default model
+ *
+ * This will inject a Cube, because this is the most basic model.
  */
-bool StaticModel::buildTriangleList()
+{
-  if( unlikely(this->pModelInfo.pTriangles != NULL))
-    return true;
-  /* make sure, that all the arrays are finalized */
-  if( normals.size() == 0) // vertices-Array must be built for this
-    this->buildVertexNormals();
-  int                index = 0;                   //!< the counter for the triangle array
-  ModelFaceElement*  tmpElem;       //!< the temporary faceelement reference
-  ModelFace*         tmpFace;              //!< the temporary face referece
-  bool warned = false;
-  this->pModelInfo.numTriangles = 0;
-  /* count the number of triangles */
-  /* now iterate through all groups and build up the triangle list */
-  this->currentGroup = this->firstGroup;
-  while( this->currentGroup != NULL)
+  {
-    tmpFace = this->currentGroup->firstFace;
-    while( tmpFace != NULL)
+    {
-      /* if its a triangle just add it to the list */
-      if( tmpFace->vertexCount == 3){
-        ++this->pModelInfo.numTriangles;
-      } /* if the polygon is a quad */
-      else if( tmpFace->vertexCount == 4) {
-        this->pModelInfo.numTriangles += 2;
+      }
-      else if( tmpFace->vertexCount > 4) {
-        if (!warned)        {
-          PRINTF(2)("This model (%s) got over 4 vertices per face <=> conflicts in the CD engine!\n", this->getCName());
-          warned = true;
+        }
+      }
-      tmpFace = tmpFace->next;
+    }
-    this->currentGroup = this->currentGroup->next;
+  }
-  PRINTF(3)("got %i triangles, %i vertices\n", this->pModelInfo.numTriangles, this->pModelInfo.numVertices);
-  /* write MODELINFO structure */
-  /* allocate memory for the new triangle structures */
-  if( (this->pModelInfo.pTriangles = new sTriangleExt[this->pModelInfo.numTriangles]) == NULL)
+  {
-    PRINTF(1)("Could not allocate memory for triangle list\n");
-    return false;
+  }
-  /* now iterate through all groups and build up the triangle list */
-  this->currentGroup = this->firstGroup;
-  while( this->currentGroup != NULL)
+  {
-    tmpFace = this->currentGroup->firstFace;
-    while( tmpFace != NULL)
+    {
-      tmpElem = tmpFace->firstElem;
-      /* if its a triangle just add it to the list */
-      if( tmpFace->vertexCount == 3)
+      {
-        for( int j = 0; j < 3; ++j)
+        {
-          this->pModelInfo.pTriangles[index].indexToVertices[j] = (unsigned int)tmpElem->vertexNumber * 3 ;
-          this->pModelInfo.pTriangles[index].indexToNormals[j] = (unsigned int)tmpElem->normalNumber * 3 ;
-          this->pModelInfo.pTriangles[index].indexToTexCoor[j] = (unsigned int)tmpElem->texCoordNumber * 3 ;
-          tmpElem = tmpElem->next;
+        }
-        ++index;
-      } /* if the polygon is a quad */
-      else if( tmpFace->vertexCount == 4)
+      {
-        this->pModelInfo.pTriangles[index].indexToVertices[0] = (unsigned int)tmpElem->vertexNumber * 3;
-        this->pModelInfo.pTriangles[index].indexToNormals[0] = (unsigned int)tmpElem->normalNumber * 3;
-        this->pModelInfo.pTriangles[index].indexToTexCoor[0] = (unsigned int)tmpElem->texCoordNumber * 3;
-        this->pModelInfo.pTriangles[index + 1].indexToVertices[0] = (unsigned int)tmpElem->vertexNumber * 3;
-        this->pModelInfo.pTriangles[index + 1].indexToNormals[0] = (unsigned int)tmpElem->normalNumber * 3;
-        this->pModelInfo.pTriangles[index + 1].indexToTexCoor[0] = (unsigned int)tmpElem->texCoordNumber * 3;
-        tmpElem = tmpElem->next;
-        this->pModelInfo.pTriangles[index].indexToVertices[1] = (unsigned int)tmpElem->vertexNumber * 3;
-        this->pModelInfo.pTriangles[index].indexToNormals[1] = (unsigned int)tmpElem->normalNumber * 3;
-        this->pModelInfo.pTriangles[index].indexToTexCoor[1] = (unsigned int)tmpElem->texCoordNumber * 3;
-        tmpElem = tmpElem->next;
-        this->pModelInfo.pTriangles[index].indexToVertices[2] = (unsigned int)tmpElem->vertexNumber * 3;
-        this->pModelInfo.pTriangles[index].indexToNormals[2] = (unsigned int)tmpElem->normalNumber * 3;
-        this->pModelInfo.pTriangles[index].indexToTexCoor[2] = (unsigned int)tmpElem->texCoordNumber * 3;
-        this->pModelInfo.pTriangles[index + 1].indexToVertices[2] = (unsigned int)tmpElem->vertexNumber * 3;
-        this->pModelInfo.pTriangles[index + 1].indexToNormals[2] = (unsigned int)tmpElem->normalNumber * 3;
-        this->pModelInfo.pTriangles[index + 1].indexToTexCoor[2] = (unsigned int)tmpElem->texCoordNumber * 3;
-        tmpElem = tmpElem->next;
-        this->pModelInfo.pTriangles[index + 1].indexToVertices[1] = (unsigned int)tmpElem->vertexNumber * 3;
-        this->pModelInfo.pTriangles[index + 1].indexToNormals[1] = (unsigned int)tmpElem->normalNumber * 3;
-        this->pModelInfo.pTriangles[index + 1].indexToTexCoor[1] = (unsigned int)tmpElem->texCoordNumber * 3;
-        index += 2;
+      }
-      tmpFace = tmpFace->next;
+    }
-    this->currentGroup = this->currentGroup->next;
+  }
-  return true;
+}
-/**
- *  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:
-. The Vertex itself
-. The VertexNormale
-. The VertexTextureCoordinate
-   merging this information, the face will be drawn.
-*/
-bool StaticModel::addGLElement (ModelFaceElement* elem)
+{
-  PRINTF(5)("importing grafical Element to openGL.\n");
-  if (elem->texCoordNumber > -1)
+  {
-    if (likely((unsigned int)elem->texCoordNumber < this->pModelInfo.numTexCoor))
-      glTexCoord2fv(&this->vTexture[0] + elem->texCoordNumber * 2);
-    else
-      PRINTF(2)("TextureCoordinate %d is not in the List (max: %d)\nThe Model might be incomplete\n",
-                elem->texCoordNumber, this->pModelInfo.numTexCoor);
+  }
-  if (elem->normalNumber > -1)
+  {
-    if (likely((unsigned int)elem->normalNumber < this->pModelInfo.numNormals))
-      glNormal3fv(&this->normals[0] + elem->normalNumber * 3);
-    else
-      PRINTF(2)("Normal %d is not in the List (max: %d)\nThe Model might be incomplete",
-                elem->normalNumber, this->pModelInfo.numNormals);
+  }
-  if (elem->vertexNumber > -1)
+  {
-    if (likely((unsigned int)elem->vertexNumber < this->pModelInfo.numVertices))
-      glVertex3fv(&this->vertices[0]+ elem->vertexNumber * 3);
-    else
-      PRINTF(2)("Vertex %d is not in the List (max: %d)\nThe Model might be incomplete",
-                elem->vertexNumber, this->pModelInfo.numVertices);
+  }
-  return true;
+}
-/**
- *  Includes a default model
-   This will inject a Cube, because this is the most basic model.
-*/
 void StaticModel::cubeModel()
+{

trunk/src/lib/graphics/importer/static_model.h

-                      r7221
+                      r9869
 #include "material.h"
-#include "glincl.h"
 #include <vector>
+#include <list>
+// definition of different modes for setting up Faces
+#define VERTEX 0       //!< If Faces are created WITH Vertex-Coordinate
+#define NORMAL 1       //!< If Faces are created WITH Normals (otherwise autocalculate)
+#define TEXCOORD 2     //!< If Faces are created WITH TextureCoordinate
+//! an enumerator for VERTEX_FORMAT
+typedef enum VERTEX_FORMAT {
+  VERTEX_ONLY = VERTEX,
+  VERTEX_NORMAL = NORMAL,
+  VERTEX_TEXCOORD = TEXCOORD,
+  VERTEX_TEXCOORD_NORMAL = NORMAL | TEXCOORD
+};
+////////////////////
+/// SUB-ELEMENTS ///
+////////////////////
+//! This is the placeholder of one Vertex beloning to a Face.
+class ModelFaceElement
+{
+ public:
+  ModelFaceElement();
+  ~ModelFaceElement();
+  int                 vertexNumber;         //!< The number of the Vertex out of the Array* vertices, this vertex points to.
+  int                 normalNumber;         //!< The number of the Normal out of the Array* normals, this vertex points to.
+  int                 texCoordNumber;       //!< The number of the textureCoordinate out of the Array* vTexture, this vertex points to.
+  ModelFaceElement*   next;                 //!< Point to the next FaceElement in this List.
+};
+//! This is the placeholder of a Face belonging to a Group of Faces.
+class ModelFace
+{
+ public:
+  ModelFace();
+  ~ModelFace();
+  unsigned int        vertexCount;     //!< The Count of vertices this Face has.
+  ModelFaceElement*   firstElem;       //!< Points to the first Vertex (FaceElement) of this Face.
+  Material*           material;        //!< The Material to use.
+  ModelFace*          next;            //!< Pointer to the next Face.
+};
+//! Group to handle multiple Models per obj-file.
+class ModelGroup
+{
+ public:
+  ModelGroup();
+  ~ModelGroup();
+  void cleanup();
+  std::string  name;           //!< the Name of the Group. this is an identifier, that can be accessed via the draw (std::string name) function.
+  GLubyte*     indices;        //!< The indices of the Groups. Needed for vertex-arrays
+  GLuint       listNumber;     //!< The number of the GL-List this Group gets.
+  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          faceCount;      //!< The Number of Faces this Group holds.
+  ModelGroup*  next;           //!< Pointer to the next Group.
+};
+struct ModelMaterial
+{
+  Material* material;
+  bool external;
+};
+#include "static_model_data.h"
 /////////////
 …
 class StaticModel : public Model
+{
+ public:
+  ObjectListDeclaration(StaticModel);
+public:
   StaticModel(const std::string& modelName = "");
+  StaticModel(const StaticModel& staticModel);
   virtual ~StaticModel();
+  virtual void draw() const;
+  void draw(int groupNumber) const;
+  void draw(const std::string& groupName) const;
+  StaticModel& operator=(const StaticModel& model);
+  void rebuild();
+  virtual void draw() const { data->draw(); };
+  void draw(int groupNumber) const { data->draw(groupNumber); };
+  void draw(const std::string& groupName) const { data->draw(groupName); };
+  Material* addMaterial(Material* material);
+  Material* addMaterial(const std::string& materialName);
+  void rebuild() { data->rebuild(); };
+  bool addGroup(const std::string& groupString);
+  Material* addMaterial(Material* material) { return data->addMaterial(material); };
+  Material* addMaterial(const std::string& materialName) { return data->addMaterial(materialName); };
+  bool addVertex(const std::string& vertexString);
+  bool addVertex(float x, float y, float z);
+  bool addGroup(const std::string& groupString) { return data->addGroup(groupString); };
+  bool addFace(const std::string& faceString);
+  bool addVertex(const std::string& vertexString) { return data->addVertex(vertexString); };
+  bool addVertex(float x, float y, float z) { return data->addVertex(x, y, z); };
+  bool addFace(const std::string& faceString) { return data->addFace(faceString); };
   bool addFace(int faceElemCount, VERTEX_FORMAT type, ...);
   bool addVertexNormal(const std::string& normalString);
   bool addVertexNormal(float x, float y, float z);
+  bool addVertexNormal(const std::string& normalString) { return this->data->addVertexNormal(normalString); };
+  bool addVertexNormal(float x, float y, float z) { return this->data->addVertexNormal(x,y,z); };
   bool addVertexTexture(const std::string& vTextureString);
   bool addVertexTexture(float u, float v);
+  bool addVertexTexture(const std::string& vTextureString) { return this->data->addVertexTexture(vTextureString); };
+  bool addVertexTexture(float u, float v) { return this->data->addVertexTexture(u, v); };
   bool setMaterial(const std::string& mtlString);
   bool setMaterial(Material* mtl);
+  bool setMaterial(const std::string& mtlString) { return data->setMaterial(mtlString); };
+  bool setMaterial(Material* mtl) { return data->setMaterial(mtl);};
   void finalize();
+  void acquireData(const StaticModelData::Pointer& data);
+  const StaticModelData::Pointer& dataPointer() const { return this->data; };
+ protected:
+  inline void setScaleFactor(float scaleFactor) { this->data->setScaleFactor(scaleFactor); };
+  float getScaleFactor() const { return data->getScaleFactor(); }
+protected:
   void cubeModel();
+  Material* findMaterialByName(const std::string& materialName);
+ protected:
+  float            scaleFactor;     //!< The Factor with which the Model should be scaled. @todo maybe one wants to scale the Model after Initialisation
+ private:
+  bool buildVertexNormals();
+  bool importToDisplayList();
+  bool buildTriangleList();
+  bool addGLElement(ModelFaceElement* elem);
+  bool cleanup();
+ private:
+  bool                       finalized;       //!< Sets the Object to be finalized.
+  unsigned int               faceCount;       //!< A modelwide Counter for the faces
+  std::vector<GLfloat>       vertices;        //!< The Array that handles the Vertices.
+  std::vector<GLfloat>       normals;         //!< The Array that handles the Normals.
+  std::vector<GLfloat>       vTexture;        //!< The Array that handles the VertexTextureCoordinates.
+  ModelGroup*                firstGroup;      //!< The first of all groups.
+  ModelGroup*                currentGroup;    //!< The currentGroup. this is the one we will work with.
+  int                        groupCount;      //!< The Count of Groups.
+  std::list<ModelMaterial*>  materialList;    //!< A list for all the Materials in this Model
+private:
+  void updateBase();
+private:
+  StaticModelData::Pointer         data;
 };

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

-                      r9406
+                      r9869
 #endif
+ObjectListDefinition(Texture);
 /**
 …
     : data(texture.data)
+{
   this->setClassID(CL_TEXTURE, "Texture");
+  this->registerObject(this, Texture::_objectList);
   this->priority = 0.5;
+}
 …
 void Texture::init()
+{
   this->setClassID(CL_TEXTURE, "Texture");
   this->data = TextureDataPointer(new TextureData());
+  this->registerObject(this, Texture::_objectList);
+  this->data = TextureData::Pointer(new TextureData());
   this->priority = 0.5;
 …
+}
 Texture& Texture::operator=(const TextureDataPointer& textureDataPointer)
+Texture& Texture::operator=(const TextureData::Pointer& textureDataPointer)
+{
   this->data = textureDataPointer;

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

-                      r8761
+                      r9869
 /*!
  * @file texture.h
  * @brief Contains the texture class, that handles the reading of Images into Texutre-files.
+ * @brief Contains the texture class, that handles the reading of Images into Texture-files.
  */
 …
 class Texture : public BaseObject
+{
+  ObjectListDeclaration(Texture);
 public:
   Texture();
 …
   Texture& operator=(const Texture& texture);
+  Texture& operator=(const TextureDataPointer& textureDataPointer);
+  Texture& operator=(const TextureData::Pointer& textureDataPointer);
+  void acquireData(const TextureData::Pointer& textureDataPointer) { this->data = textureDataPointer; };
+  const TextureData::Pointer& dataPointer() const { return data; }
   virtual ~Texture();
 …
 private:
   TextureDataPointer            data;               //!< The TextureData
+  TextureData::Pointer          data;               //!< The TextureData
   GLclampf                      priority;           //!< the priority of the current texture (used for garphics cards with limited mem)

trunk/src/lib/graphics/importer/texture_data.h

-                      r8761
+                      r9869
 class TextureData
+{
+  public:
+    typedef CountPointer<TextureData> Pointer;
   public:
     TextureData();
 …
 };
-typedef CountPointer<TextureData> TextureDataPointer;
 #endif /* _TEXTURE_DATA_H */

trunk/src/lib/graphics/importer/texture_sequence.cc

-                      r9406
+                      r9869
 #endif
+ObjectListDefinition(TextureSequence);
 /**
  * @brief Constructor for a Texture
 …
 TextureSequence::TextureSequence(unsigned int count, ...)
+{
   this->setClassID(CL_TEXTURE_SEQUENCE, "TextureSequence");
+  this->registerObject(this, TextureSequence::_objectList);
   va_list textureNameList;
 …
 TextureSequence::TextureSequence(const std::vector<std::string>& textureNames, const std::string& prependFolder)
+{
   this->setClassID(CL_TEXTURE_SEQUENCE, "TextureSequence");
+  this->registerObject(this, TextureSequence::_objectList);
   this->loadImageSeries(textureNames, prependFolder);
+}

trunk/src/lib/graphics/importer/texture_sequence.h

r8324	r9869
15	15	class TextureSequence : public Texture
16	16	{
	17	ObjectListDeclaration(TextureSequence);
17	18	public:
18	19	TextureSequence(unsigned int count = 0, ...);

trunk/src/lib/graphics/importer/vertex_array_model.cc

-                      r9406
+                      r9869
+ObjectListDefinition(VertexArrayModel);
 /////////////
 …
 VertexArrayModel::VertexArrayModel()
+{
   this->setClassID(CL_MODEL, "VertexArrayModel");
+  this->registerObject(this, VertexArrayModel::_objectList);
   this->newStripe();
 …
 VertexArrayModel::VertexArrayModel(const Model& model)
+{
   this->setClassID(CL_MODEL, "VertexArrayModel");
+  this->registerObject(this, VertexArrayModel::_objectList);
   // importing the data to the new Model.

trunk/src/lib/graphics/importer/vertex_array_model.h

-                      r6769
+                      r9869
 class VertexArrayModel : public Model
+{
+ public:
+  ObjectListDeclaration(VertexArrayModel);
+  public:
   VertexArrayModel();
   VertexArrayModel(const Model& model);

trunk/src/lib/graphics/light.cc

-                      r8742
+                      r9869
 #include "glincl.h"
 #include "vector.h"
+#include "parser/tinyxml/tinyxml.h"
+#include "util/loading/load_param.h"
+#include "util/loading/load_param_xml.h"
 #include "util/loading/factory.h"
 #include "debug.h"
+CREATE_FACTORY(Light, CL_LIGHT);
+#include "class_id_DEPRECATED.h"
+ObjectListDefinitionID(Light, CL_LIGHT);
+CREATE_FACTORY(Light);
 //! Definition of the Lights and their Names
 …
   PRINTF(4)("initializing Light number %d.\n", this->lightNumber);
+  this->registerObject(this, Light::_objectList);
   this->lightNumber = LightManager::getInstance()->registerLight(this);
-  this->setClassID(CL_LIGHT, "Light");
   char tmpName[10];
   sprintf(tmpName, "Light[%d]", this->lightNumber);
 …
 ** LIGHT-MANAGER **
 ******************/
+ObjectListDefinition(LightManager);
 /**
  *  standard constructor for a Light
 …
 LightManager::LightManager ()
+{
   this->setClassID(CL_LIGHT_MANAGER, "LightManager");
+  this->registerObject(this, LightManager::_objectList);
   glEnable (GL_LIGHTING);

trunk/src/lib/graphics/light.h

-                      r8255
+                      r9869
 class Light : public PNode
+{
+        public:
+                Light(const TiXmlElement* root = NULL);
+                virtual ~Light();
+                virtual void loadParams(const TiXmlElement* root);
+                void setDiffuseColor(GLfloat r, GLfloat g, GLfloat b);
+                void setSpecularColor(GLfloat r, GLfloat g, GLfloat b);
+                void setAttenuation(float constantAttenuation, float linearAttenuation, float quadraticAttenuation);
+                void setSpotDirection(const Vector& direction);
+                void setSpotDirection(float x, float y, float z) { setSpotDirection(Vector(x,y,z)); };
+                void setSpotCutoff(GLfloat cutoff);
+                /** @returns the lightNumber*/
+                int getLightNumber() const {return this->lightNumber;}
+                virtual void draw() const;
+                void debug() const;
+        // attributes
+        private:
+                int              lightNumber;               //!< The number of this Light.
+                GLfloat          diffuseColor[4];           //!< The Diffuse Color this Light emmits.
+                GLfloat          specularColor[4];          //!< The specular Color of this Light.
+                float            constantAttenuation;       //!< The Factor of the the Constant Attenuation.
+                float            linearAttenuation;         //!< The Factor of the the Linear Attenuation.
+                float            quadraticAttenuation;      //!< The Factor of the the Quadratic Attenuation.
+                GLfloat          spotDirection[4];          //!< The direction of the Spot Light.
+                GLfloat          spotCutoff;                //!< The cutoff Angle of the Light Source
+  ObjectListDeclaration(Light);
+public:
+  Light(const TiXmlElement* root = NULL);
+  virtual ~Light();
+  virtual void loadParams(const TiXmlElement* root);
+  void setDiffuseColor(GLfloat r, GLfloat g, GLfloat b);
+  void setSpecularColor(GLfloat r, GLfloat g, GLfloat b);
+  void setAttenuation(float constantAttenuation, float linearAttenuation, float quadraticAttenuation);
+  void setSpotDirection(const Vector& direction);
+  void setSpotDirection(float x, float y, float z) { setSpotDirection(Vector(x,y,z)); };
+  void setSpotCutoff(GLfloat cutoff);
+  /** @returns the lightNumber*/
+  int getLightNumber() const {return this->lightNumber;}
+  virtual void draw() const;
+  void debug() const;
+  // attributes
+private:
+  int              lightNumber;               //!< The number of this Light.
+  GLfloat          diffuseColor[4];           //!< The Diffuse Color this Light emmits.
+  GLfloat          specularColor[4];          //!< The specular Color of this Light.
+  float            constantAttenuation;       //!< The Factor of the the Constant Attenuation.
+  float            linearAttenuation;         //!< The Factor of the the Linear Attenuation.
+  float            quadraticAttenuation;      //!< The Factor of the the Quadratic Attenuation.
+  GLfloat          spotDirection[4];          //!< The direction of the Spot Light.
+  GLfloat          spotCutoff;                //!< The cutoff Angle of the Light Source
 };
 //! A class that handles Lights
 /**
 …
 */
 class LightManager : public BaseObject
+        {
         friend class Light;
+{
+  ObjectListDeclaration(LightManager);
+        public:
+                virtual ~LightManager();
+                /** @returns a Pointer to the only object of this Class */
+                inline static LightManager* getInstance() { if (!singletonRef) singletonRef = new LightManager();  return singletonRef; };
+  friend class Light;
+public:
+  virtual ~LightManager();
+  /** @returns a Pointer to the only object of this Class */
+  inline static LightManager* getInstance() { if (!singletonRef) singletonRef = new LightManager();  return singletonRef; };
                 virtual void loadParams(const TiXmlElement* root);
                 void loadLights(const TiXmlElement* root);
+  virtual void loadParams(const TiXmlElement* root);
+  void loadLights(const TiXmlElement* root);
                 void setAmbientColor(GLfloat r, GLfloat g, GLfloat b);
                 // HACK: Assuming r = g = b values
                 inline GLfloat getAmbientColor() {  return this->ambientColor[0]; }
+  void setAmbientColor(GLfloat r, GLfloat g, GLfloat b);
+  // HACK: Assuming r = g = b values
+inline GLfloat getAmbientColor() {  return this->ambientColor[0]; }
                 Light* getLight(int lightNumber) const;
                 inline Light* getLight() const { return this->currentLight; };
+  Light* getLight(int lightNumber) const;
+  inline Light* getLight() const { return this->currentLight; };
                 void draw() const;
+  void draw() const;
                 void debug() const;
+  void debug() const;
         private:
                 LightManager();
+private:
+  LightManager();
                 int  registerLight(Light* light);
                 void unregisterLight(Light* light);
+  int  registerLight(Light* light);
+  void unregisterLight(Light* light);
         private:
                 static LightManager*    singletonRef;       //!< This is the LightHandlers Reference.
                 GLfloat                 ambientColor[4];    //!< The ambient Color of the scene.
+private:
+  static LightManager*    singletonRef;       //!< This is the LightHandlers Reference.
+  GLfloat                 ambientColor[4];    //!< The ambient Color of the scene.
                 Light**                 lights;             //!< An array of Lenght NUMBEROFLIGHTS, that holds pointers to all LightValues.
                 Light*                  currentLight;       //!< The current Light, we are working with.
+  Light**                 lights;             //!< An array of Lenght NUMBEROFLIGHTS, that holds pointers to all LightValues.
+  Light*                  currentLight;       //!< The current Light, we are working with.
 };

trunk/src/lib/graphics/render2D/element_2d.cc

-                      r9406
+                      r9869
 #include "graphics_engine.h"
 #include "util/loading/load_param.h"
-#include "class_list.h"
 #include "color.h"
+#include "debug.h"
 #include "shell_command.h"
 SHELL_COMMAND(debug, Element2D, debug2D);
+ObjectListDefinition(Element2D);
 …
 Element2D::Element2D (Element2D* parent, E2D_LAYER layer, short nodeFlags)
+{
   this->setClassID(CL_ELEMENT_2D, "Element2D");
+  this->registerObject(this, Element2D::_objectList);
   this->setVisibility(true);
 …
 void Element2D::setBindNode(const std::string& bindNode)
+{
   const PNode* tmpBindNode = dynamic_cast<const PNode*>(ClassList::getObject(bindNode, CL_PARENT_NODE));
+  const PNode* tmpBindNode = PNode::objectList().getObject(bindNode);
   if (tmpBindNode != NULL)
     this->bindNode = tmpBindNode;
 …
 void Element2D::addChild2D (const std::string& childName)
+{
   Element2D* childNode = dynamic_cast<Element2D*>(ClassList::getObject(childName, CL_ELEMENT_2D));
+  Element2D* childNode = Element2D::objectList().getObject(childName);
   if (childNode != NULL)
     this->addChild2D(childNode);
 …
 void Element2D::setParent2D (const std::string& parentName)
+{
   Element2D* parentNode = dynamic_cast<Element2D*>(ClassList::getObject(parentName, CL_ELEMENT_2D));
+  Element2D* parentNode = Element2D::objectList().getObject(parentName);
   if (parentNode != NULL)
     parentNode->addChild2D(this);
 …
 void Element2D::setParentSoft2D(const std::string& parentName, float bias)
+{
   Element2D* parentNode = dynamic_cast<Element2D*>(ClassList::getObject(parentName, CL_ELEMENT_2D));
+  Element2D* parentNode = Element2D::objectList().getObject(parentName);
   if (parentNode != NULL)
     this->setParentSoft2D(parentNode, bias);

trunk/src/lib/graphics/render2D/element_2d.h

-                      r8360
+                      r9869
   E2D_PARENT_MOVEMENT                = 0x0004,    //!< Moves all children along with the parent.
 // special linkage modes
+  // special linkage modes
   E2D_PARENT_ALL                     = 0x0003,    //!< Moves all children around the center of their parent, and also rotates their centers
   E2D_PARENT_ROTATE_AND_MOVE         = 0x0005,    //!< Rotates all children around their axis, and moves them as the Parent Moves, but does not rotate around the center of their parent.
 …
   E2D_REPARENT_DELETE_CHILDREN       = 0x0040,    //!< Deletes the Children of the node when This Node is Removed. (Use with care).
   /// FIXME
    E2D_REPARENT_KEEP_POSITION         = 0x0080,   //!< Tries to keep the Position if the Node is reparented.
+  E2D_REPARENT_KEEP_POSITION         = 0x0080,   //!< Tries to keep the Position if the Node is reparented.
 …
  * -> the tree is sorted on insertion of a new Child: @see Element2D::addChild2D()
  */
+class Element2D : virtual public BaseObject {
+  public:
+    Element2D(Element2D* parent = Element2D::getNullElement(), E2D_LAYER layer = E2D_DEFAULT_LAYER, short nodeFlags = E2D_PARENT_MODE_DEFAULT);
+    virtual ~Element2D();
+    virtual void loadParams(const TiXmlElement* root);
+    // ACTIVATION //
+    inline void activate2D() { this->bActive = this->bRelCoorChanged = this->bRelDirChanged = true; };
+    inline void deactivate2D() { this->bActive = false; };
+    inline bool get2DActiveState() { return this->bActive; };
+    // ALIGNMENT //
+    /** @param alignment the new Alignment of the 2D-Element */
+    inline void setAlignment(E2D_ALIGNMENT alignment) { this->alignment = alignment; };
+    void setAlignment(const std::string& alignment);
+    inline E2D_ALIGNMENT getAlignment() const { return this->alignment; };
+    // LAYERING //
+    void setLayer(E2D_LAYER layer);
+    void setLayer(const std::string& layer);
+    /** @returns the Layer this Element is drawn to */
+    inline E2D_LAYER getLayer() const { return this->layer; };
+    // VISIBILITY //
+    /** @param visible true if the Element should be visible false otherwise (will not be rendered) */
+    inline void setVisibility(bool visible) { this->bVisible = visible; };
+    /** @returns the visibility state */
+    inline bool isVisible() const { return (this->bVisible && this->bCurrentlyVisible);  };
+    // POSITIONAL (E2D-specials) //
+    /** @param bindNode the Node this 2D-element should follow. if NULL the Element will not follow anything */
+    void setBindNode(const PNode* bindNode);
+    void setBindNode(const std::string& bindNode);
+    inline const PNode* getBindNode() const { return this->bindNode; };
+    inline void setSize2D(float x, float y) { this->size = Vector2D(x, y); };
+    inline void setSize2D(const Vector2D& size) { this->size = size; };
+    inline const Vector2D& getSize2D() const { return this->size; };
+    void setSizeSoft2D(float x, float y, float bias = 1.0);
+    inline void setSizeX2D(float x) { this->size.x = x; };
+    inline void setSizeY2D(float y) { this->size.y = y; };
+    inline float getSizeX2D() const { return this->size.x; };
+    inline float getSizeY2D() const { return this->size.y; };
+  public:
+    virtual void tick(float dt) {};
+    virtual void draw() const  {};
+    void tick2D(float dt);
+    void draw2D(E2D_LAYER from, E2D_LAYER to) const;
+    void drawChildren(E2D_LAYER from, E2D_LAYER to) const;
+    // LIKE PNODE
+  public:
+    void setRelCoor2D (const Vector2D& relCoord);
+    void setRelCoorX2D(float x);
+    void setRelCoorY2D(float y);
+    void setRelCoor2D (float x, float y);
+    void setRelCoor2Dpx (int x, int y);
+    void setRelCoorSoft2D (const Vector2D& relCoordSoft, float bias = 1.0);
+    void setRelCoorSoft2D (float x, float y, float bias = 1.0);
+    void setRelCoorSoft2Dpx (int x, int y, float bias = 1.0);
+    /** @returns the relative position */
+    inline const Vector2D& getRelCoor2D () const { return this->prevRelCoordinate; };
+    /** @returns the Relative Coordinate Destination */
+    inline const Vector2D& getRelCoorSoft2D() const { return (this->toCoordinate)?*this->toCoordinate:this->relCoordinate; };
+    const Vector2D& getRelCoor2Dpx() const;
+    void setAbsCoor2D (const Vector2D& absCoord);
+    void setAbsCoor2D (float x, float y);
+    void setAbsCoorX2D(float x);
+    void setAbsCoorY2D(float y);
+    void setAbsCoor2Dpx (int x, int y);
+    void setAbsCoorSoft2D (const Vector2D& absCoordSoft, float bias = 1.0);
+    void setAbsCoorSoft2D (float x, float y, float bias = 1.0);
+    /** @returns the absolute position */
+    inline const Vector2D& getAbsCoor2D () const { return this->absCoordinate; };
+    const Vector2D& getAbsCoor2Dpx () const;
+    void shiftCoor2D (const Vector2D& shift);
+    void shiftCoor2Dpx (int x, int y);
+    void setRelDir2D (float relDir);
+    void setRelDirSoft2D(float relDirSoft, float bias = 1.0);
+    /** @returns the relative Direction */
+    inline float getRelDir2D () const { return this->prevRelDirection; };
+    /** @returns the Relative Directional Destination */
+    inline float getRelDirSoft2D() const { return (this->toDirection)?*this->toDirection:this->relDirection; };
+    void setAbsDir2D (float absDir);
+    void setAbsDirSoft2D (float absDirSoft, float bias = 1.0);
+    /** @returns the absolute Direction */
+    inline float getAbsDir2D () const { return this->absDirection; };
+    void shiftDir2D (float shiftDir);
+    /** @returns the Speed of the Node */
+    inline float getSpeed() const { return 0; };
+    /** @returns the Velocity of the Node */
+    inline const Vector2D& getVelocity() const { return this->velocity; };
+    void addChild2D (Element2D* child);
+    void addChild2D (const std::string& childName);
+    void removeChild2D (Element2D* child);
+    void remove2D();
+    /** @param parent the new parent of this Element2D */
+    void setParent2D (Element2D* parent) { parent->addChild2D(this); };
+    void setParent2D (const std::string& parentName);
+    /** @returns the parent of this Element2D */
+    inline Element2D* getParent2D () const { return this->parent; };
+    /** @returns the List of Children of this Element2D */
+    inline const std::list<Element2D*>& getChildren2D() const { return this->children; };
+    void setParentSoft2D(Element2D* parentNode, float bias = 1.0);
+    void setParentSoft2D(const std::string& parentName, float bias = 1.0);
+    void setParentMode2D (E2D_PARENT_MODE parentMode);
+    void setParentMode2D (const std::string& parentingMode);
+    /** @returns the Parenting mode of this node */
+    int getParentMode2D() const { return this->parentMode; };
+    // NULL_PARENT //
+    /** @returns the NullParent, the (main) ROOT of the PNode Tree. If it does not yet exist, it will be created. */
+    static Element2D* getNullElement()  { return (Element2D::nullElement != NULL)? Element2D::nullElement : Element2D::createNullElement(); };
+    void update2D (float dt);
+    void debug2D (unsigned int depth = 1, unsigned int level = 0) const;
+    void debugDraw2D(unsigned int depth = 1, float size = 1.0, Vector color = Vector(1,0,0), unsigned int level = 0) const;
+    // helper functions //
+    static const char* parentingModeToString2D(int parentingMode);
+    static E2D_PARENT_MODE stringToParentingMode2D(const std::string& parentingMode);
+    static const char* layer2DToChar(E2D_LAYER layer);
+    static E2D_LAYER charToLayer2D(const std::string& layer);
+    static bool layerSortPredicate(const Element2D* elem1, const Element2D* elem2);
+  private:
+    void eraseChild2D(Element2D* child);
+    /** tells the child that the parent's Coordinate has changed */
+    inline void parentCoorChanged2D () { this->bRelCoorChanged = true; }
+    /** tells the child that the parent's Direction has changed */
+    inline void parentDirChanged2D () { this->bRelDirChanged = true; }
+    /** @returns the last calculated coordinate */
+    inline Vector2D getLastAbsCoor2D() { return this->lastAbsCoordinate; }
+    void reparent2D();
+    static Element2D* createNullElement();
+    bool checkIntegrity(const Element2D* checkParent) const;
+  private:
+    const PNode*            bindNode;           //!< a node over which to display this 2D-element
+    Vector2D                size;               //!< The size of the rendered item
+    Vector2D*               toSize;             //!< The Size to iterate to.
+    E2D_ALIGNMENT           alignment;          //!< How the Element is aligned around its Position
+    bool                    bVisible;           //!< If the given Element2D is visible.
+    bool                    bCurrentlyVisible;  //!< Evaluated in the TICK process, to see if the Element is Currently visible.
+    bool                    bActive;            //!< If the given Element2D is active.
+    E2D_LAYER               layer;              //!< What layer this Element2D is on.
+    bool                    bRelCoorChanged;    //!< If Relative Coordinate has changed since last time we checked
+    bool                    bRelDirChanged;     //!< If Relative Direction has changed since last time we checked
+    Vector2D                relCoordinate;      //!< coordinates relative to the parent
+    Vector2D                absCoordinate;      //!< absolute coordinates in the world ( from (0,0,0) )
+    float                   relDirection;       //!< direction relative to the parent
+    float                   absDirection;       //!< absolute diretion in the world ( from (0,0,1) )
+    Vector2D                prevRelCoordinate;  //!< The last Relative Coordinate from the last update-Cycle.
+    Vector2D                lastAbsCoordinate;  //!< this is used for speedcalculation, it stores the last coordinate
+    float                   prevRelDirection;   //!< The last Relative Direciton from the last update-Cycle.
+    Vector2D                velocity;           //!< Saves the velocity.
+    Vector2D*               toCoordinate;       //!< a position to which to iterate. (This is used in conjunction with setParentSoft.and set*CoorSoft)
+    float*                  toDirection;        //!< a direction to which to iterate. (This is used in conjunction with setParentSoft and set*DirSoft)
+    float                   bias;               //!< how fast to iterate to the given position (default is 1)
+    Element2D*              parent;             //!< a pointer to the parent node
+    std::list<Element2D*>   children;           //!< list of the children of this Element2D
+    unsigned int            parentMode;         //!< the mode of the binding
+    static Element2D*       nullElement;        //!< The top-most Element
+class Element2D : virtual public BaseObject
+{
+  ObjectListDeclaration(Element2D);
+public:
+  Element2D(Element2D* parent = Element2D::getNullElement(), E2D_LAYER layer = E2D_DEFAULT_LAYER, short nodeFlags = E2D_PARENT_MODE_DEFAULT);
+  virtual ~Element2D();
+  virtual void loadParams(const TiXmlElement* root);
+  // ACTIVATION //
+  inline void activate2D() { this->bActive = this->bRelCoorChanged = this->bRelDirChanged = true; };
+  inline void deactivate2D() { this->bActive = false; };
+  inline bool get2DActiveState() { return this->bActive; };
+  // ALIGNMENT //
+  /** @param alignment the new Alignment of the 2D-Element */
+  inline void setAlignment(E2D_ALIGNMENT alignment) { this->alignment = alignment; };
+  void setAlignment(const std::string& alignment);
+  inline E2D_ALIGNMENT getAlignment() const { return this->alignment; };
+  // LAYERING //
+  void setLayer(E2D_LAYER layer);
+  void setLayer(const std::string& layer);
+  /** @returns the Layer this Element is drawn to */
+  inline E2D_LAYER getLayer() const { return this->layer; };
+  // VISIBILITY //
+  /** @param visible true if the Element should be visible false otherwise (will not be rendered) */
+  inline void setVisibility(bool visible) { this->bVisible = visible; };
+  /** @returns the visibility state */
+  inline bool isVisible() const { return (this->bVisible && this->bCurrentlyVisible);  };
+  // POSITIONAL (E2D-specials) //
+  /** @param bindNode the Node this 2D-element should follow. if NULL the Element will not follow anything */
+  void setBindNode(const PNode* bindNode);
+  void setBindNode(const std::string& bindNode);
+  inline const PNode* getBindNode() const { return this->bindNode; };
+  inline void setSize2D(float x, float y) { this->size = Vector2D(x, y); };
+  inline void setSize2D(const Vector2D& size) { this->size = size; };
+  inline const Vector2D& getSize2D() const { return this->size; };
+  void setSizeSoft2D(float x, float y, float bias = 1.0);
+  inline void setSizeX2D(float x) { this->size.x = x; };
+  inline void setSizeY2D(float y) { this->size.y = y; };
+  inline float getSizeX2D() const { return this->size.x; };
+  inline float getSizeY2D() const { return this->size.y; };
+public:
+  virtual void tick(float dt) {};
+  virtual void draw() const  {};
+  void tick2D(float dt);
+  void draw2D(E2D_LAYER from, E2D_LAYER to) const;
+  void drawChildren(E2D_LAYER from, E2D_LAYER to) const;
+  // LIKE PNODE
+public:
+  void setRelCoor2D (const Vector2D& relCoord);
+  void setRelCoorX2D(float x);
+  void setRelCoorY2D(float y);
+  void setRelCoor2D (float x, float y);
+  void setRelCoor2Dpx (int x, int y);
+  void setRelCoorSoft2D (const Vector2D& relCoordSoft, float bias = 1.0);
+  void setRelCoorSoft2D (float x, float y, float bias = 1.0);
+  void setRelCoorSoft2Dpx (int x, int y, float bias = 1.0);
+  /** @returns the relative position */
+  inline const Vector2D& getRelCoor2D () const { return this->prevRelCoordinate; };
+  /** @returns the Relative Coordinate Destination */
+inline const Vector2D& getRelCoorSoft2D() const { return (this->toCoordinate)?*this->toCoordinate:this->relCoordinate; };
+  const Vector2D& getRelCoor2Dpx() const;
+  void setAbsCoor2D (const Vector2D& absCoord);
+  void setAbsCoor2D (float x, float y);
+  void setAbsCoorX2D(float x);
+  void setAbsCoorY2D(float y);
+  void setAbsCoor2Dpx (int x, int y);
+  void setAbsCoorSoft2D (const Vector2D& absCoordSoft, float bias = 1.0);
+  void setAbsCoorSoft2D (float x, float y, float bias = 1.0);
+  /** @returns the absolute position */
+  inline const Vector2D& getAbsCoor2D () const { return this->absCoordinate; };
+  const Vector2D& getAbsCoor2Dpx () const;
+  void shiftCoor2D (const Vector2D& shift);
+  void shiftCoor2Dpx (int x, int y);
+  void setRelDir2D (float relDir);
+  void setRelDirSoft2D(float relDirSoft, float bias = 1.0);
+  /** @returns the relative Direction */
+  inline float getRelDir2D () const { return this->prevRelDirection; };
+  /** @returns the Relative Directional Destination */
+inline float getRelDirSoft2D() const { return (this->toDirection)?*this->toDirection:this->relDirection; };
+  void setAbsDir2D (float absDir);
+  void setAbsDirSoft2D (float absDirSoft, float bias = 1.0);
+  /** @returns the absolute Direction */
+  inline float getAbsDir2D () const { return this->absDirection; };
+  void shiftDir2D (float shiftDir);
+  /** @returns the Speed of the Node */
+  inline float getSpeed() const { return 0; };
+  /** @returns the Velocity of the Node */
+  inline const Vector2D& getVelocity() const { return this->velocity; };
+  void addChild2D (Element2D* child);
+  void addChild2D (const std::string& childName);
+  void removeChild2D (Element2D* child);
+  void remove2D();
+  /** @param parent the new parent of this Element2D */
+  void setParent2D (Element2D* parent) { parent->addChild2D(this); };
+  void setParent2D (const std::string& parentName);
+  /** @returns the parent of this Element2D */
+  inline Element2D* getParent2D () const { return this->parent; };
+  /** @returns the List of Children of this Element2D */
+  inline const std::list<Element2D*>& getChildren2D() const { return this->children; };
+  void setParentSoft2D(Element2D* parentNode, float bias = 1.0);
+  void setParentSoft2D(const std::string& parentName, float bias = 1.0);
+  void setParentMode2D (E2D_PARENT_MODE parentMode);
+  void setParentMode2D (const std::string& parentingMode);
+  /** @returns the Parenting mode of this node */
+  int getParentMode2D() const { return this->parentMode; };
+  // NULL_PARENT //
+  /** @returns the NullParent, the (main) ROOT of the PNode Tree. If it does not yet exist, it will be created. */
+static Element2D* getNullElement()  { return (Element2D::nullElement != NULL)? Element2D::nullElement : Element2D::createNullElement(); };
+  void update2D (float dt);
+  void debug2D (unsigned int depth = 1, unsigned int level = 0) const;
+  void debugDraw2D(unsigned int depth = 1, float size = 1.0, Vector color = Vector(1,0,0), unsigned int level = 0) const;
+  // helper functions //
+  static const char* parentingModeToString2D(int parentingMode);
+  static E2D_PARENT_MODE stringToParentingMode2D(const std::string& parentingMode);
+  static const char* layer2DToChar(E2D_LAYER layer);
+  static E2D_LAYER charToLayer2D(const std::string& layer);
+  static bool layerSortPredicate(const Element2D* elem1, const Element2D* elem2);
+private:
+  void eraseChild2D(Element2D* child);
+  /** tells the child that the parent's Coordinate has changed */
+  inline void parentCoorChanged2D () { this->bRelCoorChanged = true; }
+  /** tells the child that the parent's Direction has changed */
+  inline void parentDirChanged2D () { this->bRelDirChanged = true; }
+  /** @returns the last calculated coordinate */
+  inline Vector2D getLastAbsCoor2D() { return this->lastAbsCoordinate; }
+  void reparent2D();
+  static Element2D* createNullElement();
+  bool checkIntegrity(const Element2D* checkParent) const;
+private:
+  const PNode*            bindNode;           //!< a node over which to display this 2D-element
+  Vector2D                size;               //!< The size of the rendered item
+  Vector2D*               toSize;             //!< The Size to iterate to.
+  E2D_ALIGNMENT           alignment;          //!< How the Element is aligned around its Position
+  bool                    bVisible;           //!< If the given Element2D is visible.
+  bool                    bCurrentlyVisible;  //!< Evaluated in the TICK process, to see if the Element is Currently visible.
+  bool                    bActive;            //!< If the given Element2D is active.
+  E2D_LAYER               layer;              //!< What layer this Element2D is on.
+  bool                    bRelCoorChanged;    //!< If Relative Coordinate has changed since last time we checked
+  bool                    bRelDirChanged;     //!< If Relative Direction has changed since last time we checked
+  Vector2D                relCoordinate;      //!< coordinates relative to the parent
+  Vector2D                absCoordinate;      //!< absolute coordinates in the world ( from (0,0,0) )
+  float                   relDirection;       //!< direction relative to the parent
+  float                   absDirection;       //!< absolute diretion in the world ( from (0,0,1) )
+  Vector2D                prevRelCoordinate;  //!< The last Relative Coordinate from the last update-Cycle.
+  Vector2D                lastAbsCoordinate;  //!< this is used for speedcalculation, it stores the last coordinate
+  float                   prevRelDirection;   //!< The last Relative Direciton from the last update-Cycle.
+  Vector2D                velocity;           //!< Saves the velocity.
+  Vector2D*               toCoordinate;       //!< a position to which to iterate. (This is used in conjunction with setParentSoft.and set*CoorSoft)
+  float*                  toDirection;        //!< a direction to which to iterate. (This is used in conjunction with setParentSoft and set*DirSoft)
+  float                   bias;               //!< how fast to iterate to the given position (default is 1)
+  Element2D*              parent;             //!< a pointer to the parent node
+  std::list<Element2D*>   children;           //!< list of the children of this Element2D
+  unsigned int            parentMode;         //!< the mode of the binding
+  static Element2D*       nullElement;        //!< The top-most Element
 };

trunk/src/lib/graphics/render2D/image_plane.cc

-                      r9406
+                      r9869
 #include "graphics_engine.h"
-#include "glincl.h"
 #include "p_node.h"
+#include "class_id_DEPRECATED.h"
+CREATE_FACTORY(ImagePlane, CL_IMAGE_ENTITY);
+ObjectListDefinitionID(ImagePlane, CL_IMAGE_PLANE);
+CREATE_FACTORY(ImagePlane);
 …
 void ImagePlane::init()
+{
   this->setClassID(CL_IMAGE_PLANE, "ImagePlane");
+  this->registerObject(this, ImagePlane::_objectList);
   this->setName("ImagePlane");

trunk/src/lib/graphics/render2D/image_plane.h

r7843	r9869
17	17	class ImagePlane : public Element2D
18	18	{
19
	19	ObjectListDeclaration(ImagePlane);
20	20	public:
21	21	ImagePlane(const TiXmlElement* root = NULL);

trunk/src/lib/graphics/render2D/render_2d.cc

-                      r9406
+                      r9869
 #include "graphics_engine.h"
-#include "class_list.h"
 #include "element_2d.h"
+ObjectListDefinition(Render2D);
 …
 Render2D::Render2D ()
+{
    this->setClassID(CL_RENDER_2D, "Render2D");
    this->setName("Render2D");
+  this->registerObject(this, Render2D::_objectList);
+  this->setName("Render2D");
    this->showNodes = false;
+  this->showNodes = false;
+}

trunk/src/lib/graphics/render2D/render_2d.h

-                      r7840
+                      r9869
 //! A default singleton class.
+class Render2D : public BaseObject {
+class Render2D : public BaseObject
+{
+  ObjectListDeclaration(Render2D);
   friend class Element2D;
   public:
     virtual ~Render2D();
     /** @returns a Pointer to the only object of this Class */
     inline static Render2D* getInstance() { if (!singletonRef) singletonRef = new Render2D();  return singletonRef; };
+public:
+  virtual ~Render2D();
+  /** @returns a Pointer to the only object of this Class */
+  inline static Render2D* getInstance() { if (!singletonRef) singletonRef = new Render2D();  return singletonRef; };
     void toggleNodesVisibility() { this->showNodes = !this->showNodes; };
+void toggleNodesVisibility() { this->showNodes = !this->showNodes; };
     void update(float dt);
     void tick(float dt);
     void draw(E2D_LAYER from, E2D_LAYER to) const;
+  void update(float dt);
+  void tick(float dt);
+  void draw(E2D_LAYER from, E2D_LAYER to) const;
   private:
     Render2D();
     static Render2D*              singletonRef;                    //!< Reference to this class.
+private:
+  Render2D();
+  static Render2D*              singletonRef;                    //!< Reference to this class.
     bool                          showNodes;                       //!< If the debug-Nodes should be visible
  };
+  bool                          showNodes;                       //!< If the debug-Nodes should be visible
+};
 #endif /* _RENDER_2D_H */

trunk/src/lib/graphics/shader.cc

-                      r9406
+                      r9869
 #include "shader.h"
-#include "stdlibincl.h"
 #include "compiler.h"
 //#include <stdio.h>
 …
 #include "debug.h"
-#include "util/loading/resource_manager.h"
 …
+ObjectListDefinition(Shader);
+void Shader::Uniform::setV(unsigned int count, float* vv) const
+{
+  switch (count)
+  {
+    case 1:
+    glUniform1fv(this->uniform, 1, vv);
+    break;
+    case 2:
+    glUniform2fv(this->uniform, 2, vv);
+    break;
+    case 3:
+    glUniform3fv(this->uniform, 3, vv);
+    break;
+    case 4:
+    glUniform4fv(this->uniform, 4, vv);
+    break;
+  }
+}
+void Shader::Uniform::setV(unsigned int count, int* vv) const
+{
+  switch (count)
+  {
+    case 1:
+    glUniform1iv(this->uniform, 1, vv);
+    break;
+    case 2:
+    glUniform2iv(this->uniform, 2, vv);
+    break;
+    case 3:
+    glUniform3iv(this->uniform, 3, vv);
+    break;
+    case 4:
+    glUniform4iv(this->uniform, 4, vv);
+    break;
+  }
+}
+Shader::Shader()
+  : data(new ShaderData)
+{
+}
 /**
 …
 */
 Shader::Shader (const std::string& vertexShaderFile, const std::string& fragmentShaderFile)
+  : data(new ShaderData)
+{
+   this->setClassID(CL_SHADER, "Shader");
+  if (!Shader::checkShaderAbility())
+    PRINTF(2)("Your system does not support shaders\n");
+  this->load(vertexShaderFile, fragmentShaderFile);
-   this->shaderProgram = 0;
-   this->vertexShader = 0;
-   this->fragmentShader = 0;
-   if (GLEW_ARB_shader_objects && GLEW_ARB_shading_language_100)
+     {
-       this->shaderProgram = glCreateProgramObjectARB();
-       if (!vertexShaderFile.empty())
-         this->loadShaderProgramm(Shader::Vertex, vertexShaderFile);
-       if (!fragmentShaderFile.empty())
-         this->loadShaderProgramm(Shader::Fragment, fragmentShaderFile);
-       this->linkShaderProgram();
+    }
-   else
+     {
-       PRINTF(2)("Shaders are not supported on your hardware\n");
+     }
+}
+const Shader* Shader::storedShader = NULL;
+/**
+ * standard deconstructor
+ */
+Shader::~Shader ()
+void Shader::activateShader() const
+{
+  if (this->shaderProgram == glGetHandleARB(GL_PROGRAM_OBJECT_ARB))
+    Shader::deactivateShader();
+  // delete what has to be deleted here
+  this->deleteProgram(Shader::Vertex);
+  this->deleteProgram(Shader::Fragment);
+  if (this->fragmentShader != 0)
+  if (likely (this->getProgram() != 0))
+  {
+    glDetachObjectARB(this->shaderProgram, this->fragmentShader);
+    glDeleteObjectARB(this->fragmentShader);
+  }
+  if (this->vertexShader != 0)
+  {
+    glDetachObjectARB(this->shaderProgram, this->vertexShader);
+    glDeleteObjectARB(this->vertexShader);
+  }
+  if (this->shaderProgram != 0)
+  {
+    GLint status = 0;
+    //glLinkProgramARB(this->shaderProgram);
+    glDeleteObjectARB(this->shaderProgram);
+       // link error checking
+    glGetObjectParameterivARB(this->shaderProgram, GL_OBJECT_DELETE_STATUS_ARB, &status);
+    if (status == GL_INVALID_VALUE || status == GL_INVALID_OPERATION)
+      this->printError(this->shaderProgram);
+  }
+}
+Shader* Shader::getShader(const std::string& vertexShaderFile, const std::string& fragmentShaderFile)
+{
+  return (Shader*)ResourceManager::getInstance()->load(vertexShaderFile, SHADER,  RP_LEVEL, fragmentShaderFile);
+}
+bool Shader::unload(Shader* shader)
+{
+  return ResourceManager::getInstance()->unload(shader);
+}
+Shader* Shader::storedShader = NULL;
+bool Shader::loadShaderProgramm(Shader::Type type, const std::string& fileName)
+{
+  GLhandleARB shader = 0;
+  if (type != Shader::Vertex && type != Shader::Fragment)
+    return false;
+  this->deleteProgram(type);
+  std::string program;
+  if (!readShader(fileName, program))
+    return false;
+  if (type == Shader::Vertex && GLEW_ARB_vertex_shader)
+  {
+    this->vertexShaderFile = fileName;
+    shader = this->vertexShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
+  }
+  if (type == Shader::Fragment && GLEW_ARB_fragment_shader)
+  {
+    this->fragmentShaderFile = fileName;
+    shader = this->fragmentShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
+  }
+  if (shader != 0)
+  {
+    GLint status = 0;
+    const char* prog = program.c_str();
+    glShaderSourceARB(shader, 1, &prog, NULL);
+    glCompileShaderARB(shader);
+    // checking on error.
+    glGetObjectParameterivARB(shader, GL_OBJECT_COMPILE_STATUS_ARB, &status);
+    if (status == GL_INVALID_VALUE || status == GL_INVALID_OPERATION)
+      this->printError(shader);
+    else
+      glAttachObjectARB(this->shaderProgram, shader);
+  }
+  return true;
+}
+void Shader::linkShaderProgram()
+{
+  GLint status = 0;
+  glLinkProgramARB(this->shaderProgram);
+       // link error checking
+  glGetObjectParameterivARB(this->shaderProgram, GL_OBJECT_LINK_STATUS_ARB, &status);
+  if (status == GL_INVALID_VALUE || status == GL_INVALID_OPERATION)
+    this->printError(this->shaderProgram);
+}
+bool Shader::readShader(const std::string& fileName, std::string& output)
+{
+  char lineBuffer[PARSELINELENGTH];
+  std::ifstream shader;
+  shader.open(fileName.c_str());
+  if (!shader.is_open())
+    return false;
+  while (!shader.eof())
+  {
+    shader.getline(lineBuffer, PARSELINELENGTH);
+    output += lineBuffer;
+    output += "\n";
+  }
+  shader.close();
+  return true;
+}
+void Shader::activateShader()
+{
+  if (likely (this->shaderProgram != 0))
+  {
+    glUseProgramObjectARB(this->shaderProgram);
+    glUseProgramObjectARB(this->getProgram());
     Shader::storedShader = this;
+  }
+}
-void Shader::bindShader(const char* name, const float* value, size_t size)
+{
-        if (likely (this->shaderProgram != 0)) {
-                glUseProgramObjectARB(this->shaderProgram);
-                unsigned int location = glGetUniformLocationARB(this->shaderProgram, name);
-                /* This is EXPENSIVE and should be avoided. */
-                if      (size == 1)  glUniform1fvARB(location, 1, value);
-                else if (size == 2)  glUniform2fvARB(location, 1, value);
-                else if (size == 3)  glUniform3fvARB(location, 1, value);
-                else if (size == 4)  glUniform4fvARB(location, 1, value);
-                else if (size == 9)  glUniformMatrix3fvARB(location, 1, false, value);
-                else if (size == 16) glUniformMatrix4fvARB(location, 1, false, value);
+        }
+}
 void Shader::deactivateShader()
+{
+ if (storedShader != NULL)
+   glUseProgramObjectARB(0);
+ Shader::storedShader = NULL;
+}
+void Shader::deleteProgram(Shader::Type type)
+{
+  GLint status = 0;
+  if (type == Shader::Vertex && this->vertexShader != 0)
+  {
+    this->vertexShaderFile = "";
+    glDetachObjectARB(this->shaderProgram, this->vertexShader);
+    glDeleteObjectARB(this->vertexShader);
+    glGetObjectParameterivARB(this->vertexShader, GL_OBJECT_DELETE_STATUS_ARB, &status);
+    if (status == GL_INVALID_VALUE || status == GL_INVALID_OPERATION)
+      Shader::printError(this->vertexShader);
+    this->vertexShader = 0;
+  }
+  else if (type == Shader::Fragment && this->fragmentShader != 0)
+  {
+    this->fragmentShaderFile = "";
+    glDetachObjectARB(this->shaderProgram, this->fragmentShader);
+    glDeleteObjectARB(this->fragmentShader);
+    glGetObjectParameterivARB(this->fragmentShader, GL_OBJECT_DELETE_STATUS_ARB, &status);
+    if (status == GL_INVALID_VALUE || status == GL_INVALID_OPERATION)
+      Shader::printError(this->fragmentShader);
+    this->fragmentShader = 0;
+  }
+  else
+    return;
+}
+void Shader::printError(GLhandleARB program)
+{
+  if (program == 0)
+    return;
+  int infologLength = 0;
+  int charsWritten  = 0;
+  char *infoLog;
+  glGetObjectParameterivARB(program, GL_OBJECT_INFO_LOG_LENGTH_ARB,
+                            &infologLength);
+  if (infologLength > 0)
+  {
+    infoLog = new char[infologLength+1];
+    glGetInfoLogARB(program, infologLength, &charsWritten, infoLog);
+    printf("%s\n", infoLog);
+    delete[] infoLog;
+  }
+  if (storedShader != NULL)
+    glUseProgramObjectARB(0);
+  Shader::storedShader = NULL;
+}
 …
+}
-void Shader::debug() const
+{
-  PRINT(3)("Shader info: (SHADER: %d)\n", this->shaderProgram);
-  if (this->vertexShader != 0)
+  {
-/*    PRINT(3)("VertexShaderProgramm: number=%d, file='%s'\n", this->vertexShader, this->vertexShaderFile);
-    if (this->vertexShaderSource != NULL)
-      for (unsigned int i = 0; i < this->vertexShaderSource->getCount(); i++)
-        PRINT(3)("%d: %s\n", i, this->vertexShaderSource->getEntry(i));
+  }
-  if (this->fragmentShader != 0)
+  {
-    PRINT(3)("FragmentShaderProgramm: number=%d, file='%s'\n", this->fragmentShader, this->fragmentShaderFile);
-    if (this->fragmentShaderSource != NULL)
-      for (unsigned int i = 0; i < this->fragmentShaderSource->getCount(); i++)
-        PRINT(3)("%d: %s\n", i, this->fragmentShaderSource->getEntry(i));*/
+  }
+}

trunk/src/lib/graphics/shader.h

-                      r8255
+                      r9869
 #include "base_object.h"
+#include "glincl.h"
+#include <vector>
+#include "shader_data.h"
 // FORWARD DECLARATION
 …
 //! A class for ...
+//! The Shader is a Class-wrapper around the OpenGL Shader Language (GLSL).
 class Shader : public BaseObject
+{
+  ObjectListDeclaration(Shader);
 public:
   class Uniform
+  {
   public:
-    Uniform(const Shader* shader, const std::string& location) { this->uniform = glGetUniformLocationARB(shader->getProgram(), location.c_str()) ; }
     Uniform(const Shader& shader, const std::string& location) { this->uniform = glGetUniformLocation(shader.getProgram(), location.c_str()) ; };
     Uniform(GLhandleARB shaderProgram, const std::string& location) { this->uniform = glGetUniformLocation(shaderProgram, location.c_str()) ; };
 …
     void set(int v0, int v1, int v2, int v3) const { glUniform4i(this->uniform, v0, v1, v2, v3); }
+    void setV(unsigned int count, float* vv) const
+    {
+      switch (count)
+      {
+        case 1:
+          glUniform1fv(this->uniform, 1, vv);
+          break;
+        case 2:
+          glUniform2fv(this->uniform, 2, vv);
+          break;
+        case 3:
+          glUniform3fv(this->uniform, 3, vv);
+          break;
+        case 4:
+          glUniform4fv(this->uniform, 4, vv);
+          break;
+      }
+    }
+    void setV(unsigned int count, int* vv) const
+    {
+      switch (count)
+      {
+        case 1:
+          glUniform1iv(this->uniform, 1, vv);
+          break;
+        case 2:
+          glUniform2iv(this->uniform, 2, vv);
+          break;
+        case 3:
+          glUniform3iv(this->uniform, 3, vv);
+          break;
+        case 4:
+          glUniform4iv(this->uniform, 4, vv);
+          break;
+      }
+    }
+    private:
+    void setV(unsigned int count, float* vv) const;
+    void setV(unsigned int count, int* vv) const;
+  private:
     GLint uniform;
   };
-  typedef enum
+  {
-    None       = 0,
-    Fragment   = 1,
-    Vertex     = 2,
-    Program    = 4,
+  }
-  Type;
 public:
+  Shader(const std::string& vertexShaderFile = "", const std::string& fragmentShaderFile = "");
+  virtual ~Shader();
+  static Shader* getShader(const std::string& vertexShaderFile, const std::string& fragmentShaderFile);
+  static bool unload(Shader* shader);
+  Shader();
+  Shader(const std::string& vertexShaderFile, const std::string& fragmentShaderFile = "");
+  Shader& operator=(const Shader& shader) { this->data = shader.data; return *this; };
+  const ShaderData::Pointer& dataPointer() const { return data; };
+  void acquireData(const ShaderData::Pointer& pointer) { this->data = pointer; };
+  bool load(const std::string& vertexShaderFile, const std::string& fragmentShaderFile = "")
+    { return this->data->load(vertexShaderFile, fragmentShaderFile); }
+  Shader::Uniform getUniform(const std::string& location) { return Shader::Uniform(*this, location); }
+  GLhandleARB getProgram() const { return this->data->getProgram(); }
+  GLhandleARB getVertexS() const { return this->data->getVertexS(); }
+  GLhandleARB getFragmentS() const { return this->data->getFragmentS(); }
+  void activateShader() const;
+  static void deactivateShader();
+  void debug() const { this->data->debug(); };
   static bool checkShaderAbility();
-  void activateShader();
-  void bindShader(const char* name, const float* value, size_t size);
-  static void deactivateShader();
+  Shader::Uniform getUniform(const std::string& location) { return Shader::Uniform(this, location); }
+  inline static bool isShaderActive() { return (Shader::storedShader != NULL) ? true : false; };
+  inline static const Shader* getActiveShader() { return Shader::storedShader; };
+  bool loadShaderProgramm(Shader::Type type, const std::string& fileName);
+  void deleteProgram(Shader::Type type);
+  void linkShaderProgram();
+  bool readShader(const std::string& fileName, std::string& output);
+inline static bool shaderActive() { return (Shader::storedShader != NULL)? true : false; };
+  inline static Shader* getActiveShader() { return Shader::storedShader; };
+  inline static void suspendShader() { Shader* currShader = storedShader; if (storedShader!= NULL) { Shader::deactivateShader(); Shader::storedShader = currShader;} };
+  inline static void suspendShader() { const Shader* currShader = storedShader; if (storedShader!= NULL) { Shader::deactivateShader(); Shader::storedShader = currShader;} };
   inline static void restoreShader() { if (storedShader != NULL) storedShader->activateShader(); storedShader = NULL; };
+private:
+  ShaderData::Pointer    data;
+  GLhandleARB getProgram() const { return this->shaderProgram; }
+  GLhandleARB getVertexS() const { return this->vertexShader; }
+  GLhandleARB getFragmentS() const { return this->fragmentShader; }
+  void debug() const;
+  static void printError(GLhandleARB program);
+private:
+  std::string            fragmentShaderFile;
+  std::string            vertexShaderFile;
+  GLhandleARB            shaderProgram;
+  GLhandleARB            vertexShader;
+  GLhandleARB            fragmentShader;
+  static Shader*         storedShader;
+  static const Shader*         storedShader;
 };

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

-                      r9406
+                      r9869
 #define QUADTREE_MATERIAL_COUNT       4
+ObjectListDefinition(Quadtree);
 /**
  *  standard constructor
 …
 Quadtree::Quadtree (const modelInfo* pModelInfo, const int treeDepth)
+{
   this->setClassID(CL_QUADTREE, "Quadtree");
+  this->registerObject(this, Quadtree::_objectList);
   this->pModelInfo = pModelInfo;
   this->treeDepth = treeDepth;

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

r6022	r9869
21	21	//! A class for quadtree separation of the world
22	22	class Quadtree : public BaseObject {
23
	23	ObjectListDeclaration(Quadtree);
24	24
25	25	public:

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

-                      r9406
+                      r9869
+ObjectListDefinition(QuadtreeNode);
 /**
 …
 void QuadtreeNode::init()
+{
   this->setClassID(CL_QUADTREE_NODE, "QuadtreeNode");
+  this->registerObject(this, QuadtreeNode::_objectList);
   /* init the rest of the variables for both init types */

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

r6617	r9869
26	26	//! A class for a Quadtree Node representation
27	27	class QuadtreeNode : public BaseObject {
	28	ObjectListDeclaration(QuadtreeNode);
28	29
29	30	public:

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

-                      r9406
+                      r9869
+ObjectListDefinition(SpatialSeparation);
 /**
  *  standard constructor
+ * @brief 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
+ *
+ * The boxes are overlaping because this makes collision detection a lot simpler
+ *
  */
 SpatialSeparation::SpatialSeparation (Model* model, float overlapSize)
 …
   PRINT(3)("+-| (Event) Spatial Separation process kicked on\n");
   this->setClassID(CL_SPATIAL_SEPARATION, "SpatialSeparation");
+  this->registerObject(this, SpatialSeparation::_objectList);
   /* debug vice */
   this->createQuadtree(model);
 …
 /**
  *  standard constructor
+ * @brief standard constructor
  * @param model the model that is to be separated
  * @param overlapSize each box will overlap for a given size
 …
 SpatialSeparation::SpatialSeparation (Model* model, Model* playerModel)
+{
   this->setClassID(CL_SPATIAL_SEPARATION, "SpatialSeparation");
+  this->registerObject(this, SpatialSeparation::_objectList);
+}
 …
 /**
  *  standard deconstructor
+ * @brief standard deconstructor
  */
 SpatialSeparation::~SpatialSeparation ()
 …
 /**
  *  creates a quadtree
+ * @brief creates a quadtree
  * @param model the model to do a quadtree on
  * @param minLength the minimal length of a quadtree node
 …
 /**
  *  brief creates a quadtree
+ * @brief creates a quadtree
  * @param model the model to do a quadtree on
  * @param minLength the minimal length of a quadtree node
 …
 /**
  *  creates a quadtree
+ * @brief creates a quadtree
  * @param model the model to do a quadtree on
  * @param minLength the minimal length of a quadtree node
 …
 /**
  *  draws all the quadtrees
+ * @brief draws all the quadtrees
  */
 void SpatialSeparation::drawQuadtree()
 …
   this->quadtree->drawTree();
+}

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

r6022	r9869
19	19	//! A class for spatial separation of vertices based arrays
20	20	class SpatialSeparation : public BaseObject {
	21	ObjectListDeclaration(SpatialSeparation);
21	22
22	23	public:

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

-                      r8989
+                      r9869
 #include "compiler.h"
+ObjectListDefinition(Font);
 Font::Font()
 …
+{
   this->init();
+}
 …
   Material::operator=(font);
   this->data = font.data;
+  this->setTexture(this->data->textureData());
   return *this;
 …
   this->setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
   this->setClassID(CL_FONT, "Font");
   if (Font::defaultFontData.get() == NULL)
+  this->registerObject(this, Font::_objectList);
+  if (Font::defaultFontData.isNull())
+  {
     Font::initDefaultFont();
 …
+}
 FontDataPointer Font::defaultFontData(NULL);
+FontData::Pointer Font::defaultFontData(NULL);
 /**
 …
+{
   // temporarily create a Font.
   Font::defaultFontData = FontDataPointer(new FontData);
+  Font::defaultFontData = FontData::Pointer(new FontData);
   // apply the Data.
   Font::defaultFontData = Font(font_xpm).data;
 …
 bool Font::loadFontFromTTF(const std::string& fontFile, unsigned int renderSize)
+{
   this->data = FontDataPointer (new FontData());
+  this->data = FontData::Pointer (new FontData());
   bool retVal = this->data->loadFontFromTTF(fontFile, renderSize);
   if (!retVal)
 …
 bool Font::loadFontFromSDL_Surface(SDL_Surface* surface)
+{
   this->data = FontDataPointer (new FontData());
+  this->data = FontData::Pointer (new FontData());
   bool retVal = this->data->loadFontFromSDL_Surface(surface);
   if (!retVal)
 …
 void Font::setTexture(const TextureDataPointer& texDataPointer)
+void Font::setTexture(const TextureData::Pointer& texDataPointer)
+{
   this->setDiffuseMap(texDataPointer);

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

-                      r8766
+                      r9869
 class Font : public Material
+{
+  ObjectListDeclaration(Font);
+public:
+  typedef FontData::Glyph Glyph;
 public:
   Font();
 …
   /** @returns a Pointer to the Array of Glyphs */
   inline Glyph** getGlyphArray() const { return this->data->getGlyphArray(); };
+  inline const Glyph* const * const getGlyphArray() const { return this->data->getGlyphArray(); };
   inline int getMaxHeight() const { return data->getMaxHeight(); };
 …
   void debug() const;
+  void acquireData(const FontData::Pointer& data) { this->data = data; };
+  const FontData::Pointer& dataPointer() const { return data; };
 private:
   void init();
   static void initDefaultFont();
   void setTexture(const TextureDataPointer& texDataPointer);
+  void setTexture(const TextureData::Pointer& texDataPointer);
 private:
   FontDataPointer           data;                //!< A Data-Pointer to a Font.
+  FontData::Pointer         data;                //!< A Data-Pointer to a Font.
   static FontDataPointer    defaultFontData;     //!< a default font, that is used, if other fonts were unable to be loaded.
+  static FontData::Pointer  defaultFontData;     //!< a default font, that is used, if other fonts were unable to be loaded.
 };

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

-                      r8768
+                      r9869
 #define FONT_DEFAULT_RENDER_SIZE     50            //!< At what Resolution to render fonts.
+class FontData
+{
+public:
 //! A struct for handling glyphs
 /**
  * a Glyph is one letter of a certain font
  */
 struct Glyph
+{
+  struct Glyph
+  {
   // Glyph-specific (size and so on)
   Uint16   character;         //!< The character
   float    minX;              //!< The minimum distance from the origin in X
   float    maxX;              //!< The maximum distance from the origin in X
   float    minY;              //!< The minimum distance from the origin in Y
   float    maxY;              //!< The maximum distance from the origin in Y
   float    width;             //!< The width of the Glyph
   float    height;            //!< The height of the Glyph
   float    bearingX;          //!< How much is right of the Origin
   float    bearingY;          //!< How much is above the Origin
   float    advance;           //!< How big a Glyph would be in monospace-mode
+    Uint16   character;         //!< The character
+    float    minX;              //!< The minimum distance from the origin in X
+    float    maxX;              //!< The maximum distance from the origin in X
+    float    minY;              //!< The minimum distance from the origin in Y
+    float    maxY;              //!< The maximum distance from the origin in Y
+    float    width;             //!< The width of the Glyph
+    float    height;            //!< The height of the Glyph
+    float    bearingX;          //!< How much is right of the Origin
+    float    bearingY;          //!< How much is above the Origin
+    float    advance;           //!< How big a Glyph would be in monospace-mode
   GLfloat texCoord[4];        //!< Texture coordinates: 0:left, 1:right, 2: top, 3: bottom.
 };
+    GLfloat texCoord[4];        //!< Texture coordinates: 0:left, 1:right, 2: top, 3: bottom.
+  };
+class FontData
+{
+  typedef CountPointer<FontData> Pointer;
 public:
   FontData();
 …
   /** @returns a Pointer to the Array of Glyphs */
   inline Glyph** getGlyphArray() const { return this->glyphArray; };
+  inline const Glyph* const * const getGlyphArray() const { return this->glyphArray; };
   int getMaxHeight() const { return maxHeight; };
 …
   /** @returns the Texture-Data of this FontData */
   const TextureDataPointer& textureData() const { return texData; };
+  const TextureData::Pointer& textureData() const { return texData; };
   bool rebuild() { return texData->rebuild(); };
 …
   int           maxDescent;          //!< Max Desent of the Font.
   TextureDataPointer   texData;
+  TextureData::Pointer   texData;
 };
-typedef CountPointer<FontData> FontDataPointer;
 #endif /* _FONT_DATA_H */

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

-                      r9406
+                      r9869
 #include "font.h"
+ObjectListDefinition(LimitedWidthText);
 /**
  * @brief creates a new Text Element
 …
     : Text(fontFile, textSize)
+{
   this->setClassID(CL_LIMITED_WIDTH_TEXT, "LimitedWidthText");
+  this->registerObject(this, LimitedWidthText::_objectList);
   this->_dotsPosition = End;
 …
   glRotatef(this->getAbsDir2D(), 0, 0, 1);
   Glyph* tmpGlyph;
+  const Font::Glyph* tmpGlyph;
   float posX = 0.0f;
   glBegin(GL_QUADS);

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

r8980	r9869
14	14	class LimitedWidthText : public Text
15	15	{
	16	ObjectListDeclaration(LimitedWidthText);
16	17	public:
17	18	typedef enum {

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

-                      r9406
+                      r9869
 #include "font.h"
+ObjectListDefinition(MultiLineText);
 /**
  * @brief creates a new Text Element
 …
   : Text(fontFile, textSize)
+{
   this->setClassID(CL_MULTI_LINE_TEXT, "MultiLineText");
+  this->registerObject(this, MultiLineText::_objectList);
   this->lineSpacing = 1.0;
 …
   glRotatef(this->getAbsDir2D(), 0, 0, 1);
   Glyph* tmpGlyph;
+  const Font::Glyph* tmpGlyph;
   float posX = 0.0f;
   float posY = 0.0f;

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

r7757	r9869
14	14	class MultiLineText : public Text
15	15	{
	16	ObjectListDeclaration(MultiLineText);
16	17	public:
17	18	MultiLineText(const std::string& fontFile = "", unsigned int fontSize = TEXT_DEFAULT_SIZE, float lineWidth = 100.0);

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

-                      r9406
+                      r9869
 #include "text.h"
+#include "resource_font.h"
 #include "font.h"
-#include "util/loading/resource_manager.h"
 #include "debug.h"
+ObjectListDefinition(Text);
 /**
 …
  */
 Text::Text(const std::string& fontFile, unsigned int textSize)
     // : _font(fontFile, FONT_DEFAULT_RENDER_SIZE)
+{
   this->setClassID(CL_TEXT, "Text");
+// : _font(fontFile, FONT_DEFAULT_RENDER_SIZE)
+{
+  this->registerObject(this, Text::_objectList);
   // initialize this Text
+  this->setFont(fontFile, FONT_DEFAULT_RENDER_SIZE);
+  if (!fontFile.empty())
+    this->setFont(fontFile, FONT_DEFAULT_RENDER_SIZE);
+  else
+    this->setFont("fonts/final_frontier.ttf", FONT_DEFAULT_RENDER_SIZE);
   this->_size = textSize;
   this->setSizeY2D(textSize);
 …
     : _font()
+{
   this->setClassID(CL_TEXT, "Text");
+  this->registerObject(this, Text::_objectList);
   *this = text;
 …
 void Text::setFont(const std::string& fontFile, unsigned int fontSize)
+{
+  Font* newFont = NULL;
+  //  Font* oldFont = this->_font;
+  // load a new Font
+  if (!fontFile.empty())
+  {
+    newFont = (Font*)ResourceManager::getInstance()->load(fontFile, TTF, RP_GAME, (int)fontSize);
+    if (newFont == NULL)
+    {
+      //      newFont = &Font::();
+      PRINTF(2)("Font %s could not be loaded, probably file not found\n", fontFile.c_str());
+    }
+  }
+  if (newFont == NULL)
+    this->_font = Font();
+  else
+    this->_font = *newFont;
+  this->_font = ResourceFont(fontFile, fontSize);
   this->setupTextWidth();
 …
   glRotatef(this->getAbsDir2D(), 0, 0, 1);
   Glyph* tmpGlyph;
+  const Font::Glyph* tmpGlyph;
   float posX = 0.0f;
   glBegin(GL_QUADS);

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

r8764	r9869
26	26	class Text : public Element2D
27	27	{
	28	ObjectListDeclaration(Text);
28	29	public:
29	30	Text(const std::string& fontFile = "", unsigned int fontSize = TEXT_DEFAULT_SIZE);

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

-                      r9406
+                      r9869
 #include "graphics_engine.h"
-#include "util/loading/resource_manager.h"
-#include "class_list.h"
 #include "debug.h"
 …
 /// TEXT-ENGINE ///
 ///////////////////
+ObjectListDefinition(TextEngine);
 /**
  *  standard constructor
 …
 TextEngine::TextEngine ()
+{
    this->setClassID(CL_TEXT_ENGINE, "TextEngine");
    this->setName("TextEngine");
    this->enableFonts();
+  this->registerObject(this, TextEngine::_objectList);
+  this->setName("TextEngine");
+  this->enableFonts();
+}
 …
+{
   // first remove all the remaining Texts (if any).
+  const std::list<BaseObject*>* textList = ClassList::getList(CL_TEXT);
+  if (textList != NULL)
+  {
+    while(textList->size() > 0)
+      delete dynamic_cast<Text*>(textList->front());
+  }
+  while (!Text::objectList().empty())
+    delete Text::objectList().front();
   // delete all remaining fonts (There should not be Anything to do here)
+  const std::list<BaseObject*>* fontList = ClassList::getList(CL_FONT);
+  if (fontList != NULL)
+  //const std::list<BaseObject*>* fontList = ClassList::getList(CL_FONT);
+  //if (fontList != NULL)
+  {
     ///FIXME
 //    while (fontList->size() > 0)
+    //    while (fontList->size() > 0)
+    {
 //      Font* font = dynamic_cast<Font*>(fontList->back());
+      //      Font* font = dynamic_cast<Font*>(fontList->back());
       //if (likely(font != Font::getDefaultFont()))
       //        ResourceManager::getInstance()->unload(font, RP_GAME);
 …
+{
   if (!TTF_WasInit())
+    {
       if(TTF_Init()==-1)
         PRINTF(1)("TTF_Init: %s\n", TTF_GetError());
+  {
+    if(TTF_Init()==-1)
+      PRINTF(1)("TTF_Init: %s\n", TTF_GetError());
       TextEngine::checkVersion();
+    }
+    TextEngine::checkVersion();
+  }
   else
     PRINTF(4)("Fonts already initialized\n");
 …
+{
   if (TTF_WasInit())
+    {
 //      Font::removeDefaultFont();
       TTF_Quit();
+    }
+  {
+    //      Font::removeDefaultFont();
+    TTF_Quit();
+  }
   else
     PRINTF(4)("Fonts were not initialized.\n");
 …
 void TextEngine::debug() const
+{
+  const std::list<BaseObject*>* textList = ClassList::getList(CL_TEXT);
+  if (textList != NULL)
+  PRINT(0)("+-------------------------------+\n");
+  PRINT(0)("+ TEXT ENGINE DEBUG INFORMATION +\n");
+  PRINT(0)("+-------------------------------+\n");
+  PRINT(0)("Reference: %p; Text Counts: %d\n", this, Text::objectList().size());
+  for (ObjectList<Text>::const_iterator it = Text::objectList().begin();
+       it != Text::objectList().end();
+       ++it)
+  {
+    PRINT(0)("+-------------------------------+\n");
+    PRINT(0)("+ TEXT ENGINE DEBUG INFORMATION +\n");
+    PRINT(0)("+-------------------------------+\n");
+    PRINT(0)("Reference: %p; Text Counts: %d\n", this, textList->size());
+    std::list<BaseObject*>::const_iterator text;
+    for ( text = textList->begin(); text != textList->end(); text++)
+      dynamic_cast<Text*>(*text)->debug();
+      (*it)->debug();
     PRINT(0)("+---------------------------TE--+\n");
+  }
 …
       compile_version.minor == link_version.minor &&
       compile_version.patch == link_version.patch)
+    {
       return true;
+    }
+  {
+    return true;
+  }
   else
+    {
       PRINTF(2)("compiled with SDL_ttf version: %d.%d.%d\n",
                 compile_version.major,
                 compile_version.minor,
                 compile_version.patch);
+  {
+    PRINTF(2)("compiled with SDL_ttf version: %d.%d.%d\n",
+              compile_version.major,
+              compile_version.minor,
+              compile_version.patch);
       PRINTF(2)("running with SDL_ttf version: %d.%d.%d\n",
                 link_version.major,
                 link_version.minor,
                 link_version.patch);
       return false;
+    }
+    PRINTF(2)("running with SDL_ttf version: %d.%d.%d\n",
+              link_version.major,
+              link_version.minor,
+              link_version.patch);
+    return false;
+  }
+}

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

-                      r5515
+                      r9869
 class TextEngine : public BaseObject
+{
+ public:
+  ObjectListDeclaration(TextEngine);
+  public:
   virtual ~TextEngine();
   /** @returns a Pointer to the only object of this Class */

trunk/src/lib/gui/gl/glgui_bar.cc

-                      r8991
+                      r9869
+{
+  ObjectListDefinition(GLGuiBar);
   /**
    * @brief standard constructor
 …
   void GLGuiBar::init()
+  {
     this->setClassID(CL_GLGUI_BAR, "GLGuiBar");
+    this->registerObject(this, GLGuiBar::_objectList);
     this->setFrontColor(_changedValueColor, true);

trunk/src/lib/gui/gl/glgui_bar.h

r8991	r9869
21	21	class GLGuiBar : public GLGuiWidget
22	22	{
23
	23	ObjectListDeclaration(GLGuiBar);
24	24	public:
25	25	GLGuiBar();

trunk/src/lib/gui/gl/glgui_box.cc

-                      r9656
+                      r9869
 namespace OrxGui
+{
+  ObjectListDefinition(GLGuiBox);
   /**
    * standard constructor
 …
   void GLGuiBox::init()
+  {
     this->setClassID(CL_GLGUI_BOX, "GLGuiBox");
+    this->registerObject(this, GLGuiBox::_objectList);
+  }
 …
     while (itC != this->_children.end())
+    {
       if ((*itC)->isA(CL_GLGUI_CONTAINER))
+      if ((*itC)->isA(GLGuiContainer::staticClassID()))
         static_cast<GLGuiContainer*>(*itC)->showAll();
       else
 …
     while (itC != this->_children.end())
+    {
       if ((*itC)->isA(CL_GLGUI_CONTAINER))
+      if ((*itC)->isA(GLGuiContainer::staticClassID()))
         static_cast<GLGuiContainer*>(*itC)->hideAll();
       else

trunk/src/lib/gui/gl/glgui_box.h

r9656	r9869
19	19	class GLGuiBox : public GLGuiContainer
20	20	{
21
	21	ObjectListDeclaration(GLGuiBox);
22	22	public:
23	23	GLGuiBox(OrxGui::Orientation orientation = OrxGui::Vertical);

trunk/src/lib/gui/gl/glgui_button.cc

-                      r9406
+                      r9869
 namespace OrxGui
+{
+  ObjectListDefinition(GLGuiButton);
   /**
    * standard constructor
 …
   void GLGuiButton::init()
+  {
     this->setClassID(CL_GLGUI_BUTTON, "GLGuiButton");
+    this->registerObject(this, GLGuiButton::_objectList);
     this->setSelectable(true);

trunk/src/lib/gui/gl/glgui_button.h

r9406	r9869
31	31	class GLGuiButton : public GLGuiWidget
32	32	{
33
	33	ObjectListDeclaration(GLGuiButton);
34	34	public:
35	35	GLGuiButton(const std::string& label);

trunk/src/lib/gui/gl/glgui_checkbutton.cc

r9406	r9869
22	22	namespace OrxGui
23	23	{
24
	24	ObjectListDefinition(GLGuiCheckButton);
25	25
26	26	/**
…	…
49	49	void GLGuiCheckButton::init()
50	50	{
51		this->~~setClassID(CL_GLGUI_CHECKBUTTON, "GLGuiCheckButton"~~);
	51	this->registerObject(this, GLGuiCheckButton::_objectList);
52	52	}
53	53

trunk/src/lib/gui/gl/glgui_checkbutton.h

r9406	r9869
21	21	class GLGuiCheckButton : public GLGuiButton
22	22	{
23
	23	ObjectListDeclaration(GLGuiCheckButton);
24	24	public:
25	25	GLGuiCheckButton(const std::string& label = "", bool active = false);

trunk/src/lib/gui/gl/glgui_colorselector.h

r8145	r9869
21	21	class GLGui : public GLGui
22	22	{
23
	23	ObjectListDeclaration(GLGuiColorSelector);
24	24	public:
25	25	GLGui();

trunk/src/lib/gui/gl/glgui_container.cc

-                      r9656
+                      r9869
 namespace OrxGui
+{
+  ObjectListDefinition(GLGuiContainer);
   /**
    * standard constructor
 …
   void GLGuiContainer::init()
+  {
     this->setClassID(CL_GLGUI_CONTAINER, "GLGuiContainer");
+    this->registerObject(this, GLGuiContainer::_objectList);
     this->setBackgroundTexture("gui_container_background.png");

trunk/src/lib/gui/gl/glgui_container.h

r9656	r9869
20	20	class GLGuiContainer : public GLGuiWidget
21	21	{
22
	22	ObjectListDeclaration(GLGuiContainer);
23	23	public:
24	24	GLGuiContainer();

trunk/src/lib/gui/gl/glgui_cursor.cc

-                      r8619
+                      r9869
 namespace OrxGui
+{
+  ObjectListDefinition(GLGuiCursor);
   /**
    * standard constructor
 …
   void GLGuiCursor::init()
+  {
     this->setClassID(CL_GLGUI_CURSOR, "GLGuiCursor");
+    this->registerObject(this, GLGuiCursor::_objectList);
     this->setBackgroundColor(Color(1.0, 1.0, 1.0, 1.0));

trunk/src/lib/gui/gl/glgui_cursor.h

r8324	r9869
26	26	class GLGuiCursor : public GLGuiWidget, public EventListener
27	27	{
28
	28	ObjectListDeclaration(GLGuiCursor);
29	29	public:
30	30	GLGuiCursor();

trunk/src/lib/gui/gl/glgui_fixedposition_box.cc

-                      r9656
+                      r9869
 namespace OrxGui
+{
+  ObjectListDefinition(GLGuiFixedpositionBox);
   /**
    * standard constructor
 …
       : GLGuiBox(orientation)
+  {
+    this->registerObject(this, GLGuiFixedpositionBox::_objectList);
     this->subscribeEvent(ES_ALL, EV_VIDEO_RESIZE);
     this->setPosition(position);

trunk/src/lib/gui/gl/glgui_fixedposition_box.h

r9656	r9869
21	21	class GLGuiFixedpositionBox : public OrxGui::GLGuiBox, EventListener
22	22	{
23
	23	ObjectListDeclaration(GLGuiFixedpositionBox);
24	24	public:
25	25	GLGuiFixedpositionBox(OrxGui::Position position = OrxGui::Center, OrxGui::Orientation orientation = OrxGui::Vertical);

trunk/src/lib/gui/gl/glgui_frame.cc

-                      r9406
+                      r9869
 namespace OrxGui
+{
+  ObjectListDefinition(GLGuiFrame);
   /**
    * standard constructor
 …
   void GLGuiFrame::init()
+  {
     this->setClassID(CL_GLGUI_FRAME, "GLGuiFrame");
+    this->registerObject(this, GLGuiFrame::_objectList);
     this->child = NULL;
+  }
 …
     if (this->child != NULL)
+    {
       if (this->child->isA(CL_GLGUI_CONTAINER))
+      if (this->child->isA(GLGuiContainer::staticClassID()))
         static_cast<GLGuiContainer*>(this->child)->showAll();
       else
 …
     if (this->child != NULL)
+    {
       if (this->child->isA(CL_GLGUI_CONTAINER))
+      if (this->child->isA(GLGuiContainer::staticClassID()))
         static_cast<GLGuiContainer*>(this->child)->hideAll();
       else

trunk/src/lib/gui/gl/glgui_frame.h

r8145	r9869
20	20	class GLGuiFrame : public GLGuiContainer
21	21	{
22
	22	ObjectListDeclaration(GLGuiFrame);
23	23	public:
24	24	GLGuiFrame();

trunk/src/lib/gui/gl/glgui_handler.cc

-                      r9656
+                      r9869
 #include "glgui_cursor.h"
+#include "class_list.h"
+#include "loading/resource_manager.h"
 #include <cassert>
 …
 /// TAKE THIS OUT OF HERE.
 #include "graphics_engine.h"
-#include "loading/resource_manager.h"
 namespace OrxGui
+{
+  ObjectListDefinition(GLGuiHandler);
   /**
    * standard constructor
 …
   GLGuiHandler::GLGuiHandler ()
+  {
     this->setClassID(CL_GLGUI_HANDLER, "GLGuiHandler");
+    this->registerObject(this, GLGuiHandler::_objectList);
     this->setName("GLGuiHandler");
 …
     this->_cursor->setMaxBorders(Vector2D(GraphicsEngine::getInstance()->getResolutionX(), GraphicsEngine::getInstance()->getResolutionY()));
     _cursor->loadTextureSequence(ResourceManager::getInstance()->getDataDir() + "/" + "maps/reap_mouse/reap_mouse_##.png", 1, 49);
+    _cursor->loadTextureSequence(Resources::ResourceManager::getInstance()->mainGlobalPath().name() + "/" + "maps/reap_mouse/reap_mouse_##.png", 1, 49);
+  }
 …
+  {
     // retrieve Objects.
+    const std::list<BaseObject*>* objects = ClassList::getList(CL_GLGUI_WIDGET);
+    if (objects)
+    {
+      std::list<BaseObject*>::const_iterator it ;
+      std::list<BaseObject*>::const_iterator currentIt = objects->end();
+    ObjectList<GLGuiWidget>::const_iterator it, currentIt;
+    currentIt = GLGuiWidget::objectList().end();
+    if (GLGuiWidget::selected() != NULL)
+    {
+      it = std::find(GLGuiWidget::objectList().begin(), GLGuiWidget::objectList().end(), GLGuiWidget::selected());
+      if (it != GLGuiWidget::objectList().end())
+      {
+        currentIt = it;
+        it++;
+      }
+    }
+    else
+    {
+      it = GLGuiWidget::objectList().begin();
+    }
+    bool cycledOnce = false;
+    for (; it != currentIt; ++it)
+    {
+      if (it == GLGuiWidget::objectList().end() && !cycledOnce)
+      {
+        it = GLGuiWidget::objectList().begin();
+        cycledOnce = true;
+      }
+      if ((*it)->selectable() && (*it)->isVisible())
+      {
+        (*it)->select();
+        return;
+      }
+    }
+  }
+  void GLGuiHandler::selectPrevious()
+  {
+    ObjectList<GLGuiWidget>::const_iterator it, currentIt;
+    currentIt = GLGuiWidget::objectList().begin();
       if (GLGuiWidget::selected() != NULL)
+      {
+        it = std::find(objects->begin(), objects->end(), GLGuiWidget::selected());
+        if (it != objects->end())
+        {
+          currentIt = it;
+          it++;
+        }
+      }
+      else
+      {
+        it = objects->begin();
+      }
+      bool cycledOnce = false;
+      for (; it != currentIt; ++it)
+      {
+        if (it == objects->end() && !cycledOnce)
+        {
+          it = objects->begin();
+          cycledOnce = true;
+        }
+        if (dynamic_cast<GLGuiWidget*>(*it)->selectable() && dynamic_cast<GLGuiWidget*>(*it)->isVisible())
+        {
+          dynamic_cast<GLGuiWidget*>(*it)->select();
+          return;
+        }
+      }
+    }
+    else
+    {
+      PRINTF(0)("NO GUI-ELEMENTS EXISTING\n");
+    }
+  }
+  void GLGuiHandler::selectPrevious()
+  {
+    // retrieve Objects.
+    const std::list<BaseObject*>* objects = ClassList::getList(CL_GLGUI_WIDGET);
+    if (objects)
+    {
+      std::list<BaseObject*>::const_iterator it ;
+      std::list<BaseObject*>::const_iterator currentIt = objects->begin();
+      if (GLGuiWidget::selected() != NULL)
+      {
+        it = std::find(objects->begin(), objects->end(), GLGuiWidget::selected());
+        if (it != objects->end())
+        it = std::find(GLGuiWidget::objectList().begin(), GLGuiWidget::objectList().end(), GLGuiWidget::selected());
+        if (it != GLGuiWidget::objectList().end())
+        {
           currentIt = it;
 …
       else
+      {
         it = objects->end();
+        it = GLGuiWidget::objectList().end();
+      }
 …
       for (; it != currentIt; --it)
+      {
         if (it == objects->end() && !cycledOnce)
+        if (it == GLGuiWidget::objectList().end() && !cycledOnce)
+        {
           --it ;
 …
+        }
         if (dynamic_cast<GLGuiWidget*>(*it)->selectable() && dynamic_cast<GLGuiWidget*>(*it)->isVisible())
+        {
           dynamic_cast<GLGuiWidget*>(*it)->select();
+        if ((*it)->selectable() && (*it)->isVisible())
+        {
+          (*it)->select();
           return;
+        }
+      }
+    }
-    else
+    {
-      PRINTF(0)("NO GUI-ELEMENTS EXISTING\n");
+    }
+  }
 …
+    {
       case EV_MOUSE_MOTION:
         this->checkFocus();
         break;
+      this->checkFocus();
+      break;
       case  EV_MOUSE_BUTTON_LEFT:
         if (GLGuiWidget::mouseFocused() != NULL && event.bPressed)
+        {
           // if clickable select the Widget.
           if (GLGuiWidget::mouseFocused()->clickable())
+          {
             Vector2D cursorPos = (this->_cursor != NULL) ? this->_cursor->getAbsCoor2D() : Vector2D(event.x, event.y);
             GLGuiWidget::mouseFocused()->select();
             GLGuiWidget::mouseFocused()->click(cursorPos - GLGuiWidget::mouseFocused()->getAbsCoor2D());
+          }
+        }
         else if (GLGuiWidget::selected() != NULL && !event.bPressed)
+        {
           if (GLGuiWidget::selected()->clickable())
+          {
             Vector2D cursorPos = (this->_cursor != NULL) ? this->_cursor->getAbsCoor2D() : Vector2D(event.x, event.y);
             GLGuiWidget::selected()->release(cursorPos - GLGuiWidget::selected()->getAbsCoor2D());
+          }
+        }
         break;
+      if (GLGuiWidget::mouseFocused() != NULL && event.bPressed)
+      {
+        // if clickable select the Widget.
+        if (GLGuiWidget::mouseFocused()->clickable())
+        {
+          Vector2D cursorPos = (this->_cursor != NULL) ? this->_cursor->getAbsCoor2D() : Vector2D(event.x, event.y);
+          GLGuiWidget::mouseFocused()->select();
+          GLGuiWidget::mouseFocused()->click(cursorPos - GLGuiWidget::mouseFocused()->getAbsCoor2D());
+        }
+      }
+      else if (GLGuiWidget::selected() != NULL && !event.bPressed)
+      {
+        if (GLGuiWidget::selected()->clickable())
+        {
+          Vector2D cursorPos = (this->_cursor != NULL) ? this->_cursor->getAbsCoor2D() : Vector2D(event.x, event.y);
+          GLGuiWidget::selected()->release(cursorPos - GLGuiWidget::selected()->getAbsCoor2D());
+        }
+      }
+      break;
       case EV_LEAVE_STATE:
         if (GLGuiWidget::selected() != NULL)
           GLGuiWidget::selected()->unselect();
         if (GLGuiWidget::mouseFocused() != NULL)
           GLGuiWidget::mouseFocused()->breakMouseFocus();
         break;
+      if (GLGuiWidget::selected() != NULL)
+        GLGuiWidget::selected()->unselect();
+      if (GLGuiWidget::mouseFocused() != NULL)
+        GLGuiWidget::mouseFocused()->breakMouseFocus();
+      break;
       case EV_VIDEO_RESIZE:
         if (this->_cursor != NULL)
           this->_cursor->setMaxBorders(Vector2D(event.resize.w, event.resize.h));
         this->_resolution = Vector2D(event.resize.w, event.resize.h);
         break;
+      if (this->_cursor != NULL)
+        this->_cursor->setMaxBorders(Vector2D(event.resize.w, event.resize.h));
+      this->_resolution = Vector2D(event.resize.w, event.resize.h);
+      break;
       case SDLK_TAB:
         if (event.bPressed)
+        {
           if (EventHandler::getInstance()->isPressed(SDLK_LSHIFT) || EventHandler::getInstance()->isPressed(SDLK_RSHIFT))
             this->selectPrevious();
           else
             this->selectNext();
+        }
         break;
+      if (event.bPressed)
+      {
+        if (EventHandler::getInstance()->isPressed(SDLK_LSHIFT) || EventHandler::getInstance()->isPressed(SDLK_RSHIFT))
+          this->selectPrevious();
+        else
+          this->selectNext();
+      }
+      break;
+    }
 …
+  {
     // CHECK THE COLLISIONS.
     const std::list<BaseObject*>* objects = ClassList::getList(CL_GLGUI_WIDGET);
     if (objects != NULL && this->_cursor != NULL)
+    {
       for (std::list<BaseObject*>::const_iterator it = objects->begin(); it != objects->end(); it++)
+      {
         GLGuiWidget* widget = dynamic_cast<GLGuiWidget*>(*it);
+    if (this->_cursor != NULL)
+    {
+      for (ObjectList<GLGuiWidget>::const_iterator it = GLGuiWidget::objectList().begin();
+           it != GLGuiWidget::objectList().end();
+           it++)
+      {
+        GLGuiWidget* widget = (*it);
         if (widget->isVisible() &&

trunk/src/lib/gui/gl/glgui_handler.h

r9656	r9869
19	19	class GLGuiHandler : public EventListener
20	20	{
21
	21	ObjectListDeclaration(GLGuiHandler);
22	22	public:
23	23	/** @returns a Pointer to the only object of this Class */

trunk/src/lib/gui/gl/glgui_image.cc

-                      r8619
+                      r9869
 namespace OrxGui
+{
+  ObjectListDefinition(GLGuiImage);
   /**
    * standard constructor
 …
   void GLGuiImage::init()
+  {
     this->setClassID(CL_GLGUI_IMAGE, "GLGuiImage");
+    this->registerObject(this, GLGuiImage::_objectList);
     this->setForegroundColor(Color(1,1,1,1));

trunk/src/lib/gui/gl/glgui_image.h

r9406	r9869
21	21	class GLGuiImage : public GLGuiWidget
22	22	{
23
	23	ObjectListDeclaration(GLGuiImage);
24	24	public:
25	25	GLGuiImage();

trunk/src/lib/gui/gl/glgui_inputline.cc

-                      r9406
+                      r9869
 namespace OrxGui
+{
+  ObjectListDefinition(GLGuiInputLine);
   /**
    * @brief standard constructor
 …
   void GLGuiInputLine::init()
+  {
     this->setClassID(CL_GLGUI_INPUTLINE, "GLGuiInputLine");
+    this->registerObject(this, GLGuiInputLine::_objectList);
     this->setFocusable(true);

trunk/src/lib/gui/gl/glgui_inputline.h

r9406	r9869
25	25	class GLGuiInputLine : public OrxGui::GLGuiWidget
26	26	{
27
	27	ObjectListDeclaration(GLGuiInputLine);
28	28	public:
29	29	GLGuiInputLine();

trunk/src/lib/gui/gl/glgui_mainwidget.cc

r8145	r9869
20	20	namespace OrxGui
21	21	{
22
	22	ObjectListDefinition(GLGuiMainWidget);
23	23
24	24	/**
…	…
27	27	GLGuiMainWidget::GLGuiMainWidget()
28	28	{
29		this->~~setClassID(CL_GLGUI_MAIN_WIDGET, "GLGuiMainWidget"~~);
	29	this->registerObject(this, GLGuiMainWidget::_objectList);
30	30	this->setName("GLGuiMainWidget");
31	31	}

trunk/src/lib/gui/gl/glgui_mainwidget.h

r8145	r9869
15	15	class GLGuiMainWidget : public GLGuiWidget
16	16	{
17
	17	ObjectListDeclaration(GLGuiMainWidget);
18	18	public:
19	19	virtual ~GLGuiMainWidget(void);

trunk/src/lib/gui/gl/glgui_menu.cc

r8145	r9869
20	20	namespace OrxGui
21	21	{
22
	22	ObjectListDefinition(GLGuiMenu);
23	23	/**
24	24	* standard constructor

trunk/src/lib/gui/gl/glgui_menu.h

r8145	r9869
19	19	class GLGuiMenu : public GLGuiMenu
20	20	{
21
	21	ObjectListDeclaration(GLGuiMenu);
22	22	public:
23	23	GLGuiMenu();

trunk/src/lib/gui/gl/glgui_pushbutton.cc

r8717	r9869
23	23	namespace OrxGui
24	24	{
25
	25	ObjectListDefinition(GLGuiPushButton);
26	26	/**
27	27	* @brief standard constructor
…	…
58	58	void GLGuiPushButton::init()
59	59	{
60		this->~~setClassID(CL_GLGUI_PUSHBUTTON, "GLGuiPushButton"~~);
	60	this->registerObject(this, GLGuiPushButton::_objectList);
61	61	}
62	62

trunk/src/lib/gui/gl/glgui_pushbutton.h

r8717	r9869
21	21	class GLGuiPushButton : public GLGuiButton
22	22	{
23
	23	ObjectListDeclaration(GLGuiPushButton);
24	24	public:
25	25	GLGuiPushButton(const std::string& label = "");

trunk/src/lib/gui/gl/glgui_slider.cc

-                      r9406
+                      r9869
 namespace OrxGui
+{
+  ObjectListDefinition(GLGuiSlider);
   /**
    * @brief standard constructor
 …
+  {
     this->setClassID(CL_GLGUI_SLIDER, "GLGuiSlider");
+    this->registerObject(this, GLGuiSlider::_objectList);
     this->setClickable(true);

trunk/src/lib/gui/gl/glgui_slider.h

r9406	r9869
21	21	class GLGuiSlider : public GLGuiWidget
22	22	{
23
	23	ObjectListDeclaration(GLGuiSlider);
24	24	public:
25	25	GLGuiSlider();

trunk/src/lib/gui/gl/glgui_table.cc

-                      r8717
+                      r9869
 namespace OrxGui
+{
+  ObjectListDefinition(GLGuiTable);
   /**
    * @brief standard constructor
 …
   void GLGuiTable::init()
+  {
     this->setClassID(CL_GLGUI_TABLE, "GLGuiTable");
+    this->registerObject(this, GLGuiTable::_objectList);
     this->setBorderTop(10);

trunk/src/lib/gui/gl/glgui_table.h

r8717	r9869
25	25	class GLGuiTable : public OrxGui::GLGuiWidget
26	26	{
27
	27	ObjectListDeclaration(GLGuiTable);
28	28	public:
29	29	GLGuiTable(unsigned int rows, unsigned int columns);

trunk/src/lib/gui/gl/glgui_text.cc

-                      r9656
+                      r9869
 namespace OrxGui
+{
+  ObjectListDefinition(GLGuiText);
   /**
    * standard constructor
 …
   void GLGuiText::init()
+  {
     this->setClassID(CL_GLGUI_TEXT, "GLGuiText");
+    this->registerObject(this, GLGuiText::_objectList);
     this->_text.setParent2D(this);

trunk/src/lib/gui/gl/glgui_text.h

r9656	r9869
20	20	class GLGuiText : public GLGuiWidget
21	21	{
22
	22	ObjectListDeclaration(GLGuiText);
23	23	public:
24	24	GLGuiText();

trunk/src/lib/gui/gl/glgui_textfield.cc

-                      r9406
+                      r9869
 namespace OrxGui
+{
+  ObjectListDefinition(GLGuiTextfield);
   /**
    * standard constructor
 …
   void GLGuiTextfield::init()
+  {
     this->setClassID(CL_GLGUI_TEXTFIELD, "GLGuiTextfield");
+    this->registerObject(this, GLGuiTextfield::_objectList);
     this->_text.setParent2D(this);

trunk/src/lib/gui/gl/glgui_textfield.h

r9406	r9869
20	20	class GLGuiTextfield : public GLGuiWidget
21	21	{
22
	22	ObjectListDeclaration(GLGuiTextfield);
23	23	public:
24	24	GLGuiTextfield();

trunk/src/lib/gui/gl/glgui_widget.cc

-                      r9656
+                      r9869
 #include "loading/load_param.h"
-/// TODO TAKE THIS OUT OF HERE
 #include "loading/resource_manager.h"
 namespace OrxGui
+{
+  ObjectListDefinition(GLGuiWidget);
   /**
    * @brief standard constructor
 …
   void GLGuiWidget::init()
+  {
     this->setClassID(CL_GLGUI_WIDGET, "GLGuiWidget");
+    this->registerObject(this, GLGuiWidget::_objectList);
     this->_focusable = false;
 …
     if(GLGuiWidget::_defaultFont == NULL)
       GLGuiWidget::_defaultFont = new Font(ResourceManager::getInstance()->getDataDir() + "/fonts/final_frontier.ttf", 20);
+      GLGuiWidget::_defaultFont = new Font(Resources::ResourceManager::getInstance()->mainGlobalPath().name() + "/fonts/final_frontier.ttf", 20);
     this->_font = *GLGuiWidget::_defaultFont;

trunk/src/lib/gui/gl/glgui_widget.h

-                      r9656
+                      r9869
 namespace OrxGui
+{
   class GLGuiCursor;
 …
   class GLGuiWidget : public Element2D
+  {
+    ObjectListDeclaration(GLGuiWidget);
   public:
     GLGuiWidget(GLGuiWidget* parent = NULL);

trunk/src/lib/gui/gl/glgui_window.cc

r8145	r9869
20	20	namespace OrxGui
21	21	{
22
	22	ObjectListDefinition(GLGuiWindow);
23	23	/**
24	24	* standard constructor
…	…
43	43	void GLGuiWindow::init()
44	44	{
45		this->~~setClassID(CL_GLGUI_WINDOW, "GLGuiWindow"~~);
	45	this->registerObject(this, GLGuiWindow::_objectList);
46	46
47	47	}

trunk/src/lib/gui/gl/glgui_window.h

r8145	r9869
20	20	class GLGuiWindow : public GLGuiContainer
21	21	{
22
	22	ObjectListDeclaration(GLGuiWindow);
23	23	public:
24	24	GLGuiWindow();

trunk/src/lib/gui/gl/glmenu/glmenu_imagescreen.cc

-                      r9406
+                      r9869
 #include "util/loading/factory.h"
 #include "util/loading/load_param.h"
+CREATE_FACTORY(GLMenuImageScreen, CL_GLMENU_IMAGE_SCREEN);
+#include "debug.h"
+#include "class_id_DEPRECATED.h"
+ObjectListDefinitionID(GLMenuImageScreen, CL_GLMENU_IMAGE_SCREEN);
+CREATE_FACTORY(GLMenuImageScreen);
 /**
 …
 GLMenuImageScreen::GLMenuImageScreen(const TiXmlElement* root)
+{
   this->setClassID(CL_GLMENU_IMAGE_SCREEN, "GLMenuImageScreen");
+  this->registerObject(this, GLMenuImageScreen::_objectList);
   this->setName("GLMenuLoadScreen");
   // Select Our VU Meter Background Texture
 …
+{
   LoadParam(root, "BackgroundImage", this, GLMenuImageScreen, setBackgroundImage)
     .describe("sets the image to load onto the loadscreen");
+  .describe("sets the image to load onto the loadscreen");
   LoadParam(root, "BackgroundPS", this, GLMenuImageScreen, setPosScale)
     .describe("The Position and Scale of the Background Image in %(0-1.0). PosX, PosY, SizeX, SizeY");
+  .describe("The Position and Scale of the Background Image in %(0-1.0). PosX, PosY, SizeX, SizeY");
   LoadParam(root, "BarImage", this, GLMenuImageScreen, setBarImage)
     .describe("sets the image of the LoadingBar");
+  .describe("sets the image of the LoadingBar");
   LoadParam(root, "BarPS", this, GLMenuImageScreen, setBarPosScale)
     .describe("The Position and Scale of the Loading Bar in %(0-1.0). PosX, PosY, SizeX, SizeY");
+  .describe("The Position and Scale of the Loading Bar in %(0-1.0). PosX, PosY, SizeX, SizeY");
   LoadParam(root, "ElementCount", this, GLMenuImageScreen, setMaximum)
     .describe("The Count of elements to load into the bar (this is only a maximum value)");
+  .describe("The Count of elements to load into the bar (this is only a maximum value)");
+}

trunk/src/lib/gui/gl/glmenu/glmenu_imagescreen.h

-                      r8145
+                      r9869
 class GLMenuImageScreen : public BaseObject
+{
+  ObjectListDeclaration(GLMenuImageScreen);
 public:
   GLMenuImageScreen (const TiXmlElement* root = NULL);
 …
   void setMaximum (int maxValue);
   /** @returns the maximum of countable steps*/
   inline int GLMenuImageScreen::getMaximum() const { return this->maxValue; };
+  inline int getMaximum() const { return this->maxValue; };
   void setValue (int currentValue);

trunk/src/lib/gui/gl/specials/glgui_notifier.cc

-                      r8619
+                      r9869
 namespace OrxGui
+{
+  ObjectListDefinition(GLGuiNotifier);
   /**
    * @brief standard constructor
 …
   GLGuiNotifier::GLGuiNotifier ()
+  {
     this->setClassID(CL_GLGUI_NOTIFIER, "GLGuiNotifier");
+    this->registerObject(this, GLGuiNotifier::_objectList);
     // Element2D and generals

trunk/src/lib/gui/gl/specials/glgui_notifier.h

-                      r8619
+                      r9869
   class GLGuiNotifier : public GLGuiWidget
+  {
+    ObjectListDeclaration(GLGuiNotifier);
   public:
     GLGuiNotifier();
 …
       MultiLineText*    text;
+    } DisplayLine;
+    }
+    DisplayLine;

trunk/src/lib/gui/gui.cc

r7661	r9869
18	18	#include "gui.h"
19	19	#include "gui_saveable.h"
20		#include "preferences.h"
	20	#include "parser/preferences/preferences.h"
21	21
22	22	namespace OrxGui

trunk/src/lib/gui/gui_saveable.cc

r9406	r9869
18	18	#include "gui_saveable.h"
19	19	#include "gui.h"
20		#include "preferences.h"
	20	#include "parser/preferences/preferences.h"
21	21
22	22	#include "debug.h"

trunk/src/lib/lang/Makefile.am

-                      r9677
+                      r9869
+MAINSRCDIR=../..
+include $(MAINSRCDIR)/defs/include_paths.am
+LIB_PREFIX=$(MAINSRCDIR)/lib
+include $(MAINSRCDIR)/lib/BuildLibs.am
+INCLUDES = -I../..
+INCLUDES +=-I..
+INCLUDES +=-I../util
 noinst_LIBRARIES = libORXlang.a
 …
 libORXlang_a_SOURCES = \
                 base_object.cc \
+                class_list.cc \
+                new_class_id.cc \
+                new_object_list.cc
+                class_id.cc \
+                object_list.cc
 noinst_HEADERS = \
                 base_object.h \
+                class_list.h \
+                new_class_id.h \
+                new_object_list.h
+## THIS ALL IS JUST FOR TESTING!!
+check_PROGRAMS = test_object_list
+test_object_list_SOURCES = \
+                test_object_list.cc
+test_object_list_DEPENDENCIES = libORXlang.a
+test_object_list_LDADD = \
+                $(MAINSRCDIR)/util/libORXutils.a \
+                $(libORXlibs_a_LIBRARIES_) \
+                $(MAINSRCDIR)/world_entities/libORXwe.a \
+                $(libORXlibs_a_LIBRARIES_) \
+                $(MAINSRCDIR)/util/libORXutils.a
+#test_object_list_LDADD = \
+                libORXlang.a
+                class_id.h \
+                object_list.h

trunk/src/lib/lang/base_object.cc

-                      r9406
+                      r9869
 /*
    orxonox - the future of 3D-vertical-scrollers
 …
 #include "base_object.h"
+#include "util/debug.h"
 #include "util/loading/load_param.h"
+#include "class_list.h"
+ObjectListDefinition(BaseObject);
 /**
  * @brief sets the name from a LoadXML-Element
  * @param root the element to load from
+ * @param objectName: The name of the Object.
  */
 BaseObject::BaseObject(const std::string& objectName)
+{
-  this->classID = CL_BASE_OBJECT;
   this->className = "BaseObject";
   this->objectName = objectName;
-  this->classList = NULL;
   this->xmlElem = NULL;
+  //ClassList::addToClassList(this, this->classID, "BaseObject");
+  this->registerObject(this, BaseObject::_objectList);
+}
 …
 BaseObject::~BaseObject ()
+{
+  ClassList::removeFromClassList(this);
+  /// Remove from the ObjectLists
+  ClassEntries::iterator it;
+  PRINTF(5)("Deleting Object of type %s::%s\n", this->getClassCName(), getCName());
+  for (it = this->_classes.begin(); it != this->_classes.end(); ++it)
+  {
+    if (ORX_DEBUG >= 5)
+      assert((*it)._objectList->checkIteratorInList((*it)._iterator) || (*it)._objectList->checkObjectInList(this));
+    (*it)._objectList->unregisterObject((*it)._iterator);
+    delete (*it)._iterator;
+  }
   if (this->xmlElem != NULL)
 …
 /**
- * @brief sets the class identifiers
- * @param id a number for the class from class_id.h enumeration
- * @param className the class name
-*/
-void BaseObject::setClassID(ClassID classID, const std::string& className)
+{
-  //printf("%s(0x%.8X)->%s(0x%.8X)\n", this->className, this->classID, className, classID);
-  assert (!(this->classID & classID & !CL_MASK_SUBSUPER_CLASS_IDA ));
-  this->leafClassID = classID;
-  this->classID |= (long)classID;
-  this->className = className;
-  this->classList = ClassList::addToClassList(this, classID, this->classID, className);
+}
-/**
  * @brief set the name of the Object
  * @param objectName The new name of the Object.
 …
 /**
+ * @brief queries for the ClassID of the Leaf Class (the last made class of this type
+ * @returns the ClassID of the Leaf Class (e.g. the ID of the Class)
+ *
+ * the returned ID can be used to generate new Objects of the same type through
+ * Factory::fabricate(Object->getLeafClassID());
+ * @brief Seeks in the Inheritance if it matches objectList.
+ * @param objectList The ObjectList this should be a member of (by Pointer-comparison).
+ * @return True if found, false if not.
  */
 const ClassID& BaseObject::getLeafClassID() const
+bool BaseObject::isA(const ObjectListBase& objectList) const
+{
+  return this->leafClassID;
+}
+/**
+ * @brief checks if the class is a classID
+ * @param classID the Identifier to check for
+ * @returns true if it is, false otherwise
+*/
+bool BaseObject::isA (ClassID classID) const
+{
+  // if classID is a derivable object from a SUPERCLASS
+  if (classID & CL_MASK_SUPER_CLASS)
+  {
+    if( likely(this->classID & classID))
+  ClassEntries::const_iterator it;
+  for (it = this->_classes.begin(); it != this->_classes.end(); ++it)
+    if ((*it)._objectList == &objectList)
       return true;
+  }
-  // if classID is a SubSuperClass, and
-  else if (classID & CL_MASK_SUBSUPER_CLASS)
+  {
-    if (likely(((this->classID & CL_MASK_SUBSUPER_CLASS_IDA) == (classID & CL_MASK_SUBSUPER_CLASS_IDA)) &&
-        this->classID & classID & CL_MASK_SUBSUPER_CLASS_IDB))
-      return true;
+  }
-  // if classID is a LOWLEVEL-class
-  else
+  {
-    if( likely((this->classID & CL_MASK_LOWLEVEL_CLASS) == classID))
-      return true;
+  }
   return false;
+}
+/**
+ * @brief Seeks in the Inheritance if it matches objectList.
+ * @param classID The ClassID this should be a member of (by Pointer-comparison).
+ * @return True if found, false if not.
+ */
+bool BaseObject::isA(const ClassID& classID) const
+{
+  ClassEntries::const_iterator it;
+  for (it = this->_classes.begin(); it != this->_classes.end(); ++it)
+    if (*(*it)._objectList == classID)
+      return true;
+  return false;
+}
 /**
  * @brief checks if the class is a classID
  * @param classID the Identifier to check for
  * @returns true if it is, false otherwise
+ * @brief Seeks in the Inheritance if it matches objectList.
+ * @param classID The ClassID of the class this should be a member of.
+ * @return True if found, false if not.
  */
 bool BaseObject::isA (const std::string& className) const
+bool BaseObject::isA(int classID) const
+{
+  ClassID classID = ClassList::StringToID(className);
+  if (classID != CL_NULL)
+    return this->isA(classID);
+  else
+    return false;
+  ClassEntries::const_iterator it;
+  for (it = this->_classes.begin(); it != this->_classes.end(); ++it)
+    if (*(*it)._objectList == classID)
+      return true;
+  return false;
+}
+/**
+ * @brief Seeks in the Inheritance if it matches objectList.
+ * @param className The ClassName of the class this should be a member of.
+ * @return True if found, false if not.
+ */
+bool BaseObject::isA(const std::string& className) const
+{
+  ClassEntries::const_iterator it;
+  for (it = this->_classes.begin(); it != this->_classes.end(); ++it)
+    if (*(*it)._objectList == className)
+      return true;
+  return false;
+}
 /**
  * @brief compares the ObjectName with an external name
  * @param objectName: the name to check.
  * @returns true on match, false otherwise.
+ * @brief This is for debug purposes, to see the Inheritances of this Object and its classes.
+ *
+ * The Inheritance will be listed in a Linear fashion, diamand structures are resolved in a linear dependency.
  */
 bool BaseObject::operator==(const std::string& objectName) const
+void BaseObject::listInheritance() const
+{
+  return (this->objectName == objectName);
+  PRINT(0)("Listing inheritance diagram for %s::%s: ", getClassCName(), getCName());
+  ClassEntries::const_iterator it;
+  for (it = this->_classes.begin(); it != this->_classes.end(); ++it)
+    PRINT(0)(" -> %s(id:%d)", (*it)._objectList->name().c_str(), (*it)._objectList->id());
+  PRINT(0)("\n");
+}

trunk/src/lib/lang/base_object.h

-                      r9406
+                      r9869
 #define __BASE_OBJECT_H_
 #include "class_id.h"
 #include "sigslot/slot.h"
+#include "object_list.h"
+#include "util/sigslot/slot.h"
 #include <string>
 …
 class BaseObject : public sigslot::has_slots<>
+{
+  //! Declare an ObjectList for this Class.
+  ObjectListDeclaration(BaseObject);
 public:
   BaseObject (const std::string& objectName = "");
 …
   inline TiXmlNode* getXmlElem() const { return this->xmlElem; };
   /** @returns the className of the corresponding Object */
   inline const std::string& getClassName() const { return this->className; }
+  //  /** @returns the className of the corresponding Object */
+  //inline const std::string& getClassName() const { return this->className; }
   /** @returns the className of the corresponding Object as a C-compliant string (const char*) */
+  inline const char* getClassCName() const { return this->className.c_str(); };
+  /** @returns the classID of the corresponding Object */
+  inline int getClassID() const { return this->classID; };
+  const ClassID& getLeafClassID() const;
+  inline const char* getClassCName() const { return _classes.front()._objectList->name().c_str(); };
+  /** @returns the ClassName of the Topmost Object of the ClassStack */
+  inline const std::string& getClassName() const { return _classes.front()._objectList->name(); };
+  bool isA (ClassID classID) const;
+  bool isA (const std::string& className) const;
+  /** @returns the ClassID of this Object */
+  inline const ClassID& getClassID() const { return _classes.front()._objectList->identity(); }
+  /** @returns the ID of the Topmost object of the ClassStack */
+  inline const int& getLeafClassID() const { return _classes.front()._objectList->identity().id(); }
+  bool isA(const ObjectListBase& objectList) const;
+  bool isA(const ClassID& classID) const;
+  bool isA(int classID) const;
+  bool isA(const std::string& className) const;
+  void listInheritance() const;
   /** @param classID comparer for a ClassID @returns true on match, false otherwise */
+  bool operator==(ClassID classID) const  { return this->isA(classID); };
+  bool operator==(const std::string& objectName) const;
+  bool operator==(int classID) const  { return this->isA(classID); };
+  /** @param objectName: the name to check. * @returns true on match, false otherwise. */
+  bool operator==(const std::string& objectName) const { return this->objectName == objectName;};
 protected:
   void setClassID(ClassID classID, const std::string& className);
+  template<class T> void registerObject(T* object, ObjectList<T>& list);
 protected:
 …
 private:
-  std::string        className;        //!< the name of the class
-  long               classID;          //!< this is the id from the class_id.h enumeration
-  ClassID            leafClassID;      //!< The Leaf Class ID
-  ClassList*         classList;        //!< Pointer to the ClassList this Object is inside of
   TiXmlNode*         xmlElem;          //!< The XML Element with wich this Object was loaded(saved).
+  //////////////////////////////
+  //// Type Definition Part ////
+  //////////////////////////////
+  //! A ClassEntry so we can store Classes inside of Objects
+  struct ClassEntry
+  {
+    /** Simple Constuctor @param objectList the ObjectList, @param iterator the (intrusive) Iterator inside of the ObjectList */
+    inline ClassEntry (ObjectListBase* objectList, ObjectListBase::IteratorBase* iterator) : _objectList(objectList), _iterator(iterator) {}
+    ObjectListBase*                _objectList;  //!< An ObjectList this Object is part of
+    ObjectListBase::IteratorBase*  _iterator;    //!< An iterator pointing to the position of the Object inside of the List.
+  };
+  typedef std::list<ClassEntry>       ClassEntries;   //!< Type definition for the List.
+  std::string                         className;    //!< the name of the class
+  ClassEntries                        _classes;     //!< All Classes this object is part of.
 };
+/**
+ * @brief Registeres an Object of Type T to objectList
+ * @param object The Object to append to the objectList.
+ * @param objectList The ObjectList to append the Object to.
+ *
+ * This function is essential to integrate objects into their designated ObjectList.
+ * Remember if you do not want objects to be stored in Lists (less overhead),
+ * do not attempt to call this function.
+ */
+template<class T>
+inline void BaseObject::registerObject(T* object, ObjectList<T>& objectList)
+{
+  this->_classes.push_front(ClassEntry(&objectList, objectList.registerObject(object)));
+}
 #endif /* __BASE_OBJECT_H_ */

trunk/src/lib/network/converter.cc

r9406	r9869
28	28	SHELL_COMMAND_STATIC(debug, Converter, Converter::debug);
29	29
30
	30	ObjectListDefinition(Converter);
31	31	/* using namespace std is default, this needs to be here */
32	32

trunk/src/lib/network/converter.h

r7230	r9869
24	24	class Converter : public BaseObject
25	25	{
	26	ObjectListDeclaration(Converter);
26	27	public:
27	28	static byte* intToByteArray(int x);

trunk/src/lib/network/data_stream.cc

-                      r9406
+                      r9869
 /* using namespace std is default, this needs to be here */
+ObjectListDefinition(DataStream);
 /**
 …
 DataStream::DataStream()
+{
-  this->setClassID(CL_DATA_STREAM, "DataStream");
   this->upBuffer = new byte[DATA_STREAM_BUFFER_SIZE];
   this->downBuffer = new byte[DATA_STREAM_BUFFER_SIZE];
 …
 DataStream::DataStream(DataStream& inStream, DataStream& outStream)
+{
     this->setClassID(CL_DATA_STREAM, "DataStream");
+  this->registerObject(this, DataStream::_objectList);
     this->downStream = &outStream;
     this->upStream = &inStream;

trunk/src/lib/network/data_stream.h

-                      r6981
+                      r9869
 class DataStream : public BaseObject
+{
+      public:
+  ObjectListDeclaration(DataStream);
+  public:
       DataStream();
       DataStream(DataStream& inStream, DataStream& outStream);

trunk/src/lib/network/handshake.cc

-                      r9656
+                      r9869
+ObjectListDefinition(Handshake);
 …
+{
   /* set the class id for the base object */
   this->setClassID(CL_HANDSHAKE, "Handshake");
+  this->registerObject(this, Handshake::_objectList);

trunk/src/lib/network/handshake.h

r9494	r9869
42	42	class Handshake : public Synchronizeable
43	43	{
44
	44	ObjectListDeclaration(Handshake);
45	45	public:
46	46	Handshake( int nodeType, int clientId = 0, int networkGameManagerId = 0, int messageManagerId = 0 );

trunk/src/lib/network/message_manager.cc

-                      r9656
+                      r9869
+ObjectListDefinition(MessageManager);
 MessageManager* MessageManager::singletonRef = NULL;
 …
 MessageManager::MessageManager ()
+{
   this->setClassID( CL_MESSAGE_MANAGER, "MessageManager" );
+  this->registerObject(this, MessageManager::_objectList);
   newNumber = 1;
   setSynchronized( true );

trunk/src/lib/network/message_manager.h

r9656	r9869
96	96	class MessageManager : public Synchronizeable {
97	97
98
	98	ObjectListDeclaration(MessageManager);
99	99	public:
100	100	inline static MessageManager * getInstance(){ if (!singletonRef) singletonRef = new MessageManager(); return singletonRef; }

trunk/src/lib/network/monitor/connection_monitor.cc

-                      r9494
+                      r9869
 /* using namespace std is default, this needs to be here */
+ObjectListDefinition(ConnectionMonitor);
 /**
  * constructor
 …
+{
   /* set the class id for the base object and add ist to class list*/
   this->setClassID(CL_CONNECTION_MONITOR, "ConnectionMonitor");
+  this->registerObject(this, ConnectionMonitor::_objectList);
   this->userId = userId;

trunk/src/lib/network/monitor/connection_monitor.h

r9494	r9869
19	19	class ConnectionMonitor : virtual public BaseObject
20	20	{
	21	ObjectListDeclaration(ConnectionMonitor);
21	22	public:
22	23	ConnectionMonitor( int userId );

trunk/src/lib/network/monitor/network_monitor.cc

-                      r9656
+                      r9869
 SHELL_COMMAND(debug, NetworkMonitor, debug);
+ObjectListDefinition(NetworkMonitor);
 …
   : Synchronizeable()
+{
   this->setClassID(CL_NETWORK_MONITOR, "NetworkMonitor");
+  this->registerObject(this, NetworkMonitor::_objectList);
   this->networkStream = networkStream;

trunk/src/lib/network/monitor/network_monitor.h

r9656	r9869
27	27	class NetworkMonitor : public Synchronizeable
28	28	{
29
	29	ObjectListDeclaration(NetworkMonitor);
30	30	public:
31	31	NetworkMonitor(NetworkStream* networkStream);

trunk/src/lib/network/monitor/network_stats_widget.cc

-                      r9656
+                      r9869
 #include "peer_info.h"
+#include "loading/resource_manager.h"
 #include "multi_type.h"
 #include "shell_command.h"
-#include "loading/resource_manager.h"
 // this fcuk does not work!
 …
 // ->setAlias("ProxyGui");
 HostWidget::HostWidget(const std::string& name, const IP& ip)
     : GLGuiBox(OrxGui::Horizontal)
 …
+{
   if(_font == NULL)
     _font = new Font(ResourceManager::getInstance()->getDataDir() + "/fonts/arial.ttf", 20);
+    _font = new Font(Resources::ResourceManager::getInstance()->mainGlobalPath().name() + "/fonts/arial.ttf", 20);
   //this->_name.setFont(*_font);
 …
 //======================================================//
+ObjectListDefinition(NetworkStatsWidget);
 /**
  * @brief standard constructor
 …
 NetworkStatsWidget* NetworkStatsWidget::_statsWidget = NULL;
-#include "class_list.h"
 void NetworkStatsWidget::toggleGUI()
+{
+  BaseObject* bo = NULL;
+  const std::list<BaseObject*>* ls = ClassList::getList(CL_NETWORK_MONITOR);
+  if (ls != NULL && !ls->empty())
+    bo = ls->front();
+  if (bo != NULL && NetworkStatsWidget::_statsWidget == NULL)
+  {
+    NetworkStatsWidget::_statsWidget = new NetworkStatsWidget(dynamic_cast<NetworkMonitor*> (bo));
+  NetworkMonitor* monitor;
+  if (!NetworkMonitor::objectList().empty())
+    monitor = NetworkMonitor::objectList().front();
+  if (monitor != NULL && NetworkStatsWidget::_statsWidget == NULL)
+  {
+    NetworkStatsWidget::_statsWidget = new NetworkStatsWidget(monitor);
     NetworkStatsWidget::_statsWidget->showAll();
+  }

trunk/src/lib/network/monitor/network_stats_widget.h

r9656	r9869
81	81	class NetworkStatsWidget : public OrxGui::GLGuiFixedpositionBox
82	82	{
	83	ObjectListDeclaration(NetworkStatsWidget);
83	84	public:
84	85	static void toggleGUI();

trunk/src/lib/network/network_game_manager.cc

-                      r9656
+                      r9869
 #include "util/loading/factory.h"
 #include "state.h"
-#include "class_list.h"
 #include "debug.h"
 …
 #include "multiplayer_team_deathmatch.h"
 #include "preferences.h"
+#include "parser/preferences/preferences.h"
+ObjectListDefinition(NetworkGameManager);
 NetworkGameManager* NetworkGameManager::singletonRef = NULL;
 …
   /* set the class id for the base object */
   this->setClassID(CL_NETWORK_GAME_MANAGER, "NetworkGameManager");
+  this->registerObject(this, NetworkGameManager::_objectList);
   this->setSynchronized(true);
 …
   assert( SharedNetworkData::getInstance()->isMasterServer());
   assert( State::getGameRules() );
   assert( State::getGameRules()->isA( CL_NETWORK_GAME_RULES ) );
+  assert( State::getGameRules()->isA( NetworkGameRules::staticClassID()) );
   NetworkGameRules & rules = *(dynamic_cast<NetworkGameRules*>(State::getGameRules()));
   int          team = rules.getTeamForNewUser();
   ClassID      playableClassId = rules.getPlayableClassId( userId, team );
+  ClassID   playableClassId = rules.getPlayableClassId( userId, team );
   std::string  playableModel = rules.getPlayableModelFileName( userId, team, playableClassId );
   std::string  playableTexture = rules.getPlayableModelFileName( userId, team, playableClassId );
 …
   assert( bo != NULL );
   assert( bo->isA( CL_PLAYABLE ) );
+  assert( bo->isA( Playable::staticClassID()) );
   Playable & playable = *(dynamic_cast<Playable*>(bo));
 …
     stats->setNickName( Preferences::getInstance()->getString( "multiplayer", "nickname", "Server" ) );
   if ( rules.isA( CL_MULTIPLAYER_TEAM_DEATHMATCH ) )
+  if ( rules.isA( MultiplayerTeamDeathmatch::staticClassID()) )
     dynamic_cast<MultiplayerTeamDeathmatch*>(&rules)->respawnPlayable( &playable, team, 0.0f );
 …
+  }
   const std::list<BaseObject*> * list = ClassList::getList( CL_SYNCHRONIZEABLE );
   for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
+  {
     if ( dynamic_cast<Synchronizeable*>(*it)->getUniqueID() == uniqueId )
+  for (ObjectList<Synchronizeable>::const_iterator it = Synchronizeable::objectList().begin();
+       it != Synchronizeable::objectList().end();
+      ++it)
+  {
+    if ( (*it)->getUniqueID() == uniqueId )
+    {
       if ( (*it)->isA(CL_PLAYABLE) )
+      if ( (*it)->isA(Playable::staticClassID()) )
+      {
         getInstance()->playablesToDelete.push_back( dynamic_cast<Playable*>(*it) );
 …
+      }
       delete dynamic_cast<Synchronizeable*>(*it);
+      delete (*it);
       return true;
+    }
 …
     if ( State::getPlayer()->getPlayable() != *it )
+    {
+      const std::list<BaseObject*> * list = ClassList::getList( CL_PLAYABLE );
+      if ( list && std::find( list->begin(), list->end(), *it ) != list->end() )
+      if ( std::find( Playable::objectList().begin(), Playable::objectList().end(), *it ) != Playable::objectList().end() )
+      {
         PRINTF(0)("Delete unused playable: %s owner: %d\n", (*it)->getClassCName(), (*it)->getOwner() );
 …
   assert( State::getGameRules() );
   assert( State::getGameRules()->isA( CL_NETWORK_GAME_RULES ) );
+  assert( State::getGameRules()->isA( NetworkGameRules::staticClassID()) );
   NetworkGameRules & rules = *(dynamic_cast<NetworkGameRules*>(State::getGameRules()));

trunk/src/lib/network/network_game_manager.h

-                      r9656
+                      r9869
 class NetworkGameManager: public Synchronizeable
+{
+  ObjectListDeclaration(NetworkGameManager);
   public:
     virtual ~NetworkGameManager();
     static NetworkGameManager* NetworkGameManager::getInstance()
+    static NetworkGameManager* getInstance()
     { if (!NetworkGameManager::singletonRef) NetworkGameManager::singletonRef = new NetworkGameManager(); return NetworkGameManager::singletonRef; }

trunk/src/lib/network/network_log.cc

-                      r7954
+                      r9869
 #include "network_log.h"
+#include <cassert>
 /**
 …
     return false;
+  }
   listensock = SDLNet_TCP_Open( &ip );
   if( !listensock ) {
     PRINT(1)( "SDLNet_TCP_Open: %s\n", SDLNet_GetError() );
     return false;
+  }
+  }
   return true;
 …
   va_list ap;
   va_start( ap, format );
   assert( vsnprintf( buf, NETWORK_LOG_BUFLEN, format, ap ) < NETWORK_LOG_BUFLEN );
   va_end( ap );
+  assert( vsnprintf( buf, NETWORK_LOG_BUFLEN, format, ap ) < NETWORK_LOG_BUFLEN );
+  va_end( ap );
   printfnet();
+}
 …
+{
   TCPsocket newSock = SDLNet_TCP_Accept( listensock );
   if ( newSock )
     sockets.push_back( newSock );
 …
   va_list ap;
   va_start( ap, format );
   assert( vsnprintf( buf, NETWORK_LOG_BUFLEN, format, ap ) < NETWORK_LOG_BUFLEN );
   va_end( ap );
+  assert( vsnprintf( buf, NETWORK_LOG_BUFLEN, format, ap ) < NETWORK_LOG_BUFLEN );
+  va_end( ap );
   PRINT(0)( buf );
   printfnet();
 …
   va_list ap;
   va_start( ap, format );
   assert( vsnprintf( buf, NETWORK_LOG_BUFLEN, format, ap ) < NETWORK_LOG_BUFLEN );
   va_end( ap );
+  assert( vsnprintf( buf, NETWORK_LOG_BUFLEN, format, ap ) < NETWORK_LOG_BUFLEN );
+  va_end( ap );
   PRINT(1)( buf );
   printfnet();
 …
   va_list ap;
   va_start( ap, format );
   assert( vsnprintf( buf, NETWORK_LOG_BUFLEN, format, ap ) < NETWORK_LOG_BUFLEN );
   va_end( ap );
+  assert( vsnprintf( buf, NETWORK_LOG_BUFLEN, format, ap ) < NETWORK_LOG_BUFLEN );
+  va_end( ap );
   PRINT(2)( buf );
   printfnet();
 …
   va_list ap;
   va_start( ap, format );
   assert( vsnprintf( buf, NETWORK_LOG_BUFLEN, format, ap ) < NETWORK_LOG_BUFLEN );
   va_end( ap );
+  assert( vsnprintf( buf, NETWORK_LOG_BUFLEN, format, ap ) < NETWORK_LOG_BUFLEN );
+  va_end( ap );
   PRINT(3)( buf );
   printfnet();
 …
   va_list ap;
   va_start( ap, format );
   assert( vsnprintf( buf, NETWORK_LOG_BUFLEN, format, ap ) < NETWORK_LOG_BUFLEN );
   va_end( ap );
+  assert( vsnprintf( buf, NETWORK_LOG_BUFLEN, format, ap ) < NETWORK_LOG_BUFLEN );
+  va_end( ap );
   PRINT(4)( buf );
   printfnet();
 …
   va_list ap;
   va_start( ap, format );
   assert( vsnprintf( buf, NETWORK_LOG_BUFLEN, format, ap ) < NETWORK_LOG_BUFLEN );
   va_end( ap );
+  assert( vsnprintf( buf, NETWORK_LOG_BUFLEN, format, ap ) < NETWORK_LOG_BUFLEN );
+  va_end( ap );
   PRINT(5)( buf );
   printfnet();
 …
   if ( !listensock )
     return;
   acceptNewConnections();
 …
       continue;
+    }
     it++;
+  }

trunk/src/lib/network/network_log.h

r7954	r9869
38	38	class NetworkLog
39	39	{
40
41	40	public:
42	41	virtual ~NetworkLog(void);

trunk/src/lib/network/network_manager.cc

-                      r9656
+                      r9869
 #define DEBUG_MODULE_NETWORK
-#include "class_list.h"
 #include "debug.h"
 #include "shell_command.h"
 …
 #include "shared_network_data.h"
 #include "network_stream.h"
 #include "preferences.h"
+#include "parser/preferences/preferences.h"
 #include "network_log.h"
 #include "network_game_manager.h"
 …
+ObjectListDefinition(NetworkManager);
 NetworkManager* NetworkManager::singletonRef = NULL;
 …
+{
   /* set the class id for the base object */
   this->setClassID(CL_NETWORK_MANAGER, "NetworkManager");
+  this->registerObject(this, NetworkManager::_objectList);
   PRINTF(0)("START\n");

trunk/src/lib/network/network_manager.h

r9656	r9869
25	25	class NetworkManager : public BaseObject
26	26	{
27
	27	ObjectListDeclaration(NetworkManager);
28	28	public:
29	29

trunk/src/lib/network/network_protocol.cc

-                      r9406
+                      r9869
+ObjectListDefinition(NetworkProtocol);
 /**
   standard constructor
 …
+{
   /* set the class id for the base object */
   this->setClassID(CL_NETWORK_PROTOCOL, "NetworkProtocol");
+  this->registerObject(this, NetworkProtocol::_objectList);
   this->headerLength = INTSIZE+FLOATSIZE;
+}

trunk/src/lib/network/network_protocol.h

r6981	r9869
25	25	class NetworkProtocol : virtual public BaseObject
26	26	{
	27	ObjectListDeclaration(NetworkProtocol);
27	28	public:
28	29	NetworkProtocol();

trunk/src/lib/network/network_socket.cc

-                      r9406
+                      r9869
 #include "network_socket.h"
+/* header for debug output */
+#include "debug.h"
+ObjectListDefinition(NetworkSocket);
 /**
  * Default constructor

trunk/src/lib/network/network_socket.h

r9406	r9869
17	17	class NetworkSocket : public BaseObject
18	18	{
	19	ObjectListDeclaration(NetworkSocket);
19	20	public:
20	21	NetworkSocket();

trunk/src/lib/network/network_stream.cc

-                      r9656
+                      r9869
 #include "shared_network_data.h"
 #include "message_manager.h"
 #include "preferences.h"
+#include "parser/preferences/preferences.h"
 #include "zip.h"
-#include "src/lib/util/loading/resource_manager.h"
 #include "network_log.h"
 #include "player_stats.h"
+#include "lib/util/loading/factory.h"
+#include "loading/factory.h"
+#include "loading/resource_manager.h"
 #include "debug.h"
-#include "class_list.h"
-#include <algorithm>
 #include "network_stream.h"
 …
 #define PACKAGE_SIZE  256
+ObjectListDefinition(NetworkStream);
 /**
  * empty constructor
 …
+{
   /* set the class id for the base object */
   this->setClassID(CL_NETWORK_STREAM, "NetworkStream");
+  this->registerObject(this, NetworkStream::_objectList);
   this->clientSocket = NULL;
   this->clientSoftSocket = NULL;
 …
       // if handshake not finished only sync handshake
       if ( peer->second.handshake && sync.getLeafClassID() != CL_HANDSHAKE )
+      if ( peer->second.handshake && Handshake::staticClassID() != sync.getLeafClassID())
         continue;
 …
       if ( ( SharedNetworkData::getInstance()->isMasterServer() ||
              SharedNetworkData::getInstance()->isProxyServerActive() &&  peer->second.isClient())
              && sync.getLeafClassID() == CL_HANDSHAKE && sync.getUniqueID() != peer->second.userId )
+             && Handshake::staticClassID() == sync.getLeafClassID() && sync.getUniqueID() != peer->second.userId )
         continue;
       /* list of synchronizeables that will never be synchronized over the network: */
       // do not sync null parent
       if ( sync.getLeafClassID() == CL_NULL_PARENT )
+      if ( NullParent::staticClassID() == sync.getLeafClassID())
         continue;
 …
           /* These are some small exeptions in creation: Not all objects can/should be created via Factory */
           /* Exception 1: NullParent */
           if( leafClassId == CL_NULL_PARENT || leafClassId == CL_SYNCHRONIZEABLE || leafClassId == CL_NETWORK_GAME_MANAGER )
+          if( NullParent::staticClassID() == leafClassId || Synchronizeable::staticClassID() == leafClassId || NetworkGameManager::staticClassID() == leafClassId)
+          {
             PRINTF(1)("Don't create Object with ID %x, ignored!\n", (int)leafClassId);
 …
+          }
           else
             b = Factory::fabricate( (ClassID)leafClassId );
+            ; /// FIXME CLASS_ID :: b = Factory::fabricate( leafClassId );
           if ( !b )
 …
+          }
           if ( b->isA(CL_SYNCHRONIZEABLE) )
+          if ( b->isA(Synchronizeable::staticClassID()) )
+          {
             sync = dynamic_cast<Synchronizeable*>(b);
 …
     length = remainingBytesToWriteToDict;
   std::string fileName = ResourceManager::getInstance()->getDataDir();
+  std::string fileName = Resources::ResourceManager::getInstance()->mainGlobalPath().name();
   fileName += "/dicts/newdict";

trunk/src/lib/network/network_stream.h

r9656	r9869
33	33	class NetworkStream : public DataStream
34	34	{
35
	35	ObjectListDeclaration(NetworkStream);
36	36	public:
37	37	NetworkStream();

trunk/src/lib/network/player_stats.cc

-                      r9656
+                      r9869
 #include "player_stats.h"
-#include "class_list.h"
 #include "src/lib/util/loading/factory.h"
 #include "player.h"
+#include "playable.h"
 #include "state.h"
 #include "shared_network_data.h"
 …
 #include "converter.h"
 #include "preferences.h"
+#include "parser/preferences/preferences.h"
 #include "debug.h"
 #include "shell_command.h"
+CREATE_FACTORY(PlayerStats, CL_PLAYER_STATS);
+#include "class_id_DEPRECATED.h"
+ObjectListDefinitionID(PlayerStats, CL_PLAYER_STATS);
+CREATE_FACTORY(PlayerStats);
 /**
 …
 void PlayerStats::init( )
+{
   this->setClassID( CL_PLAYER_STATS, "PlayerStats" );
+  this->registerObject(this, PlayerStats::_objectList);
   this->assignedUserId = 0;
 …
 PlayerStats * PlayerStats::getStats( int userId )
+{
+  const std::list<BaseObject*> * list = ClassList::getList( CL_PLAYER_STATS );
+  if ( !list )
+  {
+    return NULL;
+  }
+  for ( std::list<BaseObject*>::const_iterator it = list->
+        begin();
+        it != list->end();
+        it++ )
+  {
+    if ( dynamic_cast<PlayerStats*>(*it)->getAssignedUserId() == userId )
+  for (ObjectList<PlayerStats>::const_iterator it = PlayerStats::objectList().begin();
+       it != PlayerStats::objectList().end();
+       ++it)
+  {
+    if ( (*it)->getAssignedUserId() == userId )
+    {
       return dynamic_cast<PlayerStats*>(*it);
+      return (*it);
+    }
+  }
 …
 void PlayerStats::setPlayableUniqueId( int uniqueId )
+{
-  const std::list<BaseObject*> * list = ClassList::getList( CL_PLAYABLE );
-  if ( !list )
+  {
-    this->playableUniqueId = uniqueId;
-    return;
+  }
   this->playable = NULL;
+  for ( std::list<BaseObject*>::const_iterator it = list->
+        begin();
+        it != list->end();
+        it++ )
+  {
+    if ( dynamic_cast<Playable*>(*it)->
+         getUniqueID() == uniqueId )
+  for (ObjectList<Playable>::const_iterator it = Playable::objectList().begin();
+       it != Playable::objectList().end();
+       ++it)
+  {
+    if ( (*it)->getUniqueID() == uniqueId )
+    {
       this->playable = dynamic_cast<Playable*>(*it);
+      this->playable = (*it);
       //TODO when OM_PLAYERS is ticked add line:
       //this->playable->toList( OM_PLAYERS );
 …
+  }
+  if ( this->playable && this->assignedUserId == SharedNetworkData::getInstance()
+       ->getHostID() )
+  if ( this->playable && this->assignedUserId == SharedNetworkData::getInstance()->getHostID() )
+  {
     State::getPlayer()->setPlayable( this->playable );
 …
 void PlayerStats::deleteAllPlayerStats( )
+{
+  const std::list<BaseObject*> * list;
+  while ( (list  = ClassList::getList( CL_PLAYER_STATS )) != NULL && list->begin() != list->end() )
+    delete *list->begin();
+  while(!PlayerStats::objectList().empty())
+    delete PlayerStats::objectList().front();
+}
 …
   ScoreList result;
+  const std::list<BaseObject*> * list = ClassList::getList( CL_PLAYER_STATS );
+  if ( !list )
+  {
+    return result;
+  }
+  for ( std::list<BaseObject*>::const_iterator it = list->
+        begin();
+        it != list->end();
+        it++ )
+  {
+    PlayerStats & stats = *dynamic_cast<PlayerStats*>(*it);
+  for (ObjectList<PlayerStats>::const_iterator it = PlayerStats::objectList().begin();
+       it != PlayerStats::objectList().end();
+       ++it)
+  {
+    PlayerStats& stats = *(*it);
     TeamScoreList::iterator it = result[stats.getTeamId()].begin();

trunk/src/lib/network/player_stats.h

-                      r9656
+                      r9869
 class PlayerStats : public Synchronizeable
+{
+  ObjectListDeclaration(PlayerStats);
   public:
     PlayerStats( const TiXmlElement* root = NULL );
 …
     inline int getPlayableClassId(){ return playableClassId; }
     void setPlayableClassId( int classId ){ this->playableClassId = classId; };
+    void setPlayableClassId( const ClassID& classId ){ this->playableClassId = classId.id(); };
     inline int getPlayableUniqueId(){ return playableUniqueId; }

trunk/src/lib/network/proxy/network_settings.cc

-                      r9656
+                      r9869
 #include "shared_network_data.h"
+#include "loading/load_param.h"
 #include "loading/resource_manager.h"
-#include "loading/load_param.h"
 #include "debug.h"
+ObjectListDefinition(NetworkSettings);
 NetworkSettings* NetworkSettings::singletonRef = NULL;
 …
+{
   /* set the class id for the base object */
   this->setClassID(CL_NETWORK_SETTINGS, "NetworkSettings");
+  this->registerObject(this, NetworkSettings::_objectList);
   // suggest a good standard max players value
 …
 void NetworkSettings::loadData()
+{
   std::string fileName = ResourceManager::getInstance()->getDataDir();
+  std::string fileName = Resources::ResourceManager::getInstance()->mainGlobalPath().name();
   fileName += "configs/network_settings.conf";

trunk/src/lib/network/proxy/network_settings.h

r9494	r9869
24	24	class NetworkSettings : public BaseObject
25	25	{
26
	26	ObjectListDeclaration(NetworkSettings);
27	27	public:
28	28	inline static NetworkSettings* getInstance() { if (!NetworkSettings::singletonRef) NetworkSettings::singletonRef = new NetworkSettings();

trunk/src/lib/network/proxy/proxy_control.cc

-                      r9656
+                      r9869
 #include "proxy_control.h"
-#include "class_list.h"
 #include "shell_command.h"
 …
 #include "converter.h"
 #include "preferences.h"
+#include "parser/preferences/preferences.h"
 #include "debug.h"
 …
 SHELL_COMMAND(forceReconnect, ProxyControl, forceReconnectionShell);
+ObjectListDefinition(ProxyControl);
 /**
 …
 ProxyControl::ProxyControl()
+{
   this->setClassID( CL_PROXY_CONTROL, "ProxyControl" );
+  this->registerObject(this, ProxyControl::_objectList);
   this->setSynchronized(false);

trunk/src/lib/network/proxy/proxy_control.h

r9656	r9869
30	30	class ProxyControl : public Synchronizeable
31	31	{
32
	32	ObjectListDeclaration(ProxyControl);
33	33	public:
34	34	inline static ProxyControl* getInstance() { if (!ProxyControl::singletonRef) ProxyControl::singletonRef = new ProxyControl();

trunk/src/lib/network/server_socket.cc

-                      r7954
+                      r9869
 #include "server_socket.h"
+/* header for debug output */
+#include "debug.h"
+ObjectListDefinition(ServerSocket);
 /**
  * constructor

trunk/src/lib/network/server_socket.h

r9656	r9869
19	19	class ServerSocket : public BaseObject
20	20	{
	21	ObjectListDeclaration(ServerSocket);
21	22	public:
22	23	ServerSocket( int port);

trunk/src/lib/network/shared_network_data.cc

-                      r9494
+                      r9869
+ObjectListDefinition(SharedNetworkData);
 SharedNetworkData* SharedNetworkData::singletonRef = NULL;
 …
+{
   /* set the class id for the base object */
   this->setClassID(CL_SHARED_NETWORK_DATA, "SharedNetworkData");
+  this->registerObject(this, SharedNetworkData::_objectList);
   this->nodeType = NET_MASTER_SERVER;

trunk/src/lib/network/shared_network_data.h

r9656	r9869
22	22	class SharedNetworkData : public BaseObject
23	23	{
24
	24	ObjectListDeclaration(SharedNetworkData);
25	25	public:
26	26	inline static SharedNetworkData* getInstance() { if (!SharedNetworkData::singletonRef) SharedNetworkData::singletonRef = new SharedNetworkData();

trunk/src/lib/network/synchronizeable.cc

-                      r9656
+                      r9869
+ObjectListDefinition(Synchronizeable);
 /**
 …
 Synchronizeable::Synchronizeable()
+{
   this->setClassID(CL_SYNCHRONIZEABLE, "Synchronizeable");
+  this->registerObject(this, Synchronizeable::_objectList);
   this->owner = 0;
 //   this->setIsServer(SharedNetworkData::getInstance()->getHostID() == 0);
 …
     // remove the message manager only by the server
     if ( (SharedNetworkData::getInstance()->isMasterServer() )
            && this->beSynchronized() && this->getUniqueID() > 0 && !this->isA( CL_MESSAGE_MANAGER ) )
+          && this->beSynchronized() && this->getUniqueID() > 0 && !this->isA( MessageManager::staticClassID() ) )
       NetworkGameManager::getInstance()->removeSynchronizeable( this->getUniqueID() );
+  }

trunk/src/lib/network/synchronizeable.h

r9406	r9869
41	41	class Synchronizeable : virtual public BaseObject
42	42	{
	43	ObjectListDeclaration(Synchronizeable);
43	44
44	45	public:

trunk/src/lib/network/tcp_server_socket.cc

-                      r9494
+                      r9869
 #include "debug.h"
+ObjectListDefinition(TcpServerSocket);
 TcpServerSocket::TcpServerSocket( int port ) : ServerSocket( port )
+{
 …
+{
   /* set the class id for the base object */
   this->setClassID(CL_SERVER_SOCKET, "TcpServerSocket");
+  this->registerObject(this, TcpServerSocket::_objectList);
   terminateThread = false;

trunk/src/lib/network/tcp_server_socket.h

r9406	r9869
19	19	class TcpServerSocket : public ServerSocket
20	20	{
	21	ObjectListDeclaration(TcpServerSocket);
21	22	public:
22	23	TcpServerSocket( int port );

trunk/src/lib/network/tcp_socket.cc

r7954	r9869
30	30	#include "debug.h"
31	31
	32	ObjectListDefinition(TcpSocket);
32	33	/**
33	34	* Default constructor
…	…
60	61	{
61	62	/* set the class id for the base object */
62		this->~~setClassID(CL_NETWORK_SOCKET, "TcpSocket"~~);
	63	this->registerObject(this, TcpSocket::_objectList);
63	64
64	65	tcpSocket = NULL;
…	…
122	123	{
123	124	IPaddress ip;
124
125		bOk = true;
126
	125
	126	bOk = true;
	127
127	128	if ( SDLNet_ResolveHost( &ip, host.c_str(), port ) != 0 )
128	129	{
…	…
131	132	return;
132	133	}
133
	134
134	135	//check if not already connected or listening
135	136	if (tcpSocket)
…	…
345	346	}
346	347	#endif
347
	348
348	349	PRINTF(0)("QUIT READ THREAD\n");
349
	350
350	351	return 0;
351	352	}
…	…
425	426
426	427	return 0;
427
	428
428	429	}
429	430

trunk/src/lib/network/tcp_socket.h

r9406	r9869
40	40	class TcpSocket : public NetworkSocket
41	41	{
	42	ObjectListDeclaration(TcpSocket);
42	43	public:
43	44	TcpSocket();

trunk/src/lib/network/udp_broadcast.cc

r8623	r9869
26	26	this->port = 0;
27	27	packet = SDLNet_AllocPacket( BROADCAST_PACKET_SIZE );
28
29		if ( !packet )
	28
	29	if ( !packet )
30	30	{
31	31	printf( "SDLNet_AllocPacket: %s\n", SDLNet_GetError() );
32	32	assert( packet );
33	33	}
34
	34
35	35	this->socket = NULL;
36	36	}
…	…
47	47	this->packet = NULL;
48	48	}
49
	49
50	50	if ( this->socket )
51	51	{
…	…
53	53	this->socket = NULL;
54	54	}
55
	55
56	56	}
57	57
58	58	/**
59	59	* listen for incoming broadcast packets
60		* @param port port to listen on
	60	* @param port port to listen on
61	61	* @return true on success
62	62	*/
…	…
74	74	{
75	75	this->port = port;
76
	76
77	77	return true;
78	78	}
…	…
80	80	/**
81	81	* send packet
82		* @param data data to send
	82	* @param data data to send
83	83	* @param length length of data
84	84	* @param ip if ip == NULL broadcast is used

trunk/src/lib/network/udp_broadcast.h

-                      r8623
+                      r9869
 class UdpBroadcast
+{
   public:
     UdpBroadcast();
     virtual ~UdpBroadcast();
     bool listen( int port );
     bool open( int port );

trunk/src/lib/network/udp_server_socket.cc

r9494	r9869
18	18
19	19
20
	20	ObjectListDefinition(UdpServerSocket);
21	21	/**
22	22	* constructor

trunk/src/lib/network/udp_server_socket.h

r9494	r9869
50	50	class UdpServerSocket : public ServerSocket
51	51	{
	52	ObjectListDeclaration(UdpServerSocket);
52	53	public:
53	54	UdpServerSocket( int port);

trunk/src/lib/network/udp_socket.cc

r9406	r9869
18	18	#include "debug.h"
19	19
	20	ObjectListDefinition(UdpSocket);
20	21
21	22	void UdpSocket::init( )

trunk/src/lib/network/udp_socket.h

r9656	r9869
24	24	class UdpSocket : public NetworkSocket
25	25	{
	26	ObjectListDeclaration(UdpSocket);
26	27	public:
27	28	UdpSocket();

trunk/src/lib/network/zip.cc

-                      r8623
+                      r9869
 #include "zip.h"
+#include "src/lib/util/loading/resource_manager.h"
+#include "loading/resource_manager.h"
 #include "debug.h"
 …
 int Zip::loadDictionary( std::string name )
+{
   std::string fileName = ResourceManager::getInstance()->getDataDir();
+  std::string fileName = Resources::ResourceManager::getInstance()->mainGlobalPath().name();
   //PRINTF(0)("datadir: %s\n", fileName.c_str());
   fileName = fileName + "/dicts/" + name;

trunk/src/lib/parser/Makefile.am

-                      r7256
+                      r9869
           tinyxml \
           ini_parser \
           preferences \
           cmdline_parser
+          cmdline_parser \
+          preferences

trunk/src/lib/parser/cmdline_parser/Makefile.am

r7256	r9869
	1
	2	INCLUDES = -I../../..
1	3
2	4	noinst_LIBRARIES = libCmdLineParser.a

trunk/src/lib/parser/cmdline_parser/cmdline_parser.cc

r9406	r9869
16	16	#include "cmdline_parser.h"
17	17
	18	#include <cassert>
18	19	#include "src/lib/util/substring.h"
19	20

trunk/src/lib/parser/cmdline_parser/cmdline_parser.h

-                      r8316
+                      r9869
 #include <vector>
 #include "src/defs/debug.h"
 #include "src/lib/util/multi_type.h"
+#include "lib/util/debug.h"
+#include "lib/util/multi_type.h"

trunk/src/lib/parser/ini_parser/Makefile.am

r8330	r9869
1		INCLUDES~~=-I../../util~~
	1	INCLUDES = -I../../..
2	2
3	3

trunk/src/lib/parser/ini_parser/ini_parser.cc

-                      r9406
+                      r9869
 #ifdef DEBUG_LEVEL
  #include "../../../defs/debug.h"
+ #include "../../../lib/util/debug.h"
 #else
  #define PRINTF(x) printf
 …
       else if( (ptr = strchr( lineBegin, '=')) != NULL)
+      {
         if (currentSection == NULL)
+        if (currentSection == this->sections.end())
+        {
           PRINTF(2)("Not in a Section yet for %s\n", lineBegin);
 …
+  {
     std::list<IniEntry>::const_iterator entry = this->getEntryIT(entryName, sectionName);
     if (entry != NULL &&  (*entry).name == entryName)
+    if (/** FIXME entry != NULL && */  (*entry).name == entryName)
       return (*entry).value;
     PRINTF(2)("Entry '%s' in section '%s' not found.\n", entryName.c_str(), sectionName.c_str());
 …
       if ((*entry).name == entryName)
         break;
+  if (entry == (*section).entries.end())
+    return NULL;
+  else
+    return entry;
+  return entry;
+}
 …
       if ((*entry).name == entryName)
         break;
+  if (entry == (*section).entries.end())
+    return NULL;
+  else
+    return entry;
+  return entry;
+}

trunk/src/lib/parser/ini_parser/ini_parser.h

-                      r8330
+                      r9869
 #define PARSELINELENGHT     512       //!< how many chars to read at once
 #include "filesys/file.h"
+#include "lib/util/filesys/file.h"
 #include <list>
 …
     bool addVar(const std::string& entryName, const std::string& value, const std::string& sectionName = "" );
     const std::string& getVar(const std::string& entryName, const std::string& sectionName, const std::string& defaultValue = "") const;
     bool IniParser::editVar(const std::string& entryName, const std::string& value, const std::string& sectionName = "", bool createMissing = true);
+    bool editVar(const std::string& entryName, const std::string& value, const std::string& sectionName = "", bool createMissing = true);
     void setEntryComment(const std::string& comment, const std::string& entryName, const std::string& sectionName);
     const std::string& getEntryComment(const std::string& entryName, const std::string& sectionName) const;

trunk/src/lib/parser/preferences/Makefile.am

-                      r7256
+                      r9869
 libPrefsParser_a_SOURCES = \
                 cmd_line_prefs_reader.cc \
+                ini_file_prefs_reader.cc
+                ini_file_prefs_reader.cc \
+                preferences.cc
 noinst_HEADERS = \
                 cmd_line_prefs_reader.h \
+                ini_file_prefs_reader.h
+                ini_file_prefs_reader.h \
+                preferences.h

trunk/src/lib/parser/preferences/cmd_line_prefs_reader.h

-                      r7256
+                      r9869
 #define _CMD_LINE_PREFS_READER_H
-#include "stdincl.h"
 #include "debug.h"
 …
 };
 #define REGISTER_ARG_FLAG(shortOption,longOption,section,key,description,value) bool _ARGVAR_##shortOption##_##longOption = CmdLinePrefsReader::registerArgument(#shortOption[0],#longOption,section,key,description,"",value)
+#define REGISTER_ARG_FLAG(shortOption,longOption,section,key,description,value) bool _ARGVAR_##shortOption##_##longOption = CmdLinePrefsReader::registerArgument(#shortOption[0],#longOption,section,key,description,"",value)
 #define REGISTER_ARG_ARG(shortOption,longOption,section,key,description,argname) bool _ARGVAR_##shortOption##_##longOption = CmdLinePrefsReader::registerArgument(#shortOption[0],#longOption,section,key,description,argname)
+#define REGISTER_ARG_ARG(shortOption,longOption,section,key,description,argname) bool _ARGVAR_##shortOption##_##longOption = CmdLinePrefsReader::registerArgument(#shortOption[0],#longOption,section,key,description,argname)
 //! A class for reading commandline arguments into Preferences
 class CmdLinePrefsReader
+class CmdLinePrefsReader
+{
 …
     bool parse(int argc, char** argv);
     static bool registerArgument( const char shortOption, const std::string & longOption, const std::string & section, const std::string & key, const std::string & help,  const std::string & argName = "", const std::string & value = "%arg%" );
     static bool asdf;
   private:
     static bool callBack( ArgTableEntry entry, void* data, const std::string & arg, const std::vector<MultiType> & argArgs );
     static RegistredArgs regArgs;

trunk/src/lib/parser/preferences/ini_file_prefs_reader.h

-                      r7256
+                      r9869
 #define _INI_FILE_PREFS_READER_H
 #include "src/lib/parser/ini_parser/ini_parser.h"
 #include "src/lib/util/preferences.h"
+#include "lib/parser/ini_parser/ini_parser.h"
+#include "lib/parser/preferences/preferences.h"

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

-                      r9406
+                      r9869
 #include "util/loading/load_param.h"
+ObjectListDefinition(Field);
 /**
  *  standard constructor
+ * @brief standard constructor
 */
 Field::Field ()
 …
 /**
+ *  standard deconstructor
+*/
+ * @brief standard deconstructor
+ */
 Field::~Field ()
+{
 …
 /**
   \brief initializes a Field
 */
+  * @brief initializes a Field
+ */
 void Field::init()
+{
   this->setClassID(CL_FIELD, "Field");
+  this->registerObject(this, Field::_objectList);
   this->setMagnitude(1);
   this->setAttenuation(0);
 …
 /**
 * @param root The XML-element to load settings from
+ * @param root The XML-element to load settings from
  */
 void Field::loadParams(const TiXmlElement* root)

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

-                      r6512
+                      r9869
 /*!
  * @file field.h
   *  abstract definition of a Physical Field
     This is a totally abstract class, that only enables different Physical Fields to
     exist on a common Level.
 */
+ * abstract definition of a Physical Field
+ *
+ * This is a totally abstract class, that only enables different Physical Fields to
+ * exist on a common Level.
+ */
 #ifndef _FIELD_H
 …
 class Field : public PNode
+{
+  ObjectListDeclaration(Field);
  public:
   Field();

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

-                      r9406
+                      r9869
 #include "util/loading/factory.h"
+#include "class_id_DEPRECATED.h"
+ObjectListDefinitionID(Gravity, CL_FIELD_GRAVITY);
+CREATE_FACTORY(Gravity, CL_FIELD_GRAVITY);
+CREATE_FACTORY(Gravity);
 Gravity::Gravity(const TiXmlElement* root)
+{
   this->setClassID(CL_FIELD_GRAVITY, "Gravity");
+  this->registerObject(this, Gravity::_objectList);
   if (root != NULL)

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

r6512	r9869
16	16	//! A class for ...
17	17	class Gravity : public Field {
	18	ObjectListDeclaration(Gravity);
18	19
19	20	public:

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

-                      r9406
+                      r9869
+#include "class_id_DEPRECATED.h"
+ObjectListDefinitionID(PointGravity, CL_FIELD_POINT_GRAVITY);
 /**
 …
 PointGravity::PointGravity ()
+{
    this->setClassID(CL_FIELD_POINT_GRAVITY, "PointGravity");
+  this->registerObject(this, PointGravity::_objectList);
+}

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

-                      r5405
+                      r9869
 /*!
+/*!
  * @file point_gravity.h
   *  Definition of ...
 …
 //! A class for ...
 class PointGravity : public Field {
+  ObjectListDeclaration(PointGravity);
  public:

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

-                      r9406
+                      r9869
+#include "class_id_DEPRECATED.h"
+ObjectListDefinitionID(Twirl, CL_FIELD_TWIRL);
 /**
 …
 Twirl::Twirl ()
+{
    this->setClassID(CL_FIELD_TWIRL, "Twirl");
+  this->registerObject(this, Twirl::_objectList);
+}

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

-                      r5405
+                      r9869
 /*!
+/*!
  * @file twirl.h
   *  Definition of ...
 …
 //! A class for ...
 class Twirl : public Field {
+  ObjectListDeclaration(Twirl);
  public:

trunk/src/lib/physics/physics_connection.cc

-                      r9406
+                      r9869
 #include "physics_engine.h"
+#include "debug.h"
 #include "field.h"
 #include "particle_system.h"
+#include "fields/field.h"
+#include "particles/particle_system.h"
 #include "physics_interface.h"
 …
 #include "util/loading/load_param.h"
+CREATE_FACTORY(PhysicsConnection, CL_PHYSICS_CONNECTION);
+#include "class_id_DEPRECATED.h"
+ObjectListDefinition(PhysicsConnection);
+CREATE_FACTORY(PhysicsConnection);
 /**
  *  creates a PhysicsConnection
 …
 PhysicsConnection::PhysicsConnection(PhysicsInterface* subject, Field* field)
+{
   this->setClassID(CL_PHYSICS_CONNECTION, "PhysicsConnection");
+  this->registerObject(this, PhysicsConnection::_objectList);
   this->type = PCON_PhysIField;
 …
 PhysicsConnection::PhysicsConnection(const TiXmlElement* root)
+{
   this->setClassID(CL_PHYSICS_CONNECTION, "PhysicsConnection");
+  this->registerObject(this, PhysicsConnection::_objectList);
   this->type = PCON_PhysIField;

trunk/src/lib/physics/physics_connection.h

r7221	r9869
27	27	class PhysicsConnection : public BaseObject
28	28	{
29
	29	ObjectListDeclaration(PhysicsConnection);
30	30	public:
31	31	PhysicsConnection(PhysicsInterface* subject, Field* field);

trunk/src/lib/physics/physics_engine.cc

-                      r9406
+                      r9869
 #include "physics_engine.h"
-#include "class_list.h"
-#include "parser/tinyxml/tinyxml.h"
 #include "util/loading/factory.h"
 #include "util/loading/load_param.h"
 /**
  *  standard constructor
 */
+#include "util/loading/load_param_xml.h"
+ObjectListDefinition(PhysicsEngine);
+/**
+ * @brief standard constructor
+ */
 PhysicsEngine::PhysicsEngine()
+{
   this->setClassID(CL_PHYSICS_ENGINE, "PhysicsEngine");
+  this->registerObject(this, PhysicsEngine::_objectList);
   this->setName("PhysicsEngine");
   this->interfaces = NULL;
 …
 PhysicsInterface* PhysicsEngine::getPhysicsInterfaceByName(const std::string& physicsInterfaceName) const
+{
+  BaseObject* interface = ClassList::getObject(physicsInterfaceName, CL_PHYSICS_INTERFACE);
+  return (interface != NULL)?  dynamic_cast<PhysicsInterface*>(interface) : NULL;
+  return PhysicsInterface::objectList().getObject(physicsInterfaceName);
+}
 …
   /* actually tick all the PhysicsInterfaces. Move the objects around */
+  if (this->interfaces != NULL || (this->interfaces = ClassList::getList(CL_PHYSICS_INTERFACE)) != NULL)
+  {
     std::list<BaseObject*>::const_iterator tickPhys;
     for (tickPhys = this->interfaces->begin(); tickPhys != this->interfaces->end(); tickPhys++)
       dynamic_cast<PhysicsInterface*>(*tickPhys)->tickPhys(dt);
+  }
+  ObjectList<PhysicsInterface>::const_iterator it;
+  for (it = PhysicsInterface::objectList().begin();
+       it != PhysicsInterface::objectList().end();
+       ++it)
+      (*it)->tickPhys(dt);
+}

trunk/src/lib/physics/physics_engine.h

-                      r7221
+                      r9869
 #include "physics_connection.h"
 #include "physics_interface.h"
 #include "field.h"
+#include "fields/field.h"
 #include <list>
 …
 //! A class, that brings things into motion through Physics.
+class PhysicsEngine : public BaseObject {
+ public:
+class PhysicsEngine : public BaseObject
+{
+  ObjectListDeclaration(PhysicsEngine);
+public:
   virtual ~PhysicsEngine();
   /** @returns a Pointer to the only object of this Class */
 …
   void                   debug() const;
  private:
+private:
   PhysicsEngine();
  private:
+private:
   static PhysicsEngine*         singletonRef;         //!< the singleton reference of the PhysicsEngine

trunk/src/lib/physics/physics_interface.cc

-                      r9406
+                      r9869
 #include "physics_engine.h"
 #include "field.h"
+#include "fields/field.h"
 #include "p_node.h"
 …
+ObjectListDefinition(PhysicsInterface);
 /**
  *  standard constructor
+ * @brief standard constructor
  */
 PhysicsInterface::PhysicsInterface ()
+{
   this->setClassID(CL_PHYSICS_INTERFACE, "PhysicsInterface");
+  this->registerObject(this, PhysicsInterface::_objectList);
   this->mass = 1;

trunk/src/lib/physics/physics_interface.h

r8190	r9869
29	29	class PhysicsInterface : virtual public BaseObject
30	30	{
	31	ObjectListDeclaration(PhysicsInterface);
31	32	public:
32	33	PhysicsInterface();

trunk/src/lib/script_engine/Makefile.am

-                      r8711
+                      r9869
                 script_manager.cc \
                 script_class.cc \
+                script_method.cc
+                script_method.cc \
+                executor_lua_state.cc
 AM_CPPFLAGS= @LUA_INCLUDES@
 …
                 script_manager.h \
                 script_class.h \
+                script_method.h
+                script_method.h \
+                executor_lua_state.h

trunk/src/lib/script_engine/lunar.h

-                      r8408
+                      r9869
   userdataType;
 public:
   typedef Executor* mfp;
+  typedef Executor<lua_State*>* mfp;
   typedef struct { const char *name; mfp mfunc; }
   RegType;
 …
     lua_remove(L, 1);  // remove self so member function args start at index 1
     // get member function from upvalue
+    Executor *l = static_cast<Executor*>(lua_touserdata(L, lua_upvalueindex(1)));
+    int value;
+    (*l)(obj, value, L);  // call member function
+    return value;
+    mfp l = static_cast<mfp>(lua_touserdata(L, lua_upvalueindex(1)));
+    (*l)(obj, L);  // call member function
+    return l->hasRetVal()? 1 : 0;
+  }

trunk/src/lib/script_engine/script.cc

-                      r9298
+                      r9869
 #include "luaincl.h"
 #include "debug.h"
+#include "util/loading/resource_manager.h"
+#include "loading/resource_manager.h"
 #include "loading/load_param.h"
 #include "parser/tinyxml/tinyxml.h"
+#include "class_list.h"
+CREATE_SCRIPTABLE_CLASS(Script, CL_SCRIPT,
+                    addMethod("addObject", ExecutorLua2<Script,const std::string&, const std::string& >(&Script::addObject))
+                    ->addMethod("registerClass", ExecutorLua1<Script,const std::string&>(&Script::registerClass))
+                    ->addMethod("selectFunction", ExecutorLua2ret<Script, bool, const std::string&, int >(&Script::selectFunction))
+                    ->addMethod("executeFunction", ExecutorLua0ret<Script,bool >(&Script::executeFunction))
+ObjectListDefinition(Script);
+CREATE_SCRIPTABLE_CLASS(Script,
+                    addMethod("addObject", Executor2<Script, lua_State*,const std::string&, const std::string& >(&Script::addObject))
+                    ->addMethod("registerClass", Executor1<Script, lua_State*,const std::string&>(&Script::registerClass))
+                    ->addMethod("selectFunction", Executor2ret<Script, lua_State*, bool, const std::string&, int >(&Script::selectFunction))
+                    ->addMethod("executeFunction", Executor0ret<Script, lua_State*,bool >(&Script::executeFunction))
                      );
 Script::Script(const TiXmlElement* root)
+{
   this->setClassID(CL_SCRIPT, "Script");
+  this->registerObject(this, Script::_objectList);
   returnCount = argumentCount = 0;
 …
 Script::Script(const std::string& filename)
+{
   this->setClassID(CL_SCRIPT, "Script");
+  this->registerObject(this, Script::_objectList);
   returnCount = argumentCount = 0;
 …
   luaopen_math(luaState);
   luaopen_debug(luaState);
   this->loadFile(filename);
 …
 bool Script::loadFile(const std::string& filename)
+ {
    std::string filedest(ResourceManager::getInstance()->getDataDir());
    filedest += "scripts/" + filename;
+   std::string filedest(Resources::ResourceManager::getInstance()->mainGlobalPath().name());
+   filedest += "/scripts/" + filename;
    this->addThisScript();
    this->registerStandartClasses();
    if(currentFile.length() != 0)
+   {
 …
    //printf(("Script %s: I am about to add %s of class %s\n",this->getName(),objectName.c_str(),className.c_str());
    BaseObject* scriptClass = ClassList::getObject(className, CL_SCRIPT_CLASS);
+   ScriptClass* scriptClass = ScriptClass::objectList().getObject(className);
   // printf(("The script class for %s is at %p \n",className.c_str(),scriptClass);
    WorldObject tmpObj;
 …
      if( !classIsRegistered(className) )
+     {
      static_cast<ScriptClass*>(scriptClass)->registerClass(this);
+     }
      BaseObject* object = ClassList::getObject(objectName, className);
+       scriptClass->registerClass(this);
+     }
+     BaseObject* object = ObjectListBase::getBaseObject(className, objectName);
     // printf(("%s is at %p \n",objectName.c_str(),object);
      if (object != NULL && !objectIsAdded(objectName))
+     {
         static_cast<ScriptClass*>(scriptClass)->insertObject(this, object, false);
+        scriptClass->insertObject(this, object, false);
         tmpObj.name = objectName;
         registeredObjects.push_back(tmpObj);
 …
  bool Script::executeFile()
+ {
    PRINT(2)("WARNING: script.executeFile is not implemented yet\n");
+   PRINTF(2)("script.executeFile is not implemented yet\n");
    /*if(currentFile.length() != 0)
+   {
 …
     if(error != 0)
+    {
       printf("SCRIPT %s : ERROR: Failed to execute function %s: \n",currentFile.c_str(),currentFunction.c_str());
+      PRINTF(1)("Script '%s' : Failed to execute function '%s': \n",currentFile.c_str(),currentFunction.c_str());
      reportError(error);
      //clean up
 …
+   }
    else
      printf("SCRIPT %s : ERROR: no function selected.\n",currentFile.c_str());
+     PRINTF(1)("SCRIPT '%s' : no function selected.\n",currentFile.c_str());
    return false;
 …
        lua_remove(luaState,-1*returnCount);
        returnCount--;
+     }
+   }
 …
 void Script::addThisScript()
+{
+  BaseObject* scriptClass = ClassList::getObject("Script", CL_SCRIPT_CLASS);
+   if (scriptClass != NULL)
+   {
+     static_cast<ScriptClass*>(scriptClass)->registerClass(this);
+     static_cast<ScriptClass*>(scriptClass)->insertObject(this, this,"thisscript", false);
+  ScriptClass* scriptClass = ScriptClass::objectList().getObject("Script");
+  if (scriptClass != NULL)
+   {
+     scriptClass->registerClass(this);
+     scriptClass->insertObject(this, this,"thisscript", false);
+   }
+}
 …
+ {
    bool success = false;
    //this->registerClass(std::string("Vector"));
     this->registerClass("ScriptTrigger");
 …
    return success;
+ }
  void Script::registerClass( const std::string& className)
+ {
    BaseObject* scriptClass = ClassList::getObject(className, CL_SCRIPT_CLASS);
+   ScriptClass* scriptClass = ScriptClass::objectList().getObject(className);
    //printf(("The script class for %s is at %p \n",className.c_str(),scriptClass);
    WorldObject tmpObj;
    if (scriptClass != NULL)
 …
+     }
+   }
+ }

trunk/src/lib/script_engine/script.h

-                      r9298
+                      r9869
 class Script : public BaseObject
+{
+  ObjectListDeclaration(Script);
   public:
     Script(const TiXmlElement* root = NULL);
 …
     bool loadFile(const std::string& filename);
     void addObject( const std::string& className,const std::string& objectName);
     void registerClass(const std::string& className);                           //!< Register a class but dont add any instances
+    void registerClass(const std::string& className);                           //!< Register a class but dont add any instances
     /// QUERRYING

trunk/src/lib/script_engine/script_class.cc

-                      r8711
+                      r9869
 #include <cassert>
+ObjectListDefinition(ScriptClass);
 /**
  * @brief standard constructor
  * @todo this constructor is not jet implemented - do it
 */
 ScriptClass::ScriptClass(const std::string& name, ClassID classID, ScriptMethod* scriptMethods)
     : BaseObject(name)
+ScriptClass::ScriptClass(const std::string& name, const ClassID& classID, ScriptMethod* scriptMethods)
+    : BaseObject(name), _classID(classID)
+{
   assert(scriptMethods != NULL);
   this->setClassID(CL_SCRIPT_CLASS, "ScriptClass");
+  this->registerObject(this, ScriptClass::_objectList);
   this->_classID = classID;

trunk/src/lib/script_engine/script_class.h

-                      r9003
+                      r9869
  * this should be used at the beginning of all the Classes that should be loadable (in the cc-file)
  */
 #define CREATE_SCRIPTABLE_CLASS(CLASS_NAME, CLASS_ID, SCRIPT_METHODS) \
     tScriptClass<CLASS_NAME> global_##CLASS_NAME##_ScriptableClass(#CLASS_NAME, CLASS_ID, (new ScriptMethod)->SCRIPT_METHODS)
+#define CREATE_SCRIPTABLE_CLASS(CLASS_NAME, SCRIPT_METHODS) \
+    tScriptClass<CLASS_NAME> global_##CLASS_NAME##_ScriptableClass(#CLASS_NAME, CLASS_NAME::staticClassID(), (new ScriptMethod)->SCRIPT_METHODS)
 //! A class for ...
 class ScriptClass : protected BaseObject
+class ScriptClass : public BaseObject
+{
+  ObjectListDeclaration(ScriptClass);
 public:
   virtual ~ScriptClass();
-  bool operator==(const std::string& name) { return (this->getName() == name); }
-  bool operator==(ClassID classID) { return (this->_classID == classID); }
   virtual void registerClass(Script* script) = 0;
   virtual int insertObject(Script* L, BaseObject* obj, bool gc=false) = 0;
   virtual int insertObject(Script* L, BaseObject* obj, const std::string& name, bool gc=false) = 0;
+  virtual int insertObject(Script* L, BaseObject* obj, const std::string& name, bool gc=false) = 0;
   const ScriptMethod* scriptMethods() const { return this->_scriptMethods; }
 protected:
   ScriptClass(const std::string& name, ClassID classID, ScriptMethod* scriptMethods);
+  ScriptClass(const std::string& name, const ClassID& classID, ScriptMethod* scriptMethods);
 private:

trunk/src/lib/script_engine/script_manager.cc

-                      r9003
+                      r9869
 #include "lunar.h"
-#include "class_list.h"
 #include "script.h"
 #include "script_trigger.h"
 #include "luaincl.h"
+#include "loading/load_param.h"
+#include "parser/tinyxml/tinyxml.h"
+#include "loading/load_param_xml.h"
 …
+{
   this->setName("ScriptManager");
-  this->scripts = NULL;
-  this->triggers = NULL;
   if (root != NULL)
 …
   // fill the scripts and triggers (doing that on runtime is very slow!)
-  getTriggers();
-  getScripts();
+}
 …
+{
   //Delete all scripts as they aren't deleted automatically
+  if(this->getScripts())
+    while(!scripts->empty())
+      delete scripts->front();
+  while(!Script::objectList().empty())
+    delete Script::objectList().front();
   //Delete all triggers
+  if(this->getTriggers())
+    while(!triggers->empty())
+      delete triggers->front();
+  while(!ScriptTrigger::objectList().empty())
+    delete ScriptTrigger::objectList().front();
+}
 …
 Script* ScriptManager::getScriptByFile(const std::string& file)
+{
+  if(getScripts())
+    for(std::list<BaseObject*>::const_iterator it = scripts->begin(); it != scripts->end(); it++ )
+    {
+      if( (dynamic_cast<Script*>(*it))->getFileName().compare(file) == 0)
+      {
+        return dynamic_cast<Script*>(*it);
+      }
+    }
+  for (ObjectList<Script>::const_iterator it = Script::objectList().begin();
+       it != Script::objectList().end();
+       ++it)
+    if( ((*it))->getFileName().compare(file) == 0)
+      return (*it);
   return NULL;
+}
-bool ScriptManager::getScripts()
+{
-  return (this->scripts != NULL || (this->scripts = ClassList::getList(CL_SCRIPT)) != NULL);
+}
-bool ScriptManager::getTriggers()
+{
-  return (this->triggers != NULL || (this->triggers = ClassList::getList(CL_SCRIPT_TRIGGER)) != NULL);
+}

trunk/src/lib/script_engine/script_manager.h

-                      r8894
+                      r9869
    void  createTriggers(const TiXmlElement* triggers);
-   bool getTriggers();
-   bool getScripts();
    static ScriptManager*             singletonRef;   //!< Reference to this class
-   const std::list<BaseObject*>*     triggers;       //!< A list of all the triggers in the world
-   const std::list<BaseObject*>*     scripts;        //!< A list of all the scripts in the world
 };
 #endif

trunk/src/lib/script_engine/script_method.cc

r8711	r9869
25	25	{ }
26	26
27		ScriptMethod* ScriptMethod::addMethod(const std::string& methodName, const Executor& executor)
	27	ScriptMethod* ScriptMethod::addMethod(const std::string& methodName, const Executor<lua_State*>& executor)
28	28	{
29	29	this->methods.push_back(ScriptMethod::Method(methodName, executor));
…	…
32	32	}
33	33
34		ScriptMethod::Method::Method(const std::string& name, const Executor& executor)
	34	ScriptMethod::Method::Method(const std::string& name, const Executor<lua_State*>& executor)
35	35	{
36	36	this->name = name;

trunk/src/lib/script_engine/script_method.h

-                      r8711
+                      r9869
 #include <vector>
 #include "executor/executor_lua.h"
+#include "executor_lua_state.h"
+#include "executor/executor_member.h"
 class ScriptMethod
 …
   ~ScriptMethod();
   ScriptMethod* addMethod(const std::string& methodName, const Executor& executor);
+  ScriptMethod* addMethod(const std::string& methodName, const Executor<lua_State*>& executor);
   unsigned int size() const { return methods.size(); };
   const std::string& name(unsigned int methodNumber) const { return methods[methodNumber].name; };
   const Executor* executor(unsigned int methodNumber) const { return methods[methodNumber].executor; };
+  const Executor<lua_State*>* executor(unsigned int methodNumber) const { return methods[methodNumber].executor; };
 …
   struct Method
+  {
     Method(const std::string& name, const Executor& executor);
     std::string    name;
     Executor*      executor;
+    Method(const std::string& name, const Executor<lua_State*>& executor);
+    std::string             name;
+    Executor<lua_State*>*   executor;
   };

trunk/src/lib/shell/Makefile.am

-                      r7428
+                      r9869
 libORXshell_a_SOURCES = \
                 shell.cc \
-                shell_buffer.cc \
                 shell_input.cc \
                 shell_command.cc \
 …
 noinst_HEADERS= \
                 shell.h \
-                shell_buffer.h \
                 shell_input.h \
+                shell_command_class.h \
                 shell_command.h \
-                shell_command_class.h \
                 shell_completion.h \
                 shell_completion_plugin.h

trunk/src/lib/shell/shell.cc

-                      r8362
+                      r9869
 #include "shell.h"
 #include "shell_command.h"
 #include "shell_buffer.h"
+#include "debug_buffer.h"
 #include "shell_input.h"
 …
   ->completionPlugin(0, OrxShell::CompletorFileSystem(".ttf", "fonts/"));
+  ObjectListDefinition(Shell);
   /**
 …
   Shell::Shell ()
+  {
+    this->setClassID(CL_SHELL, "Shell");
+    this->registerObject(this, Shell::_objectList);
     this->setName("Shell");
     this->shellBuffer = ShellBuffer::getInstance();
+    this->shellBuffer = DebugBuffer::getInstance();
     // EVENT-Handler subscription of '`' to all States.
 …
     this->setSizeX2D(width);
     for (std::list<MultiLineText*>::iterator textIt = this->bufferText.begin(); textIt != this->bufferText.end(); ++textIt)
+    {
       (*textIt)->setLineWidth(width);
+    }
+  }
 …
+  {
     this->flush();
     ShellBuffer::addBufferLineStatic("orxonox - shell\n ==================== \n", NULL);
+    DebugBuffer::addBufferLineStatic("orxonox - shell\n ==================== \n", NULL);
+  }
 …
         this->moveDisplayBuffer(-this->bufferDisplaySize+1);
+      }
       else if (event.type == EV_VIDEO_RESIZE)
+      {
         this->updateResolution(event.resize.w);
         this->repositionText();
+      }
+    }
+    else if (event.type == EV_VIDEO_RESIZE)
+    {
+      this->updateResolution(event.resize.w);
+      this->repositionText();
+    }
+  }

trunk/src/lib/shell/shell.h

-                      r7762
+                      r9869
 #include "shell_input.h"
 #include "shell_buffer.h"
+#include "debug_buffer.h"
 #include "material.h"
 …
   class Shell : public Element2D, public EventListener
+  {
+    ObjectListDeclaration(Shell);
   public:
     Shell();
 …
   private:
     // GENERAL
     ShellBuffer*                shellBuffer;            //!< The local ShellBuffer.
+    DebugBuffer*                shellBuffer;            //!< The local ShellBuffer.
     bool                        bActive;                //!< If the shell is active.

trunk/src/lib/shell/shell_command.cc

-                      r9406
+                      r9869
 #include "compiler.h"
+#include "helper_functions.h"
 #include "debug.h"
-#include "class_list.h"
 #include "key_names.h"
 …
 namespace OrxShell
+{
+  ObjectListDefinition(ShellCommand);
   SHELL_COMMAND(debug, ShellCommandClass, help);
 …
    * @param paramCount the count of parameters this command takes
    */
   ShellCommand::ShellCommand(const std::string& commandName, const std::string& className, Executor* executor)
+  {
     this->setClassID(CL_SHELL_COMMAND, "ShellCommand");
+  ShellCommand::ShellCommand(const std::string& commandName, const std::string& className, Executor<const SubString>* executor)
+  {
+    this->registerObject(this, ShellCommand::_objectList);
     PRINTF(4)("create shellcommand '%s' for class '%s'\n", commandName.c_str(), className.c_str());
     this->setName(commandName);
 …
     // copy the executor:
     this->executor = executor;
-    this->executor->setName(commandName);
     for (unsigned int i = 0; i < this->executor->getParamCount(); i++)
 …
    * @brief registers a new ShellCommand
    */
   ShellCommand* ShellCommand::registerCommand(const std::string& commandName, const std::string& className, Executor* executor)
+  ShellCommand* ShellCommand::registerCommand(const std::string& commandName, const std::string& className, Executor<const SubString>* executor)
+  {
     if (ShellCommand::exists(commandName, className))
 …
   void ShellCommand::unregisterCommand(const std::string& commandName, const std::string& className)
+  {
     ShellCommandClass* cmdClass = ShellCommandClass::acquireCommandClass(className);
     if (cmdClass != NULL)
+    {
       CmdList::iterator cmd;
       for (cmd = cmdClass->commandList.begin(); cmd != cmdClass->commandList.end(); cmd++)
+      for (cmd = cmdClass->_commandList.begin(); cmd != cmdClass->_commandList.end(); cmd++)
         if (commandName == (*cmd)->getName())
+        {
 …
     CmdList::const_iterator elem;
     for (unsigned int i = 0; i < cmdClass->commandList.size(); i++)
+    {
       if (commandName == cmdClass->commandList[i]->getName())
         return (cmdClass->commandList[i]);
+    for (unsigned int i = 0; i < cmdClass->_commandList.size(); i++)
+    {
+      if (commandName == cmdClass->_commandList[i]->getName())
+        return (cmdClass->_commandList[i]);
+    }
     return NULL;
 …
       return false;
     const std::list<BaseObject*>* objectList = ClassList::getList(cmd->shellClass->getName());
+    const ObjectListBase* const objectList = ObjectListBase::getObjectList(cmd->shellClass->getName());
     if (objectList != NULL)
+    {
+      std::list<BaseObject*>::const_iterator bo;
+      ObjectListBase::base_list list;
+      objectList->getBaseObjectList(&list);
+      ObjectListBase::base_iterator it;
       // No Description given (only for speedup)
       if (objectDescriptor.empty())
+      {
         for (bo = objectList->begin(); bo != objectList->end(); bo++)
           boList->push_back(*bo);
+        for (it = list.begin(); it != list.end(); it++)
+          boList->push_back(*it);
+      }
       // some description
       else
+      {
         for (bo = objectList->begin(); bo != objectList->end(); bo++)
           if (!nocaseCmp(objectDescriptor, (*bo)->getName(), objectDescriptor.size()))
             boList->push_back(*bo);
+        for (it = list.begin(); it != list.end(); it++)
+          if (!nocaseCmp(objectDescriptor, (*it)->getName(), objectDescriptor.size()))
+            boList->push_back(*it);
+      }
+    }
 …
     if (sc != NULL)
+    {
+      for(std::vector<BaseObject*>::const_iterator bo = boList.begin(); bo != boList.end(); ++bo)
+      {
+        PRINT(0)("Command '%s' on '%s::%s'\n", sc->getCName(), (*bo)->getClassCName(), (*bo)->getCName());
+        (*sc->executor)((*bo), inputSplits.subSet(paramBegin));
+      }
+      if(sc->executor->getType() == Executor<const SubString>::FunctionStatic )
+      {
+        PRINT(0)("Static Command '%s' of Class '%s' with parameters\n", sc->getCName(), sc->shellClass->getCName());
+        (*sc->executor)(NULL, inputSplits.subSet(paramBegin));
+      }
+      else
+        for(std::vector<BaseObject*>::const_iterator bo = boList.begin(); bo != boList.end(); ++bo)
+        {
+          PRINT(0)("Command '%s' on '%s::%s'\n", sc->getCName(), (*bo)->getClassCName(), (*bo)->getCName());
+          (*sc->executor)((*bo), inputSplits.subSet(paramBegin));
+        }
       return true;
+    }
 …
     else
+    {
 //       if(this->completors[parameter] == NULL)
 //       delete this->completors[parameter];
 //       this->completors[parameter] = completorPlugin.clone();
+      //       if(this->completors[parameter] == NULL)
+      //       delete this->completors[parameter];
+      //       this->completors[parameter] = completorPlugin.clone();
+    }
     return this;

trunk/src/lib/shell/shell_command.h

-                      r8145
+                      r9869
 #include "base_object.h"
+#include "executor/executor.h"
+/// THIS IS USED TO LOAD CONSTANT AND STATIC FUNCTIONS EASILY.
+#include "executor/executor_substring.h"
+#include "executor/functor_member.h"
+#include "executor/functor_const_member.h"
+#include "executor/functor_static.h"
 #include "shell_completion_plugin.h"
 …
    */
 #define SHELL_COMMAND(command, class, function) \
            OrxShell::ShellCommand* shell_command_##class##_##command = OrxShell::ShellCommand::registerCommand(#command, #class, createExecutor<class>(&class::function))
+           OrxShell::ShellCommand* shell_command_##class##_##command = OrxShell::ShellCommand::registerCommand(#command, #class, createExecutor<class, BaseObject>(&class::function))
   /**
 …
    */
 #define SHELL_COMMAND_STATIC(command, class, function) \
            OrxShell::ShellCommand* shell_command_##class##_##command = OrxShell::ShellCommand::registerCommand(#command, #class, createExecutor<class>(function))
+           OrxShell::ShellCommand* shell_command_##class##_##command = OrxShell::ShellCommand::registerCommand(#command, #class, createExecutor<class, BaseObject>(function))
 …
   class ShellCommand : public BaseObject
+  {
+    ObjectListDeclaration(ShellCommand);
     friend class ShellCommandClass;
   public:
 …
     ShellCommand* completionPlugin(unsigned int parameter, const CompletorPlugin& completorPlugin);
     static ShellCommand* registerCommand(const std::string& commandName, const std::string& className, Executor* executor);
+    static ShellCommand* registerCommand(const std::string& commandName, const std::string& className, Executor<const SubString>* executor);
     static void unregisterCommand(const std::string& commandName, const std::string& className);
     static const ShellCommand* const getCommand(const std::string& commandName, const std::string& className);
 …
   protected:
     ShellCommand(const std::string& commandName, const std::string& className, Executor* executor);
+    ShellCommand(const std::string& commandName, const std::string& className, Executor<const SubString>* executor);
     virtual ~ShellCommand();
 …
     std::string                      description;           //!< A description for this commnand. (initially ""). Assigned with (create)->describe("blablabla");
     std::vector<CompletorPlugin*>    completors;            //!< Completors for the Parameters
     Executor*                        executor;              //!< The Executor, that really executes the Function.
+    Executor<const SubString>*       executor;              //!< The Executor, that really executes the Function.
   };

trunk/src/lib/shell/shell_command_class.cc

-                      r9406
+                      r9869
 #include "debug.h"
-#include "class_list.h"
 #include "compiler.h"
 …
 namespace OrxShell
+{
+  CmdClassList* ShellCommandClass::commandClassList = NULL;
+  ObjectListDefinition(ShellCommandClass);
+  CmdClassList* ShellCommandClass::_commandClassList = NULL;
   /**
 …
    */
   ShellCommandClass::ShellCommandClass(const std::string& className)
       : className(className)
+  {
     this->setClassID(CL_SHELL_COMMAND_CLASS, "ShellCommandClass");
+      : _className(className)
+  {
+    this->registerObject(this, ShellCommandClass::_objectList);
     this->setName(className);
+    this->classID = CL_NULL;
+    if (ShellCommandClass::commandClassList == NULL)
+      ShellCommandClass::commandClassList = new CmdClassList;
+    ShellCommandClass::commandClassList->push_back(this);
+    if (ShellCommandClass::_commandClassList == NULL)
+      ShellCommandClass::_commandClassList = new CmdClassList;
+    ShellCommandClass::_commandClassList->push_back(this);
+  }
 …
   ShellCommandClass::~ShellCommandClass()
+  {
     while(!this->commandList.empty())
       delete this->commandList.back();
     if (ShellCommandClass::commandClassList != NULL)
+    {
       CmdClassList::iterator delClass = std::find(ShellCommandClass::commandClassList->begin(), ShellCommandClass::commandClassList->end(), this);
       if (delClass != ShellCommandClass::commandClassList->end())
         ShellCommandClass::commandClassList->erase(delClass);
+    while(!this->_commandList.empty())
+      delete this->_commandList.back();
+    if (ShellCommandClass::_commandClassList != NULL)
+    {
+      CmdClassList::iterator delClass = std::find(ShellCommandClass::_commandClassList->begin(), ShellCommandClass::_commandClassList->end(), this);
+      if (delClass != ShellCommandClass::_commandClassList->end())
+        ShellCommandClass::_commandClassList->erase(delClass);
+    }
+  }
 …
   void ShellCommandClass::registerCommand(ShellCommand* command)
+  {
     this->commandList.push_back(command);
+    this->_commandList.push_back(command);
+  }
 …
   void ShellCommandClass::unregisterCommand(ShellCommand* command)
+  {
     CmdList::iterator delC = std::find(this->commandList.begin(), this->commandList.end(), command);
     if (delC != this->commandList.end())
       this->commandList.erase(delC);
+    CmdList::iterator delC = std::find(this->_commandList.begin(), this->_commandList.end(), command);
+    if (delC != this->_commandList.end())
+      this->_commandList.erase(delC);
+  }
 …
     // unregister all commands and Classes
     CmdClassList::iterator classIT;
     if (ShellCommandClass::commandClassList == NULL)
+    if (ShellCommandClass::_commandClassList == NULL)
       return;
     while (!ShellCommandClass::commandClassList->empty())
       delete ShellCommandClass::commandClassList->back();
     delete ShellCommandClass::commandClassList;
     ShellCommandClass::commandClassList = NULL;
+    while (!ShellCommandClass::_commandClassList->empty())
+      delete ShellCommandClass::_commandClassList->back();
+    delete ShellCommandClass::_commandClassList;
+    ShellCommandClass::_commandClassList = NULL;
+  }
 …
   bool ShellCommandClass::getCommandListOfClass(const std::string& className, std::list<std::string>& stringList)
+  {
     if (ShellCommandClass::commandClassList == NULL)
+    if (ShellCommandClass::_commandClassList == NULL)
       return false;
     CmdClassList::const_iterator elem;
     for(elem = ShellCommandClass::commandClassList->begin(); elem != ShellCommandClass::commandClassList->end(); elem++)
+    for(elem = ShellCommandClass::_commandClassList->begin(); elem != ShellCommandClass::_commandClassList->end(); elem++)
+    {
       if (className == (*elem)->getName())
+      {
         CmdList::iterator command;
         for(command = (*elem)->commandList.begin(); command != (*elem)->commandList.end(); command++)
+        for(command = (*elem)->_commandList.begin(); command != (*elem)->_commandList.end(); command++)
           stringList.push_back((*command)->getName());
         return true;
 …
   ShellCommandClass* ShellCommandClass::getCommandClass(const std::string& className)
+  {
     if (ShellCommandClass::commandClassList == NULL)
+    if (ShellCommandClass::_commandClassList == NULL)
       return false;
     CmdClassList::const_iterator classIT;
     for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
       if (className == (*classIT)->className)
+    for (classIT = ShellCommandClass::_commandClassList->begin(); classIT != ShellCommandClass::_commandClassList->end(); classIT++)
+      if (className == (*classIT)->_className)
         return (*classIT);
     return NULL;
 …
+  {
     return (ShellCommandClass::getCommandClass(className) != NULL);
+  }
-  ClassID ShellCommandClass::getClassID()
+  {
-    if (this->classID == CL_NULL)
-      this->classID = ClassList::StringToID(this->className);
-    return this->classID;
+  }
 …
   void ShellCommandClass::help(const std::string& className)
+  {
     if (ShellCommandClass::commandClassList == NULL)
+    if (ShellCommandClass::_commandClassList == NULL)
+    {
       PRINT(0)("No Commands Registered\n");
 …
+    }
     if (className.empty())
       PRINT(0)("===== Displaying %d registered Classes:\n", ShellCommandClass::commandClassList->size());
+      PRINT(0)("===== Displaying %d registered Classes:\n", ShellCommandClass::_commandClassList->size());
     CmdClassList::iterator classIT;
     for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
+    {
       if (className.empty() || className == (*classIT)->className)
+    for (classIT = ShellCommandClass::_commandClassList->begin(); classIT != ShellCommandClass::_commandClassList->end(); classIT++)
+    {
+      if (className.empty() || className == (*classIT)->_className)
+      {
         PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className.c_str(), (*classIT)->commandList.size());
+        PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->_className.c_str(), (*classIT)->_commandList.size());
         CmdList::const_iterator cmdIT;
         for (cmdIT = (*classIT)->commandList.begin(); cmdIT != (*classIT)->commandList.end(); cmdIT++)
+        for (cmdIT = (*classIT)->_commandList.begin(); cmdIT != (*classIT)->_commandList.end(); cmdIT++)
+        {
           PRINT(0)("  command:'%s' : params:%d: ", (*cmdIT)->getCName(), (*cmdIT)->executor->getParamCount());

trunk/src/lib/shell/shell_command_class.h

-                      r8362
+                      r9869
   class ShellCommandClass : public BaseObject
+  {
+    ObjectListDeclaration(ShellCommandClass);
     friend class ShellCommand;
   public:
     /** @returns the CommandClassList */
     static const CmdClassList& getCommandClassList() { return *ShellCommandClass::commandClassList; };
+    static const CmdClassList& getCommandClassList() { return *ShellCommandClass::_commandClassList; };
     static bool getCommandListOfClass(const std::string& className, std::list<std::string>& stringList);
 …
   private:
+    const std::string                      className;                 //!< The Name of the Class. This should match the ClassName of the Commands Class.
+    ClassID                                classID;                   //!< The classID of this Class
+    CmdList                                commandList;               //!< A list of Commands from this Class
+    const std::string                      _className;                 //!< The Name of the Class. This should match the ClassName of the Commands Class.
+    CmdList                                _commandList;               //!< A list of Commands from this Class
     static CmdClassList*                   commandClassList;          //!< A list of Classes
+    static CmdClassList*                   _commandClassList;          //!< A list of Classes
   };
+}

trunk/src/lib/shell/shell_completion.cc

-                      r9406
+                      r9869
 #include "shell_command.h"
+#include "substring.h"
+#include "class_list.h"
+#include "helper_functions.h"
 #include "debug.h"
 …
   bool ShellCompletion::autoComplete(std::string& input)
+  {
     long classID = CL_NULL;                          //< the classID retrieved from the Class.
     const std::list<BaseObject*>* objectList = NULL; //< the list of Objects stored in classID's ClassList
+    ClassID classID;
+    const ObjectListBase* objectList = NULL;      //< the list of Objects stored in classID's ClassList
     bool emptyComplete = false;                      //< if the completion input is empty string. e.g ""
     long completeType = NullCompletion;              //< the Type we'd like to complete.
 …
              (!emptyComplete && inputSplits.size() == 2))
+    {
+      classID = ClassList::StringToID(inputSplits.getString(0));
+      objectList = ClassList::getList((ClassID)classID);
+      if (classID != CL_NULL)
+      objectList = ObjectListBase::getObjectList(inputSplits[0]);
+      if (objectList != NULL)
+        classID = objectList->identity();
+      if (classID != NullClass::staticClassID())
         completeType |= ObjectCompletion;
       completeType |= FunctionCompletion;
 …
              (!emptyComplete && inputSplits.size() == 3))
+    {
       if (ClassList::exists(inputSplits[0], inputSplits[1]))
+      if (ObjectListBase::getBaseObject(inputSplits[0], inputSplits[1]))
         completeType |= FunctionCompletion;
+    }
 …
     if (completeType & ClassCompletion)
       this->objectComplete(completeString, CL_SHELL_COMMAND_CLASS);
+      this->objectComplete(completeString, &ShellCommandClass::objectList());
     if (completeType & ObjectCompletion)
       this->objectComplete(completeString, classID);
+      this->objectComplete(completeString, objectList);
     if (completeType & FunctionCompletion)
       this->commandComplete(completeString, inputSplits[0]);
 …
    * @return true on success, false otherwise
    */
+  bool ShellCompletion::objectComplete(const std::string& objectBegin, long classID)
+  {
+    const std::list<BaseObject*>* boList = ClassList::getList((ClassID)classID);
+    if (boList != NULL)
+    {
+      CompletionType type = ObjectCompletion;
+      if (classID == CL_SHELL_COMMAND_CLASS)
+        type = ClassCompletion;
+      if (!this->addToCompleteList(*boList, objectBegin, type))
+        return false;
+    }
+    else
+      return false;
+  bool ShellCompletion::objectComplete(const std::string& objectBegin, const ObjectListBase* objectList)
+  {
+    assert (objectList != NULL);
+    CompletionType type = ObjectCompletion;
+    if (objectList == &ShellCommandClass::objectList())
+      type = ClassCompletion;
+    ObjectListBase::base_list list;
+    objectList->getBaseObjectList(&list);
+    if (!this->addToCompleteList(list, objectBegin, type))
+     return false;
     return true;
+  }
 …
     switch (type)
+    {
         default:// SHELLC_NONE
         return typeNames[0];
         case  ClassCompletion:
         return typeNames[1];
         case ObjectCompletion:
         return typeNames[2];
         case FunctionCompletion:
         return typeNames[3];
         case AliasCompletion:
         return typeNames[4];
         case ParamCompletion:
         return typeNames[5];
+      default:// SHELLC_NONE
+      return typeNames[0];
+      case  ClassCompletion:
+      return typeNames[1];
+      case ObjectCompletion:
+      return typeNames[2];
+      case FunctionCompletion:
+      return typeNames[3];
+      case AliasCompletion:
+      return typeNames[4];
+      case ParamCompletion:
+      return typeNames[5];
+    }
+  }

trunk/src/lib/shell/shell_completion.h

-                      r7415
+                      r9869
 // FORWARD DECLARATION
 class BaseObject;
+class ObjectListBase;
 namespace OrxShell
 …
       bool autoComplete(std::string& input);
       static const std::string& ShellCompletion::typeToString(ShellCompletion::CompletionType type);
+      static const std::string& typeToString(ShellCompletion::CompletionType type);
     private:
       bool objectComplete(const std::string& objectBegin, long classID);
+      bool objectComplete(const std::string& objectBegin, const ObjectListBase* const objectList);
       bool commandComplete(const std::string& commandBegin, const std::string& className);
       bool aliasComplete(const std::string& aliasBegin);

trunk/src/lib/shell/shell_completion_plugin.cc

-                      r8330
+                      r9869
 #include "shell_command.h"
+#include "substring.h"
+#include "class_list.h"
+#include "helper_functions.h"
 #include "loading/resource_manager.h"
 …
     if (completionBegin.empty()) // if we do not yet have the beginning of the line, start with the chosen startDir.
+    {
       dir.setFileName(ResourceManager::getInstance()->getDataDir() + this->_subDir);
+      dir.setFileName(Resources::ResourceManager::getInstance()->mainGlobalPath().name() + this->_subDir);
       dir.open();
       for(unsigned int i = 0; i < dir.fileCount(); i++ )
 …
         directoryName = completionBegin.substr(0, pos);
       dir.setFileName(ResourceManager::getInstance()->getDataDir() + directoryName);
+      dir.setFileName(Resources::ResourceManager::getInstance()->mainGlobalPath().name() + directoryName);
       dir.open();
 …
           continue;
+        }
         printf("%s\n", (ResourceManager::getInstance()->getDataDir() + fileName).c_str());
+        printf("%s\n", (Resources::ResourceManager::getInstance()->mainGlobalPath().name() + fileName).c_str());
         if (!nocaseCmp(completionBegin, fileName, completionBegin.size()) &&
              ResourceManager::isInDataDir(fileName))
+             Resources::ResourceManager::getInstance()->checkFileInMainPath(fileName))
+        {
           printf("Dir %s\n", fileName.c_str());

trunk/src/lib/shell/shell_input.cc

-                      r8339
+                      r9869
 #include "compiler.h"
 #include "key_names.h"
 namespace OrxShell
 …
   ->setAlias("help");
+  ObjectListDefinition(ShellInput);
   /**
 …
       : Text ("")
+  {
+    this->registerObject(this, ShellInput::_objectList);
     this->pressedKey = SDLK_FIRST;
+    this->setClassID(CL_SHELL_INPUT, "ShellInput");
+    this->inputLine = "";
     this->historyIT = ShellInput::history.begin();
     this->setHistoryLength(50);
 …
+    {
       //if (!this->isEventSubscribed(ES_SHELL, i))
         this->subscribeEvent(ES_SHELL, i);
+      this->subscribeEvent(ES_SHELL, i);
+    }
     // unsubscribe unused TODO improve.
 …
     this->unsubscribeEvent(ES_SHELL, SDLK_PAGEUP);
     this->unsubscribeEvent(ES_SHELL, SDLK_PAGEDOWN);
+  }
 …
   void ShellInput::flush()
+  {
+    this->inputLine.clear();
+    this->setText(this->inputLine);
+    this->inputLineBegin.clear();
+    this->inputLineEnd.clear();
+    this->clear();
+  }
 …
   void ShellInput::setInputText(const std::string& text)
+  {
+    this->inputLine = text;
+    this->setText(this->inputLine);
+    this->inputLineBegin = text;
+    this->inputLineEnd.clear();
+    this->setText(text);
+  }
 …
+    }
     this->inputLine += character;
     this->setText(this->inputLine);
+    this->inputLineBegin += character;
+    this->setText(this->inputLineBegin + this->inputLineEnd);
+  }
 …
+    }
     this->inputLine += characters;
     this->setText(this->inputLine);
+    this->inputLineBegin += characters;
+    this->setText(this->inputLineBegin + this->inputLineEnd);
+  }
 …
       this->historyScrolling = false;
+    }
     if (this->inputLine.size() < characterCount)
       characterCount = this->inputLine.size();
     this->inputLine.erase(this->inputLine.size() - characterCount, this->inputLine.size());
     this->setText(this->inputLine);
+    if (this->inputLineBegin.size() < characterCount)
+      characterCount = this->inputLineBegin.size();
+    this->inputLineBegin.erase(this->inputLineBegin.size() - characterCount, this->inputLineBegin.size());
+    this->setText(this->inputLineBegin + this->inputLineEnd);
+  }
 …
   bool ShellInput::executeCommand()
+  {
+    ShellBuffer::addBufferLineStatic("Execute Command: %s\n", this->inputLine.c_str());
+    if (this->inputLine.empty())
+    if (this->getInput().empty())
       return false;
+    ShellCommand::execute(this->inputLine);
+    DebugBuffer::addBufferLineStatic("Execute Command: %s\n", this->getInput().c_str());
+    ShellCommand::execute(this->getInput());
     // removing the eventually added Entry (from scrolling) to the List
 …
     // adding the new Command to the History
     if (history.empty() || history.back() != this->inputLine)
       this->history.push_back(this->inputLine);
+    if (history.empty() || history.back() != this->getInput())
+      this->history.push_back(this->getInput());
     if (this->history.size() > this->historyLength)
+    {
 …
     if (!this->historyScrolling)
+    {
       this->history.push_back(this->inputLine);
+      this->history.push_back(this->getInput());
       this->historyScrolling = true;
       this->historyIT = --this->history.end();
 …
+  }
+  /**
+   * @brief moves the cursor chars Characters to the right.
+   * @param chars how much to move the cursor.
+   */
+  void ShellInput::moveCursor(int chars)
+  {
+    if (chars > 0)
+    {
+      PRINTF(5)("move cursor %d to the right\n", chars);
+      if (chars >= (int) this->inputLineEnd.size())
+        chars = inputLineEnd.size();
+      this->inputLineBegin += this->inputLineEnd.substr(0, chars);
+      this->inputLineEnd.erase(0, chars);
+    }
+    else if (chars < 0)
+    {
+      chars = -chars;
+      PRINTF(5)("move cursor %d to the left\n", chars);
+      if (chars >= (int) this->inputLineBegin.size())
+        chars = inputLineBegin.size();
+      this->inputLineEnd = this->inputLineBegin.substr(this->inputLineBegin.size() - chars) + this->inputLineEnd;
+      this->inputLineBegin.erase(this->inputLineBegin.size() - chars);
+    }
+  }
   /**
 …
   void ShellInput::help(const std::string& className, const std::string& functionName)
+  {
-    printf("%s::%s\n", className.c_str(), functionName.c_str());
     if (className.empty())
+    {
       PRINT(0)("Help for the most important Shell-commands\n");
       PRINT(0)("F1 - HELP; F2 - DEBUG; '`' - open/close shell\n");
       PRINT(0)("input order:\n");
       PRINT(0)("ClassName [objectName] function [parameter1, [parameter2 ...]]  or\n");
       PRINT(0)("Alias [parameter]\n");
       PRINT(0)("- Also try 'help className'");
+      PRINT(0)("== Help for the most important Shell-commands\n");
+      PRINT(0)("  F1 - HELP; F2 - DEBUG; '`' - open/close shell\n");
+      PRINT(0)("  input order:\n");
+      PRINT(0)("   ClassName [objectName] function [parameter1, [parameter2 ...]]  or\n");
+      PRINT(0)("   Alias [parameter]\n");
+      PRINT(0)("- Also try 'help className' or pushing 'TAB'\n");
+    }
     else if (!className.empty() && functionName.empty())
 …
+      {
         case SDLK_BACKSPACE:
           this->removeCharacters(1);
           break;
+        this->removeCharacters(1);
+        break;
         case SDLK_UP:
           this->historyMoveUp();
           break;
+        this->historyMoveUp();
+        break;
         case SDLK_DOWN:
           this->historyMoveDown();
           break;
+        this->historyMoveDown();
+        break;
         default:
+          {
             if (likely(pressedKey < 127))
               this->addCharacter(this->pressedKey);
+          }
+        {
+          if (likely(pressedKey < 127))
+            this->addCharacter(this->pressedKey);
+        }
+      }
+    }
 …
         this->pressedEvent = event.type;
+      }
+      else if (event.type == SDLK_LEFT)
+      {
+        this->moveCursor(-1);
+        this->pressedKey = event.type;
+        this->pressedEvent = event.type;
+      }
+      else if (event.type == SDLK_RIGHT)
+      {
+        this->moveCursor(+1);
+        this->pressedKey = event.type;
+        this->pressedEvent = event.type;
+      }
       else if (event.type == SDLK_TAB)
+      {
         this->completion.autoComplete(this->inputLine);
         this->setText(this->inputLine);
+        this->completion.autoComplete(this->inputLineBegin);
+        this->setText(this->getInput());
+      }
       else if (event.type == SDLK_BACKSPACE)
 …
         this->removeCharacters(1);
+      }
+      else if (event.type == SDLK_DELETE)
+      {
+        if (!this->inputLineEnd.empty())
+        {
+          this->inputLineEnd.erase(0, 1);
+          this->setText(this->getInput());
+        }
+      }
       else if (event.type == SDLK_RETURN)
+      {

trunk/src/lib/shell/shell_input.h

-                      r7858
+                      r9869
   class ShellInput : public Text,  public EventListener
+  {
+    ObjectListDeclaration(ShellInput);
   public:
 …
     /** @returns the inputLine */
     const std::string& getInput() const { return this->inputLine; };
+    std::string getInput() const { return this->inputLineBegin + this->inputLineEnd; };
     // InputLine
 …
     void historyMoveDown();
+    void moveCursor(int chars);
     void help(const std::string& className = "", const std::string& function = "");
 …
     ShellCompletion                   completion;       //!< The Completion Interface.
+    std::string                       inputLine;        //!< the Char-Array of the Buffer
+    std::string                       inputLineBegin;   //!< The Line up to the cursor.
+    std::string                       inputLineEnd;     //!< The Line from the cursor on
     float                             repeatRate;       //!< The Repeat-Delay.
     float                             repeatDelay;      //!< The delay of the first Character of a given Character.

trunk/src/lib/shell/some_shell_commands.cc

-                      r8623
+                      r9869
 #include "network_game_rules.h"
   SHELL_COMMAND(say, NetworkGameRules, shellSay)->setAlias("say");
+SHELL_COMMAND(say, NetworkGameRules, shellSay)->setAlias("say");
 #include "player_stats.h"
   SHELL_COMMAND(nick, PlayerStats, shellNick)->setAlias("nick");
+SHELL_COMMAND(nick, PlayerStats, shellNick)->setAlias("nick");
 #include "class_list.h"
   SHELL_COMMAND(debug, ClassList, ClassList::debugS)
       ->describe("Shows all registered classes, if param1: is a valid ClassName only values of this class are shown. param2: how much output")
       ->defaultValues(MT_NULL, 1);
+// #include "class_list.h"
+//   SHELL_COMMAND(debug, ClassList, ClassList::debugS)
+//       ->describe("Shows all registered classes, if param1: is a valid ClassName only values of this class are shown. param2: how much output")
+//       ->defaultValues(MT_NULL, 1);
 #include "p_node.h"
   SHELL_COMMAND(debugNode, PNode, debugNode);
   SHELL_COMMAND(setPosition, PNode, setAbsCoor);
+SHELL_COMMAND(debugNode, PNode, debugNode);
+SHELL_COMMAND(setPosition, PNode, setAbsCoor);
 #include "render_2d.h"
   SHELL_COMMAND(toggleNodeVisibility, Render2D, toggleNodesVisibility);
+SHELL_COMMAND(toggleNodeVisibility, Render2D, toggleNodesVisibility);
 #include "material.h"
   SHELL_COMMAND(setDiffuseTexture, Material, setDiffuseMap)
       ->defaultValues(MT_NULL, (int)GL_TEXTURE_2D)
       ->completionPlugin(0, CompletorFileSystem());
+SHELL_COMMAND(setDiffuseTexture, Material, setDiffuseMap)
+->defaultValues(MT_NULL, (int)GL_TEXTURE_2D)
+->completionPlugin(0, CompletorFileSystem());
+#include "loading/resource_manager.h"
+namespace Resources {
+  SHELL_COMMAND(debug, ResourceManager, debug);
+  SHELL_COMMAND(load, ResourceManager, loadFromLoadStringHACK);
+  SHELL_COMMAND(unload, ResourceManager, unloadAllBelowKeepLevelINT);
+}
+#include "loading/load_param_class_description.h"
+SHELL_COMMAND_STATIC(printAll, LoadParamClassDescription, &LoadParamClassDescription::printAll)
+->defaultValues(MT_NULL, true);
+SHELL_COMMAND_STATIC(capture, LoadParamClassDescription, &LoadParamClassDescription::captureDescriptions)
+    ->defaultValues(true);
+#include "loading/game_loader.h"
+SHELL_COMMAND(quit, GameLoader, stop)
+    ->describe("quits the game")
+    ->setAlias("orxoquit");
+#include "object_list.h"
+SHELL_COMMAND_STATIC(debugAll, ObjectListBase, &ObjectListBase::debugAll);

trunk/src/lib/sound/Makefile.am

-                      r5475
+                      r9869
                         sound_source.cc \
                         sound_buffer.cc \
+                        sound_buffer_data.cc \
+                        resource_sound_buffer.cc \
                         ogg_player.cc
 …
                  sound_source.h \
                  sound_buffer.h \
+                 sound_buffer_data.h \
+                 resource_sound_buffer.h \
                  ogg_player.h

trunk/src/lib/sound/ogg_player.cc

-                      r9406
+                      r9869
 #include "helper_functions.h"
+#ifdef HAVE_SDL_SDL_H
+#include <SDL/SDL.h>
+#include <SDL/SDL_endian.h>
+#else
+#include <SDL.h>
+#include <SDL_endian.h>
+#endif
+#include "sdlincl.h"
 namespace OrxSound
+{
+  ObjectListDefinition(OggPlayer);
   /**
    * initializes an Ogg-player from a file
 …
   OggPlayer::OggPlayer(const std::string& fileName)
+  {
     this->setClassID(CL_SOUND_OGG_PLAYER, "OggPlayer");
+    this->registerObject(this, OggPlayer::_objectList);
     this->state = OggPlayer::None;
 …
         ogg->update();
+      }
       SDL_Delay(10);
+      SDL_Delay(1);
+    }
     PRINTF(4)("End the AudioThread\n");

trunk/src/lib/sound/ogg_player.h

-                      r9019
+                      r9869
 #include <ogg/ogg.h>
 #include <vorbis/vorbisfile.h>
 #include "threading.h"
+#include "util/threading.h"
 struct File;
 …
   class OggPlayer : public BaseObject
+  {
+    ObjectListDeclaration(OggPlayer);
   public:
     /**
 …
     std::string         _title;
     std::string         _artist;
     std::string         _album;
     std::string         _vendor;
+    std::string         _title;               //!< Song Title.
+    std::string         _artist;              //!< Artist Name of the current song.
+    std::string         _album;               //!< Album Name of the current song.
+    std::string         _vendor;              //!< Vendor Name of the current song.
   };

trunk/src/lib/sound/sound_buffer.cc

-                      r8971
+                      r9869
 #include "sound_buffer.h"
-#include "sound_engine.h"
-#include "sdlincl.h"
-#include <cassert>
-#include "debug.h"
-#include "sys/stat.h"
-#include "helper_functions.h"
-#ifdef HAVE_SDL_SDL_H
-#include <SDL/SDL.h>
-#include <SDL/SDL_endian.h>
-#else
-#include <SDL.h>
-#include <SDL_endian.h>
-#endif
 namespace OrxSound
+{
+  ObjectListDefinition(SoundBuffer);
   //////////////////
   /* SOUND-BUFFER */
   //////////////////
+  SoundBuffer::SoundBuffer()
+      : data(new SoundBufferData)
+  {
+    this->registerObject(this, SoundBuffer::_objectList);
+  }
   /**
    *  Creates a Soundbuffer out of an inputfile
+   * @brief Creates a Soundbuffer out of an inputfile
    * @param fileName The name of the File
    */
   SoundBuffer::SoundBuffer(const std::string& fileName)
+      : data(new SoundBufferData)
+  {
+    this->setClassID(CL_SOUND_BUFFER, "SoundBuffer");
+    this->setName(fileName);
+    this->registerObject(this, SoundBuffer::_objectList);
+    this->load(fileName);
+  }
+    // generate a Buffer
+    alGenBuffers(1, &this->bufferID);
+    SoundEngine::checkError("Generate Buffer", __LINE__);
+    if (!nocaseCmp(fileName.substr(fileName.size() - 3), "WAV"))
+    {
+      this->loadWAV(fileName);
+    }
+    else if (!nocaseCmp(fileName.substr(fileName.size() - 3), "OGG"))
+      this->loadOGG(fileName);
+  SoundBuffer::SoundBuffer(const SoundBuffer& buffer)
+      : data(buffer.data)
+  {
+    this->registerObject(this, SoundBuffer::_objectList);
+  }
+  }
+  SoundBuffer::SoundBuffer(const SoundBufferData::Pointer& dataPointer)
+      : data(dataPointer)
+  {
+    this->registerObject(this, SoundBuffer::_objectList);
+  };
   SoundBuffer::~SoundBuffer()
+  {
-    //  SoundEngine::getInstance()->removeBuffer(this);
-    alDeleteBuffers(1, &this->bufferID);
-    SoundEngine::checkError("SoundBuffer: Delete Buffer", __LINE__);
+  }
-  /**
-   * @brief loads a Waveform from the local fileSystem into this Source.
-   * @param fileName the Name of the File to Load.
-   * @returns true on success.
-   */
-  bool SoundBuffer::loadWAV(const std::string& fileName)
+  {
-    SDL_AudioSpec wavSpec;
-    Uint32 wavLength;
-    Uint8 *wavBuffer;
-    /* Load the WAV */
-    if( SDL_LoadWAV(fileName.c_str(), &wavSpec, &wavBuffer, &wavLength) == NULL)
+    {
-      PRINTF(2)("Could not open %s: %s\n", fileName.c_str(), SDL_GetError());
-      return false;
+    }
-#if SDL_BYTEORDER == SDL_BIG_ENDIAN
-    if ( !( wavSpec.format == AUDIO_U8 || wavSpec.format == AUDIO_S8 ) )
+    {
-      int cnt = wavLength/2;
-      Uint16* wavBufferAsShorts = ( Uint16* )wavBuffer;
-      for ( int i = 0; i < cnt; ++i, ++wavBufferAsShorts )
-        *wavBufferAsShorts = SDL_Swap16( *wavBufferAsShorts );
+    }
-#endif
-    alBufferData(this->bufferID, SoundBuffer::sdlAudioSpecToAlFormat(&wavSpec),
-                 wavBuffer, wavLength, wavSpec.freq);
-    SDL_FreeWAV(wavBuffer);
-    if (SoundEngine::checkError("Could not load Wave file", __LINE__))
-      return true;
-    else
-      return false;
+  }
-#ifndef AL_FORMAT_VORBIS_EXT
-#define AL_FORMAT_VORBIS_EXT 0x100030
-#endif
-  /**
-   * @brief loads an OGG-file into a SOundBuffer
-   * @param fileName the Name of the File to load.
-   * @returns true on success (file exists and is fully loaded), false otherwise.
-   */
-  bool SoundBuffer::loadOGG(const std::string& fileName)
+  {
-    void*     ovdata;
-    FILE*     fh;
-    fh = fopen( fileName.c_str() , "rb") ;
-    if( fh != NULL )
+    {
-      struct stat sbuf ;
-      if(stat( fileName.c_str(), &sbuf ) != -1)
+      {
-        ovdata = malloc(sbuf.st_size);
-        if(ovdata != NULL)
+        {
-          fread( ovdata, 1, sbuf.st_size, fh);
-          alBufferData( this->bufferID,
-                        AL_FORMAT_VORBIS_EXT,
-                        ovdata,
-                        sbuf.st_size,
-) ;
-          SoundEngine::checkError("Could not load OGG file", __LINE__);
-          free(ovdata);
+        }
-        fclose(fh);
+      }
-      else
-        return false;
+    }
-    else
-      return false;
-    return true ;
+  }
-  /**
-   * @brief converts an SDL_AudioSpec into a valid OpenAL AUDIO_FORMAT enumerator
-   * @param audiospec the AudioSpec to convert.
-   * @returns the AL_FORMAT
-   */
-  ALenum SoundBuffer::sdlAudioSpecToAlFormat(const SDL_AudioSpec* audiospec)
+  {
-    assert (audiospec != NULL);
-    bool stereo = true;
-    bool is16Bit = true;
-    if (audiospec->format == AUDIO_U8 || audiospec->format == AUDIO_S8)
-      is16Bit = false;
-    if (audiospec->channels == 1)
-      stereo = false;
-    if (!stereo && !is16Bit)
-      return AL_FORMAT_MONO8;
-    else if (!stereo && is16Bit)
-      return AL_FORMAT_MONO16;
-    else if (stereo && !is16Bit)
-      return AL_FORMAT_STEREO8;
-    else /* if (stereo && is16Bit) */
-      return AL_FORMAT_STEREO16;
+  }
+}

trunk/src/lib/sound/sound_buffer.h

-                      r8969
+                      r9869
 #include "base_object.h"
+#include "alincl.h"
+// FORWARD DECLARATION
+typedef struct SDL_AudioSpec;
+#include "sound_buffer_data.h"
 namespace OrxSound
+{
   //! A class that represents a datastructure to play Sounds.
   class SoundBuffer : public BaseObject
+  class SoundBuffer : virtual public BaseObject
+  {
+    ObjectListDeclaration(SoundBuffer);
   public:
+    SoundBuffer();
+    SoundBuffer(const SoundBuffer& buffer);
+    SoundBuffer(const SoundBufferData::Pointer& dataPointer);
     SoundBuffer(const std::string& fileName);
     virtual ~SoundBuffer();
+    bool loadWAV(const std::string& fileName);
+    bool loadOGG(const std::string& fileName);
+    /** @brief assignment operator */
+    SoundBuffer& operator=(const SoundBuffer& buffer) { this->data = buffer.data; return *this; };
+    bool operator==(const SoundBuffer& buffer) const {return this->data == buffer.data; };
+    /** @see SoundBufferData::load */
+    inline bool load(const std::string& fileName) { return this->data->load(fileName); };
+    /** @see SoundBufferData::loadWav */
+    inline bool loadWAV(const std::string& fileName) { return this->data->loadWAV(fileName); };
+    /** @see SoundBufferData::loadOgg */
+    inline bool loadOGG(const std::string& fileName) { return this->data->loadOGG(fileName); };
     /** @returns the ID of the buffer used in this SoundBuffer */
+    inline ALuint getID() const { return this->bufferID; }
+    inline ALuint getID() const { return this->data->getID(); }
+    inline bool loaded() const { return this->data->loaded(); }
+    /** @returns the DataPointer */
+    const SoundBufferData::Pointer& dataPointer() const { return data; }
+    /** @param dataPointer the data to acquire @brief Buffer shall acquire dataPointers data */
+    void acquireData(const SoundBufferData::Pointer& dataPointer)  { data = dataPointer; };
   private:
+    ALenum sdlAudioSpecToAlFormat(const SDL_AudioSpec* audiospec);
+  private:
+    ALuint        bufferID;             //!< The address of the Buffer.
+    ALsizei       size;                 //!< The size of the Buffer.
+    ALboolean     loop;                 //!< loop information.
+    SoundBufferData::Pointer    data;                //!< Pointer to the Stored Data
   };
+}

trunk/src/lib/sound/sound_engine.cc

-                      r9235
+                      r9869
 #include "sound_engine.h"
-#include "class_list.h"
 #include "p_node.h"
-#include "util/loading/resource_manager.h"
 #include "debug.h"
 #include "util/preferences.h"
+#include "parser/preferences/preferences.h"
 #include "globals.h"
+#include "resource_sound_buffer.h"
 namespace OrxSound
+{
+  ObjectListDefinition(SoundEngine);
   //////////////////
   /* SOUND-ENGINE */
 …
   SoundEngine::SoundEngine ()
+  {
     this->setClassID(CL_SOUND_ENGINE, "SoundEngine");
+    this->registerObject(this, SoundEngine::_objectList);
     this->setName("SoundEngine");
     this->listener = NULL;
-    this->bufferList = NULL;
-    this->sourceList = NULL;
     this->device = NULL;
 …
+  {
     // deleting all the SoundSources
+    if(this->sourceList != NULL)
+    {
+      while (this->sourceList->size() > 0)
+        delete static_cast<SoundSource*>(this->sourceList->front());
+    }
+    while (!SoundSource::objectList().empty())
+      delete (SoundSource::objectList().front());
     while(!this->ALSources.empty())
 …
     // deleting all the SoundBuffers
+    if (this->bufferList != NULL)
+    {
+      while(this->bufferList->size() > 0)
+        ResourceManager::getInstance()->unload(static_cast<SoundBuffer*>(this->bufferList->front()));
+    }
+    //    while(!SoundBuffer::objectList().empty())
+    //ResourceManager::getInstance()->unload(SoundBuffer::objectList().front());
     // removing openAL from AudioResource
 …
   SoundSource* SoundEngine::createSource(const std::string& fileName, PNode* sourceNode)
+  {
     SoundBuffer* buffer = NULL;
+    SoundBuffer buffer;
     if (!fileName.empty())
+    {
       buffer= (SoundBuffer*)ResourceManager::getInstance()->load(fileName, WAV, RP_LEVEL);
       if (buffer == NULL)
+      buffer = ResourceSoundBuffer(fileName);
+      if (!buffer.loaded())
         PRINTF(2)("Wav-Sound %s could not be loaded onto new Source\n", fileName.c_str());
+    }
 …
     // updating all the Sources positions
+    if (likely(this->sourceList != NULL || (this->sourceList = ClassList::getList(CL_SOUND_SOURCE)) != NULL))
+    {
+      std::list<BaseObject*>::const_iterator sourceIT;
+      SoundSource* source;
+      for (sourceIT = this->sourceList->begin(); sourceIT != this->sourceList->end(); sourceIT++)
+    ObjectList<SoundSource>::const_iterator sourceIT;
+    for (sourceIT = SoundSource::objectList().begin();
+         sourceIT != SoundSource::objectList().end();
+         sourceIT++)
+    {
+      if ((*sourceIT)->isPlaying())
+      {
+        source = static_cast<SoundSource*>(*sourceIT);
+        if (source->isPlaying())
+        int play = 0x000;
+        alGetSourcei((*sourceIT)->getID(), AL_SOURCE_STATE, &play);
+        if (DEBUG_LEVEL > 2)
+          SoundEngine::checkError("SoundEngine::update() Play", __LINE__);
+        if(play == AL_PLAYING)
+        {
+          int play = 0x000;
+          alGetSourcei(source->getID(), AL_SOURCE_STATE, &play);
+          if (DEBUG_LEVEL > 2)
+            SoundEngine::checkError("SoundEngine::update() Play", __LINE__);
+          if(play == AL_PLAYING)
+          if (likely((*sourceIT)->getNode() != NULL))
+          {
+            if (likely(source->getNode() != NULL))
+            {
+              alSource3f(source->getID(), AL_POSITION,
+                         source->getNode()->getAbsCoor().x,
+                         source->getNode()->getAbsCoor().y,
+                         source->getNode()->getAbsCoor().z);
+              if (DEBUG_LEVEL > 2)
+                SoundEngine::checkError("SoundEngine::update() Set Source Position", __LINE__);
+              alSource3f(source->getID(), AL_VELOCITY,
+                         source->getNode()->getVelocity().x,
+                         source->getNode()->getVelocity().y,
+                         source->getNode()->getVelocity().z);
+              if (DEBUG_LEVEL > 2)
+                SoundEngine::checkError("SoundEngine::update() Set Source Velocity", __LINE__);
+            }
+            alSource3f((*sourceIT)->getID(), AL_POSITION,
+                       (*sourceIT)->getNode()->getAbsCoor().x,
+                       (*sourceIT)->getNode()->getAbsCoor().y,
+                       (*sourceIT)->getNode()->getAbsCoor().z);
+            if (DEBUG_LEVEL > 2)
+              SoundEngine::checkError("SoundEngine::update() Set Source Position", __LINE__);
+            alSource3f((*sourceIT)->getID(), AL_VELOCITY,
+                       (*sourceIT)->getNode()->getVelocity().x,
+                       (*sourceIT)->getNode()->getVelocity().y,
+                       (*sourceIT)->getNode()->getVelocity().z);
+            if (DEBUG_LEVEL > 2)
+              SoundEngine::checkError("SoundEngine::update() Set Source Velocity", __LINE__);
+          }
           else
+          {
             source->stop();
+          }
+        }
+        else
+        {
+          (*sourceIT)->stop();
+        }
+      }
 …
       default:
       case AL_NO_ERROR:
         return ("AL_NO_ERROR");
+      return ("AL_NO_ERROR");
       case AL_INVALID_NAME:
         return ("AL_INVALID_NAME");
+      return ("AL_INVALID_NAME");
       case AL_INVALID_ENUM:
         return ("AL_INVALID_ENUM");
+      return ("AL_INVALID_ENUM");
       case AL_INVALID_VALUE:
         return ("AL_INVALID_VALUE");
+      return ("AL_INVALID_VALUE");
       case AL_INVALID_OPERATION:
         return ("AL_INVALID_OPERATION");
+      return ("AL_INVALID_OPERATION");
       case AL_OUT_OF_MEMORY:
         return ("AL_OUT_OF_MEMORY");
+      return ("AL_OUT_OF_MEMORY");
     };
+  }
 …
       default:
       case ALC_NO_ERROR:
         return ("AL_NO_ERROR");
+      return ("AL_NO_ERROR");
       case ALC_INVALID_DEVICE:
         return ("ALC_INVALID_DEVICE");
+      return ("ALC_INVALID_DEVICE");
       case ALC_INVALID_CONTEXT:
         return("ALC_INVALID_CONTEXT");
+      return("ALC_INVALID_CONTEXT");
       case ALC_INVALID_ENUM:
         return("ALC_INVALID_ENUM");
+      return("ALC_INVALID_ENUM");
       case ALC_INVALID_VALUE:
         return ("ALC_INVALID_VALUE");
+      return ("ALC_INVALID_VALUE");
       case ALC_OUT_OF_MEMORY:
         return("ALC_OUT_OF_MEMORY");
+      return("ALC_OUT_OF_MEMORY");
     };
+  }

trunk/src/lib/sound/sound_engine.h

-                      r7847
+                      r9869
   class SoundEngine : public BaseObject
+  {
+  public:
+    ObjectListDeclaration(SoundEngine);
+    public:
     virtual ~SoundEngine();
     /** @returns a Pointer to the only object of this Class */
 …
     const PNode*                   listener;                 //!< The listener of the Scene
-    const std::list<BaseObject*>*  bufferList;               //!< A list of buffers
-    const std::list<BaseObject*>*  sourceList;               //!< A list for all the sources in the scene.
     unsigned int                   maxSourceCount;           //!< How many Sources is the Maximum
     std::stack<ALuint>             ALSources;                //!< A list of real openAL-Sources, the engine allocates, and stores for reuse.

trunk/src/lib/sound/sound_source.cc

-                      r8969
+                      r9869
 #include "sound_engine.h"
-#include "alincl.h"
 #include "compiler.h"
 #include "debug.h"
 …
 namespace OrxSound
+{
+  ObjectListDefinition(SoundSource);
   /**
   * @brief creates a SoundSource at position sourceNode with the SoundBuffer buffer
   */
+  SoundSource::SoundSource(const PNode* sourceNode, const SoundBuffer* buffer)
+  {
+    this->setClassID(CL_SOUND_SOURCE, "SoundSource");
+  SoundSource::SoundSource(const PNode* sourceNode, const SoundBuffer& buffer)
+  {
+    this->registerObject(this, SoundSource::_objectList);
     // adding the Source to the SourcesList of the SoundEngine
     this->buffer = buffer;
 …
   SoundSource::SoundSource(const SoundSource& source)
+  {
     this->setClassID(CL_SOUND_SOURCE, "SoundSource");
+    this->registerObject(this, SoundSource::_objectList);
     // adding the Source to the SourcesList of the SoundEngine
 …
   void SoundSource::play()
+  {
     if (this->buffer && this->retrieveSource())
+    if (this->retrieveSource())
+    {
       if (this->bPlay)
         alSourceStop(this->sourceID);
       alSourcei (this->sourceID, AL_BUFFER, this->buffer->getID());
+      alSourcei (this->sourceID, AL_BUFFER, this->buffer.getID());
       alSourcei (this->sourceID, AL_LOOPING,  AL_FALSE);
       alSourcef (this->sourceID, AL_GAIN, 1);
 …
   * @param buffer the buffer to play back on this Source
   */
   void SoundSource::play(const SoundBuffer* buffer)
+  void SoundSource::play(const SoundBuffer& buffer)
+  {
     if (!this->retrieveSource())
 …
     alSourceStop(this->sourceID);
     alSourcei (this->sourceID, AL_BUFFER, buffer->getID());
+    alSourcei (this->sourceID, AL_BUFFER, buffer.getID());
     alSourcei (this->sourceID, AL_LOOPING,  AL_FALSE);
     alSourcef (this->sourceID, AL_GAIN, 1);
 …
     alSourcePlay(this->sourceID);
     if (unlikely(this->buffer != NULL))
       alSourcei (this->sourceID, AL_BUFFER, this->buffer->getID());
+    if (unlikely(this->buffer.getID() != 0))
+      alSourcei (this->sourceID, AL_BUFFER, this->buffer.getID());
     this->bPlay = true;
 …
    * @param gain the gain of the sound buffer
   */
   void SoundSource::play(const SoundBuffer* buffer, float gain)
+  void SoundSource::play(const SoundBuffer& buffer, float gain)
+  {
     if (!this->retrieveSource())
 …
     alSourceStop(this->sourceID);
     alSourcei (this->sourceID, AL_BUFFER, buffer->getID());
+    alSourcei (this->sourceID, AL_BUFFER, buffer.getID());
     alSourcei (this->sourceID, AL_LOOPING,  AL_FALSE);
     alSourcef (this->sourceID, AL_GAIN, gain);
 …
     alSourcePlay(this->sourceID);
     if (unlikely(this->buffer != NULL))
       alSourcei (this->sourceID, AL_BUFFER, this->buffer->getID());
+    if (unlikely(this->buffer.getID() != 0))
+      alSourcei (this->sourceID, AL_BUFFER, this->buffer.getID());
     this->bPlay = true;
 …
    * @param loop if true, sound gets looped
    */
   void SoundSource::play(const SoundBuffer* buffer, float gain, bool loop)
+  void SoundSource::play(const SoundBuffer& buffer, float gain, bool loop)
+  {
     if (!this->retrieveSource())
 …
     alSourceStop(this->sourceID);
     alSourcei (this->sourceID, AL_BUFFER, buffer->getID());
+    alSourcei (this->sourceID, AL_BUFFER, buffer.getID());
     if (loop)
 …
     alSourcePlay(this->sourceID);
     if (unlikely(this->buffer != NULL))
       alSourcei (this->sourceID, AL_BUFFER, this->buffer->getID());
+    if (unlikely(this->buffer.getID() != 0))
+      alSourcei (this->sourceID, AL_BUFFER, this->buffer.getID());
     this->bPlay = true;
 …
    * @param gain the new gain value
    */
   void SoundSource::gain(const SoundBuffer* buffer, float gain)
+  void SoundSource::gain(const SoundBuffer& buffer, float gain)
+  {
     // alSourcei (this->sourceID, AL_BUFFER, buffer->getID());
 …
   * @param duration time perios to fade in
   */
   void SoundSource::fadein(const SoundBuffer* buffer, ALfloat duration)
+  void SoundSource::fadein(const SoundBuffer& buffer, ALfloat duration)
+  {
     //if (this->buffer && this->retrieveSource())

trunk/src/lib/sound/sound_source.h

-                      r8793
+                      r9869
 #include "base_object.h"
+#include "sound_buffer.h"
 #include "alincl.h"
 …
 namespace OrxSound
+{
-  class SoundBuffer;
   //! A class that represents a SoundSource
   class SoundSource : public BaseObject
+  {
+    ObjectListDeclaration(SoundSource);
   public:
     SoundSource(const PNode* sourceNode = NULL, const SoundBuffer* buffer = NULL);
+    SoundSource(const PNode* sourceNode = NULL, const SoundBuffer& buffer = SoundBuffer());
     SoundSource(const SoundSource& source);
     SoundSource& operator=(const SoundSource& source);
 …
     // user interaction
     void play();
     void play(const SoundBuffer* buffer);
     void play(const SoundBuffer* buffer, float gain);
     void play(const SoundBuffer* buffer, float gain, bool loop);
+    void play(const SoundBuffer& buffer);
+    void play(const SoundBuffer& buffer, float gain);
+    void play(const SoundBuffer& buffer, float gain, bool loop);
     void gain(const SoundBuffer* buffer, float gain);
+    void gain(const SoundBuffer& buffer, float gain);
     void stop();
     void pause();
     void rewind();
     void fadein(const SoundBuffer* buffer, ALfloat duration);
+    void fadein(const SoundBuffer& buffer, ALfloat duration);
     // development functions
 …
     void setSourceNode(const PNode* sourceNode);
     /** @returns the SoundBuffer of this Source */
     inline const SoundBuffer* getBuffer() const { return this->buffer; };
+    inline const SoundBuffer& getBuffer() const { return this->buffer; };
     /** @returns the SourceNode of this Source */
     inline const PNode* getNode() const { return this->sourceNode; };
 …
     bool                   resident;    //!< If the alSource should be resident (if true, the alSource will be returned on deletion).
     ALuint                 sourceID;    //!< The ID of the Source
     const SoundBuffer*     buffer;      //!< The buffer to play in this source.
+    SoundBuffer            buffer;      //!< The buffer to play in this source.
     const PNode*           sourceNode;  //!< The SourceNode representing the position/velocity... of this source.
   };

trunk/src/lib/util/Makefile.am

-                      r9406
+                      r9869
 include $(MAINSRCDIR)/defs/include_paths.am
+noinst_LIBRARIES = libORXlibutil.a
+noinst_LIBRARIES = \
+                libORXlibutil.a \
+                libORXexecutor.a
+libORXexecutor_a_SOURCES = \
+                executor/executor_substring.cc
 libORXlibutil_a_SOURCES = \
 …
                 helper_functions.cc \
                 multi_type.cc \
+                executor/executor.cc \
+                executor/executor_functional.cc \
+                executor/executor_lua.cc \
+                debug_buffer.cc \
+                \
                 loading/resource_manager.cc \
 …
                 loading/load_param.cc \
                 loading/load_param_description.cc \
+                loading/load_param_class_description.cc \
                 loading/factory.cc \
                 loading/dynamic_loader.cc \
+                loading/fast_factory.cc \
+                \
                 filesys/file.cc \
 …
                 filesys/net_link.cc \
+                \
-                preferences.cc \
                 threading.cc \
                 timer.cc
+#               loading/dynamic_loader.cc
 …
                 color.h \
                 helper_functions.h \
+                debug.h \
+                debug_buffer.h \
+                \
+                \
                 executor/executor.h \
-                executor/executor_functional.h \
                 executor/executor_xml.h \
+                executor/executor_lua.h \
+                executor/executor_substring.h \
+                executor/executor_generic.h \
+                executor/executor_member.h \
+                executor/executor_const_member.h \
+                executor/executor_static.h \
+                \
                 executor/functor_list.h \
+                executor/functor_generic.h \
+                executor/functor_member.h \
+                executor/functor_const_member.h \
+                executor/functor_static.h \
+                \
+                \
                 filesys/file.h \
 …
                 filesys/net_link.h \
+                \
-                preferences.h \
                 threading.h \
                 timer.h \
 …
                 loading/game_loader.h \
                 loading/load_param.h \
+                loading/load_param_xml.h \
                 loading/load_param_description.h \
+                loading/load_param_class_description.h \
                 loading/factory.h \
+                loading/fast_factory.h \
                 loading/dynamic_loader.h \
+                \

trunk/src/lib/util/color.cc

-                      r8986
+                      r9869
 //! Black Color
 const Color Color::black(0,0,0,1);
+//! Orx Color
+const Color Color::orx(.2, .5, .7, .8);  //!< TODO Define the ORX-color :)
+/**
+ * @brief slerps the Color in the HSV color space into the direction of c
+ * @param c the Color to slerp to
+ * @param v the Value to slerp 0 means stay at *this, 1 means at c.
+ */
 void Color::slerpHSV(const Color& c, float v)
+{
 …
+}
+/**
+ * @brief simple slerp wrapper.
+ * @param from from this color
+ * @param to to this one
+ * @param v how much
+ * @see void Color::slerpHSV(const Color& c, float v)
+ */
 Color Color::slerpHSVColor(const Color& from, const Color& to, float v)
+{
 …
+}
+/**
+ * @brief nice and simple debug output for the colors (colorless :) )
+ */
 void Color::debug() const
+{
 …
+// Needed by rgb2hsv()
+/**
+ * @returns the maximum of r g and a.
+ * @param r Red.
+ * @param g Green
+ * @param b Blue
+ */
 float Color::maxrgb(float r, float g, float b)
+{
 …
+}
+// Needed by rgb2hsv()
+/**
+ * @returns the minimum of r g and a.
+ * @param r Red.
+ * @param g Green
+ * @param b Blue
+ */
 float Color::minrgb(float r,float g,float b)
+{

trunk/src/lib/util/color.h

-                      r9656
+                      r9869
 #include "vector.h"
+//! a very abstract Class that helps transforming Colors into different Systems
+//! A Class that handles Colors.
+/**
+ * A Color is a collection of 4 values:
+ * <ul>
+ *  <li>Red</li>
+ *  <li>Green</li>
+ *  <li>Blue</li>
+ *  <li>Alpha</li>
+ * </ul>
+ * With these four values any color of the entire spectrum can be defined.
+ *
+ * By default a Color lies between 0 and 1 for each component.
+ * for example [1,0,0,.5] means red and half visible.
+ */
 class Color
+{
 public:
+  /** @param r red, @param g green @param b blue @param a alpha @brief constructs a Color. */
   Color(float r = 0.0f, float g = 0.0f, float b = 0.0f, float a = 1.0f) { _rgba[0] = r; _rgba[1] = g; _rgba[2] = b; _rgba[3] = a; };
+  /** @param c Color @brief copy constructor */
   Color(const Color& c) { _rgba[0] = c.r(); _rgba[1] = c.g(); _rgba[2] = c.b(); _rgba[3] = c.a(); }
+  /** @param c the Color to set to this color @returns the copied color */
   inline const Color& operator=(const Color& c) { _rgba[0] = c.r(); _rgba[1] = c.g(); _rgba[2] = c.b(); _rgba[3] = c.a(); return *this; };
+  /** @param c the color to compare @returns true on match. @brief compares two colors */
   inline bool operator==(const Color& c) const { return (r() == c.r() && g() == c.g() && b() == c.b() && a() == c.a()); };
+  /** @returns the i'th Value of the Color @param i part of the color 0:r, 1:g, 2:b, 3:a */
   inline float& operator[](unsigned int i) { return _rgba[i]; }
+  /** @returns a Constant Value of the color. @param i part of the color 0:r, 1:g, 2:b, 3:a */
   inline const float& operator[](unsigned int i) const { return _rgba[i]; }
+  /** @returns the red part. */
   inline float r() const { return _rgba[0]; }
+  /** @returns the reference to the red part */
   inline float& r() { return _rgba[0]; }
+  /** @returns the green part. */
   inline float g() const { return _rgba[1]; }
+  /** @returns the reference to the green part */
   inline float& g() { return _rgba[1]; }
+  /** @returns the blue part */
   inline float b() const { return _rgba[2]; }
+  /** @returns the reference to the blue part */
   inline float& b() { return _rgba[2]; }
+  /** @returns the alpha part */
   inline float a() const { return _rgba[3]; }
+  /** @returns the reference to the alpha part */
   inline float& a() { return _rgba[3]; }
+  /** @param r red, @param g green @param b blue @param a alpha @brief sets the color. */
   void setColor(float r = 0.0f, float g = 0.0f, float b = 0.0f, float a = 1.0f) { _rgba[0] = r; _rgba[1] = g; _rgba[2] = b; _rgba[3] = a; };
+  /** @param c the color to set. @brief sets the color. */
   void setColor(const Color& c) { r() = c.r();  g()= c.g(); b() = c.b(); a() = c.a(); };
+  /** @returns the distance to the color @param c the color to calculate the distance to. */
   inline float dist(const Color& c) const { return (sqrt((r()-c.r())*(r()-c.r()) + (g()-c.g())*(g()-c.g()) + (b()-c.b())*(b()-c.b()) + (a()-c.a())*(a()-c.a()))); }
   /// Maths
+  /** @param c the color to add to this one @returns the two added colors */
   inline const Color& operator+=(const Color& c) { r()+=c.r(); g()+=c.g(); b()+=c.b(); a()+=c.a(); return *this; };
+  /** @returns the result of the added colors @param c the color to add */
   inline Color operator+(const Color& c) const { return Color(r()+c.r(), g()+c.g(), b()+c.b(), a()+c.a()); };
+  /** @param c the color to substract to this one @returns the two substracted colors */
   inline const Color& operator-=(const Color& c) { r()-=c.r(); g()-=c.g(); b()-=c.b(); a()-=c.a(); return *this; };
+  /** @returns the result of the substracted colors @param c the color to substract */
   inline Color operator-(const Color& c) const { return Color(r()-c.r(), g()-c.g(), b()-c.b(), a()-c.a()); };
+  /** @param v the multiplier @returns the Color multiplied by v */
   inline const Color& operator*=(float v) { r()*=v, g()*=v, b()*=v, a()*=v; return *this; };
+  /** @param v the multiplier @returns a multiplied color */
   inline Color operator*(float v) const { return Color(r()*v, g()*v, b()*v, a()*v); };
+  /** @param c the color to slerp to @param v how much to slerp [0:1] @brief moves the color into the direction of another color */
   void slerp(const Color& c, float v) { *this += (c - *this) * v; };
   void slerpHSV(const Color& c, float v);
   static Color slerpHSVColor(const Color& from, const Color& to, float v);
 …
   static const Color white;
   static const Color black;
-  static const Color orx;
 private:
+  float       _rgba[4]; //!< Color Values
+  /*  float       _r;     //!< Red Value.
+  float       _g;     //!< Green Value.
+  float       _b;     //!< Blue Value.
+  float       _a;     //!< Alpha Value.*/
+  float       _rgba[4]; //!< Color Values [r,g,b,a] (red green blue alpha)
 };

trunk/src/lib/util/count_pointer.h

-                      r8761
+                      r9869
+{
 public:
+    explicit CountPointer(X* p = 0) // allocate a new counter
+        : itsCounter(0) { if (p) itsCounter = new counter(p); }
+    virtual ~CountPointer() { release(); }
+    CountPointer(const CountPointer& r) { acquire(r.itsCounter); }
+    CountPointer& operator=(const CountPointer& r)
+  explicit CountPointer(X* p = NULL) // allocate a new counter
+      : itsCounter(NULL) { if (p) itsCounter = new counter(p); }
+  ~CountPointer() { release(); }
+  CountPointer(const CountPointer& r) { acquire(r.itsCounter); }
+  CountPointer& operator=(const CountPointer& r)
+  {
+    if (this != &r)
+    {
+        if (this != &r) {
+            release();
+            acquire(r.itsCounter);
+        }
+        return *this;
+      release();
+      acquire(r.itsCounter);
+    }
+    bool operator==(const CountPointer& r) const { return this->itsCounter->ptr == r.itsCounter->ptr; };
+    X& operator*()  const { return *itsCounter->ptr; }
+    X* operator->() const { return itsCounter->ptr; }
+    X* get()        const { return itsCounter ? itsCounter->ptr : 0; }
+    bool unique()   const { return (itsCounter ? itsCounter->count == 1 : true); }
+    virtual unsigned int count() const { return (this->itsCounter ? itsCounter->count : 0); }
+    return *this;
+  }
+  bool operator==(const CountPointer& r) const { return this->itsCounter->ptr == r.itsCounter->ptr; };
+  inline X& operator*()  const { return *itsCounter->ptr; }
+  inline X* operator->() const { return itsCounter->ptr; }
+  inline bool unique()   const { return (itsCounter ? itsCounter->count == 1 : true); }
+  inline bool isNull()   const { return (!itsCounter); }
+  unsigned int count() const { return (this->itsCounter ? itsCounter->count : 0); }
 private:
+    struct counter {
+        counter(X* p = 0, unsigned c = 1) : ptr(p), count(c) {}
+        X*          ptr;
+        unsigned    count;
+    }* itsCounter;
+  struct counter
+  {
+    counter(X* p = NULL, unsigned c = 1) : ptr(p), count(c) {}
+    X*          ptr;
+    unsigned    count;
+  }
+  * itsCounter;
+    void acquire(counter* c)
+  void acquire(counter* c)
+  {
+    // increment the count
+    itsCounter = c;
+    if (c) ++c->count;
+  }
+  void release()
+  {
+    // decrement the count, delete if it is 0
+    if (itsCounter)
+    {
+      // increment the count
+        itsCounter = c;
+        if (c) ++c->count;
+      if (--itsCounter->count == 0)
+      {
+        delete itsCounter->ptr;
+        delete itsCounter;
+      }
+      itsCounter = NULL;
+    }
+    void release()
+    {
+      // decrement the count, delete if it is 0
+        if (itsCounter) {
+            if (--itsCounter->count == 0) {
+                delete itsCounter->ptr;
+                delete itsCounter;
+            }
+            itsCounter = 0;
+        }
+    }
+  }
 };

trunk/src/lib/util/executor/executor.h

-                      r8894
+                      r9869
 #include "base_object.h"
-#include "helper_functions.h"
 #include "multi_type.h"
+#include "substring.h"
+#include "functor_list.h" //< MUST BE INCLUDED HERE AT LEAST ONCE.
+//! an enumerator for the definition of the Type.
+typedef enum {
+  Executor_Objective         = 1,
+  Executor_Static            = 2,
+  Executor_NoLoadString      = 8,
+} Executor_Type;
+//! The maximum Count of Arguments of the Executor
+/** This is Hardcoded, for each Executor. */
+#define EXECUTOR_MAX_ARGUMENTS                7
+/** @returns the Type of an Argument taken by the Executor */
+template<typename type> inline MT_Type ExecutorParamType() { return MT_EXT1; };
+/** @returns the Type of an Argument taken by the Executor in this case MT_BOOL */
+template<> inline MT_Type ExecutorParamType<bool>() { return MT_BOOL; };
+/** @returns the Type of an Argument taken by the Executor in this case MT_INT*/
+template<> inline MT_Type ExecutorParamType<int>() { return MT_INT; };
+/** @returns the Type of an Argument taken by the Executor in this case MT_UINT*/
+template<> inline MT_Type ExecutorParamType<unsigned int>() { return MT_UINT; };
+/** @returns the Type of an Argument taken by the Executor in this case MT_FLOAT*/
+template<> inline MT_Type ExecutorParamType<float>() { return MT_FLOAT; };
+/** @returns the Type of an Argument taken by the Executor in this case MT_CHAR*/
+template<> inline MT_Type ExecutorParamType<char>() { return MT_CHAR; };
+/** @returns the Type of an Argument taken by the Executor in this case MT_STRING*/
+template<> inline MT_Type ExecutorParamType<const std::string&>() { return MT_STRING; };
 ////////////////
 …
  *  Functions with many types (@see functor_list.h)
  */
+class Executor : public BaseObject
+template <typename CallType, class BaseClass = BaseObject> class Executor
+{
+  public:
+    virtual ~Executor();
+    virtual Executor* clone () const = 0;
+//    virtual bool operator==(const Executor* executor) const = 0;
+    // SETTING up the EXECUTOR
+    Executor* defaultValues(const MultiType& value0 = MT_NULL, const MultiType& value1 = MT_NULL,
+                            const MultiType& value2 = MT_NULL, const MultiType& value3 = MT_NULL,
+                            const MultiType& value4 = MT_NULL, const MultiType& param5 = MT_NULL,
+                            const MultiType& param6 = MT_NULL);
+    /** @param i the i'th defaultValue, @returns reference to the MultiType */
+    inline MultiType& getDefaultValue(unsigned int i) { return defaultValue[i]; };
+    // EXECUTE
+    /** executes a Command. @param objec the Object, @param count how many values, @param values the Values */
+    virtual void operator()(BaseObject* object, int& count, void* values) const = 0;
+    /** executes a Command @param object the object to apply this to @param parameters the parameters the command takes */
+    virtual void operator()(BaseObject* object, const SubString& sub = SubString()) const = 0;
+    // RETRIEVE INFORMATION
+    /** @returns the Type of this Function (either static or objective) */
+    inline long getType() const { return this->functorType; };
+    /** @returns the Count of Parameters this Executor takes */
+    inline unsigned int getParamCount() const { return this->paramCount; };
+    static void debug();
+  protected:
+    Executor(const MultiType& param0 = MT_NULL, const MultiType& param1 = MT_NULL,
+             const MultiType& param2 = MT_NULL, const MultiType& param3 = MT_NULL,
+             const MultiType& param4 = MT_NULL, const MultiType& param5 = MT_NULL,
+             const MultiType& param6 = MT_NULL);
+    void cloning(Executor* executor) const;
+  protected:
+    short                       functorType;      //!< The type of Function we've got (either static or objective).
+    unsigned int                paramCount;       //!< the count of parameters.
+    MultiType                   defaultValue[7];  //!< Default Values.
+public:
+  //! an enumerator for the definition of the Type.
+  typedef enum {
+    FunctionMember,      //!< The function is neither Static nor Constant
+    FunctionStatic,      //!< The Function is Static and pointing to either a Static Member or a C-style function.
+    FunctionConstMember, //!< The Function is Constant and pointing to a Member that does not change the Object.
+  } FunctionType;
+public:
+  virtual ~Executor() {};
+  // RETRIEVE INFORMATION
+  /** @param i the i'th defaultValue, @returns reference to the MultiType */
+  inline MultiType& getDefaultValue(unsigned int i) { return defaultValue[i]; };
+  /** @returns the default Values as a List */
+  inline const MultiType* const getDefaultValues() { return defaultValue; };
+  /** @returns the Type of this Function (either static or objective) */
+  inline FunctionType getType() const { return this->functionType; };
+  /** @returns the Count of Parameters this Executor takes */
+  inline unsigned int getParamCount() const { return this->paramCount; };
+  /** @returns true if the Executor has a return Value. */
+  inline bool hasRetVal() const { return bRetVal; };
+  /** executes a Command. @param object the Object, @param values The Value of type CallType to pass to the Executor. */
+  virtual void operator()(BaseClass* object, CallType& values) const = 0;
+  /**
+   * @brief set the default values of the executor
+   * @param value0 the first default value
+   * @param value1 the second default value
+   * @param value2 the third default value
+   * @param value3 the fourth default value
+   * @param value4 the fifth default value
+   * @param value5 the sixth default value
+   * @param value6 the seventh default value
+   * @returns itself
+   * @note: THIS FUNCTION WILL BE REPLACED BY A CONFIGURATOR (most probably).
+  */
+  Executor* defaultValues(const MultiType& value0 = MT_NULL, const MultiType& value1 = MT_NULL,
+                          const MultiType& value2 = MT_NULL, const MultiType& value3 = MT_NULL,
+                          const MultiType& value4 = MT_NULL, const MultiType& value5 = MT_NULL,
+                          const MultiType& value6 = MT_NULL)
+  {
+    const MultiType* value[5];
+    value[0] = &value0;
+    value[1] = &value1;
+    value[2] = &value2;
+    value[3] = &value3;
+    value[4] = &value4;
+    value[5] = &value5;
+    value[6] = &value6;
+    for (unsigned int i = 0; i < this->paramCount; i++)
+    {
+      if (*value[i] != MT_NULL)
+      {
+        this->defaultValue[i].setValueOf(*value[i]);
+        this->defaultValue[i].storeString();
+      }
+    }
+    return this;
+  }
+  /** @returns the Clone as a new Copy of the Executor. */
+  virtual Executor<CallType, BaseClass>* clone () const = 0;
+protected:
+  //! Now follows a List of Executor Constructors, to be fast in creating.
+  //! Creates an Executor with no Argument.
+  Executor(bool hasRetVal, FunctionType functionType = FunctionMember)
+  : bRetVal(hasRetVal), paramCount(0), functionType(functionType)
+  { };
+  //! Creates an Executor with 1 Argument.
+  Executor(bool hasRetVal, const MultiType& param0,
+           FunctionType functionType = FunctionMember)
+  : bRetVal(hasRetVal), paramCount(1), functionType(functionType)
+  {
+    this->defaultValue[0] = param0;
+  };
+  //! Creates an Executor with 2 Arguments.
+  Executor(bool hasRetVal, const MultiType& param0, const MultiType& param1,
+           FunctionType functionType = FunctionMember)
+  : bRetVal(hasRetVal), paramCount(2), functionType(functionType)
+  {
+    this->defaultValue[0] = param0;
+    this->defaultValue[1] = param1;
+  };
+  //! Creates an Executor with 3 Arguments.
+  Executor(bool hasRetVal, const MultiType& param0, const MultiType& param1,
+           const MultiType& param2,
+           FunctionType functionType = FunctionMember)
+  : bRetVal(hasRetVal), paramCount(3), functionType(functionType)
+  {
+    this->defaultValue[0] = param0;
+    this->defaultValue[1] = param1;
+    this->defaultValue[2] = param2;
+  };
+  //! Creates an Executor with 4 Arguments.
+  Executor(bool hasRetVal, const MultiType& param0, const MultiType& param1,
+           const MultiType& param2, const MultiType& param3,
+           FunctionType functionType = FunctionMember)
+  : bRetVal(hasRetVal), paramCount(4), functionType(functionType)
+  {
+    this->defaultValue[0] = param0;
+    this->defaultValue[1] = param1;
+    this->defaultValue[2] = param2;
+    this->defaultValue[3] = param3;
+  };
+  //! Creates an Executor with 5 Arguments.
+  Executor(bool hasRetVal, const MultiType& param0, const MultiType& param1,
+           const MultiType& param2, const MultiType& param3,
+           const MultiType& param4,
+           FunctionType functionType = FunctionMember)
+  : bRetVal(hasRetVal), paramCount(5), functionType(functionType)
+  {
+    this->defaultValue[0] = param0;
+    this->defaultValue[1] = param1;
+    this->defaultValue[2] = param2;
+    this->defaultValue[3] = param3;
+    this->defaultValue[4] = param4;
+  };
+  //! Creates an Executor with 6 Arguments.
+  Executor(bool hasRetVal, const MultiType& param0, const MultiType& param1,
+           const MultiType& param2, const MultiType& param3,
+           const MultiType& param4, const MultiType& param5,
+           FunctionType functionType = FunctionMember)
+  : bRetVal(hasRetVal), paramCount(6), functionType(functionType)
+  {
+    this->defaultValue[0] = param0;
+    this->defaultValue[1] = param1;
+    this->defaultValue[2] = param2;
+    this->defaultValue[3] = param3;
+    this->defaultValue[4] = param4;
+    this->defaultValue[5] = param5;
+  };
+  //! Creates an Executor with 7 Arguments.
+  Executor(bool hasRetVal, const MultiType& param0, const MultiType& param1,
+           const MultiType& param2, const MultiType& param3,
+           const MultiType& param4, const MultiType& param5,
+           const MultiType& param6,
+           FunctionType functionType = FunctionMember)
+  : bRetVal(hasRetVal), paramCount(7), functionType(functionType)
+  {
+    this->defaultValue[0] = param0;
+    this->defaultValue[1] = param1;
+    this->defaultValue[2] = param2;
+    this->defaultValue[3] = param3;
+    this->defaultValue[4] = param4;
+    this->defaultValue[5] = param5;
+    this->defaultValue[6] = param6;
+  };
+protected:
+  const bool                  bRetVal;          //!< True if the Executor has a return Value.
+  const unsigned int          paramCount;       //!< the count of parameters.
+  MultiType                   defaultValue[7];  //!< Default Values.
+  const FunctionType          functionType;     //!< What Type of Function it is.
 };
-#include "executor/executor_functional.h"
-#define EXECUTOR_FUNCTIONAL_USE_CONST
-#include "executor/executor_functional.h"
-#define EXECUTOR_FUNCTIONAL_USE_STATIC
-#include "executor/executor_functional.h"
 #endif /* _EXECUTOR_H */

trunk/src/lib/util/executor/executor_xml.h

-                      r8362
+                      r9869
  * What must be defined is a XML-root to search the ParameterName under an  a Function to call.
  */
 template<class T> class ExecutorXML : public Executor
+template<class T, class BaseClass = BaseObject> class ExecutorXML : public Executor<const TiXmlElement*>
+{
   public:
     /**
+public:
+  /**
    * @brief Constructor of a ExecutorXML
      * @param function a Function to call
      * @param root The XML root to search paramName under
      * @param paramName the ParameterName the search in root, and lookup the TiXmlElement from
      */
     ExecutorXML(void(T::*function)(const TiXmlElement*), const TiXmlElement* root, const char* paramName)
       : Executor(MT_EXT1)
+    {
       PRINTF(4)("Loading %s from XML-element %p\n", paramName, root);
+   * @param function a Function to call
+   * @param root The XML root to search paramName under
+   * @param paramName the ParameterName the search in root, and lookup the TiXmlElement from
+   */
+  ExecutorXML(void(T::*function)(const TiXmlElement*), const TiXmlElement* root, const std::string& paramName)
+      : Executor<const TiXmlElement*>(false, MT_EXT1)
+  {
+    PRINTF(4)("Loading %s from XML-element %p\n", paramName.c_str(), root);
       if (likely(root != NULL && paramName != NULL))
         this->element = root->FirstChildElement(paramName);
       else
         this->element = NULL;
+    if (likely(root != NULL))
+      this->element = root->FirstChildElement(paramName);
+    else
+      this->element = NULL;
       this->functionPointer = function;
       this->functorType = Executor_Objective | Executor_NoLoadString;
+    }
+    this->paramName = paramName;
+    this->functionPointer = function;
+  }
+    /**
+     * @brief clones an ExecutorXML, used to copy this Element.
+     * @returns a _new_ Copy of this Executor
+     */
+    virtual Executor* clone () const
+    {
+      ExecutorXML<T>* executor = new ExecutorXML<T>();
+      this->cloning(executor);
+      executor->functionPointer = this->functionPointer;
+      executor->element = this->element;
+      return executor;
+    }
+  /**
+   * @brief clones an ExecutorXML, used to copy this Element.
+   * @returns a _new_ Copy of this Executor
+   */
+  virtual Executor<const TiXmlElement*>* clone () const
+  {
+    return new ExecutorXML<T>(functionPointer, element, paramName);
+  }
+    /**
+     * @brief executes the Command on BaseObject
+     * @param object the BaseObject to execute this Executor on
+     * @param loadString ignored in this case
+     */
+    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
+    {
+      if (object != NULL && this->element != NULL)
+        (dynamic_cast<T*>(object)->*(functionPointer))(this->element);
+    }
+  /**
+   * @brief executes the Command on BaseObject
+   * @param object the BaseObject to execute this Executor on
+   * @param element ignored in this case
+   */
+  virtual void operator()(BaseObject* object, const TiXmlElement*& element) const
+  {
+    assert (object != NULL);
+    if (this->element != NULL)
+      (dynamic_cast<T*>(object)->*(functionPointer))(this->element);
+  }
+    virtual void operator()(BaseObject* object, int& count, void* values) const
+    {
+      PRINTF(1)("missuse of XML-operator, OR IMPLEMENT.\n");
+    }
+  private:
+    /**
+   * @brief used for the copy-(Clone)-constructor
+     */
+    ExecutorXML() : Executor() { };
+  private:
+    void    (T::*functionPointer)(const TiXmlElement*);  //!< The functionPointer to the function to be called
+    const   TiXmlElement* element;                       //!< The XML-element to call.
+private:
+  void    (T::*functionPointer)(const TiXmlElement*);  //!< The functionPointer to the function to be called.
+  const   TiXmlElement* element;                       //!< The XML-element to call.
+  std::string           paramName;                     //!< The Name of the Parameter this Executor should call.
 };

trunk/src/lib/util/executor/functor_list.h

-                      r9406
+                      r9869
+/*!
+ * @file functor_list.h
+ * all the Different types of Functions one can include by using a simple createExecutor call
+ * with a FunctionPointer as Argument
+ */
 /*
    orxonox - the future of 3D-vertical-scrollers
 …
    the Free Software Foundation; either version 2, or (at your option)
    any later version.
-   */
-/*!
- * @file functors_list.h
- * all the Different types of Functions one can include
 */
-/**
-   useable FunctionParameters are:
-   l_INT:       int
-   l_LONG:      long
-   l_SHORT:     short
-   l_FLOAT:     float
-   l_STRING:    const std::string&
-   l_XML_ELEM:  TiXmlElement*
- */
-#ifndef __FUNCTOR_PARAMETERS__
-#define __FUNCTOR_PARAMETERS__
-//! defines the maximum count of arguments function pointers might have
-#define FUNCTOR_MAX_ARGUMENTS                7
-#include "multi_type.h"
-#define l_BOOL_TYPE        bool                 //!< The type of an BOOL
-#define l_BOOL_FUNC        isBool               //!< The function to call to parse BOOL
-#define l_BOOL_PARAM       MT_BOOL              //!< the type of the parameter BOOL
-#define l_BOOL_DEFAULT     false                //!< a default Value for an BOOL
-#define l_BOOL_DEFGRAB(i)  this->defaultValue[i].getBool()
-#define l_INT_TYPE         int                  //!< The type of an INT
-#define l_INT_FUNC         isInt                //!< The function to call to parse INT
-#define l_INT_PARAM        MT_INT               //!< the type of the parameter INT
-#define l_INT_DEFAULT      0                    //!< a default Value for an INT
-#define l_INT_DEFGRAB(i)   this->defaultValue[i].getInt()
-#define l_UINT_TYPE        unsigned int         //!< The type of an UINT
-#define l_UINT_FUNC        isInt                //!< The function to call to parse UINT
-#define l_UINT_PARAM       MT_INT        //!< the type of the parameter UINT
-#define l_UINT_DEFAULT     0                    //!< a default Value for an UINT
-#define l_UINT_DEFGRAB(i)  (unsigned int)this->defaultValue[i].getInt()
-#define l_LONG_TYPE        long                 //!< The type of a LONG
-#define l_LONG_FUNC        isInt                //!< The function to parse a LONG
-#define l_LONG_PARAM       MT_INT //!< the type of the parameter LONG
-#define l_LONG_DEFAULT     0                    //!< a default Value for a LONG
-#define l_LONG_DEFGRAB(i)  (long)this->defaultValue[i].getInt()
-// #define l_SHORT_TYPE       short                //!< The type of a SHORT
-// #define l_SHORT_FUNC       atoi                 //!< The function to parse a SHORT
-// #define l_SHORT_NAME       "short"              //!< The name of a SHORT
-// #define l_SHORT_PARAM      ParameterShort       //!< the type of the parameter SHORT
-// #define l_SHORT_DEFAULT    0                    //!< a default Value for a SHORT
-#define l_FLOAT_TYPE       float                //!< The type of a FLOAT
-#define l_FLOAT_FUNC       isFloat              //!< The function to parse a FLOAT
-#define l_FLOAT_PARAM      MT_FLOAT             //!< the type of the parameter FLOAT
-#define l_FLOAT_DEFAULT    0.0                  //!< a default Value for a FLOAT
-#define l_FLOAT_DEFGRAB(i) this->defaultValue[i].getFloat()
-//#define l_VECTOR_TYPE      const Vector&        //!< The type of a VECTOR
-//#define l_VECTOR_FUNC      isVector             //!< The function to parse a VECTOR
-//#define l_VECTOR_NAME      "Vector[x/y/z]"      //!< The name of a VECTOR
-//#define l_VECTOR_DEFAULT   Vector(0,0,0)        //!< Default value for a VECTOR
-#define l_STRING_TYPE      const std::string&   //!< The type of a STRING
-#define l_STRING_FUNC      isString             //!< The function to parse a STRING
-#define l_STRING_PARAM     MT_STRING            //!< the type of the parameter STRING
-#define l_STRING_DEFAULT   ""                   //!< a default Value for an STRING
-#define l_STRING_DEFGRAB(i) this->defaultValue[i].getString()
-#define l_XML_ELEM_TYPE    const TiXmlElement*  //!< The type of an XML_ELEM
-#define l_XML_ELEM_FUNC                         //!< The function to parse an XML_ELEM
-//#define l_XML_ELEM_PARAM   Parameter            //!< the type of the parameter XML_ELEM
-#define l_XML_ELEM_DEFAULT NULL                 //!< The dafault Value for an XML_ELEM
-#endif /* __FUNCTOR_PARAMETERS__ */
 #ifdef FUNCTOR_LIST
+  FUNCTOR_LIST(0)();
+  FUNCTOR_LIST(0)(FUNCTOR_CALL_TYPE);
   //! makes functions with one string
   FUNCTOR_LIST(1)(l_STRING);
+  FUNCTOR_LIST(1)(FUNCTOR_CALL_TYPE, const std::string&);
   //! makes functions with two strings
   FUNCTOR_LIST(2)(l_STRING, l_STRING);
+  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, const std::string&, const std::string&);
   //! makes functions with three strings
   FUNCTOR_LIST(3)(l_STRING, l_STRING, l_STRING);
+  FUNCTOR_LIST(3)(FUNCTOR_CALL_TYPE, const std::string&, const std::string&, const std::string&);
   //! makes functions with four strings
   FUNCTOR_LIST(4)(l_STRING, l_STRING, l_STRING, l_STRING);
+  FUNCTOR_LIST(4)(FUNCTOR_CALL_TYPE, const std::string&, const std::string&, const std::string&, const std::string&);
   //! makes functions with one bool
   FUNCTOR_LIST(1)(l_BOOL);
+  FUNCTOR_LIST(1)(FUNCTOR_CALL_TYPE, bool);
   //! makes functions with one int
   FUNCTOR_LIST(1)(l_INT);
+  FUNCTOR_LIST(1)(FUNCTOR_CALL_TYPE, int);
   //! makes functions with two ints
   FUNCTOR_LIST(2)(l_INT, l_INT);
+  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, int, int);
   //! makes functions with three ints
   FUNCTOR_LIST(3)(l_INT, l_INT, l_INT);
+  FUNCTOR_LIST(3)(FUNCTOR_CALL_TYPE, int, int, int);
   //! makes functions with four ints
   FUNCTOR_LIST(4)(l_INT, l_INT, l_INT, l_INT);
+  FUNCTOR_LIST(4)(FUNCTOR_CALL_TYPE, int, int, int, int);
   //! makes functions with one unsigned int
   FUNCTOR_LIST(1)(l_UINT);
+  FUNCTOR_LIST(1)(FUNCTOR_CALL_TYPE, unsigned int);
   //! makes functions with two unsigned ints
   FUNCTOR_LIST(2)(l_UINT, l_UINT);
+  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, unsigned int, unsigned int);
   //! makes functions with three unsigned ints
   FUNCTOR_LIST(3)(l_UINT, l_UINT, l_UINT);
+  FUNCTOR_LIST(3)(FUNCTOR_CALL_TYPE, unsigned int, unsigned int, unsigned int);
   //! makes functions with four unsigned ints
   FUNCTOR_LIST(4)(l_UINT, l_UINT, l_UINT, l_UINT);
+  FUNCTOR_LIST(4)(FUNCTOR_CALL_TYPE, unsigned int, unsigned int, unsigned int, unsigned int);
   //! makes functions with one float
   FUNCTOR_LIST(1)(l_FLOAT);
+  FUNCTOR_LIST(1)(FUNCTOR_CALL_TYPE, float);
   //! makes functions with two floats
   FUNCTOR_LIST(2)(l_FLOAT, l_FLOAT);
+  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, float, float);
   //! makes functions with three floats
   FUNCTOR_LIST(3)(l_FLOAT, l_FLOAT, l_FLOAT);
+  FUNCTOR_LIST(3)(FUNCTOR_CALL_TYPE, float, float, float);
   //! makes functions with four floats
   FUNCTOR_LIST(4)(l_FLOAT, l_FLOAT, l_FLOAT, l_FLOAT);
+  FUNCTOR_LIST(4)(FUNCTOR_CALL_TYPE, float, float, float, float);
   //! makes functions with four floats
   FUNCTOR_LIST(5)(l_FLOAT, l_FLOAT, l_FLOAT, l_FLOAT, l_FLOAT);
+  FUNCTOR_LIST(5)(FUNCTOR_CALL_TYPE, float, float, float, float, float);
   //! mixed values:
+  FUNCTOR_LIST(2)(l_STRING, l_INT);
+  FUNCTOR_LIST(2)(l_STRING, l_FLOAT);
+  FUNCTOR_LIST(2)(l_UINT, l_LONG);
+  FUNCTOR_LIST(2)(l_STRING, l_UINT);
+  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, const std::string&, bool);
+  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, const std::string&, int);
+  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, const std::string&, float);
+  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, unsigned int, long);
+  FUNCTOR_LIST(2)(FUNCTOR_CALL_TYPE, const std::string&, unsigned int);
   FUNCTOR_LIST(3)(l_STRING, l_FLOAT, l_UINT);
   FUNCTOR_LIST(4)(l_STRING, l_FLOAT, l_UINT, l_UINT);
   FUNCTOR_LIST(3)(l_STRING, l_INT, l_UINT);
   FUNCTOR_LIST(3)(l_STRING, l_UINT, l_UINT);
+  FUNCTOR_LIST(3)(FUNCTOR_CALL_TYPE, const std::string&, float, unsigned int);
+  FUNCTOR_LIST(4)(FUNCTOR_CALL_TYPE, const std::string&, float, unsigned int, unsigned int);
+  FUNCTOR_LIST(3)(FUNCTOR_CALL_TYPE, const std::string&, int, unsigned int);
+  FUNCTOR_LIST(3)(FUNCTOR_CALL_TYPE, const std::string&, unsigned int, unsigned int);
   FUNCTOR_LIST(5)(l_FLOAT, l_FLOAT, l_FLOAT, l_FLOAT, l_STRING);
+  FUNCTOR_LIST(5)(FUNCTOR_CALL_TYPE, float, float, float, float, const std::string&);
 #endif /* FUNCTOR_LIST */

trunk/src/lib/util/filesys/directory.cc

-                      r8523
+                      r9869
 #include <sys/stat.h>
 #include <dirent.h>
+const char Directory::delimiter = '/';
 #else
 #include <windows.h>
 #include <winbase.h>
+const char Direcotry::delimiter = '\\';
 #endif
 …
  */
 Directory::Directory(const Directory& directory)
   : File(directory)
+    : File(directory)
+{
   this->_opened = directory._opened;
 …
 #endif
+}
+Directory Directory::operator+(const Directory& dir) const
+{
+  return Directory(*this) += dir;
+}
+/**
+ * @param dir the Directory to append to this one (say this one is "/var", then dir can be "log")
+ * @returns The Directory appended by dir.
+ *
+ * @note the Directoy will again be closed even if it was opened previously!
+ */
+Directory& Directory::operator+=(const Directory& dir)
+{
+  this->setFileName(this->name() + Directory::delimiter + dir.name());
+  return *this;
+}
+/**
+ * @brief Traverses the Directory tree one step up. (Parent Directory)
+ * @returns a Reference to the Directory.
+ */
+Directory& Directory::operator--()
+{
+}
+/**
+ * @brief Traverses the Directory tree one step up. (Parent Directory)
+ * @param int the PostFix iterator
+ * @returns a Reference to the Directory.
+ */
+Directory& Directory::operator--(int)
+{
+}
+/**
+ * @returns The Parent Directory.
+ */
+Directory Directory::parentDir() const
+{
+}
+File operator+(const Directory& dir, const File& file)
+{
+  return File(dir.name() + Directory::delimiter + file.name());
+}

trunk/src/lib/util/filesys/directory.h

-                      r8333
+                      r9869
 #include <vector>
+//! A Directory is a Special file, that contains multiple Files.
+/**
+ * @example Correct usage
+ * Directory dir("/var/log");
+ * dir.open();
+ * if (dir.fileNameInDir("emerge.log"))
+ *  { // do stuff; }
+ */
 class Directory : public File
+{
 …
   bool create();
+  Directory operator+(const Directory& dir) const;
+  Directory& operator+=(const Directory& dir);
+  Directory& operator--();
+  Directory& operator--(int);
+  Directory parentDir() const;
   /** @returns if the Directory was opened */
   bool isOpen() const { return this->_opened; }
 …
   const std::string& operator[](unsigned int fileNumber) const { return this->_fileNames[fileNumber]; };
   /** @returns a formated string containing the FileName, prepended with the directory-Name */
   std::string fileNameInDir(unsigned int fileNumber) const { return this->name() + "/" + _fileNames[fileNumber]; };
+  std::string fileNameInDir(unsigned int fileNumber) const { return this->name() + Directory::delimiter + _fileNames[fileNumber]; };
   /** @returns a File pointing to the File @param fileNumber the fileNumber (must not bigger than fileCount()) */
   File getFile(unsigned int fileNumber) const { return File(fileNameInDir(fileNumber)); };
+public:
+  static const char           delimiter;        //!< A Delimiter (*nix: '/', windows: '\\')
 private:
 …
   std::vector<std::string>    _fileNames;       //!< The List of Files contained in the directory. (will be filled when open was called.)
 };
+File operator+(const Directory& dir, const File& file);
 #endif /* __DIRECTORY_H_ */

trunk/src/lib/util/filesys/file.cc

r8619	r9869
326	326	}
327	327
	328	/**
	329	* @brief converts an Absolute Filename to a Relative one
	330	* @param absFileName the FileName to convert. The Relative path will be stored in absFileName.
	331	*/
328	332	void File::absToRel(std::string& absFileName)
329	333	{

trunk/src/lib/util/loading/dynamic_loader.cc

-                      r9406
+                      r9869
+ObjectListDefinition(DynamicLoader);
 /**
 …
 */
 DynamicLoader::DynamicLoader (const std::string& libName)
     : Factory(NULL, CL_NULL)
+    : Factory(libName)
+{
   this->setClassID(CL_DYNAMIC_LOADER, "DynamicLoader");
+  this->registerObject(this, DynamicLoader::_objectList);
   this->handle = NULL;

trunk/src/lib/util/loading/dynamic_loader.h

r7193	r9869
19	19	class DynamicLoader : public Factory
20	20	{
	21	ObjectListDeclaration(DynamicLoader);
21	22
22	23	public:

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

-                      r9675
+                      r9869
 #define DEBUG_SPECIAL_MODULE DEBUG_MODULE_LOADING
 #include "util/loading/factory.h"
+#include "factory.h"
 #include "debug.h"
 //#include "shell_command.h"
+ObjectListDefinition(Factory);
 //SHELL_COMMAND(create, Factory, fabricate);
 …
  * set everything to zero and define factoryName
  */
 Factory::Factory (const std::string& factoryName, ClassID classID)
     : classID(classID), className(factoryName)
+Factory::Factory (const ClassID& classID)
+    : _classID(classID)
+{
+  this->setClassID(CL_FACTORY, "Factory");
+  this->setName(factoryName);
+  PRINTF(4)("Factory::create(%s::%d)\n", classID.name().c_str(), classID.id());
+  //this->registerObject(this, Factory::_objectList);
+  this->setName(classID.name());
+  if( Factory::factoryList == NULL)
+    Factory::factoryList = new std::list<Factory*>;
+  Factory::factoryList->push_back(this);
+  Factory::_factoryIDMap[classID] = this;
+  Factory::_factoryStringMap[classID.name()] = this;
+}
+/** @brief a reference to the First Factory */
+std::list<Factory*>* Factory::factoryList = NULL;
+/** @brief A Map of all Factories ordered by ID. */
+Factory::FactoryIDMap Factory::_factoryIDMap;
+/** @brief A Map of all Factories ordered by Name. */
+Factory::FactoryStringMap Factory::_factoryStringMap;
 /**
 …
 Factory::~Factory ()
+{
+  //  printf("%s\n", this->factoryName);
+  //  Factory* tmpDel = this->next;
+  //  this->next = NULL;
+}
+  FactoryIDMap::iterator it = Factory::_factoryIDMap.find(this->_classID);
+  if (it != Factory::_factoryIDMap.end() && (*it).second == this)
+    Factory::_factoryIDMap.erase(it);
+/**
+ * @brief deletes all the Factories. (cleanup)
+ */
+void Factory::deleteFactories()
+{
+  if (Factory::factoryList != NULL)
+  {
+    while(!Factory::factoryList->empty())
+    {
+      delete Factory::factoryList->front();
+      Factory::factoryList->pop_front();
+    }
+    delete Factory::factoryList;
+    Factory::factoryList = NULL;
+  }
+  FactoryStringMap::iterator stringIt = Factory::_factoryStringMap.find(this->_classID.name());
+  if (stringIt != Factory::_factoryStringMap.end() && (*stringIt).second == this)
+    Factory::_factoryStringMap.erase(stringIt);
+}
 …
  * @returns true on match, false otherwise
  */
 bool Factory::operator==(ClassID classID) const
+bool Factory::operator==(int classID) const
+{
   return (this->classID == classID);
+  return (this->_classID == classID);
+}
-/**
- * @brief Compares the Factories Name against a given ClassName
- * @param className the Name of the Class to Query
- * @returns true on match, false otherwise.
- */
-bool Factory::operator==(const char* className) const
+{
-  return (className != NULL && this->className == className);
+}
 /**
 …
 bool Factory::operator==(const std::string& className) const
+{
   return (this->className == className);
+  return (this->_classID.name() == className);
+}
 …
 BaseObject* Factory::fabricate(const TiXmlElement* root)
+{
+  assert (root != NULL && Factory::factoryList != NULL);
+  std::list<Factory*>::const_iterator factory;
+  for (factory = Factory::factoryList->begin(); factory != Factory::factoryList->end(); factory++)
+    if (*(*factory) == root->Value())
+    {
+      PRINTF(2)("Create a new Object of type %s\n", (*factory)->getCName());
+      return (*factory)->fabricateObject(root);
+    }
+  PRINTF(2)("Could not Fabricate an Object of Class '%s'\n", root->Value());
+  return NULL;
+  FactoryStringMap::const_iterator it = Factory::_factoryStringMap.find(root->Value());
+  if (it != Factory::_factoryStringMap.end())
+  {
+    PRINTF(2)("Create a new Object of type %s\n", (*it).second->getCName());
+    return (*it).second->fabricateObject(root);
+  }
+  else
+  {
+    PRINTF(2)("Could not Fabricate an Object of Class '%s'\n", root->Value());
+    return NULL;
+  }
+}
 …
 BaseObject* Factory::fabricate(const std::string& className)
+{
+  if (Factory::factoryList == NULL)
+  FactoryStringMap::const_iterator it = Factory::_factoryStringMap.find(className);
+  if (it != Factory::_factoryStringMap.end())
+  {
+    PRINTF(2)("Create a new Object of type %s\n", (*it).second->getCName());
+    return (*it).second->fabricateObject(NULL);
+  }
+  else
+  {
+    PRINTF(2)("Could not Fabricate an Object of Class '%s'\n", className.c_str());
     return NULL;
+  std::list<Factory*>::const_iterator factory;
+  for (factory = Factory::factoryList->begin(); factory != Factory::factoryList->end(); factory++)
+    if (*(*factory) == className)
+    {
+      PRINTF(4)("Create a new Object of type %s\n", (*factory)->getCName());
+      return (*factory)->fabricateObject(NULL);
+    }
+  PRINTF(2)("Could not Fabricate an Object of Class '%s'\n", className.c_str());
+  return NULL;
+  }
+}
 /**
 …
  * @returns a new Object of Type classID on match, NULL otherwise
  */
 BaseObject* Factory::fabricate(ClassID classID)
+BaseObject* Factory::fabricate(const ClassID& classID)
+{
+  if (Factory::factoryList == NULL)
+  FactoryIDMap::const_iterator it = Factory::_factoryIDMap.find(classID);
+  if (it != Factory::_factoryIDMap.end())
+  {
+    PRINTF(4)("Create a new Object of type %s\n", (*it).second->getCName());
+    return (*it).second->fabricateObject(NULL);
+  }
+  else
+  {
+    PRINTF(2)("Could not Fabricate an Object of ClassID '%d'\n", classID.id());
     return NULL;
+  }
+}
-  std::list<Factory*>::const_iterator factory;
-  for (factory = Factory::factoryList->begin(); factory != Factory::factoryList->end(); factory++)
-    if (*(*factory) == classID)
+    {
-      PRINTF(4)("Create a new Object of type %s\n", (*factory)->getCName());
-      return (*factory)->fabricateObject(NULL);
+    }
+  PRINTF(2)("Could not Fabricate an Object of ClassID '0x%h'\n", classID);
+  return NULL;
+/**
+ * @brief print out some nice litte debug information about the Factory.
+ */
+void Factory::debug() const
+{
+  PRINTF(0)("Factory of class '%s' with ClassID: %d\n", this->_classID.name().c_str(), this->_classID.id());
+}
+/**
+ * @brief Prints out some nice Debug information about all factories
+ */
+void Factory::debugAll()
+{
+  PRINTF(0)("Debugging all %d Factories\n", Factory::_factoryStringMap.size());
+  Factory::FactoryStringMap::const_iterator it;
+  for (it = Factory::_factoryStringMap.begin(); it != Factory::_factoryStringMap.end(); ++it)
+    (*it).second->debug();
+}

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

-                      r8148
+                      r9869
 #ifndef _FACTORY_H
 #define _FACTORY_H
+#ifndef __FACTORY_H
+#define __FACTORY_H
 class BaseObject;
 …
 #include "parser/tinyxml/tinyxml.h"
 #include "base_object.h"
+#include <vector>
+#include <list>
+#include <map>
 /**
 …
  * this should be used at the beginning of all the Classes that should be loadable (in the cc-file)
  */
 #define CREATE_FACTORY(CLASS_NAME, CLASS_ID) \
     tFactory<CLASS_NAME>* global_##CLASS_NAME##_Factory = new tFactory<CLASS_NAME>(#CLASS_NAME, CLASS_ID)
+#define CREATE_FACTORY(CLASS_NAME) \
+    tFactory<CLASS_NAME> global_##CLASS_NAME##_Factory = tFactory<CLASS_NAME>(CLASS_NAME::staticClassID())
 //! The Factory is a loadable object handler
+class Factory : public BaseObject {
+ public:
+class Factory : public BaseObject
+{
+  //! Declare the ObjectList at the BaseObject List
+  ObjectListDeclaration(Factory);
+public:
   virtual ~Factory ();
+  static void deleteFactories();
+  static  BaseObject* fabricate(const std::string& className);
+  static  BaseObject* fabricate(const ClassID& classID);
+  static  BaseObject* fabricate(const TiXmlElement* root);
+  static  BaseObject* fabricate(const std::string& className);
+  static  BaseObject* fabricate(ClassID classID);
+  static  BaseObject* fabricate(const TiXmlElement* root = NULL);
+  bool operator==(int classID) const;
+  bool operator==(const std::string& className) const;
+  /** @param classID the ID to compare @returns true if the ID's match */
+  bool operator==(const ClassID& classID) const { return _classID == classID; };
+  bool operator==(ClassID classID) const;
+  bool operator==(const char* className) const;
+  bool operator==(const std::string& className) const;
+  void debug() const;
+  static void debugAll();
+  protected:
+    Factory (const std::string& factoryName, ClassID classID);
+    virtual BaseObject* fabricateObject(const TiXmlElement* root = NULL) const = 0;
+protected:
+  Factory (const ClassID& id);
+  /**
+   * @brief The core function of the Factory. Creates objects of the Factories Type.
+   * @param root The TiXmlElement of the Factory.
+   * @returns the created Object in BaseType* format.
+   */
+  virtual BaseObject* fabricateObject(const TiXmlElement* root = NULL) const = 0;
+  protected:
+    const ClassID                 classID;              //!< The Class-Identifyer of the Factory.
+    const std::string             className;            //!< The name of the Class.
+    static std::list<Factory*>*   factoryList;          //!< List of Registered Factories
+private:
+  //! Copy Constructor is hidden.
+  Factory (const Factory&) {};
+protected:
+  /** The Type of the FactoryMap that is sorted by ID */
+  typedef std::map<const ClassID, Factory*>  FactoryIDMap;
+  /** The Type of the FactoryMap that is sorted by Name */
+  typedef std::map<std::string, Factory*>    FactoryStringMap;
+  const ClassID                 _classID;              //!< The Class-Identifyer of the Factory.
+  static FactoryIDMap           _factoryIDMap;         //!< List of Registered Factories
+  static FactoryStringMap       _factoryStringMap;     //!< List of Registered Factories
 };
 …
 template<class T> class tFactory : public Factory
+{
+ public:
+ /**
+  * @brief creates a new type Factory to enable the loading of T
+  * @param factoryName the Name of the Factory to load.
+  * @param classID the ID of the Class to be created.
+  */
+  tFactory (const char* factoryName, ClassID classID)
+   : Factory(factoryName, classID)
+public:
+  /**
+   * @brief creates a new type Factory to enable the loading of T
+   * @param classID the ID of the Class to be created.
+   */
+  tFactory (const ClassID& classID)
+      : Factory(classID)
   {  }
+  /**
+   * @brief copy constructor
+   * @param factory the Factory to copy
+   */
+  tFactory (const tFactory& factory) : Factory(factory._classID) {};
+  private:
+   /**
+    * @brief fabricates an Object of type T, with the constructor T::T(const TiXmlElemnt*)
+    * @param root the TiXmlElement T should load parameters from.
+    * @return the newly fabricated T.
+    */
+    virtual BaseObject* fabricateObject(const TiXmlElement* root = NULL) const
+    {
+      return new T(root);
+    }
+  /**
+   * @brief fabricates an Object of type T, with the constructor T::T(const TiXmlElemnt*)
+   * @param root the TiXmlElement T should load parameters from.
+   * @return the newly fabricated T.
+   */
+  virtual BaseObject* fabricateObject(const TiXmlElement* root = NULL) const
+  {
+    return new T(root);
+  }
 };

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

-                      r9110
+                      r9869
 #include "game_loader.h"
 #include "util/loading/load_param.h"
 #include "shell_command.h"
+#include "util/loading/resource_manager.h"
+#include "debug.h"
 #include "campaign.h"
-#include "util/loading/resource_manager.h"
 #include "key_mapper.h"
+SHELL_COMMAND(quit, GameLoader, stop)
+->describe("quits the game")
+->setAlias("orxoquit");
+ObjectListDefinition(GameLoader);
 GameLoader* GameLoader::singletonRef = NULL;
 …
 GameLoader::GameLoader ()
+{
   this->setClassID(CL_GAME_LOADER, "GameLoader");
+  this->registerObject(this, GameLoader::_objectList);
   this->setName("GameLoader");
   this->bRun = true;
 …
     delete this->currentCampaign;
   this->currentCampaign = NULL;
   GameLoader::singletonRef = NULL;
+}
 …
+{
   ErrorMessage errorCode;
   std::string campaignName = ResourceManager::getFullName(fileName);
+  std::string campaignName = Resources::ResourceManager::getInstance()->prependAbsoluteMainPath(fileName);
   if (!campaignName.empty())
+  {
 …
+{
   ErrorMessage errorCode;
   std::string campaignName = ResourceManager::getFullName(fileName);
+  std::string campaignName = Resources::ResourceManager::getInstance()->prependAbsoluteMainPath(fileName);
   if (!campaignName.empty())
+  {

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

-                      r7868
+                      r9869
 class GameLoader : public EventListener
+{
+ public:
+  ObjectListDeclaration(GameLoader);
+  public:
   virtual ~GameLoader ();
   /**  this class is a singleton class @returns an instance of itself  */

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

-                      r9406
+                      r9869
 #define DEBUG_SPECIAL_MODULE DEBUG_MODULE_LOADING
+#include "util/loading/load_param.h"
+#include "load_param_description.h"
+#include <stdarg.h>
+#include "load_param.h"
+#include "load_param_class_description.h"
+#include "compiler.h"
+#include "debug.h"
 /**
  * Constructs a new LoadParameter
+ * @brief Constructs a new LoadParameter
  * @param root the XML-element to load this Parameter from
  * @param paramName the Parameter to load
+ * @param object the BaseObject, to load this parameter on to (will be cast to executor's Parameter)
+ * @param executor the Executor, that executes the loading procedure.
+ * @param inLoadCycle If we are in a LoadCycle (loading differs.).
  */
 CLoadParam::CLoadParam(const TiXmlElement* root, const std::string& paramName, BaseObject* object, Executor* executor, bool inLoadCycle)
   :  object(object), paramName(paramName)
+LoadParamBase::LoadParamBase(const TiXmlElement* root, const std::string& paramName, bool inLoadCycle)
+    :  paramName(paramName), inLoadCycle(inLoadCycle)
+{
-  this->inLoadCycle = inLoadCycle;
   // determin the LoadString.
   if (likely(!inLoadCycle))
 …
   else
     this->loadElem = NULL;
+}
-  // set the Executor.
-  this->executor = executor;
+  //if (this->executor)
+  //  this->executor->setName(paramName);
+/**
+ * @param classID the ID of the class. This is needed to identify into what class this Parameter belongs.
+ * @param descriptionText The text to set as a description for this Parameter
+ * @returns a pointer to itself.
+ */
+void LoadParamBase::describe(const ClassID& classID, const std::string& descriptionText)
+{
+  PRINTF(5)("Describing Class '%s'(id:%d) Parameter '%s': description '%s'\n",
+            classID.name().c_str(), classID.id(), paramName.c_str(), descriptionText.c_str());
+  if (LoadParamClassDescription::descriptionsCaptured())
+    LoadParamClassDescription::describeClass(classID, paramName, descriptionText);
+}
 /**
+ * This is a VERY SPECIAL deconsrtuctor.
+ * It is made, so that it loads the Parameters on destruction.
+ * meaning, if an Executor a valid Object exist, and all
+ * Execution-Conditions are met, they are executed here.
+ * @brief sets the Values of the Description to a usefull text.
  */
 CLoadParam::~CLoadParam()
+void LoadParamBase::setDescriptionValues(const ClassID& classID, unsigned int paramCount, const MultiType* const defaultValues, bool retVal)
+{
+  if (likely(this->executor != NULL))
+  {
+    std::string loadString = "";
+    if (this->loadElem != NULL &&  this->loadElem->ToText())
+      loadString = this->loadElem->Value();
+    if (likely(this->object != NULL) &&
+        ( !loadString.empty() ||
+          ((this->executor->getType() & Executor_NoLoadString) == Executor_NoLoadString)))
+    {
+      PRINTF(4)("Loading value '%s' with Parameters '%s' onto: %s::%s\n", this->paramName.c_str(), loadString.c_str(), this->object->getClassCName(), this->object->getCName());
+      (*this->executor)(this->object, SubString(loadString, ",", SubString::WhiteSpaces, false, '\\'));
+    }
+    delete this->executor;
+  }
+  if(LoadParamClassDescription::descriptionsCaptured())
+    LoadParamClassDescription::setValuesOf(classID, paramName, paramCount, defaultValues, retVal);
+}
-/**
- * @brief set the default values of the executor
- * @param value0 the first default value
- * @param value1 the second default value
- * @param value2 the third default value
- * @param value3 the fourth default value
- * @param value4 the fifth default value
- */
-CLoadParam& CLoadParam::defaultValues(const MultiType& value0, const MultiType& value1,
-                                      const MultiType& value2, const MultiType& value3,
-                                      const MultiType& value4)
+{
-  assert(this->executor != NULL);
-  this->executor->defaultValues(value0, value1, value2, value3, value4);
-  return *this;
+}
-/**
- * @param descriptionText The text to set as a description for this Parameter
- * @returns a pointer to itself.
-*/
-CLoadParam& CLoadParam::describe(const std::string& descriptionText)
+{
-  if (LoadClassDescription::parametersDescription && this->paramDesc && this->paramDesc->getDescription().empty())
+  {
-    this->paramDesc->setDescription(descriptionText);
+  }
-  return *this;
+}
-// const LoadParamDescription* LoadParamDescription::getClass(const char* className)
-// {
-//   tIterator<LoadClassDescription>* iterator = LoadClassDescription::classList->getIterator();
-//   LoadClassDescription* enumClassDesc = iterator->firstElement();
-//   while (enumClassDesc)
-//   {
-//     if (!strcmp(enumClassDesc->className, classNameBegin, className))
-//     {
-//       delete iterator;
-//       return enumClassDesc;
-//     }
-//     enumClassDesc = iterator->nextElement();
-//   }
-//   delete iterator;
-//
-//   return NULL;
-// }
-/*
- * @param object The object this Parameter is loaded too.
- * @param root: the XML-element to load this option from.
- * @param paramName: The name of the parameter loaded.
- * @param paramCount: how many parameters this loading-function takes
- * @param multi: if false LoadParam assumes only one occurence of this parameter in root, if true it assumes multiple occurences.
- * @param ...: the parameter information (1. Parameter, 2. Default Value for the Parameter, ...)
-*/
-/*LoadParam::LoadParam(const TiXmlElement* root, BaseObject* object, const char* paramName,
-                             int paramCount, bool multi, const void* pointerToParam, ...)
+{
-  this->setClassID(CL_LOAD_PARAM, "LoadParam");
-  this->executor = NULL;
-  this->loadString = NULL;
-  this->pointerToParam = pointerToParam;
-  if (paramCount == 0 || this->pointerToParam != NULL)
-    this->loadString = "none";
-  else
+{
-      if (likely(!multi))
-        this->loadString = grabParameter(root, paramName);
-      else
+{
-          if (!strcmp(root->Value(), paramName))
+{
-              const TiXmlNode* val = root->FirstChild();
-              if( val->ToText())
-                this->loadString = val->Value();
+}
+}
+}
-  this->paramDesc = NULL;
-  if (LoadClassDescription::parametersDescription)
+{
-    // locating the class
-    this->classDesc = LoadClassDescription::addClass(object->getClassCName());
-    if ((this->paramDesc = this->classDesc->addParam(paramName)) != NULL)
+{
-      this->paramDesc->paramCount = paramCount;
-      this->paramDesc->types = new int[paramCount];
-      this->paramDesc->defaultValues = new char*[paramCount];
-      va_list types;
-      va_start (types, pointerToParam);
-      char defaultVal[512];
-      for(int i = 0; i < paramCount; i++)
+{
-        defaultVal[0] = '\0';
-          // parameters parsed
-        int tmpType = va_arg (types, int);
-        this->paramDesc->types[i] = tmpType;
-        switch (tmpType)
+{
-  case MT_INT:
-            sprintf(defaultVal, "%d", va_arg(types, int));
-            break;
-//          case MT_LONG:
-//            sprintf(defaultVal, "%0.3f", va_arg(types, l_LONG_TYPE));
-//            break;
-  case MT_FLOAT:
-            sprintf(defaultVal, "%0.3f", va_arg(types, double));
-            break;
-  case MT_STRING:
-            sprintf(defaultVal, "%s", va_arg(types, l_STRING_TYPE));
-            break;
-  case MT_EXT1:
-            sprintf(defaultVal, "");
-            break;
+}
-        this->paramDesc->defaultValues[i] = new char[strlen(defaultVal)+1];
-        strcpy(this->paramDesc->defaultValues[i], defaultVal);
+}
-      va_end(types);
-      int argCount = 0;
+}
+}
-}*/
 …
  * @returns the Value of the parameter if found, NULL otherwise
 */
 std::string grabParameter(const TiXmlElement* root, const std::string& parameterName)
+std::string LoadParamBase::grabParameter(const TiXmlElement* root, const std::string& parameterName)
+{
+  const TiXmlElement* element;
+  const TiXmlNode* node;
+  if (root == NULL)
+    return "";
+  element = root->FirstChildElement( parameterName);
+  if( element == NULL) return "";
+  node = element->FirstChild();
+  while( node != NULL)
+  const TiXmlElement* const element = grabParameterElement(root, parameterName);
+  if (element != NULL)
+    return element->Value();
+  else
+  {
     if( node->ToText()) return node->Value();
     node = node->NextSibling();
+    static std::string empty("");
+    return empty;
+  }
-  return "";
+}
 …
  * @returns the Element of the parameter if found, NULL otherwise
  */
 const TiXmlElement* grabParameterElement(const TiXmlElement* root, const std::string& parameterName)
+const TiXmlElement* LoadParamBase::grabParameterElement(const TiXmlElement* root, const std::string& parameterName)
+{
   const TiXmlElement* element;
 …
   return NULL;
+}

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

-                      r8048
+                      r9869
 #define _LOAD_PARAM_H
+#include "base_object.h"
+#include "util/executor/executor_substring.h"
+#include "util/executor/executor_member.h"
+#include "util/executor/functor_member.h"
+#include "executor/executor.h"
+#include "executor/executor_xml.h"
+#include "parser/tinyxml/tinyxml.h"
 // Forward Declaration //
 class LoadClassDescription;
 class LoadParamDescription;
+class MultiType;
+class TiXmlElement;
 /**
  * Loads a Parameter from ROOT named PARAMETER_NAME
  * onto OBJECT of CLASS, trough the FUNCTION
+ * onto OBJECT of CLASS, trough FUNCTION
  * @param ROOT the TiXmlElement to load the Parameter from
  * @param PARAMETER_NAME the Name of the Parameter to load
 …
  */
 #define LoadParam(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
          CLoadParam(ROOT, PARAMETER_NAME, OBJECT, createExecutor<CLASS>(&CLASS::FUNCTION), false)
+         CLoadParam<CLASS>(ROOT, PARAMETER_NAME, OBJECT, createExecutor<CLASS, CLASS>(&CLASS::FUNCTION), false)
+/**
+ * @brief Does essentially the same as LoadParam, but within a Cycle in an ordered fashion.
+ *
+ * This Function looks in each Element, if the PARAMETER_NAME matches, and loads onto OBJECT
+ * of CLASS the ROOT through FUNCTION
+ *
+ * @see LoadParam(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION)
+ */
 #define LoadParam_CYCLE(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
+         CLoadParam(ROOT, PARAMETER_NAME, OBJECT, createExecutor<CLASS>(&CLASS::FUNCTION), true)
+#define LoadParamXML(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
+         CLoadParam(ROOT, PARAMETER_NAME, OBJECT, new ExecutorXML<CLASS>(&CLASS::FUNCTION, ROOT, PARAMETER_NAME), false)
+#define LoadParamXML_CYCLE(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
+         CLoadParam(ROOT, PARAMETER_NAME, OBJECT, new ExecutorXML<CLASS>(&CLASS::FUNCTION, ROOT, PARAMETER_NAME), true)
+         CLoadParam<CLASS>(ROOT, PARAMETER_NAME, OBJECT, createExecutor<CLASS, CLASS>(&CLASS::FUNCTION), true)
 /**
 …
+}
 /**************************
 **** REAL DECLARATIONS ****
 **************************/
 //! abstract Base class for a Loadable parameter
 class CLoadParam : public BaseObject
+//!< A BaseClass for all LoadParam's.
+class LoadParamBase
+{
+  public:
+    CLoadParam(const TiXmlElement* root, const std::string& paramName, BaseObject* object, Executor* executor, bool inLoadCycle = false);
+    virtual ~CLoadParam();
+protected:
+  LoadParamBase(const TiXmlElement* root, const std::string& paramName, bool inLoadCycle = false);
+    CLoadParam& describe(const std::string& descriptionText);
+    CLoadParam& defaultValues(const MultiType& value0 = MT_NULL, const MultiType& value1 = MT_NULL,
+                              const MultiType& value2 = MT_NULL, const MultiType& value3 = MT_NULL,
+                              const MultiType& value4 = MT_NULL);
+    CLoadParam& attribute(const std::string& attributeName, const Executor& executor);
+protected:
+  void describe(const ClassID& classID, const std::string& descriptionText);
+  void setDescriptionValues(const ClassID& classID, unsigned int paramCount, const MultiType* const defaultValues, bool retVal = false);
+public:
+  static std::string grabParameter(const TiXmlElement* root, const std::string& parameterName);
+  static const TiXmlElement* grabParameterElement(const TiXmlElement* root, const std::string& parameterName);
+protected:
+  const std::string        paramName;            //!< The Name of the Parameter this LoadParams applies to.
+  bool                     inLoadCycle;          //!< If the Parameter is in a LoadCycle.
+  const TiXmlElement*      loadElem;             //!< The Element to load.
+};
+  private:
+    bool                     inLoadCycle;
+    Executor*                executor;
+    BaseObject*              object;
+    const std::string        paramName;
+//! The Loading Class of the LoadParam, that acctually executes the loading process.
+template <class OperateClass> class CLoadParam : public LoadParamBase
+{
+public:
+  /**
+   * @brief generates a LoadParam based on:
+   * @param root the Root Element to load onto the object. @param paramName the Parameter name that is loaded.
+   * @param object the Object to apply the changes on. @param executor the Functional Object, that actually executes the function Call.
+   * @param inLoadCycle If we are inside of a loading cycle. (Loading will be different here)
+   */
+  CLoadParam(const TiXmlElement* root, const std::string& paramName, OperateClass* object, Executor<const SubString, OperateClass>* executor, bool inLoadCycle = false)
+      : LoadParamBase(root, paramName, inLoadCycle)
+  {
+    assert (executor != NULL);
+    this->object = object;
+    this->executor = executor;
+  }
+  virtual ~CLoadParam()
+  {
+    std::string loadString;
+    if (this->loadElem != NULL &&  this->loadElem->ToText())
+    {
+      loadString = this->loadElem->Value();
+      if (!loadString.empty())
+      {
+        /*      PRINTF(4)("Loading value '%s' with Parameters '%s' onto: %s::%s\n",
+                this->paramName.c_str(), loadString.c_str(), this->object->getClassCName(), this->object->getCName());*/
+        (*this->executor)(this->object, SubString(loadString, ",", SubString::WhiteSpaces, false, '\\'));
+      }
+    }
+    this->setDescriptionValues(OperateClass::staticClassID(), executor->getParamCount(), executor->getDefaultValues(), executor->hasRetVal());
+    delete this->executor;
+  }
+  /**
+   * @brief set the default values of the executor
+   * @param value0 the first default value   @param value1 the second default value
+   * @param value2 the third default value   @param value3 the fourth default value
+   * @param value4 the fifth default value
+   */
+  CLoadParam& defaultValues(const MultiType& value0 = MT_NULL, const MultiType& value1 = MT_NULL,
+                            const MultiType& value2 = MT_NULL, const MultiType& value3 = MT_NULL,
+                            const MultiType& value4 = MT_NULL)
+  { this->executor->defaultValues(value0, value1, value2, value3, value4); return *this;  };
+  //! Describes a LoadParam
+  CLoadParam& describe(const std::string& descriptionText) { LoadParamBase::describe(OperateClass::staticClassID(), descriptionText); return *this; };
+  //     CLoadParam& attribute(const std::string& attributeName, const Executor<SubString>& executor);
+    LoadClassDescription*    classDesc;            //!< The LoadClassDescription of this CLoadParameter
+    LoadParamDescription*    paramDesc;            //!< The LoadParameterDescription of this LoadParameter
+    const TiXmlElement*      loadElem;             //!< The Element to load.
+    const void*              pointerToParam;       //!< A Pointer to a Parameter.
+    MultiType*               defaultValue;
+private:
+  Executor<const SubString, OperateClass>*         executor;            //!< The Executor, that actually executes the Loading process.
+  OperateClass*                                    object;              //!< The Object this LoadParam operates on.
 };
-// helper function
-std::string grabParameter(const TiXmlElement* root, const std::string& parameterName);
-const TiXmlElement* grabParameterElement(const TiXmlElement* root, const std::string& parameterName);
 #endif /* _LOAD_PARAM_H */

trunk/src/lib/util/loading/load_param_description.cc

-                      r8362
+                      r9869
 #include "multi_type.h"
-#include <stdarg.h>
 #include "debug.h"
 /**
+ * @brief Creates a Description of a LoadParam
  * @param paramName the name of the parameter to load
  */
 LoadParamDescription::LoadParamDescription(const std::string& paramName)
+{
+  this->types = NULL;
+  this->defaultValues = NULL;
+  this->paramName = paramName;
+}
+/**
+ *  removes all the alocated memory
+ */
+LoadParamDescription::~LoadParamDescription()
+{
+  if (this->defaultValues != NULL)
+  {
+    for(int i = 0; i < this->paramCount; i++)
+    {
+      delete[] this->defaultValues[i];
+    }
+  }
+  delete[] this->types;
+  delete[] this->defaultValues;
+}
+    : _name(paramName), _parameterCount(0)
+{ }
 /**
 …
 void LoadParamDescription::setDescription(const std::string& descriptionText)
+{
   this->description = descriptionText;
+  this->_description = descriptionText;
+}
 /**
+ *  prints out this parameter, its input method and the description (if availiable)
+ * @brief sets the Values of the LoadParam in the Description.
+ * @param paramCount the count of arguments the underlying paramDescription takes.
+ * @param defaultValues the default Values the underlying parameter takes.
+ * @param retVal if the underlying parameter has a return value
  */
+void LoadParamDescription::print() const
+void LoadParamDescription::setValues(unsigned int paramCount,
+                                     const MultiType* const defaultValues,
+                                     bool retVal)
+{
   PRINT(3)(" <%s>", this->paramName.c_str());
   for (int i = 0; i < this->paramCount; i++)
+  this->_parameterCount = paramCount;
+  for (unsigned int i = 0; i < paramCount; ++i)
+  {
+    if (i > 0)
+      PRINT(3)(",");
+    // FIXME
+    //     switch (this->types[i])
+//     {
+//       default:
+//         PRINTF(3)("none");
+//         break;
+//       case ParameterBool:
+//         PRINT(3)("bool");
+//         break;
+//       case ParameterChar:
+//         PRINT(3)("char");
+//         break;
+//       case ParameterString:
+//         PRINT(3)("string");
+//         break;
+//       case ParameterInt:
+//         PRINT(3)("int");
+//         break;
+//       case ParameterUInt:
+//         PRINT(3)("Uint");
+//         break;
+//       case ParameterFloat:
+//         PRINT(3)("float");
+//         break;
+//       case ParameterLong:
+//         PRINT(3)("long");
+//         break;
+//       case ParameterXML:
+//         PRINT(3)("XML");
+//         break;
+//     }
+    this->_defaultValues.push_back(defaultValues[i].getString());
+    this->_types.push_back(MultiType::MultiTypeToString(defaultValues[i].getType()));
+  }
-  PRINT(3)("</%s>", this->paramName.c_str());
-  if (!this->description.empty())
-    PRINT(3)(" -- %s", this->description.c_str());
-  // default values
-  if (this->paramCount > 0)
+  {
-    PRINT(3)(" (Default: ");
-    for (int i = 0; i < this->paramCount; i++)
+    {
-      if (i > 0)
-        PRINT(3)(", ");
-      if (this->types[i] & MT_STRING)
-      { // leave brackets !!
-        PRINT(3)("\"%s\"", this->defaultValues[i]);
+      }
-      else
+      {
-        PRINT(3)("%s", this->defaultValues[i]);
+      }
+    }
-    PRINT(3)(")");
+  }
-  PRINT(3)("\n");
+}
-/**
- *  A list, that holds all the classes that are loadable (classes not objects!!)
- */
-std::list<LoadClassDescription*>* LoadClassDescription::classList = NULL;
-/**
- *  if the description of Parameters should be executed
- */
-bool LoadClassDescription::parametersDescription = false;
-/**
- * @param className the name of the class to be loadable
- */
-LoadClassDescription::LoadClassDescription(const std::string& className)
+{
-  this->className = className;
-  if (LoadClassDescription::classList == NULL)
-    LoadClassDescription::classList = new std::list<LoadClassDescription*>;
-  LoadClassDescription::classList->push_back(this);
+}
-/**
- *  deletes a classDescription (deletes all the parameterDescriptions as well
- */
-LoadClassDescription::~LoadClassDescription()
+{
-  std::list<LoadParamDescription*>::iterator it = this->paramList.begin();
-  while (!this->paramList.empty())
+  {
-    delete this->paramList.front();
-    this->paramList.pop_front();
+  }
+}
-void LoadClassDescription::deleteAllDescriptions()
+{
-  if (LoadClassDescription::classList != NULL)
+  {
-    while (!LoadClassDescription::classList->empty())
+    {
-      delete LoadClassDescription::classList->front();
-      LoadClassDescription::classList->pop_front();
+    }
-    delete LoadClassDescription::classList;
+  }
-  LoadClassDescription::classList = NULL;
+}
 /**
+ *  adds a class to the list of loadable classes
+ * @param className The name of the class to add
+   this function searches for the className string, and if found just returns the appropriate Class.
+   Otherwise it returns a new classDescription
+ * @brief prints out this parameter, its input method and the description (if availiable)
+ * @param stream the stream to print to.
+ * @param withComments if the comments should be appended.
  */
+LoadClassDescription* LoadClassDescription::addClass(const std::string& className)
+void LoadParamDescription::print(FILE* stream, bool withComments) const
+{
+  if (LoadClassDescription::classList != NULL)
+  fprintf(stream, " <%s>", this->_name.c_str());
+  for (unsigned int i = 0; i < this->_parameterCount; i++)
+  {
+    std::list<LoadClassDescription*>::iterator it = LoadClassDescription::classList->begin();
+    while (it != LoadClassDescription::classList->end())
+    if (i > 0)
+      fprintf(stream, ",");
+    fprintf(stream, "%s", this->_types[i].c_str());
+  }
+  fprintf(stream, "</%s>", this->_name.c_str());
+  // here the comments are printed out.
+  if (withComments)
+  {
+    if (!this->_description.empty())
+      fprintf(stream, " <!-- %s", this->_description.c_str());
+    // default values
+    if (this->_parameterCount > 0)
+    {
+      if ((*it)->className == className)
+      fprintf(stream, " (Default: ");
+      for (unsigned int i = 0; i < this->_parameterCount; i++)
+      {
+        return (*it);
+        if (i > 0)
+          fprintf(stream, ", ");
+        if (this->_types[i] == "string")
+        { // leave brackets !!
+          fprintf(stream, "\"%s\"", this->_defaultValues[i].c_str());
+        }
+        else
+        {
+          fprintf(stream, "%s", this->_defaultValues[i].c_str());
+        }
+      }
       it++;
+      fprintf(stream, ")");
+    }
+    if (!this->_description.empty() || this->_parameterCount > 0)
+      fprintf(stream, " -->");
+  }
   return new LoadClassDescription(className);
+  fprintf(stream, "\n");
+}
-/**
- *  does the same as addClass(const std::string& className), but with params
- * @param paramName the name of the parameter to add.
- */
-LoadParamDescription* LoadClassDescription::addParam(const std::string& paramName)
+{
-  std::list<LoadParamDescription*>::iterator it = this->paramList.begin();
-  while (it != this->paramList.end())
+  {
-    if ((*it)->paramName == paramName)
+    {
-      return NULL;
+    }
-    it++;
+  }
-  LoadParamDescription* newParam = new LoadParamDescription(paramName);
-  this->paramList.push_back(newParam);
-  return newParam;
+}
-/**
- *  prints out all loadable Classes, and their parameters
- * @param fileName prints the output to a File
- * @todo implement it
- */
-void LoadClassDescription::printAll(const std::string& fileName)
+{
-  PRINT(3)("===============================================================\n");
-  PRINT(3)(" Listing all the Loadable Options (loaded since Game started).\n\n");
-  if (LoadClassDescription::classList != NULL)
+  {
-    std::list<LoadClassDescription*>::iterator classDesc = LoadClassDescription::classList->begin();
-    while (classDesc != LoadClassDescription::classList->end())
+    {
-      PRINT(3)("<%s>\n", (*classDesc)->className.c_str());
-      std::list<LoadParamDescription*>::iterator param = (*classDesc)->paramList.begin();
-      while (param != (*classDesc)->paramList.end())
+      {
-        (*param)->print();
-        param++;
+      }
-      PRINT(3)("</%s>\n\n", (*classDesc)->className.c_str());
-      classDesc++;
+    }
+  }
-  else
-    PRINT(3)("no Classes defined so far\n");
-  PRINT(3)("===============================================================\n");
+}
-/**
- * searches for classes, which beginn with classNameBegin
- * @param classNameBegin the beginning string of a Class
- * @return a NEW char-array with ClassNames. The LIST should be deleted afterwards,
- * !! The strings MUST NOT be deleted !!
- */
-std::list<std::string> LoadClassDescription::searchClassWithShort(const std::string& classNameBegin)
+{
-  /// FIXME
-  // NOT USED
-/*  unsigned int searchLength = strlen(classNameBegin);
-  std::list<const std::string&> retVal;
-  tIterator<LoadClassDescription>* iterator = LoadClassDescription::classList->getIterator();
-  LoadClassDescription* enumClassDesc = iterator->firstElement();
-  while (enumClassDesc)
+  {
-    if (strlen(enumClassDesc->className)>searchLength+1 &&
-        !strncasecmp(enumClassDesc->className, classNameBegin, searchLength))
+    {
-      retVal->add(enumClassDesc->className);
+    }
-    enumClassDesc = iterator->nextElement();
+  }
-  delete iterator;
-  return retVal;*/
-  std::list<std::string> a;
-  return a;
+}

trunk/src/lib/util/loading/load_param_description.h

-                      r7221
+                      r9869
 /*!
  * @file load_param.h
+ * @file load_param_description.h
  * A Class and macro-functions, that makes our lives easy to load-in parameters
  */
 …
 #define _LOAD_PARAM_DESCRIPTION_H
 #include "base_object.h"
 #include <list>
+#include <vector>
+#include <string>
 // Forward Declaration //
 …
 class LoadParamDescription
+{
-  friend class LoadParam;
-  friend class LoadClassDescription;
 public:
+  LoadParamDescription(const std::string& paramName);
+  ~LoadParamDescription();
+  LoadParamDescription(const std::string& paramName = "");
+  //! Compares a LoadParamDescription with a String.
+  bool operator==(const std::string& paramName) const { return this->_name == paramName; };
+  //! Compares two LoadParamDescription
+  bool operator==(const LoadParamDescription& paramDescr) const { return this->_name == paramDescr._name; };
+  //! Compares two LoadParamDescription with the less operator
+  bool operator<(const LoadParamDescription& paramDescr) const { return this->_name < paramDescr._name; };
   void setDescription(const std::string& descriptionText);
+  void setValues(unsigned int paramCount,
+                 const MultiType* const defaultValues,
+                 bool retVal = false);
   /** @returns the descriptionString */
   const std::string& getDescription() { return this->description; };
+  const std::string& description() { return this->_description; };
   void print() const;
+  void print(FILE* stream = stdout, bool withComments = true) const;
 private:
+  std::string   paramName;             //!< The name of the parameter.
+  int           paramCount;            //!< The count of parameters.
+  int*          types;                 //!< What kind of parameters does this function take ??
+  std::string   description;           //!< A longer description about this function.
+  char**        defaultValues;         //!< The 'Default Values'. @TODO MAKE THIS A MULTITYPE
+};
+  std::string                _name;                  //!< The Name of the Parameter.
+  unsigned int               _parameterCount;        //!< The Count of parameters.
+  std::string                _description;           //!< A longer description about this function.
+//! A class for descriptions of a loadable module
+class LoadClassDescription
+{
+  friend class CLoadParam;
+public:
+  LoadClassDescription(const std::string& className);
+  ~LoadClassDescription();
+  static LoadClassDescription* addClass(const std::string& className);
+  LoadParamDescription* addParam(const std::string& paramName);
+  static void deleteAllDescriptions();
+  static void printAll(const std::string& fileName = "");
+  static std::list<std::string> searchClassWithShort(const std::string& classNameBegin);
+  //  static const LoadParamDescription* getClass(const std::string& className);
+private:
+  static bool                              parametersDescription;  //!< if parameter-description should be enabled.
+  static std::list<LoadClassDescription*>* classList;              //!< a list, that stores all the loadable classes. (after one instance has been loaded)
+  std::string                              className;              //!< name of the class
+  std::list<LoadParamDescription*>         paramList;              //!< List of parameters this class knows.
+  std::vector<std::string>   _types;                 //!< A Vector of types of this Parameter.
+  std::vector<std::string>   _defaultValues;         //!< A Vector of defaultValues of this Parameter.
 };

trunk/src/lib/util/loading/resource.cc

-                      r9406
+                      r9869
 */
 #define DEBUG_SPECIAL_MODULE DEBUG_MODULE_LOADING
+#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_LOAD
 #include "resource.h"
+/**
+ * standard constructor
+*/
+Resource::Resource (const std::string& fileName)
+#include "resource_manager.h"
+#include "debug.h"
+namespace Resources
+{
+//   this->setClassID(CL_RESOURCE, "Resource");
+  //! Define an ObjectList for the Resources
+  ObjectListDefinition(Resource);
+  /**
+   * @brief standard constructor
+   * @param type the Type this resource belongs to.
+   */
+  Resource::Resource (Type* type)
+      : _pointer(NULL), _type(type)
+  {
+    this->registerObject(this, Resource::_objectList);
+  }
+  /**
+   * @brief standard deconstructor
+   */
+  Resource::~Resource ()
+  {
+    // delete what has to be deleted here
+  }
+  /**
+   * @brief Locates a File inside of the Resources Paths and returns the appended path.
+   *
+   * @param fileName the Name of the file to look for.
+   * @returns the Name of the File prepended with the PAth it is in, if found, empty String ("") otherwise.
+   *
+   * This Function searches in (ordered):
+   * 1. mainGlobalPath (from ResourceManger)
+   * 2. all of the global Paths (from ResourceManger)
+   * 3. all of the Resources Paths (from Resources::Type)
+   *
+   * in each of these directory, first "./" is searched, and afterwards all of the subDirs (from Resources::Type) are searched.
+   *
+   * @todo finish it!!
+   */
+  std::string Resource::locateFile(const std::string& fileName) const
+  {
+    if ((ResourceManager::getInstance()->mainGlobalPath() + File(fileName)).exists() )
+      return (ResourceManager::getInstance()->mainGlobalPath() + File(fileName)).name();
+    std::string locatedFile;
+    locatedFile = locateFileInSubDir(ResourceManager::getInstance()->mainGlobalPath(), fileName);
+    if (!locatedFile.empty())
+    {
+      return locatedFile;
+    }
+    if (File(fileName).exists())
+      return fileName;
+    return (ResourceManager::getInstance()->mainGlobalPath() + File(fileName)).name();
+  }
+  /**
+   * @brief tests in all the SubDirectories defined in Resource under Directory if the fileName exists.
+   * @param directory the directory to in what to search for all subdirectories for.
+   * @param fileName the Name of the File to query for
+   * @return true on success.
+   */
+  std::string Resource::locateFileInSubDir(const Directory& directory, const std::string& fileName) const
+  {
+    std::vector<Directory>::const_iterator it;
+    for (it = this->_type->resourceSubPaths().begin(); it != this->_type->resourceSubPaths().end(); ++it)
+    {
+      Directory dir = directory + (*it);
+      File file = dir + File(fileName);
+      if ((dir+ File(fileName)).exists())
+        return (dir+File(fileName)).name();
+    }
+    return "";
+  }
+  /**
+   * @param loadString the Identifier of the Resource.
+   * @returns a Store-Pointer to the Resource if found, NULL otherwise
+   */
+  StorePointer* Resource::acquireResource(const std::string& loadString)
+  {
+    //const Type* const type = _resourceTypes[this->_type->id()];
+    for (unsigned int i = 0; i < _type->storedResources().size(); ++i)
+    {
+      if (_type->storedResources()[i]->loadString() == loadString)
+        return _type->storedResources()[i];
+    }
+    return NULL;
+  }
+  /**
+   * @brief registers a StorePointer to a Resource's Type.
+   * @param pointer the StorePointer to register.
+   */
+  void Resource::addResource(StorePointer* pointer)
+  {
+    assert(pointer != NULL);
+    this->_type->addResource(pointer);
+  }
+  ///////////////////
+  //// KEEPLEVEL ////
+  ///////////////////
+  //! Constructs a default KeepLevel as Set in the ResourceManager via setDefaultKeepLevel.
+  KeepLevel::KeepLevel()
+  {
+    this->_keepLevel = ResourceManager::getInstance()->defaultKeepLevel().keepLevel();
+  }
+  /**
+   * @param keepLevel the level to set.
+   */
+  KeepLevel::KeepLevel(unsigned int keepLevel)
+  {
+    _keepLevel = keepLevel;
+  }
+  /**
+   * @brief constructor of a KeepLevel.
+   * @param keepLevelName the Name of the KeepLevel. Must be one Name of the defined Names in the ResourceManager.
+   *
+   * @note the Name is transformed into an Integer for fast interpretation.
+   */
+  KeepLevel::KeepLevel(const std::string& keepLevelName)
+  {
+    this->_keepLevel = ResourceManager::getInstance()->getKeepLevelID(keepLevelName);
+  }
+  /**
+   * @returns the name of the KeepLevel.
+   */
+  const std::string& KeepLevel::name() const
+  {
+    return ResourceManager::getInstance()->getKeepLevelName(this->_keepLevel);
+  }
+  ///////////////////////
+  //// STORE POINTER ////
+  ///////////////////////
+  /**
+   * @brief allocates a StorePointer.
+   * @param loadString An identifier String that is unique between all resources of this type.
+   * @param keepLevel the KeepLevel at wich to keep this resource.
+   */
+  StorePointer::StorePointer(const std::string& loadString, const KeepLevel& keeplevel)
+      : _loadString(loadString), _keepLevel(keeplevel)
+  {
+    PRINTF(4)("Acquired a Resource with LoadString '%s' and KeepLevel '%s'\n", _loadString.c_str(), _keepLevel.name().c_str());
+  }
+  StorePointer::~StorePointer()
+  {
+    PRINTF(4)("Deleting Stored Resource '%s' from KeepLevel '%s'\n", _loadString.c_str(), _keepLevel.name().c_str());
+  };
+  //////////////
+  //// TYPE ////
+  //////////////
+  /**
+   * @brief allocates a Type.
+   * @param typeName the Name of the Type to be stored in this Container.
+   */
+  Type::Type(const std::string& typeName)
+      : _typeName(typeName)
+  {
+    ResourceManager::getInstance()->registerType(this);
+    PRINTF(4)("Created ResourceType '%s'\n", typeName.c_str());
+  }
+  //! Destructs a Type.
+  Type::~Type()
+  {
+    ResourceManager::getInstance()->unregisterType(this);
+  }
+  /**
+   * @brief adds a Resource to this Resource's type.
+   * @param resource the Resource to add.
+   */
+  void Type::addResource(StorePointer* resource)
+  {
+    this->_storedResources.push_back(resource);
+  }
+  /**
+   * @brief adds a Path to the Type's resource-paths.
+   * @param path the path-name to add.
+   */
+  bool Type::addResourcePath(const std::string& path)
+  {
+    std::vector<Directory>::const_iterator it;
+    for (it = this->_resourcePaths.begin(); it != this->_resourcePaths.end(); ++it)
+      if ((*it) == path)
+        return false;
+    this->_resourcePaths.push_back(path);
+    return true;
+  }
+  /**
+   * @brief Adds a SubPath to the Type's resource-subpaths.
+   * @param subPath the subpath to add.
+   */
+  bool Type::addResourceSubPath(const std::string& subPath)
+  {
+    std::vector<Directory>::const_iterator it;
+    for (it = this->_resourceSubPaths.begin(); it != this->_resourceSubPaths.end(); ++it)
+      if ((*it) == subPath)
+        return false;
+    this->_resourceSubPaths.push_back(subPath);
+    return true;
+  }
+  /**
+   * @brief Unloads all Resources below a certain Level.
+   * @param keepLevel the KeepLevel at what to remove the Resources from.
+   */
+  void Type::unloadAllBelowKeepLevel(const Resources::KeepLevel& keepLevel)
+  {
+    std::vector<Resources::StorePointer*>::iterator it, it2;
+    bool finished = false;
+    while (!finished)
+    {
+      finished = true;
+      for (it = this->_storedResources.begin(); it != this->_storedResources.end();++it)
+        if((*it)->keepLevel() < keepLevel && (*it)->last())
+        {
+          delete (*it);
+          this->_storedResources.erase(it);
+          finished = false;
+          break;
+        }
+    }
+  }
+  /**
+   * @brief print out some nice Debug information in a beatifully designed style
+   */
+  void Type::debug() const
+  {
+    PRINT(0)(" ResourceType '%s' stores %d Resources\n", this->_typeName.c_str(), this->_storedResources.size());
+    PRINT(0)("  Paths:\n");
+    for (unsigned int i = 0; i < this->_resourcePaths.size(); ++i)
+      PRINT(0)("    %s\n", this->_resourcePaths[i].name().c_str());
+    PRINT(0)("  Sub-Paths:");
+    for (unsigned int i = 0; i < this->_resourceSubPaths.size(); ++i)
+      PRINT(0)(" '%s'", this->_resourceSubPaths[i].name().c_str());
+    PRINT(0)("\n");
+    PRINT(0)("  Loaded Resources:\n");
+    std::vector<Resources::StorePointer*>::const_iterator it;
+    for (it = this->_storedResources.begin(); it != this->_storedResources.end(); ++it)
+      PRINT(0)("    '%s' : KeepLevel '%s'\n", (*it)->loadString().c_str(), (*it)->keepLevel().name().c_str());
+  }
+}
-/**
- * standard deconstructor
- */
-Resource::~Resource ()
+{
-  // delete what has to be deleted here
+}

trunk/src/lib/util/loading/resource.h

-                      r7195
+                      r9869
 #include "base_object.h"
-#include "multi_type.h"
 #include <string>
+#include <vector>
+#include <set>
+// FORWARD DECLARATION
+#include "filesys/directory.h"
+//! A Namespace Resources and ResourceHandling is defined in.
+namespace Resources
+{
+  //! The KeepLevel handles the unloading of Resources.
+  /**
+   * Allocating a Resource also appends a KeepLevel to the Resource.
+   * When the Resource is not used anymore it is decided on the grounds of the KeepLevel,
+   * if the Resource should be deleted. (e.g. at the end of a Level, Campaign, or something like this).
+   */
+  class KeepLevel
+  {
+  public:
+    KeepLevel();
+    KeepLevel(unsigned int keepLevel);
+    KeepLevel(const std::string& keepLevelName);
+    //! Compare equality
+    inline bool operator==(const KeepLevel& keepLevel) const { return this->_keepLevel == keepLevel._keepLevel; };
+    //! Compares inequality
+    inline bool operator!=(const KeepLevel& keepLevel) const { return this->_keepLevel != keepLevel._keepLevel; };
+    //! Compares less/equal than
+    inline bool operator<=(const KeepLevel& keepLevel) const { return this->_keepLevel <= keepLevel._keepLevel; };
+    //! Compares less than
+    inline bool operator<(const KeepLevel& keepLevel) const { return this->_keepLevel < keepLevel._keepLevel; };
+    /** @returns the KeepLevel as a number */
+    inline unsigned int keepLevel() const { return _keepLevel; };
+    const std::string& name() const;
+  private:
+    unsigned int                _keepLevel;              //!< The KeepLevel a Resource is in.
+  };
+  ///////////////////
+  // STORE POINTER //
+  ///////////////////
+  //! Stores a Resource-Pointer, the LoadString and it's keepLevel.
+  class StorePointer
+  {
+  public:
+    //! Virtual Destructor, that removes the Stored information-pointer.
+    virtual ~StorePointer();
+    /** @returns the LoadString this resource was loaded with */
+    const std::string& loadString() const { return _loadString; };
+    /** @returns the KeepLevel of this resource */
+    const Resources::KeepLevel& keepLevel() const { return _keepLevel; };
+    virtual bool last() const = 0;
+    protected:
+      StorePointer(const std::string& loadString, const Resources::KeepLevel& keeplevel);
+    private:
+      StorePointer(const StorePointer&) : _keepLevel(0) {};
+  private:
+    std::string                 _loadString;             //!< An identifier, to match when loading a File.
+    Resources::KeepLevel        _keepLevel;              //!< The Priority of this resource. (can only be increased, so none else will delete this)
+  };
+//! An enumerator for different (UN)LOAD-types.
+/**
+ * RP_NO:        will be unloaded on request
+ * RP_LEVEL:     will be unloaded at the end of a Level
+ * RP_CAMPAIGN:  will be unloaded at the end of a Campaign
+ * RP_GAME:      will be unloaded at the end of the whole Game (when closing orxonox)
+ */
+typedef enum ResourcePriority
+{
+  RP_NO        =   0,
+  RP_LEVEL     =   1,
+  RP_CAMPAIGN  =   2,
+  RP_GAME      =   3
+};
+  ///////////////////
+  // RESOURCE TYPE //
+  ///////////////////
+  //! A Type of Resources.
+  /**
+   * The Type is used to store the Pointers to already loaded Resources,
+   * and also to store type-specific properties.
+   * These are the Loading Paths, the subpaths and so on.
+   */
+  class Type
+  {
+  public:
+    virtual ~Type();
+    /** @returns true if the names match @param typeName the Name to compare. @brief compare the Type with a Name */
+    bool operator==(const std::string& typeName) const { return this->_typeName == typeName; };
+    ////////////////////
+    //// EXTENSIONS ////
+    void addExtension(const std::string& extension);
+    ///////////////
+    //// PATHS ////
+    bool addResourcePath(const std::string& path);
+    bool addResourceSubPath(const std::string& subPath);
+    /// Retrieve Functions
+    /** @returns the name of the stored Class this Type loads Resources for */
+    const std::string& storedClassName() const { return _typeName; };
+    /** @returns the ID of the Type != ClassID */
+    /** @returns the type-specific paths this Resource searches in. */
+    const std::vector<Directory>& resourcePaths() const { return _resourcePaths; };
+    /** @returns the Type specific SubPaths this Resource Searches in @see std::vector<std::string>  _resourceSubPaths */
+    const std::vector<Directory>& resourceSubPaths() const { return _resourceSubPaths; };
+    /** @returns the Pointers to the Stored resources. @note do not use this, for more than some lookup */
+    const std::vector<Resources::StorePointer*>& storedResources() const { return _storedResources; };
+    ///////////////////////////////
+    //// LOADING AND UNLOADING ////
+    virtual void createFromString(const std::string& loadString, const KeepLevel& keepLevel = KeepLevel()) = 0;
+    void unloadAllBelowKeepLevel(const Resources::KeepLevel& keepLevel);
+    ///////////////////
+    //// INTERNALS ////
+    void addResource(Resources::StorePointer* resource);
+    ///////////////
+    //// DEBUG ////
+    void debug() const;
+  protected:
+    Type(const std::string& typeName);
+  private:
+    Type(const Type& type) {};
+  private:
+    const std::string                     _typeName;          //!< Name of the Type. (Name of the Resource this loads.)
+    std::vector<Directory>                _resourcePaths;     //!< The Paths to search for files in this type
+    std::vector<Directory>                _resourceSubPaths;  //!< The subpaths that will be searched under all the _resourcePaths.
+    std::vector<std::string>              _fileExtensions;    //!< File Extensions, this Resource supports.
+    std::vector<Resources::StorePointer*> _storedResources;   //!< An array of all the stored Resources.
+  };
+  /**
+   * @brief A Type Definition Class for any Object that is resourceable.
+   *
+   * This Class's main reason of Existence is, that resources can be dynamically
+   * created over a loadString. For this the Type of Resource is required, and the Resource must
+   * itself support the 'void createFromString(const std::string&)' function.
+   */
+  template<class T> class tType : public Type
+  {
+  public:
+    /** Create the ResourceType @see Type(const std::string&) */
+    tType(const std::string& typeName) : Type(typeName) {};
+    /** @param loadString the String to load a Resource with @brief tries to create a Resource of Type T with a loadString */
+    virtual void createFromString(const std::string& loadString, const KeepLevel& keepLevel = KeepLevel()) { T::createFromString(loadString, keepLevel); }
+  };
+//! A Resource is an Object, that can be loaded from Disk
+/**
+ *
+ */
+class Resource : virtual public BaseObject {
+  /////////////////////
+  // RESOURCE ITSELF //
+  /////////////////////
+  //! A Resource is an Object, that can be loaded from Disk
+  /**
+   * The Resource Hanldes the location and stores pointers to data that can be retrieved.
+   */
+  class Resource : virtual public BaseObject
+  {
+    ObjectListDeclaration(Resource);
  public:
    Resource(const std::string& fileName);
   virtual ~Resource();
+  public:
+    Resource(Resources::Type* type);
+    virtual ~Resource();
+  virtual bool load(std::string& fileName, const MultiType& param1, const MultiType& param2);
+  virtual bool reload();
+  virtual bool unload();
+    /** @brief reloads the underlying resource */
+    virtual bool reload() { return false; };
+    /** @brief unloads the underlying Resource */
+    virtual bool unload() { return false; };
+ private:
+   std::string       fileName;
+    std::string locateFile(const std::string& fileName) const;
    unsigned int      referenceCount;    //!< How many times this Resource has been loaded.
+/// TODO REMOVE THIS:   ResourceType      type;              //!< ResourceType of this Resource.
    ResourcePriority  prio;              //!< The Priority of this resource. (can only be increased, so noone else will delete this)
+  protected:
+    Resources::StorePointer* acquireResource(const std::string& loadString);
+    void addResource(Resources::StorePointer* pointer);
+   MultiType         param[3];          //!< The Parameters given to this Resource.
+};
+  private:
+    std::string locateFileInSubDir(const Directory& directory, const std::string& fileName) const;
+  private:
+    Resources::StorePointer*       _pointer;                         //!< Virtual Pointer to the ResourceData.
+    Resources::Type*               _type;                            //!< Type of the Resource.
+  };
+}
 #endif /* _RESOURCE_H */

trunk/src/lib/util/loading/resource_manager.cc

-                      r9406
+                      r9869
 #define DEBUG_SPECIAL_MODULE DEBUG_MODULE_LOAD
+#include "util/loading/resource_manager.h"
+#include "substring.h"
+#include "resource_manager.h"
 #include "debug.h"
 #include <algorithm>
+#include <assert.h>
+// different resource Types
+#ifndef NO_MODEL
+#include "objModel.h"
+#include "primitive_model.h"
+#include "md2/md2Model.h"
+#include "md3/md3_data.h"
+#include "md3/md3_animation_cfg.h"
+#endif /* NO_MODEL */
+#ifndef NO_TEXTURES
+#include "texture.h"
+#endif /* NO_TEXTURES */
+#ifndef NO_TEXT
+#include "font.h"
+#endif /* NO_TEXT */
+#ifndef NO_AUDIO
+#include "sound_buffer.h"
+#include "ogg_player.h"
+#endif /* NO_AUDIO */
+#ifndef NO_SHADERS
+#include "shader.h"
+#endif /* NO_SHADERS */
+// File Handling Includes
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+/**
+ * @brief standard constructor
+*/
+ResourceManager::ResourceManager ()
+#include <cassert>
+namespace Resources
+{
+  this->setClassID(CL_RESOURCE_MANAGER, "ResourceManager");
+  this->setName("ResourceManager");
+  this->dataDir = "./";
+  this->tryDataDir("./data");
+  /// Definition of the ResourceManager's ObjectList.
+  ObjectListDefinition(ResourceManager);
+  //! Singleton Reference to the ResourceManager
+  ResourceManager* ResourceManager::_singletonRef = NULL;
+  /**
+   * @brief standard constructor
+  */
+  ResourceManager::ResourceManager ()
+  : _defaultKeepLevel(0)
+  {
+    this->registerObject(this, ResourceManager::_objectList);
+    this->setName("ResourceManager");
+    this->_mainGlobalPath = Directory("./");
+  }
+  /**
+   * @brief standard destructor
+  */
+  ResourceManager::~ResourceManager ()
+  {
+    this->unloadAllBelowKeepLevel(this->_keepLevelNames.size());
+    ResourceManager::_singletonRef = NULL;
+  }
+  /**
+   * @brief Registers a new Type to the ResourceManager.
+   * @param type the Type to register.
+   */
+  void ResourceManager::registerType(Resources::Type* type)
+  {
+    this->_resourceTypes.push_back(type);
+    PRINTF(5)("ResourceType '%s' added\n", type->storedClassName().c_str());
+  }
+  /**
+   * @brief Unregisters a new Type to the ResourceManager.
+   * @param type the Type to unregister.
+   */
+  void ResourceManager::unregisterType(Resources::Type* type)
+  {
+    std::vector<Resources::Type*>::iterator it = std::find (this->_resourceTypes.begin(), this->_resourceTypes.end(), type);
+    if (it != this->_resourceTypes.end())
+    {
+      this->_resourceTypes.erase(it);
+      PRINTF(5)("ResourceType '%s' removed\n", type->storedClassName().c_str());
+    }
+  }
+  /**
+   * @brief Sets the main Global path (the main path Resources are searched for)
+   * @param directory the directory to set.
+   * @see Resource::locateFile
+   */
+  void ResourceManager::setMainGlobalPath(const Directory& directory)
+  {
+    this->_mainGlobalPath = directory;
+    this->_mainGlobalPath.open();
+  }
+  /**
+   * @brief add a Global search path. (global paths besided the main path.)
+   * @param directory a directory to add.
+   */
+  void ResourceManager::addGlobalPath(const Directory& directory)
+  {
+    std::vector<Directory>::const_iterator it = std::find(this->_globalPaths.begin(), this->_globalPaths.end(), directory);
+    if (it == this->_globalPaths.end())
+      this->_globalPaths.push_back(directory);
+  }
+  /**
+   * @brief add a ResourcePath to a Type's Paths.
+   * @param resourceName the Type's name of Resource to add the path to.
+   * @param pathName pathName the Name of the path to add.
+   * @return true on success. (if a path was added (no duplicate, and resourceName existed).
+   */
+  bool ResourceManager::addResourcePath(const std::string& resourceName, const std::string& pathName)
+  {
+    std::vector<Resources::Type*>::iterator it;
+    for (it = this->_resourceTypes.begin(); it != this->_resourceTypes.end(); ++it)
+      if (*(*it) == resourceName)
+        return (*it)->addResourcePath(pathName);
+    PRINTF(2)("ResourcePath %s could not be added to the ResourceType %s\n", pathName.c_str(), resourceName.c_str());
+    return false;
+  }
+  /**
+   * @brief add a ResourcePath to a Type's SubPaths.
+   * @param resourceName the Type's name of Resource to add the subpath to.
+   * @param pathName pathName the Name of the path to add.
+   * @return true on success. (if a path was added (no duplicate, and resourceName existed).
+   */
+  bool ResourceManager::addResourceSubPath(const std::string& resourceName, const std::string& pathName)
+  {
+    std::vector<Resources::Type*>::iterator it;
+    for (it = this->_resourceTypes.begin(); it != this->_resourceTypes.end(); ++it)
+      if (*(*it) == resourceName)
+        return (*it)->addResourceSubPath(pathName);
+    PRINTF(2)("ResourceSubPath %s could not be added to the ResourceType %s\n", pathName.c_str(), resourceName.c_str());
+    return false;
+  }
+  /**
+   * @brief checks wether a File is inside of the MainPath.
+   * @param fileInside the file to check
+   * @return true if the file is inside.
+   */
+  bool ResourceManager::checkFileInMainPath(const File& fileInside)
+  {
+    return (this->_mainGlobalPath + fileInside).exists();
+  }
+  /**
+   * @brief prepends the fileName by the MainGlobalPath (same as mainGlobalPath + '/' + fileName).
+   * @param fileName The FileName to prepend
+   * @returns the prepended file-name
+   */
+  std::string ResourceManager::prependAbsoluteMainPath(const std::string& fileName)
+  {
+    return (this->_mainGlobalPath + File(fileName)).name();
+  }
+  /**
+   * @brief add a KeepLevelName (this function just counts upwards).
+   * @param keepLevelName the Name of the KeepLevel to set.
+   * @returns the Level the Name was set to.
+   */
+  unsigned int ResourceManager::addKeepLevelName(const std::string& keepLevelName)
+  {
+    this->_keepLevelNames.push_back(keepLevelName);
+    return _keepLevelNames.size()-1;
+  }
+  /**
+   * @param keepLevelName the Name of the KeepLevel.
+   * @returns the ID of the KeepLevel named keepLevelName
+   */
+  unsigned int ResourceManager::getKeepLevelID(const std::string& keepLevelName) const
+  {
+    for (unsigned int i = 0; i < this->_keepLevelNames.size(); ++i)
+      if (this->_keepLevelNames[i] == keepLevelName)
+        return i;
+    PRINTF(2)("KeepLevel '%s' not found. Using 0 instead\n", keepLevelName.c_str());
+    return 0;
+  }
+  /**
+   * @param keepLevelID the ID to check.
+   * @return the name of the KeepLevel.
+   */
+  const std::string& ResourceManager::getKeepLevelName(unsigned int keepLevelID) const
+  {
+    assert(keepLevelID < this->_keepLevelNames.size());
+    return this->_keepLevelNames[keepLevelID];
+  }
+  /**
+   * @brief loads a Resource from a TypeName and a loadString.
+   * @param resourceTypeName The Name of the Type to what to load a Resource from.
+   * @param loadString the loadString to load in the Type.
+   */
+  void ResourceManager::loadFromLoadString(const std::string& resourceTypeName, const std::string& loadString, const KeepLevel& keepLevel)
+  {
+    std::vector<Resources::Type*>::const_iterator it;
+    for (it = this->_resourceTypes.begin(); it != this->_resourceTypes.end(); ++it)
+    {
+      if (*(*it) == resourceTypeName)
+      {
+        (*it)->createFromString(loadString, keepLevel);
+        /// TODO check if the resource was allocated!!
+        return ;
+      }
+    }
+    return ;
+  }
+  /**
+   * @brief unloads all Resources below a certain threshhold.
+   * @param keepLevel the KeepLevel below which to erase.
+   *
+   * @not Resources will only be erased, if th keepLevel is below, and the resources are not
+   * referenced anymore.
+   */
+  void ResourceManager::unloadAllBelowKeepLevel(const Resources::KeepLevel& keepLevel)
+  {
+    std::vector<Resources::Type*>::const_iterator it;
+    for (it = this->_resourceTypes.begin(); it != this->_resourceTypes.end(); ++it)
+    {
+      (*it)->unloadAllBelowKeepLevel(keepLevel);
+    }
+  }
+  /**
+   * @brief outputs debug information about the ResourceManager
+   */
+  void ResourceManager::debug() const
+  {
+    PRINT(0)("/==RM================================\\\n");
+    PRINT(0)("| RESOURCE-MANAGER DEBUG INFORMATION |\n");
+    PRINT(0)("\\====================================/\n");
+    PRINT(0)(" MainGlobal search path is %s\n", this->_mainGlobalPath.name().c_str());
+    if(!this->_globalPaths.empty())
+    {
+      PRINT(0)(" Additional Global search Paths are: ");
+      for (unsigned int i = 0; i < this->_globalPaths.size(); ++i)
+        PRINT(0)("'%s' ", this->_globalPaths[i].name().c_str());
+      PRINT(0)("\n");
+    }
+    PRINT(0)(" Listing %d Types: \n", this->_resourceTypes.size());
+    std::vector<Resources::Type*>::const_iterator it;
+    for (it = this->_resourceTypes.begin(); it != this->_resourceTypes.end(); ++it)
+    {
+      (*it)->debug();
+      if (it != --this->_resourceTypes.end())
+        PRINT(0)(" ------------------------------------\n ");
+    }
+    PRINT(0)("KeepLevels are: ");
+    for (unsigned int i = 0; i < this->_keepLevelNames.size(); ++i)
+      PRINT(0)("%d:'%s'  ", i, this->_keepLevelNames[i].c_str());
+    PRINT(0)("\n");
+    PRINT(0)("=================================RM==/\n");
+  }
+}
-//! Singleton Reference to the ResourceManager
-ResourceManager* ResourceManager::singletonRef = NULL;
-/**
- * @brief standard destructor
-*/
-ResourceManager::~ResourceManager ()
+{
-  // deleting the Resources-List
-  this->unloadAllByPriority(RP_GAME);
-  if (!this->resourceList.empty())
-    PRINTF(1)("Not removed all Resources, since there are still %d resources registered\n", this->resourceList.size());
-  ResourceManager::singletonRef = NULL;
+}
-/**
- * @brief sets the data main directory
- * @param dataDir the DataDirectory.
- */
-bool ResourceManager::setDataDir(const std::string& dataDir)
+{
-  File dataDirectory(dataDir);
-  if (dataDirectory.isDirectory())
+  {
-    this->dataDir = dataDirectory.name();
-    if (dataDir[dataDir.size()-1] != '/' && dataDir[dataDir.size()-1] != '\\')
+    {
-      this->dataDir += '/';
+    }
-    return true;
+  }
-  else
+  {
-    PRINTF(1)("%s is not a Directory, and can not be the Data Directory, leaving as %s \n", dataDir.c_str(), this->dataDir.c_str());
-    return false;
+  }
+}
-/**
- * @brief sets the data main directory
- * @param dataDir the DataDirectory.
+ *
- * this is essentially the same as setDataDir, but it ommits the error-message
- */
-bool ResourceManager::tryDataDir(const std::string& dataDir)
+{
-  File dataDirectory(dataDir);
-  if (dataDirectory.isDirectory())
+  {
-    this->dataDir = dataDirectory.name();
-    if (dataDir[dataDir.size()-1] != '/' && dataDir[dataDir.size()-1] != '\\')
+    {
-      this->dataDir += '/';
+    }
-    return true;
+  }
-  return false;
+}
-/**
- * @brief checks for the DataDirectory, by looking if
- * @param fileInside is iniside of the given directory.
-*/
-bool ResourceManager::verifyDataDir(const std::string& fileInside)
+{
-  File dataDirectory(this->dataDir);
-  if (!dataDirectory.isDirectory())
+  {
-    PRINTF(1)("'%s' is not a directory\n", this->dataDir.c_str());
-    return false;
+  }
-  File testFile(this->dataDir + fileInside);
-  return testFile.isFile();
+}
-#ifndef NO_TEXTURES
-/**
- * @brief adds a new Path for Images
- * @param imageDir The path to insert
- * @returns true, if the Path was well and injected (or already existent within the list)
-   false otherwise
-*/
-bool ResourceManager::addImageDir(const std::string& imageDir)
+{
-  std::string newDir = imageDir;
-  if (imageDir[imageDir.size()-1] != '/' && imageDir[imageDir.size()-1] != '\\')
+  {
-    newDir += '/';
+  }
-  // check if the param is a Directory
-  if (File(newDir).isDirectory())
+  {
-    // check if the Directory has been added before
-    std::vector<std::string>::const_iterator imageDir;
-    for (imageDir = this->imageDirs.begin(); imageDir != this->imageDirs.end(); imageDir++)
+    {
-      if (*imageDir == newDir)
+      {
-        PRINTF(3)("Path %s already loaded\n", newDir.c_str());
-        return true;
+      }
+    }
-    // adding the directory to the List
-    this->imageDirs.push_back(newDir);
-    return true;
+  }
-  else
+  {
-    PRINTF(1)("%s is not a Directory, and can not be added to the Paths of Images\n", newDir.c_str());
-    return false;
+  }
+}
-#endif /* NO_TEXTURES */
-/**
- * @brief loads resources
- * @param fileName: The fileName of the resource to load
- * @param prio: The ResourcePriority of this resource (will only be increased)
- * @param param0: an additional option to parse (see the constuctors for more help)
- * @param param1: an additional option to parse (see the constuctors for more help)
- * @param param2: an additional option to parse (see the constuctors for more help)
- * @returns a pointer to a desired Resource.
-*/
-BaseObject* ResourceManager::load(const std::string& fileName, ResourcePriority prio,
-                                  const MultiType& param0, const MultiType& param1, const MultiType& param2)
+{
-  ResourceType tmpType;
-#ifndef NO_MODEL
-#define __IF_OK
-  if (!strncasecmp(fileName.c_str()+(fileName.size()-4), ".obj", 4))
-    tmpType = OBJ;
-  else if (!strncmp(fileName.c_str()+(fileName.size()-4), ".md2", 4))
-    tmpType = MD2;
-  else if (!strncmp(fileName.c_str()+(fileName.size()-4), ".md3", 4))
-    tmpType = MD3;
-  else if (!strncmp(fileName.c_str()+(fileName.size()-4), ".cfg", 4))
-    tmpType = MD3_CONFIG;
-  else if (!strcasecmp(fileName.c_str(), "cube") ||
-            !strcasecmp(fileName.c_str(), "sphere") ||
-            !strcasecmp(fileName.c_str(), "plane") ||
-            !strcasecmp(fileName.c_str(), "cylinder") ||
-            !strcasecmp(fileName.c_str(), "cone"))
-    tmpType = PRIM;
-#endif /* NO_MODEL */
-#ifndef NO_AUDIO
-#ifdef __IF_OK
-  else
-#endif
-#define __IF_OK
-    if (!strncasecmp(fileName.c_str()+(fileName.size()-4), ".wav", 4))
-      tmpType = WAV;
-    else if (!strncasecmp(fileName.c_str()+(fileName.size()-4), ".mp3", 4))
-      tmpType = MP3;
-    else if (!strncasecmp(fileName.c_str()+(fileName.size()-4), ".ogg", 4))
-      tmpType = OGG;
-#endif /* NO_AUDIO */
-#ifndef NO_TEXT
-#ifdef __IF_OK
-    else
-#endif
-#define __IF_OK
-      if (!strncasecmp(fileName.c_str()+(fileName.size()-4), ".ttf", 4))
-        tmpType = TTF;
-#endif /* NO_TEXT */
-#ifndef NO_SHADERS
-#ifdef __IF_OK
-      else
-#endif
-#define __IF_OK
-        if (!strncasecmp(fileName.c_str()+(fileName.size()-5), ".vert", 5))
-          tmpType = SHADER;
-#endif /* NO_SHADERS */
-#ifndef NO_TEXTURES
-#ifdef __IF_OK
-        else
-#else
-  if
-#endif
-          tmpType = IMAGE;
-#endif /* NO_TEXTURES */
-#undef __IF_OK
-  return this->load(fileName, tmpType, prio, param0, param1, param2);
+}
-/**
- * @brief caches a Resource
+ *
- * @see load;
+ *
- * @brief returns true if ok, false otherwise.
- * This function loads a Resource without applying it to an Object.
- * This is for loading purposes, e.g, when the user is loading a Resource
- * during the initialisation instead of at Runtime.
- */
-bool ResourceManager::cache(const std::string& fileName, ResourceType type, ResourcePriority prio,
-                            const MultiType& param0, const MultiType& param1, const MultiType& param2)
+{
-  // searching if the resource was loaded before.
-  Resource* tmpResource;
-  // check if we already loaded this Resource
-  tmpResource = this->locateResourceByInfo(fileName, type, param0, param1, param2);
-  // otherwise load it
-  if (tmpResource == NULL)
-    tmpResource = this->loadResource(fileName, type, prio, param0, param1, param2);
-  // return cached pointer.
-  if (tmpResource != NULL) // if the resource was loaded before.
+  {
-    if(tmpResource->prio < prio)
-      tmpResource->prio = prio;
-    return true;
+  }
-  else
-    return false;
+}
-/**
- * tells the ResourceManager to generate a Copy of the Resource.
- * @brief resourcePointer: The Pointer to the resource to copy
- * @returns the Resource pointed to resourcePointer.
- */
-BaseObject* ResourceManager::copy(BaseObject* resourcePointer)
+{
-  Resource* tmp = locateResourceByPointer(resourcePointer);
-  if (tmp!=NULL)
+  {
-    tmp->count++;
-    return tmp->pointer;
+  }
-  else
-    return NULL;
+}
-/**
- * @brief loads resources
- * @param fileName: The fileName of the resource to load
- * @param type: The Type of Resource to load.
- * @param prio: The ResourcePriority of this resource (will only be increased)
- * @param param0: an additional option to parse (see the constuctors for more help)
- * @param param1: an additional option to parse (see the constuctors for more help)
- * @param param2: an additional option to parse (see the constuctors for more help)
- * @returns a pointer to a desired Resource.
-*/
-BaseObject* ResourceManager::load(const std::string& fileName, ResourceType type, ResourcePriority prio,
-                                  const MultiType& param0, const MultiType& param1, const MultiType& param2)
+{
-  // searching if the resource was loaded before.
-  Resource* tmpResource;
-  // check if we already loaded this Resource
-  tmpResource = this->locateResourceByInfo(fileName, type, param0, param1, param2);
-  // otherwise load it
-  if (tmpResource == NULL)
+  {
-    tmpResource = this->loadResource(fileName, type, prio, param0, param1, param2);
+  }
-  // return cached pointer.
-  if (tmpResource != NULL) // if the resource was loaded before.
+  {
-    tmpResource->count++;
-    if(tmpResource->prio < prio)
-      tmpResource->prio = prio;
-    return tmpResource->pointer;
+  }
-  else
-    return NULL;
+}
-/**
- * @brief loads resources for internal purposes
- * @param fileName: The fileName of the resource to load
- * @param type: The Type of Resource to load.
- * @param prio: The ResourcePriority of this resource (will only be increased)
- * @param param0: an additional option to parse (see the constuctors for more help)
- * @param param1: an additional option to parse (see the constuctors for more help)
- * @param param2: an additional option to parse (see the constuctors for more help)
- * @returns a pointer to a desired Resource.
- */
-Resource* ResourceManager::loadResource(const std::string& fileName, ResourceType type, ResourcePriority prio,
-                                        const MultiType& param0, const MultiType& param1, const MultiType& param2)
+{
-  // Setting up the new Resource
-  Resource* tmpResource = new Resource;
-  tmpResource->count = 0;
-  tmpResource->type = type;
-  tmpResource->prio = prio;
-  tmpResource->pointer = NULL;
-  tmpResource->name = fileName;
-  // creating the full name. (directoryName + FileName)
-  std::string fullName = ResourceManager::getFullName(fileName);
-  // Checking for the type of resource \see ResourceType
-  switch(type)
+  {
-#ifndef NO_MODEL
-    case OBJ:
-      if (param0.getType() != MT_NULL)
-        tmpResource->param[0] = param0;
-      else
-        tmpResource->param[0] = 1.0f;
-      if(File(fullName).isFile())
-        tmpResource->pointer = new OBJModel(fullName, tmpResource->param[0].getFloat());
-      else
+      {
-        PRINTF(2)("File %s in %s does not exist. Loading a cube-Model instead\n", fileName.c_str(), dataDir.c_str());
-        tmpResource->pointer = ResourceManager::load("cube", PRIM, prio, tmpResource->param[0].getFloat());
+      }
-      break;
-    case PRIM:
-      if (param0 != MT_NULL)
-        tmpResource->param[0] = param0;
-      else
-        tmpResource->param[0] = 1.0f;
-      if (tmpResource->name == "cube")
-        tmpResource->pointer = new PrimitiveModel(PRIM_CUBE, tmpResource->param[0].getFloat());
-      else if (tmpResource->name == "sphere")
-        tmpResource->pointer = new PrimitiveModel(PRIM_SPHERE, tmpResource->param[0].getFloat());
-      else if (tmpResource->name == "plane")
-        tmpResource->pointer = new PrimitiveModel(PRIM_PLANE, tmpResource->param[0].getFloat());
-      else if (tmpResource->name == "cylinder")
-        tmpResource->pointer = new PrimitiveModel(PRIM_CYLINDER, tmpResource->param[0].getFloat());
-      else if (tmpResource->name == "cone")
-        tmpResource->pointer = new PrimitiveModel(PRIM_CONE, tmpResource->param[0].getFloat());
-      break;
-    case MD2:
-      if(File(fullName).isFile())
+      {
-        tmpResource->param[0] = param0;
-        tmpResource->param[1] = param1;
-        tmpResource->pointer = new MD2Data(fullName, tmpResource->param[0].getCString(), tmpResource->param[1].getFloat());
+      }
-      break;
-    case MD3:
-      if(File(fullName).isFile())
+      {
-        tmpResource->param[0] = param0;
-        tmpResource->param[1] = param1;
-        tmpResource->pointer = new md3::MD3Data(fullName, tmpResource->param[0].getCString(), tmpResource->param[1].getFloat());
+      }
-      break;
-    case MD3_CONFIG:
-      if(File(fullName).isFile())
+      {
-        tmpResource->param[0] = param0;
-        tmpResource->param[1] = param1;
-        tmpResource->pointer = new md3::MD3AnimationCfg(fullName);
+      }
-      break;
-#endif /* NO_MODEL */
-#ifndef NO_TEXT
-    case TTF:
-      if (param0 != MT_NULL)
+      {
-        assert(param0.getInt() >= 0);
-        tmpResource->param[0] = param0;
+      }
-      else
-        tmpResource->param[0] = FONT_DEFAULT_RENDER_SIZE;
-      if(File(fullName).isFile())
-        tmpResource->pointer = new Font(fullName, (unsigned int) tmpResource->param[0].getInt());
-      else
-        PRINTF(2)("%s does not exist in %s. Not loading Font\n", fileName.c_str(), this->dataDir.c_str());
-      break;
-#endif /* NO_TEXT */
-#ifndef NO_AUDIO
-    case WAV:
-      if(File(fullName).isFile())
-        tmpResource->pointer = new OrxSound::SoundBuffer(fullName);
-      break;
-    case OGG:
-      if (File(fullName).isFile())
-        tmpResource->pointer = new OrxSound::OggPlayer(fullName);
-      break;
-#endif /* NO_AUDIO */
-#ifndef NO_TEXTURES
-    case IMAGE:
-      if (param0 != MT_NULL)
-        tmpResource->param[0] = param0;
-      else
-        tmpResource->param[0] = GL_TEXTURE_2D;
-      if(File(fullName).isFile())
+      {
-        PRINTF(4)("Image %s resides to %s\n", fileName.c_str(), fullName.c_str());
-        tmpResource->pointer = new Texture(fullName, tmpResource->param[0].getInt());
+      }
-      else
+      {
-        std::vector<std::string>::iterator imageDir;
-        for (imageDir = this->imageDirs.begin(); imageDir != this->imageDirs.end(); imageDir++)
+        {
-          std::string imgName = *imageDir + fileName;
-          if(File(imgName).isFile())
+          {
-            PRINTF(4)("Image %s resides to %s\n", fileName.c_str(), imgName.c_str());
-            tmpResource->pointer = new Texture(imgName, tmpResource->param[0].getInt());
-            break;
+          }
+        }
+      }
-      if(!tmpResource)
-        PRINTF(2)("!!Image %s not Found!!\n", fileName.c_str());
-      break;
-#endif /* NO_TEXTURES */
-#ifndef NO_SHADERS
-    case SHADER:
-      if(File(fullName).isFile())
+      {
-        if (param0 != MT_NULL)
+        {
-          MultiType param = param0; /// HACK
-          std::string secFullName = ResourceManager::getFullName(param.getCString());
-          if (File(secFullName).isFile())
+          {
-            tmpResource->param[0] = secFullName;
-            tmpResource->pointer = new Shader(fullName, secFullName);
+          }
+        }
-        else
+        {
-          tmpResource->param[0] = param0;
-          tmpResource->pointer = new Shader(fullName, "");
+        }
+      }
-      break;
-#endif /* NO_SHADERS */
-    default:
-      tmpResource->pointer = NULL;
-      PRINTF(1)("No type found for %s.\n   !!This should not happen unless the Type is not supported yet. JUST DO IT!!\n", tmpResource->name.c_str());
-      break;
+  }
-  if (tmpResource->pointer != NULL)
-    this->resourceList.push_back(tmpResource);
-  if (tmpResource->pointer != NULL)
-    return tmpResource;
-  else
+  {
-    PRINTF(2)("Resource %s could not be loaded\n", fileName.c_str());
-    delete tmpResource;
-    return NULL;
+  }
+}
-/**
- * @brief unloads a Resource
- * @param pointer: The pointer to free
- * @param prio: the PriorityLevel to unload this resource
- * @returns true if successful (pointer found, and deleted), false otherwise
-*/
-bool ResourceManager::unload(BaseObject* pointer, ResourcePriority prio)
+{
-  if (pointer == NULL)
-    return false;
-  // if pointer is existent. and only one resource of this type exists.
-  Resource* tmpResource = this->locateResourceByPointer(pointer);
-  if (tmpResource != NULL)
-    return unload(tmpResource, prio);
-  else
+  {
-    PRINTF(2)("Resource not Found %p\n", pointer);
-    return false;
+  }
+}
-/**
- * @brief unloads a Resource
- * @param resource: The resource to unloade
- * @param prio the PriorityLevel to unload this resource
- * @returns true on success, false otherwise.
-*/
-bool ResourceManager::unload(Resource* resource, ResourcePriority prio)
+{
-  if (resource == NULL)
-    return false;
-  if (resource->count > 0)
-    resource->count--;
-  if (resource->prio <= prio)
+  {
-    if (resource->count == 0)
+    {
-      delete resource->pointer;
-      // deleting the List Entry:
-      PRINTF(4)("Resource %s safely removed.\n", resource->name.c_str());
-      std::vector<Resource*>::iterator resourceIT = std::find(this->resourceList.begin(), this->resourceList.end(), resource);
-      this->resourceList.erase(resourceIT);
-      delete resource;
+    }
-    else
-      PRINTF(4)("Resource %s not removed, because there are still %d References to it.\n", resource->name.c_str(), resource->count);
+  }
-  else
-    PRINTF(4)("not deleting resource %s because DeleteLevel to high\n", resource->name.c_str());
-  return true;
+}
-/**
- * @brief unloads all alocated Memory of Resources with a pririty lower than prio
- * @param prio The priority to delete
-*/
-bool ResourceManager::unloadAllByPriority(ResourcePriority prio)
+{
-  bool removedAll = true;
-  unsigned int removeCount;
-  for (unsigned int round = 0; round < 3; round++)
+  {
-    int index = this->resourceList.size() - 1;
-    removeCount = 0;
-    while (index >= 0)
+    {
-      if (this->resourceList[index]->prio <= prio)
+      {
-        if (this->resourceList[index]->count == 0)
-          unload(this->resourceList[index], prio);
-        else
+        {
-          if (round == 3)
+          {
-            PRINTF(2)("unable to unload %s because there are still %d references to it\n",
-                      this->resourceList[index]->name.c_str(), this->resourceList[index]->count);
-            removedAll = false;
+          }
-          removeCount++;
+        }
+      }
-      index--;
+    }
-    if (removeCount == 0) break;
+  }
-  return removedAll;
+}
-/**
- * @brief Searches for a Resource by some information
- * @param fileName: The name to look for
- * @param type the Type of resource to locate.
- * @param param0: an additional option to parse (see the constuctors for more help)
- * @param param1: an additional option to parse (see the constuctors for more help)
- * @param param2: an additional option to parse (see the constuctors for more help)
- * @returns a Pointer to the Resource if found, NULL otherwise.
-*/
-Resource* ResourceManager::locateResourceByInfo(const std::string& fileName, ResourceType type,
-    const MultiType& param0, const MultiType& param1, const MultiType& param2) const
+{
-  std::vector<Resource*>::const_iterator resource;
-  for (resource = this->resourceList.begin(); resource != this->resourceList.end(); resource++)
+  {
-    if ((*resource)->type == type && fileName == (*resource)->name)
+    {
-      bool match = false;
-      switch (type)
+      {
-#ifndef NO_MODEL
-        case PRIM:
-        case OBJ:
-          if (param0 == MT_NULL)
+          {
-            if ((*resource)->param[0] == 1.0f)
-              match = true;
+          }
-          else if ((*resource)->param[0] == param0.getFloat())
-            match = true;
-          break;
-        case MD2:
-          if (param0 == MT_NULL && ((*resource)->param[0] == "") && param1 == MT_NULL && ((*resource)->param[0] == 1.0f))
-              match = true;
-          else if ((*resource)->param[0] == ((MultiType)param0).getString() && (*resource)->param[1] == ((MultiType)param1).getFloat())
-            match = true;
-          break;
-        case MD3:
-          if (param0 == MT_NULL && ((*resource)->param[0] == "") && param1 == MT_NULL && ((*resource)->param[0] == 1.0f))
-            match = true;
-          else if ((*resource)->param[0] == ((MultiType)param0).getString() && (*resource)->param[1] == ((MultiType)param1).getFloat())
-            match = true;
-          break;
-        case MD3_CONFIG:
-          if (param0 == MT_NULL && ((*resource)->param[0] == ""))
-            match = true;
-          else if ((*resource)->param[0] == ((MultiType)param0).getString())
-            match = true;
-          break;
-#endif /* NO_MODEL */
-#ifndef NO_TEXT
-        case TTF:
-          if (param0 == MT_NULL)
+          {
-            if ((*resource)->param[0] == FONT_DEFAULT_RENDER_SIZE)
-              match = true;
+          }
-          else if ((*resource)->param[0] == param0.getInt())
-            match = true;
-          break;
-#endif /* NO_TEXT */
-#ifndef NO_SHADERS
-        case SHADER:
-          if (param0 == MT_NULL)
+          {
-            if ((*resource)->param[0] == "")
-              match = true;
+          }
-          else if ((*resource)->param[0] == ((MultiType)param0).getString())
-            match = true;
-          break;
-#endif /* NO_SHADERS */
-#ifndef NO_TEXTURES
-        case IMAGE:
-          if (param0 == MT_NULL)
+          {
-            if ((*resource)->param[0] == GL_TEXTURE_2D)
-              match = true;
+          }
-          else if ((*resource)->param[0] ==  param0.getInt())
-            match = true;
-          break;
-#endif /* NO_TEXTURES */
-        default:
-          match = true;
-          break;
+      }
-      if (match)
+      {
-        return (*resource);
+      }
+    }
+  }
-  return NULL;
+}
-/**
- * @brief Searches for a Resource by Pointer
- * @param pointer the Pointer to search for
- * @returns a Pointer to the Resource if found, NULL otherwise.
- */
-Resource* ResourceManager::locateResourceByPointer(const void* pointer) const
+{
-  //  Resource* enumRes = resourceList->enumerate();
-  std::vector<Resource*>::const_iterator resource;
-  for (resource = this->resourceList.begin(); resource != this->resourceList.end(); resource++)
-    if (pointer == (*resource)->pointer)
-      return (*resource);
-  return NULL;
+}
-std::string ResourceManager::toResourcableString(unsigned int i)
+{
-/*  int len = strlen(ResourceManager::ResourceTypeToChar(this->resourceList[i]->type));
-  len += this->resourceList[i]->name.size();
-  if (this->resourceList[i]->param[0].getCString()) len += strlen(this->resourceList[i]->param[0].getCString()) +1;
-  if (this->resourceList[i]->param[1].getCString()) len += strlen(this->resourceList[i]->param[1].getCString()) +1;
-  if (this->resourceList[i]->param[2].getCString()) len += strlen(this->resourceList[i]->param[2].getCString()) +1;
-  len += 10;
-  std::string tmp = new char[len];
-  tmp[0] = '\0';
-  strcat(tmp, ResourceManager::ResourceTypeToChar(this->resourceList[i]->type));
-  strcat(tmp,",");
-  strcat (tmp, this->resourceList[i]->name);
-  if (this->resourceList[i]->param[0].getCString() && this->resourceList[i]->param[0].getCString() != '\0')
+  {
-    strcat(tmp,",");
-    strcat( tmp, this->resourceList[i]->param[0].getCString());
+  }
-  if (this->resourceList[i]->param[1].getCString() && this->resourceList[i]->param[1].getCString() != '\0')
+  {
-    strcat(tmp,",");
-    strcat( tmp, this->resourceList[i]->param[1].getCString());
+  }
-  if (this->resourceList[i]->param[2].getCString() && this->resourceList[i]->param[2].getCString() != '\0')
+  {
-    strcat(tmp,",");
-    strcat( tmp, this->resourceList[i]->param[2].getCString());
+  }
-  return tmp;*/
-  return "";
+}
-/**
- * @brief caches a Resource from a ResourceableString created with the toResourcableString-function
- * @param resourceableString the String to cache the resource from.
- */
-bool ResourceManager::fromResourceableString(const std::string& resourceableString)
+{
-/*  SubString splits(resourceableString, ',');
-  splits.debug();
-  if (splits.getCount() == 2)
-    this->cache(splits[1], ResourceManager::stringToResourceType(splits[0]),
-                RP_LEVEL);
-  else if (splits.getCount() == 3)
-    return this->cache(splits[1], ResourceManager::stringToResourceType(splits[0]),
-                RP_LEVEL, splits[2]);
-  else if (splits.getCount() == 4)
-    return this->cache(splits[1], ResourceManager::stringToResourceType(splits[0]),
-                RP_LEVEL, splits[2], splits[3]);
-  else if (splits.getCount() == 5)
-    return this->cache(splits[1], ResourceManager::stringToResourceType(splits[0]),
-                RP_LEVEL, splits[2], splits[3], splits[4]);*/
-  return false;
+}
-/**
- * @param fileName the Name of the File to check
- * @returns The full name of the file, including the DataDir, and NULL if the file does not exist
- * !!IMPORTANT: this has to be deleted from the outside!!
-*/
-std::string ResourceManager::getFullName(const std::string& fileName)
+{
-  if (fileName.empty() || ResourceManager::getInstance()->getDataDir().empty())
-    return "";
-  std::string retName = ResourceManager::getInstance()->getDataDir() +fileName;
-  if (File(retName).isFile() || File(retName).isDirectory())
-    return retName;
-  else
-    return "";
+}
-/**
- * @brief checks wether a file is in the DataDir.
- * @param fileName the File to check if it is in the Data-Dir structure.
- * @returns true if the file exists, false otherwise
- */
-bool ResourceManager::isInDataDir(const std::string& fileName)
+{
-  if (fileName.empty() || ResourceManager::getInstance()->getDataDir().empty())
-    return false;
-  bool retVal = false;
-  std::string checkFile = ResourceManager::getInstance()->getDataDir() + fileName;
-  if (File(checkFile).exists())
-    retVal = true;
-  else
-    retVal = false;
-  return retVal;
+}
-/**
- * @brief outputs debug information about the ResourceManager
- */
-void ResourceManager::debug() const
+{
-  PRINT(0)("=RM===================================\n");
-  PRINT(0)("= RESOURCE-MANAGER DEBUG INFORMATION =\n");
-  PRINT(0)("======================================\n");
-  // if it is not initialized
-  PRINT(0)(" Reference is: %p\n", ResourceManager::singletonRef);
-  PRINT(0)(" Data-Directory is: %s\n", this->dataDir.c_str());
-  PRINT(0)(" List of Image-Directories: ");
-  std::vector<std::string>::const_iterator imageDir;
-  for (imageDir = this->imageDirs.begin(); imageDir != this->imageDirs.end(); imageDir++)
-    PRINT(0)("%s ", (*imageDir).c_str());
-  PRINT(0)("\n");
-  PRINT(0)("List of all stored Resources:\n");
-  std::vector<Resource*>::const_iterator resource;
-  for (resource = this->resourceList.begin(); resource != this->resourceList.end(); resource++)
+  {
-    PRINT(0)("-----------------------------------------\n");
-    PRINT(0)("Name: %s; References: %d; Type: %s ", (*resource)->name.c_str(), (*resource)->count, ResourceManager::ResourceTypeToChar((*resource)->type));
-    PRINT(0)("gets deleted at ");
-    switch((*resource)->prio)
+    {
-      default:
-      case RP_NO:
-        PRINT(0)("first posibility (0)\n");
-        break;
-      case RP_LEVEL:
-        PRINT(0)("the end of the Level (1)\n");
-        break;
-      case RP_CAMPAIGN:
-        PRINT(0)("the end of the campaign (2)\n");
-        break;
-      case RP_GAME:
-        PRINT(0)("when leaving the game (3)\n");
-        break;
+    }
+  }
-  PRINT(0)("==================================RM==\n");
+}
-/**
- * @brief converts a ResourceType into the corresponding String
- * @param type the ResourceType to translate
- * @returns the converted String.
- */
-const char* ResourceManager::ResourceTypeToChar(ResourceType type)
+{
-  return ResourceManager::resourceNames[type];
+}
-/**
- * @brief converts a String into a ResourceType (good for loading)
- * @param resourceType the name of the Type
- * @returns the Number of the Type, or 0 (defautl) if not found.
- */
-ResourceType ResourceManager::stringToResourceType(const std::string& resourceType)
+{
-  for (unsigned int i = 0; i < RESOURCE_TYPE_SIZE; i++)
-    if (resourceType == ResourceManager::resourceNames[i])
-      return (ResourceType)i;
-  return (ResourceType)0;
+}
-/**
- * The Names of the ResourceTypes
- */
-const char* ResourceManager::resourceNames[] =
+  {
-#ifndef NO_MODEL
-    "ObjectModel",
-    "PrimitiveModel",
-    "MD2-Data",
-    "MD3-Data",
-    "MD3-Config"
-#endif
-#ifndef NO_TEXT
-    "Font",
-#endif
-#ifndef NO_AUDIO
-    "Wav",
-    "mp3",
-    "ogg",
-#endif
-#ifndef NO_TEXTURES
-    "Texture",
-#endif
-#ifndef NO_SHADERS
-    "Shader",
-#endif
-  };

trunk/src/lib/util/loading/resource_manager.h

-                      r8724
+                      r9869
 /*!
  * @file resource_manager.h
+  *  The Resource Manager checks if a file/resource is loaded.
+    If a file/resource was already loaded the resourceManager will
+    return a void pointer to the desired resource.
+    Otherwise it will instruct the coresponding resource-loader to load,
+    and receive a pointer to it.
+    it is possible to compile the resource Manager without some modules by
+    just adding the compile flag -D....
+    (NO_MODEL)
+    (NO_AUDIO)
+    (NO_TEXT)
+    (NO_TEXTURES)
+    (NO_SHADERS)
+*/
+ */
 #ifndef _RESOURCE_MANAGER_H
 #define _RESOURCE_MANAGER_H
 #include "base_object.h"
+#include "resource.h"
 #include "filesys/file.h"
+#include "filesys/directory.h"
+#include "multi_type.h"
+#include <vector>
+namespace Resources
+{
+//! An eumerator for different fileTypes the resourceManager supports
+typedef enum ResourceType
+{
+#ifndef NO_MODEL
+  OBJ,                  //!< loading .obj file
+  PRIM,                 //!< loading primitive model
+  MD2,                  //!< loading md2-file
+  MD3,                  //!< loading md3-file
+  MD3_CONFIG,           //!< the md3 config file
+#endif /* NO_MODEL */
+#ifndef NO_TEXT
+  TTF,                  //!< loading a TrueTypeFont
+#endif /* NO_TEXT */
+#ifndef NO_AUDIO
+  WAV,                  //!< loading wav
+  MP3,                  //!< loading mp3
+  OGG,                  //!< loading ogg
+#endif /* NO_AUDIO */
+#ifndef NO_TEXTURES
+  IMAGE,                //!< loading an image
+#endif /* NO_TEXTURES */
+#ifndef NO_SHADERS
+  SHADER,               //!< openGL-shader program
+#endif /* NO_SHADERS */
+  RESOURCE_TYPE_SIZE
+};
+  class ResourceManager : public BaseObject
+  {
+    ObjectListDeclaration(ResourceManager);
+  public:
+    ///////////////////////
+    //// INSTANZIATION ////
+    /** @returns a Pointer to the only object of this Class */
+    inline static ResourceManager* getInstance() { if (!_singletonRef) _singletonRef = new ResourceManager();  return _singletonRef; };
+    /** @brief deletes the Instance if it exists. */
+    inline static void deleteInstance() { if (_singletonRef) delete _singletonRef; };
+//! An enumerator for different UNLOAD-types.
+/**
+   RP_NO:        will be unloaded on request
+   RP_LEVEL:     will be unloaded at the end of a Level
+   RP_CAMPAIGN:  will be unloaded at the end of a Campaign
+   RP_GAME:      will be unloaded at the end of the whole Game (when closing orxonox)
+*/
+typedef enum ResourcePriority
+{
+  RP_NO        =   0,
+  RP_LEVEL     =   1,
+  RP_CAMPAIGN  =   2,
+  RP_GAME      =   4
+};
+    ////////////////////////
+    //// RESOURCE PATHS ////
+    void setMainGlobalPath(const Directory& directory);
+    void addGlobalPath(const Directory& directory);
+//! A Struct that keeps track about a resource its name its Type, and so on
+struct Resource
+{
+  BaseObject*       pointer;           //!< Pointer to the Resource.
+  unsigned int      count;             //!< How many times this Resource has been loaded.
+    bool addResourcePath(const std::string& resourceName, const std::string& pathName);
+    bool addResourceSubPath(const std::string& resourceName, const std::string& pathName);
+    void registerType(Resources::Type* type);
+    void unregisterType(Resources::Type* type);
+  std::string       name;              //!< Name of the Resource.
+  ResourceType      type;              //!< ResourceType of this Resource.
+  ResourcePriority  prio;              //!< The Priority of this resource. (This will only be increased)
+    /** @returns the main global search Path */
+    const Directory& mainGlobalPath() const { return _mainGlobalPath; };
+    /** @returns all global paths without mainGlobalPath */
+    const std::vector<Directory>& globalPaths() const { return _globalPaths; };
+  MultiType         param[3];          //!< The Parameters given to this Resource.
+};
+    ////////////////////
+    //// KEEPLEVELS ////
+    unsigned int addKeepLevelName(const std::string& keepLevelName);
+    unsigned int getKeepLevelID(const std::string& keepLevelName) const;
+    const std::string& getKeepLevelName(unsigned int keepLevelID) const;
+    void setDefaultKeepLevel(const KeepLevel& keepLevel) { this->_defaultKeepLevel = keepLevel; };
+    const KeepLevel& defaultKeepLevel() const { return this->_defaultKeepLevel; };
+    //////////////////////////
+    //// GENERAL QUERIES ////
+    /** @returns the Types of Resources */
+    const std::vector<Resources::Type*> resourceTypes() const { return _resourceTypes; };
+//! The ResourceManager is a class, that decides if a file/resource should be loaded
+/**
+ * If a file/resource was already loaded the resourceManager will
+ * return a pointer to the desired resource.
+ * Otherwise it will instruct the corresponding resource-loader to load,
+ * and receive the pointer to it.
+ *
+ * It does it by looking, if a desired file has already been loaded.
+ * There is also the possibility to check for some variables
+ */
+class ResourceManager : public BaseObject
+{
+ public:
+  virtual ~ResourceManager();
+  /** @returns a Pointer to the only object of this Class */
+  inline static ResourceManager* getInstance() { if (!singletonRef) singletonRef = new ResourceManager();  return singletonRef; };
+    bool checkFileInMainPath(const File& fileInside);
+    std::string prependAbsoluteMainPath(const std::string& fileName);
+  bool setDataDir(const std::string& dataDir);
+  /** @returns the Name of the data directory */
+  inline const std::string& getDataDir() const { return this->dataDir; };
+    ////////////////////////////////////////
+    //// RESOURCE LOADING AND UNLOADING ////
+    void loadFromLoadString(const std::string& resourceTypeName, const std::string& loadString, const KeepLevel& keepLevel = KeepLevel());
+    void loadFromLoadStringHACK(const std::string& resourceTypeName, const std::string& loadString) { this->loadFromLoadString(resourceTypeName, loadString); };
+    void unloadAllBelowKeepLevel(const Resources::KeepLevel& keepLevel);
+    void unloadAllBelowKeepLevelINT(unsigned int level) { unloadAllBelowKeepLevel(level); };
   bool tryDataDir(const std::string& dataDir);
   bool verifyDataDir(const std::string& fileInside);
   bool addImageDir(const std::string& imageDir);
+    ///////////////
+    //// DEBUG ////
+    void debug() const;
   bool cache(const std::string& fileName, ResourceType type, ResourcePriority prio = RP_NO,
              const MultiType& param0 = MultiType(), const MultiType& param1 = MultiType(), const MultiType& param2 = MultiType());
   BaseObject* copy(BaseObject* resourcePointer);
+  private:
+    ResourceManager();
+    virtual ~ResourceManager();
+  BaseObject* load(const std::string& fileName, ResourcePriority prio = RP_NO,
+                   const MultiType& param0 = MultiType(), const MultiType& param1 = MultiType(), const MultiType& param2 = MultiType());
+  BaseObject* load(const std::string& fileName, ResourceType type, ResourcePriority prio = RP_NO,
+                   const MultiType& param0 = MultiType(), const MultiType& param1 = MultiType(), const MultiType& param2 = MultiType());
+  bool unload(BaseObject* pointer, ResourcePriority prio = RP_NO);
+  bool unload(Resource* resource, ResourcePriority = RP_NO);
+  bool unloadAllByPriority(ResourcePriority prio);
+  private:
+    static ResourceManager*            _singletonRef;       //!< singleton Reference
+  Resource* locateResourceByInfo(const std::string& fileName, ResourceType type,
+                                 const MultiType& param0 = MultiType(), const MultiType& param1 = MultiType(), const MultiType& param2 = MultiType()) const;
+  Resource* locateResourceByPointer(const void* pointer) const;
+    Directory                          _mainGlobalPath;     //!< The main include directory (default at "./")
+    std::vector<Directory>             _globalPaths;        //!< Additional Global include directories.
+  std::string toResourcableString(unsigned int i);
+  bool fromResourceableString(const std::string& resourceableString);
+  /** @returns the Count of Resources the ResourceManager handles */
+  unsigned int resourceCount() const { return this->resourceList.size(); }
+    std::vector<Resources::Type*>      _resourceTypes;      //!< A Vector of all the stored ResourceTypes @see Resources::Type
+  void debug() const;
+    std::vector<std::string>           _keepLevelNames;     //!< Names of KeepLevels @see Resources::KeepLevel
+    KeepLevel                          _defaultKeepLevel;   //!< The default KeepLevel.
+  };
+  // utility functions for handling files in and around the data-directory
+  static std::string getFullName(const std::string& fileName);
+  static bool isInDataDir(const std::string& fileName);
+  static const char* ResourceTypeToChar(ResourceType type);
+  static ResourceType stringToResourceType(const std::string& resourceType);
+ private:
+  ResourceManager();
+  Resource* loadResource(const std::string& fileName, ResourceType type, ResourcePriority prio,
+                         const MultiType& param0, const MultiType& param1, const MultiType& param2);
+ private:
+  static ResourceManager*    singletonRef;       //!< singleton Reference
+  std::string                dataDir;            //!< The Data Directory, where all relevant Data is stored.
+  std::vector<std::string>   imageDirs;          //!< A list of directories in which images are stored.
+  std::vector<Resource*>     resourceList;       //!< The List of Resources, that has already been loaded.
+  static const char*         resourceNames[RESOURCE_TYPE_SIZE];
+};
+}
 #endif /* _RESOURCE_MANAGER_H */

trunk/src/lib/util/multi_type.cc

-                      r9406
+                      r9869
+  {
     default:
       this->value.Float = 0.0f;
       break;
+    this->value.Float = 0.0f;
+    break;
     case MT_BOOL:
       this->value.Bool = false;
       break;
+    this->value.Bool = false;
+    break;
     case MT_INT:
       this->value.Int = 0;
       break;
+    this->value.Int = 0;
+    break;
     case MT_FLOAT:
       this->value.Float = 0.0f;
       break;
+    this->value.Float = 0.0f;
+    break;
     case MT_CHAR:
       this->value.Char = '\0';
       break;
+    this->value.Char = '\0';
+    break;
     case MT_STRING:
       this->storedString = "";
       break;
+    this->storedString = "";
+    break;
+  }
+}
 …
+  {
     case MT_NULL:
       return true;
+    return true;
     case MT_BOOL:
       return (this->value.Bool == mt.value.Bool);
+    return (this->value.Bool == mt.value.Bool);
     case MT_INT:
       return (this->value.Int == mt.value.Int);
+    return (this->value.Int == mt.value.Int);
     case MT_CHAR:
       return (this->value.Char == mt.value.Char);
+    return (this->value.Char == mt.value.Char);
     case MT_FLOAT:
       return (this->value.Float == mt.value.Float);
+    return (this->value.Float == mt.value.Float);
     case MT_STRING:
       return (this->storedString == mt.storedString);
+    return (this->storedString == mt.storedString);
     default:
       return false;
+    return false;
+  }
+}
 …
+  {
     case MT_BOOL:
       this->setBool(this->getBool());
       break;
+    this->setBool(this->getBool());
+    break;
     case MT_INT:
       this->setInt(this->getInt());
       break;
+    this->setInt(this->getInt());
+    break;
     case MT_FLOAT:
       this->setFloat(this->getFloat());
       break;
+    this->setFloat(this->getFloat());
+    break;
     case MT_CHAR:
       this->setChar(this->getChar());
       break;
+    this->setChar(this->getChar());
+    break;
     case MT_STRING:
       this->setString(this->getString());
       break;
+    this->setString(this->getString());
+    break;
     default:
       this->type = type;
+    this->type = type;
+  }
+}
 …
+ *
  * This is a pure Value copy. The current type will be preserved.
+ *
- * @TODO speedup
  */
 void MultiType::setValueOf(const MultiType& mt)
 …
+}
+/**
+ * @brief stores any value to the string.
+ * @note this Value can be grabbed by using the getStoredString function.
+ */
+void MultiType::storeString()
+{
+  if (!(this->type & MT_STRING))
+    this->storedString = this->getString();
+}
 /**************************
 …
   else if (this->type & MT_STRING) return (this->storedString == "true" ||
                                             this->storedString == "TRUE" ||
                                             this->storedString != "0"); //! @TODO make this better...
+                                            this->storedString != "0"); // TODO make this better...
   return false;
 …
  * @brief returns a Constant string (actually this is slower than getString()
  * @returns a constant string of the stored version's one.
+ * @note this  could lead to a inconsistency of data
+ * @note this  could lead to a inconsistency of data AND IS HIGHLY NON_THREAD_SAFE!
+ * PLEASE THINK ABOUT USING THE getStoredString function in conjunction with storeString().
  */
 const std::string& MultiType::getConstString() const
+{
   MultiType::constString = this->getString();
   return MultiType::constString;
+}
+/**
+ * @brief returns the currently stored string.
+ * @returns the Stored string.
+ * @note Storing a string works as follows: \\
+ * MultiType a(3);  // Creates a MultiType of Type int with value 3 \\
+ * a.storeString(); // Stores the String in the internal structure. \\
+ * std::string name = a.getStoredString();
+ *
+ * This would be the same as
+ * name = a.getString();
+ * but with much more const'ness.
+ */
+const std::string& MultiType::getStoredString() const
+{
+  MultiType::constString = this->getString();
+  return MultiType::constString;
+}
 /**
 …
+  {
     case MT_BOOL:
       this->setBool(false);
       break;
+    this->setBool(false);
+    break;
     case MT_INT:
       this->setInt(0);
       break;
+    this->setInt(0);
+    break;
     case MT_FLOAT:
       this->setFloat(0.0f);
       break;
+    this->setFloat(0.0f);
+    break;
     case MT_CHAR:
       this->setChar('\0');
       break;
+    this->setChar('\0');
+    break;
     case MT_STRING:
       this->setString("");
       break;
+    this->setString("");
+    break;
     default:
 #ifdef DEBUG
       PRINTF(2)("Unknown Type not reseting\n");
+    PRINTF(2)("Unknown Type not reseting\n");
 #endif
       break;
+    break;
+  }
+}
 …
+  {
     case MT_BOOL:
       return MultiType::typeNames[1];
+    return MultiType::typeNames[1];
     case MT_INT:
       return MultiType::typeNames[2];
+    return MultiType::typeNames[2];
     case MT_FLOAT:
       return MultiType::typeNames[3];
+    return MultiType::typeNames[3];
     case MT_CHAR:
       return MultiType::typeNames[4];
+    return MultiType::typeNames[4];
     case MT_STRING:
       return MultiType::typeNames[5];
+    return MultiType::typeNames[5];
     default:
       return MultiType::typeNames[0];
+    return MultiType::typeNames[0];
+  }
+}

trunk/src/lib/util/multi_type.h

-                      r8035
+                      r9869
   MT_BOOL            = 1,                  //!< A bool Value.
   MT_INT             = 2,                  //!< An int Value.
   MT_UINT            = 2,
   MT_LONG            = 2,
+  MT_UINT            = 2,                  //!< A insigned int Value.
+  MT_LONG            = 2,                  //!< A long Value
   MT_FLOAT           = 4,                  //!< A float Value.
   MT_CHAR            = 8,                  //!< A single char.
 …
     MultiType& operator=(const MultiType& mt);
+    /** @param value the value to set (here a bool) @returns the MultiType where this the bool is stored */
     MultiType& operator=(bool value) { this->setBool(value); return *this; };
+    /** @param value the value to set (here an int) @returns the MultiType where this the int is stored */
     MultiType& operator=(int value) { this->setInt(value); return *this; };
+    /** @param value the value to set (here an int) @returns the MultiType where this the float is stored */
     MultiType& operator=(float value) { this->setFloat(value); return *this; };
+    /** @param value the value to set (here a char) @returns the MultiType where this the char is stored */
     MultiType& operator=(char value) { this->setChar(value); return *this; };
+    /** @param value the value to set (here a string) @returns the MultiType where this the string is stored */
     MultiType& operator=(const std::string& value) { this->setString(value); return *this; };
     bool operator==(const MultiType& mt) const;
+    /** @param value the value to compare this MultiType against @returns true if comparison was io */
     bool operator==(bool value) const { return (this->getBool() == value); };
+    /** @param value the value to compare this MultiType against @returns true if comparison was io */
     bool operator==(int value) const { return (this->getInt() == value); };
+    /** @param value the value to compare this MultiType against @returns true if comparison was io */
     bool operator==(float value) const { return (this->getFloat() ==  value); };
+    /** @param value the value to compare this MultiType against @returns true if comparison was io */
     bool operator==(char value) const { return (this->getChar() == value); };
+    /** @param value the value to compare this MultiType against @returns true if comparison was io */
     bool operator==(const std::string& value) const { return (this->getString() == value); };
+    /** @param type the Type to compare this MultiType against @returns true if the types matched */
     bool operator==(MT_Type type) const { return (this->type == type); }
+    /** @param type the type to compare this MultiType against @returns true if the types do not match */
     bool operator!=(MT_Type type) const { return (this->type != type); }
 …
     // for your convenience.
+    /** @param value the value to set. Here a bool */
     inline void setValue(bool value) { this->setBool(value); };
+    /** @param value the value to set. Here an int */
     inline void setValue(int value) { this->setInt(value); };
+    /** @param value the value to set. Here a float */
     inline void setValue(float value) { this->setFloat(value); };
+    /** @param value the value to set. Here a char */
     inline void setValue(char value) { this->setChar(value); };
+    /** @param value the value to set. Here a char array (string) */
     inline void setValue(const char* value) { this->setString(value); };
+    /** @param value the value to set. Here a string */
     inline void setValue(const std::string& value) { this->setString(value); };
     void setValueOf(const MultiType& mt);
 …
     inline MT_Type getType() const { return this->type; };
+    void storeString();
     /* RETRIEVING FUNCTIONS */
 …
     std::string getString() const;
     const std::string& getConstString() const;
+    const std::string& getStoredString() const;
     void reset();

trunk/src/lib/util/sigslot/signal.h

-                      r9406
+                      r9869
+  {
   public:
+    virtual ~_connection_base0() {};
     virtual has_slots<mt_policy>* getdest() const = 0;
     virtual void emit() = 0;
 …
+  {
   public:
+    virtual ~_connection_base1() {};
     virtual has_slots<mt_policy>* getdest() const = 0;
     virtual void emit(arg1_type) = 0;
 …
+  {
   public:
+    virtual ~_connection_base2() {};
     virtual has_slots<mt_policy>* getdest() const = 0;
     virtual void emit(arg1_type, arg2_type) = 0;
 …
+  {
   public:
+    virtual ~_connection_base3() {};
     virtual has_slots<mt_policy>* getdest() const = 0;
     virtual void emit(arg1_type, arg2_type, arg3_type) = 0;
 …
+  {
   public:
+    virtual ~_connection_base4() {};
     virtual has_slots<mt_policy>* getdest() const = 0;
     virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type) = 0;
 …
+  {
   public:
+    virtual ~_connection_base5() {};
     virtual has_slots<mt_policy>* getdest() const = 0;
     virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type,
 …
+  {
   public:
+    virtual ~_connection_base6() {};
     virtual has_slots<mt_policy>* getdest() const = 0;
     virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type,
 …
+  {
   public:
+    virtual ~_connection_base7() {};
     virtual has_slots<mt_policy>* getdest() const = 0;
     virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type,
 …
+  {
   public:
+    virtual ~_connection_base8() {};
     virtual has_slots<mt_policy>* getdest() const = 0;
     virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type,

trunk/src/lib/util/substring.cc

-                      r9406
+                      r9869
  * @param delimiters multiple set of characters at what to split. (delimiters)
  * @param delimiterNeighbours neighbours of the delimiters, that will be erased only when near a delimiter.
+ * @param emptyEntries If empty entries should be allewed or removed.
  * @param escapeChar The Escape Character that overrides splitters commends and so on...
  * @param safemode_char within these characters splitting won't happen
 …
 /** @brief Helper that gets you a String consisting of all WhiteSpaces and the Comma */
 const std::string SubString::WhiteSpacesWithComma = " \n\t,";
+/** An Empty SubString */
+const SubString SubString::NullSubString = SubString();
 /**
 …
  * @brief comparator.
  * @param subString the SubString to compare against this one.
+ * @param length how many entries to compare. (from 0 to length)
  * @returns true if the Stored Strings match
  */
 …
  * @brief splits line into tokens and stores them in ret.
  * @param ret the Array, where the Splitted strings will be stored in
- * @param offsets an Array of Offsets, here the distance from the inputstring
  * to the beginning of the current token is stored
  * @param line the inputLine to split
  * @param delimiters a String of Delimiters (here the input will be splitted)
  * @param delimiterNeighbour Naighbours to the Delimitter, that will be removed if they are to the left or the right of a Delimiter.
+ * @param delimiterNeighbours Naighbours to the Delimitter, that will be removed if they are to the left or the right of a Delimiter.
  * @param emptyEntries: if empty Strings are added to the List of Strings.
  * @param escape_char: Escape carater (escapes splitters)

trunk/src/lib/util/substring.h

-                      r9406
+                      r9869
+{
 public:
+  //! An enumerator for the State the Parser is in
   typedef enum {
     SL_NORMAL,
     SL_ESCAPE,
     SL_SAFEMODE,
     SL_SAFEESCAPE,
     SL_COMMENT,
+    SL_NORMAL,            //!< Normal state
+    SL_ESCAPE,            //!< After an escape character
+    SL_SAFEMODE,          //!< In safe mode (between "" mostly).
+    SL_SAFEESCAPE,        //!< In safe mode with the internal escape character, that escapes even the savemode character.
+    SL_COMMENT,           //!< In Comment mode.
   } SPLIT_LINE_STATE;
 …
             const std::string& delimiters, const std::string& delimiterNeighbours = "", bool emptyEntries=false,
             char escapeChar ='\\', char safemode_char = '"', char comment_char = '\0');
+  SubString(unsigned int argc, const char** argv);
   /** @brief create a Substring as a copy of another one. @param subString the SubString to copy. */
-  SubString(unsigned int argc, const char** argv);
   SubString(const SubString& subString) { *this = subString; };
   SubString(const SubString& subString, unsigned int subSetBegin);
 …
   static const std::string WhiteSpaces;
   static const std::string WhiteSpacesWithComma;
+  static const SubString   NullSubString;
 private:

Context Navigation

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

Legend: