[#19232] (2.5) Correction of cmake for windows about audio (jack and openal)
[blender.git] / source / gameengine / SceneGraph / SG_Spatial.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
30 #ifndef __SG_SPATIAL_H
31 #define __SG_SPATIAL_H
32
33 #include <MT_Vector3.h>
34 #include <MT_Point3.h>
35 #include <MT_Matrix3x3.h> // or Quaternion later ?
36 #include "SG_IObject.h"
37 #include "SG_BBox.h"
38 #include "SG_ParentRelation.h"
39
40
41 class SG_Node;
42 class SG_ParentRelation;
43
44 /**
45  * SG_Spatial contains spatial information (local & world position, rotation 
46  * and scaling) for a Scene graph node.
47  * It also contains a link to the node's parent.
48  */
49 class SG_Spatial : public SG_IObject
50 {
51
52 protected:
53         MT_Point3               m_localPosition;
54         MT_Matrix3x3            m_localRotation;
55         MT_Vector3              m_localScaling;
56
57         MT_Point3               m_worldPosition;
58         MT_Matrix3x3            m_worldRotation;
59         MT_Vector3              m_worldScaling;
60         
61         SG_ParentRelation *     m_parent_relation;
62         
63         SG_BBox                 m_bbox;
64         MT_Scalar               m_radius;
65         bool                    m_modified;
66         bool                    m_ogldirty;             // true if the openGL matrix for this object must be recomputed
67
68 public:
69         inline void ClearModified() 
70         { 
71                 m_modified = false; 
72                 m_ogldirty = true;
73         }
74         inline void SetModified()
75         {
76                 m_modified = true;
77                 ActivateScheduleUpdateCallback();
78         }
79         inline void ClearDirty()
80         {
81                 m_ogldirty = false;
82         }
83         /** 
84          * Define the realtionship this node has with it's parent
85          * node. You should pass an unshared instance of an SG_ParentRelation
86          * allocated on the heap to this method. Ownership of this
87          * instance is assumed by this class. 
88          * You may call this function several times in the lifetime 
89          * of a node to change the relationship dynamically. 
90          * You must call this method before the first call to UpdateSpatialData().
91          * An assertion willl be fired at run-time in debug if this is not 
92          * the case.
93          * The relation is activated only if no controllers of this object
94          * updated the coordinates of the child.
95          */
96
97                 void
98         SetParentRelation(
99                 SG_ParentRelation *relation
100         );
101         
102         SG_ParentRelation * GetParentRelation()
103         {
104                 return m_parent_relation;
105         }
106
107
108
109
110         /**
111          * Apply a translation relative to the current position.
112          * if local then the translation is assumed to be in the 
113          * local coordinates of this object. If not then the translation
114          * is assumed to be in global coordinates. In this case 
115          * you must provide a pointer to the parent of this object if it 
116          * exists otherwise if there is no parent set it to NULL
117          */ 
118
119                 void
120         RelativeTranslate(
121                 const MT_Vector3& trans,
122                 const SG_Spatial *parent,
123                 bool local
124         );
125
126         void SetLocalPosition(const MT_Point3& trans)
127         {
128                 m_localPosition = trans;
129                 SetModified();
130         }
131
132         void SetWorldPosition(const MT_Point3& trans)
133         {
134                 m_worldPosition = trans;
135         }
136
137         
138                 void                            
139         RelativeRotate(
140                 const MT_Matrix3x3& rot,
141                 bool local
142         );
143
144         void SetLocalOrientation(const MT_Matrix3x3& rot)
145         {
146                 m_localRotation = rot;
147                 SetModified();
148         }
149
150         // rot is arrange like openGL matrix
151         void SetLocalOrientation(const float* rot)
152         {
153                 m_localRotation.setValue(rot);
154                 SetModified();
155         }
156
157         void SetWorldOrientation(const MT_Matrix3x3& rot) 
158         {
159                 m_worldRotation = rot;
160         }
161
162         void RelativeScale(const MT_Vector3& scale)
163         {
164                 m_localScaling = m_localScaling * scale;
165                 SetModified();
166         }
167
168         void SetLocalScale(const MT_Vector3& scale)
169         {
170                 m_localScaling = scale;
171                 SetModified();
172         }
173
174         void SetWorldScale(const MT_Vector3& scale)
175         { 
176                 m_worldScaling = scale;
177         }
178
179         const MT_Point3& GetLocalPosition() const       
180         {
181                 return m_localPosition;
182         }
183
184         const MT_Matrix3x3& GetLocalOrientation() const 
185         {
186                 return m_localRotation;
187         }
188
189         const MT_Vector3& GetLocalScale() const
190         {
191                 return m_localScaling;
192         }
193
194         const MT_Point3& GetWorldPosition() const       
195         {
196                 return m_worldPosition;
197         }
198
199         const MT_Matrix3x3&     GetWorldOrientation() const     
200         {
201                 return m_worldRotation;
202         }
203
204         const MT_Vector3& GetWorldScaling() const       
205         {
206                 return m_worldScaling;
207         }
208
209         void SetWorldFromLocalTransform()
210         {
211                 m_worldPosition= m_localPosition;
212                 m_worldScaling= m_localScaling;
213                 m_worldRotation= m_localRotation;
214         }
215
216
217
218         MT_Transform GetWorldTransform() const;
219
220         bool    ComputeWorldTransforms(const SG_Spatial *parent, bool& parentUpdated)
221         {
222                 return m_parent_relation->UpdateChildCoordinates(this,parent,parentUpdated);
223         }
224
225
226         /**
227          * Bounding box functions.
228          */
229         SG_BBox& BBox()
230         {
231                 return m_bbox;
232         }
233
234         void SetBBox(SG_BBox& bbox)
235         {
236                 m_bbox = bbox;
237         }
238
239
240         bool inside(const MT_Point3 &point) const;
241         void getBBox(MT_Point3 *box) const;
242         void getAABBox(MT_Point3 *box) const;
243         
244         MT_Scalar Radius() const { return m_radius; }
245         void SetRadius(MT_Scalar radius) { m_radius = radius; }
246         bool IsModified() { return m_modified; }
247         bool IsDirty() { return m_ogldirty; }
248         
249 protected:
250         friend class SG_Controller;
251         friend class KX_BoneParentRelation;
252         friend class KX_VertexParentRelation;
253         friend class KX_SlowParentRelation;
254         friend class KX_NormalParentRelation;
255         
256         /** 
257          * Protected constructor this class is not
258          * designed for direct instantiation
259          */
260
261         SG_Spatial(
262                 void* clientobj,
263                 void* clientinfo,
264                 SG_Callbacks& callbacks
265         );
266
267         SG_Spatial(
268                 const SG_Spatial& other
269         );
270
271
272         virtual ~SG_Spatial();
273
274         /** 
275          * Update the world coordinates of this spatial node. This also informs
276          * any controllers to update this object. 
277          */ 
278
279                 bool 
280         UpdateSpatialData(
281                 const SG_Spatial *parent,
282                 double time,
283                 bool& parentUpdated
284         );
285
286
287 #ifdef WITH_CXX_GUARDEDALLOC
288 public:
289         void *operator new( unsigned int num_bytes) { return MEM_mallocN(num_bytes, "GE:SG_Spatial"); }
290         void operator delete( void *mem ) { MEM_freeN(mem); }
291 #endif
292 };
293
294 #endif //__SG_SPATIAL_H
295