Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

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

extended model again, added mounting point generation procedures now working on a nicer interface

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