Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/orxonox/trunk/src/lib/coord/p_node.h @ 5045

Last change on this file since 5045 was 5008, checked in by bensch, 19 years ago

orxonox/trunk: better coloring

File size: 6.7 KB
Line 
1/*!
2    @file p_node.h
3  *  Definition of a parenting node
4
5    parenting is how coordinates are handled in orxonox, meaning, that all coordinates
6    are representet relative to another parent node. this nodes build a parenting
7    tree of one-sided references (from up to down referenced).
8    Every node manages itself a list of childrens (of whos it is parent - easy...)
9
10    absCoordinate, absDirection have to be recalculated as soon as there was a change in
11    place or ortientation. this is only the case if
12    o bDirChanged is true (so changed) AND timeStamp != now
13    o bCoorChanged is true (so moved) AND timeStamp != now
14    this conditions make it cheaper to recalculate the tree (reduces redundant work).
15
16    remember: if you have to change the coordinates or the directions, use the functions
17    that are defined to execute this operation - otherwhise there will be big problems...
18*/
19
20
21#ifndef _P_NODE_H
22#define _P_NODE_H
23
24#include "base_object.h"
25#include "vector.h"
26
27
28
29// FORWARD DEFINITION \\
30class TiXmlElement;
31template<class T> class tList;
32
33#define PNODE_ITERATION_DELTA    .001
34//! Parental linkage modes
35typedef enum
36{
37  PNODE_LOCAL_ROTATE          =   1,    //!< Rotates all the children around their centers.
38  PNODE_ROTATE_MOVEMENT       =   2,    //!< Moves all the children around the center of their parent, without the rotation around their own centers.
39
40  PNODE_MOVEMENT              =   4,    //!< Moves all children along with the parent.
41// special linkage modes
42  PNODE_ALL                   =   3,    //!< Moves all children around the center of their parent, and also rotates their centers
43  PNODE_ROTATE_AND_MOVE       =   5     //!< Rotates all children around their axis, and moves them as the Parent Moves, but does not rotate around the center of their parent.
44
45} PARENT_MODE;
46
47//! The default mode of the translation-binding.
48#define DEFAULT_MODE PNODE_ALL
49
50
51//! Patent Node is a Engine to calculate the position of an Object in respect to the position of its parent.
52class PNode : virtual public BaseObject {
53
54 public:
55  PNode ();
56  PNode(const TiXmlElement* root);
57  PNode (const Vector& absCoor, PNode* pNode);
58  virtual ~PNode ();
59
60  void loadParams(const TiXmlElement* root);
61
62  void setRelCoor (const Vector& relCoord);
63  void setRelCoor (float x, float y, float z);
64  void setRelCoorSoft(const Vector& relCoordSoft, float bias = 1.0);
65  void setRelCoorSoft(float x, float y, float z, float bias = 1.0);
66  /** @returns the relative position */
67  inline const Vector& getRelCoor () const { return this->relCoordinate; };
68  void setAbsCoor (const Vector& absCoord);
69  void setAbsCoor (float x, float y, float z);
70  /** @returns the absolute position */
71  inline const Vector& getAbsCoor () const { return this->absCoordinate; };
72  void shiftCoor (const Vector& shift);
73
74  void setRelDir (const Quaternion& relDir);
75  void setRelDir (float x, float y, float z);
76  void setRelDirSoft(const Quaternion& relDirSoft, float bias = 1.0);
77  void setRelDirSoft(float x, float y, float z, float bias = 1.0);
78  /** @returns the relative Direction */
79  inline const Quaternion& getRelDir () const { return this->relDirection; };
80  /** @returns a Vector pointing into the relative Direction */
81  inline Vector getRelDirV() const { return this->relDirection.apply(Vector(0,1,0)); };
82  void setAbsDir (const Quaternion& absDir);
83  void setAbsDir (float x, float y, float z);
84  /** @returns the absolute Direction */
85  inline const Quaternion& getAbsDir () const { return this->absDirection; };
86  /** @returns a Vector pointing into the absolute Direction */
87  inline Vector getAbsDirV() const { return this->absDirection.apply(Vector(0,1,0)); };
88  void shiftDir (const Quaternion& shift);
89
90  /** @returns the Speed of the Node */
91  inline float getSpeed() const { return this->velocity.len(); };
92  /** @returns the Velocity of the Node */
93  inline const Vector& getVelocity() const { return this->velocity; };
94
95
96  void addChild (PNode* child, int parentingMode = DEFAULT_MODE);
97  void addChild (const char* childName);
98  void removeChild (PNode* child);
99  void remove();
100
101  void setParent (PNode* parent);
102  void setParent (const char* parentName);
103  /** @returns the parent of this PNode */
104  PNode* getParent () const { return this->parent; };
105
106  void softReparent(PNode* parentNode, float bias = 1.0);
107  void softReparent(const char* parentName, float bias = 1.0);
108
109  /** @param parentMode sets the parentingMode of this Node */
110  void setParentMode (PARENT_MODE parentMode) { this->parentMode = parentMode; };
111  void setParentMode (const char* parentingMode);
112  /** @returns the Parenting mode of this node */
113  int getParentMode() const { return this->parentMode; };
114
115  void update (float dt);
116
117  void debug (unsigned int depth = 1, unsigned int level = 0) const;
118  void debugDraw(unsigned int depth = 1, float size = 1.0, Vector color = Vector(1,1,1)) const;
119
120
121  // helper functions //
122  static const char* parentingModeToChar(int parentingMode);
123  static PARENT_MODE charToParentingMode(const char* parentingMode);
124 private:
125  void init(PNode* parent);
126  /** tells the child that the parent's Coordinate has changed */
127  inline void parentCoorChanged () { this->bRelCoorChanged = true; }
128  /** tells the child that the parent's Direction has changed */
129  inline void parentDirChanged () { this->bRelDirChanged = true; }
130  /** @returns the last calculated coordinate */
131  inline Vector getLastAbsCoor() { return this->lastAbsCoordinate; }
132
133
134 private:
135  bool            bRelCoorChanged;    //!< If Relative Coordinate has changed since last time we checked
136  bool            bRelDirChanged;     //!< If Relative Direction has changed since last time we checked
137
138  Vector          relCoordinate;      //!< coordinates relative to the parent
139  Vector          absCoordinate;      //!< absolute coordinates in the world ( from (0,0,0) )
140  Quaternion      relDirection;       //!< direction relative to the parent
141  Quaternion      absDirection;       //!< absolute direvtion in the world ( from (0,0,1) )
142
143  Vector          velocity;           //!< Saves the velocity.
144  Vector          lastAbsCoordinate;  //!< this is used for speedcalculation, it stores the last coordinate
145
146
147  Vector*         toCoordinate;       //!< a position to which to iterate. (This is used in conjunction with softReparent.and set*CoorSoft)
148  Quaternion*     toDirection;        //!< a direction to which to iterate. (This is used in conjunction with softReparent and set*DirSoft)
149  float           bias;               //!< how fast to iterate to the given position (default is 1)
150
151  PNode*          parent;             //!< a pointer to the parent node
152  tList<PNode>*   children;           //!< list of the children of this PNode
153
154  unsigned int    parentMode;         //!< the mode of the binding
155};
156
157#endif /* _P_NODE_H */
158
Note: See TracBrowser for help on using the repository browser.