6b3101be34d6e105c1237cf6db45ea0760224028
[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
251
252         /**
253          * @return a pointer to the physics controller owned by this class.
254          */
255
256                 KX_IPhysicsController* 
257         GetPhysicsController(
258         ) ;
259
260         void    SetPhysicsController
261                 (KX_IPhysicsController* physicscontroller) 
262         { m_pPhysicsController1 = physicscontroller;};
263
264
265         /**
266          * @section Coordinate system manipulation functions
267          */
268
269                 void                                            
270         NodeSetLocalPosition(
271                 const MT_Point3& trans
272         );
273
274                 void                                            
275         NodeSetLocalOrientation(
276                 const MT_Matrix3x3& rot
277         );
278
279                 void                                            
280         NodeSetLocalScale(
281                 const MT_Vector3& scale
282         );
283
284                 void                                            
285         NodeSetRelativeScale(
286                 const MT_Vector3& scale
287         );
288
289                 void                                            
290         NodeUpdateGS(
291                 double time,
292                 bool bInitiator
293         );
294
295         const 
296                 MT_Matrix3x3&                   
297         NodeGetWorldOrientation(
298         ) const;
299
300         const 
301                 MT_Vector3&                     
302         NodeGetWorldScaling(
303         ) const;
304
305         const 
306                 MT_Point3&                      
307         NodeGetWorldPosition(
308         ) const;
309
310
311         /**
312          * @section scene graph node accessor functions.
313          */
314
315                 SG_Node*                                        
316         GetSGNode(
317         ) { 
318                 return m_pSGNode;
319         }
320
321         const 
322                 SG_Node*                                
323         GetSGNode(
324         ) const { 
325                 return m_pSGNode;
326         }
327
328         /**
329          * Set the Scene graph node for this game object.
330          * warning - it is your responsibility to make sure
331          * all controllers look at this new node. You must
332          * also take care of the memory associated with the
333          * old node. This class takes ownership of the new
334          * node.
335          */
336                 void                                            
337         SetSGNode(
338                 SG_Node* node
339         ){ 
340                 m_pSGNode = node; 
341         }
342         
343         /**
344          * Deprecated & broken
345          */
346                 bool                                            
347         IsDynamic(
348         ) const { 
349                 return m_bDyna; 
350         }
351         
352
353         /**
354          * @section Physics accessors for this node.
355          *
356          * All these calls get passed directly to the physics controller 
357          * owned by this object.
358          * This is real interface bloat. Why not just use the physics controller
359          * directly? I think this is because the python interface is in the wrong
360          * place.
361          */
362
363                 void                                            
364         ApplyForce(
365                 const MT_Vector3& force,        bool local
366         );
367
368                 void                                            
369         ApplyTorque(
370                 const MT_Vector3& torque,
371                 bool local
372         );
373
374                 void                                            
375         ApplyRotation(
376                 const MT_Vector3& drot,
377                 bool local
378         );
379
380                 void                                            
381         ApplyMovement(
382                 const MT_Vector3& dloc,
383                 bool local
384         );
385
386                 void                                            
387         addLinearVelocity(
388                 const MT_Vector3& lin_vel,
389                 bool local
390         );
391
392                 void                                            
393         setLinearVelocity(
394                 const MT_Vector3& lin_vel,
395                 bool local
396         );
397
398                 void                                            
399         setAngularVelocity(
400                 const MT_Vector3& ang_vel,
401                 bool local
402         );
403
404         /**     
405          * Update the physics object transform based upon the current SG_Node
406          * position.
407          */
408                 void                                            
409         UpdateTransform(
410         );
411
412         /**
413          * Only update the transform if it's a non-dynamic object
414          */
415                 void 
416         UpdateNonDynas(
417         );
418
419         /**
420          * Odd function to update an ipo. ???
421          */ 
422                 void    
423         UpdateIPO(
424                 float curframetime,
425                 bool resurse, 
426                 bool ipo_as_force,
427                 bool force_ipo_local
428         );
429
430         /**
431          * @section Mesh accessor functions.
432          */
433         
434         /**     
435          * Run through the meshes associated with this
436          * object and bucketize them. See RAS_Mesh for
437          * more details on this function. Interesting to 
438          * note that polygon bucketizing seems to happen on a per
439          * object basis. Which may explain why there is such
440          * a big performance gain when all static objects
441          * are joined into 1.
442          */
443                 void                                            
444         Bucketize(
445         );
446
447         /**
448          * Clear the meshes associated with this class
449          * and remove from the bucketing system.
450          * Don't think this actually deletes any of the meshes.
451          */
452                 void                                            
453         RemoveMeshes(
454         );
455
456         /**
457          * Add a mesh to the set of meshes associated with this
458          * node. Meshes added in this way are not deleted by this class.
459          * Make sure you call RemoveMeshes() before deleting the
460          * mesh though,
461          */
462                 void                                            
463         AddMesh(
464                 RAS_MeshObject* mesh
465         ){ 
466                 m_meshes.push_back(mesh);
467         }
468
469         /**
470          * Pick out a mesh associated with the integer 'num'.
471          */
472                 RAS_MeshObject*                         
473         GetMesh(
474                 int num
475         ) const { 
476                 return m_meshes[num]; 
477         }
478
479         /**
480          * Return the number of meshes currently associated with this
481          * game object.
482          */
483                 int                                                     
484         GetMeshCount(
485         ) const { 
486                 return m_meshes.size(); 
487         }
488         
489         /**     
490          * Set the debug color of the meshes associated with this
491          * class. Does this still work?
492          */
493                 void                                            
494         SetDebugColor(
495                 unsigned int bgra
496         );
497
498         /** 
499          * Reset the debug color of meshes associated with this class.
500          */
501                 void                                            
502         ResetDebugColor(
503         );
504
505         /** 
506          * Set the visibility of the meshes associated with this
507          * object.
508          */
509                 void                                            
510         MarkVisible(
511                 bool visible
512         );
513
514         /** 
515          * Set the visibility according to the visibility flag.
516          */
517                 void                                            
518         MarkVisible(
519                 void
520         );
521
522                 
523         /**
524          * Was this object marked visible? (only for the ewxplicit
525          * visibility system).
526          */
527                 bool
528         GetVisible(
529                 void
530         );
531
532         /**
533          * Set visibility flag of this object
534          */
535                 void
536         SetVisible(
537                 bool b
538         );
539
540                 
541         /**
542          * @section Logic bubbling methods.
543          */
544
545         /**
546          * Stop making progress
547          */
548         void Suspend(void);
549
550         /**
551          * Resume making progress
552          */
553         void Resume(void);
554         
555         KX_ClientObjectInfo* getClientInfo() { return m_pClient_info; }
556         /**
557          * @section Python interface functions.
558          */
559
560         virtual 
561                 PyObject*                       
562         _getattr(
563                 char *attr
564         );
565
566                 PyObject*                                       
567         PySetPosition(
568                 PyObject* self,
569                 PyObject* args,
570                 PyObject* kwds
571         );
572
573         static 
574                 PyObject*                       
575         sPySetPosition(
576                 PyObject* self,
577                 PyObject* args,
578                 PyObject* kwds
579         );
580         
581         KX_PYMETHOD(KX_GameObject,GetPosition);
582         KX_PYMETHOD(KX_GameObject,GetLinearVelocity);
583         KX_PYMETHOD(KX_GameObject,GetVelocity);
584         KX_PYMETHOD(KX_GameObject,GetMass);
585         KX_PYMETHOD(KX_GameObject,GetReactionForce);
586         KX_PYMETHOD(KX_GameObject,GetOrientation);
587         KX_PYMETHOD(KX_GameObject,SetOrientation);
588         KX_PYMETHOD(KX_GameObject,SetVisible);
589         KX_PYMETHOD(KX_GameObject,SuspendDynamics);
590         KX_PYMETHOD(KX_GameObject,RestoreDynamics);
591         KX_PYMETHOD(KX_GameObject,EnableRigidBody);
592         KX_PYMETHOD(KX_GameObject,DisableRigidBody);
593         KX_PYMETHOD(KX_GameObject,ApplyImpulse);
594         KX_PYMETHOD(KX_GameObject,GetMesh);
595         KX_PYMETHOD(KX_GameObject,GetParent);
596         KX_PYMETHOD(KX_GameObject,GetPhysicsId);
597
598 private :
599
600         /**     
601          * Random internal function to convert python function arguments
602          * to 2 vectors.
603          * @return true if conversion was possible.
604          */
605
606                 bool                                            
607         ConvertPythonVectorArgs(
608                 PyObject* args,
609                 MT_Vector3& pos,
610                 MT_Vector3& pos2
611         );      
612
613 };
614
615 #endif //__KX_GAMEOBJECT
616