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