Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/lib/graphics/render2D/element_2d.h @ 10221

Last change on this file since 10221 was 9869, checked in by bensch, 18 years ago

orxonox/trunk: merged the new_class_id branche back to the trunk.
merged with command:
svn merge https://svn.orxonox.net/orxonox/branches/new_class_id trunk -r9683:HEAD
no conflicts… puh..

File size: 13.6 KB
Line 
1/*!
2 * @file element_2d.h
3 * Definition of the 2D elements rendered on top of all other stuff.
4 */
5
6#ifndef _ELEMENT_2D_H
7#define _ELEMENT_2D_H
8
9#include "base_object.h"
10
11#include "vector.h"
12#include "vector2D.h"
13#include <list>
14
15// FORWARD DECLARATION
16class PNode;
17class TiXmlElement;
18
19//!< An enumerator defining the Depth of a 2D-element.
20typedef enum
21{
22  E2D_LAYER_BELOW_ALL           =     0,        //!< Will be rendered below the 3D-scene. @todo make this work.
23  E2D_LAYER_BOTTOM              =     1,        //!< Will be rendered on the bottom Layer
24  E2D_LAYER_MEDIUM              =     2,        //!< Will be rendered on the medium Layer.
25  E2D_LAYER_TOP                 =     3,        //!< Will be rendered on top of everything else
26  E2D_LAYER_ABOVE_ALL           =     4,        //!< Will be rendered above everything else.
27
28  E2D_LAYER_COUNT               =     5,         //!< The count of Layers.
29} E2D_LAYER;
30#define E2D_DEFAULT_LAYER       E2D_LAYER_MEDIUM
31#define E2D_LAYER_ALL           5
32
33typedef enum
34{
35  E2D_ALIGN_NONE                =     0,
36  E2D_ALIGN_LEFT                =     1,
37  E2D_ALIGN_RIGHT               =     2,
38  E2D_ALIGN_CENTER              =     4,
39  E2D_ALIGN_SCREEN_CENTER       =     8
40} E2D_ALIGNMENT;
41
42typedef enum
43{
44  E2D_PARENT_NONE                    = 0x0000,
45  E2D_PARENT_LOCAL_ROTATE            = 0x0001,    //!< Rotates all the children around their centers.
46  E2D_PARENT_ROTATE_MOVEMENT         = 0x0002,    //!< Moves all the children around the center of their parent, without the rotation around their own centers.
47
48  E2D_PARENT_MOVEMENT                = 0x0004,    //!< Moves all children along with the parent.
49  // special linkage modes
50  E2D_PARENT_ALL                     = 0x0003,    //!< Moves all children around the center of their parent, and also rotates their centers
51  E2D_PARENT_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.
52
53
54  // REPARENTING
55  E2D_REPARENT_TO_NULL               = 0x0010,    //!< Reparents to the Null, if the Parent is Removed. Meaning the Node wont have a parent anymore.
56  E2D_REPARENT_TO_PARENTS_PARENT     = 0x0020,    //!< Reparents the Node to the parents (old) parent it the parent gets removed.
57  /////////////////////////////////////////////   //  ELSE: Reparents to the NullParent.
58  E2D_REPARENT_DELETE_CHILDREN       = 0x0040,    //!< Deletes the Children of the node when This Node is Removed. (Use with care).
59  /// FIXME
60  E2D_REPARENT_KEEP_POSITION         = 0x0080,   //!< Tries to keep the Position if the Node is reparented.
61
62
63  // DELETION
64  E2D_PROHIBIT_CHILD_DELETE          = 0x0100,    //!< Prohibits the Children from being deleted if this Node gets deleted.
65  E2D_PROHIBIT_DELETE_WITH_PARENT    = 0x0200,    //!< Prohibits the Node to be deleted if the Parent is. Child will be reparented according to the Repaenting-Rules
66  E2D_REPARENT_CHILDREN_ON_REMOVE    = 0x0400,    //!< Reparents the Children of the Node if the Node gets Removed.
67  E2D_REPARENT_ON_PARENTS_REMOVE     = 0x0800,    //!< The Node gets Reparented if its Parent gets removed. Child will be reparented according to the Reparenting-Rules.
68
69  // VISIBILITY/ACTIVITY
70  E2D_HIDE_CHILDREN_IF_HIDDEN        = 0x1000,    //!< Prohibits the Children from being drawn if this node isn't visible. (used for Draw))
71  //E2D_HIDE_IF_PARENT_HIDDEN          = 0x2000,    //!< Prohibits the node from being drawn if the Parent is invisible.
72  E2D_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.)
73  E2D_STATIC_NODE                    = 0x8000,    //!< Used for nodes that do not have any moving children, and that do not move.
74
75} E2D_PARENT_MODE;
76#define     E2D_PARENT_MODE_DEFAULT     E2D_PARENT_ALL | \
77                                        E2D_REPARENT_KEEP_POSITION
78
79//! A class for 2D-elements
80/**
81 * this class mainly tries to imitate PNode in its functionality, but on a 2D-level
82 * it extends PNode in the Sense of the tick-ability/draw-alility layering (and size)
83 *
84 * Layering: Layers are sorted into the Tree. e.g:
85 * the roor is in the lowest Layer, the leaves in the highest (of each branche)
86 * the first child of each node is in the lowest layer of all children, the last in the highest
87 * -> the tree is sorted on insertion of a new Child: @see Element2D::addChild2D()
88 */
89class Element2D : virtual public BaseObject
90{
91  ObjectListDeclaration(Element2D);
92
93public:
94  Element2D(Element2D* parent = Element2D::getNullElement(), E2D_LAYER layer = E2D_DEFAULT_LAYER, short nodeFlags = E2D_PARENT_MODE_DEFAULT);
95  virtual ~Element2D();
96
97  virtual void loadParams(const TiXmlElement* root);
98
99  // ACTIVATION //
100  inline void activate2D() { this->bActive = this->bRelCoorChanged = this->bRelDirChanged = true; };
101  inline void deactivate2D() { this->bActive = false; };
102  inline bool get2DActiveState() { return this->bActive; };
103
104  // ALIGNMENT //
105  /** @param alignment the new Alignment of the 2D-Element */
106  inline void setAlignment(E2D_ALIGNMENT alignment) { this->alignment = alignment; };
107  void setAlignment(const std::string& alignment);
108  inline E2D_ALIGNMENT getAlignment() const { return this->alignment; };
109
110  // LAYERING //
111  void setLayer(E2D_LAYER layer);
112  void setLayer(const std::string& layer);
113  /** @returns the Layer this Element is drawn to */
114  inline E2D_LAYER getLayer() const { return this->layer; };
115
116  // VISIBILITY //
117  /** @param visible true if the Element should be visible false otherwise (will not be rendered) */
118  inline void setVisibility(bool visible) { this->bVisible = visible; };
119  /** @returns the visibility state */
120  inline bool isVisible() const { return (this->bVisible && this->bCurrentlyVisible);  };
121
122
123  // POSITIONAL (E2D-specials) //
124  /** @param bindNode the Node this 2D-element should follow. if NULL the Element will not follow anything */
125  void setBindNode(const PNode* bindNode);
126  void setBindNode(const std::string& bindNode);
127  inline const PNode* getBindNode() const { return this->bindNode; };
128
129  inline void setSize2D(float x, float y) { this->size = Vector2D(x, y); };
130  inline void setSize2D(const Vector2D& size) { this->size = size; };
131  inline const Vector2D& getSize2D() const { return this->size; };
132  void setSizeSoft2D(float x, float y, float bias = 1.0);
133  inline void setSizeX2D(float x) { this->size.x = x; };
134  inline void setSizeY2D(float y) { this->size.y = y; };
135  inline float getSizeX2D() const { return this->size.x; };
136  inline float getSizeY2D() const { return this->size.y; };
137
138public:
139  virtual void tick(float dt) {};
140  virtual void draw() const  {};
141  void tick2D(float dt);
142  void draw2D(E2D_LAYER from, E2D_LAYER to) const;
143  void drawChildren(E2D_LAYER from, E2D_LAYER to) const;
144
145  // LIKE PNODE
146public:
147  void setRelCoor2D (const Vector2D& relCoord);
148  void setRelCoorX2D(float x);
149  void setRelCoorY2D(float y);
150  void setRelCoor2D (float x, float y);
151  void setRelCoor2Dpx (int x, int y);
152  void setRelCoorSoft2D (const Vector2D& relCoordSoft, float bias = 1.0);
153  void setRelCoorSoft2D (float x, float y, float bias = 1.0);
154  void setRelCoorSoft2Dpx (int x, int y, float bias = 1.0);
155  /** @returns the relative position */
156  inline const Vector2D& getRelCoor2D () const { return this->prevRelCoordinate; };
157  /** @returns the Relative Coordinate Destination */
158inline const Vector2D& getRelCoorSoft2D() const { return (this->toCoordinate)?*this->toCoordinate:this->relCoordinate; };
159  const Vector2D& getRelCoor2Dpx() const;
160  void setAbsCoor2D (const Vector2D& absCoord);
161  void setAbsCoor2D (float x, float y);
162  void setAbsCoorX2D(float x);
163  void setAbsCoorY2D(float y);
164  void setAbsCoor2Dpx (int x, int y);
165  void setAbsCoorSoft2D (const Vector2D& absCoordSoft, float bias = 1.0);
166  void setAbsCoorSoft2D (float x, float y, float bias = 1.0);
167  /** @returns the absolute position */
168  inline const Vector2D& getAbsCoor2D () const { return this->absCoordinate; };
169  const Vector2D& getAbsCoor2Dpx () const;
170
171  void shiftCoor2D (const Vector2D& shift);
172  void shiftCoor2Dpx (int x, int y);
173
174  void setRelDir2D (float relDir);
175  void setRelDirSoft2D(float relDirSoft, float bias = 1.0);
176  /** @returns the relative Direction */
177  inline float getRelDir2D () const { return this->prevRelDirection; };
178  /** @returns the Relative Directional Destination */
179inline float getRelDirSoft2D() const { return (this->toDirection)?*this->toDirection:this->relDirection; };
180  void setAbsDir2D (float absDir);
181  void setAbsDirSoft2D (float absDirSoft, float bias = 1.0);
182  /** @returns the absolute Direction */
183  inline float getAbsDir2D () const { return this->absDirection; };
184  void shiftDir2D (float shiftDir);
185
186  /** @returns the Speed of the Node */
187  inline float getSpeed() const { return 0; };
188  /** @returns the Velocity of the Node */
189  inline const Vector2D& getVelocity() const { return this->velocity; };
190
191
192  void addChild2D (Element2D* child);
193  void addChild2D (const std::string& childName);
194  void removeChild2D (Element2D* child);
195  void remove2D();
196
197  /** @param parent the new parent of this Element2D */
198  void setParent2D (Element2D* parent) { parent->addChild2D(this); };
199  void setParent2D (const std::string& parentName);
200  /** @returns the parent of this Element2D */
201  inline Element2D* getParent2D () const { return this->parent; };
202  /** @returns the List of Children of this Element2D */
203  inline const std::list<Element2D*>& getChildren2D() const { return this->children; };
204
205  void setParentSoft2D(Element2D* parentNode, float bias = 1.0);
206  void setParentSoft2D(const std::string& parentName, float bias = 1.0);
207
208  void setParentMode2D (E2D_PARENT_MODE parentMode);
209  void setParentMode2D (const std::string& parentingMode);
210  /** @returns the Parenting mode of this node */
211  int getParentMode2D() const { return this->parentMode; };
212
213  // NULL_PARENT //
214  /** @returns the NullParent, the (main) ROOT of the PNode Tree. If it does not yet exist, it will be created. */
215static Element2D* getNullElement()  { return (Element2D::nullElement != NULL)? Element2D::nullElement : Element2D::createNullElement(); };
216
217
218  void update2D (float dt);
219
220  void debug2D (unsigned int depth = 1, unsigned int level = 0) const;
221  void debugDraw2D(unsigned int depth = 1, float size = 1.0, Vector color = Vector(1,0,0), unsigned int level = 0) const;
222
223  // helper functions //
224  static const char* parentingModeToString2D(int parentingMode);
225  static E2D_PARENT_MODE stringToParentingMode2D(const std::string& parentingMode);
226
227  static const char* layer2DToChar(E2D_LAYER layer);
228  static E2D_LAYER charToLayer2D(const std::string& layer);
229
230  static bool layerSortPredicate(const Element2D* elem1, const Element2D* elem2);
231
232private:
233  void eraseChild2D(Element2D* child);
234  /** tells the child that the parent's Coordinate has changed */
235  inline void parentCoorChanged2D () { this->bRelCoorChanged = true; }
236  /** tells the child that the parent's Direction has changed */
237  inline void parentDirChanged2D () { this->bRelDirChanged = true; }
238  /** @returns the last calculated coordinate */
239  inline Vector2D getLastAbsCoor2D() { return this->lastAbsCoordinate; }
240
241  void reparent2D();
242  static Element2D* createNullElement();
243  bool checkIntegrity(const Element2D* checkParent) const;
244
245
246private:
247  const PNode*            bindNode;           //!< a node over which to display this 2D-element
248  Vector2D                size;               //!< The size of the rendered item
249  Vector2D*               toSize;             //!< The Size to iterate to.
250
251  E2D_ALIGNMENT           alignment;          //!< How the Element is aligned around its Position
252
253  bool                    bVisible;           //!< If the given Element2D is visible.
254  bool                    bCurrentlyVisible;  //!< Evaluated in the TICK process, to see if the Element is Currently visible.
255  bool                    bActive;            //!< If the given Element2D is active.
256  E2D_LAYER               layer;              //!< What layer this Element2D is on.
257
258  bool                    bRelCoorChanged;    //!< If Relative Coordinate has changed since last time we checked
259  bool                    bRelDirChanged;     //!< If Relative Direction has changed since last time we checked
260
261  Vector2D                relCoordinate;      //!< coordinates relative to the parent
262  Vector2D                absCoordinate;      //!< absolute coordinates in the world ( from (0,0,0) )
263  float                   relDirection;       //!< direction relative to the parent
264  float                   absDirection;       //!< absolute diretion in the world ( from (0,0,1) )
265
266  Vector2D                prevRelCoordinate;  //!< The last Relative Coordinate from the last update-Cycle.
267  Vector2D                lastAbsCoordinate;  //!< this is used for speedcalculation, it stores the last coordinate
268  float                   prevRelDirection;   //!< The last Relative Direciton from the last update-Cycle.
269
270  Vector2D                velocity;           //!< Saves the velocity.
271
272  Vector2D*               toCoordinate;       //!< a position to which to iterate. (This is used in conjunction with setParentSoft.and set*CoorSoft)
273  float*                  toDirection;        //!< a direction to which to iterate. (This is used in conjunction with setParentSoft and set*DirSoft)
274  float                   bias;               //!< how fast to iterate to the given position (default is 1)
275
276  Element2D*              parent;             //!< a pointer to the parent node
277  std::list<Element2D*>   children;           //!< list of the children of this Element2D
278
279  unsigned int            parentMode;         //!< the mode of the binding
280
281  static Element2D*       nullElement;        //!< The top-most Element
282};
283
284#endif /* _ELEMENT_2D_H */
Note: See TracBrowser for help on using the repository browser.