Index: trunk/src/lib/graphics/render2D/element_2d.cc
===================================================================
--- trunk/src/lib/graphics/render2D/element_2d.cc	(revision 9406)
+++ trunk/src/lib/graphics/render2D/element_2d.cc	(revision 9869)
@@ -29,10 +29,12 @@
 #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);
 
 
@@ -46,5 +48,5 @@
 Element2D::Element2D (Element2D* parent, E2D_LAYER layer, short nodeFlags)
 {
-  this->setClassID(CL_ELEMENT_2D, "Element2D");
+  this->registerObject(this, Element2D::_objectList);
 
   this->setVisibility(true);
@@ -268,5 +270,5 @@
 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;
@@ -640,5 +642,5 @@
 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);
@@ -718,5 +720,5 @@
 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);
@@ -771,5 +773,5 @@
 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);
Index: trunk/src/lib/graphics/render2D/element_2d.h
===================================================================
--- trunk/src/lib/graphics/render2D/element_2d.h	(revision 9406)
+++ trunk/src/lib/graphics/render2D/element_2d.h	(revision 9869)
@@ -47,5 +47,5 @@
 
   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.
@@ -58,5 +58,5 @@
   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.
 
 
@@ -87,195 +87,197 @@
  * -> 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
 };
 
Index: trunk/src/lib/graphics/render2D/image_plane.cc
===================================================================
--- trunk/src/lib/graphics/render2D/image_plane.cc	(revision 9406)
+++ trunk/src/lib/graphics/render2D/image_plane.cc	(revision 9869)
@@ -21,12 +21,11 @@
 
 #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);
 
 
@@ -56,5 +55,5 @@
 void ImagePlane::init()
 {
-  this->setClassID(CL_IMAGE_PLANE, "ImagePlane");
+  this->registerObject(this, ImagePlane::_objectList);
   this->setName("ImagePlane");
 
Index: trunk/src/lib/graphics/render2D/image_plane.h
===================================================================
--- trunk/src/lib/graphics/render2D/image_plane.h	(revision 9406)
+++ trunk/src/lib/graphics/render2D/image_plane.h	(revision 9869)
@@ -17,5 +17,5 @@
 class ImagePlane :  public Element2D
 {
-
+  ObjectListDeclaration(ImagePlane);
   public:
     ImagePlane(const TiXmlElement* root = NULL);
Index: trunk/src/lib/graphics/render2D/render_2d.cc
===================================================================
--- trunk/src/lib/graphics/render2D/render_2d.cc	(revision 9406)
+++ trunk/src/lib/graphics/render2D/render_2d.cc	(revision 9869)
@@ -19,7 +19,7 @@
 
 #include "graphics_engine.h"
-#include "class_list.h"
 #include "element_2d.h"
 
+ObjectListDefinition(Render2D);
 
 
@@ -29,8 +29,8 @@
 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;
 }
 
Index: trunk/src/lib/graphics/render2D/render_2d.h
===================================================================
--- trunk/src/lib/graphics/render2D/render_2d.h	(revision 9406)
+++ trunk/src/lib/graphics/render2D/render_2d.h	(revision 9869)
@@ -12,24 +12,27 @@
 
 //! 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 */
