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