Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/world_entities/world_entity.cc @ 10147

Last change on this file since 10147 was 10147, checked in by patrick, 14 years ago

merged the mount_point branche back to trunk to use the new std::* based obj file importer

File size: 21.6 KB
Line 
1
2
3/*
4   orxonox - the future of 3D-vertical-scrollers
5
6   Copyright (C) 2004 orx
7
8   This program is free software; you can redistribute it and/or modify
9   it under the terms of the GNU General Public License as published by
10   the Free Software Foundation; either version 2, or (at your option)
11   any later version.
12
13   ### File Specific:
14   main-programmer: Patrick Boenzli, Benjamin Grauer
15   co-programmer: Christian Meier
16*/
17#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_WORLD_ENTITY
18
19#include "world_entity.h"
20#include "shell_command.h"
21
22#include "util/loading/resource_manager.h"
23#include "resource_obj.h"
24#include "md2/md2Model.h"
25#include "md3/md3_model.h"
26
27#include "oif/object_information_file.h"
28#include "mount_point.h"
29
30#include "aabb_tree_node.h"
31
32#include "util/loading/load_param.h"
33#include "obb_tree.h"
34
35#include "elements/glgui_energywidget.h"
36
37#include "state.h"
38#include "camera.h"
39
40#include "collision_filter.h"
41#include "collision_event.h"
42#include "game_rules.h"
43#include "kill.h"
44#include "debug.h"
45
46#include "projectiles/projectile.h"
47
48SHELL_COMMAND(model, WorldEntity, loadModel)
49->describe("sets the Model of the WorldEntity")
50->defaultValues("models/ships/fighter.obj", 1.0f);
51
52SHELL_COMMAND(debugEntity, WorldEntity, debugWE);
53
54
55ObjectListDefinition(WorldEntity);
56/**
57 *  Loads the WordEntity-specific Part of any derived Class
58 *
59 * @param root: Normally NULL, as the Derived Entities define a loadParams Function themeselves,
60 *              that can calls WorldEntities loadParams for itself.
61 */
62WorldEntity::WorldEntity()
63  : Synchronizeable(), _collisionFilter(this)
64{
65  this->registerObject(this, WorldEntity::_objectList);
66
67  this->obbTree = NULL;
68  this->aabbNode = NULL;
69  this->healthWidget = NULL;
70  this->healthMax = 1.0f;
71  this->health = 1.0f;
72  this->damage = 0.0f; // no damage dealt by a default entity
73  this->scaling = 1.0f;
74  this->oiFile = NULL;
75
76  /* OSOLETE */
77  this->bVisible = true;
78  this->bCollide = true;
79
80  this->objectListNumber = OM_INIT;
81  this->lastObjectListNumber = OM_INIT;
82
83  this->_bOnGround = false;
84
85  // registering default reactions:
86  this->subscribeReaction(CoRe::CREngine::CR_OBJECT_DAMAGE, Projectile::staticClassID());
87
88  this->toList(OM_NULL);
89
90  this->registerVar( new SynchronizeableString( &this->md2TextureFileName, &this->md2TextureFileName, "md2TextureFileName", PERMISSION_MASTER_SERVER ) );
91  this->modelFileName_handle = registerVarId( new SynchronizeableString( &modelFileName, &modelFileName, "modelFileName", PERMISSION_MASTER_SERVER ) );
92  this->scaling_handle = registerVarId( new SynchronizeableFloat( &scaling, &scaling, "scaling", PERMISSION_MASTER_SERVER ) );
93  this->list_handle = registerVarId( new SynchronizeableInt( (int*)&objectListNumber, &list_write, "list", PERMISSION_MASTER_SERVER ) );
94
95  this->health_handle = registerVarId( new SynchronizeableFloat( &this->health, &this->health_write, "health", PERMISSION_MASTER_SERVER ) );
96  this->healthMax_handle = registerVarId( new SynchronizeableFloat( &this->healthMax, &this->healthMax_write, "maxHealth", PERMISSION_MASTER_SERVER ) );
97}
98
99/**
100 *  standard destructor
101*/
102WorldEntity::~WorldEntity ()
103{
104  State::getObjectManager()->toList(this, OM_INIT);
105
106  // Delete the model (unregister it with the ResourceManager)
107  for (unsigned int i = 0; i < this->models.size(); i++)
108    this->setModel(NULL, i);
109
110  // remove the object information file
111  if( this->oiFile)
112    delete this->oiFile;
113  // and clear all monut points
114  this->mountPoints.clear();
115
116  // Delete the obbTree
117  if( this->obbTree != NULL)
118    delete this->obbTree;
119
120  if (this->healthWidget != NULL)
121    delete this->healthWidget;
122
123  this->unsubscribeReactions();
124}
125
126/**
127 * loads the WorldEntity Specific Parameters.
128 * @param root: the XML-Element to load the Data From
129 */
130void WorldEntity::loadParams(const TiXmlElement* root)
131{
132  // Do the PNode loading stuff
133  PNode::loadParams(root);
134
135  LoadParam(root, "md2texture", this, WorldEntity, loadMD2Texture)
136  .describe("the fileName of the texture, that should be loaded onto this world-entity. (must be relative to the data-dir)")
137  .defaultValues("");
138
139  // Model Loading
140  LoadParam(root, "model", this, WorldEntity, loadModel)
141  .describe("the fileName of the model, that should be loaded onto this world-entity. (must be relative to the data-dir)")
142  .defaultValues("", 1.0f, 0);
143
144  LoadParam(root, "maxHealth", this, WorldEntity, setHealthMax)
145  .describe("The Maximum health that can be loaded onto this entity")
146  .defaultValues(1.0f);
147
148  LoadParam(root, "health", this, WorldEntity, setHealth)
149  .describe("The Health the WorldEntity has at this moment")
150  .defaultValues(1.0f);
151
152  LoadParam(root, "list", this, WorldEntity, toListS);
153}
154
155
156/**
157 * loads a Model onto a WorldEntity
158 * @param fileName the name of the model to load
159 * @param scaling the Scaling of the model
160 *
161 * FIXME
162 * @todo: separate the obb tree generation from the model
163 */
164void WorldEntity::loadModel(const std::string& fileName, float scaling, unsigned int modelNumber, unsigned int obbTreeDepth)
165{
166  this->modelLODName = fileName;
167  this->scaling = scaling;
168
169  std::string name = fileName;
170
171  if (  name.find( Resources::ResourceManager::getInstance()->mainGlobalPath().name() ) == 0 )
172  {
173    name.erase(Resources::ResourceManager::getInstance()->mainGlobalPath().name().size());
174  }
175
176  this->modelFileName = name;
177
178  if (!fileName.empty())
179  {
180    // search for the special character # in the LoadParam
181    if (fileName.find('#') != std::string::npos)
182    {
183      PRINTF(4)("Found # in %s... searching for LOD's\n", fileName.c_str());
184      std::string lodFile = fileName;
185      unsigned int offset = lodFile.find('#');
186      for (unsigned int i = 0; i < 3; i++)
187      {
188        lodFile[offset] = 48+(int)i;
189        if (Resources::ResourceManager::getInstance()->checkFileInMainPath( lodFile))
190          this->loadModel(lodFile, scaling, i);
191      }
192      return;
193    }
194    if (this->scaling <= 0.0)
195    {
196      PRINTF(1)("YOU GAVE ME A CRAPY SCALE resetting to 1.0\n");
197      this->scaling = 1.0;
198    }
199    /// LOADING AN OBJ FILE
200    if(fileName.find(".obj") != std::string::npos)
201    {
202      PRINTF(4)("fetching OBJ file: %s\n", fileName.c_str());
203      // creating the model and loading it
204      StaticModel* model = new StaticModel();
205      *model = ResourceOBJ(fileName, this->scaling);
206      if (model->getVertexCount() > 0)
207      {
208        this->setModel(model, modelNumber);
209        if( modelNumber == 0 /* FIXME && !this->isA(CL_WEAPON) */)
210          this->buildObbTree(obbTreeDepth);
211      }
212      else
213        delete model;
214
215      // now get the object information file for this model, if any
216      std::string oifName = fileName.substr(0, fileName.length() - 4) + ".oif";
217      this->loadObjectInformationFile( oifName);
218    }
219    /// LOADING AN MD2-model
220    else if(fileName.find(".md2") != std::string::npos)
221    {
222      PRINTF(4)("fetching MD2 file: %s\n", fileName.c_str());
223      Model* m = new MD2Model(fileName, this->md2TextureFileName, this->scaling);
224      //this->setModel((Model*)ResourceManager::getInstance()->load(fileName, MD2, RP_CAMPAIGN), 0);
225      this->setModel(m, 0);
226
227      if( m != NULL)
228        this->buildObbTree(obbTreeDepth);
229    }
230    /// LOADING AN MD3-MODEL.
231    else if(fileName.find(".md3") != std::string::npos)
232    {
233      PRINTF(4)("fetching MD3 file: %s\n", fileName.c_str());
234//      Model* m = new md3::MD3Model(fileName, this->scaling);
235//      this->setModel(m, 0);
236
237      //       if( m != NULL)
238      //         this->buildObbTree(obbTreeDepth);
239    }
240  }
241  else
242  {
243    this->setModel(NULL);
244  }
245}
246
247/**
248 * sets a specific Model for the Object.
249 * @param model The Model to set
250 * @param modelNumber the n'th model in the List to get.
251 */
252void WorldEntity::setModel(Model* model, unsigned int modelNumber)
253{
254  if (this->models.size() <= modelNumber)
255    this->models.resize(modelNumber+1, NULL);
256
257  if (this->models[modelNumber] != NULL)
258  {
259    delete this->models[modelNumber];
260  }
261
262  this->models[modelNumber] = model;
263}
264
265
266
267/**
268 * loads the object information file for this model
269 * @param fileName the name of the file
270 */
271void WorldEntity::loadObjectInformationFile(const std::string& fileName)
272{
273  PRINTF(4)("loading the oif File: %s\n", fileName.c_str());
274
275  this->oiFile = new ObjectInformationFile(fileName);
276}
277
278
279/**
280 * builds the obb-tree
281 * @param depth the depth to calculate
282 */
283bool WorldEntity::buildObbTree(int depth)
284{
285  if( this->obbTree != NULL)
286  {
287    delete this->obbTree;
288    this->obbTree = NULL;
289  }
290
291  if (this->models[0] != NULL)
292    this->obbTree = new OBBTree(depth, models[0]->getModelInfo(), this);
293  else
294  {
295    PRINTF(1)("could not create obb-tree, because no model was loaded yet\n");
296    this->obbTree = NULL;
297    return false;
298  }
299
300
301  // create the axis aligned bounding box
302  if( this->aabbNode != NULL)
303  {
304    delete this->aabbNode;
305    this->aabbNode = NULL;
306  }
307
308  if( this->models[0] != NULL)
309  {
310    this->aabbNode = new AABBTreeNode();
311    this->aabbNode->spawnBVTree(this->models[0]);
312  }
313  else
314  {
315    PRINTF(1)("could not create aabb bounding box, because no model was loaded yet\n");
316    this->aabbNode = NULL;
317    return false;
318  }
319  return true;
320}
321
322
323/**
324 * adds a mount point to the end of the list
325 * @param mountPoint point to be added
326 */
327void WorldEntity::addMountPoint(MountPoint* mountPoint)
328{
329  // add the mount point at the last position
330  this->mountPoints.push_back(mountPoint);
331}
332
333/**
334 * adds a mount point to a world entity
335 * @param mountPoint point to be added
336 */
337void WorldEntity::addMountPoint(int slot, MountPoint* mountPoint)
338{
339  if( this->mountPoints[slot] != NULL)
340  {
341    PRINTF(0)("adding a mount point to a slot, that already exists! ignoring - maybe some object do not get connected well (object: %s)\n", this->getClassCName());
342  }
343
344  // just connect the mount point
345  this->mountPoints[slot] = mountPoint;
346}
347
348
349/**
350 * mounts a world entity on a specified mount point (~socket)
351 * @param entity entity to be connected
352 */
353void WorldEntity::mount(int slot, WorldEntity* entity)
354{
355  if( this->mountPoints[slot] == NULL)
356  {
357    PRINTF(0)("you tried to add an entity to a mount point that doesn't exist (slot %i)\n", slot);
358    return;
359  }
360
361  // mount the entity
362  this->mountPoints[slot]->mount(entity);
363}
364
365
366/**
367 * removes a mount point from a specified mount point
368 * @param mountPoint entity to be unconnected
369 */
370void WorldEntity::unmount(int slot)
371{
372    if( this->mountPoints[slot] == NULL)
373  {
374    PRINTF(0)("you tried to remove an entity from a mount point that doesn't exist (slot %i)\n", slot);
375    return;
376  }
377
378  // unmount the entity
379  this->mountPoints[slot]->unmount();
380}
381
382
383/**
384 * subscribes this world entity to a collision reaction
385 *  @param type the type of reaction to subscribe to
386 *  @param target1 a filter target (classID)
387 */
388void WorldEntity::subscribeReaction(CoRe::CREngine::ReactionType type, const ClassID& target1)
389{
390  this->_collisionFilter.subscribeReaction(type, target1);
391}
392
393
394/**
395 * subscribes this world entity to a collision reaction
396 *  @param type the type of reaction to subscribe to
397 *  @param target1 a filter target (classID)
398 */
399void WorldEntity::subscribeReaction(CoRe::CREngine::ReactionType type, const ClassID& target1, const ClassID& target2)
400{
401  this->_collisionFilter.subscribeReaction(type, target1, target2);
402}
403
404
405/**
406 * subscribes this world entity to a collision reaction
407 *  @param type the type of reaction to subscribe to
408 *  @param target1 a filter target (classID)
409 */
410void WorldEntity::subscribeReaction(CoRe::CREngine::ReactionType type, const ClassID& target1, const ClassID& target2, const ClassID& target3)
411{
412  this->_collisionFilter.subscribeReaction(type, target1, target2, target3);
413}
414
415
416/**
417 * unsubscribes a specific reaction from the worldentity
418 *  @param type the reaction to unsubscribe
419 */
420void WorldEntity::unsubscribeReaction(CoRe::CREngine::ReactionType type)
421{
422  this->_collisionFilter.unsubscribeReaction(type);
423}
424
425
426/**
427 * unsubscribes all collision reactions
428 */
429void WorldEntity::unsubscribeReactions()
430{
431  this->_collisionFilter.unsubscribeReactions();
432}
433
434
435/**
436 * @brief moves this entity to the List OM_List
437 * @param list the list to set this Entity to.
438 *
439 * this is the same as a call to State::getObjectManager()->toList(entity , list);
440 * directly, but with an easier interface.
441 *
442 * @todo inline this (peut etre)
443 */
444void WorldEntity::toList(OM_LIST list)
445{
446  State::getObjectManager()->toList(this, list);
447}
448
449void WorldEntity::toListS(const std::string& listName)
450{
451  OM_LIST id = ObjectManager::StringToOMList(listName);
452  if (id != OM_NULL)
453    this->toList(id);
454  else
455    PRINTF(2)("List %s not found\n", listName.c_str());
456}
457
458
459void WorldEntity::toReflectionList()
460{
461  State::getObjectManager()->toReflectionList( this );
462}
463
464void removeFromReflectionList()
465{
466  /// TODO
467  ///  State::getObject
468}
469
470/**
471 * sets the character attributes of a worldentity
472 * @param character attributes
473 *
474 * these attributes don't have to be set, only use them, if you need them
475*/
476//void WorldEntity::setCharacterAttributes(CharacterAttributes* charAttr)
477//{}
478
479
480/**
481 *  this function is called, when two entities collide
482 * @param entity: the world entity with whom it collides
483 *
484 * Implement behaviour like damage application or other miscellaneous collision stuff in this function
485 */
486void WorldEntity::collidesWith(WorldEntity* entity, const Vector& location)
487{
488  /**
489   * THIS IS A DEFAULT COLLISION-Effect.
490   * IF YOU WANT TO CREATE A SPECIFIC COLLISION ON EACH OBJECT
491   * USE::
492   * if (entity->isA(CL_WHAT_YOU_ARE_LOOKING_FOR)) { printf "dothings"; };
493   *
494   * You can always define a default Action.... don't be affraid just test it :)
495   */
496  //  PRINTF(3)("collision %s vs %s @ (%f,%f,%f)\n", this->getClassCName(), entity->getClassCName(), location.x, location.y, location.z);
497}
498
499
500/**
501 *  this function is called, when two entities collide
502 * @param entity: the world entity with whom it collides
503 *
504 * Implement behaviour like damage application or other miscellaneous collision stuff in this function
505 */
506void WorldEntity::collidesWithGround(const Vector& location)
507{
508  PRINTF(0)("BSP_GROUND: %s collides \n", this->getClassCName() );
509}
510
511void WorldEntity::collidesWithGround(const Vector& feet, const Vector& ray_1, const Vector& ray_2)
512{
513
514  // PRINTF(0)("BSP_GROUND: Player collides \n", this->getClassCName() );
515
516  Vector v = this->getAbsDirX();
517  v.x *= 10.1;
518  v.y *= 10.1;
519  v.z *= 10.1;
520  Vector u = Vector(0.0,-20.0,0.0);
521
522
523  if(!(this->getAbsCoor().x == ray_2.x && this->getAbsCoor().y == ray_2.y && this->getAbsCoor().z == ray_2.z) )
524  {
525
526    this->setAbsCoor(ray_2 - v);
527
528  }
529  else
530  {
531    if(ray_1.x == this->getAbsCoor().x + v.x && ray_1.y == this->getAbsCoor().y + v.y + 0.1 && ray_1.z ==this->getAbsCoor().z + v.z)
532    {
533      this->setAbsCoor(feet -u );
534    }
535
536    this->setAbsCoor(ray_2 - v);
537
538  }
539
540
541}
542
543/**
544 *  this is called immediately after the Entity has been constructed, initialized and then Spawned into the World
545 *
546 */
547void WorldEntity::postSpawn ()
548{}
549
550
551/**
552 *  this method is called by the world if the WorldEntity leaves the game
553 */
554void WorldEntity::leaveWorld ()
555{}
556
557
558/**
559 * resets the WorldEntity to its initial values. eg. used for multiplayer games: respawning
560 */
561void WorldEntity::reset()
562{
563  this->setHealth( this->getHealthMax() );
564}
565
566/**
567 *  this method is called every frame
568 * @param time: the time in seconds that has passed since the last tick
569 *
570 * Handle all stuff that should update with time inside this method (movement, animation, etc.)
571*/
572void WorldEntity::tick(float time)
573{}
574
575
576/**
577 *  the entity is drawn onto the screen with this function
578 *
579 * This is a central function of an entity: call it to let the entity painted to the screen.
580 * Just override this function with whatever you want to be drawn.
581*/
582void WorldEntity::draw() const
583{
584  //PRINTF(0)("(%s::%s)\n", this->getClassCName(), this->getName());
585  //  assert(!unlikely(this->models.empty()));
586  {
587    glMatrixMode(GL_MODELVIEW);
588    glPushMatrix();
589
590    /* translate */
591    glTranslatef (this->getAbsCoor ().x,
592                  this->getAbsCoor ().y,
593                  this->getAbsCoor ().z);
594    Vector tmpRot = this->getAbsDir().getSpacialAxis();
595    glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
596
597
598    // This Draws the LOD's
599    float cameraDistance = State::getCamera()->distance(this);
600    if (cameraDistance > 30 && this->models.size() >= 3 && this->models[2] != NULL)
601    {
602      this->models[2]->draw();
603    }
604    else if (cameraDistance > 10 && this->models.size() >= 2 && this->models[1] != NULL)
605    {
606      this->models[1]->draw();
607    }
608    else if (this->models.size() >= 1 && this->models[0] != NULL)
609    {
610      this->models[0]->draw();
611    }
612
613    //     if( this->aabbNode != NULL)
614    //       this->aabbNode->drawBV(0, DRAW_BV_POLYGON, Vector(1, 0.6, 0.2), true);
615
616    glPopMatrix();
617  }
618}
619
620/**
621 * @param health the Health to add.
622 * @returns the health left (this->healthMax - health+this->health)
623 */
624float WorldEntity::increaseHealth(float health)
625{
626  this->health += health;
627  if (this->health > this->healthMax)
628  {
629    float retHealth = this->healthMax - this->health;
630    this->health = this->healthMax;
631    this->updateHealthWidget();
632    return retHealth;
633  }
634  this->updateHealthWidget();
635  return 0.0;
636}
637
638/**
639 * @param health the Health to be removed
640 * @returns 0.0 or the rest, that was not substracted (bellow 0.0)
641 */
642float WorldEntity::decreaseHealth(float health)
643{
644  this->health -= health;
645
646  if (this->health < 0)
647  {
648    float retHealth = -this->health;
649    this->health = 0.0f;
650    this->updateHealthWidget();
651    return retHealth;
652  }
653  this->updateHealthWidget();
654  return 0.0;
655
656}
657
658/**
659 * @param maxHealth the maximal health that can be loaded onto the entity.
660 */
661void WorldEntity::setHealthMax(float healthMax)
662{
663  this->healthMax = healthMax;
664  if (this->health > this->healthMax)
665  {
666    PRINTF(3)("new maxHealth is bigger as the old health. Did you really intend to do this for (%s::%s)\n", this->getClassCName(), this->getCName());
667    this->health = this->healthMax;
668  }
669  this->updateHealthWidget();
670}
671
672/**
673 * @brief creates the HealthWidget
674 *
675 * since not all entities need an HealthWidget, it is only created on request.
676 */
677void WorldEntity::createHealthWidget()
678{
679  if (this->healthWidget == NULL)
680  {
681    this->healthWidget = new OrxGui::GLGuiEnergyWidget();
682    this->healthWidget->setDisplayedName(std::string(this->getClassName()) + " Energy:");
683    this->healthWidget->setSize2D(30,400);
684    this->healthWidget->setAbsCoor2D(10,100);
685
686    this->updateHealthWidget();
687  }
688  else
689    PRINTF(3)("Allready created the HealthWidget for %s::%s\n", this->getClassCName(), this->getCName());
690}
691
692void WorldEntity::increaseHealthMax(float increaseHealth)
693{
694  this->healthMax += increaseHealth;
695  this->updateHealthWidget();
696}
697
698
699OrxGui::GLGuiWidget* WorldEntity::getHealthWidget()
700{
701  this->createHealthWidget();
702  return this->healthWidget;
703}
704
705/**
706 * @param visibility shows or hides the health-bar
707 * (creates the widget if needed)
708 */
709void WorldEntity::setHealthWidgetVisibilit(bool visibility)
710{
711  if (visibility)
712  {
713    if (this->healthWidget != NULL)
714      this->healthWidget->show();
715    else
716    {
717      this->createHealthWidget();
718      this->updateHealthWidget();
719      this->healthWidget->show();
720    }
721  }
722  else if (this->healthWidget != NULL)
723    this->healthWidget->hide();
724}
725
726
727/**
728 * hit the world entity with
729 *  @param damage damage to be dealt
730 */
731void WorldEntity::hit(float damage, WorldEntity* killer)
732{
733  this->decreaseHealth(damage);
734
735  PRINTF(5)("Hit me: %s::%s now only %f/%f health\n", this->getClassCName(), this->getCName(), this->getHealth(), this->getHealthMax());
736
737  if( this->getHealth() > 0)
738  {
739    // any small explosion animaitions
740  }
741  else
742  {
743    this->destroy( killer );
744  }
745}
746
747
748/**
749 * destoys the world entity
750 */
751void WorldEntity::destroy(WorldEntity* killer)
752{
753  this->toList(OM_DEAD);
754}
755
756
757/**
758 * @brief updates the HealthWidget
759 */
760void WorldEntity::updateHealthWidget()
761{
762  if (this->healthWidget != NULL)
763  {
764    this->healthWidget->setMaximum(this->healthMax);
765    this->healthWidget->setValue(this->health);
766  }
767}
768
769
770/**
771 * DEBUG-DRAW OF THE BV-Tree.
772 * @param depth What depth to draw
773 * @param drawMode the mode to draw this entity under
774 */
775void WorldEntity::drawBVTree(int depth, int drawMode) const
776{
777  glMatrixMode(GL_MODELVIEW);
778  glPushMatrix();
779  /* translate */
780  glTranslatef (this->getAbsCoor ().x,
781                this->getAbsCoor ().y,
782                this->getAbsCoor ().z);
783  /* rotate */
784  Vector tmpRot = this->getAbsDir().getSpacialAxis();
785  glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
786
787
788  if (this->obbTree)
789    this->obbTree->drawBV(depth, drawMode);
790
791
792  glPopMatrix();
793}
794
795
796/**
797 * Debug the WorldEntity
798 */
799void WorldEntity::debugEntity() const
800{
801  PRINT(0)("WorldEntity %s::%s  (DEBUG)\n", this->getClassCName(), this->getCName());
802  this->debugNode();
803  PRINT(0)("List: %s ; ModelCount %d - ", ObjectManager::OMListToString(this->objectListNumber).c_str(), this->models.size());
804  for (unsigned int i = 0; i < this->models.size(); i++)
805  {
806    if (models[i] != NULL)
807      PRINT(0)(" : %d:%s", i, this->models[i]->getCName());
808  }
809  PRINT(0)("\n");
810
811}
812
813
814/**
815 * handler for changes on registred vars
816 * @param id id's which changed
817 */
818void WorldEntity::varChangeHandler( std::list< int > & id )
819{
820  if ( std::find( id.begin(), id.end(), modelFileName_handle ) != id.end() ||
821       std::find( id.begin(), id.end(), scaling_handle ) != id.end()
822     )
823  {
824    loadModel( modelFileName, scaling );
825  }
826
827  if ( std::find( id.begin(), id.end(), list_handle ) != id.end() )
828  {
829    this->toList( (OM_LIST)list_write );
830  }
831
832  if ( std::find( id.begin(), id.end(), health_handle ) != id.end() )
833  {
834    this->setHealth( health_write );
835  }
836
837  if ( std::find( id.begin(), id.end(), healthMax_handle ) != id.end() )
838  {
839    this->setHealthMax( healthMax_write );
840  }
841
842  PNode::varChangeHandler( id );
843}
844
Note: See TracBrowser for help on using the repository browser.