Changeset 4728 in orxonox.OLD for orxonox/trunk/src/lib/physics

Timestamp:

Jun 28, 2005, 11:56:46 PM (19 years ago)

Author:

bensch

Message:

orxonox/trunk: more loading (especially for physics)

Location:

orxonox/trunk/src/lib/physics

Files:

• fields/field.cc (modified) (4 diffs)
• fields/field.h (modified) (4 diffs)
• fields/gravity.cc (modified) (4 diffs)
• fields/gravity.h (modified) (2 diffs)
• physics_connection.cc (modified) (3 diffs)
• physics_connection.h (modified) (1 diff)
• physics_engine.cc (modified) (5 diffs)
• physics_engine.h (modified) (2 diffs)

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

@@ -1 @@
-/* 
+/*
    orxonox - the future of 3D-vertical-scrollers
 
@@ -20 +20 @@
 #include "physics_engine.h"
 
+#include "factory.h"
+#include "load_param.h"
 using namespace std;
-
 
 /**
    \brief standard constructor
-   \todo this constructor is not jet implemented - do it
 */
-Field::Field () 
+Field::Field ()
 {
-   this->setClassName ("Field");
-   this->setMagnitude(1);
-   this->setAttenuation(0);
-   
-   PhysicsEngine::getInstance()->addField(this);
+  this->init();
 }
 
+/**
+  \param root The XML-element to load settings from
+ */
+Field::Field(const TiXmlElement* root)
+{
+  this->init();
+  this->loadParams(root);
+}
 
 /**
@@ -41 +45 @@
 
 */
-Field::~Field () 
+Field::~Field ()
 {
    PhysicsEngine::getInstance()->removeField(this);
 }
 
+/**
+  \brief initializes a Field
+*/
+void Field::init(void)
+{
+  this->setClassID(CL_FIELD, "Field");
+  this->setMagnitude(1);
+  this->setAttenuation(0);
+
+  PhysicsEngine::getInstance()->addField(this);
+}
+
+/**
+  \param root The XML-element to load settings from
+ */
+void Field::loadParams(const TiXmlElement* root)
+{
+  static_cast<PNode*>(this)->loadParams(root);
+
+  LoadParam<Field>(root, "magnitude", this, &Field::setMagnitude)
+      .describe("sets the magnitude of this Field");
+
+  LoadParam<Field>(root, "attenuation", this, &Field::setAttenuation)
+      .describe("sets the attenuation of this Field.");
+
+}
 
 /**
    \param magnitude the magnitude of the Field.
 */
-void Field::setMagnitude(const float& magnitude)
+void Field::setMagnitude(float magnitude)
 {
   this->magnitude = magnitude;
@@ -58 +88 @@
    \param attenuation The attenuation of the Field (the bigger the smaller the region of influence)
 */
-void Field::setAttenuation(const float& attenuation)
+void Field::setAttenuation(float attenuation)
 {
   this->attenuation = attenuation;

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

@@ -1 @@
-/* 
+/*
    orxonox - the future of 3D-vertical-scrollers
 
@@ -14 +14 @@
 */
 
-/*! 
+/*!
     \file field.h
     \brief abstract definition of a Physical Field
 
-    This is a totally abstract class, that only enables different Physical Fields to 
+    This is a totally abstract class, that only enables different Physical Fields to
     exist on a common Level.
 */
@@ -28 +28 @@
 
 // FORWARD DEFINITION
-
+class TiXmlElement;
 
 
 //! An abstract class that represents a Force.
-class Field : public PNode 
+class Field : public PNode
 {
  public:
   Field();
+  Field(const TiXmlElement* root);
   virtual ~Field();
 
-  /** 
+  void init(void);
+  void loadParams(const TiXmlElement* root);
+
+  /**
       \param data This is the data given to this force, to calculate the ForceVector
       \returns The Force Vector
@@ -44 +48 @@
   virtual Vector calcForce(const Vector& data) const = 0;
 
-  void setMagnitude(const float& magnitude);
+  void setMagnitude(float magnitude);
   /** \returns The Magnitude of the Field */
   inline const float& getMagnitude(void) const {return this->magnitude;}
 
-  void setAttenuation(const float& attenuation);
+  void setAttenuation(float attenuation);
   /** \returns The Attenuation of the Fiels */
   inline const float& getAttenuation(void) const {return this->attenuation;}

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

@@ -1 @@
-/* 
+/*
    orxonox - the future of 3D-vertical-scrollers
 
@@ -18 +18 @@
 #include "gravity.h"
 
+#include "load_param.h"
+#include "factory.h"
+
 using namespace std;
 
+CREATE_FACTORY(Gravity);
 
 /**
@@ -25 +29 @@
    \todo this constructor is not jet implemented - do it
 */
-Gravity::Gravity () 
+Gravity::Gravity ()
 {
-   this->setClassName ("Gravity");
+   this->setClassName("Gravity");
 }
 
+Gravity::Gravity(const TiXmlElement* root)
+{
+  this->setClassName("Gravity");
+
+  this->loadParams(root);
+}
 
 /**
@@ -35 +45 @@
 
 */
-Gravity::~Gravity () 
+Gravity::~Gravity ()
 {
   // delete what has to be deleted here
+}
+
+void Gravity::loadParams(const TiXmlElement* root)
+{
+  static_cast<Field*>(this)->loadParams(root);
+
 }
 

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

@@ -1 @@
-/*! 
+/*!
     \file gravity.h
     \brief Definition of ...
@@ -19 +19 @@
  public:
   Gravity();
+  Gravity(const TiXmlElement* root);
   virtual ~Gravity();
+
+  void loadParams(const TiXmlElement* root);
 
   virtual Vector calcForce(const Vector& data) const;

orxonox/trunk/src/lib/physics/physics_connection.cc

@@ -24 +24 @@
 #include "physics_interface.h"
 
+#include "factory.h"
+
 using namespace std;
+
+CREATE_FACTORY(PhysicsConnection);
 
 /**
@@ -39 +43 @@
 }
 
+PhysicsConnection::PhysicsConnection(const TiXmlElement* root)
+{
+  this->setClassID(CL_PHYSICS_CONNECTION, "PhysicsConnection");
+  this->type = PCON_PhysIField;
+
+  static_cast<BaseObject*>(this)->loadParams(root);
+
+  LoadParam<PhysicsConnection>(root, "subject", this, &PhysicsConnection::setSubject)
+      .describe("set the subject by a name");
+
+  LoadParam<PhysicsConnection>(root, "field", this, &PhysicsConnection::setField)
+      .describe("set the field by name");
+}
 
 /**
@@ -50 +67 @@
 
 /**
+   \param subjectName the name of the Subject for this PhysicsConnection
+*/
+void PhysicsConnection::setSubject(const char* subjectName)
+{
+  this->subject = PhysicsEngine::getInstance()->getPhysicsInterfaceByName(subjectName);
+  if (this->subject == NULL)
+    PRINTF(2)("subject: (%s) not found for PhysicsConnection\n", subjectName);
+}
+
+/**
+  \param fieldName the Name of the Field for this connection
+*/
+void PhysicsConnection::setField(const char* fieldName)
+{
+  this->field = PhysicsEngine::getInstance()->getFieldByName(fieldName);
+  if (this->field == NULL)
+    PRINTF(2)("field: (%s) not found for PhysicsConnection\n", fieldName);
+}
+
+/**
     \brief applies the Force to some Object.
 */
 void PhysicsConnection::apply(void) const
 {
-  if (likely(this->type == PCON_PhysIField && this->field->getMagnitude() != 0.0))
+  if (likely(this->type == PCON_PhysIField && this->field->getMagnitude() != 0.0
+      && this->subject != NULL && this->field != NULL))
       this->subject->applyField(this->field);
   else ;

orxonox/trunk/src/lib/physics/physics_connection.h

@@ -30 +30 @@
   PhysicsConnection(PhysicsInterface* subject, Field* field);
   //  PhysicsConnection(PhysicsInterface* partnerOne, PhysicsInterface* partnerTwo);
+  PhysicsConnection(const TiXmlElement* root);
 
   virtual ~PhysicsConnection();
+
+  void setSubject(const char* subjectName);
+  void setField(const char* fieldName);
 
   void apply(void) const;

orxonox/trunk/src/lib/physics/physics_engine.cc

@@ -21 +21 @@
 
 #include "list.h"
+#include "game_loader.h"
+#include "tinyxml.h"
 
 using namespace std;
@@ -51 +53 @@
 }
 
+/**
+  \param root the XML-element to load settings from
+ */
+void loadParams(const TiXmlElement* root)
+{
+  const TiXmlElement* element;
+
+  PRINTF(4)("Loading Physical Fields\n");
+  element = root->FirstChildElement("Fields");
+  {
+    element = element->FirstChildElement();
+    GameLoader::getInstance()->fabricate(element);
+
+    element = element->NextSiblingElement();
+  }
+
+  PRINTF(4)("Loading Physical Connections\n");
+  element = root->FirstChildElement("PhysicsConnections");
+  {
+    element = element->FirstChildElement();
+    GameLoader::getInstance()->fabricate(element);
+
+    element = element->NextSiblingElement();
+  }
+
+}
+
+
+
 
 /**
@@ -75 +106 @@
 
 /**
+  \param physicsInterfaceName the Name of the PhysicsInterface to search for
+  \returns the PhysicsInterface if found, or NULL if not
+ */
+PhysicsInterface* PhysicsEngine::getPhysicsInterfaceByName(const char* physicsInterfaceName) const
+{
+  tIterator<PhysicsInterface>* tmpIt = interfaces->getIterator();
+  PhysicsInterface* tmpInt = tmpIt->nextElement();
+  while(tmpInt)
+  {
+    if (!strcmp(physicsInterfaceName, tmpInt->getName()))
+    {
+      delete tmpIt;
+      return tmpInt;
+    }
+    tmpInt = tmpIt->nextElement();
+  }
+  delete tmpIt;
+  return NULL;
+}
+
+/**
    \brief adds a Field to the list of handeled fields
    \param field the field to add
@@ -97 +149 @@
 
 /**
+  \param FieldName the Name of the PhysicsInterface to search for
+  \returns the Field if found, or NULL if not
+ */
+Field* PhysicsEngine::getFieldByName(const char* FieldName) const
+{
+  tIterator<Field>* tmpIt = fields->getIterator();
+  Field* tmpField = tmpIt->nextElement();
+  while(tmpField)
+  {
+    if (!strcmp(FieldName, tmpField->getName()))
+    {
+      delete tmpIt;
+      return tmpField;
+    }
+    tmpField = tmpIt->nextElement();
+  }
+  delete tmpIt;
+  return NULL;
+}
+
+
+
+/**
    \brief adds A Physical Connection to the List of Connections
    \param connection the Connection to add
@@ -118 +193 @@
 }
 
-
+/**
+  \param physicsConnectionName the Name of the PhysicsInterface to search for
+  \returns the PhysicsConnection if found, or NULL if not
+ */
+PhysicsConnection* PhysicsEngine::getPhysicsConnectionByName(const char* physicsConnectionName) const
+{
+  tIterator<PhysicsConnection>* tmpIt = connections->getIterator();
+  PhysicsConnection* tmpConn = tmpIt->nextElement();
+  while(tmpConn)
+  {
+    if (!strcmp(physicsConnectionName, tmpConn->getName()))
+    {
+      delete tmpIt;
+      return tmpConn;
+    }
+    tmpConn = tmpIt->nextElement();
+  }
+  delete tmpIt;
+  return NULL;
+}
 
 

orxonox/trunk/src/lib/physics/physics_engine.h

@@ -16 +16 @@
 // Forward Declaration
 template<class T> class tList;
-
+class TiXmlElement;
 
 //! A class, that brings things into motion through Physics.
@@ -26 +26 @@
   inline static PhysicsEngine* getInstance(void) { if (!singletonRef) singletonRef = new PhysicsEngine();  return singletonRef; };
 
-  void addPhysicsInterface(PhysicsInterface* physicsInterface);
-  void removePhysicsInterface(PhysicsInterface* physicsInterface);
+  void loadParams(const TiXmlElement* root);
 
-  void addField(Field* field);
-  void removeField(Field* field);
+  void                   addPhysicsInterface(PhysicsInterface* physicsInterface);
+  void                   removePhysicsInterface(PhysicsInterface* physicsInterface);
+  PhysicsInterface*      getPhysicsInterfaceByName(const char* physicsInterfaceName) const;
 
-  void addConnection(PhysicsConnection* connection);
-  void removeConnection(PhysicsConnection* connection);
+  void                   addField(Field* field);
+  void                   removeField(Field* field);
+  Field*                 getFieldByName(const char* FieldName) const;
 
-  void tick(float dt);
+  void                   addConnection(PhysicsConnection* connection);
+  void                   removeConnection(PhysicsConnection* connection);
+  PhysicsConnection*     getPhysicsConnectionByName(const char* physicsConnectionName) const;
 
-  void debug(void) const;
+
+  void                   tick(float dt);
+
+  void                   debug(void) const;
 
  private: