Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/branches/bsp_model/src/lib/coord/p_node.h @ 8538

Last change on this file since 8538 was 8490, checked in by patrick, 18 years ago

merged the bsp branche back to trunk

File size: 12.0 KB
Line 
1/*!
2 * @file p_node.h
3 * @brief Definition of THE 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 bRelCoorChanged is true (so moved)
13 *  o bRelDirChanged is true (so changed)
14 *  this conditions make it cheaper to recalculate the tree (reduces redundant work).
15 */
16
17
18#ifndef _P_NODE_H
19#define _P_NODE_H
20
21#include "base_object.h"
22#include "stdincl.h"
23#include "synchronizeable.h"
24
25#include "vector.h"
26#include "quaternion.h"
27#include <list>
28
29// FORWARD DECLARATION
30class TiXmlElement;
31
32#define PNODE_ITERATION_DELTA    .001
33
34//! Parental linkage modes
35typedef enum
36{
37  // PARENTAL FOLLOWING
38  PNODE_LOCAL_ROTATE                   = 0x0001,    //!< Rotates all the children around their centers.
39  PNODE_ROTATE_MOVEMENT                = 0x0002,    //!< Moves all the children around the center of their parent, without the rotation around their own centers.
40
41  PNODE_MOVEMENT                       = 0x0004,    //!< Moves all children along with the parent.
42  // special linkage modes
43  PNODE_ALL                            = 0x0003,    //!< Moves all children around the center of their parent, and also rotates their centers
44  PNODE_ROTATE_AND_MOVE                = 0x0005,    //!< Rotates all children around their axis, and moves them as the Parent Moves, but does not rotate around the center of their parent.
45
46
47  // REPARENTING
48  PNODE_REPARENT_TO_NULL               = 0x0010,    //!< Reparents to the Null, if the Parent is Removed. Meaning the Node wont have a parent anymore.
49  PNODE_REPARENT_TO_PARENTS_PARENT     = 0x0020,    //!< Reparents the Node to the parents (old) parent it the parent gets removed.
50  /////////////////////////////////////////////     //  ELSE: Reparents to the NullParent.
51  PNODE_REPARENT_DELETE_CHILDREN       = 0x0040,    //!< Deletes the Children of the node when This Node is Removed. (Use with care).
52  /// FIXME
53   PNODE_REPARENT_KEEP_POSITION         = 0x0080,    //!< Tries to keep the Position if the Node is reparented.
54
55
56  // DELETION
57  PNODE_PROHIBIT_CHILD_DELETE          = 0x0100,    //!< Prohibits the Children from being deleted if this Node gets deleted.
58  PNODE_PROHIBIT_DELETE_WITH_PARENT    = 0x0200,    //!< Prohibits the Node to be deleted if the Parent is. Child will be reparented according to the Repaenting-Rules
59  PNODE_REPARENT_CHILDREN_ON_REMOVE    = 0x0400,    //!< Reparents the Children of the Node if the Node gets Removed.
60  PNODE_REPARENT_ON_PARENTS_REMOVE     = 0x0800,    //!< The Node gets Reparented if its Parent gets removed. Child will be reparented according to the Reparenting-Rules.
61
62  // VISIBILITY/ACTIVITY
63  PNODE_HIDE_CHILDREN_IF_HIDDEN        = 0x1000,    //!< Prohibits the Children from being drawn if this node isn't visible. (used for Draw))
64  PNODE_HIDE_IF_PARENT_HIDDEN          = 0x2000,    //!< Prohibits the node from being drawn if the Parent is invisible.
65  PNODE_UPDATE_CHILDREN_IF_INACTIVE    = 0x4000,    //!< Updates the Children of this Node even if the Parent is Inactive (note if this's parent is inactive children won't be updated.)
66  PNODE_STATIC_NODE                    = 0x8000,    //!< Used for nodes that do not have any moving children, and that do not move.
67
68} PARENT_MODE;
69
70//! The default mode of the translation-binding.
71#define PNODE_PARENT_MODE_DEFAULT PNODE_ALL | \
72                                  PNODE_REPARENT_KEEP_POSITION
73
74
75//! Patent Node is a Engine to calculate the position of an Object in respect to the position of its parent.
76class PNode : virtual public BaseObject, virtual public Synchronizeable {
77 public:
78  PNode (PNode* parent = PNode::getNullParent(), long nodeFlags = PNODE_PARENT_MODE_DEFAULT);
79  virtual ~PNode ();
80
81  virtual void loadParams(const TiXmlElement* root);
82
83  void init();
84
85  // ACTIVATION //
86  inline void activateNode() { this->bActive = this->bRelCoorChanged = this->bRelDirChanged = true; };
87  inline void deactivateNode() { this->bActive = false; };
88  inline bool getNodeActiveState() { return this->bActive; };
89
90  // POSITION //
91  void setRelCoor (const Vector& relCoord);
92  void setRelCoor (float x, float y, float z);
93  void setRelCoorSoft(const Vector& relCoordSoft, float bias = 1.0);
94  void setRelCoorSoft(float x, float y, float z, float bias = 1.0);
95  /** @returns the relative position */
96  inline const Vector& getRelCoor () const { return this->prevRelCoordinate; };
97  /** @returns the Relative Coordinate Destination */
98  inline const Vector& getRelCoorSoft2D() const { return (this->toCoordinate)? *this->toCoordinate : this->relCoordinate; };
99  void setAbsCoor (const Vector& absCoord);
100  void setAbsCoor (float x, float y, float z);
101  void setAbsCoorSoft(const Vector& absCoordSoft, float bias = 1.0);
102  void setAbsCoorSoft(float x, float y, float z, float bias = 1.0);
103  /** @returns the absolute position */
104  inline const Vector& getAbsCoor () const { return this->absCoordinate; };
105  /** @returns the absolute position */
106  inline const Vector& getLastAbsCoor () const { return this->lastAbsCoordinate; };
107  void shiftCoor (const Vector& shift);
108  void shiftCoor (float x, float y, float z) { this->shiftCoor(Vector(x, y, z)); };
109
110  // SPEED //
111  /** @returns the Speed of the Node */
112  inline float getSpeed() const { return this->velocity.len(); };
113  /** @returns the Velocity of the Node */
114  inline const Vector& getVelocity() const { return this->velocity; };
115
116
117  // ROTATION //
118  void setRelDir (const Quaternion& relDir);
119  void setRelDir (float angle, float x, float y, float z);
120  void setRelDirSoft(const Quaternion& relDirSoft, float bias = 1.0);
121  void setRelDirSoft(float angle, float x, float y, float z, float bias = 1.0);
122  /** @returns the relative Direction */
123  inline const Quaternion& getRelDir () const { return this->prevRelDirection; };
124  /** @returns the Relative Directional Destination */
125  inline const Quaternion& getRelDirSoft2D() const { return (this->toDirection)? *this->toDirection : this->relDirection; };
126  /** @returns a Vector pointing into the relative Direction */
127  inline Vector getRelDirV() const { return this->prevRelDirection.apply(Vector(0,1,0)); };
128  void setAbsDir (const Quaternion& absDir);
129  void setAbsDir (float angle, float x, float y, float z);
130  void setAbsDirSoft(const Quaternion& absDirSoft, float bias = 1.0);
131  void setAbsDirSoft(float angle, float x, float y, float z, float bias = 1.0);
132  void shiftDir (const Quaternion& shift);
133  /** @returns the absolute Direction */
134  inline const Quaternion& getAbsDir () const { return this->absDirection; };
135  /** @returns a Vector pointing into the absolute Direction */
136  inline Vector getAbsDirV() const { return this->absDirection.apply(Vector(0,1,0)); };
137  /** @returns A Vector pointing into the forward direction (X) of the Node */
138  inline Vector getAbsDirX() const { return this->absDirection.apply(Vector(1,0,0)); };
139  /** @returns A Vector pointing into the upward direction (Y) of the Node */
140  inline Vector getAbsDirY() const { return this->absDirection.apply(Vector(0,1,0)); };
141  /** @returns A Vector pointing into the right direction (Z) of the Node */
142  inline Vector getAbsDirZ() const { return this->absDirection.apply(Vector(0,0,1)); };
143
144
145  // PARENTING //
146  void addChild (PNode* child);
147  void addChild (const std::string& childName);
148  void removeChild (PNode* child);
149  void removeNode();
150
151  PNode* seekNextAssignedPNode(PNode* node) const;
152
153  /** @param parent the new parent of this node */
154  inline void setParent (PNode* parent) { parent->addChild(this); };
155  void setParent (const std::string& parentName);
156  /** @returns the parent of this PNode */
157  inline PNode* getParent () const { return this->parent; };
158  /** @returns the List of Children of this PNode */
159  const std::list<PNode*>& getNodesChildren() const { return this->children; };
160
161  void setParentSoft(PNode* parentNode, float bias = 1.0);
162  void setParentSoft(const std::string& parentName, float bias = 1.0);
163
164  // PARENTING_MODE AND OTHER FLAGS //
165  void setParentMode (PARENT_MODE parentMode);
166  void setParentMode (const std::string& parentingMode);
167  /** @returns the Parenting mode of this node */
168  int getParentMode() const { return 0x000f & this->parentMode; };
169
170  void addNodeFlags(unsigned short nodeFlags);
171  void removeNodeFlags(unsigned short nodeFlags);
172
173  // NULL_PARENT //
174  /** @returns the NullParent, the (main) ROOT of the PNode Tree. If it does not yet exist, it will be created. */
175  static PNode* getNullParent()  { return (PNode::nullParent != NULL)? PNode::nullParent : PNode::createNullParent(); };
176
177  // UPDATING //
178  void updateNode (float dt);
179
180  // DEBUG //
181  void countChildNodes(int& nodes) const;
182  void debugNode (unsigned int depth = 1, unsigned int level = 0) const;
183  void debugDraw(unsigned int depth = 1, float size = 1.0, const Vector& color = Vector(1, 0, 0), unsigned int level = 0) const;
184
185  // HELPER_FUNCTIONS //
186  static const char* parentingModeToString(int parentingMode);
187  static PARENT_MODE stringToParentingMode(const std::string& parentingMode);
188  float distance(const PNode* node) const { return (this->getAbsCoor() - node->getAbsCoor()).len(); };
189
190 private:
191  /** tells the child that the parent's Coordinate has changed */
192  inline void parentCoorChanged () { this->bRelCoorChanged = true; }
193  /** tells the child that the parent's Direction has changed */
194  inline void parentDirChanged () { this->bRelDirChanged = true; }
195 public:
196  /** @returns the last calculated coordinate */
197  inline Vector getLastAbsCoor() { return this->lastAbsCoordinate; }
198 private:
199  static PNode* createNullParent();
200  void reparent();
201  bool checkIntegrity(const PNode* checkParent) const;
202  void eraseChild(PNode* child);
203
204 private:
205  bool               bRelCoorChanged;    //!< If Relative Coordinate has changed since last time we checked
206  bool               bRelDirChanged;     //!< If Relative Direction has changed since last time we checked
207
208  Vector             relCoordinate;      //!< coordinates relative to the parent
209  Vector             absCoordinate;      //!< absolute coordinates in the world ( from (0,0,0) )
210  Quaternion         relDirection;       //!< direction relative to the parent
211  Quaternion         absDirection;       //!< absolute direvtion in the world ( from (0,0,1) )
212
213  Vector             prevRelCoordinate;  //!< The last Relative Coordinate from the last update-Cycle.
214  Vector             lastAbsCoordinate;  //!< this is used for speedcalculation, it stores the last coordinate
215  Quaternion         prevRelDirection;   //!< The last Relative Direciton from the last update-Cycle.
216//  Quaternion         lastAbsDirection;
217
218  Vector             velocity;           //!< Saves the velocity.
219
220  Vector*            toCoordinate;       //!< a position to which to iterate. (This is used in conjunction with setParentSoft.and set*CoorSoft)
221  Quaternion*        toDirection;        //!< a direction to which to iterate. (This is used in conjunction with setParentSoft and set*DirSoft)
222  float              bias;               //!< how fast to iterate to the given position (default is 1)
223
224  PNode*             parent;             //!< a pointer to the parent node.
225  std::list<PNode*>  children;           //!< list of the children of this PNode.
226
227  bool               bActive;            //!< If the Node is Active (for cutting off the rest of the tree in update).
228  unsigned short     parentMode;         //!< the mode of the binding
229
230
231  static PNode*      nullParent;         //!< The ROOT of the main PNode Tree.
232
233  private:
234    float coorx;
235    float coory;
236    float coorz;
237
238    float rotw;
239    float rotx;
240    float roty;
241    float rotz;
242
243  private:
244    int relCoordinate_handle;
245    int relDirection_handle;
246    Vector relCoordinate_write;
247    Quaternion relDirection_write;
248
249  public:
250    virtual void varChangeHandler( std::list<int> & id );
251};
252
253#endif /* _P_NODE_H */
Note: See TracBrowser for help on using the repository browser.