Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 9685 in orxonox.OLD for branches/new_class_id/src/lib/graphics


Ignore:
Timestamp:
Aug 22, 2006, 1:16:23 PM (18 years ago)
Author:
bensch
Message:

adapted many classes to the new ClassID System, now comes the hard part… Scripting… then Network… wow this will be so bad :/

Location:
branches/new_class_id/src/lib/graphics
Files:
46 edited

Legend:

Unmodified
Added
Removed

  • branches/new_class_id/src/lib/graphics/effects/atmospheric_engine.cc

    r9406 r9685  
    2222#include "util/loading/load_param.h"
    2323#include "util/loading/factory.h"
    24 #include "class_list.h"
    2524
    26 
    27 
     25NewObjectListDefinition(AtmosphericEngine);
    2826
    2927/**
    3028 * @param root The XML-element to load the AtmosphericEngine from
    3129 */
    32 AtmosphericEngine::AtmosphericEngine() {
    33     this->setClassID(CL_ATMOSPHERIC_ENGINE, "AtmosphericEngine");
     30AtmosphericEngine::AtmosphericEngine()
     31{
     32  this->registerObject(this, AtmosphericEngine::_objectList);
    3433}
    3534
    … …  
    4342 *  destroys a AtmosphericEngine
    4443 */
    45 AtmosphericEngine::~AtmosphericEngine() {
    46     AtmosphericEngine::singletonRef = NULL;
     44AtmosphericEngine::~AtmosphericEngine()
     45{
     46  AtmosphericEngine::singletonRef = NULL;
    4747
    48     const std::list<BaseObject*>* weatherEffects = ClassList::getList( CL_WEATHER_EFFECT);
    49 
    50     if (weatherEffects != NULL) {
    51         while(!weatherEffects->empty())
    52             delete weatherEffects->front();
    53     }
     48  while(!WeatherEffect::objectList().empty())
     49    delete WeatherEffect::objectList().front();
    5450}
    5551
    … …  
    5753 * @param root The XML-element to load the AtmosphericEngine from
    5854 */
    59 void AtmosphericEngine::loadParams(const TiXmlElement* root) {
    60     LoadParamXML(root, "WeatherEffect", this, AtmosphericEngine, loadWeatherEffect);
    61     LoadParamXML(root, "SunEffect", this, AtmosphericEngine, loadSunEffect);
     55void AtmosphericEngine::loadParams(const TiXmlElement* root)
     56{
     57  LoadParamXML(root, "WeatherEffect", this, AtmosphericEngine, loadWeatherEffect);
     58  LoadParamXML(root, "SunEffect", this, AtmosphericEngine, loadSunEffect);
    6259}
    6360
    … …  
    6562 * @param root The XML-element to load WeatherEffects from
    6663 */
    67 void AtmosphericEngine::loadWeatherEffect(const TiXmlElement* root) {
    68     LOAD_PARAM_START_CYCLE(root, element);
    69     {
    70         PRINTF(4)("element is: %s\n", element->Value());
    71         // Factory::fabricate(element);
     64void AtmosphericEngine::loadWeatherEffect(const TiXmlElement* root)
     65{
     66  LOAD_PARAM_START_CYCLE(root, element);
     67  {
     68    PRINTF(4)("element is: %s\n", element->Value());
     69    // Factory::fabricate(element);
    7270
    73         BaseObject* bo = Factory::fabricate(element);
    74         if( bo == NULL)
    75             PRINTF(0)(" Could not create Element %s\n", element->Value());
    76     }
    77     LOAD_PARAM_END_CYCLE(element);
     71    BaseObject* bo = Factory::fabricate(element);
     72    if( bo == NULL)
     73      PRINTF(0)(" Could not create Element %s\n", element->Value());
     74  }
     75  LOAD_PARAM_END_CYCLE(element);
    7876}
    7977
    … …  
    8179 * @param root The XML-element to load SunEffects from
    8280 */
    83 void AtmosphericEngine::loadSunEffect(const TiXmlElement* root) {
    84     LOAD_PARAM_START_CYCLE(root, element);
    85     {
    86         PRINTF(4)("element is: %s\n", element->Value());
    87     }
    88     LOAD_PARAM_END_CYCLE(element);
     81void AtmosphericEngine::loadSunEffect(const TiXmlElement* root)
     82{
     83  LOAD_PARAM_START_CYCLE(root, element);
     84  {
     85    PRINTF(4)("element is: %s\n", element->Value());
     86  }
     87  LOAD_PARAM_END_CYCLE(element);
    8988}
    9089
    … …  
    9392 * draws the effect, if needed
    9493 */
    95 void AtmosphericEngine::draw() const {
    96     const std::list<BaseObject*>* weatherEffects = ClassList::getList( CL_WEATHER_EFFECT);
    97 
    98     // draw the weather effects
    99     if (weatherEffects != NULL) {
    100         std::list<BaseObject*>::const_iterator it;
    101         for (it = weatherEffects->begin(); it != weatherEffects->end(); it++)
    102             dynamic_cast<WeatherEffect*>(*it)->draw();
    103     }
     94void AtmosphericEngine::draw() const
     95{
     96  for (NewObjectList<WeatherEffect>::const_iterator it = WeatherEffect::objectList().begin();
     97       it != WeatherEffect::objectList().end();
     98       ++it)
     99    (*it)->draw();
    104100}
    105101
    … …  
    109105 * ticks the effect if there is any time dependancy
    110106 */
    111 void AtmosphericEngine::tick(float dt) {
    112     const std::list<BaseObject*>* weatherEffects = ClassList::getList( CL_WEATHER_EFFECT);
     107void AtmosphericEngine::tick(float dt)
     108{
    113109
    114     // tick the weather effects
    115     if (weatherEffects != NULL) {
    116         std::list<BaseObject*>::const_iterator it;
    117         for (it = weatherEffects->begin(); it != weatherEffects->end(); it++) {
    118             /*      printf("%s::%s \n", (*it)->getClassCName(), (*it)->getName());*/
    119             dynamic_cast<WeatherEffect*>(*it)->tick(dt);
    120         }
    121     }
     110  for (NewObjectList<WeatherEffect>::const_iterator it = WeatherEffect::objectList().begin();
     111       it != WeatherEffect::objectList().end();
     112       ++it)
     113    (*it)->tick(dt);
    122114}

  • branches/new_class_id/src/lib/graphics/effects/atmospheric_engine.h

    r7810 r9685  
    11/*!
    22 * @file atmospheric_engine.h
    3  * 
     3 *
    44 */
    55
    … …  
    1414class AtmosphericEngine : public BaseObject
    1515{
     16  NewObjectListDeclaration(AtmosphericEngine);
    1617  public:
    1718    ~AtmosphericEngine();

  • branches/new_class_id/src/lib/graphics/effects/graphics_effect.cc

    r9406 r9685  
    2222#include "util/loading/load_param.h"
    2323
    24 
    25 
    26 
    27 
     24NewObjectListDefinition(GraphicsEffect);
    2825
    2926/**
    … …  
    3330 */
    3431GraphicsEffect::GraphicsEffect(const TiXmlElement* root) {
    35     this->setClassID(CL_GRAPHICS_EFFECT, "GraphicsEffect");
     32  this->registerObject(this, GraphicsEffect::_objectList);
    3633    this->bActivated = false;
    3734}

  • branches/new_class_id/src/lib/graphics/effects/graphics_effect.h

    r8495 r9685  
    1313//! A class that handles GraphicsEffects. The GraphicsEffectManager operates on this.
    1414class GraphicsEffect : public BaseObject {
    15 public:
     15  NewObjectListDeclaration(GraphicsEffect);
     16  public:
    1617    GraphicsEffect(const TiXmlElement* root = NULL);
    1718    virtual ~GraphicsEffect();

  • branches/new_class_id/src/lib/graphics/effects/weather_effect.cc

    r9406 r9685  
    2020#include "util/loading/load_param.h"
    2121
    22 
    23 
    24 
     22NewObjectListDefinition(WeatherEffect);
    2523
    2624/**
    … …  
    2927WeatherEffect::WeatherEffect(const TiXmlElement* root)
    3028{
    31   this->setClassID(CL_WEATHER_EFFECT, "WeatherEffect");
     29  this->registerObject(this, WeatherEffect::_objectList);
    3230  this->bActivated = false;
    3331}

  • branches/new_class_id/src/lib/graphics/effects/weather_effect.h

    r8495 r9685  
    1212class WeatherEffect : public BaseObject
    1313{
     14  NewObjectListDeclaration(WeatherEffect);
     15
    1416  public:
    1517    WeatherEffect(const TiXmlElement* root = NULL);

  • branches/new_class_id/src/lib/graphics/graphics_engine.cc

    r9406 r9685  
    4545#include "util/loading/load_param.h"
    4646#include "util/loading/factory.h"
    47 #include "class_list.h"
    4847
    4948#ifdef __WIN32__
    … …  
    5453SHELL_COMMAND(fps, GraphicsEngine, toggleFPSdisplay);
    5554
     55NewObjectListDefinition(GraphicsEngine);
     56
    5657/**
    5758 * @brief standard constructor
    … …  
    5960GraphicsEngine::GraphicsEngine ()
    6061{
    61   this->setClassID(CL_GRAPHICS_ENGINE, "GraphicsEngine");
     62  this->registerObject(this, GraphicsEngine::_objectList);
    6263  this->setName("GraphicsEngine");
    6364
    … …  
    590591
    591592  // tick the graphics effects
    592   if (this->graphicsEffects != NULL || (this->graphicsEffects = ClassList::getList(CL_GRAPHICS_EFFECT)) != NULL)
    593   {
    594     std::list<BaseObject*>::const_iterator it;
    595     for (it = this->graphicsEffects->begin(); it != this->graphicsEffects->end(); it++)
    596       dynamic_cast<GraphicsEffect*>(*it)->tick(dt);
    597   }
     593  for (NewObjectList<GraphicsEffect>::const_iterator it = GraphicsEffect::objectList().begin();
     594       it != GraphicsEffect::objectList().end();
     595       ++it)
     596    (*it)->tick(dt);
    598597}
    599598
    … …  
    688687  {
    689688    case EV_VIDEO_RESIZE:
    690       this->resolutionChanged(event.resize);
    691       break;
    692   }
    693 }
     689    this->resolutionChanged(event.resize);
     690    break;
     691  }
     692}

  • branches/new_class_id/src/lib/graphics/graphics_engine.h

    r9406 r9685  
    3030class GraphicsEngine : public EventListener
    3131{
     32  NewObjectListDeclaration(GraphicsEngine);
    3233  public:
    3334    virtual ~GraphicsEngine();

  • branches/new_class_id/src/lib/graphics/importer/material.cc

    r9406 r9685  
    2727#include "util/loading/resource_manager.h"
    2828
     29NewObjectListDefinition(Material);
     30
    2931/**
    3032 * @brief creates a Material.
    … …  
    3335Material::Material (const std::string& mtlName)
    3436{
    35   this->setClassID(CL_MATERIAL, "Material");
     37  this->registerObject(this, Material::_objectList);
    3638
    3739  this->setIllum(3);

  • branches/new_class_id/src/lib/graphics/importer/material.h

    r8761 r9685  
    2424class Material : public BaseObject
    2525{
     26  NewObjectListDeclaration(Material);
    2627public:
    2728  Material (const std::string& mtlName = "");

  • branches/new_class_id/src/lib/graphics/importer/md2/md2Model.cc

    r9406 r9685  
    2222
    2323
    24 
     24NewObjectListDefinition(MD2Model);
    2525
    2626//! the model anorms
    … …  
    7878MD2Model::MD2Model(const std::string& modelFileName, const std::string& skinFileName, float scale)
    7979{
    80   this->setClassID(CL_MD2_MODEL, "MD2Model");
     80  this->registerObject(this, MD2Model::_objectList);
    8181  /* this creates the data container via ressource manager */
    8282  if (!modelFileName.empty())

  • branches/new_class_id/src/lib/graphics/importer/md2/md2Model.h

    r9235 r9685  
    149149//! This is a MD2 Model class
    150150class MD2Model : public InteractiveModel {
    151 
     151  NewObjectListDeclaration(MD2Model);
    152152public:
    153153  MD2Model(const std::string& modelFileName, const std::string& skinFileName = "", float scale = 1.0f);

  • branches/new_class_id/src/lib/graphics/importer/media_container.cc

    r8316 r9685  
    3030#include "debug.h"
    3131
     32NewObjectListDefinition(MediaContainer);
    3233
    3334/**
    … …  
    3738{
    3839  // set the class id for the base object
    39   this->setClassID(CL_MEDIA_CONTAINER, "MediaContainer");
     40  this->registerObject(this, MediaContainer::_objectList);
    4041
    4142  fps = 0;

  • branches/new_class_id/src/lib/graphics/importer/media_container.h

    r7221 r9685  
    2424class MediaContainer : public TextureSequence
    2525{
    26 
     26  NewObjectListDeclaration(MediaContainer);
    2727private:
    2828

  • branches/new_class_id/src/lib/graphics/importer/movie_player.cc

    r7221 r9685  
    3030#include "debug.h"
    3131
     32NewObjectListDefinition(MoviePlayer);
    3233
    3334MoviePlayer::MoviePlayer(const std::string& filename)
    3435{
    3536  // set the class id for the base object
    36   this->setClassID(CL_MOVIE_PLAYER, "MoviePlayer");
    37 
     37  this->registerObject(this, MoviePlayer::_objectList);
    3838  status = STOP;
    3939  timer = 0;

  • branches/new_class_id/src/lib/graphics/importer/movie_player.h

    r7221 r9685  
    3131class MoviePlayer : public BaseObject
    3232{
     33  NewObjectListDeclaration(MoviePlayer);
    3334
    3435private:

  • branches/new_class_id/src/lib/graphics/importer/texture.cc

    r9406 r9685  
    6464#endif
    6565
    66 
     66NewObjectListDefinition(Texture);
    6767
    6868/**
    … …  
    8686    : data(texture.data)
    8787{
    88   this->setClassID(CL_TEXTURE, "Texture");
     88  this->registerObject(this, Texture::_objectList);
    8989  this->priority = 0.5;
    9090}
    … …  
    149149void Texture::init()
    150150{
    151   this->setClassID(CL_TEXTURE, "Texture");
     151  this->registerObject(this, Texture::_objectList);
    152152
    153153  this->data = TextureDataPointer(new TextureData());

  • branches/new_class_id/src/lib/graphics/importer/texture.h

    r8761 r9685  
    2020class Texture : public BaseObject
    2121{
     22  NewObjectListDeclaration(Texture);
    2223public:
    2324  Texture();

  • branches/new_class_id/src/lib/graphics/importer/texture_sequence.cc

    r9406 r9685  
    2828#endif
    2929
     30NewObjectListDefinition(TextureSequence);
     31
    3032/**
    3133 * @brief Constructor for a Texture
    … …  
    3335TextureSequence::TextureSequence(unsigned int count, ...)
    3436{
    35   this->setClassID(CL_TEXTURE_SEQUENCE, "TextureSequence");
     37  this->registerObject(this, TextureSequence::_objectList);
    3638
    3739  va_list textureNameList;
    … …  
    5456TextureSequence::TextureSequence(const std::vector<std::string>& textureNames, const std::string& prependFolder)
    5557{
    56   this->setClassID(CL_TEXTURE_SEQUENCE, "TextureSequence");
     58  this->registerObject(this, TextureSequence::_objectList);
    5759  this->loadImageSeries(textureNames, prependFolder);
    5860}

  • branches/new_class_id/src/lib/graphics/importer/texture_sequence.h

    r8324 r9685  
    1515class TextureSequence : public Texture
    1616{
     17  NewObjectListDeclaration(TextureSequence);
    1718  public:
    1819    TextureSequence(unsigned int count = 0, ...);

  • branches/new_class_id/src/lib/graphics/light.cc

    r8742 r9685  
    2727#include "debug.h"
    2828
     29#include "class_id.h"
     30
    2931CREATE_FACTORY(Light, CL_LIGHT);
     32NewObjectListDefinitionID(Light, CL_LIGHT);
    3033
    3134//! Definition of the Lights and their Names
    … …  
    5154  PRINTF(4)("initializing Light number %d.\n", this->lightNumber);
    5255
     56  this->registerObject(this, Light::_objectList);
     57
    5358  this->lightNumber = LightManager::getInstance()->registerLight(this);
    5459
    55   this->setClassID(CL_LIGHT, "Light");
    5660  char tmpName[10];
    5761  sprintf(tmpName, "Light[%d]", this->lightNumber);
    … …  
    211215** LIGHT-MANAGER **
    212216******************/
     217NewObjectListDefinition(LightManager);
    213218/**
    214219 *  standard constructor for a Light
    … …  
    216221LightManager::LightManager ()
    217222{
    218   this->setClassID(CL_LIGHT_MANAGER, "LightManager");
     223  this->registerObject(this, LightManager::_objectList);
    219224
    220225  glEnable (GL_LIGHTING);

  • branches/new_class_id/src/lib/graphics/light.h

    r8255 r9685  
    2525class Light : public PNode
    2626{
    27         public:
    28                 Light(const TiXmlElement* root = NULL);
    29                 virtual ~Light();
    30                
    31                 virtual void loadParams(const TiXmlElement* root);
    32                
    33                 void setDiffuseColor(GLfloat r, GLfloat g, GLfloat b);
    34                 void setSpecularColor(GLfloat r, GLfloat g, GLfloat b);
    35                 void setAttenuation(float constantAttenuation, float linearAttenuation, float quadraticAttenuation);
    36                 void setSpotDirection(const Vector& direction);
    37                 void setSpotDirection(float x, float y, float z) { setSpotDirection(Vector(x,y,z)); };
    38                 void setSpotCutoff(GLfloat cutoff);
    39                
    40                 /** @returns the lightNumber*/
    41                 int getLightNumber() const {return this->lightNumber;}
    42                
    43                 virtual void draw() const;
    44                
    45                 void debug() const;
    46        
    47         // attributes
    48         private:
    49                 int              lightNumber;               //!< The number of this Light.
    50                 GLfloat          diffuseColor[4];           //!< The Diffuse Color this Light emmits.
    51                 GLfloat          specularColor[4];          //!< The specular Color of this Light.
    52                 float            constantAttenuation;       //!< The Factor of the the Constant Attenuation.
    53                 float            linearAttenuation;         //!< The Factor of the the Linear Attenuation.
    54                 float            quadraticAttenuation;      //!< The Factor of the the Quadratic Attenuation.
    55                 GLfloat          spotDirection[4];          //!< The direction of the Spot Light.
    56                 GLfloat          spotCutoff;                //!< The cutoff Angle of the Light Source
     27  NewObjectListDeclaration(Light);
     28public:
     29  Light(const TiXmlElement* root = NULL);
     30  virtual ~Light();
     31
     32  virtual void loadParams(const TiXmlElement* root);
     33
     34  void setDiffuseColor(GLfloat r, GLfloat g, GLfloat b);
     35  void setSpecularColor(GLfloat r, GLfloat g, GLfloat b);
     36  void setAttenuation(float constantAttenuation, float linearAttenuation, float quadraticAttenuation);
     37  void setSpotDirection(const Vector& direction);
     38  void setSpotDirection(float x, float y, float z) { setSpotDirection(Vector(x,y,z)); };
     39  void setSpotCutoff(GLfloat cutoff);
     40
     41  /** @returns the lightNumber*/
     42  int getLightNumber() const {return this->lightNumber;}
     43
     44  virtual void draw() const;
     45
     46  void debug() const;
     47
     48  // attributes
     49private:
     50  int              lightNumber;               //!< The number of this Light.
     51  GLfloat          diffuseColor[4];           //!< The Diffuse Color this Light emmits.
     52  GLfloat          specularColor[4];          //!< The specular Color of this Light.
     53  float            constantAttenuation;       //!< The Factor of the the Constant Attenuation.
     54  float            linearAttenuation;         //!< The Factor of the the Linear Attenuation.
     55  float            quadraticAttenuation;      //!< The Factor of the the Quadratic Attenuation.
     56  GLfloat          spotDirection[4];          //!< The direction of the Spot Light.
     57  GLfloat          spotCutoff;                //!< The cutoff Angle of the Light Source
    5758};
    58        
    59        
    60        
     59
     60
     61
    6162//! A class that handles Lights
    6263/**
    … …  
    8788*/
    8889class LightManager : public BaseObject
    89         {
    90         friend class Light;
     90{
     91  NewObjectListDeclaration(LightManager);
    9192
    92         public:
    93                 virtual ~LightManager();
    94                 /** @returns a Pointer to the only object of this Class */
    95                 inline static LightManager* getInstance() { if (!singletonRef) singletonRef = new LightManager();  return singletonRef; };
     93  friend class Light;
     94public:
     95  virtual ~LightManager();
     96  /** @returns a Pointer to the only object of this Class */
     97  inline static LightManager* getInstance() { if (!singletonRef) singletonRef = new LightManager();  return singletonRef; };
    9698
    97                 virtual void loadParams(const TiXmlElement* root);
    98                 void loadLights(const TiXmlElement* root);
     99  virtual void loadParams(const TiXmlElement* root);
     100  void loadLights(const TiXmlElement* root);
    99101
    100                 void setAmbientColor(GLfloat r, GLfloat g, GLfloat b);
    101                 // HACK: Assuming r = g = b values
    102                 inline GLfloat getAmbientColor() {  return this->ambientColor[0]; }
     102  void setAmbientColor(GLfloat r, GLfloat g, GLfloat b);
     103  // HACK: Assuming r = g = b values
     104inline GLfloat getAmbientColor() {  return this->ambientColor[0]; }
    103105
    104                 Light* getLight(int lightNumber) const;
    105                 inline Light* getLight() const { return this->currentLight; };
     106  Light* getLight(int lightNumber) const;
     107  inline Light* getLight() const { return this->currentLight; };
    106108
    107                 void draw() const;
     109  void draw() const;
    108110
    109                 void debug() const;
     111  void debug() const;
    110112
    111         private:
    112                 LightManager();
     113private:
     114  LightManager();
    113115
    114                 int  registerLight(Light* light);
    115                 void unregisterLight(Light* light);
     116  int  registerLight(Light* light);
     117  void unregisterLight(Light* light);
    116118
    117         private:
    118                 static LightManager*    singletonRef;       //!< This is the LightHandlers Reference.
    119                 GLfloat                 ambientColor[4];    //!< The ambient Color of the scene.
     119private:
     120  static LightManager*    singletonRef;       //!< This is the LightHandlers Reference.
     121  GLfloat                 ambientColor[4];    //!< The ambient Color of the scene.
    120122
    121                 Light**                 lights;             //!< An array of Lenght NUMBEROFLIGHTS, that holds pointers to all LightValues.
    122                 Light*                  currentLight;       //!< The current Light, we are working with.
     123  Light**                 lights;             //!< An array of Lenght NUMBEROFLIGHTS, that holds pointers to all LightValues.
     124  Light*                  currentLight;       //!< The current Light, we are working with.
    123125
    124126};

  • branches/new_class_id/src/lib/graphics/render2D/element_2d.cc

    r9406 r9685  
    2929#include "graphics_engine.h"
    3030#include "util/loading/load_param.h"
    31 #include "class_list.h"
    3231
    3332#include "color.h"
    … …  
    3534#include "shell_command.h"
    3635SHELL_COMMAND(debug, Element2D, debug2D);
     36
     37NewObjectListDefinition(Element2D);
    3738
    3839
    … …  
    4647Element2D::Element2D (Element2D* parent, E2D_LAYER layer, short nodeFlags)
    4748{
    48   this->setClassID(CL_ELEMENT_2D, "Element2D");
     49  this->registerObject(this, Element2D::_objectList);
    4950
    5051  this->setVisibility(true);
    … …  
    268269void Element2D::setBindNode(const std::string& bindNode)
    269270{
    270   const PNode* tmpBindNode = dynamic_cast<const PNode*>(ClassList::getObject(bindNode, CL_PARENT_NODE));
     271  const PNode* tmpBindNode = PNode::objectList().getObject(bindNode);
    271272  if (tmpBindNode != NULL)
    272273    this->bindNode = tmpBindNode;
    … …  
    640641void Element2D::addChild2D (const std::string& childName)
    641642{
    642   Element2D* childNode = dynamic_cast<Element2D*>(ClassList::getObject(childName, CL_ELEMENT_2D));
     643  Element2D* childNode = Element2D::objectList().getObject(childName);
    643644  if (childNode != NULL)
    644645    this->addChild2D(childNode);
    … …  
    718719void Element2D::setParent2D (const std::string& parentName)
    719720{
    720   Element2D* parentNode = dynamic_cast<Element2D*>(ClassList::getObject(parentName, CL_ELEMENT_2D));
     721  Element2D* parentNode = Element2D::objectList().getObject(parentName);
    721722  if (parentNode != NULL)
    722723    parentNode->addChild2D(this);
    … …  
    771772void Element2D::setParentSoft2D(const std::string& parentName, float bias)
    772773{
    773   Element2D* parentNode = dynamic_cast<Element2D*>(ClassList::getObject(parentName, CL_ELEMENT_2D));
     774  Element2D* parentNode = Element2D::objectList().getObject(parentName);
    774775  if (parentNode != NULL)
    775776    this->setParentSoft2D(parentNode, bias);

  • branches/new_class_id/src/lib/graphics/render2D/element_2d.h

    r8360 r9685  
    4747
    4848  E2D_PARENT_MOVEMENT                = 0x0004,    //!< Moves all children along with the parent.
    49 // special linkage modes
     49  // special linkage modes
    5050  E2D_PARENT_ALL                     = 0x0003,    //!< Moves all children around the center of their parent, and also rotates their centers
    5151  E2D_PARENT_ROTATE_AND_MOVE         = 0x0005,    //!< Rotates all children around their axis, and moves them as the Parent Moves, but does not rotate around the center of their parent.
    … …  
    5858  E2D_REPARENT_DELETE_CHILDREN       = 0x0040,    //!< Deletes the Children of the node when This Node is Removed. (Use with care).
    5959  /// FIXME
    60    E2D_REPARENT_KEEP_POSITION         = 0x0080,   //!< Tries to keep the Position if the Node is reparented.
     60  E2D_REPARENT_KEEP_POSITION         = 0x0080,   //!< Tries to keep the Position if the Node is reparented.
    6161
    6262
    … …  
    8787 * -> the tree is sorted on insertion of a new Child: @see Element2D::addChild2D()
    8888 */
    89 class Element2D : virtual public BaseObject {
    90 
    91   public:
    92     Element2D(Element2D* parent = Element2D::getNullElement(), E2D_LAYER layer = E2D_DEFAULT_LAYER, short nodeFlags = E2D_PARENT_MODE_DEFAULT);
    93     virtual ~Element2D();
    94 
    95     virtual void loadParams(const TiXmlElement* root);
    96 
    97     // ACTIVATION //
    98     inline void activate2D() { this->bActive = this->bRelCoorChanged = this->bRelDirChanged = true; };
    99     inline void deactivate2D() { this->bActive = false; };
    100     inline bool get2DActiveState() { return this->bActive; };
    101 
    102     // ALIGNMENT //
    103     /** @param alignment the new Alignment of the 2D-Element */
    104     inline void setAlignment(E2D_ALIGNMENT alignment) { this->alignment = alignment; };
    105     void setAlignment(const std::string& alignment);
    106     inline E2D_ALIGNMENT getAlignment() const { return this->alignment; };
    107 
    108     // LAYERING //
    109     void setLayer(E2D_LAYER layer);
    110     void setLayer(const std::string& layer);
    111     /** @returns the Layer this Element is drawn to */
    112     inline E2D_LAYER getLayer() const { return this->layer; };
    113 
    114     // VISIBILITY //
    115     /** @param visible true if the Element should be visible false otherwise (will not be rendered) */
    116     inline void setVisibility(bool visible) { this->bVisible = visible; };
    117     /** @returns the visibility state */
    118     inline bool isVisible() const { return (this->bVisible && this->bCurrentlyVisible);  };
    119 
    120 
    121     // POSITIONAL (E2D-specials) //
    122     /** @param bindNode the Node this 2D-element should follow. if NULL the Element will not follow anything */
    123     void setBindNode(const PNode* bindNode);
    124     void setBindNode(const std::string& bindNode);
    125     inline const PNode* getBindNode() const { return this->bindNode; };
    126 
    127     inline void setSize2D(float x, float y) { this->size = Vector2D(x, y); };
    128     inline void setSize2D(const Vector2D& size) { this->size = size; };
    129     inline const Vector2D& getSize2D() const { return this->size; };
    130     void setSizeSoft2D(float x, float y, float bias = 1.0);
    131     inline void setSizeX2D(float x) { this->size.x = x; };
    132     inline void setSizeY2D(float y) { this->size.y = y; };
    133     inline float getSizeX2D() const { return this->size.x; };
    134     inline float getSizeY2D() const { return this->size.y; };
    135 
    136   public:
    137     virtual void tick(float dt) {};
    138     virtual void draw() const  {};
    139     void tick2D(float dt);
    140     void draw2D(E2D_LAYER from, E2D_LAYER to) const;
    141     void drawChildren(E2D_LAYER from, E2D_LAYER to) const;
    142 
    143     // LIKE PNODE
    144   public:
    145     void setRelCoor2D (const Vector2D& relCoord);
    146     void setRelCoorX2D(float x);
    147     void setRelCoorY2D(float y);
    148     void setRelCoor2D (float x, float y);
    149     void setRelCoor2Dpx (int x, int y);
    150     void setRelCoorSoft2D (const Vector2D& relCoordSoft, float bias = 1.0);
    151     void setRelCoorSoft2D (float x, float y, float bias = 1.0);
    152     void setRelCoorSoft2Dpx (int x, int y, float bias = 1.0);
    153     /** @returns the relative position */
    154     inline const Vector2D& getRelCoor2D () const { return this->prevRelCoordinate; };
    155     /** @returns the Relative Coordinate Destination */
    156     inline const Vector2D& getRelCoorSoft2D() const { return (this->toCoordinate)?*this->toCoordinate:this->relCoordinate; };
    157     const Vector2D& getRelCoor2Dpx() const;
    158     void setAbsCoor2D (const Vector2D& absCoord);
    159     void setAbsCoor2D (float x, float y);
    160     void setAbsCoorX2D(float x);
    161     void setAbsCoorY2D(float y);
    162     void setAbsCoor2Dpx (int x, int y);
    163     void setAbsCoorSoft2D (const Vector2D& absCoordSoft, float bias = 1.0);
    164     void setAbsCoorSoft2D (float x, float y, float bias = 1.0);
    165     /** @returns the absolute position */
    166     inline const Vector2D& getAbsCoor2D () const { return this->absCoordinate; };
    167     const Vector2D& getAbsCoor2Dpx () const;
    168 
    169     void shiftCoor2D (const Vector2D& shift);
    170     void shiftCoor2Dpx (int x, int y);
    171 
    172     void setRelDir2D (float relDir);
    173     void setRelDirSoft2D(float relDirSoft, float bias = 1.0);
    174     /** @returns the relative Direction */
    175     inline float getRelDir2D () const { return this->prevRelDirection; };
    176     /** @returns the Relative Directional Destination */
    177     inline float getRelDirSoft2D() const { return (this->toDirection)?*this->toDirection:this->relDirection; };
    178     void setAbsDir2D (float absDir);
    179     void setAbsDirSoft2D (float absDirSoft, float bias = 1.0);
    180     /** @returns the absolute Direction */
    181     inline float getAbsDir2D () const { return this->absDirection; };
    182     void shiftDir2D (float shiftDir);
    183 
    184     /** @returns the Speed of the Node */
    185     inline float getSpeed() const { return 0; };
    186     /** @returns the Velocity of the Node */
    187     inline const Vector2D& getVelocity() const { return this->velocity; };
    188 
    189 
    190     void addChild2D (Element2D* child);
    191     void addChild2D (const std::string& childName);
    192     void removeChild2D (Element2D* child);
    193     void remove2D();
    194 
    195     /** @param parent the new parent of this Element2D */
    196     void setParent2D (Element2D* parent) { parent->addChild2D(this); };
    197     void setParent2D (const std::string& parentName);
    198     /** @returns the parent of this Element2D */
    199     inline Element2D* getParent2D () const { return this->parent; };
    200     /** @returns the List of Children of this Element2D */
    201     inline const std::list<Element2D*>& getChildren2D() const { return this->children; };
    202 
    203     void setParentSoft2D(Element2D* parentNode, float bias = 1.0);
    204     void setParentSoft2D(const std::string& parentName, float bias = 1.0);
    205 
    206     void setParentMode2D (E2D_PARENT_MODE parentMode);
    207     void setParentMode2D (const std::string& parentingMode);
    208     /** @returns the Parenting mode of this node */
    209     int getParentMode2D() const { return this->parentMode; };
    210 
    211     // NULL_PARENT //
    212     /** @returns the NullParent, the (main) ROOT of the PNode Tree. If it does not yet exist, it will be created. */
    213     static Element2D* getNullElement()  { return (Element2D::nullElement != NULL)? Element2D::nullElement : Element2D::createNullElement(); };
    214 
    215 
    216     void update2D (float dt);
    217 
    218     void debug2D (unsigned int depth = 1, unsigned int level = 0) const;
    219     void debugDraw2D(unsigned int depth = 1, float size = 1.0, Vector color = Vector(1,0,0), unsigned int level = 0) const;
    220 
    221     // helper functions //
    222     static const char* parentingModeToString2D(int parentingMode);
    223     static E2D_PARENT_MODE stringToParentingMode2D(const std::string& parentingMode);
    224 
    225     static const char* layer2DToChar(E2D_LAYER layer);
    226     static E2D_LAYER charToLayer2D(const std::string& layer);
    227 
    228     static bool layerSortPredicate(const Element2D* elem1, const Element2D* elem2);
    229 
    230   private:
    231     void eraseChild2D(Element2D* child);
    232     /** tells the child that the parent's Coordinate has changed */
    233     inline void parentCoorChanged2D () { this->bRelCoorChanged = true; }
    234     /** tells the child that the parent's Direction has changed */
    235     inline void parentDirChanged2D () { this->bRelDirChanged = true; }
    236     /** @returns the last calculated coordinate */
    237     inline Vector2D getLastAbsCoor2D() { return this->lastAbsCoordinate; }
    238 
    239     void reparent2D();
    240     static Element2D* createNullElement();
    241     bool checkIntegrity(const Element2D* checkParent) const;
    242 
    243 
    244   private:
    245     const PNode*            bindNode;           //!< a node over which to display this 2D-element
    246     Vector2D                size;               //!< The size of the rendered item
    247     Vector2D*               toSize;             //!< The Size to iterate to.
    248 
    249     E2D_ALIGNMENT           alignment;          //!< How the Element is aligned around its Position
    250 
    251     bool                    bVisible;           //!< If the given Element2D is visible.
    252     bool                    bCurrentlyVisible;  //!< Evaluated in the TICK process, to see if the Element is Currently visible.
    253     bool                    bActive;            //!< If the given Element2D is active.
    254     E2D_LAYER               layer;              //!< What layer this Element2D is on.
    255 
    256     bool                    bRelCoorChanged;    //!< If Relative Coordinate has changed since last time we checked
    257     bool                    bRelDirChanged;     //!< If Relative Direction has changed since last time we checked
    258 
    259     Vector2D                relCoordinate;      //!< coordinates relative to the parent
    260     Vector2D                absCoordinate;      //!< absolute coordinates in the world ( from (0,0,0) )
    261     float                   relDirection;       //!< direction relative to the parent
    262     float                   absDirection;       //!< absolute diretion in the world ( from (0,0,1) )
    263 
    264     Vector2D                prevRelCoordinate;  //!< The last Relative Coordinate from the last update-Cycle.
    265     Vector2D                lastAbsCoordinate;  //!< this is used for speedcalculation, it stores the last coordinate
    266     float                   prevRelDirection;   //!< The last Relative Direciton from the last update-Cycle.
    267 
    268     Vector2D                velocity;           //!< Saves the velocity.
    269 
    270     Vector2D*               toCoordinate;       //!< a position to which to iterate. (This is used in conjunction with setParentSoft.and set*CoorSoft)
    271     float*                  toDirection;        //!< a direction to which to iterate. (This is used in conjunction with setParentSoft and set*DirSoft)
    272     float                   bias;               //!< how fast to iterate to the given position (default is 1)
    273 
    274     Element2D*              parent;             //!< a pointer to the parent node
    275     std::list<Element2D*>   children;           //!< list of the children of this Element2D
    276 
    277     unsigned int            parentMode;         //!< the mode of the binding
    278 
    279     static Element2D*       nullElement;        //!< The top-most Element
     89class Element2D : virtual public BaseObject
     90{
     91  NewObjectListDeclaration(Element2D);
     92
     93public:
     94  Element2D(Element2D* parent = Element2D::getNullElement(), E2D_LAYER layer = E2D_DEFAULT_LAYER, short nodeFlags = E2D_PARENT_MODE_DEFAULT);
     95  virtual ~Element2D();
     96
     97  virtual void loadParams(const TiXmlElement* root);
     98
     99  // ACTIVATION //
     100  inline void activate2D() { this->bActive = this->bRelCoorChanged = this->bRelDirChanged = true; };
     101  inline void deactivate2D() { this->bActive = false; };
     102  inline bool get2DActiveState() { return this->bActive; };
     103
     104  // ALIGNMENT //
     105  /** @param alignment the new Alignment of the 2D-Element */
     106  inline void setAlignment(E2D_ALIGNMENT alignment) { this->alignment = alignment; };
     107  void setAlignment(const std::string& alignment);
     108  inline E2D_ALIGNMENT getAlignment() const { return this->alignment; };
     109
     110  // LAYERING //
     111  void setLayer(E2D_LAYER layer);
     112  void setLayer(const std::string& layer);
     113  /** @returns the Layer this Element is drawn to */
     114  inline E2D_LAYER getLayer() const { return this->layer; };
     115
     116  // VISIBILITY //
     117  /** @param visible true if the Element should be visible false otherwise (will not be rendered) */
     118  inline void setVisibility(bool visible) { this->bVisible = visible; };
     119  /** @returns the visibility state */
     120  inline bool isVisible() const { return (this->bVisible && this->bCurrentlyVisible);  };
     121
     122
     123  // POSITIONAL (E2D-specials) //
     124  /** @param bindNode the Node this 2D-element should follow. if NULL the Element will not follow anything */
     125  void setBindNode(const PNode* bindNode);
     126  void setBindNode(const std::string& bindNode);
     127  inline const PNode* getBindNode() const { return this->bindNode; };
     128
     129  inline void setSize2D(float x, float y) { this->size = Vector2D(x, y); };
     130  inline void setSize2D(const Vector2D& size) { this->size = size; };
     131  inline const Vector2D& getSize2D() const { return this->size; };
     132  void setSizeSoft2D(float x, float y, float bias = 1.0);
     133  inline void setSizeX2D(float x) { this->size.x = x; };
     134  inline void setSizeY2D(float y) { this->size.y = y; };
     135  inline float getSizeX2D() const { return this->size.x; };
     136  inline float getSizeY2D() const { return this->size.y; };
     137
     138public:
     139  virtual void tick(float dt) {};
     140  virtual void draw() const  {};
     141  void tick2D(float dt);
     142  void draw2D(E2D_LAYER from, E2D_LAYER to) const;
     143  void drawChildren(E2D_LAYER from, E2D_LAYER to) const;
     144
     145  // LIKE PNODE
     146public:
     147  void setRelCoor2D (const Vector2D& relCoord);
     148  void setRelCoorX2D(float x);
     149  void setRelCoorY2D(float y);
     150  void setRelCoor2D (float x, float y);
     151  void setRelCoor2Dpx (int x, int y);
     152  void setRelCoorSoft2D (const Vector2D& relCoordSoft, float bias = 1.0);
     153  void setRelCoorSoft2D (float x, float y, float bias = 1.0);
     154  void setRelCoorSoft2Dpx (int x, int y, float bias = 1.0);
     155  /** @returns the relative position */
     156  inline const Vector2D& getRelCoor2D () const { return this->prevRelCoordinate; };
     157  /** @returns the Relative Coordinate Destination */
     158inline const Vector2D& getRelCoorSoft2D() const { return (this->toCoordinate)?*this->toCoordinate:this->relCoordinate; };
     159  const Vector2D& getRelCoor2Dpx() const;
     160  void setAbsCoor2D (const Vector2D& absCoord);
     161  void setAbsCoor2D (float x, float y);
     162  void setAbsCoorX2D(float x);
     163  void setAbsCoorY2D(float y);
     164  void setAbsCoor2Dpx (int x, int y);
     165  void setAbsCoorSoft2D (const Vector2D& absCoordSoft, float bias = 1.0);
     166  void setAbsCoorSoft2D (float x, float y, float bias = 1.0);
     167  /** @returns the absolute position */
     168  inline const Vector2D& getAbsCoor2D () const { return this->absCoordinate; };
     169  const Vector2D& getAbsCoor2Dpx () const;
     170
     171  void shiftCoor2D (const Vector2D& shift);
     172  void shiftCoor2Dpx (int x, int y);
     173
     174  void setRelDir2D (float relDir);
     175  void setRelDirSoft2D(float relDirSoft, float bias = 1.0);
     176  /** @returns the relative Direction */
     177  inline float getRelDir2D () const { return this->prevRelDirection; };
     178  /** @returns the Relative Directional Destination */
     179inline float getRelDirSoft2D() const { return (this->toDirection)?*this->toDirection:this->relDirection; };
     180  void setAbsDir2D (float absDir);
     181  void setAbsDirSoft2D (float absDirSoft, float bias = 1.0);
     182  /** @returns the absolute Direction */
     183  inline float getAbsDir2D () const { return this->absDirection; };
     184  void shiftDir2D (float shiftDir);
     185
     186  /** @returns the Speed of the Node */
     187  inline float getSpeed() const { return 0; };
     188  /** @returns the Velocity of the Node */
     189  inline const Vector2D& getVelocity() const { return this->velocity; };
     190
     191
     192  void addChild2D (Element2D* child);
     193  void addChild2D (const std::string& childName);
     194  void removeChild2D (Element2D* child);
     195  void remove2D();
     196
     197  /** @param parent the new parent of this Element2D */
     198  void setParent2D (Element2D* parent) { parent->addChild2D(this); };
     199  void setParent2D (const std::string& parentName);
     200  /** @returns the parent of this Element2D */
     201  inline Element2D* getParent2D () const { return this->parent; };
     202  /** @returns the List of Children of this Element2D */
     203  inline const std::list<Element2D*>& getChildren2D() const { return this->children; };
     204
     205  void setParentSoft2D(Element2D* parentNode, float bias = 1.0);
     206  void setParentSoft2D(const std::string& parentName, float bias = 1.0);
     207
     208  void setParentMode2D (E2D_PARENT_MODE parentMode);
     209  void setParentMode2D (const std::string& parentingMode);
     210  /** @returns the Parenting mode of this node */
     211  int getParentMode2D() const { return this->parentMode; };
     212
     213  // NULL_PARENT //
     214  /** @returns the NullParent, the (main) ROOT of the PNode Tree. If it does not yet exist, it will be created. */
     215static Element2D* getNullElement()  { return (Element2D::nullElement != NULL)? Element2D::nullElement : Element2D::createNullElement(); };
     216
     217
     218  void update2D (float dt);
     219
     220  void debug2D (unsigned int depth = 1, unsigned int level = 0) const;
     221  void debugDraw2D(unsigned int depth = 1, float size = 1.0, Vector color = Vector(1,0,0), unsigned int level = 0) const;
     222
     223  // helper functions //
     224  static const char* parentingModeToString2D(int parentingMode);
     225  static E2D_PARENT_MODE stringToParentingMode2D(const std::string& parentingMode);
     226
     227  static const char* layer2DToChar(E2D_LAYER layer);
     228  static E2D_LAYER charToLayer2D(const std::string& layer);
     229
     230  static bool layerSortPredicate(const Element2D* elem1, const Element2D* elem2);
     231
     232private:
     233  void eraseChild2D(Element2D* child);
     234  /** tells the child that the parent's Coordinate has changed */
     235  inline void parentCoorChanged2D () { this->bRelCoorChanged = true; }
     236  /** tells the child that the parent's Direction has changed */
     237  inline void parentDirChanged2D () { this->bRelDirChanged = true; }
     238  /** @returns the last calculated coordinate */
     239  inline Vector2D getLastAbsCoor2D() { return this->lastAbsCoordinate; }
     240
     241  void reparent2D();
     242  static Element2D* createNullElement();
     243  bool checkIntegrity(const Element2D* checkParent) const;
     244
     245
     246private:
     247  const PNode*            bindNode;           //!< a node over which to display this 2D-element
     248  Vector2D                size;               //!< The size of the rendered item
     249  Vector2D*               toSize;             //!< The Size to iterate to.
     250
     251  E2D_ALIGNMENT           alignment;          //!< How the Element is aligned around its Position
     252
     253  bool                    bVisible;           //!< If the given Element2D is visible.
     254  bool                    bCurrentlyVisible;  //!< Evaluated in the TICK process, to see if the Element is Currently visible.
     255  bool                    bActive;            //!< If the given Element2D is active.
     256  E2D_LAYER               layer;              //!< What layer this Element2D is on.
     257
     258  bool                    bRelCoorChanged;    //!< If Relative Coordinate has changed since last time we checked
     259  bool                    bRelDirChanged;     //!< If Relative Direction has changed since last time we checked
     260
     261  Vector2D                relCoordinate;      //!< coordinates relative to the parent
     262  Vector2D                absCoordinate;      //!< absolute coordinates in the world ( from (0,0,0) )
     263  float                   relDirection;       //!< direction relative to the parent
     264  float                   absDirection;       //!< absolute diretion in the world ( from (0,0,1) )
     265
     266  Vector2D                prevRelCoordinate;  //!< The last Relative Coordinate from the last update-Cycle.
     267  Vector2D                lastAbsCoordinate;  //!< this is used for speedcalculation, it stores the last coordinate
     268  float                   prevRelDirection;   //!< The last Relative Direciton from the last update-Cycle.
     269
     270  Vector2D                velocity;           //!< Saves the velocity.
     271
     272  Vector2D*               toCoordinate;       //!< a position to which to iterate. (This is used in conjunction with setParentSoft.and set*CoorSoft)
     273  float*                  toDirection;        //!< a direction to which to iterate. (This is used in conjunction with setParentSoft and set*DirSoft)
     274  float                   bias;               //!< how fast to iterate to the given position (default is 1)
     275
     276  Element2D*              parent;             //!< a pointer to the parent node
     277  std::list<Element2D*>   children;           //!< list of the children of this Element2D
     278
     279  unsigned int            parentMode;         //!< the mode of the binding
     280
     281  static Element2D*       nullElement;        //!< The top-most Element
    280282};
    281283

  • branches/new_class_id/src/lib/graphics/render2D/image_plane.cc

    r9406 r9685  
    2121
    2222#include "graphics_engine.h"
    23 #include "glincl.h"
    2423#include "p_node.h"
    2524
    2625
     26#include "class_id.h"
     27CREATE_FACTORY(ImagePlane, CL_IMAGE_ENTITY);
    2728
    28 
    29 
    30 CREATE_FACTORY(ImagePlane, CL_IMAGE_ENTITY);
     29NewObjectListDefinitionID(ImagePlane, CL_IMAGE_ENTITY);
    3130
    3231
    … …  
    5655void ImagePlane::init()
    5756{
    58   this->setClassID(CL_IMAGE_PLANE, "ImagePlane");
     57  this->registerObject(this, ImagePlane::_objectList);
    5958  this->setName("ImagePlane");
    6059

  • branches/new_class_id/src/lib/graphics/render2D/image_plane.h

    r7843 r9685  
    1717class ImagePlane :  public Element2D
    1818{
    19 
     19  NewObjectListDeclaration(ImagePlane);
    2020  public:
    2121    ImagePlane(const TiXmlElement* root = NULL);

  • branches/new_class_id/src/lib/graphics/render2D/render_2d.cc

    r9406 r9685  
    1919
    2020#include "graphics_engine.h"
    21 #include "class_list.h"
    2221#include "element_2d.h"
    2322
     23NewObjectListDefinition(Render2D);
    2424
    2525
    … …  
    2929Render2D::Render2D ()
    3030{
    31    this->setClassID(CL_RENDER_2D, "Render2D");
    32    this->setName("Render2D");
     31  this->registerObject(this, Render2D::_objectList);
     32  this->setName("Render2D");
    3333
    34    this->showNodes = false;
     34  this->showNodes = false;
    3535}
    3636

  • branches/new_class_id/src/lib/graphics/render2D/render_2d.h

    r7840 r9685  
    1212
    1313//! A default singleton class.
    14 class Render2D : public BaseObject {
     14class Render2D : public BaseObject
     15{
     16  NewObjectListDeclaration(Render2D);
     17
    1518  friend class Element2D;
    1619
    17   public:
    18     virtual ~Render2D();
    19     /** @returns a Pointer to the only object of this Class */
    20     inline static Render2D* getInstance() { if (!singletonRef) singletonRef = new Render2D();  return singletonRef; };
     20public:
     21  virtual ~Render2D();
     22  /** @returns a Pointer to the only object of this Class */
     23  inline static Render2D* getInstance() { if (!singletonRef) singletonRef = new Render2D();  return singletonRef; };
    2124
    22     void toggleNodesVisibility() { this->showNodes = !this->showNodes; };
     25void toggleNodesVisibility() { this->showNodes = !this->showNodes; };
    2326
    24     void update(float dt);
    25     void tick(float dt);
    26     void draw(E2D_LAYER from, E2D_LAYER to) const;
     27  void update(float dt);
     28  void tick(float dt);
     29  void draw(E2D_LAYER from, E2D_LAYER to) const;
    2730
    28   private:
    29     Render2D();
    30     static Render2D*              singletonRef;                    //!< Reference to this class.
     31private:
     32  Render2D();
     33  static Render2D*              singletonRef;                    //!< Reference to this class.
    3134
    32     bool                          showNodes;                       //!< If the debug-Nodes should be visible
    33  };
     35  bool                          showNodes;                       //!< If the debug-Nodes should be visible
     36};
    3437
    3538#endif /* _RENDER_2D_H */

  • branches/new_class_id/src/lib/graphics/shader.cc

    r9406 r9685  
    3333
    3434
    35 
     35NewObjectListDefinition(Shader);
    3636
    3737/**
    … …  
    4040Shader::Shader (const std::string& vertexShaderFile, const std::string& fragmentShaderFile)
    4141{
    42    this->setClassID(CL_SHADER, "Shader");
    43 
     42  this->registerObject(this, Shader::_objectList);
    4443   this->shaderProgram = 0;
    4544   this->vertexShader = 0;

  • branches/new_class_id/src/lib/graphics/shader.h

    r8255 r9685  
    1919class Shader : public BaseObject
    2020{
     21  NewObjectListDeclaration(Shader);
    2122public:
    2223  class Uniform
    … …  
    4243      {
    4344        case 1:
    44           glUniform1fv(this->uniform, 1, vv);
    45           break;
     45        glUniform1fv(this->uniform, 1, vv);
     46        break;
    4647        case 2:
    47           glUniform2fv(this->uniform, 2, vv);
    48           break;
     48        glUniform2fv(this->uniform, 2, vv);
     49        break;
    4950        case 3:
    50           glUniform3fv(this->uniform, 3, vv);
    51           break;
     51        glUniform3fv(this->uniform, 3, vv);
     52        break;
    5253        case 4:
    53           glUniform4fv(this->uniform, 4, vv);
    54           break;
     54        glUniform4fv(this->uniform, 4, vv);
     55        break;
    5556      }
    5657    }
    … …  
    6061      {
    6162        case 1:
    62           glUniform1iv(this->uniform, 1, vv);
    63           break;
     63        glUniform1iv(this->uniform, 1, vv);
     64        break;
    6465        case 2:
    65           glUniform2iv(this->uniform, 2, vv);
    66           break;
     66        glUniform2iv(this->uniform, 2, vv);
     67        break;
    6768        case 3:
    68           glUniform3iv(this->uniform, 3, vv);
    69           break;
     69        glUniform3iv(this->uniform, 3, vv);
     70        break;
    7071        case 4:
    71           glUniform4iv(this->uniform, 4, vv);
    72           break;
     72        glUniform4iv(this->uniform, 4, vv);
     73        break;
    7374      }
    7475    }
    75     private:
     76  private:
    7677    GLint uniform;
    7778  };
    … …  
    99100  static void deactivateShader();
    100101
    101   Shader::Uniform getUniform(const std::string& location) { return Shader::Uniform(this, location); }
     102Shader::Uniform getUniform(const std::string& location) { return Shader::Uniform(this, location); }
    102103
    103104  bool loadShaderProgramm(Shader::Type type, const std::string& fileName);
    … …  
    118119
    119120
    120   GLhandleARB getProgram() const { return this->shaderProgram; }
     121GLhandleARB getProgram() const { return this->shaderProgram; }
    121122  GLhandleARB getVertexS() const { return this->vertexShader; }
    122123  GLhandleARB getFragmentS() const { return this->fragmentShader; }

  • branches/new_class_id/src/lib/graphics/spatial_separation/quadtree.cc

    r9406 r9685  
    2727#define QUADTREE_MATERIAL_COUNT       4
    2828
     29NewObjectListDefinition(Quadtree);
    2930/**
    3031 *  standard constructor
    … …  
    3233Quadtree::Quadtree (const modelInfo* pModelInfo, const int treeDepth)
    3334{
    34   this->setClassID(CL_QUADTREE, "Quadtree");
     35  this->registerObject(this, Quadtree::_objectList);
    3536  this->pModelInfo = pModelInfo;
    3637  this->treeDepth = treeDepth;

  • branches/new_class_id/src/lib/graphics/spatial_separation/quadtree.h

    r6022 r9685  
    2121//! A class for quadtree separation of the world
    2222class Quadtree : public BaseObject {
    23 
     23  NewObjectListDeclaration(Quadtree);
    2424
    2525  public:

  • branches/new_class_id/src/lib/graphics/spatial_separation/quadtree_node.cc

    r9406 r9685  
    2727
    2828
    29 
     29NewObjectListDefinition(QuadtreeNode);
    3030
    3131/**
    … …  
    102102void QuadtreeNode::init()
    103103{
    104   this->setClassID(CL_QUADTREE_NODE, "QuadtreeNode");
     104  this->registerObject(this, QuadtreeNode::_objectList);
    105105
    106106  /* init the rest of the variables for both init types */

  • branches/new_class_id/src/lib/graphics/spatial_separation/quadtree_node.h

    r6617 r9685  
    2626//! A class for a Quadtree Node representation
    2727class QuadtreeNode : public BaseObject {
     28  NewObjectListDeclaration(QuadtreeNode);
    2829
    2930  public:

  • branches/new_class_id/src/lib/graphics/spatial_separation/spatial_separation.cc

    r9406 r9685  
    2424
    2525
    26 
     26NewObjectListDefinition(SpatialSeparation);
    2727
    2828/**
    29  * standard constructor
     29 * @brief standard constructor
    3030 * @param model the model that is to be separated
    3131 * @param overlapSize each box will overlap for a given size
    32 
    33    The boxes are overlaping because this makes collision detection a lot simpler
    34 
     32 *
     33 * The boxes are overlaping because this makes collision detection a lot simpler
     34 *
    3535 */
    3636SpatialSeparation::SpatialSeparation (Model* model, float overlapSize)
    … …  
    3939  PRINT(3)("+-| (Event) Spatial Separation process kicked on\n");
    4040
    41   this->setClassID(CL_SPATIAL_SEPARATION, "SpatialSeparation");
     41  this->registerObject(this, SpatialSeparation::_objectList);
    4242  /* debug vice */
    4343  this->createQuadtree(model);
    … …  
    4646
    4747/**
    48  * standard constructor
     48 * @brief standard constructor
    4949 * @param model the model that is to be separated
    5050 * @param overlapSize each box will overlap for a given size
    … …  
    5454SpatialSeparation::SpatialSeparation (Model* model, Model* playerModel)
    5555{
    56   this->setClassID(CL_SPATIAL_SEPARATION, "SpatialSeparation");
     56  this->registerObject(this, SpatialSeparation::_objectList);
    5757
    5858}
    … …  
    6060
    6161/**
    62  * standard deconstructor
     62 * @brief standard deconstructor
    6363 */
    6464SpatialSeparation::~SpatialSeparation ()
    … …  
    7070
    7171/**
    72  * creates a quadtree
     72 * @brief creates a quadtree
    7373 * @param model the model to do a quadtree on
    7474 * @param minLength the minimal length of a quadtree node
    … …  
    8383
    8484/**
    85  *  brief creates a quadtree
     85 * @brief creates a quadtree
    8686 * @param model the model to do a quadtree on
    8787 * @param minLength the minimal length of a quadtree node
    … …  
    9595
    9696/**
    97  * creates a quadtree
     97 * @brief creates a quadtree
    9898 * @param model the model to do a quadtree on
    9999 * @param minLength the minimal length of a quadtree node
    … …  
    109109
    110110/**
    111  * draws all the quadtrees
     111 * @brief draws all the quadtrees
    112112 */
    113113void SpatialSeparation::drawQuadtree()
    … …  
    118118  this->quadtree->drawTree();
    119119}
    120 
    121 
    122 
    123 
    124 
    125 
    126 
    127 
    128 
    129 
    130 
    131 

  • branches/new_class_id/src/lib/graphics/spatial_separation/spatial_separation.h

    r6022 r9685  
    1919//! A class for spatial separation of vertices based arrays
    2020class SpatialSeparation : public BaseObject {
     21  NewObjectListDeclaration(SpatialSeparation);
    2122
    2223  public:

  • branches/new_class_id/src/lib/graphics/text_engine/font.cc

    r8989 r9685  
    2929#include "compiler.h"
    3030
     31NewObjectListDefinition(Font);
    3132
    3233Font::Font()
    … …  
    130131  this->setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    131132
    132   this->setClassID(CL_FONT, "Font");
     133  this->registerObject(this, Font::_objectList);
    133134  if (Font::defaultFontData.get() == NULL)
    134135  {

  • branches/new_class_id/src/lib/graphics/text_engine/font.h

    r8766 r9685  
    1919class Font : public Material
    2020{
     21  NewObjectListDeclaration(Font);
    2122
    2223public:

  • branches/new_class_id/src/lib/graphics/text_engine/limited_width_text.cc

    r9406 r9685  
    1919#include "font.h"
    2020
     21NewObjectListDefinition(LimitedWidthText);
    2122/**
    2223 * @brief creates a new Text Element
    … …  
    2728    : Text(fontFile, textSize)
    2829{
    29   this->setClassID(CL_LIMITED_WIDTH_TEXT, "LimitedWidthText");
     30  this->registerObject(this, LimitedWidthText::_objectList);
    3031
    3132  this->_dotsPosition = End;

  • branches/new_class_id/src/lib/graphics/text_engine/limited_width_text.h

    r8980 r9685  
    1414class LimitedWidthText : public Text
    1515{
     16  NewObjectListDeclaration(LimitedWidthText);
    1617  public:
    1718    typedef enum {

  • branches/new_class_id/src/lib/graphics/text_engine/multi_line_text.cc

    r9406 r9685  
    1919#include "font.h"
    2020
     21NewObjectListDefinition(MultiLineText);
     22
    2123/**
    2224 * @brief creates a new Text Element
    … …  
    2729  : Text(fontFile, textSize)
    2830{
    29   this->setClassID(CL_MULTI_LINE_TEXT, "MultiLineText");
     31  this->registerObject(this, MultiLineText::_objectList);
    3032
    3133  this->lineSpacing = 1.0;

  • branches/new_class_id/src/lib/graphics/text_engine/multi_line_text.h

    r7757 r9685  
    1414class MultiLineText : public Text
    1515{
     16  NewObjectListDeclaration(MultiLineText);
    1617  public:
    1718    MultiLineText(const std::string& fontFile = "", unsigned int fontSize = TEXT_DEFAULT_SIZE, float lineWidth = 100.0);

  • branches/new_class_id/src/lib/graphics/text_engine/text.cc

    r9406 r9685  
    2222#include "debug.h"
    2323
     24NewObjectListDefinition(Text);
     25
    2426/**
    2527 * @brief creates a new Text Element
    … …  
    3032    // : _font(fontFile, FONT_DEFAULT_RENDER_SIZE)
    3133{
    32   this->setClassID(CL_TEXT, "Text");
     34  this->registerObject(this, Text::_objectList);
    3335
    3436  // initialize this Text
    … …  
    4446    : _font()
    4547{
    46   this->setClassID(CL_TEXT, "Text");
     48  this->registerObject(this, Text::_objectList);
    4749
    4850  *this = text;

  • branches/new_class_id/src/lib/graphics/text_engine/text.h

    r8764 r9685  
    2626class Text : public Element2D
    2727{
     28  NewObjectListDeclaration(Text);
    2829  public:
    2930    Text(const std::string& fontFile = "", unsigned int fontSize = TEXT_DEFAULT_SIZE);

  • branches/new_class_id/src/lib/graphics/text_engine/text_engine.cc

    r9406 r9685  
    3434#include "graphics_engine.h"
    3535#include "util/loading/resource_manager.h"
    36 #include "class_list.h"
    3736
    3837#include "debug.h"
    … …  
    4039/// TEXT-ENGINE ///
    4140///////////////////
     41NewObjectListDefinition(TextEngine);
    4242/**
    4343 *  standard constructor
    … …  
    4545TextEngine::TextEngine ()
    4646{
    47    this->setClassID(CL_TEXT_ENGINE, "TextEngine");
    48    this->setName("TextEngine");
    49    this->enableFonts();
     47  this->registerObject(this, TextEngine::_objectList);
     48  this->setName("TextEngine");
     49  this->enableFonts();
    5050}
    5151
    … …  
    6262{
    6363  // first remove all the remaining Texts (if any).
    64   const std::list<BaseObject*>* textList = ClassList::getList(CL_TEXT);
    65   if (textList != NULL)
    66   {
    67     while(textList->size() > 0)
    68       delete dynamic_cast<Text*>(textList->front());
    69   }
     64  while (!Text::objectList().empty())
     65    delete Text::objectList().front();
    7066  // delete all remaining fonts (There should not be Anything to do here)
    71   const std::list<BaseObject*>* fontList = ClassList::getList(CL_FONT);
    72   if (fontList != NULL)
     67
     68  //const std::list<BaseObject*>* fontList = ClassList::getList(CL_FONT);
     69  //if (fontList != NULL)
    7370  {
    7471    ///FIXME
    75 //    while (fontList->size() > 0)
     72    //    while (fontList->size() > 0)
    7673    {
    77 //      Font* font = dynamic_cast<Font*>(fontList->back());
     74      //      Font* font = dynamic_cast<Font*>(fontList->back());
    7875      //if (likely(font != Font::getDefaultFont()))
    7976      //        ResourceManager::getInstance()->unload(font, RP_GAME);
    … …  
    9188{
    9289  if (!TTF_WasInit())
    93     {
    94       if(TTF_Init()==-1)
    95         PRINTF(1)("TTF_Init: %s\n", TTF_GetError());
     90  {
     91    if(TTF_Init()==-1)
     92      PRINTF(1)("TTF_Init: %s\n", TTF_GetError());
    9693
    97       TextEngine::checkVersion();
    98     }
     94    TextEngine::checkVersion();
     95  }
    9996  else
    10097    PRINTF(4)("Fonts already initialized\n");
    … …  
    107104{
    108105  if (TTF_WasInit())
    109     {
    110 //      Font::removeDefaultFont();
    111       TTF_Quit();
    112     }
     106  {
     107    //      Font::removeDefaultFont();
     108    TTF_Quit();
     109  }
    113110  else
    114111    PRINTF(4)("Fonts were not initialized.\n");
    … …  
    122119void TextEngine::debug() const
    123120{
    124   const std::list<BaseObject*>* textList = ClassList::getList(CL_TEXT);
    125   if (textList != NULL)
     121  PRINT(0)("+-------------------------------+\n");
     122  PRINT(0)("+ TEXT ENGINE DEBUG INFORMATION +\n");
     123  PRINT(0)("+-------------------------------+\n");
     124  PRINT(0)("Reference: %p; Text Counts: %d\n", this, Text::objectList().size());
     125
     126  for (NewObjectList<Text>::const_iterator it = Text::objectList().begin();
     127       it != Text::objectList().end();
     128       ++it)
    126129  {
    127     PRINT(0)("+-------------------------------+\n");
    128     PRINT(0)("+ TEXT ENGINE DEBUG INFORMATION +\n");
    129     PRINT(0)("+-------------------------------+\n");
    130     PRINT(0)("Reference: %p; Text Counts: %d\n", this, textList->size());
    131 
    132     std::list<BaseObject*>::const_iterator text;
    133     for ( text = textList->begin(); text != textList->end(); text++)
    134       dynamic_cast<Text*>(*text)->debug();
     130      (*it)->debug();
    135131    PRINT(0)("+---------------------------TE--+\n");
    136132  }
    … …  
    152148      compile_version.minor == link_version.minor &&
    153149      compile_version.patch == link_version.patch)
    154     {
    155       return true;
    156     }
     150  {
     151    return true;
     152  }
    157153  else
    158     {
    159       PRINTF(2)("compiled with SDL_ttf version: %d.%d.%d\n",
    160                 compile_version.major,
    161                 compile_version.minor,
    162                 compile_version.patch);
     154  {
     155    PRINTF(2)("compiled with SDL_ttf version: %d.%d.%d\n",
     156              compile_version.major,
     157              compile_version.minor,
     158              compile_version.patch);
    163159
    164       PRINTF(2)("running with SDL_ttf version: %d.%d.%d\n",
    165                 link_version.major,
    166                 link_version.minor,
    167                 link_version.patch);
    168       return false;
    169     }
     160    PRINTF(2)("running with SDL_ttf version: %d.%d.%d\n",
     161              link_version.major,
     162              link_version.minor,
     163              link_version.patch);
     164    return false;
     165  }
    170166}

  • branches/new_class_id/src/lib/graphics/text_engine/text_engine.h

    r5515 r9685  
    2424class TextEngine : public BaseObject
    2525{
    26  public:
     26  NewObjectListDeclaration(TextEngine);
     27  public:
    2728  virtual ~TextEngine();
    2829  /** @returns a Pointer to the only object of this Class */
Note: See TracChangeset for help on using the changeset viewer.