Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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


Ignore:
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:
8 edited

Legend:

Unmodified
Added
Removed
  • orxonox/trunk/src/lib/physics/fields/field.cc

    r4394 r4728  
    1 /* 
     1/*
    22   orxonox - the future of 3D-vertical-scrollers
    33
     
    2020#include "physics_engine.h"
    2121
     22#include "factory.h"
     23#include "load_param.h"
    2224using namespace std;
    23 
    2425
    2526/**
    2627   \brief standard constructor
    27    \todo this constructor is not jet implemented - do it
    2828*/
    29 Field::Field () 
     29Field::Field ()
    3030{
    31    this->setClassName ("Field");
    32    this->setMagnitude(1);
    33    this->setAttenuation(0);
    34    
    35    PhysicsEngine::getInstance()->addField(this);
     31  this->init();
    3632}
    3733
     34/**
     35  \param root The XML-element to load settings from
     36 */
     37Field::Field(const TiXmlElement* root)
     38{
     39  this->init();
     40  this->loadParams(root);
     41}
    3842
    3943/**
     
    4145
    4246*/
    43 Field::~Field () 
     47Field::~Field ()
    4448{
    4549   PhysicsEngine::getInstance()->removeField(this);
    4650}
    4751
     52/**
     53  \brief initializes a Field
     54*/
     55void Field::init(void)
     56{
     57  this->setClassID(CL_FIELD, "Field");
     58  this->setMagnitude(1);
     59  this->setAttenuation(0);
     60
     61  PhysicsEngine::getInstance()->addField(this);
     62}
     63
     64/**
     65  \param root The XML-element to load settings from
     66 */
     67void Field::loadParams(const TiXmlElement* root)
     68{
     69  static_cast<PNode*>(this)->loadParams(root);
     70
     71  LoadParam<Field>(root, "magnitude", this, &Field::setMagnitude)
     72      .describe("sets the magnitude of this Field");
     73
     74  LoadParam<Field>(root, "attenuation", this, &Field::setAttenuation)
     75      .describe("sets the attenuation of this Field.");
     76
     77}
    4878
    4979/**
    5080   \param magnitude the magnitude of the Field.
    5181*/
    52 void Field::setMagnitude(const float& magnitude)
     82void Field::setMagnitude(float magnitude)
    5383{
    5484  this->magnitude = magnitude;
     
    5888   \param attenuation The attenuation of the Field (the bigger the smaller the region of influence)
    5989*/
    60 void Field::setAttenuation(const float& attenuation)
     90void Field::setAttenuation(float attenuation)
    6191{
    6292  this->attenuation = attenuation;
  • orxonox/trunk/src/lib/physics/fields/field.h

    r4481 r4728  
    1 /* 
     1/*
    22   orxonox - the future of 3D-vertical-scrollers
    33
     
    1414*/
    1515
    16 /*! 
     16/*!
    1717    \file field.h
    1818    \brief abstract definition of a Physical Field
    1919
    20     This is a totally abstract class, that only enables different Physical Fields to 
     20    This is a totally abstract class, that only enables different Physical Fields to
    2121    exist on a common Level.
    2222*/
     
    2828
    2929// FORWARD DEFINITION
    30 
     30class TiXmlElement;
    3131
    3232
    3333//! An abstract class that represents a Force.
    34 class Field : public PNode 
     34class Field : public PNode
    3535{
    3636 public:
    3737  Field();
     38  Field(const TiXmlElement* root);
    3839  virtual ~Field();
    3940
    40   /**
     41  void init(void);
     42  void loadParams(const TiXmlElement* root);
     43
     44  /**
    4145      \param data This is the data given to this force, to calculate the ForceVector
    4246      \returns The Force Vector
     
    4448  virtual Vector calcForce(const Vector& data) const = 0;
    4549
    46   void setMagnitude(const float& magnitude);
     50  void setMagnitude(float magnitude);
    4751  /** \returns The Magnitude of the Field */
    4852  inline const float& getMagnitude(void) const {return this->magnitude;}
    4953
    50   void setAttenuation(const float& attenuation);
     54  void setAttenuation(float attenuation);
    5155  /** \returns The Attenuation of the Fiels */
    5256  inline const float& getAttenuation(void) const {return this->attenuation;}
  • orxonox/trunk/src/lib/physics/fields/gravity.cc

    r4396 r4728  
    1 /* 
     1/*
    22   orxonox - the future of 3D-vertical-scrollers
    33
     
    1818#include "gravity.h"
    1919
     20#include "load_param.h"
     21#include "factory.h"
     22
    2023using namespace std;
    2124
     25CREATE_FACTORY(Gravity);
    2226
    2327/**
     
    2529   \todo this constructor is not jet implemented - do it
    2630*/
    27 Gravity::Gravity () 
     31Gravity::Gravity ()
    2832{
    29    this->setClassName ("Gravity");
     33   this->setClassName("Gravity");
    3034}
    3135
     36Gravity::Gravity(const TiXmlElement* root)
     37{
     38  this->setClassName("Gravity");
     39
     40  this->loadParams(root);
     41}
    3242
    3343/**
     
    3545
    3646*/
    37 Gravity::~Gravity () 
     47Gravity::~Gravity ()
    3848{
    3949  // delete what has to be deleted here
     50}
     51
     52void Gravity::loadParams(const TiXmlElement* root)
     53{
     54  static_cast<Field*>(this)->loadParams(root);
     55
    4056}
    4157
  • orxonox/trunk/src/lib/physics/fields/gravity.h

    r4395 r4728  
    1 /*! 
     1/*!
    22    \file gravity.h
    33    \brief Definition of ...
     
    1919 public:
    2020  Gravity();
     21  Gravity(const TiXmlElement* root);
    2122  virtual ~Gravity();
     23
     24  void loadParams(const TiXmlElement* root);
    2225
    2326  virtual Vector calcForce(const Vector& data) const;
  • orxonox/trunk/src/lib/physics/physics_connection.cc

    r4597 r4728  
    2424#include "physics_interface.h"
    2525
     26#include "factory.h"
     27
    2628using namespace std;
     29
     30CREATE_FACTORY(PhysicsConnection);
    2731
    2832/**
     
    3943}
    4044
     45PhysicsConnection::PhysicsConnection(const TiXmlElement* root)
     46{
     47  this->setClassID(CL_PHYSICS_CONNECTION, "PhysicsConnection");
     48  this->type = PCON_PhysIField;
     49
     50  static_cast<BaseObject*>(this)->loadParams(root);
     51
     52  LoadParam<PhysicsConnection>(root, "subject", this, &PhysicsConnection::setSubject)
     53      .describe("set the subject by a name");
     54
     55  LoadParam<PhysicsConnection>(root, "field", this, &PhysicsConnection::setField)
     56      .describe("set the field by name");
     57}
    4158
    4259/**
     
    5067
    5168/**
     69   \param subjectName the name of the Subject for this PhysicsConnection
     70*/
     71void PhysicsConnection::setSubject(const char* subjectName)
     72{
     73  this->subject = PhysicsEngine::getInstance()->getPhysicsInterfaceByName(subjectName);
     74  if (this->subject == NULL)
     75    PRINTF(2)("subject: (%s) not found for PhysicsConnection\n", subjectName);
     76}
     77
     78/**
     79  \param fieldName the Name of the Field for this connection
     80*/
     81void PhysicsConnection::setField(const char* fieldName)
     82{
     83  this->field = PhysicsEngine::getInstance()->getFieldByName(fieldName);
     84  if (this->field == NULL)
     85    PRINTF(2)("field: (%s) not found for PhysicsConnection\n", fieldName);
     86}
     87
     88/**
    5289    \brief applies the Force to some Object.
    5390*/
    5491void PhysicsConnection::apply(void) const
    5592{
    56   if (likely(this->type == PCON_PhysIField && this->field->getMagnitude() != 0.0))
     93  if (likely(this->type == PCON_PhysIField && this->field->getMagnitude() != 0.0
     94      && this->subject != NULL && this->field != NULL))
    5795      this->subject->applyField(this->field);
    5896  else ;
  • orxonox/trunk/src/lib/physics/physics_connection.h

    r4597 r4728  
    3030  PhysicsConnection(PhysicsInterface* subject, Field* field);
    3131  //  PhysicsConnection(PhysicsInterface* partnerOne, PhysicsInterface* partnerTwo);
     32  PhysicsConnection(const TiXmlElement* root);
    3233
    3334  virtual ~PhysicsConnection();
     35
     36  void setSubject(const char* subjectName);
     37  void setField(const char* fieldName);
    3438
    3539  void apply(void) const;
  • orxonox/trunk/src/lib/physics/physics_engine.cc

    r4597 r4728  
    2121
    2222#include "list.h"
     23#include "game_loader.h"
     24#include "tinyxml.h"
    2325
    2426using namespace std;
     
    5153}
    5254
     55/**
     56  \param root the XML-element to load settings from
     57 */
     58void loadParams(const TiXmlElement* root)
     59{
     60  const TiXmlElement* element;
     61
     62  PRINTF(4)("Loading Physical Fields\n");
     63  element = root->FirstChildElement("Fields");
     64  {
     65    element = element->FirstChildElement();
     66    GameLoader::getInstance()->fabricate(element);
     67
     68    element = element->NextSiblingElement();
     69  }
     70
     71  PRINTF(4)("Loading Physical Connections\n");
     72  element = root->FirstChildElement("PhysicsConnections");
     73  {
     74    element = element->FirstChildElement();
     75    GameLoader::getInstance()->fabricate(element);
     76
     77    element = element->NextSiblingElement();
     78  }
     79
     80}
     81
     82
     83
    5384
    5485/**
     
    75106
    76107/**
     108  \param physicsInterfaceName the Name of the PhysicsInterface to search for
     109  \returns the PhysicsInterface if found, or NULL if not
     110 */
     111PhysicsInterface* PhysicsEngine::getPhysicsInterfaceByName(const char* physicsInterfaceName) const
     112{
     113  tIterator<PhysicsInterface>* tmpIt = interfaces->getIterator();
     114  PhysicsInterface* tmpInt = tmpIt->nextElement();
     115  while(tmpInt)
     116  {
     117    if (!strcmp(physicsInterfaceName, tmpInt->getName()))
     118    {
     119      delete tmpIt;
     120      return tmpInt;
     121    }
     122    tmpInt = tmpIt->nextElement();
     123  }
     124  delete tmpIt;
     125  return NULL;
     126}
     127
     128/**
    77129   \brief adds a Field to the list of handeled fields
    78130   \param field the field to add
     
    97149
    98150/**
     151  \param FieldName the Name of the PhysicsInterface to search for
     152  \returns the Field if found, or NULL if not
     153 */
     154Field* PhysicsEngine::getFieldByName(const char* FieldName) const
     155{
     156  tIterator<Field>* tmpIt = fields->getIterator();
     157  Field* tmpField = tmpIt->nextElement();
     158  while(tmpField)
     159  {
     160    if (!strcmp(FieldName, tmpField->getName()))
     161    {
     162      delete tmpIt;
     163      return tmpField;
     164    }
     165    tmpField = tmpIt->nextElement();
     166  }
     167  delete tmpIt;
     168  return NULL;
     169}
     170
     171
     172
     173/**
    99174   \brief adds A Physical Connection to the List of Connections
    100175   \param connection the Connection to add
     
    118193}
    119194
    120 
     195/**
     196  \param physicsConnectionName the Name of the PhysicsInterface to search for
     197  \returns the PhysicsConnection if found, or NULL if not
     198 */
     199PhysicsConnection* PhysicsEngine::getPhysicsConnectionByName(const char* physicsConnectionName) const
     200{
     201  tIterator<PhysicsConnection>* tmpIt = connections->getIterator();
     202  PhysicsConnection* tmpConn = tmpIt->nextElement();
     203  while(tmpConn)
     204  {
     205    if (!strcmp(physicsConnectionName, tmpConn->getName()))
     206    {
     207      delete tmpIt;
     208      return tmpConn;
     209    }
     210    tmpConn = tmpIt->nextElement();
     211  }
     212  delete tmpIt;
     213  return NULL;
     214}
    121215
    122216
  • orxonox/trunk/src/lib/physics/physics_engine.h

    r4558 r4728  
    1616// Forward Declaration
    1717template<class T> class tList;
    18 
     18class TiXmlElement;
    1919
    2020//! A class, that brings things into motion through Physics.
     
    2626  inline static PhysicsEngine* getInstance(void) { if (!singletonRef) singletonRef = new PhysicsEngine();  return singletonRef; };
    2727
    28   void addPhysicsInterface(PhysicsInterface* physicsInterface);
    29   void removePhysicsInterface(PhysicsInterface* physicsInterface);
     28  void loadParams(const TiXmlElement* root);
    3029
    31   void addField(Field* field);
    32   void removeField(Field* field);
     30  void                   addPhysicsInterface(PhysicsInterface* physicsInterface);
     31  void                   removePhysicsInterface(PhysicsInterface* physicsInterface);
     32  PhysicsInterface*      getPhysicsInterfaceByName(const char* physicsInterfaceName) const;
    3333
    34   void addConnection(PhysicsConnection* connection);
    35   void removeConnection(PhysicsConnection* connection);
     34  void                   addField(Field* field);
     35  void                   removeField(Field* field);
     36  Field*                 getFieldByName(const char* FieldName) const;
    3637
    37   void tick(float dt);
     38  void                   addConnection(PhysicsConnection* connection);
     39  void                   removeConnection(PhysicsConnection* connection);
     40  PhysicsConnection*     getPhysicsConnectionByName(const char* physicsConnectionName) const;
    3841
    39   void debug(void) const;
     42
     43  void                   tick(float dt);
     44
     45  void                   debug(void) const;
    4046
    4147 private:
Note: See TracChangeset for help on using the changeset viewer.