Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/branches/mount_points/src/world_entities/world_entity.cc @ 10185

Last change on this file since 10185 was 10185, checked in by patrick, 17 years ago

some more properties of the mount point

File size: 22.1 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
207      // check if ther is a valid model and load other stuff
208      if (model->getVertexCount() > 0)
209      {
210        this->setModel(model, modelNumber);
211        if( modelNumber == 0)
212        {
213          this->buildObbTree(obbTreeDepth);
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->loadMountPoints( oifName);
218        }
219      }
220      else
221        delete model;
222    }
223    /// LOADING AN MD2-model
224    else if(fileName.find(".md2") != std::string::npos)
225    {
226      PRINTF(4)("fetching MD2 file: %s\n", fileName.c_str());
227      Model* m = new MD2Model(fileName, this->md2TextureFileName, this->scaling);
228      //this->setModel((Model*)ResourceManager::getInstance()->load(fileName, MD2, RP_CAMPAIGN), 0);
229      this->setModel(m, 0);
230
231      if( m != NULL)
232        this->buildObbTree(obbTreeDepth);
233    }
234    /// LOADING AN MD3-MODEL.
235    else if(fileName.find(".md3") != std::string::npos)
236    {
237      PRINTF(4)("fetching MD3 file: %s\n", fileName.c_str());
238//      Model* m = new md3::MD3Model(fileName, this->scaling);
239//      this->setModel(m, 0);
240
241      //       if( m != NULL)
242      //         this->buildObbTree(obbTreeDepth);
243    }
244  }
245  else
246  {
247    this->setModel(NULL);
248  }
249}
250
251/**
252 * sets a specific Model for the Object.
253 * @param model The Model to set
254 * @param modelNumber the n'th model in the List to get.
255 */
256void WorldEntity::setModel(Model* model, unsigned int modelNumber)
257{
258  if (this->models.size() <= modelNumber)
259    this->models.resize(modelNumber+1, NULL);
260
261  if (this->models[modelNumber] != NULL)
262  {
263    delete this->models[modelNumber];
264  }
265
266  this->models[modelNumber] = model;
267}
268
269
270
271/**
272 * loads the object information file for this model
273 * @param fileName the name of the file
274 */
275void WorldEntity::loadMountPoints(const std::string& fileName)
276{
277  PRINTF(0)("loading the oif File: %s\n", fileName.c_str());
278
279
280  // first get all mount points from the model
281  std::list<mountPointSkeleton> mpList = this->getModel(0)->getMountPoints();
282  // for each skeleton create a mounting point world entity
283  std::list<mountPointSkeleton>::const_iterator it = mpList.begin();
284
285  for( ; it != mpList.end(); it++)
286  {
287    MountPoint* mp = new MountPoint((*it).up, (*it).forward, (*it).center, (*it).name);
288
289    std::string nrStr = (*it).name.substr(1, 2);;
290
291    PRINTF(0)("got mp nr: %s\n", nrStr.c_str());
292
293    this->addMountPoint(mp);
294  }
295
296  // now load the object information file
297  this->oiFile = new ObjectInformationFile(fileName);
298
299
300
301
302}
303
304
305/**
306 * builds the obb-tree
307 * @param depth the depth to calculate
308 */
309bool WorldEntity::buildObbTree(int depth)
310{
311  if( this->obbTree != NULL)
312  {
313    delete this->obbTree;
314    this->obbTree = NULL;
315  }
316
317  if (this->models[0] != NULL)
318    this->obbTree = new OBBTree(depth, models[0]->getModelInfo(), this);
319  else
320  {
321    PRINTF(1)("could not create obb-tree, because no model was loaded yet\n");
322    this->obbTree = NULL;
323    return false;
324  }
325
326
327  // create the axis aligned bounding box
328  if( this->aabbNode != NULL)
329  {
330    delete this->aabbNode;
331    this->aabbNode = NULL;
332  }
333
334  if( this->models[0] != NULL)
335  {
336    this->aabbNode = new AABBTreeNode();
337    this->aabbNode->spawnBVTree(this->models[0]);
338  }
339  else
340  {
341    PRINTF(1)("could not create aabb bounding box, because no model was loaded yet\n");
342    this->aabbNode = NULL;
343    return false;
344  }
345  return true;
346}
347
348
349/**
350 * adds a mount point to the end of the list
351 * @param mountPoint point to be added
352 */
353void WorldEntity::addMountPoint(MountPoint* mountPoint)
354{
355  // add the mount point at the last position
356  this->mountPoints.push_back(mountPoint);
357}
358
359/**
360 * adds a mount point to a world entity
361 * @param mountPoint point to be added
362 */
363void WorldEntity::addMountPoint(int slot, MountPoint* mountPoint)
364{
365  if( this->mountPoints[slot] != NULL)
366  {
367    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());
368  }
369
370  // just connect the mount point
371  this->mountPoints[slot] = mountPoint;
372}
373
374
375/**
376 * mounts a world entity on a specified mount point (~socket)
377 * @param entity entity to be connected
378 */
379void WorldEntity::mount(int slot, WorldEntity* entity)
380{
381  if( this->mountPoints[slot] == NULL)
382  {
383    PRINTF(0)("you tried to add an entity to a mount point that doesn't exist (slot %i)\n", slot);
384    return;
385  }
386
387  // mount the entity
388  this->mountPoints[slot]->mount(entity);
389}
390
391
392/**
393 * removes a mount point from a specified mount point
394 * @param mountPoint entity to be unconnected
395 */
396void WorldEntity::unmount(int slot)
397{
398    if( this->mountPoints[slot] == NULL)
399  {
400    PRINTF(0)("you tried to remove an entity from a mount point that doesn't exist (slot %i)\n", slot);
401    return;
402  }
403
404  // unmount the entity
405  this->mountPoints[slot]->unmount();
406}
407
408
409/**
410 * subscribes this world entity to a collision reaction
411 *  @param type the type of reaction to subscribe to
412 *  @param target1 a filter target (classID)
413 */
414void WorldEntity::subscribeReaction(CoRe::CREngine::ReactionType type, const ClassID& target1)
415{
416  this->_collisionFilter.subscribeReaction(type, target1);
417}
418
419
420/**
421 * subscribes this world entity to a collision reaction
422 *  @param type the type of reaction to subscribe to
423 *  @param target1 a filter target (classID)
424 */
425void WorldEntity::subscribeReaction(CoRe::CREngine::ReactionType type, const ClassID& target1, const ClassID& target2)
426{
427  this->_collisionFilter.subscribeReaction(type, target1, target2);
428}
429
430
431/**
432 * subscribes this world entity to a collision reaction
433 *  @param type the type of reaction to subscribe to
434 *  @param target1 a filter target (classID)
435 */
436void WorldEntity::subscribeReaction(CoRe::CREngine::ReactionType type, const ClassID& target1, const ClassID& target2, const ClassID& target3)
437{
438  this->_collisionFilter.subscribeReaction(type, target1, target2, target3);
439}
440
441
442/**
443 * unsubscribes a specific reaction from the worldentity
444 *  @param type the reaction to unsubscribe
445 */
446void WorldEntity::unsubscribeReaction(CoRe::CREngine::ReactionType type)
447{
448  this->_collisionFilter.unsubscribeReaction(type);
449}
450
451
452/**
453 * unsubscribes all collision reactions
454 */
455void WorldEntity::unsubscribeReactions()
456{
457  this->_collisionFilter.unsubscribeReactions();
458}
459
460
461/**
462 * @brief moves this entity to the List OM_List
463 * @param list the list to set this Entity to.
464 *
465 * this is the same as a call to State::getObjectManager()->toList(entity , list);
466 * directly, but with an easier interface.
467 *
468 * @todo inline this (peut etre)
469 */
470void WorldEntity::toList(OM_LIST list)
471{
472  State::getObjectManager()->toList(this, list);
473}
474
475void WorldEntity::toListS(const std::string& listName)
476{
477  OM_LIST id = ObjectManager::StringToOMList(listName);
478  if (id != OM_NULL)
479    this->toList(id);
480  else
481    PRINTF(2)("List %s not found\n", listName.c_str());
482}
483
484
485void WorldEntity::toReflectionList()
486{
487  State::getObjectManager()->toReflectionList( this );
488}
489
490void removeFromReflectionList()
491{
492  /// TODO
493  ///  State::getObject
494}
495
496/**
497 * sets the character attributes of a worldentity
498 * @param character attributes
499 *
500 * these attributes don't have to be set, only use them, if you need them
501*/
502//void WorldEntity::setCharacterAttributes(CharacterAttributes* charAttr)
503//{}
504
505
506/**
507 *  this function is called, when two entities collide
508 * @param entity: the world entity with whom it collides
509 *
510 * Implement behaviour like damage application or other miscellaneous collision stuff in this function
511 */
512void WorldEntity::collidesWith(WorldEntity* entity, const Vector& location)
513{
514  /**
515   * THIS IS A DEFAULT COLLISION-Effect.
516   * IF YOU WANT TO CREATE A SPECIFIC COLLISION ON EACH OBJECT
517   * USE::
518   * if (entity->isA(CL_WHAT_YOU_ARE_LOOKING_FOR)) { printf "dothings"; };
519   *
520   * You can always define a default Action.... don't be affraid just test it :)
521   */
522  //  PRINTF(3)("collision %s vs %s @ (%f,%f,%f)\n", this->getClassCName(), entity->getClassCName(), location.x, location.y, location.z);
523}
524
525
526/**
527 *  this function is called, when two entities collide
528 * @param entity: the world entity with whom it collides
529 *
530 * Implement behaviour like damage application or other miscellaneous collision stuff in this function
531 */
532void WorldEntity::collidesWithGround(const Vector& location)
533{
534  PRINTF(0)("BSP_GROUND: %s collides \n", this->getClassCName() );
535}
536
537void WorldEntity::collidesWithGround(const Vector& feet, const Vector& ray_1, const Vector& ray_2)
538{
539
540  // PRINTF(0)("BSP_GROUND: Player collides \n", this->getClassCName() );
541
542  Vector v = this->getAbsDirX();
543  v.x *= 10.1;
544  v.y *= 10.1;
545  v.z *= 10.1;
546  Vector u = Vector(0.0,-20.0,0.0);
547
548
549  if(!(this->getAbsCoor().x == ray_2.x && this->getAbsCoor().y == ray_2.y && this->getAbsCoor().z == ray_2.z) )
550  {
551
552    this->setAbsCoor(ray_2 - v);
553
554  }
555  else
556  {
557    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)
558    {
559      this->setAbsCoor(feet -u );
560    }
561
562    this->setAbsCoor(ray_2 - v);
563
564  }
565
566
567}
568
569/**
570 *  this is called immediately after the Entity has been constructed, initialized and then Spawned into the World
571 *
572 */
573void WorldEntity::postSpawn ()
574{}
575
576
577/**
578 *  this method is called by the world if the WorldEntity leaves the game
579 */
580void WorldEntity::leaveWorld ()
581{}
582
583
584/**
585 * resets the WorldEntity to its initial values. eg. used for multiplayer games: respawning
586 */
587void WorldEntity::reset()
588{
589  this->setHealth( this->getHealthMax() );
590}
591
592/**
593 *  this method is called every frame
594 * @param time: the time in seconds that has passed since the last tick
595 *
596 * Handle all stuff that should update with time inside this method (movement, animation, etc.)
597*/
598void WorldEntity::tick(float time)
599{}
600
601
602/**
603 *  the entity is drawn onto the screen with this function
604 *
605 * This is a central function of an entity: call it to let the entity painted to the screen.
606 * Just override this function with whatever you want to be drawn.
607*/
608void WorldEntity::draw() const
609{
610  //PRINTF(0)("(%s::%s)\n", this->getClassCName(), this->getName());
611  //  assert(!unlikely(this->models.empty()));
612  {
613    glMatrixMode(GL_MODELVIEW);
614    glPushMatrix();
615
616    /* translate */
617    glTranslatef (this->getAbsCoor ().x,
618                  this->getAbsCoor ().y,
619                  this->getAbsCoor ().z);
620    Vector tmpRot = this->getAbsDir().getSpacialAxis();
621    glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
622
623
624    // This Draws the LOD's
625    float cameraDistance = State::getCamera()->distance(this);
626    if (cameraDistance > 30 && this->models.size() >= 3 && this->models[2] != NULL)
627    {
628      this->models[2]->draw();
629    }
630    else if (cameraDistance > 10 && this->models.size() >= 2 && this->models[1] != NULL)
631    {
632      this->models[1]->draw();
633    }
634    else if (this->models.size() >= 1 && this->models[0] != NULL)
635    {
636      this->models[0]->draw();
637    }
638
639    //     if( this->aabbNode != NULL)
640    //       this->aabbNode->drawBV(0, DRAW_BV_POLYGON, Vector(1, 0.6, 0.2), true);
641
642    glPopMatrix();
643  }
644}
645
646/**
647 * @param health the Health to add.
648 * @returns the health left (this->healthMax - health+this->health)
649 */
650float WorldEntity::increaseHealth(float health)
651{
652  this->health += health;
653  if (this->health > this->healthMax)
654  {
655    float retHealth = this->healthMax - this->health;
656    this->health = this->healthMax;
657    this->updateHealthWidget();
658    return retHealth;
659  }
660  this->updateHealthWidget();
661  return 0.0;
662}
663
664/**
665 * @param health the Health to be removed
666 * @returns 0.0 or the rest, that was not substracted (bellow 0.0)
667 */
668float WorldEntity::decreaseHealth(float health)
669{
670  this->health -= health;
671
672  if (this->health < 0)
673  {
674    float retHealth = -this->health;
675    this->health = 0.0f;
676    this->updateHealthWidget();
677    return retHealth;
678  }
679  this->updateHealthWidget();
680  return 0.0;
681
682}
683
684/**
685 * @param maxHealth the maximal health that can be loaded onto the entity.
686 */
687void WorldEntity::setHealthMax(float healthMax)
688{
689  this->healthMax = healthMax;
690  if (this->health > this->healthMax)
691  {
692    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());
693    this->health = this->healthMax;
694  }
695  this->updateHealthWidget();
696}
697
698/**
699 * @brief creates the HealthWidget
700 *
701 * since not all entities need an HealthWidget, it is only created on request.
702 */
703void WorldEntity::createHealthWidget()
704{
705  if (this->healthWidget == NULL)
706  {
707    this->healthWidget = new OrxGui::GLGuiEnergyWidget();
708    this->healthWidget->setDisplayedName(std::string(this->getClassName()) + " Energy:");
709    this->healthWidget->setSize2D(30,400);
710    this->healthWidget->setAbsCoor2D(10,100);
711
712    this->updateHealthWidget();
713  }
714  else
715    PRINTF(3)("Allready created the HealthWidget for %s::%s\n", this->getClassCName(), this->getCName());
716}
717
718void WorldEntity::increaseHealthMax(float increaseHealth)
719{
720  this->healthMax += increaseHealth;
721  this->updateHealthWidget();
722}
723
724
725OrxGui::GLGuiWidget* WorldEntity::getHealthWidget()
726{
727  this->createHealthWidget();
728  return this->healthWidget;
729}
730
731/**
732 * @param visibility shows or hides the health-bar
733 * (creates the widget if needed)
734 */
735void WorldEntity::setHealthWidgetVisibilit(bool visibility)
736{
737  if (visibility)
738  {
739    if (this->healthWidget != NULL)
740      this->healthWidget->show();
741    else
742    {
743      this->createHealthWidget();
744      this->updateHealthWidget();
745      this->healthWidget->show();
746    }
747  }
748  else if (this->healthWidget != NULL)
749    this->healthWidget->hide();
750}
751
752
753/**
754 * hit the world entity with
755 *  @param damage damage to be dealt
756 */
757void WorldEntity::hit(float damage, WorldEntity* killer)
758{
759  this->decreaseHealth(damage);
760
761  PRINTF(5)("Hit me: %s::%s now only %f/%f health\n", this->getClassCName(), this->getCName(), this->getHealth(), this->getHealthMax());
762
763  if( this->getHealth() > 0)
764  {
765    // any small explosion animaitions
766  }
767  else
768  {
769    this->destroy( killer );
770  }
771}
772
773
774/**
775 * destoys the world entity
776 */
777void WorldEntity::destroy(WorldEntity* killer)
778{
779  this->toList(OM_DEAD);
780}
781
782
783/**
784 * @brief updates the HealthWidget
785 */
786void WorldEntity::updateHealthWidget()
787{
788  if (this->healthWidget != NULL)
789  {
790    this->healthWidget->setMaximum(this->healthMax);
791    this->healthWidget->setValue(this->health);
792  }
793}
794
795
796/**
797 * DEBUG-DRAW OF THE BV-Tree.
798 * @param depth What depth to draw
799 * @param drawMode the mode to draw this entity under
800 */
801void WorldEntity::drawBVTree(int depth, int drawMode) const
802{
803  glMatrixMode(GL_MODELVIEW);
804  glPushMatrix();
805  /* translate */
806  glTranslatef (this->getAbsCoor ().x,
807                this->getAbsCoor ().y,
808                this->getAbsCoor ().z);
809  /* rotate */
810  Vector tmpRot = this->getAbsDir().getSpacialAxis();
811  glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
812
813
814  if (this->obbTree)
815    this->obbTree->drawBV(depth, drawMode);
816
817
818  glPopMatrix();
819}
820
821
822/**
823 * Debug the WorldEntity
824 */
825void WorldEntity::debugEntity() const
826{
827  PRINT(0)("WorldEntity %s::%s  (DEBUG)\n", this->getClassCName(), this->getCName());
828  this->debugNode();
829  PRINT(0)("List: %s ; ModelCount %d - ", ObjectManager::OMListToString(this->objectListNumber).c_str(), this->models.size());
830  for (unsigned int i = 0; i < this->models.size(); i++)
831  {
832    if (models[i] != NULL)
833      PRINT(0)(" : %d:%s", i, this->models[i]->getCName());
834  }
835  PRINT(0)("\n");
836
837}
838
839
840/**
841 * handler for changes on registred vars
842 * @param id id's which changed
843 */
844void WorldEntity::varChangeHandler( std::list< int > & id )
845{
846  if ( std::find( id.begin(), id.end(), modelFileName_handle ) != id.end() ||
847       std::find( id.begin(), id.end(), scaling_handle ) != id.end()
848     )
849  {
850    loadModel( modelFileName, scaling );
851  }
852
853  if ( std::find( id.begin(), id.end(), list_handle ) != id.end() )
854  {
855    this->toList( (OM_LIST)list_write );
856  }
857
858  if ( std::find( id.begin(), id.end(), health_handle ) != id.end() )
859  {
860    this->setHealth( health_write );
861  }
862
863  if ( std::find( id.begin(), id.end(), healthMax_handle ) != id.end() )
864  {
865    this->setHealthMax( healthMax_write );
866  }
867
868  PNode::varChangeHandler( id );
869}
870
Note: See TracBrowser for help on using the repository browser.