Changeset 9703 in orxonox.OLD for branches/new_class_id/src/util

Timestamp:

Aug 25, 2006, 12:11:45 PM (18 years ago)

Author:

bensch

Message:

orxonox/new_object_list: fast factory, ObjectManager, and Hud adapted

Location:

branches/new_class_id/src/util

Files:

• fast_factory.cc (modified) (3 diffs)
• fast_factory.h (modified) (5 diffs)
• hud.cc (modified) (3 diffs)
• hud.h (modified) (1 diff)
• object_manager.cc (modified) (7 diffs)
• object_manager.h (modified) (3 diffs)

branches/new_class_id/src/util/fast_factory.cc

@@ -22 +22 @@
 
 
-
-/**
- * Initializes a FastFactory
+NewObjectListDefinition(FastFactory);
+
+/**
+ * @brief Initializes a FastFactory
  * @param classID the ClassID this Class belongs to (the top-most)
  * @param fastFactoryName the Name of the ObjectClass-handled here
  * @return a new FastFactory
  */
-FastFactory::FastFactory (ClassID classID, const std::string& fastFactoryName)
-{
-  this->setClassID(CL_FAST_FACTORY, "FastFactory");
+FastFactory::FastFactory (const NewClassID& classID, const std::string& fastFactoryName)
+{
+  this->registerObject(this, FastFactory::_objectList);
   this->setName(fastFactoryName);
 
@@ -97 +98 @@
  * @returns true if found, false otherwise.
  */
-FastFactory* FastFactory::searchFastFactory(ClassID classID)
+FastFactory* FastFactory::searchFastFactory(const NewClassID& classID)
 {
   if (FastFactory::first == NULL)
@@ -228 +229 @@
  * @return the Object to resurrect, NULL if classID is not found.
  */
-BaseObject* FastFactory::resurrect(ClassID classID)
+BaseObject* FastFactory::resurrect(const NewClassID& classID)
 {
   FastFactory* tmpFac = FastFactory::getFirst();

branches/new_class_id/src/util/fast_factory.h

@@ -43 +43 @@
 //! A struct, that holds Lists of Objects of a certain type.
 typedef struct FastObjectMember
-  {
-    BaseObject*          objectPointer;      //!< Pointer to the Object Stored in this Class (if it is the DeadList, else it is bork)
+{
+  BaseObject*          objectPointer;      //!< Pointer to the Object Stored in this Class (if it is the DeadList, else it is bork)
 
-    FastObjectMember*    next;               //!< the next stored FastObjectMember. (or NULL if this is the last one stored in either the deadList or the unusedContainers)
-  };
+  FastObjectMember*    next;               //!< the next stored FastObjectMember. (or NULL if this is the last one stored in either the deadList or the unusedContainers)
+};
 
 //! The FastFactory is a fast loadable object creator, and Dynamic List of dead object handler.
@@ -59 +59 @@
  */
 class FastFactory : public BaseObject
-  {
+{
+  NewObjectListDeclaration(FastFactory);
 
-  public:
-    virtual ~FastFactory ();
-    static void deleteAll();
+public:
+  virtual ~FastFactory ();
+  static void deleteAll();
 
-    // functions to push and pop elements of this class
-    BaseObject* resurrect();
-    static BaseObject* resurrect(ClassID classID);
-    void kill(BaseObject* object);
-    static void kill(BaseObject* object, bool searchForFastFactory);
+  // functions to push and pop elements of this class
+  BaseObject* resurrect();
+  static BaseObject* resurrect(const NewClassID& classID);
+  void kill(BaseObject* object);
+  static void kill(BaseObject* object, bool searchForFastFactory);
 
-    void prepare(unsigned int count);
+  void prepare(unsigned int count);
 
-    static void flushAll(bool hardFLUSH = false);
-    void flush(bool hardFLUSH = false);
+  static void flushAll(bool hardFLUSH = false);
+  void flush(bool hardFLUSH = false);
 
-    /** @returns the first FastFactory */
-    inline static FastFactory* getFirst() { return FastFactory::first; };
+  /** @returns the first FastFactory */
+  inline static FastFactory* getFirst() { return FastFactory::first; };
 
-    static FastFactory* searchFastFactory(ClassID classID);
-    static FastFactory* searchFastFactory(const std::string& fastFactoryName);
+  static FastFactory* searchFastFactory(const NewClassID& classID);
+  static FastFactory* searchFastFactory(const std::string& fastFactoryName);
 
-    ClassID getStoredID() const { return this->storedClassID; };
+  const NewClassID& getStoredID() const { return this->storedClassID; };
 
-  protected:
-    FastFactory (ClassID classID, const std::string& fastFactoryName = "");
+protected:
+  FastFactory (const NewClassID& classID, const std::string& fastFactoryName = "");
 
-    /** sets the Next factory in the list @param nextFactory the next factory */
-    inline void setNext( FastFactory* nextFastFactory) { this->next = nextFastFactory; };
-    /** @returns the next FastFactory */
-    FastFactory* getNext() const { return this->next; };
+  /** sets the Next factory in the list @param nextFactory the next factory */
+  inline void setNext( FastFactory* nextFastFactory) { this->next = nextFastFactory; };
+  /** @returns the next FastFactory */
+  FastFactory* getNext() const { return this->next; };
 
-    /** generates a new Object of the Class T */
-    virtual void fabricate() = 0;
+  /** generates a new Object of the Class T */
+  virtual void fabricate() = 0;
 
-  private:
-    static void registerFastFactory(FastFactory* fastFactory);
+private:
+  static void registerFastFactory(FastFactory* fastFactory);
 
-  protected:
-    ClassID               storedClassID;        //!< The classID of the specified class.
-    unsigned int          storedDeadObjects;    //!< How many dead objects are stored in this class
+protected:
+  NewClassID            storedClassID;        //!< The classID of the specified class.
+  unsigned int          storedDeadObjects;    //!< How many dead objects are stored in this class
 
-    FastObjectMember*     deadList;             //!< A List of all stored dead Objects of this class.
-    FastObjectMember*     unusedContainers;     //!< This is a List of unused containers, that will be reused by kill.
+  FastObjectMember*     deadList;             //!< A List of all stored dead Objects of this class.
+  FastObjectMember*     unusedContainers;     //!< This is a List of unused containers, that will be reused by kill.
 
-  private:
-    static FastFactory*   first;                //!< A pointer to the first FastFactory.
+private:
+  static FastFactory*   first;                //!< A pointer to the first FastFactory.
 
-    FastFactory*          next;                 //!< pointer to the next FastFactory.
-  };
+  FastFactory*          next;                 //!< pointer to the next FastFactory.
+};
 
 
@@ -119 +120 @@
 template<class T>
 class tFastFactory : public FastFactory
-  {
-  public:
-    static tFastFactory<T>* getFastFactory(ClassID classID, const std::string& fastFactoryName = NULL);
+{
+public:
+  static tFastFactory<T>* getFastFactory(const NewClassID& classID, const std::string& fastFactoryName = NULL);
 
-  private:
-    tFastFactory(ClassID classID, const std::string& fastFactoryName);
+private:
+  tFastFactory(const NewClassID& classID, const std::string& fastFactoryName);
 
-    virtual void fabricate();
-  };
+  virtual void fabricate();
+};
 
 /**
@@ -136 +137 @@
  */
 template<class T>
-tFastFactory<T>::tFastFactory(ClassID classID, const std::string& fastFactoryName)
+tFastFactory<T>::tFastFactory(const NewClassID& classID, const std::string& fastFactoryName)
     : FastFactory(classID, fastFactoryName)
 {}
@@ -147 +148 @@
  */
 template<class T>
-    tFastFactory<T>* tFastFactory<T>::getFastFactory(ClassID classID, const std::string& fastFactoryName)
+tFastFactory<T>* tFastFactory<T>::getFastFactory(const NewClassID& classID, const std::string& fastFactoryName)
 {
   tFastFactory<T>* tmpFac = NULL;

branches/new_class_id/src/util/hud.cc

@@ -34 +34 @@
 #include "playable.h"
 
+NewObjectListDefinition(Hud);
 /**
  * standard constructor
@@ -40 +41 @@
 Hud::Hud ()
 {
-  this->setClassID(CL_HUD, "Hud");
+  this->registerObject(this, Hud::_objectList);
 
   //this->setSize2D(
@@ -186 +187 @@
     printf("UPDATING RADAR\n");
     this->_radar->setCenterNode(State::getPlayer()->getPlayable());
-    this->_radar->addEntityList(&State::getObjectManager()->getObjectList((OM_LIST)(State::getPlayer()->getPlayable()->getOMListNumber()+1)), Color(.4, .4, 1.0));
-    this->_radar->addEntityList(&State::getObjectManager()->getObjectList(OM_GROUP_02), Color(1.0, .2, .2));
+    this->_radar->addEntityList(&State::getObjectManager()->getEntityList((OM_LIST)(State::getPlayer()->getPlayable()->getOMListNumber()+1)), Color(.4, .4, 1.0));
+    this->_radar->addEntityList(&State::getObjectManager()->getEntityList(OM_GROUP_02), Color(1.0, .2, .2));
     this->_radar->setAbsCoor2D(0.8 * this->resX, 0.01 * this->resY);
     this->_radar->setWidgetSize(0.2 * this->resX, 0.2 * this->resY);

branches/new_class_id/src/util/hud.h

@@ -23 +23 @@
 class Hud : public Element2D, public EventListener
 {
+  NewObjectListDeclaration(Hud);
 
 public:

branches/new_class_id/src/util/object_manager.cc

@@ -17 +17 @@
 
 #include "object_manager.h"
-#include "class_list.h"
 
 #include "world_entity.h"
@@ -30 +29 @@
     ->defaultValues("", 0);
 
+NewObjectListDefinition(ObjectManager);
 /**
  * @brief standard constructor
@@ -35 +35 @@
 ObjectManager::ObjectManager ()
 {
-   this->setClassID(CL_OBJECT_MANAGER, "ObjectManager");
+  this->registerObject(this, ObjectManager::_objectList);
    this->setName("ObjectManager");
 
@@ -63 +63 @@
 {
   for (unsigned int i = 0; i < OM_SIZE; ++i)
-    while(!this->objectLists[i].empty())
-      delete this->objectLists[i].front();
+    while(!this->entityLists[i].empty())
+      delete this->entityLists[i].front();
 
   // delete reflection list
@@ -83 +83 @@
 
   if (likely(entity->getOMListNumber() != OM_INIT))
-    this->objectLists[entity->getOMListNumber()].erase(entity->getEntityIterator());
+    this->entityLists[entity->getOMListNumber()].erase(entity->getEntityIterator());
 
   if (likely(omList != OM_INIT))
   {
-    this->objectLists[omList].push_back(entity);
-    entity->getEntityIterator() = --this->objectLists[omList].end();
+    this->entityLists[omList].push_back(entity);
+    entity->getEntityIterator() = --this->entityLists[omList].end();
     entity->getOMListNumber() = omList;
   }
@@ -111 +111 @@
  * @returns a new List with a list of WorldEntities of distance Radius from center
  */
-void ObjectManager::distanceFromObject(EntityList& entities, const PNode& center, float radius, ClassID classID)
-{
-  const std::list<BaseObject*>* objectList = ClassList::getList(classID);
-  if (objectList != NULL)
+  /*
+void ObjectManager::distanceFromObject(EntityList& entities, const PNode& center, float radius, const NewClassID& classID)
+{
+  TODO FIXME
+
+  const std::list<BaseObject*>* entityList = ClassList::getList(classID);
+  if (entityList != NULL)
   {
 
     std::list<BaseObject*>::const_iterator node;
-    for (node = objectList->begin(); node != objectList->end(); node++)
+    for (node = entityList->begin(); node != entityList->end(); node++)
       if ((dynamic_cast<PNode*>(*node)->getAbsCoor() - center.getAbsCoor()).len() < radius)
         entities.push_back(dynamic_cast<WorldEntity*>(*node));
   }
 }
+  */
 
 
@@ -134 +138 @@
   if (omList != OM_INIT || omList == OM_SIZE)
   {
-    PRINT(0)(" +ObjectManager-LIST: '%s'==size='%d'==---\n", ObjectManager::OMListToString((OM_LIST)omList).c_str(), this->objectLists[omList].size());
+    PRINT(0)(" +ObjectManager-LIST: '%s'==size='%d'==---\n", ObjectManager::OMListToString((OM_LIST)omList).c_str(), this->entityLists[omList].size());
   //  if (level >= 1)
     {
       ObjectManager::EntityList::const_iterator entity;
-      for (entity = this->objectLists[omList].begin(); entity != this->objectLists[omList].end(); entity++)
+      for (entity = this->entityLists[omList].begin(); entity != this->entityLists[omList].end(); entity++)
       {
         PRINT(0)(" | %s::%s\n",(*entity)->getClassCName(), (*entity)->getCName());

branches/new_class_id/src/util/object_manager.h

@@ -73 +73 @@
 class ObjectManager : public BaseObject
 {
+  NewObjectListDeclaration(ObjectManager);
 public:
   typedef std::list<WorldEntity*> EntityList;      //!< A type definition to make it easy to use EntityLists.
@@ -86 +87 @@
 
   /** @returns the List (listnumber) of objects. @param listNumber the List to get. */
-  EntityList& getObjectList(OM_LIST listNumber) { return this->objectLists[listNumber]; }
+  EntityList& getEntityList(OM_LIST listNumber) { return this->entityLists[listNumber]; }
   /** @returns a constant LIST of Objects. @param listNumber the objectList to returns */
-  const EntityList& getObjectList(OM_LIST listNumber) const { return this->objectLists[listNumber]; }
+  const EntityList& getEntityList(OM_LIST listNumber) const { return this->entityLists[listNumber]; }
 
   template <class T> static void distanceFromObject(EntityList& entities, const PNode& center, float radius, NewObjectList<T>& list);
@@ -111 +112 @@
   const std::list<BaseObject>*            pNodeList;                //!< The List of PNodes.
 
-  EntityList                              objectLists[OM_SIZE];     //!< The ObjectLists.
+  EntityList                              entityLists[OM_SIZE];     //!< The ObjectLists.
 
   static const std::string                objectManagerListNames[]; //!< Names of all the lists