Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

Last change on this file since 5729 was 5438, checked in by bensch, 19 years ago

orxonox/trunk: better display of the PNodes debug

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