[4570] | 1 | /*! |
---|
[3246] | 2 | \file p_node.h |
---|
[4836] | 3 | * Definition of a parenting node |
---|
[3246] | 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 |
---|
[4570] | 11 | place or ortientation. this is only the case if |
---|
[3246] | 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 | |
---|
[3365] | 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... |
---|
[3246] | 18 | */ |
---|
| 19 | |
---|
| 20 | |
---|
| 21 | #ifndef _P_NODE_H |
---|
| 22 | #define _P_NODE_H |
---|
| 23 | |
---|
[3543] | 24 | #include "base_object.h" |
---|
[3804] | 25 | #include "vector.h" |
---|
[3246] | 26 | |
---|
[3543] | 27 | // FORWARD DEFINITION \\ |
---|
[3365] | 28 | class PNode; /* forward decleration, so that parentEntry has access to PNode */ |
---|
[3804] | 29 | //class Quaternion; |
---|
| 30 | //class Vector; |
---|
[4436] | 31 | class TiXmlElement; |
---|
[3607] | 32 | template<class T> class tList; |
---|
[3246] | 33 | |
---|
[4765] | 34 | //! Parental linkage modes |
---|
| 35 | typedef 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. |
---|
[3565] | 41 | // special linkage modes |
---|
[4765] | 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. |
---|
[3565] | 44 | |
---|
[4765] | 45 | } PARENT_MODE; |
---|
| 46 | |
---|
[3450] | 47 | //! The default mode of the translation-binding. |
---|
[3565] | 48 | #define DEFAULT_MODE PNODE_ALL |
---|
[3246] | 49 | |
---|
[4440] | 50 | |
---|
[3450] | 51 | //! Patent Node is a Engine to calculate the position of an Object in respect to the position of its parent. |
---|
[4382] | 52 | class PNode : virtual public BaseObject { |
---|
[3365] | 53 | |
---|
[3246] | 54 | public: |
---|
| 55 | PNode (); |
---|
[4436] | 56 | PNode(const TiXmlElement* root); |
---|
[3809] | 57 | PNode (const Vector& absCoordinate, PNode* pNode); |
---|
[3365] | 58 | virtual ~PNode (); |
---|
[3246] | 59 | |
---|
[4436] | 60 | void loadParams(const TiXmlElement* root); |
---|
| 61 | |
---|
[3810] | 62 | void setRelCoor (const Vector& relCoord); |
---|
[4610] | 63 | void setRelCoor (float x, float y, float z); |
---|
[4987] | 64 | void setRelCoorSoft(const Vector& softRelCoord); |
---|
[4836] | 65 | /** @returns the relative position */ |
---|
[4372] | 66 | inline const Vector& getRelCoor () const { return this->relCoordinate; }; |
---|
[3809] | 67 | void setAbsCoor (const Vector& absCoord); |
---|
[4610] | 68 | void setAbsCoor (float x, float y, float z); |
---|
[4836] | 69 | /** @returns the absolute position */ |
---|
[4372] | 70 | inline const Vector& getAbsCoor () const { return this->absCoordinate; }; |
---|
[3809] | 71 | void shiftCoor (const Vector& shift); |
---|
[3246] | 72 | |
---|
[3810] | 73 | void setRelDir (const Quaternion& relDir); |
---|
[4771] | 74 | void setRelDir (float x, float y, float z); |
---|
[4836] | 75 | /** @returns the relative Direction */ |
---|
[4372] | 76 | inline const Quaternion& getRelDir () const { return this->relDirection; }; |
---|
[4836] | 77 | /** @returns a Vector pointing into the relative Direction */ |
---|
[4372] | 78 | inline Vector getRelDirV() const { return this->relDirection.apply(Vector(0,1,0)); }; |
---|
[3810] | 79 | void setAbsDir (const Quaternion& absDir); |
---|
[4771] | 80 | void setAbsDir (float x, float y, float z); |
---|
[4836] | 81 | /** @returns the absolute Direction */ |
---|
[4372] | 82 | inline const Quaternion& getAbsDir () const { return this->absDirection; }; |
---|
[4836] | 83 | /** @returns a Vector pointing into the absolute Direction */ |
---|
[4372] | 84 | inline Vector getAbsDirV() const { return this->absDirection.apply(Vector(0,1,0)); }; |
---|
[3802] | 85 | void shiftDir (const Quaternion& shift); |
---|
[3246] | 86 | |
---|
[4836] | 87 | /** @returns the Speed of the Node */ |
---|
[4570] | 88 | inline float getSpeed() const {return this->velocity.len();} |
---|
[4836] | 89 | /** @returns the Velocity of the Node */ |
---|
[4145] | 90 | inline const Vector& getVelocity() const {return this->velocity;} |
---|
[3644] | 91 | |
---|
[4440] | 92 | |
---|
[3802] | 93 | void addChild (PNode* pNode, int parentingMode = DEFAULT_MODE); |
---|
[4765] | 94 | void addChild (const char* childName); |
---|
[3246] | 95 | void removeChild (PNode* pNode); |
---|
[3537] | 96 | void remove(); |
---|
| 97 | |
---|
[3535] | 98 | void setParent (PNode* parent); |
---|
[4987] | 99 | void setParent (const char* parentName); |
---|
[4966] | 100 | /** @returns the parent of this PNode */ |
---|
| 101 | PNode* getParent () const { return this->parent; }; |
---|
[4761] | 102 | |
---|
[4987] | 103 | void softReparent(PNode* parentNode); |
---|
| 104 | void softReparent(const char* parentName); |
---|
| 105 | |
---|
[4765] | 106 | void setParentMode (PARENT_MODE parentMode); |
---|
| 107 | void setParentMode (const char* parentingMode); |
---|
[4836] | 108 | /** @returns the Parenting mode of this node */ |
---|
[4444] | 109 | int getParentMode() const { return this->parentMode; }; |
---|
[3246] | 110 | |
---|
[4440] | 111 | void update (float dt); |
---|
[3246] | 112 | |
---|
[4574] | 113 | void debug (unsigned int depth = 1, unsigned int level = 0) const; |
---|
[4570] | 114 | void debugDraw(float size = 1.0) const; |
---|
[3365] | 115 | |
---|
[4440] | 116 | private: |
---|
| 117 | void init(PNode* parent); |
---|
[4987] | 118 | /** tells the child that the parent's Coordinate has changed */ |
---|
[4440] | 119 | inline void parentCoorChanged () { this->bRelCoorChanged = true; } |
---|
[4987] | 120 | /** tells the child that the parent's Direction has changed */ |
---|
[4440] | 121 | inline void parentDirChanged () { this->bRelDirChanged = true; } |
---|
[4836] | 122 | /** @returns the last calculated coordinate */ |
---|
[4746] | 123 | inline Vector getLastAbsCoor() {return this->lastAbsCoordinate;} |
---|
[3246] | 124 | |
---|
[3537] | 125 | |
---|
[3644] | 126 | private: |
---|
[4440] | 127 | bool bAbsCoorChanged; //!< If Absolute Coordinate has changed since last time we checked |
---|
| 128 | bool bRelCoorChanged; //!< If Relative Coordinate has changed since last time we checked |
---|
| 129 | bool bAbsDirChanged; //!< If Absolute Direction has changed since last time we checked |
---|
| 130 | bool bRelDirChanged; //!< If Relative Direction has changed since last time we checked |
---|
[3644] | 131 | |
---|
[4440] | 132 | Vector relCoordinate; //!< coordinates relative to the parent |
---|
| 133 | Vector absCoordinate; //!< absolute coordinates in the world ( from (0,0,0) ) |
---|
| 134 | Quaternion relDirection; //!< direction relative to the parent |
---|
| 135 | Quaternion absDirection; //!< absolute direvtion in the world ( from (0,0,1) ) |
---|
| 136 | |
---|
| 137 | Vector velocity; //!< Saves the velocity. |
---|
| 138 | Vector lastAbsCoordinate; //!< this is used for speedcalculation, it stores the last coordinate |
---|
| 139 | |
---|
[4987] | 140 | |
---|
| 141 | Vector* toPosition; //!< a position to wich to iterate. (This is used in conjunction with softReparent.) |
---|
| 142 | |
---|
[4440] | 143 | PNode* parent; //!< a pointer to the parent node |
---|
[4987] | 144 | tList<PNode>* children; //!< list of the children of this PNode |
---|
[4440] | 145 | |
---|
[4444] | 146 | unsigned int parentMode; //!< the mode of the binding |
---|
[3246] | 147 | }; |
---|
| 148 | |
---|
| 149 | #endif /* _P_NODE_H */ |
---|
[4570] | 150 | |
---|