[#19232] (2.5) Correction of cmake for windows about audio (jack and openal)
[blender.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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, 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          * Get the current list of children. Do not use this interface for
82          * adding or removing children please use the methods of this class for
83          * that.
84          * @return a reference to the list of children of this node.
85          */
86         
87         NodeList& GetSGChildren()
88         {
89                 return this->m_children;
90         }
91
92         /**
93          * Get the current list of children.
94          * @return a const reference to the current list of children of this node.
95          */
96
97         const NodeList& GetSGChildren() const
98         {
99                 return this->m_children;
100         }
101
102         /** 
103          * Clear the list of children associated with this node
104          */
105
106         void ClearSGChildren()
107         {
108                 m_children.clear();
109         }
110
111         /**
112          * return the parent of this node if it exists.
113          */
114                 
115         SG_Node* GetSGParent() const 
116         { 
117                 return m_SGparent;
118         }
119
120         /**
121          * Set the parent of this node. 
122          */
123
124         void SetSGParent(SG_Node* parent)
125         {
126                 m_SGparent = parent;
127         }
128
129         /**
130          * Return the top node in this node's Scene graph hierarchy
131          */
132         
133         const 
134                 SG_Node* 
135         GetRootSGParent(
136         ) const;
137
138         /**
139          * Disconnect this node from it's parent
140          */
141
142                 void                            
143         DisconnectFromParent(
144         );
145
146         /**
147          * Return vertex parent status.
148          */
149         bool IsVertexParent()
150         {
151                 if (m_parent_relation)
152                 {
153                         return m_parent_relation->IsVertexRelation();
154                 }
155                 return false;
156         }
157
158
159         /**
160          * Return slow parent status.
161          */
162
163         bool IsSlowParent()
164         {
165                 if (m_parent_relation)
166                 {
167                         return m_parent_relation->IsSlowRelation();
168                 }
169                 return false;
170         }
171
172
173
174
175         /**             
176          * Update the spatial data of this node. Iterate through
177          * the children of this node and update their world data.
178          */
179
180                 void            
181         UpdateWorldData(
182                 double time,
183                 bool parentUpdated=false
184         );
185
186         /**
187          * Update the simulation time of this node. Iterate through
188          * the children nodes and update their simulated time.
189          */
190
191                 void            
192         SetSimulatedTime(
193                 double time,
194                 bool recurse
195         );
196
197         /**
198          * Schedule this node for update by placing it in head queue
199          */
200         bool Schedule(SG_QList& head)
201         {
202                 // Put top parent in front of list to make sure they are updated before their
203                 // children => the children will be udpated and removed from the list before
204                 // we get to them, should they be in the list too.
205                 return (m_SGparent)?head.AddBack(this):head.AddFront(this);
206         }
207
208         /**
209          * Used during Scenegraph update
210          */
211         static SG_Node* GetNextScheduled(SG_QList& head)
212         {
213                 return static_cast<SG_Node*>(head.Remove());
214         }
215
216         /**
217          * Make this node ready for schedule on next update. This is needed for nodes
218          * that must always be updated (slow parent, bone parent)
219          */
220         bool Reschedule(SG_QList& head)
221         {
222                 return head.QAddBack(this);
223         }
224
225         /**
226          * Used during Scenegraph update
227          */
228         static SG_Node* GetNextRescheduled(SG_QList& head)
229         {
230                 return static_cast<SG_Node*>(head.QRemove());
231         }
232
233         /**
234          * Node replication functions.
235          */
236
237                 SG_Node*        
238         GetSGReplica(
239         );
240
241                 void            
242         Destruct(
243         );
244         
245 private:
246
247                 void            
248         ProcessSGReplica(
249                 SG_Node** replica
250         );
251
252         /**
253          * The list of children of this node.
254          */
255         NodeList m_children;
256
257         /**
258          * The parent of this node may be NULL
259          */
260         SG_Node* m_SGparent;
261
262
263 #ifdef WITH_CXX_GUARDEDALLOC
264 public:
265         void *operator new( unsigned int num_bytes) { return MEM_mallocN(num_bytes, "GE:SG_Node"); }
266         void operator delete( void *mem ) { MEM_freeN(mem); }
267 #endif
268 };
269
270 #endif //__SG_NODE_H
271