Changeset 5654 in orxonox.OLD for trunk

Timestamp:

Nov 20, 2005, 9:12:50 PM (19 years ago)

Author:

bensch

Message:

orxonox/trunk: cycle-loading of LoadParam works…

Location:

trunk/src

Files:

• lib/coord/p_node.cc (modified) (1 diff)
• lib/graphics/render2D/element_2d.cc (modified) (1 diff)
• lib/particles/particle_engine.cc (modified) (1 diff)
• lib/particles/particle_system.cc (modified) (2 diffs)
• util/loading/load_param.cc (modified) (2 diffs)
• util/loading/load_param.h (modified) (4 diffs)
• util/track/track_manager.cc (modified) (2 diffs)
• world_entities/terrain.cc (modified) (1 diff)
• world_entities/weapons/weapon_manager.cc (modified) (1 diff)

trunk/src/lib/coord/p_node.cc

@@ -162 +162 @@
   if (root != NULL)
   {
-    const TiXmlElement* element = root->FirstChildElement();
-    while (element != NULL)
+    LOAD_PARAM_START_CYCLE(root, element);
     {
-      LoadParam<PNode>(element, "parent", this, &PNode::addChild, true)
+      LoadParam_CYCLE(element, "parent", this, PNode, addChild)
           .describe("adds a new Child to the current Node.");
 
-      element = element->NextSiblingElement();
     }
+    LOAD_PARAM_END_CYCLE(element);
   }
 }

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

@@ -165 +165 @@
   if (root != NULL)
   {
-    const TiXmlElement* element = root->FirstChildElement();
-    while (element != NULL)
-    {
-      LoadParam<Element2D>(root, "parent", this, &Element2D::addChild2D, true)
+    LOAD_PARAM_START_CYCLE(root, element);
+    {
+      LoadParam_CYCLE(element, "parent", this, Element2D, addChild2D)
           .describe("adds a new Child to the current Node.");
-
-      element = element->NextSiblingElement();
-    }
+    }
+    LOAD_PARAM_END_CYCLE(element);
   }
 }

trunk/src/lib/particles/particle_engine.cc

@@ -90 +90 @@
 void ParticleEngine::loadParams(const TiXmlElement* root)
 {
-  const TiXmlElement* element = root->FirstChildElement();
-  while( element != NULL)
-  {
-    LoadParam<ParticleEngine>(element, "connect", this, &ParticleEngine::addConnection, true)
+  LOAD_PARAM_START_CYCLE(root, element);
+  {
+    LoadParam_CYCLE(element, "connect", this, ParticleEngine, addConnection)
         .describe("connects an Emitter to a System (emitterName, systemName)");
-    element = element->NextSiblingElement();
-  }
+  }
+  LOAD_PARAM_END_CYCLE(element);
 }
 

trunk/src/lib/particles/particle_system.cc

@@ -122 +122 @@
       .describe("the maximal count of Particles, that can be emitted into this system");
 
-  //LoadParam<ParticleSystem>(root, "type", this, &ParticleSystem::setType);
   LoadParamNEW(root, "life-span", this, ParticleSystem, setLifeSpan)
       .describe("sets the life-span of the Particles.");
@@ -132 +131 @@
       .describe("sets the type of the Particles, (dot, spark, sprite or model)");
 
-  const TiXmlElement* element = root->FirstChildElement();
-  while (element != NULL)
+  LOAD_PARAM_START_CYCLE(root, element);
   {
-
+    element->ToText();
   // PER-PARTICLE-ATTRIBUTES:
-    LoadParam<ParticleSystem>(element, "radius", this, &ParticleSystem::setRadius, true)
+    LoadParam_CYCLE(element, "radius", this, ParticleSystem, setRadius)
         .describe("The Radius of each particle over time (TimeIndex [0-1], radius at TimeIndex, randomRadius at TimeIndex)");
 
-    LoadParam<ParticleSystem>(element, "mass", this, &ParticleSystem::setMass, true)
+    LoadParam_CYCLE(element, "mass", this, ParticleSystem, setMass)
         .describe("The Mass of each particle over time (TimeIndex: [0-1], mass at TimeIndex, randomMass at TimeIndex)");
 
-    LoadParam<ParticleSystem>(element, "color", this, &ParticleSystem::setColor, true)
+    LoadParam_CYCLE(element, "color", this, ParticleSystem, setColor)
         .describe("The Color of each particle over time (TimeIndex: [0-1], red: [0-1], green: [0-1], blue: [0-1], alpha: [0-1])");
-    element = element->NextSiblingElement();
   }
+  LOAD_PARAM_END_CYCLE(element);
 
 }

trunk/src/util/loading/load_param.cc

@@ -13 +13 @@
    co-programmer: ...
 */
+
+#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_LOADING
 
 #include "functor_list.h"
@@ -114 +116 @@
  * @param executor the Executor, that executes the loading procedure.
  */
-LoadParamBase::LoadParamBase(const TiXmlElement* root, const char* paramName, BaseObject* object, const Executor& executor)
-{
-  this->loadString = grabParameter(root, paramName);
+LoadParamBase::LoadParamBase(const TiXmlElement* root, const char* paramName, BaseObject* object, const Executor& executor, bool inLoadCycle)
+{
   this->paramName = paramName;
   this->object = object;
-  if (root != NULL)
-  {
-    this->executor = executor.clone();
-  }
+  this->inLoadCycle = inLoadCycle;
+
+  // determin the LoadString.
+  if (likely(!inLoadCycle))
+    this->loadString = grabParameter(root, paramName);
   else
   {
-    this->executor = NULL;
+    if (!strcmp(root->Value(), paramName))
+    {
+      const TiXmlNode* val = root->FirstChild();
+      if( val->ToText())
+        this->loadString = val->Value();
+    }
+    else
+      this->loadString = NULL;
   }
 
+  // set the Executor.
+  this->executor = executor.clone();
 }
 

trunk/src/util/loading/load_param.h

@@ -46 +46 @@
  */
 #define LoadParamNEW(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
-         LoadParamBase(ROOT, PARAMETER_NAME, OBJECT, ExecutorObjective<CLASS>(&CLASS::FUNCTION))
+         LoadParamBase(ROOT, PARAMETER_NAME, OBJECT, ExecutorObjective<CLASS>(&CLASS::FUNCTION), false)
+
+#define LoadParam_CYCLE(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
+         LoadParamBase(ROOT, PARAMETER_NAME, OBJECT, ExecutorObjective<CLASS>(&CLASS::FUNCTION), true)
 
 #define LoadParamXML(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
-         LoadParamBase(ROOT, PARAMETER_NAME, OBJECT, ExecutorXML<CLASS>(&CLASS::FUNCTION, ROOT, PARAMETER_NAME))
+         LoadParamBase(ROOT, PARAMETER_NAME, OBJECT, ExecutorXML<CLASS>(&CLASS::FUNCTION, ROOT, PARAMETER_NAME), false)
+
+#define LoadParamXML_CYCLE(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
+         LoadParamBase(ROOT, PARAMETER_NAME, OBJECT, ExecutorXML<CLASS>(&CLASS::FUNCTION, ROOT, PARAMETER_NAME), true)
+
+
+/**
+ * this Starts a Cycle in the Loading Process
+ * be aware, that in the cycle the first parameter of load_param should because
+ * called element, and that you must say true at the Fith parameter, or it will fail
+ * also you will have to close the Cycle again with LOAD_PARAM_END_CYCLE
+ *
+ * @param ROOT The root XLM-element to search element under.
+ * @param ELEMENT the element to search
+ */
+#define LOAD_PARAM_START_CYCLE(ROOT, ELEMENT) \
+  const TiXmlElement* ELEMENT; \
+  ELEMENT= ROOT->FirstChildElement(); \
+  while( ELEMENT != NULL) \
+{
+/**
+   * closes a LoadParam Loop
+   * @see LOAD_PARAM_START_CYCLE
+   * @param ELEMENT the Element to step through.
+ */
+#define LOAD_PARAM_END_CYCLE(ELEMENT) \
+  ELEMENT = ELEMENT->NextSiblingElement(); \
+}
+
+
 
 
@@ -59 +91 @@
 {
   public:
-    LoadParamBase(const TiXmlElement* root, const char* paramName, BaseObject* object, const Executor& exeutor);
+    LoadParamBase(const TiXmlElement* root, const char* paramName, BaseObject* object, const Executor& executor, bool inLoadCycle = false);
     ~LoadParamBase();
 
@@ -69 +101 @@
 
   protected:
-    bool                     withLoadString;       //!< If we need the loadString to execute this.
+    bool                     inLoadCycle;
     Executor*                executor;
     BaseObject*              object;
@@ -82 +114 @@
 };
 
-
-//! macro that makes it even more easy to load a Parameter
-/**
- * @param className the name of the class to load
- * @param parameterName the name of the parameter to load as written in the XML-file
- * @param function the function to call
- */
-#define LOAD_PARAM(className, parameterName, paramFunction) \
-        LoadParam<className>(root, #parameterName, this, &className::paramFunction)
-
-/**
- * this Starts a Cycle in the Loading Process
- * be aware, that in the cycle the first parameter of load_param should because
- * called element, and that you must say true at the Fith parameter, or it will fail
- * also you will have to close the Cycle again with LOAD_PARAM_END_CYCLE
- *
- * @param ROOT The root XLM-element to search element under.
- * @param ELEMENT the element to search
- */
-#define LOAD_PARAM_START_CYCLE(ROOT, ELEMENT) \
-  const TiXmlElement* ELEMENT; \
-  ELEMENT= ROOT->FirstChildElement(); \
-  while( ELEMENT != NULL) \
-  {
-/**
- * closes a LoadParam Loop
- * @see LOAD_PARAM_START_CYCLE
- * @param ELEMENT the Element to step through.
- */
-#define LOAD_PARAM_END_CYCLE(ELEMENT) \
-  ELEMENT = ELEMENT->NextSiblingElement(); \
-  }
 
 

trunk/src/util/track/track_manager.cc

@@ -398 +398 @@
   double x, y, z, d;
 
-  LOAD_PARAM_START_CYCLE(root, element)
-
-      LoadParam<TrackManager>(element, "WorkOn", this, &TrackManager::workOnS, true)
+  LOAD_PARAM_START_CYCLE(root, element);
+  {
+
+    LoadParam_CYCLE(element, "WorkOn", this, TrackManager, workOnS)
         .describe("Selects a TrackElement (by name) to work on");
 
-      LoadParam<TrackManager>(element, "Point", this, &TrackManager::addPoint, true)
+    LoadParam_CYCLE(element, "Point", this, TrackManager, addPoint)
         .describe("Adds a new Point to the currently selected TrackElement");
 
-      LoadParam<TrackManager>(element, "Duration", this, &TrackManager::setDuration, true)
+    LoadParam_CYCLE(element, "Duration", this, TrackManager, setDuration)
         .describe("Sets the Duration of the currently selected TrackElement");
 
-      LoadParam<TrackManager>(element, "HotPoint", this, &TrackManager::addHotPoint, true)
+    LoadParam_CYCLE(element, "HotPoint", this, TrackManager, addHotPoint)
         .describe("Sets a new Point that acts as a hot point. meaning, the curve will flow through this Point");
 
-      LoadParam<TrackManager>(element, "SavePoint", this, &TrackManager::setSavePointS, true)
+    LoadParam_CYCLE(element, "SavePoint", this, TrackManager, setSavePointS)
         .describe("Sets the current selected Point to a Savepoint, meaning that the curve will be ended and a new one starts, and that one starts again from this point on");
 
-      LoadParam<TrackManager>(element, "Fork", this, &TrackManager::forkS, true)
+    LoadParam_CYCLE(element, "Fork", this, TrackManager, forkS)
         .describe("Forks the Path into multiple forked Path names seperated by ','");
 
-      LoadParam<TrackManager>(element, "Join", this, &TrackManager::joinS, true)
+    LoadParam_CYCLE(element, "Join", this, TrackManager, joinS)
         .describe("Joins multiple joining Path names seperated by ','");
 
       /*
-        if( !strcmp( element->Value(), "Fork"))
-        {
-        container = element->FirstChild();
-        if( container->ToText())
+    if( !strcmp( element->Value(), "Fork"))
+    {
+    container = element->FirstChild();
+    if( container->ToText())
         {
         assert( container->Value() != NULL);
@@ -445 +446 @@
         }
       */
-      LOAD_PARAM_END_CYCLE(element);
+  }
+  LOAD_PARAM_END_CYCLE(element);
 }
 

trunk/src/world_entities/terrain.cc

@@ -106 +106 @@
   LoadParamNEW(root, "vegetation", this, Terrain, loadVegetation)
       .describe("the fileName of the vegetation, that should be loaded onto this terrain. (must be relative to the data-dir)") ;
-
-  //LoadParam<Terrain>(root, "DebugTerrain",  );
 }
 

trunk/src/world_entities/weapons/weapon_manager.cc

@@ -123 +123 @@
 
   LOAD_PARAM_START_CYCLE(root, element);
-
-
-  LoadParamXML(element, "weapons", this, WeaponManager, loadWeapons)
-      .describe("loads Weapons");
-
+  {
+    // CHECK IF THIS WORKS....
+    LoadParamXML_CYCLE(element, "weapons", this, WeaponManager, loadWeapons)
+        .describe("loads Weapons");
+  }
   LOAD_PARAM_END_CYCLE(element);
 }