Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Mar 18, 2005, 11:52:15 AM (20 years ago)
Author:
bensch
Message:

orxonox/trunk: merged trunk back to levelloader
merged with command:
svn merge -r 3499:HEAD trunk branches/levelloader

Conflicts in
C track_manager.h
C world_entities/player.cc
C world_entities/player.h
C world_entities/environment.h
C lib/coord/p_node.cc
C defs/debug.h
C track_manager.cc
C story_entities/campaign.h

solved in merge-favouring. It was quite easy because Chris only worked on the headers, and he didi it quite clean. Thats the spirit :)

Conflits in world.cc are a MESS: fix it

Location:
orxonox/branches/levelloader/src/world_entities
Files:
4 deleted
9 edited
10 copied

Legend:

Unmodified
Added
Removed

  • orxonox/branches/levelloader/src/world_entities/environment.cc

    r3557 r3605  
    100100Environment::~Environment ()
    101101{
    102   delete this->model;
     102
    103103}
    104104
    105105void Environment::tick (float time) {}
    106106
    107 void Environment::hit (WorldEntity* weapon, Vector loc) {}
     107void Environment::hit (WorldEntity* weapon, Vector* loc) {}
    108108
    109109void Environment::destroy () {}
    … …  
    114114{
    115115  glMatrixMode(GL_MODELVIEW);
    116   glLoadIdentity();
     116  glPushMatrix();
    117117  float matrix[4][4];
    118118 
    … …  
    123123 
    124124  this->model->draw();
     125
     126  glPopMatrix();
    125127}
    126128

  • orxonox/branches/levelloader/src/world_entities/environment.h

    r3542 r3605  
    99  friend class World;
    1010
    11  private:
    12   float xCor;
    13   float yCor;
    14   float zCor;
    15 
    16   float mountainTest[10][10];
    17 
    1811 public:
    1912  Environment ();
    2013  Environment (TiXmlElement* root);
    21   ~Environment ();
    22 
     14  virtual ~Environment ();
    2315 
    2416  virtual void tick (float time);
    25   virtual void hit (WorldEntity* weapon, Vector loc);
     17  virtual void hit (WorldEntity* weapon, Vector* loc);
    2618  virtual void destroy ();
    2719  virtual void collide (WorldEntity* other,  Uint32 ownhitflags, Uint32 otherhitflags);

  • orxonox/branches/levelloader/src/world_entities/player.cc

    r3604 r3605  
    1616*/
    1717
     18#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_PLAYER
     19
    1820#include "player.h"
     21
    1922#include "stdincl.h"
    2023//#include "collision.h"
    2124#include "objModel.h"
     25#include "list.h"
     26#include "weapon.h"
     27#include "track_manager.h"
    2228
    2329using namespace std;
    … …  
    3137Player::Player(bool isFree) : WorldEntity(isFree)
    3238{
    33 
    3439  this->model = new OBJModel("../data/models/reaplow.obj");
    35   /*
    36   objectList = glGenLists(1);
    37   glNewList (objectList, GL_COMPILE);
    38 
    39   glBegin(GL_TRIANGLES);
    40   glColor3f(1,1,1);
    41   glVertex3f(0,0,0.5);
    42   glVertex3f(-0.5,0,-1);
    43   glVertex3f(0.5,0,-1);
    44 
    45   glVertex3f(0,0,0.5);
    46   glVertex3f(0,0.5,-1);
    47   glVertex3f(0,-0.5,-1);
    48   glEnd();
    49    
    50   glBegin(GL_QUADS);
    51   glColor3f(0,0,1);
    52   glVertex3f(0.5,0.5,-1);
    53   glVertex3f(0.5,-0.5,-1);
    54   glVertex3f(-0.5,-0.5,-1);
    55   glVertex3f(-0.5,0.5,-1);
    56   glEnd();
    57  
    58   glEndList ();
    59   */
    60 }
     40  this->weapons = new tList<Weapon>();
     41  this->activeWeapon = NULL;
     42
     43  travelSpeed = 15.0;
     44  velocity = Vector();
     45  bUp = bDown = bLeft = bRight = bAscend = bDescend = false;
     46  bFire = false;
     47  acceleration = 10.0;
     48}
     49
     50/**
     51   \brief destructs the player, deletes alocated memory
     52*/
     53Player::~Player ()
     54{
     55  Weapon* w = this->weapons->enumerate();
     56  while( w != NULL)
     57    {
     58      delete w;
     59      w = this->weapons->nextElement();
     60    }
     61  delete this->weapons;
     62 
     63  //delete this->velocity;
     64}
     65
    6166
    6267/**
    … …  
    102107
    103108/**
    104    \brief destructs the player
    105 */
    106 Player::~Player ()
    107 {
    108   delete this->model;
    109 }
     109   \brief adds a weapon to the weapon list of player
     110   \param weapon to add
     111*/
     112void Player::addWeapon(Weapon* weapon)
     113{
     114  this->weapons->add(weapon);
     115}
     116
     117
     118/**
     119   \brief removes a weapon from the player
     120   \param weapon to remove
     121*/
     122void Player::removeWeapon(Weapon* weapon)
     123{
     124  this->weapons->remove(weapon);
     125}
     126
    110127
    111128/**
    … …  
    114131void Player::postSpawn ()
    115132{
    116   travelSpeed = 15.0;
    117   velocity = Vector();
    118   bUp = bDown = bLeft = bRight = bAscend = bDescend = false;
    119   bFire = false;
    120   acceleration = 10.0;
    121133  //setCollision(new CollisionCluster(1.0, Vector(0,0,0)));
    122134}
    123135
    124 /**
    125    \brief the function called for each passing timeSnap
    126    \param time The timespan passed since last update
    127 */
    128 void Player::tick (float time)
    129 {
    130   // movement
    131   this->move (time);
    132 }
     136
     137/**
     138   \brief the action occuring if the player left the game
     139*/
     140void Player::leftWorld ()
     141{}
     142
     143
    133144
    134145/**
    … …  
    137148   \param loc ??
    138149*/
    139 void Player::hit (WorldEntity* weapon, Vector loc)
    140 {
    141 }
    142 
    143 /**
    144    \brief action that happens when the player is destroyed.
    145 */
    146 void Player::destroy ()
    147 {
    148 }
     150void Player::hit (WorldEntity* weapon, Vector* loc)
     151{
     152}
     153
    149154
    150155/**
    … …  
    158163}
    159164
    160 /**
    161    \brief The connection to the command node
    162    \param cmd the Command unit from witch to map
    163 
    164    here the commands are mapped to the players movement/weaponary
    165 */
    166 void Player::command (Command* cmd)
    167 {
    168   //printf("Player|recieved command [%s]\n", cmd->cmd);
    169   if( !strcmp( cmd->cmd, "up")) bUp = !cmd->bUp;
    170   else if( !strcmp( cmd->cmd, "down")) bDown = !cmd->bUp;
    171   else if( !strcmp( cmd->cmd, "left")) bLeft = !cmd->bUp;
    172   else if( !strcmp( cmd->cmd, "right")) bRight = !cmd->bUp;
    173   else if( !strcmp( cmd->cmd, "fire")) bFire = !cmd->bUp;
    174 }
    175165
    176166/**
    … …  
    180170{
    181171  glMatrixMode(GL_MODELVIEW);
    182   glLoadIdentity();
     172  glPushMatrix();
    183173  float matrix[4][4];
    184174 
    … …  
    191181  glMultMatrixf((float*)matrix);
    192182 
    193   glMatrixMode(GL_MODELVIEW);
    194183  this->model->draw();
    195   // glCallList(objectList);
    196 }
    197 
    198 
    199 /*PN
    200   void Player::getLookat(Location* locbuf)
    201   {
    202   *locbuf = *getLocation();
    203   //locbuf->dist += 5.0;
    204   }
    205 */
    206 
    207 /**
    208    \brief the action occuring if the player left the game
    209 */
    210 void Player::leftWorld ()
    211 {
    212 }
     184  glPopMatrix();
     185}
     186
     187
     188/**
     189   \brief the function called for each passing timeSnap
     190   \param time The timespan passed since last update
     191*/
     192void Player::tick (float time)
     193{
     194  // player controlled movement
     195  this->move (time);
     196  // weapon system manipulation
     197  this->fire();
     198}
     199
    213200
    214201/**
    … …  
    220207  Vector accel(0.0, 0.0, 0.0);
    221208  /* FIXME: calculating the direction and orthDirection every timeSlice is redundant! save it somewhere */
    222   //Placement *pos = getPlacement();
    223209 
    224210  /* calculate the direction in which the craft is heading  */
    … …  
    228214  //orthDirection = orthDirection.cross (direction);
    229215
    230   if( bUp) { accel = accel+(direction*acceleration); }
    231   if( bDown) { accel = accel-(direction*acceleration); }
    232   if( bLeft ) { accel = accel - (orthDirection*acceleration); }
    233   if( bRight ) { accel = accel + (orthDirection*acceleration); }
    234   if( bAscend ) { /* not yet implemented but just: (0,0,1)*acceleration */}
    235   if( bDescend) {/* FIXME */} /* \todo up and down player movement */
    236 
    237   //Location* l = getLocation();
    238  
    239   // r(t) = r(0) + v(0)*t + 1/2*a*t^2
    240   // r = position
    241   // v = velocity
    242   // a = acceleration
    243 
    244   /* this the base-speed of the player: determines how fast and how the player follows the track*/
    245   //l->dist = l->dist + travelSpeed * time;
    246  
    247   Vector* shift = new Vector (this->travelSpeed * time, 0, 0);
    248   this->shiftCoor (shift);
    249  
    250   /* this updates the player position on the track - user interaction */
    251   //l->pos = l->pos + accel*time;
     216  if( this->bUp && this->getRelCoor().x < 20)
     217    accel = accel+(direction*acceleration);
     218  if( this->bDown && this->getRelCoor().x > -5)
     219    accel = accel-(direction*acceleration);
     220  if( this->bLeft &&  TrackManager::getInstance()->getWidth() > -this->getRelCoor().z*2)
     221    accel = accel - (orthDirection*acceleration);
     222  if( this->bRight &&  TrackManager::getInstance()->getWidth() > this->getRelCoor().z*2)
     223    accel = accel + (orthDirection*acceleration);
     224  if( this->bAscend )
     225  if( this->bDescend) {/* FIXME */} /* \todo up and down player movement */
     226
    252227  Vector move = accel * time;
    253228  this->shiftCoor (&move);
    254229}
     230
     231
     232/**
     233   \brief weapon manipulation by the player
     234*/
     235void Player::fire()
     236{
     237  if(this->bFire)
     238    {
     239      if(this->activeWeapon != NULL)
     240        this->activeWeapon->fire();
     241    }
     242  if(this->bWeaponChange)
     243    {
     244      Weapon* w = this->weapons->enumerate();
     245      this->activeWeapon = this->weapons->nextElement(this->activeWeapon);
     246    }
     247}
     248
     249
     250/**
     251   \brief The connection to the command node
     252   \param cmd the Command unit from witch to map
     253
     254   here the commands are mapped to the players movement/weaponary
     255*/
     256void Player::command (Command* cmd)
     257{
     258  PRINTF(3)("recieved command [%s]\n", cmd->cmd);
     259  if( !strcmp( cmd->cmd, "up")) this->bUp = !cmd->bUp;
     260  else if( !strcmp( cmd->cmd, "down")) this->bDown = !cmd->bUp;
     261  else if( !strcmp( cmd->cmd, "left")) this->bLeft = !cmd->bUp;
     262  else if( !strcmp( cmd->cmd, "right")) this->bRight = !cmd->bUp;
     263  else if( !strcmp( cmd->cmd, "fire")) this->bFire = !cmd->bUp;
     264  else if( !strcmp( cmd->cmd, "mode")) this->bWeaponChange = !cmd->bUp;
     265}

  • orxonox/branches/levelloader/src/world_entities/player.h

    r3542 r3605  
    99#include "world_entity.h"
    1010
     11template<class T> class tList;
    1112class OBJModel;
     13class Weapon;
    1214
    1315//! Basic controllable WorldEntity
    … …  
    1921  Player(bool isFree = false);
    2022  Player(TiXmlElement* root);
    21   ~Player();
     23  virtual ~Player();
     24
     25  void addWeapon(Weapon* weapon);
     26  void removeWeapon(Weapon* weapon);
    2227 
    2328  virtual void postSpawn();
    24   virtual void tick(float time);
    25   virtual void hit(WorldEntity* weapon, Vector loc);
    26   virtual void destroy();
     29  virtual void leftWorld();
     30  virtual void hit(WorldEntity* weapon, Vector* loc);
    2731  virtual void collide(WorldEntity* other, Uint32 ownhitflags, Uint32 otherhitflags);
     32
     33  virtual void tick(float time); 
     34  virtual void draw();
     35
    2836  virtual void command(Command* cmd);
    29  
    30   virtual void draw();
    31   // virtual void getLookat(Location* locbuf);
    32  
    33   virtual void leftWorld();
    3437 
    3538 private:
    … …  
    4144  bool bDescend;         //!< descend button presses.
    4245  bool bFire;            //!< fire button pressed.
     46  bool bWeaponChange;    //!< weapon change button pressed
     47
     48  tList<Weapon>* weapons;//!< a list of weapon
     49  Weapon* activeWeapon;  //!< the weapon that is currenty activated
    4350
    4451  Vector velocity;       //!< the velocity of the player.
    … …  
    4754 
    4855  void move(float time);
     56  void fire(void);
    4957 
    5058};

  • orxonox/branches/levelloader/src/world_entities/power_up.h

    r3499 r3605  
    1515 public:
    1616  PowerUp ();
    17   ~PowerUp ();
     17  virtual ~PowerUp ();
    1818 
    1919};

  • orxonox/branches/levelloader/src/world_entities/skysphere.cc

    r3499 r3605  
    2424*/
    2525
     26#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_WORLD_ENTITY
     27
    2628#include "material.h"
    2729#include "skysphere.h"
    … …  
    2931#include "vector.h"
    3032#include "world_entity.h"
    31 
    3233
    3334using namespace std;
    … …  
    3839Skysphere::Skysphere()
    3940{ 
    40   initialize("../data/pictures/sky-replace.jpg");
     41  this->initialize("../data/pictures/sky-replace.jpg");
    4142}
     43
    4244
    4345/**
    … …  
    4749Skysphere::Skysphere(char* fileName)
    4850{
    49   initialize(fileName);
     51  this->initialize(fileName);
    5052}
     53
    5154
    5255/**
    … …  
    5659{
    5760  PRINTF(3)("Deleting the SkySphere\n");
    58   delete skyMaterial;
    59   free(sphereObj);
     61  delete this->skyMaterial;
     62  free(this->sphereObj);
    6063}
    6164
    … …  
    6972  this->sphereObj = gluNewQuadric();
    7073  gluQuadricTexture(this->sphereObj, GL_TRUE);
    71   this->setRadius(250.0);
     74  this->setRadius(1900.0);
    7275
    7376  this->skyMaterial = new Material("Sky");
    … …  
    7578  this->skyMaterial->setIllum(3);
    7679  this->skyMaterial->setAmbient(1.0, 1.0, 1.0);
    77 }
    78 
    79 
    80 /**
    81    \brief sets the Radius of the Sphere.
    82    \param radius The Radius of The Sphere
    83 */
    84 void Skysphere::setRadius(float radius)
    85 {
    86   this->sphereRadius = radius;
    8780}
    8881
    … …  
    9992
    10093/**
    101    \brief updates the position of the Skysphere
    102    \param sphereCenter The coordinate of the Center of the Sphere
    103    
    104    This is normally done in the update-phase of world, so the Skysphere is always centered at the Camera.
    105 */
    106 void Skysphere::updatePosition(Vector sphereCenter)
    107 {
    108   this->sphereCenter = sphereCenter;
    109 }
    110 
    111 
    112 /**
    11394   \brief draws the Skysphere
    11495   
    … …  
    11798void Skysphere::draw()
    11899{
    119   glEnable(GL_TEXTURE_2D);
     100  glPushMatrix();
     101  glMatrixMode(GL_MODELVIEW);
     102  glTranslatef(this->absCoordinate.x,
     103               this->absCoordinate.y,
     104               this->absCoordinate.z);
     105
     106  //glRotatef(-30, 1, 0, 0);
     107  //glRotatef(95.0f, 0.0f, 0.0f, 1.0f);
     108  //glRotatef(-250.0f, 0.0, 1.0f, 0.0f);
     109 
    120110  skyMaterial->select();
    121   glPushMatrix();
    122   glTranslatef(this->sphereCenter.x,this->sphereCenter.y,this->sphereCenter.z);
    123  
    124   glRotatef(-30, 1, 0, 0);
    125   glRotatef(95.0f, 0.0f, 0.0f, 1.0f);
    126   glRotatef(-250.0f, 0.0, 1.0f, 0.0f);
    127  
    128   gluSphere(sphereObj, sphereRadius, 20, 20);
     111  gluSphere(this->sphereObj, this->sphereRadius, 20, 20);
    129112  glPopMatrix();
    130   glDisable(GL_TEXTURE_2D);
    131113}
     114
     115
     116/**
     117   \brief sets the Radius of the Sphere.
     118   \param radius The Radius of The Sphere
     119*/
     120void Skysphere::setRadius(float radius)
     121{
     122  this->sphereRadius = radius;
     123}

  • orxonox/branches/levelloader/src/world_entities/skysphere.h

    r3499 r3605  
    1515/* INCLUDES */
    1616#include "p_node.h"
     17#include "world_entity.h"
    1718
    1819/* FORWARD DEFINITION */
    … …  
    2122
    2223//! A Class to handle a SkySphere
    23 class Skysphere : public PNode
     24class Skysphere : public WorldEntity
    2425{
    2526
    … …  
    2728  Skysphere();
    2829  Skysphere(char* fileName);
    29   ~Skysphere();
     30  virtual ~Skysphere();
     31  void destroy();
    3032
    3133  void setRadius(float radius);
    3234  void setTexture(char* fileName);
    3335
    34   void updatePosition(Vector sphereCenter);
    35   void draw();
     36  virtual void draw();
    3637
    3738 private:
    3839  GLUquadricObj *sphereObj; //!< A Placeholder for the SkySphere.
    3940  Material *skyMaterial;    //!< A Material for the SkySphere.
    40   Vector sphereCenter;      //!< Center of the SkySphere.
    4141  float sphereRadius;       //!< Radius of the SkySphere. This should match the frustum maximum range.
    42 
    43 
     42   
    4443  void initialize(char* fileName); 
    4544};

  • orxonox/branches/levelloader/src/world_entities/world_entity.cc

    r3499 r3605  
    3838  this->setClassName ("WorldEntity");
    3939  this->bDraw = true;
     40  this->model = NULL;
    4041  //  collisioncluster = NULL;
    4142}
    … …  
    4748{
    4849  // if( collisioncluster != NULL) delete collisioncluster;
     50  delete this->model;
    4951}
    5052
    5153/**
    52    \brief get the Location of the WorldEntity
    53    \return a pointer to location
     54   \brief sets the character attributes of a worldentity
     55   \param character attributes
     56
     57   these attributes don't have to be set, only use them, if you need them
    5458*/
    55 /*PN
    56 Location* WorldEntity::getLocation ()
    57 {
    58   return &loc;
    59 }
    60 */
     59void WorldEntity::setCharacterAttributes(CharacterAttributes* charAttr)
     60{}
     61
    6162
    6263/**
    63    \brief get the Placement of the WorldEntity
    64    \return a pointer to placement
     64   \brief gets the Character attributes of this worldentity
     65   \returns character attributes
    6566*/
    66  /*PN
    67 Placement* WorldEntity::getPlacement ()
    68 {
    69   return &place;
    70 }
    71  */
     67CharacterAttributes* WorldEntity::getCharacterAttributes()
     68{}
     69
     70
    7271/**
    7372   \brief query whether the WorldEntity in question is free
    … …  
    9392}
    9493*/
    95 
    96 /**
    97    \brief this method is called every frame
    98    \param time: the time in seconds that has passed since the last tick
    99    
    100    Handle all stuff that should update with time inside this method (movement, animation, etc.)
    101 */
    102 void WorldEntity::tick(float time)
    103 {
    104 }
    10594
    10695
    … …  
    130119
    131120/**
    132    \brief the entity is drawn onto the screen with this function
    133    
    134    This is a central function of an entity: call it to let the entity painted to the screen. Just override this function with whatever you want to be drawn.
    135 */
    136 void WorldEntity::draw()
    137 {}
    138 
    139 /**
    140121   \brief this function is called, when two entities collide
    141122   \param other: the world entity with whom it collides
    … …  
    147128void WorldEntity::collide(WorldEntity* other, Uint32 ownhitflags, Uint32 otherhitflags) {}
    148129
     130
    149131/**
    150132   \brief this function is called, when the ship is hit by a waepon
    … …  
    154136   calculate the damage depending
    155137*/
    156 void WorldEntity::hit(WorldEntity* weapon, Vector loc) {}
    157 
    158 /**
    159    \brief this function is called when the entity is to be destroied
    160    
    161    This can be called, if eg. something realy bad happens :)
    162 */
    163 void WorldEntity::destroy() {}
     138void WorldEntity::hit(WorldEntity* weapon, Vector* loc) {}
    164139
    165140
    … …  
    174149}
    175150
     151
     152/**
     153   \brief this method is called by the world if the WorldEntity leaves valid gamespace
     154   
     155   For free entities this means it left the Track boundaries. With bound entities it means its Location adresses a
     156   place that is not in the world anymore. In both cases you might have to take extreme measures (a.k.a. call destroy).
     157*/
     158void WorldEntity::leftWorld ()
     159{
     160}
     161
     162
     163/**
     164   \brief this method is called every frame
     165   \param time: the time in seconds that has passed since the last tick
     166   
     167   Handle all stuff that should update with time inside this method (movement, animation, etc.)
     168*/
     169void WorldEntity::tick(float time)
     170{
     171}
     172
     173
     174/**
     175   \brief the entity is drawn onto the screen with this function
     176   
     177   This is a central function of an entity: call it to let the entity painted to the screen. Just override this function with whatever you want to be drawn.
     178*/
     179void WorldEntity::draw()
     180{}
     181
     182
    176183/**
    177184   \brief this handles incoming command messages
    … …  
    184191{
    185192}
    186 
    187 /**
    188    \brief this is called by the local Camera to determine the point it should look at on the WorldEntity
    189    \param locbuf: a pointer to the buffer to fill with a location to look at
    190        
    191    You may put any Location you want into locbuf, the Camera will determine via the corresponding Track how
    192    to look at the location you return with this.
    193 */
    194 /*PN
    195 void WorldEntity::getLookat (Location* locbuf)
    196 {
    197 }
    198 */
    199 
    200 /**
    201    \brief this method is called by the world if the WorldEntity leaves valid gamespace
    202    
    203    For free entities this means it left the Track boundaries. With bound entities it means its Location adresses a
    204    place that is not in the world anymore. In both cases you might have to take extreme measures (a.k.a. call destroy).
    205 */
    206 void WorldEntity::leftWorld ()
    207 {
    208 }

  • orxonox/branches/levelloader/src/world_entities/world_entity.h

    r3499 r3605  
    99#include "stdincl.h"
    1010#include "p_node.h"
     11#include "objModel.h"
    1112
    1213//class CollisionCluster;
    13 class OBJModel;
     14class CharacterAttributes;
     15
    1416
    1517//! Basic class from which all interactive stuff in the world is derived from
    … …  
    2224  virtual ~WorldEntity ();
    2325
    24   OBJModel* model;                  //!< The model that should be loaded for this entity.
     26
     27
    2528 
    2629  //void setCollision (CollisionCluster* newhull);
    2730 
    28   bool isFree ();
    29  
    3031  //void addAbility(Ability* ability);
    3132  //void removeAbility(Ability* ability);
    32  
     33  void setDrawable (bool bDraw); 
     34  bool isFree ();
     35  void setCharacterAttributes(CharacterAttributes* charAttr);
     36  CharacterAttributes* getCharacterAttributes();
     37
    3338  virtual void postSpawn ();
    34   virtual void tick (float time);
    35   virtual void hit (WorldEntity* weapon, Vector loc);
    36   virtual void destroy ();
     39  virtual void leftWorld ();
     40
     41  virtual void hit (WorldEntity* weapon, Vector* loc);
    3742  virtual void collide (WorldEntity* other,  Uint32 ownhitflags, Uint32 otherhitflags);
    3843  virtual void command (Command* cmd);
    … …  
    4045  void processDraw ();
    4146  virtual void draw ();
    42   void setDrawable (bool bDraw);
     47  virtual void tick (float time);
    4348 
    44   virtual void leftWorld ();
     49 protected:
     50  OBJModel* model;                  //!< The model that should be loaded for this entity.
     51  CharacterAttributes* charAttr;      //!< the character attributes of a world_entity
    4552 
    4653 private:
    … …  
    4956  bool bDraw;                         //!< If it should be visible.
    5057
     58
     59
    5160  //CollisionCluster* collisioncluster; //!< The collision-Cluster of this entity.
    5261};
Note: See TracChangeset for help on using the changeset viewer.