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