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