fixed spacing in the headers to get rid of some warnings and some other
[blender.git] / source / gameengine / Ketsji / KX_GameObject.h
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL/BL DUAL 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. The Blender
10  * Foundation also sells licenses for use in proprietary software under
11  * the Blender License.  See http://www.blender.org/BL/ for information
12  * about this.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22  *
23  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
24  * All rights reserved.
25  *
26  * The Original Code is: all of this file.
27  *
28  * Contributor(s): none yet.
29  *
30  * ***** END GPL/BL DUAL LICENSE BLOCK *****
31  * General KX game object.
32  */
33
34 #ifndef __KX_GAMEOBJECT
35 #define __KX_GAMEOBJECT
36
37
38 #ifdef WIN32
39 // get rid of this stupid "warning 'this' used in initialiser list", generated by VC when including Solid/Sumo
40 #pragma warning (disable : 4355) 
41 #endif 
42
43
44 #include "ListValue.h"
45 #include "SCA_IObject.h"
46 #include "SG_Node.h"
47 #include "MT_Transform.h"
48 #include "MT_CmMatrix4x4.h"
49 #include "GEN_Map.h"
50 #include "GEN_HashedPtr.h"
51
52 #define KX_FIXED_FRAME_PER_SEC 25.0f
53 #define KX_FIXED_SEC_PER_FRAME (1.0f / KX_FIXED_FRAME_PER_SEC)
54 #define KX_OB_DYNAMIC 1
55
56
57 //Forward declarations.
58 struct KX_ClientObjectInfo;
59 class RAS_MeshObject;
60 class KX_IPhysicsController;
61 class SM_Object;
62
63 class KX_GameObject : public SCA_IObject
64 {
65         Py_Header;
66
67         bool                                                            m_bDyna;
68         KX_ClientObjectInfo*                            m_pClient_info;
69         STR_String                                                      m_name;
70         STR_String                                                      m_text;
71         std::vector<RAS_MeshObject*>            m_meshes;
72         
73         bool                                                            m_bSuspendDynamics;
74         bool                                                            m_bUseObjectColor;
75         MT_Vector4                                                      m_objectColor;
76
77         // Is this object set to be visible? Only useful for the
78         // visibility subsystem right now.
79         bool       m_bVisible; 
80
81         KX_IPhysicsController*                          m_pPhysicsController1;
82         SG_Node*                                                        m_pSGNode;
83
84 protected:
85         MT_CmMatrix4x4                                          m_OpenGL_4x4Matrix;
86         
87 public:
88         virtual void    /* This function should be virtual - derived classed override it */
89         Relink(
90                 GEN_Map<GEN_HashedPtr, void*> *map
91         );
92
93         /**
94          * Compute an OpenGl compatable 4x4 matrix. Has the
95          * side effect of storing the result internally. The
96          * memory for the matrix remains the property of this class.
97          */ 
98                 double*                                         
99         GetOpenGLMatrix(
100         );
101
102         /**
103          * Return a pointer to a MT_CmMatrix4x4 storing the 
104          * opengl transformation for this object. This is updated
105          * by a call to GetOpenGLMatrix(). This class owns the 
106          * memory for the returned matrix.
107          */
108
109                 MT_CmMatrix4x4*                         
110         GetOpenGLMatrixPtr(
111         ) { 
112                 return &m_OpenGL_4x4Matrix;
113         };
114
115         /** 
116          * Get a pointer to the game object that is the parent of 
117          * this object. Or NULL if there is no parent. The returned
118          * object is part of a reference counting scheme. Calling
119          * this function ups the reference count on the returned 
120          * object. It is the responsibility of the caller to decrement
121          * the reference count when you have finished with it.
122          */
123                 KX_GameObject*                          
124         GetParent(
125         );
126
127
128         /**
129          * Construct a game object. This class also inherits the 
130          * default constructors - use those with care!
131          */
132
133         KX_GameObject(
134                 void* sgReplicationInfo,
135                 SG_Callbacks callbacks,
136                 PyTypeObject* T=&Type
137         );
138
139         virtual 
140         ~KX_GameObject(
141         );
142
143                 CValue*                         
144         AddRef() { 
145                 /* temporarily to find memleaks */ return CValue::AddRef(); 
146         }
147
148         /** 
149          * @section Stuff which is here due to poor design.
150          * Inherited from CValue and needs an implementation. 
151          * Do not expect these functions do to anything sensible.
152          */
153
154         /**
155          * Inherited from CValue -- does nothing!
156          */
157                 CValue*                         
158         Calc(
159                 VALUE_OPERATOR op,
160                 CValue *val
161         );
162
163         /**
164          * Inherited from CValue -- does nothing!
165          */
166                 CValue*                         
167         CalcFinal(
168                 VALUE_DATA_TYPE dtype,
169                 VALUE_OPERATOR op,
170                 CValue *val
171         );
172
173         /**
174          * Inherited from CValue -- does nothing!
175          */
176         const 
177                 STR_String &    
178         GetText(
179         );
180
181         /**
182          * Inherited from CValue -- does nothing!
183          */
184                 float                           
185         GetNumber(
186         );
187
188         /**
189          * @section Inherited from CValue. These are the useful
190          * part of the CValue interface that this class implements. 
191          */
192
193         /**
194          * Inherited from CValue -- returns the name of this object.
195          */
196                 STR_String                      
197         GetName(
198         );
199
200         /**
201          * Inherited from CValue -- set the name of this object.
202          */
203                 void                            
204         SetName(
205                 STR_String name
206         );
207
208         /**
209          * Inherited from CValue -- does nothing.
210          */
211                 void                            
212         ReplicaSetName(
213                 STR_String name
214         );
215
216         /** 
217          * Inherited from CValue -- return a new copy of this
218          * instance allocated on the heap. Ownership of the new 
219          * object belongs with the caller.
220          */
221                 CValue*                         
222         GetReplica(
223         );
224         
225         /**
226          * Inherited from CValue -- Makes sure any internal 
227          * data owned by this class is deep copied. Called internally
228          */
229                 void                            
230         ProcessReplica(
231                 KX_GameObject* replica
232         );
233
234         /** 
235          * Return the linear velocity of the game object.
236          */
237                 MT_Vector3                      
238         GetLinearVelocity(
239         );
240
241         /** 
242          * Quick'n'dirty obcolor ipo stuff
243          */
244
245                 void                            
246         SetObjectColor(
247                 const MT_Vector4& rgbavec
248         );
249
250
251
252
253         /**
254          * @return a pointer to the physics controller owned by this class.
255          */
256
257                 KX_IPhysicsController* 
258         GetPhysicsController(
259         ) ;
260
261         void    SetPhysicsController
262                 (KX_IPhysicsController* physicscontroller) 
263         { m_pPhysicsController1 = physicscontroller;};
264
265
266         /**
267          * @section Coordinate system manipulation functions
268          */
269
270                 void                                            
271         NodeSetLocalPosition(
272                 const MT_Point3& trans
273         );
274
275                 void                                            
276         NodeSetLocalOrientation(
277                 const MT_Matrix3x3& rot
278         );
279
280                 void                                            
281         NodeSetLocalScale(
282                 const MT_Vector3& scale
283         );
284
285                 void                                            
286         NodeSetRelativeScale(
287                 const MT_Vector3& scale
288         );
289
290                 void                                            
291         NodeUpdateGS(
292                 double time,
293                 bool bInitiator
294         );
295
296         const 
297                 MT_Matrix3x3&                   
298         NodeGetWorldOrientation(
299         ) const;
300
301         const 
302                 MT_Vector3&                     
303         NodeGetWorldScaling(
304         ) const;
305
306         const 
307                 MT_Point3&                      
308         NodeGetWorldPosition(
309         ) const;
310
311
312         /**
313          * @section scene graph node accessor functions.
314          */
315
316                 SG_Node*                                        
317         GetSGNode(
318         ) { 
319                 return m_pSGNode;
320         }
321
322         const 
323                 SG_Node*                                
324         GetSGNode(
325         ) const { 
326                 return m_pSGNode;
327         }
328
329         /**
330          * Set the Scene graph node for this game object.
331          * warning - it is your responsibility to make sure
332          * all controllers look at this new node. You must
333          * also take care of the memory associated with the
334          * old node. This class takes ownership of the new
335          * node.
336          */
337                 void                                            
338         SetSGNode(
339                 SG_Node* node
340         ){ 
341                 m_pSGNode = node; 
342         }
343         
344                 bool                                            
345         IsDynamic(
346         ) const { 
347                 return m_bDyna; 
348         }
349         
350
351         /**
352          * @section Physics accessors for this node.
353          *
354          * All these calls get passed directly to the physics controller 
355          * owned by this object.
356          * This is real interface bloat. Why not just use the physics controller
357          * directly? I think this is because the python interface is in the wrong
358          * place.
359          */
360
361                 void                                            
362         ApplyForce(
363                 const MT_Vector3& force,        bool local
364         );
365
366                 void                                            
367         ApplyTorque(
368                 const MT_Vector3& torque,
369                 bool local
370         );
371
372                 void                                            
373         ApplyRotation(
374                 const MT_Vector3& drot,
375                 bool local
376         );
377
378                 void                                            
379         ApplyMovement(
380                 const MT_Vector3& dloc,
381                 bool local
382         );
383
384                 void                                            
385         addLinearVelocity(
386                 const MT_Vector3& lin_vel,
387                 bool local
388         );
389
390                 void                                            
391         setLinearVelocity(
392                 const MT_Vector3& lin_vel,
393                 bool local
394         );
395
396                 void                                            
397         setAngularVelocity(
398                 const MT_Vector3& ang_vel,
399                 bool local
400         );
401
402         /**     
403          * Update the physics object transform based upon the current SG_Node
404          * position.
405          */
406                 void                                            
407         UpdateTransform(
408         );
409
410         /**
411          * Only update the transform if it's a non-dynamic object
412          */
413                 void 
414         UpdateNonDynas(
415         );
416
417         /**
418          * Odd function to update an ipo. ???
419          */ 
420                 void    
421         UpdateIPO(
422                 float curframetime,
423                 bool resurse, 
424                 bool ipo_as_force,
425                 bool force_ipo_local
426         );
427
428         /**
429          * @section Mesh accessor functions.
430          */
431         
432         /**     
433          * Run through the meshes associated with this
434          * object and bucketize them. See RAS_Mesh for
435          * more details on this function. Interesting to 
436          * note that polygon bucketizing seems to happen on a per
437          * object basis. Which may explain why there is such
438          * a big performance gain when all static objects
439          * are joined into 1.
440          */
441                 void                                            
442         Bucketize(
443         );
444
445         /**
446          * Clear the meshes associated with this class
447          * and remove from the bucketing system.
448          * Don't think this actually deletes any of the meshes.
449          */
450                 void                                            
451         RemoveMeshes(
452         );
453
454         /**
455          * Add a mesh to the set of meshes associated with this
456          * node. Meshes added in this way are not deleted by this class.
457          * Make sure you call RemoveMeshes() before deleting the
458          * mesh though,
459          */
460                 void                                            
461         AddMesh(
462                 RAS_MeshObject* mesh
463         ){ 
464                 m_meshes.push_back(mesh);
465         }
466
467         /**
468          * Pick out a mesh associated with the integer 'num'.
469          */
470                 RAS_MeshObject*                         
471         GetMesh(
472                 int num
473         ) const { 
474                 return m_meshes[num]; 
475         }
476
477         /**
478          * Return the number of meshes currently associated with this
479          * game object.
480          */
481                 int                                                     
482         GetMeshCount(
483         ) const { 
484                 return m_meshes.size(); 
485         }
486         
487         /**     
488          * Set the debug color of the meshes associated with this
489          * class. Does this still work?
490          */
491                 void                                            
492         SetDebugColor(
493                 unsigned int bgra
494         );
495
496         /** 
497          * Reset the debug color of meshes associated with this class.
498          */
499                 void                                            
500         ResetDebugColor(
501         );
502
503         /** 
504          * Set the visibility of the meshes associated with this
505          * object.
506          */
507                 void                                            
508         MarkVisible(
509                 bool visible
510         );
511
512         /** 
513          * Set the visibility according to the visibility flag.
514          */
515                 void                                            
516         MarkVisible(
517                 void
518         );
519
520                 
521         /**
522          * Was this object marked visible? (only for the ewxplicit
523          * visibility system).
524          */
525                 bool
526         GetVisible(
527                 void
528         );
529
530         /**
531          * Set visibility flag of this object
532          */
533                 void
534         SetVisible(
535                 bool b
536         );
537
538                 
539         /**
540          * @section Logic bubbling methods.
541          */
542
543         /**
544          * Stop making progress
545          */
546         void Suspend(void);
547
548         /**
549          * Resume making progress
550          */
551         void Resume(void);
552         
553         /**
554          * @section Python interface functions.
555          */
556
557         virtual 
558                 PyObject*                       
559         _getattr(
560                 char *attr
561         );
562
563                 PyObject*                                       
564         PySetPosition(
565                 PyObject* self,
566                 PyObject* args,
567                 PyObject* kwds
568         );
569
570         static 
571                 PyObject*                       
572         sPySetPosition(
573                 PyObject* self,
574                 PyObject* args,
575                 PyObject* kwds
576         );
577         
578         KX_PYMETHOD(KX_GameObject,GetPosition);
579         KX_PYMETHOD(KX_GameObject,GetLinearVelocity);
580         KX_PYMETHOD(KX_GameObject,GetVelocity);
581         KX_PYMETHOD(KX_GameObject,GetMass);
582         KX_PYMETHOD(KX_GameObject,GetReactionForce);
583         KX_PYMETHOD(KX_GameObject,GetOrientation);
584         KX_PYMETHOD(KX_GameObject,SetOrientation);
585         KX_PYMETHOD(KX_GameObject,SetVisible);
586         KX_PYMETHOD(KX_GameObject,SuspendDynamics);
587         KX_PYMETHOD(KX_GameObject,RestoreDynamics);
588         KX_PYMETHOD(KX_GameObject,EnableRigidBody);
589         KX_PYMETHOD(KX_GameObject,DisableRigidBody);
590         KX_PYMETHOD(KX_GameObject,ApplyImpulse);
591         KX_PYMETHOD(KX_GameObject,GetMesh);
592         KX_PYMETHOD(KX_GameObject,GetParent);
593         KX_PYMETHOD(KX_GameObject,GetPhysicsId);
594
595 private :
596
597         /**     
598          * Random internal function to convert python function arguments
599          * to 2 vectors.
600          * @return true if conversion was possible.
601          */
602
603                 bool                                            
604         ConvertPythonVectorArgs(
605                 PyObject* args,
606                 MT_Vector3& pos,
607                 MT_Vector3& pos2
608         );      
609
610 };
611
612 #endif //__KX_GAMEOBJECT
613