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

Timestamp:

Nov 20, 2005, 6:32:39 PM (19 years ago)

Author:

bensch

Message:

orxonox/trunk: new LoadParam procedure with all NON-cycling load-options, and it works perfectly (on first sight

now going to make the same for cycling LoadOptions

Location:

trunk/src/lib

Files:

• coord/p_node.cc (modified) (1 diff)
• graphics/light.cc (modified) (1 diff)
• graphics/render2D/element_2d.cc (modified) (1 diff)
• gui/gl_gui/glmenu/glmenu_imagescreen.cc (modified) (3 diffs)
• lang/base_object.cc (modified) (1 diff)
• particles/particle_emitter.cc (modified) (2 diffs)
• particles/particle_system.cc (modified) (2 diffs)
• physics/fields/field.cc (modified) (1 diff)
• physics/physics_connection.cc (modified) (1 diff)
• physics/physics_engine.cc (modified) (1 diff)
• shell/shell_command.cc (modified) (2 diffs)
• util/executor/executor.h (modified) (5 diffs)
• util/executor/executor_specials.h (modified) (2 diffs)

trunk/src/lib/coord/p_node.cc

@@ -141 +141 @@
   static_cast<BaseObject*>(this)->loadParams(root);
 
-  LoadParam<PNode>(root, "rel-coor", this, &PNode::setRelCoor)
+  LoadParamNEW(root, "rel-coor", this, PNode, setRelCoor)
       .describe("Sets The relative position of the Node to its parent.");
 
-  LoadParam<PNode>(root, "abs-coor", this, &PNode::setAbsCoor)
+  LoadParamNEW(root, "abs-coor", this, PNode, setAbsCoor)
       .describe("Sets The absolute Position of the Node.");
 
-  LoadParam<PNode>(root, "rel-dir", this, &PNode::setRelDir)
+  LoadParamNEW(root, "rel-dir", this, PNode, setRelDir)
       .describe("Sets The relative rotation of the Node to its parent.");
 
-  LoadParam<PNode>(root, "abs-dir", this, &PNode::setAbsDir)
+  LoadParamNEW(root, "abs-dir", this, PNode, setAbsDir)
       .describe("Sets The absolute rotation of the Node.");
 
-  LoadParam<PNode>(root, "parent", this, &PNode::setParent)
+  LoadParamNEW(root, "parent", this, PNode, setParent)
       .describe("the Name of the Parent of this PNode");
 
-  LoadParam<PNode>(root, "parent-mode", this, &PNode::setParentMode)
+  LoadParamNEW(root, "parent-mode", this, PNode, setParentMode)
       .describe("the mode to connect this node to its parent ()");
 

trunk/src/lib/graphics/light.cc

@@ -88 +88 @@
   static_cast<PNode*>(this)->loadParams(root);
 
-  LoadParam<Light>(root, "diffuse-color", this, &Light::setDiffuseColor)
+  LoadParamNEW(root, "diffuse-color", this, Light, setDiffuseColor)
       .describe("sets the diffuse color of the Light (red [0-1], green [0-1], blue [0-1])");
 
-  LoadParam<Light>(root, "specular-color", this, &Light::setSpecularColor)
+  LoadParamNEW(root, "specular-color", this, Light, setSpecularColor)
       .describe("sets the specular color of the Light (red [0-1], green [0-1], blue [0-1])");
 
-  LoadParam<Light>(root, "attenuation", this, &Light::setAttenuation)
+  LoadParamNEW(root, "attenuation", this, Light, setAttenuation)
       .describe("sets the Attenuation of the LightSource (constant Factor, linear Factor, quadratic Factor).");
 
-  LoadParam<Light>(root, "spot-direction", this, &Light::setSpotDirection)
+  LoadParamNEW(root, "spot-direction", this, Light, setSpotDirection)
       .describe("sets the Direction of the Spot");
 
-  LoadParam<Light>(root, "spot-cutoff", this, &Light::setSpotCutoff)
+  LoadParamNEW(root, "spot-cutoff", this, Light, setSpotCutoff)
       .describe("the cuttoff of the Spotlight");
 }

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

@@ -130 +130 @@
 {
   // ELEMENT2D-native settings.
-  LoadParam<Element2D>(root, "alignment", this, &Element2D::setAlignment)
+  LoadParamNEW(root, "alignment", this, Element2D, setAlignment)
       .describe("loads the alignment: (either: center, left, right or screen-center)");
 
-  LoadParam<Element2D>(root, "layer", this, &Element2D::setLayer)
+  LoadParamNEW(root, "layer", this, Element2D, setLayer)
       .describe("loads the layer onto which to project: (either: top, medium, bottom, below-all)");
 
-  LoadParam<Element2D>(root, "bind-node", this, &Element2D::setBindNode)
+  LoadParamNEW(root, "bind-node", this, Element2D, setBindNode)
       .describe("sets a node, this 2D-Element should be shown upon (name of the node)");
 
-  LoadParam<Element2D>(root, "visibility", this, &Element2D::setVisibility)
+  LoadParamNEW(root, "visibility", this, Element2D, setVisibility)
       .describe("if the Element is visible or not");
 
 
 // PNode-style:
-  LoadParam<Element2D>(root, "rel-coor", this, &Element2D::setRelCoor2D)
+  LoadParamNEW(root, "rel-coor", this, Element2D, setRelCoor2D)
       .describe("Sets The relative position of the Node to its parent.");
 
-  LoadParam<Element2D>(root, "abs-coor", this, &Element2D::setAbsCoor2D)
+  LoadParamNEW(root, "abs-coor", this, Element2D, setAbsCoor2D)
       .describe("Sets The absolute Position of the Node.");
 
-  LoadParam<Element2D>(root, "rel-dir", this, &Element2D::setRelDir2D)
+  LoadParamNEW(root, "rel-dir", this, Element2D, setRelDir2D)
       .describe("Sets The relative rotation of the Node to its parent.");
 
-  LoadParam<Element2D>(root, "abs-dir", this, &Element2D::setAbsDir2D)
+  LoadParamNEW(root, "abs-dir", this, Element2D, setAbsDir2D)
       .describe("Sets The absolute rotation of the Node.");
 
-  LoadParam<Element2D>(root, "parent", this, &Element2D::setParent2D)
+  LoadParamNEW(root, "parent", this, Element2D, setParent2D)
       .describe("the Name of the Parent of this Element2D");
 
-  LoadParam<Element2D>(root, "parent-mode", this, &Element2D::setParentMode2D)
+  LoadParamNEW(root, "parent-mode", this, Element2D, setParentMode2D)
       .describe("the mode to connect this node to its parent ()");
 

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

@@ -57 +57 @@
 void GLMenuImageScreen::loadParams(const TiXmlElement* root)
 {
-  LoadParam<GLMenuImageScreen>(root, "BackgroundImage", this, &GLMenuImageScreen::setBackgroundImage)
+  LoadParamNEW(root, "BackgroundImage", this, GLMenuImageScreen, setBackgroundImage)
     .describe("sets the image to load onto the loadscreen");
 
-  LoadParam<GLMenuImageScreen>(root, "BackgroundPS", this, &GLMenuImageScreen::setPosScale)
+  LoadParamNEW(root, "BackgroundPS", this, GLMenuImageScreen, setPosScale)
     .describe("The Position and Scale of the Background Image in %(0-1.0). PosX, PosY, SizeX, SizeY");
 
-  LoadParam<GLMenuImageScreen>(root, "BarImage", this, &GLMenuImageScreen::setBarImage)
+  LoadParamNEW(root, "BarImage", this, GLMenuImageScreen, setBarImage)
     .describe("sets the image of the LoadingBar");
 
-  LoadParam<GLMenuImageScreen>(root, "BarPS", this, &GLMenuImageScreen::setBarPosScale)
+  LoadParamNEW(root, "BarPS", this, GLMenuImageScreen, setBarPosScale)
     .describe("The Position and Scale of the Loading Bar in %(0-1.0). PosX, PosY, SizeX, SizeY");
 
-  LoadParam<GLMenuImageScreen>(root, "ElementCount", this, &GLMenuImageScreen::setMaximum)
+  LoadParamNEW(root, "ElementCount", this, GLMenuImageScreen, setMaximum)
     .describe("The Count of elements to load into the bar (this is only a maximum value)");
 }
@@ -123 +123 @@
 void GLMenuImageScreen::setPosScale(float offsetX, float offsetY, float scaleX, float scaleY)
 {
+  printf("IMG: %f %f %f %f\n", offsetX, offsetY,offsetX, offsetY);
   this->setPosition(offsetX, offsetY);
   this->setScale(scaleX, scaleY);
@@ -144 +145 @@
 void GLMenuImageScreen::setBarPosScale(float barX, float barY, float barW, float barH)
 {
+  printf("BAR: %f %f %f %f\n", barX, barY, barW, barH);
+
   this->barX = barX;
   this->barY = barY;

trunk/src/lib/lang/base_object.cc

@@ -63 +63 @@
   // name setup
   LoadParamNEW(root, "name", this, BaseObject, setName)
-  //LoadParamBase(root, "name", this, ExecutorObjective<BaseObject>(&BaseObject::setName))
       .describe("the Name of the Object.");
-//  LoadParam<BaseObject>(root, "name", this, &BaseObject::setName)
-      //.describe("the name of the Object at hand");
 }
 

trunk/src/lib/particles/particle_emitter.cc

@@ -22 +22 @@
 
 #include "load_param.h"
+#include "factory.h"
 #include "debug.h"
 #include "stdlibincl.h"
@@ -94 +95 @@
   static_cast<PNode*>(this)->loadParams(root);
 
-  LoadParam<ParticleEmitter>(root, "type", this, &ParticleEmitter::setType)
+  LoadParamNEW(root, "type", this, ParticleEmitter, setType)
     .describe("What type of emitter is this [dot, plane, cube, sphere].");
 
-  LoadParam<ParticleEmitter>(root, "size", this, &ParticleEmitter::setSize)
+  LoadParamNEW(root, "size", this, ParticleEmitter, setSize)
     .describe("How big the emitter is (no effect on dot-emitters)");
 
-  LoadParam<ParticleEmitter>(root, "rate", this, &ParticleEmitter::setEmissionRate)
+  LoadParamNEW(root, "rate", this, ParticleEmitter, setEmissionRate)
     .describe("How many particles should be emittet from this emitter");
 
-  LoadParam<ParticleEmitter>(root, "inherit-speed", this, &ParticleEmitter::setInheritSpeed)
+  LoadParamNEW(root, "inherit-speed", this, ParticleEmitter, setInheritSpeed)
     .describe("the extent, the speed of the emitter has on the particles");
 
-  LoadParam<ParticleEmitter>(root, "emission-velocity", this, &ParticleEmitter::setEmissionVelocity)
+  LoadParamNEW(root, "emission-velocity", this, ParticleEmitter, setEmissionVelocity)
     .describe("How fast the particles are emittet (their initial speed)");
 
-  LoadParam<ParticleEmitter>(root, "emission-momentum", this, &ParticleEmitter::setEmissionMomentum)
+  LoadParamNEW(root, "emission-momentum", this, ParticleEmitter, setEmissionMomentum)
       .describe("How fast the particles rotation is at emissiontime (their initial momentum)");
 
-  LoadParam<ParticleEmitter>(root, "spread", this, &ParticleEmitter::setSpread)
+  LoadParamNEW(root, "spread", this, ParticleEmitter, setSpread)
     .describe("The angle the particles are emitted from (angle, deviation)");
 

trunk/src/lib/particles/particle_system.cc

@@ -25 +25 @@
 
 #include "load_param.h"
-#include "compiler.h"
+#include "factory.h"
 #include "material.h"
 #include "state.h"
@@ -119 +119 @@
   static_cast<PhysicsInterface*>(this)->loadParams(root);
 
-  LoadParam<ParticleSystem>(root, "max-count", this, &ParticleSystem::setMaxCount)
+  LoadParamNEW(root, "max-count", this, ParticleSystem, setMaxCount)
       .describe("the maximal count of Particles, that can be emitted into this system");
 
   //LoadParam<ParticleSystem>(root, "type", this, &ParticleSystem::setType);
-  LoadParam<ParticleSystem>(root, "life-span", this, &ParticleSystem::setLifeSpan)
+  LoadParamNEW(root, "life-span", this, ParticleSystem, setLifeSpan)
       .describe("sets the life-span of the Particles.");
 
-  LoadParam<ParticleSystem>(root, "conserve", this, &ParticleSystem::setConserve)
-      .describe("sets the Conserve facrot of the Particles (1.0: they keep all their energy, 0.0:they keep no energy)");
-
-  LoadParam<ParticleSystem>(root, "type", this, &ParticleSystem::setType)
+  LoadParamNEW(root, "conserve", this, ParticleSystem, setConserve)
+      .describe("sets the Conserve factor of the Particles (1.0: they keep all their energy, 0.0:they keep no energy)");
+
+  LoadParamNEW(root, "type", this, ParticleSystem, setType)
       .describe("sets the type of the Particles, (dot, spark, sprite or model)");
 

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

@@ -60 +60 @@
   static_cast<PNode*>(this)->loadParams(root);
 
-  LoadParam<Field>(root, "magnitude", this, &Field::setMagnitude)
-      .describe("sets the magnitude of this Field");
+  LoadParamNEW(root, "magnitude", this, Field, setMagnitude)
+      .describe("sets the magnitude of this Field")
+      ->defaultValues(1, 1);
 
-  LoadParam<Field>(root, "attenuation", this, &Field::setAttenuation)
+  LoadParamNEW(root, "attenuation", this, Field, setAttenuation)
       .describe("sets the attenuation of this Field.");
 

trunk/src/lib/physics/physics_connection.cc

@@ -52 +52 @@
   static_cast<BaseObject*>(this)->loadParams(root);
 
-  LoadParam<PhysicsConnection>(root, "subject", this, &PhysicsConnection::setSubject)
+  LoadParamNEW(root, "subject", this, PhysicsConnection, setSubject)
       .describe("set the subject by a name");
 
-  LoadParam<PhysicsConnection>(root, "field", this, &PhysicsConnection::setField)
+  LoadParamNEW(root, "field", this, PhysicsConnection, setField)
       .describe("set the field by name");
 

trunk/src/lib/physics/physics_engine.cc

@@ -93 +93 @@
 void PhysicsEngine::loadParams(const TiXmlElement* root)
 {
-  LoadParam<PhysicsEngine>(root, "Fields", this, &PhysicsEngine::loadFields)
+  LoadParamXML(root, "Fields", this, PhysicsEngine, loadFields)
       .describe("loads a list of fields");
 
-  LoadParam<PhysicsEngine>(root, "Connections", this, &PhysicsEngine::loadConnections)
+  LoadParamXML(root, "Connections", this, PhysicsEngine, loadConnections)
       .describe("loads a list of fields");
 }

trunk/src/lib/shell/shell_command.cc

@@ -74 +74 @@
 
 }
-
-
-
 
 /**
@@ -256 +253 @@
           if (!strcmp(enumCMD->getName(), inputSplits.getString(fktPos)))
           {
-            if (objectPointer == NULL && enumCMD->executor->getType() == Executor_Objective)
+            if (objectPointer == NULL && enumCMD->executor->getType() & Executor_Objective)
             {
               delete itCMD;

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

@@ -21 +21 @@
 //! an enumerator for the definition of the Type.
 typedef enum {
-  Executor_Objective   = 1,
-  Executor_Static      = 2,
+  Executor_Objective         = 0x00000001,
+  Executor_Static            = 0x00000002,
+
+  Executor_NoLoadString      = 0x00000010,
 } Executor_Type;
 
@@ -43 +45 @@
 
     /** @returns the Type of this Function (either static or objective) */
-    inline Executor_Type getType() const { return this->functorType; };
+    inline long getType() const { return this->functorType; };
     /** @returns the Count of Parameters this Executor takes */
     inline unsigned int getParamCount() const { return this->paramCount; };
@@ -56 +58 @@
 
   protected:
-    Executor_Type                    functorType;      //!< The type of Function we've got (either static or objective).
-    unsigned int                     paramCount;       //!< the count of parameters.
-    MultiType*                       defaultValue;     //!< Default Values.
+    long                        functorType;      //!< The type of Function we've got (either static or objective).
+    unsigned int                paramCount;       //!< the count of parameters.
+    MultiType*                  defaultValue;     //!< Default Values.
 };
 
@@ -196 +198 @@
 #define ExecutorExecute4(t1,t2,t3,t4) \
    else if (this->paramCount == 4 && this->defaultValue[0].getType() == t1##_PARAM && this->defaultValue[1].getType() == t2##_PARAM && this->defaultValue[2].getType() == t3##_PARAM && this->defaultValue[3].getType() == t4##_PARAM) \
-    EXECUTOREXECUTER(_4_##t1##_##t2##_##t3##_##t4)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)), t3##_FUNC(sub.getString(2), t3##_DEFGRAB(2)), t4##_FUNC(sub.getString(3), t4##_DEFGRAB(3)))
+    EXECUTOREXECUTER(_4_##t1##_##t2##_##t3##_##t4)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)), t3##_FUNC(sub.getString(2), t3##_DEFGRAB(2)), t4##_FUNC(sub.getString(3), t4##_DEFGRAB(3))) \
+
 
 //! execute-macro for functions with five parameters
@@ -258 +261 @@
     virtual void execute (BaseObject* object, const char* parameters)
     {
-      SubString sub(parameters, true);
+      SubString sub(parameters, ',');  /// FIXME ///
 //! FUNCTOR_LIST is the List of Executive Functions
 #define FUNCTOR_LIST(x) ExecutorExecute ## x

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

@@ -38 +38 @@
 
       this->functionPointer = function;
+      this->functorType = Executor_Objective | Executor_NoLoadString;
     }
 
@@ -66 +67 @@
   private:
     /**
-     * used for the copy-constructor
+     * used for the copy-(Clone)-constructor
      */
     ExecutorXML() : Executor() { };