f3bf529a37db392eaf8e7df0f07f655390bd1a63
[blender-staging.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
61
62 /**
63  * KX_GameObject is the main class for dynamic objects.
64  */
65 class KX_GameObject : public SCA_IObject
66 {
67         Py_Header;
68 protected:
69
70         bool                                                            m_bDyna;
71         KX_ClientObjectInfo*                            m_pClient_info;
72         STR_String                                                      m_name;
73         STR_String                                                      m_text;
74         std::vector<RAS_MeshObject*>            m_meshes;
75         
76         bool                                                            m_bSuspendDynamics;
77         bool                                                            m_bUseObjectColor;
78         MT_Vector4                                                      m_objectColor;
79
80         // Is this object set to be visible? Only useful for the
81         // visibility subsystem right now.
82         bool       m_bVisible; 
83
84         KX_IPhysicsController*                          m_pPhysicsController1;
85         SG_Node*                                                        m_pSGNode;
86
87         MT_CmMatrix4x4                                          m_OpenGL_4x4Matrix;
88         
89 public:
90         bool                                                            m_isDeformable;
91
92         virtual void    /* This function should be virtual - derived classed override it */
93         Relink(
94                 GEN_Map<GEN_HashedPtr, void*> *map
95         );
96
97         /**
98          * Compute an OpenGl compatable 4x4 matrix. Has the
99          * side effect of storing the result internally. The
100          * memory for the matrix remains the property of this class.
101          */ 
102                 double*                                         
103         GetOpenGLMatrix(
104         );
105
106         /**
107          * Return a pointer to a MT_CmMatrix4x4 storing the 
108          * opengl transformation for this object. This is updated
109          * by a call to GetOpenGLMatrix(). This class owns the 
110          * memory for the returned matrix.
111          */
112
113                 MT_CmMatrix4x4*                         
114         GetOpenGLMatrixPtr(
115         ) { 
116                 return &m_OpenGL_4x4Matrix;
117         };
118
119         /** 
120          * Get a pointer to the game object that is the parent of 
121          * this object. Or NULL if there is no parent. The returned
122          * object is part of a reference counting scheme. Calling
123          * this function ups the reference count on the returned 
124          * object. It is the responsibility of the caller to decrement
125          * the reference count when you have finished with it.
126          */
127                 KX_GameObject*                          
128         GetParent(
129         );
130
131
132         /**
133          * Construct a game object. This class also inherits the 
134          * default constructors - use those with care!
135          */
136
137         KX_GameObject(
138                 void* sgReplicationInfo,
139                 SG_Callbacks callbacks,
140                 PyTypeObject* T=&Type
141         );
142
143         virtual 
144         ~KX_GameObject(
145         );
146
147                 CValue*                         
148         AddRef() { 
149                 /* temporarily to find memleaks */ return CValue::AddRef(); 
150         }
151
152         /** 
153          * @section Stuff which is here due to poor design.
154          * Inherited from CValue and needs an implementation. 
155          * Do not expect these functions do to anything sensible.
156          */
157
158         /**
159          * Inherited from CValue -- does nothing!
160          */
161                 CValue*                         
162         Calc(
163                 VALUE_OPERATOR op,
164                 CValue *val
165         );
166
167         /**
168          * Inherited from CValue -- does nothing!
169          */
170                 CValue*                         
171         CalcFinal(
172                 VALUE_DATA_TYPE dtype,
173                 VALUE_OPERATOR op,
174                 CValue *val
175         );
176
177         /**
178          * Inherited from CValue -- does nothing!
179          */
180         const 
181                 STR_String &    
182         GetText(
183         );
184
185         /**
186          * Inherited from CValue -- does nothing!
187          */
188                 float                           
189         GetNumber(
190         );
191
192         /**
193          * @section Inherited from CValue. These are the useful
194          * part of the CValue interface that this class implements. 
195          */
196
197         /**
198          * Inherited from CValue -- returns the name of this object.
199          */
200                 STR_String                      
201         GetName(
202         );
203
204         /**
205          * Inherited from CValue -- set the name of this object.
206          */
207                 void                            
208         SetName(
209                 STR_String name
210         );
211
212         /**
213          * Inherited from CValue -- does nothing.
214          */
215                 void                            
216         ReplicaSetName(
217                 STR_String name
218         );
219
220         /** 
221          * Inherited from CValue -- return a new copy of this
222          * instance allocated on the heap. Ownership of the new 
223          * object belongs with the caller.
224          */
225         virtual CValue*                         
226         GetReplica(
227         );
228         
229         /**
230          * Inherited from CValue -- Makes sure any internal 
231          * data owned by this class is deep copied. Called internally
232          */
233         virtual void                            
234         ProcessReplica(
235                 KX_GameObject* replica
236         );
237
238         /** 
239          * Return the linear velocity of the game object.
240          */
241                 MT_Vector3                      
242         GetLinearVelocity(
243         );
244
245         /** 
246          * Quick'n'dirty obcolor ipo stuff
247          */
248
249                 void                            
250         SetObjectColor(
251                 const MT_Vector4& rgbavec
252         );
253
254
255                 void 
256         ResolveCombinedVelocities(
257                 const MT_Vector3 & lin_vel,
258                 const MT_Vector3 & ang_vel,
259                 bool lin_vel_local,
260                 bool ang_vel_local
261         );
262
263
264         /**
265          * @return a pointer to the physics controller owned by this class.
266          */
267
268         KX_IPhysicsController* GetPhysicsController() ;
269
270         void    SetPhysicsController(KX_IPhysicsController*     physicscontroller,bool isDynamic) 
271         { 
272                 m_bDyna = isDynamic;
273                 m_pPhysicsController1 = physicscontroller;
274         }
275
276
277         /**
278          * @section Coordinate system manipulation functions
279          */
280
281         void    NodeSetLocalPosition(const MT_Point3& trans     );
282
283         void    NodeSetLocalOrientation(const MT_Matrix3x3& rot );
284
285         void    NodeSetLocalScale(      const MT_Vector3& scale );
286
287         void    NodeSetRelativeScale(   const MT_Vector3& scale );
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*        GetSGNode(      ) 
316         { 
317                 return m_pSGNode;
318         }
319
320         const   SG_Node* GetSGNode(     ) const 
321         { 
322                 return m_pSGNode;
323         }
324
325         /**
326          * Set the Scene graph node for this game object.
327          * warning - it is your responsibility to make sure
328          * all controllers look at this new node. You must
329          * also take care of the memory associated with the
330          * old node. This class takes ownership of the new
331          * node.
332          */
333                 void    SetSGNode(SG_Node* node )
334                 { 
335                         m_pSGNode = node; 
336                 }
337         
338         //Is it a dynamic/physics object ?
339         bool    IsDynamic() const 
340         { 
341                 return m_bDyna; 
342         }
343         
344
345         /**
346          * @section Physics accessors for this node.
347          *
348          * All these calls get passed directly to the physics controller 
349          * owned by this object.
350          * This is real interface bloat. Why not just use the physics controller
351          * directly? I think this is because the python interface is in the wrong
352          * place.
353          */
354
355                 void                                            
356         ApplyForce(
357                 const MT_Vector3& force,        bool local
358         );
359
360                 void                                            
361         ApplyTorque(
362                 const MT_Vector3& torque,
363                 bool local
364         );
365
366                 void                                            
367         ApplyRotation(
368                 const MT_Vector3& drot,
369                 bool local
370         );
371
372                 void                                            
373         ApplyMovement(
374                 const MT_Vector3& dloc,
375                 bool local
376         );
377
378                 void                                            
379         addLinearVelocity(
380                 const MT_Vector3& lin_vel,
381                 bool local
382         );
383
384                 void                                            
385         setLinearVelocity(
386                 const MT_Vector3& lin_vel,
387                 bool local
388         );
389
390                 void                                            
391         setAngularVelocity(
392                 const MT_Vector3& ang_vel,
393                 bool local
394         );
395
396         /**     
397          * Update the physics object transform based upon the current SG_Node
398          * position.
399          */
400                 void
401         UpdateTransform(
402         );
403
404         static void UpdateTransformFunc(SG_IObject* node, void* gameobj, void* scene);
405
406         /**
407          * Only update the transform if it's a non-dynamic object
408          */
409                 void 
410         UpdateNonDynas(
411         );
412
413         /**
414          * Odd function to update an ipo. ???
415          */ 
416                 void    
417         UpdateIPO(
418                 float curframetime,
419                 bool resurse, 
420                 bool ipo_as_force,
421                 bool force_ipo_local
422         );
423         /**
424          * Updates Material Ipo data 
425          */
426                 void 
427         UpdateMaterialData(
428                 MT_Vector4 rgba,
429                 MT_Vector3 specrgb,
430                 MT_Scalar hard,
431                 MT_Scalar spec,
432                 MT_Scalar ref,
433                 MT_Scalar emit,
434                 MT_Scalar alpha
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          * Was this object marked visible? (only for the ewxplicit
531          * visibility system).
532          */
533                 bool
534         GetVisible(
535                 void
536         );
537
538         /**
539          * Set visibility flag of this object
540          */
541                 void
542         SetVisible(
543                 bool b
544         );
545
546                 
547         /**
548          * @section Logic bubbling methods.
549          */
550
551         /**
552          * Stop making progress
553          */
554         void Suspend(void);
555
556         /**
557          * Resume making progress
558          */
559         void Resume(void);
560         
561         KX_ClientObjectInfo* getClientInfo() { return m_pClient_info; }
562         /**
563          * @section Python interface functions.
564          */
565
566         virtual 
567                 PyObject*                       
568         _getattr(
569                 const STR_String& attr
570         );
571  
572         virtual 
573                 int 
574         _setattr(
575                 const STR_String& attr, 
576                 PyObject *value
577         );              // _setattr method
578
579                 PyObject*                                       
580         PySetPosition(
581                 PyObject* self,
582                 PyObject* args,
583                 PyObject* kwds
584         );
585
586         static 
587                 PyObject*                       
588         sPySetPosition(
589                 PyObject* self,
590                 PyObject* args,
591                 PyObject* kwds
592         );
593         
594         KX_PYMETHOD(KX_GameObject,GetPosition);
595         KX_PYMETHOD(KX_GameObject,GetLinearVelocity);
596         KX_PYMETHOD(KX_GameObject,GetVelocity);
597         KX_PYMETHOD(KX_GameObject,GetMass);
598         KX_PYMETHOD(KX_GameObject,GetReactionForce);
599         KX_PYMETHOD(KX_GameObject,GetOrientation);
600         KX_PYMETHOD(KX_GameObject,SetOrientation);
601         KX_PYMETHOD(KX_GameObject,SetVisible);
602         KX_PYMETHOD(KX_GameObject,SuspendDynamics);
603         KX_PYMETHOD(KX_GameObject,RestoreDynamics);
604         KX_PYMETHOD(KX_GameObject,EnableRigidBody);
605         KX_PYMETHOD(KX_GameObject,DisableRigidBody);
606         KX_PYMETHOD(KX_GameObject,ApplyImpulse);
607         KX_PYMETHOD(KX_GameObject,SetCollisionMargin);
608         KX_PYMETHOD(KX_GameObject,GetMesh);
609         KX_PYMETHOD(KX_GameObject,GetParent);
610         KX_PYMETHOD(KX_GameObject,GetPhysicsId);
611         KX_PYMETHOD_DOC(KX_GameObject,getDistanceTo);
612 private :
613
614         /**     
615          * Random internal function to convert python function arguments
616          * to 2 vectors.
617          * @return true if conversion was possible.
618          */
619
620                 bool                                            
621         ConvertPythonVectorArgs(
622                 PyObject* args,
623                 MT_Vector3& pos,
624                 MT_Vector3& pos2
625         );      
626
627 };
628
629 #endif //__KX_GAMEOBJECT
630