Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/branches/network/src/lib/coord/p_node.cc @ 6324

Last change on this file since 6324 was 6142, checked in by bensch, 19 years ago

orxonox/trunk: merge the ObjectManager to the trunk
merged with command:
svn merge -r6082:HEAD objectmanager/ ../trunk/

conflicts resolution was easy this time :)
but specially merged the world to network_world

File size: 28.5 KB
Line 
1/*
2   orxonox - the future of 3D-vertical-scrollers
3
4   Copyright (C) 2004 orx
5
6   This program is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation; either version 2, or (at your option)
9   any later version.
10
11   ### File Specific:
12   main-programmer: Patrick Boenzli
13   co-programmer: Benjamin Grauer
14*/
15
16#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_PNODE
17
18#include "p_node.h"
19
20#include "load_param.h"
21#include "class_list.h"
22
23#include <algorithm>
24#include "compiler.h"
25#include "debug.h"
26
27#include "glincl.h"
28#include "color.h"
29
30using namespace std;
31
32
33/**
34 * @brief standard constructor
35 * @param parent the Parent of this Node. __NULL__ if __No Parent__ requested, PNode::getNullParent(), if connected to NullParent directly (default)
36 * @param nodeFlags all flags to set. THIS_WILL_OVERWRITE Default_Values. look at creation of NullParent for more Info.
37 */
38PNode::PNode (PNode* parent, long nodeFlags)
39{
40  this->setClassID(CL_PARENT_NODE, "PNode");
41
42  this->bRelCoorChanged = true;
43  this->bRelDirChanged = true;
44  this->parent = NULL;
45  this->parentMode = nodeFlags;
46  this->bActive = true;
47
48  // smooth-movers
49  this->toCoordinate = NULL;
50  this->toDirection = NULL;
51  this->bias = 1.0;
52
53  if (parent != NULL)
54    parent->addChild(this);
55}
56
57// NullParent Reference
58PNode* PNode::nullParent = NULL;
59
60/**
61 * @brief standard deconstructor
62 *
63 * There are two general ways to delete a PNode
64 * 1. delete instance;
65 *   -> result
66 *    delete this Node and all its children and children's children...
67 *    (danger if you still need the children's instance somewhere else!!)
68 *
69 * 2. instance->removeNode(); delete instance;
70 *   -> result:
71 *    moves its children to the NullParent
72 *    then deletes the Element.
73 */
74PNode::~PNode ()
75{
76  // remove the Node, delete it's children (if required).
77  std::list<PNode*>::iterator tmp = this->children.begin();
78  std::list<PNode*>::iterator deleteNode;
79  while(!this->children.empty())
80    while (tmp != this->children.end())
81    {
82      deleteNode = tmp;
83      tmp++;
84//      printf("TEST::%s(%s) %s\n", (*deleteNode)->getName(), (*deleteNode)->getClassName(), this->getName());
85      if ((this->parentMode & PNODE_PROHIBIT_CHILD_DELETE) ||
86          ((*deleteNode)->parentMode & PNODE_PROHIBIT_DELETE_WITH_PARENT))
87      {
88        if (this == PNode::nullParent && (*deleteNode)->parentMode & PNODE_REPARENT_TO_NULL)
89          delete (*deleteNode);
90        else
91          (*deleteNode)->reparent();
92      }
93      else
94        delete (*deleteNode);
95    }
96
97  if (this->parent != NULL)
98   {
99     this->parent->eraseChild(this);
100     this->parent = NULL;
101   }
102
103  // remove all other allocated memory.
104  if (this->toCoordinate != NULL)
105    delete this->toCoordinate;
106  if (this->toDirection != NULL)
107    delete this->toDirection;
108
109  if (this == PNode::nullParent)
110    PNode::nullParent = NULL;
111}
112
113
114/**
115 * @brief loads parameters of the PNode
116 * @param root the XML-element to load the properties of
117 */
118void PNode::loadParams(const TiXmlElement* root)
119{
120  static_cast<BaseObject*>(this)->loadParams(root);
121
122  LoadParam(root, "rel-coor", this, PNode, setRelCoor)
123      .describe("Sets The relative position of the Node to its parent.");
124
125  LoadParam(root, "abs-coor", this, PNode, setAbsCoor)
126      .describe("Sets The absolute Position of the Node.");
127
128  LoadParam(root, "rel-dir", this, PNode, setRelDir)
129      .describe("Sets The relative rotation of the Node to its parent.");
130
131  LoadParam(root, "abs-dir", this, PNode, setAbsDir)
132      .describe("Sets The absolute rotation of the Node.");
133
134  LoadParam(root, "parent", this, PNode, setParent)
135      .describe("the Name of the Parent of this PNode");
136
137  LoadParam(root, "parent-mode", this, PNode, setParentMode)
138      .describe("the mode to connect this node to its parent ()");
139
140  // cycling properties
141  if (root != NULL)
142  {
143    LOAD_PARAM_START_CYCLE(root, element);
144    {
145      LoadParam_CYCLE(element, "child", this, PNode, addChild)
146          .describe("adds a new Child to the current Node.");
147
148    }
149    LOAD_PARAM_END_CYCLE(element);
150  }
151}
152
153/**
154 * @brief set relative coordinates
155 * @param relCoord relative coordinates to its parent
156 *
157 *
158 * it is very importand, that you use this function, if you want to update the
159 * relCoordinates. If you don't use this, the PNode won't recognize, that something
160 * has changed and won't update the children Nodes.
161 */
162void PNode::setRelCoor (const Vector& relCoord)
163{
164  if (this->toCoordinate!= NULL)
165  {
166    delete this->toCoordinate;
167    this->toCoordinate = NULL;
168  }
169
170  this->relCoordinate = relCoord;
171  this->bRelCoorChanged = true;
172}
173
174/**
175 * @brief set relative coordinates
176 * @param x x-relative coordinates to its parent
177 * @param y y-relative coordinates to its parent
178 * @param z z-relative coordinates to its parent
179 * @see  void PNode::setRelCoor (const Vector& relCoord)
180 */
181void PNode::setRelCoor (float x, float y, float z)
182{
183  this->setRelCoor(Vector(x, y, z));
184}
185
186/**
187 * @brief sets a new relative position smoothely
188 * @param relCoordSoft the new Position to iterate to
189 * @param bias how fast to iterate to this position
190 */
191void PNode::setRelCoorSoft(const Vector& relCoordSoft, float bias)
192{
193  if (likely(this->toCoordinate == NULL))
194    this->toCoordinate = new Vector();
195
196  *this->toCoordinate = relCoordSoft;
197  this->bias = bias;
198}
199
200
201/**
202 * @brief set relative coordinates smoothely
203 * @param x x-relative coordinates to its parent
204 * @param y y-relative coordinates to its parent
205 * @param z z-relative coordinates to its parent
206 * @see  void PNode::setRelCoorSoft (const Vector&, float)
207 */
208void PNode::setRelCoorSoft (float x, float y, float z, float bias)
209{
210  this->setRelCoorSoft(Vector(x, y, z), bias);
211}
212
213
214/**
215 * @param absCoord set absolute coordinate
216 */
217void PNode::setAbsCoor (const Vector& absCoord)
218{
219  if (this->toCoordinate!= NULL)
220  {
221    delete this->toCoordinate;
222    this->toCoordinate = NULL;
223  }
224
225  if( likely(this->parentMode & PNODE_MOVEMENT))
226  {
227      /* if you have set the absolute coordinates this overrides all other changes */
228    if (likely(this->parent != NULL))
229      this->relCoordinate = absCoord - parent->getAbsCoor ();
230    else
231      this->relCoordinate = absCoord;
232  }
233  if( this->parentMode & PNODE_ROTATE_MOVEMENT)
234  {
235    if (likely(this->parent != NULL))
236      this->relCoordinate = absCoord - parent->getAbsCoor ();
237    else
238      this->relCoordinate = absCoord;
239  }
240
241  this->bRelCoorChanged = true;
242//  this->absCoordinate = absCoord;
243}
244
245
246/**
247 * @param x x-coordinate.
248 * @param y y-coordinate.
249 * @param z z-coordinate.
250 * @see void PNode::setAbsCoor (const Vector& absCoord)
251 */
252void PNode::setAbsCoor(float x, float y, float z)
253{
254  this->setAbsCoor(Vector(x, y, z));
255}
256
257
258/**
259 * @param absCoord set absolute coordinate
260 * @todo check off
261 */
262void PNode::setAbsCoorSoft (const Vector& absCoordSoft, float bias)
263{
264  if (this->toCoordinate == NULL)
265    this->toCoordinate = new Vector;
266
267  if( likely(this->parentMode & PNODE_MOVEMENT))
268  {
269      /* if you have set the absolute coordinates this overrides all other changes */
270    if (likely(this->parent != NULL))
271      *this->toCoordinate = absCoordSoft - parent->getAbsCoor ();
272    else
273      *this->toCoordinate = absCoordSoft;
274  }
275  if( this->parentMode & PNODE_ROTATE_MOVEMENT)
276  {
277    if (likely(this->parent != NULL))
278      *this->toCoordinate = absCoordSoft - parent->getAbsCoor ();
279    else
280      *this->toCoordinate = absCoordSoft;
281  }
282}
283
284
285/**
286 * @brief shift coordinate relative
287 * @param shift shift vector
288 *
289 * this function shifts the current coordinates about the vector shift. this is
290 * usefull because from some place else you can:
291 * PNode* someNode = ...;
292 * Vector objectMovement = calculateShift();
293 * someNode->shiftCoor(objectMovement);
294 *
295 * this is the internal method of:
296 * PNode* someNode = ...;
297 * Vector objectMovement = calculateShift();
298 * Vector currentCoor = someNode->getRelCoor();
299 * Vector newCoor = currentCoor + objectMovement;
300 * someNode->setRelCoor(newCoor);
301 *
302 */
303void PNode::shiftCoor (const Vector& shift)
304{
305  this->relCoordinate += shift;
306  this->bRelCoorChanged = true;
307}
308
309
310/**
311 * @brief set relative direction
312 * @param relDir to its parent
313 */
314void PNode::setRelDir (const Quaternion& relDir)
315{
316  if (this->toDirection!= NULL)
317  {
318    delete this->toDirection;
319    this->toDirection = NULL;
320  }
321  this->relDirection = relDir;
322
323  this->bRelCoorChanged = true;
324}
325
326
327/**
328 * @see void PNode::setRelDir (const Quaternion& relDir)
329 * @param x the x direction
330 * @param y the y direction
331 * @param z the z direction
332 *
333 * main difference is, that here you give a directional vector, that will be translated into a Quaternion
334 */
335void PNode::setRelDir (float x, float y, float z)
336{
337  this->setRelDir(Quaternion(Vector(x,y,z), Vector(0,1,0)));
338}
339
340
341/**
342 * @brief sets the Relative Direction of this node to its parent in a Smoothed way
343 * @param relDirSoft the direction to iterate to smoothely.
344 * @param bias how fast to iterate to the new Direction
345 */
346void PNode::setRelDirSoft(const Quaternion& relDirSoft, float bias)
347{
348  if (likely(this->toDirection == NULL))
349    this->toDirection = new Quaternion();
350
351  *this->toDirection = relDirSoft;
352  this->bias = bias;
353  this->bRelDirChanged = true;
354}
355
356
357/**
358 * @see void PNode::setRelDirSoft (const Quaternion& relDir)
359 * @param x the x direction
360 * @param y the y direction
361 * @param z the z direction
362 *
363 * main difference is, that here you give a directional vector, that will be translated into a Quaternion
364 */
365void PNode::setRelDirSoft(float x, float y, float z, float bias)
366{
367  this->setRelDirSoft(Quaternion(Vector(x,y,z), Vector(0,1,0)), bias);
368}
369
370
371/**
372 * @brief sets the absolute direction
373 * @param absDir absolute coordinates
374 */
375void PNode::setAbsDir (const Quaternion& absDir)
376{
377  if (this->toDirection!= NULL)
378  {
379    delete this->toDirection;
380    this->toDirection = NULL;
381  }
382
383  if (likely(this->parent != NULL))
384    this->relDirection = absDir / this->parent->getAbsDir();
385  else
386   this->relDirection = absDir;
387
388  this->bRelDirChanged = true;
389}
390
391
392/**
393 * @see void PNode::setAbsDir (const Quaternion& relDir)
394 * @param x the x direction
395 * @param y the y direction
396 * @param z the z direction
397 *
398 * main difference is, that here you give a directional vector, that will be translated into a Quaternion
399 */
400void PNode::setAbsDir (float x, float y, float z)
401{
402  this->setAbsDir(Quaternion(Vector(x,y,z), Vector(0,1,0)));
403}
404
405
406/**
407 * @brief sets the absolute direction
408 * @param absDir absolute coordinates
409 * @param bias how fast to iterator to the new Position
410 */
411void PNode::setAbsDirSoft (const Quaternion& absDirSoft, float bias)
412{
413  if (this->toDirection == NULL)
414    this->toDirection = new Quaternion();
415
416  if (likely(this->parent != NULL))
417    *this->toDirection = absDirSoft / this->parent->getAbsDir();
418  else
419   *this->toDirection = absDirSoft;
420
421  this->bias = bias;
422  this->bRelDirChanged = true;
423}
424
425
426/**
427 * @see void PNode::setAbsDir (const Quaternion& relDir)
428 * @param x the x direction
429 * @param y the y direction
430 * @param z the z direction
431 *
432 * main difference is, that here you give a directional vector, that will be translated into a Quaternion
433 */
434void PNode::setAbsDirSoft (float x, float y, float z, float bias)
435{
436  this->setAbsDirSoft(Quaternion(Vector(x,y,z), Vector(0,1,0)), bias);
437}
438
439
440/**
441 * @brief shift Direction
442 * @param shift the direction around which to shift.
443 */
444void PNode::shiftDir (const Quaternion& shift)
445{
446  this->relDirection = this->relDirection * shift;
447  this->bRelDirChanged = true;
448}
449
450
451/**
452 * @brief adds a child and makes this node to a parent
453 * @param child child reference
454 * use this to add a child to this node.
455 */
456void PNode::addChild (PNode* child)
457{
458  if( likely(child->parent != NULL))
459      child->parent->eraseChild(child);
460  if (this->checkIntegrity(child))
461  {
462    child->parent = this;
463    if (unlikely(this != NULL))
464      this->children.push_back(child);
465    child->parentCoorChanged();
466  }
467  else
468  {
469    PRINTF(1)("Tried to reparent to own child '%s::%s' to '%s::%s'.\n",
470              this->getClassName(), this->getName(), child->getClassName(), child->getName());
471    child->parent = NULL;
472    child->parentCoorChanged();
473  }
474}
475
476
477/**
478 * @see PNode::addChild(PNode* child);
479 * @param childName the name of the child to add to this PNode
480 */
481void PNode::addChild (const char* childName)
482{
483  PNode* childNode = dynamic_cast<PNode*>(ClassList::getObject(childName, CL_PARENT_NODE));
484  if (childNode != NULL)
485    this->addChild(childNode);
486}
487
488
489/**
490 * @brief removes a child from the node
491 * @param child the child to remove from this pNode.
492 *
493 * Children from pNode will not be lost, they are Reparented by the rules of the ParentMode
494 */
495void PNode::removeChild (PNode* child)
496{
497  if (child != NULL)
498   child->removeNode();
499}
500
501
502/**
503 * !! PRIVATE FUNCTION
504 * @brief reparents a node (happens on Parents Node delete or remove if Flags are set.)
505 */
506void PNode::reparent()
507{
508  if (this->parentMode & PNODE_REPARENT_TO_NULL)
509    this->setParent((PNode*)NULL);
510  else if (this->parentMode & PNODE_REPARENT_TO_PARENTS_PARENT && this->parent != NULL)
511    this->setParent(this->parent->getParent());
512  else
513    this->setParent(PNode::getNullParent());
514}
515
516void PNode::eraseChild(PNode* child)
517{
518  std::list<PNode*>::iterator childRemover = std::find(this->children.begin(), this->children.end(), child);
519  if(childRemover != this->children.end())
520    this->children.erase(childRemover);
521}
522
523
524/**
525 * @brief remove this pnode from the tree and adds all following to NullParent
526 *
527 * this can be the case, if an entity in the world is being destroyed.
528 */
529void PNode::removeNode()
530{
531  list<PNode*>::iterator child = this->children.begin();
532  list<PNode*>::iterator reparenter;
533  while (child != this->children.end())
534  {
535    reparenter = child;
536    child++;
537    if (this->parentMode & PNODE_REPARENT_CHILDREN_ON_REMOVE ||
538        (*reparenter)->parentMode & PNODE_REPARENT_ON_PARENTS_REMOVE)
539    {
540      printf("TEST----------------%s ---- %s\n", this->getClassName(), (*reparenter)->getClassName());
541      (*reparenter)->reparent();
542      printf("REPARENTED TO: %s::%s\n",(*reparenter)->getParent()->getClassName(),(*reparenter)->getParent()->getName());
543    }
544  }
545  if (this->parent != NULL)
546  {
547    this->parent->eraseChild(this);
548    this->parent = NULL;
549  }
550}
551
552
553/**
554 * @see PNode::setParent(PNode* parent);
555 * @param parentName the name of the Parent to set to this PNode
556 */
557void PNode::setParent (const char* parentName)
558{
559  PNode* parentNode = dynamic_cast<PNode*>(ClassList::getObject(parentName, CL_PARENT_NODE));
560  if (parentNode != NULL)
561    parentNode->addChild(this);
562  else
563    PRINTF(2)("Not Found PNode's (%s::%s) new Parent by Name: %s\n",
564              this->getClassName(), this->getName(), parentName);
565}
566
567
568/**
569 * @brief does the reparenting in a very smooth way
570 * @param parentNode the new Node to connect this node to.
571 * @param bias the speed to iterate to this new Positions
572 */
573void PNode::setParentSoft(PNode* parentNode, float bias)
574{
575  // return if the new parent and the old one match
576  if (this->parent == parentNode )
577    return;
578  if (parentNode == NULL)
579    parentNode = PNode::getNullParent();
580
581  // store the Valures to iterate to.
582  if (likely(this->toCoordinate == NULL))
583  {
584    this->toCoordinate = new Vector();
585    *this->toCoordinate = this->getRelCoor();
586  }
587  if (likely(this->toDirection == NULL))
588  {
589    this->toDirection = new Quaternion();
590    *this->toDirection = this->getRelDir();
591  }
592  this->bias = bias;
593
594
595  Vector tmpV = this->getAbsCoor();
596  Quaternion tmpQ = this->getAbsDir();
597
598  parentNode->addChild(this);
599
600 if (this->parentMode & PNODE_ROTATE_MOVEMENT && this->parent != NULL)
601   this->relCoordinate = this->parent->getAbsDir().inverse().apply(tmpV - this->parent->getAbsCoor());
602 else
603   this->relCoordinate = tmpV - parentNode->getAbsCoor();
604
605 this->relDirection = tmpQ / parentNode->getAbsDir();
606}
607
608
609/**
610 * @brief does the reparenting in a very smooth way
611 * @param parentName the name of the Parent to reconnect to
612 * @param bias the speed to iterate to this new Positions
613 */
614void PNode::setParentSoft(const char* parentName, float bias)
615{
616  PNode* parentNode = dynamic_cast<PNode*>(ClassList::getObject(parentName, CL_PARENT_NODE));
617  if (parentNode != NULL)
618    this->setParentSoft(parentNode, bias);
619}
620
621/**
622 * @param parentMode sets the parentingMode of this Node
623 */
624void PNode::setParentMode(PARENT_MODE parentMode)
625{
626  this->parentMode &= (0xfff0 | parentMode);
627}
628
629/**
630 * @brief sets the mode of this parent manually
631 * @param parentMode a String representing this parentingMode
632 */
633void PNode::setParentMode (const char* parentingMode)
634{
635  this->setParentMode(PNode::charToParentingMode(parentingMode));
636}
637
638/**
639 * @brief adds special mode Flags to this PNode
640 * @see PARENT_MODE
641 * @param nodeFlags a compsition of PARENT_MODE-flags, split by the '|' (or) operator.
642 */
643void PNode::addNodeFlags(unsigned short nodeFlags)
644{
645  this->parentMode |= nodeFlags;
646}
647
648/**
649 * @brief removes special mode Flags to this PNode
650 * @see PARENT_MODE
651 * @param nodeFlags a compsition of PARENT_MODE-flags, split by the '|' (or) operator.
652 */
653void PNode::removeNodeFlags(unsigned short nodeFlags)
654{
655  this->parentMode &= !nodeFlags;
656}
657
658/**
659 * @returns the NullParent (and if needed creates it)
660 */
661PNode* PNode::createNullParent()
662{
663  if (likely(PNode::nullParent == NULL))
664  {
665    PNode::nullParent = new PNode(NULL, PNODE_PARENT_MODE_DEFAULT | PNODE_REPARENT_TO_NULL);
666    PNode::nullParent->setName("NullParent");
667  }
668  return PNode::nullParent;
669}
670
671
672/**
673 * !! PRIVATE FUNCTION
674 * @brief checks the upward integrity (e.g if PNode is somewhere up the Node tree.)
675 * @param checkParent the Parent to check.
676 * @returns true if the integrity-check succeeds, false otherwise.
677 *
678 * If there is a second occurence of checkParent before NULL, then a loop could get
679 * into the Tree, and we do not want this.
680 */
681bool PNode::checkIntegrity(const PNode* checkParent) const
682{
683  const PNode* parent = this;
684  while ( (parent = parent->getParent()) != NULL)
685    if (unlikely(parent == checkParent))
686      return false;
687  return true;
688}
689
690
691/**
692 * @brief updates the absCoordinate/absDirection
693 * @param dt The time passed since the last update
694 *
695 * this is used to go through the parent-tree to update all the absolute coordinates
696 * and directions. this update should be done by the engine, so you don't have to
697 * worry, normaly...
698 */
699void PNode::updateNode (float dt)
700{
701  if (!(this->parentMode & PNODE_STATIC_NODE))
702  {
703    if( likely(this->parent != NULL))
704    {
705        // movement for nodes with smoothMove enabled
706        if (unlikely(this->toCoordinate != NULL))
707        {
708          Vector moveVect = (*this->toCoordinate - this->relCoordinate) *fabsf(dt)*bias;
709          if (likely(moveVect.len() >= PNODE_ITERATION_DELTA))
710          {
711            this->shiftCoor(moveVect);
712          }
713          else
714          {
715            delete this->toCoordinate;
716            this->toCoordinate = NULL;
717            PRINTF(5)("SmoothMove of %s finished\n", this->getName());
718          }
719        }
720        if (unlikely(this->toDirection != NULL))
721        {
722          Quaternion rotQuat = Quaternion::quatSlerp(this->relDirection,*this->toDirection, fabsf(dt)*this->bias);
723          if (this->relDirection.distance(rotQuat) >PNODE_ITERATION_DELTA)
724          {
725            this->relDirection = rotQuat;
726            this->bRelDirChanged;
727          }
728          else
729          {
730            delete this->toDirection;
731            this->toDirection = NULL;
732            PRINTF(5)("SmoothRotate of %s finished\n", this->getName());
733          }
734        }
735
736        // MAIN UPDATE /////////////////////////////////////
737        this->lastAbsCoordinate = this->absCoordinate;
738
739        PRINTF(5)("PNode::update - '%s::%s' - (%f, %f, %f)\n", this->getClassName(), this->getName(),
740                      this->absCoordinate.x, this->absCoordinate.y, this->absCoordinate.z);
741
742
743        if( this->parentMode & PNODE_LOCAL_ROTATE && this->bRelDirChanged)
744        {
745          /* update the current absDirection - remember * means rotation around sth.*/
746          this->prevRelCoordinate = this->relCoordinate;
747          this->absDirection = this->relDirection * parent->getAbsDir();;
748        }
749
750        if(likely(this->parentMode & PNODE_MOVEMENT && this->bRelCoorChanged))
751        {
752        /* update the current absCoordinate */
753        this->prevRelCoordinate = this->relCoordinate;
754        this->absCoordinate = this->parent->getAbsCoor() + this->relCoordinate;
755        }
756        else if( this->parentMode & PNODE_ROTATE_MOVEMENT && this->bRelCoorChanged)
757        {
758          /* update the current absCoordinate */
759        this->prevRelCoordinate = this->relCoordinate;
760        this->absCoordinate = this->parent->getAbsCoor() + parent->getAbsDir().apply(this->relCoordinate);
761        }
762        /////////////////////////////////////////////////
763      }
764
765  else // Nodes without a Parent are handled faster :: MOST LIKELY THE NULLPARENT
766    {
767      PRINTF(4)("update ParentLess Node (%s::%s) - (%f, %f, %f)\n", this->getClassName(), this->getName(),
768                this->absCoordinate.x, this->absCoordinate.y, this->absCoordinate.z);
769        if (this->bRelCoorChanged)
770        {
771          this->prevRelCoordinate = this->relCoordinate;
772          this->absCoordinate = this->relCoordinate;
773        }
774        if (this->bRelDirChanged)
775        {
776          this->prevRelDirection = this->relDirection;
777          this->absDirection = this->getAbsDir () * this->relDirection;
778        }
779      }
780    }
781
782    if(!this->children.empty() && (this->bActive || this->parentMode & PNODE_UPDATE_CHILDREN_IF_INACTIVE ))
783    {
784      list<PNode*>::iterator child;
785      for (child = this->children.begin(); child != this->children.end(); child ++)
786      {
787        /* if this node has changed, make sure, that all children are updated also */
788        if( likely(this->bRelCoorChanged))
789          (*child)->parentCoorChanged ();
790        if( likely(this->bRelDirChanged))
791          (*child)->parentDirChanged ();
792
793        (*child)->updateNode(dt);
794      }
795    }
796    this->velocity = (this->absCoordinate - this->lastAbsCoordinate) / dt;
797    this->bRelCoorChanged = false;
798    this->bRelDirChanged = false;
799}
800
801
802
803
804
805/*************
806 * DEBUGGING *
807 *************/
808/**
809 * @brief counts total amount the children walking through the entire tree.
810 * @param nodes the counter
811 */
812void PNode::countChildNodes(int& nodes) const
813{
814  nodes++;
815  list<PNode*>::const_iterator child;
816  for (child = this->children.begin(); child != this->children.end(); child ++)
817    (*child)->countChildNodes(nodes);
818}
819
820
821/**
822 * @brief displays some information about this pNode
823 * @param depth The deph into which to debug the children of this PNode to.
824 * (0: all children will be debugged, 1: only this PNode, 2: this and direct children, ...)
825 * @param level !! INTERNAL !! The n-th level of the Node we draw (this is internal and only for nice output).
826 */
827void PNode::debugNode(unsigned int depth, unsigned int level) const
828{
829  for (unsigned int i = 0; i < level; i++)
830    PRINT(0)(" |");
831  if (this->children.size() > 0)
832    PRINT(0)(" +");
833  else
834    PRINT(0)(" -");
835
836  int childNodeCount = 0;
837  this->countChildNodes(childNodeCount);
838
839  PRINT(0)("PNode(%s::%s) - absCoord: (%0.2f, %0.2f, %0.2f), relCoord(%0.2f, %0.2f, %0.2f), direction(%0.2f, %0.2f, %0.2f) - %s - %d childs\n",
840           this->getClassName(),
841           this->getName(),
842           this->absCoordinate.x,
843           this->absCoordinate.y,
844           this->absCoordinate.z,
845           this->relCoordinate.x,
846           this->relCoordinate.y,
847           this->relCoordinate.z,
848           this->getAbsDirV().x,
849           this->getAbsDirV().y,
850           this->getAbsDirV().z,
851           this->parentingModeToChar(parentMode),
852           childNodeCount);
853  if (depth >= 2 || depth == 0)
854  {
855    list<PNode*>::const_iterator child;
856    for (child = this->children.begin(); child != this->children.end(); child ++)
857    {
858      if (depth == 0)
859        (*child)->debugNode(0, level + 1);
860      else
861        (*child)->debugNode(depth - 1, level +1);
862    }
863  }
864}
865
866/**
867 * @brief displays the PNode at its position with its rotation as a cube.
868 * @param  depth The deph into which to debug the children of this PNode to.
869 * (0: all children will be displayed, 1: only this PNode, 2: this and direct children, ...)
870 * @param size the Size of the Box to draw.
871 * @param color the color of the Box to display.
872 * @param level !! INTERNAL !! The n-th level of the Node we draw (this is internal and only for nice output).
873 */
874void PNode::debugDraw(unsigned int depth, float size, const Vector& color, unsigned int level) const
875{
876  // if this is the first Element we draw
877  if (level == 0)
878  {
879    glPushAttrib(GL_ENABLE_BIT); // save the Enable-attributes
880    glMatrixMode(GL_MODELVIEW);  // goto the ModelView Matrix
881
882    glDisable(GL_LIGHTING);      // disable lighting (we do not need them for just lighting)
883    glDisable(GL_BLEND);         // ''
884    glDisable(GL_TEXTURE_2D);    // ''
885    glDisable(GL_DEPTH_TEST);    // ''
886  }
887
888  glPushMatrix();                // repush the Matrix-stack
889  /* translate */
890  glTranslatef (this->getAbsCoor ().x,
891                this->getAbsCoor ().y,
892                this->getAbsCoor ().z);
893//  this->getAbsDir ().matrix (matrix);
894
895  /* rotate */
896  Vector tmpRot = this->getAbsDir().getSpacialAxis();
897  glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
898  /* set the new Color */
899  glColor3f(color.x, color.y, color.z);
900  { /* draw a cube of size size */
901    glBegin(GL_LINE_STRIP);
902    glVertex3f(-.5*size, -.5*size,  -.5*size);
903    glVertex3f(+.5*size, -.5*size,  -.5*size);
904    glVertex3f(+.5*size, -.5*size,  +.5*size);
905    glVertex3f(-.5*size, -.5*size,  +.5*size);
906    glVertex3f(-.5*size, -.5*size,  -.5*size);
907    glEnd();
908    glBegin(GL_LINE_STRIP);
909    glVertex3f(-.5*size, +.5*size,  -.5*size);
910    glVertex3f(+.5*size, +.5*size,  -.5*size);
911    glVertex3f(+.5*size, +.5*size,  +.5*size);
912    glVertex3f(-.5*size, +.5*size,  +.5*size);
913    glVertex3f(-.5*size, +.5*size,  -.5*size);
914    glEnd();
915
916    glBegin(GL_LINES);
917    glVertex3f(-.5*size, -.5*size,  -.5*size);
918    glVertex3f(-.5*size, +.5*size,  -.5*size);
919    glVertex3f(+.5*size, -.5*size,  -.5*size);
920    glVertex3f(+.5*size, +.5*size,  -.5*size);
921    glVertex3f(+.5*size, -.5*size,  +.5*size);
922    glVertex3f(+.5*size, +.5*size,  +.5*size);
923    glVertex3f(-.5*size, -.5*size,  +.5*size);
924    glVertex3f(-.5*size, +.5*size,  +.5*size);
925    glEnd();
926  }
927
928  glPopMatrix();
929  if (depth >= 2 || depth == 0)
930  {
931    /* rotate the current color in HSV space around 20 degree */
932    Vector childColor =  Color::HSVtoRGB(Color::RGBtoHSV(color)+Vector(20,0,.0));
933    list<PNode*>::const_iterator child;
934    for (child = this->children.begin(); child != this->children.end(); child ++)
935    {
936      // drawing the Dependency graph
937     if (this != PNode::getNullParent())
938      {
939       glBegin(GL_LINES);
940       glColor3f(color.x, color.y, color.z);
941       glVertex3f(this->getAbsCoor ().x,
942                  this->getAbsCoor ().y,
943                  this->getAbsCoor ().z);
944        glColor3f(childColor.x, childColor.y, childColor.z);
945        glVertex3f((*child)->getAbsCoor ().x,
946                   (*child)->getAbsCoor ().y,
947                   (*child)->getAbsCoor ().z);
948        glEnd();
949      }
950
951      /* if we want to draw the children too */
952      if (depth == 0) /* -> all of them */
953        (*child)->debugDraw(0, size, childColor, level+1);
954      else            /* -> only the Next one */
955        (*child)->debugDraw(depth - 1, size, childColor, level +1);
956    }
957  }
958  if (level == 0)
959    glPopAttrib(); /* pop the saved attributes back out */
960}
961
962
963
964/////////////////////
965// HELPER_FUCTIONS //
966/////////////////////
967
968/**
969 * @brief converts a parentingMode into a string that is the name of it
970 * @param parentingMode the ParentingMode to convert
971 * @return the converted string
972 */
973const char* PNode::parentingModeToChar(int parentingMode)
974{
975  if (parentingMode == PNODE_LOCAL_ROTATE)
976    return "local-rotate";
977  else if (parentingMode == PNODE_ROTATE_MOVEMENT)
978    return "rotate-movement";
979  else if (parentingMode == PNODE_MOVEMENT)
980    return "movement";
981  else if (parentingMode == PNODE_ALL)
982    return "all";
983  else if (parentingMode == PNODE_ROTATE_AND_MOVE)
984    return "rotate-and-move";
985}
986
987/**
988 * @brief converts a parenting-mode-string into a int
989 * @param parentingMode the string naming the parentingMode
990 * @return the int corresponding to the named parentingMode
991 */
992PARENT_MODE PNode::charToParentingMode(const char* parentingMode)
993{
994  if (!strcmp(parentingMode, "local-rotate"))
995    return (PNODE_LOCAL_ROTATE);
996  else  if (!strcmp(parentingMode, "rotate-movement"))
997    return (PNODE_ROTATE_MOVEMENT);
998  else  if (!strcmp(parentingMode, "movement"))
999    return (PNODE_MOVEMENT);
1000  else  if (!strcmp(parentingMode, "all"))
1001    return (PNODE_ALL);
1002  else  if (!strcmp(parentingMode, "rotate-and-move"))
1003    return (PNODE_ROTATE_AND_MOVE);
1004}
Note: See TracBrowser for help on using the repository browser.