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