Merging r48257 through r48263 from trunk into soc-2011-tomato
[blender.git] / source / gameengine / SceneGraph / SG_Node.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file SG_Node.h
29  *  \ingroup bgesg
30  */
31  
32 #ifndef __SG_NODE_H__
33 #define __SG_NODE_H__
34
35 #include "SG_Spatial.h"
36 #include <vector>
37
38 typedef std::vector<SG_Node*> NodeList;
39
40 /**
41  * Scenegraph node.
42  */
43 class SG_Node : public SG_Spatial
44 {
45 public:
46         SG_Node(
47                 void* clientobj,
48                 void* clientinfo,
49                 SG_Callbacks& callbacks
50         );
51
52         SG_Node(
53                 const SG_Node & other
54         );
55
56         virtual ~SG_Node();
57
58
59         /**
60          * Add a child to this object. This also informs the child of
61          * it's parent.
62          * This just stores a pointer to the child and does not
63          * make a deep copy.
64          */
65
66                 void    
67         AddChild(
68                 SG_Node* child
69         );
70
71         /** 
72          * Remove a child node from this object. This just removes the child
73          * pointer from the list of children - it does not destroy the child.
74          * This does not inform the child that this node is no longer it's parent.
75          * If the node was not a child of this object no action is performed.
76          */
77
78                 void    
79         RemoveChild(
80                 SG_Node* child
81         );
82
83         /**
84          * Return true if the node is the ancestor of child
85          */
86                 bool
87         IsAncessor(
88                 const SG_Node* child
89         ) const;
90         /** 
91          * Get the current list of children. Do not use this interface for
92          * adding or removing children please use the methods of this class for
93          * that.
94          * \return a reference to the list of children of this node.
95          */
96         
97         NodeList& GetSGChildren()
98         {
99                 return this->m_children;
100         }
101
102         /**
103          * Get the current list of children.
104          * \return a const reference to the current list of children of this node.
105          */
106
107         const NodeList& GetSGChildren() const
108         {
109                 return this->m_children;
110         }
111
112         /** 
113          * Clear the list of children associated with this node
114          */
115
116         void ClearSGChildren()
117         {
118                 m_children.clear();
119         }
120
121         /**
122          * return the parent of this node if it exists.
123          */
124                 
125         SG_Node* GetSGParent() const 
126         { 
127                 return m_SGparent;
128         }
129
130         /**
131          * Set the parent of this node. 
132          */
133
134         void SetSGParent(SG_Node* parent)
135         {
136                 m_SGparent = parent;
137         }
138
139         /**
140          * Return the top node in this node's Scene graph hierarchy
141          */
142         
143         const 
144                 SG_Node* 
145         GetRootSGParent(
146         ) const;
147
148         /**
149          * Disconnect this node from it's parent
150          */
151
152                 void                            
153         DisconnectFromParent(
154         );
155
156         /**
157          * Return vertex parent status.
158          */
159         bool IsVertexParent()
160         {
161                 if (m_parent_relation)
162                 {
163                         return m_parent_relation->IsVertexRelation();
164                 }
165                 return false;
166         }
167
168
169         /**
170          * Return slow parent status.
171          */
172
173         bool IsSlowParent()
174         {
175                 if (m_parent_relation)
176                 {
177                         return m_parent_relation->IsSlowRelation();
178                 }
179                 return false;
180         }
181
182
183
184
185         /**             
186          * Update the spatial data of this node. Iterate through
187          * the children of this node and update their world data.
188          */
189
190                 void            
191         UpdateWorldData(
192                 double time,
193                 bool parentUpdated=false
194         );
195
196         /**
197          * Update the simulation time of this node. Iterate through
198          * the children nodes and update their simulated time.
199          */
200
201                 void            
202         SetSimulatedTime(
203                 double time,
204                 bool recurse
205         );
206
207         /**
208          * Schedule this node for update by placing it in head queue
209          */
210         bool Schedule(SG_QList& head)
211         {
212                 // Put top parent in front of list to make sure they are updated before their
213                 // children => the children will be udpated and removed from the list before
214                 // we get to them, should they be in the list too.
215                 return (m_SGparent)?head.AddBack(this):head.AddFront(this);
216         }
217
218         /**
219          * Used during Scenegraph update
220          */
221         static SG_Node* GetNextScheduled(SG_QList& head)
222         {
223                 return static_cast<SG_Node*>(head.Remove());
224         }
225
226         /**
227          * Make this node ready for schedule on next update. This is needed for nodes
228          * that must always be updated (slow parent, bone parent)
229          */
230         bool Reschedule(SG_QList& head)
231         {
232                 return head.QAddBack(this);
233         }
234
235         /**
236          * Used during Scenegraph update
237          */
238         static SG_Node* GetNextRescheduled(SG_QList& head)
239         {
240                 return static_cast<SG_Node*>(head.QRemove());
241         }
242
243         /**
244          * Node replication functions.
245          */
246
247                 SG_Node*        
248         GetSGReplica(
249         );
250
251                 void            
252         Destruct(
253         );
254         
255 private:
256
257                 void            
258         ProcessSGReplica(
259                 SG_Node** replica
260         );
261
262         /**
263          * The list of children of this node.
264          */
265         NodeList m_children;
266
267         /**
268          * The parent of this node may be NULL
269          */
270         SG_Node* m_SGparent;
271
272
273 #ifdef WITH_CXX_GUARDEDALLOC
274         MEM_CXX_CLASS_ALLOC_FUNCS("GE:SG_Node")
275 #endif
276 };
277
278 #endif //__SG_NODE_H__
279