Created a KX_SoftBodyDeformer for real-time soft bodies.
[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 #include "KX_KetsjiEngine.h" /* for m_anim_framerate */
49 #include "KX_IPhysicsController.h" /* for suspend/resume */
50 #include "DNA_object_types.h"
51 #include "SCA_LogicManager.h" /* for ConvertPythonToGameObject to search object names */
52 #define KX_OB_DYNAMIC 1
53
54
55 //Forward declarations.
56 struct KX_ClientObjectInfo;
57 class KX_RayCast;
58 class RAS_MeshObject;
59 class KX_IPhysicsController;
60 class PHY_IPhysicsEnvironment;
61 struct Object;
62
63 /**
64  * KX_GameObject is the main class for dynamic objects.
65  */
66 class KX_GameObject : public SCA_IObject
67 {
68         Py_Header;
69 protected:
70
71         bool                                                            m_bDyna;
72         KX_ClientObjectInfo*                            m_pClient_info;
73         STR_String                                                      m_name;
74         STR_String                                                      m_text;
75         int                                                                     m_layer;
76         std::vector<RAS_MeshObject*>            m_meshes;
77         struct Object*                                          m_pBlenderObject;
78         struct Object*                                          m_pBlenderGroupObject;
79         
80         bool                                                            m_bSuspendDynamics;
81         bool                                                            m_bUseObjectColor;
82         bool                                                            m_bIsNegativeScaling;
83         MT_Vector4                                                      m_objectColor;
84
85         // visible = user setting
86         // culled = while rendering, depending on camera
87         bool                                                            m_bVisible; 
88         bool                                                            m_bCulled; 
89
90         KX_IPhysicsController*                          m_pPhysicsController1;
91         // used for ray casting
92         PHY_IPhysicsEnvironment*                        m_pPhysicsEnvironment;
93         STR_String                                                      m_testPropName;
94         bool                                                            m_xray;
95         KX_GameObject*                                          m_pHitObject;
96
97         SG_Node*                                                        m_pSGNode;
98
99         MT_CmMatrix4x4                                          m_OpenGL_4x4Matrix;
100         
101 public:
102         bool                                                            m_isDeformable;
103
104         virtual void    /* This function should be virtual - derived classed override it */
105         Relink(
106                 GEN_Map<GEN_HashedPtr, void*> *map
107         );
108
109         /**
110          * Compute an OpenGl compatable 4x4 matrix. Has the
111          * side effect of storing the result internally. The
112          * memory for the matrix remains the property of this class.
113          */ 
114                 double*                                         
115         GetOpenGLMatrix(
116         );
117
118         /**
119          * Return a pointer to a MT_CmMatrix4x4 storing the 
120          * opengl transformation for this object. This is updated
121          * by a call to GetOpenGLMatrix(). This class owns the 
122          * memory for the returned matrix.
123          */
124
125                 MT_CmMatrix4x4*                         
126         GetOpenGLMatrixPtr(
127         ) { 
128                 return &m_OpenGL_4x4Matrix;
129         };
130
131         /** 
132          * Get a pointer to the game object that is the parent of 
133          * this object. Or NULL if there is no parent. The returned
134          * object is part of a reference counting scheme. Calling
135          * this function ups the reference count on the returned 
136          * object. It is the responsibility of the caller to decrement
137          * the reference count when you have finished with it.
138          */
139                 KX_GameObject*                          
140         GetParent(
141         );
142
143         /** 
144          * Sets the parent of this object to a game object
145          */                     
146         void SetParent(KX_Scene *scene, KX_GameObject *obj);
147
148         /** 
149          * Removes the parent of this object to a game object
150          */                     
151         void RemoveParent(KX_Scene *scene);
152
153         /**
154          * Construct a game object. This class also inherits the 
155          * default constructors - use those with care!
156          */
157
158         KX_GameObject(
159                 void* sgReplicationInfo,
160                 SG_Callbacks callbacks,
161                 PyTypeObject* T=&Type
162         );
163
164         virtual 
165         ~KX_GameObject(
166         );
167
168                 CValue*                         
169         AddRef() { 
170                 /* temporarily to find memleaks */ return CValue::AddRef(); 
171         }
172
173         /** 
174          * @section Stuff which is here due to poor design.
175          * Inherited from CValue and needs an implementation. 
176          * Do not expect these functions do to anything sensible.
177          */
178
179         /**
180          * Inherited from CValue -- does nothing!
181          */
182                 CValue*                         
183         Calc(
184                 VALUE_OPERATOR op,
185                 CValue *val
186         );
187
188         /**
189          * Inherited from CValue -- does nothing!
190          */
191                 CValue*                         
192         CalcFinal(
193                 VALUE_DATA_TYPE dtype,
194                 VALUE_OPERATOR op,
195                 CValue *val
196         );
197
198         /**
199          * Inherited from CValue -- does nothing!
200          */
201         const 
202                 STR_String &    
203         GetText(
204         );
205
206         /**
207          * Inherited from CValue -- does nothing!
208          */
209                 float                           
210         GetNumber(
211         );
212
213         /**
214          * @section Inherited from CValue. These are the useful
215          * part of the CValue interface that this class implements. 
216          */
217
218         /**
219          * Inherited from CValue -- returns the name of this object.
220          */
221                 STR_String                      
222         GetName(
223         );
224
225         /**
226          * Inherited from CValue -- set the name of this object.
227          */
228                 void                            
229         SetName(
230                 STR_String name
231         );
232
233         /**
234          * Inherited from CValue -- does nothing.
235          */
236                 void                            
237         ReplicaSetName(
238                 STR_String name
239         );
240
241         /** 
242          * Inherited from CValue -- return a new copy of this
243          * instance allocated on the heap. Ownership of the new 
244          * object belongs with the caller.
245          */
246         virtual CValue*                         
247         GetReplica(
248         );
249         
250         /**
251          * Inherited from CValue -- Makes sure any internal 
252          * data owned by this class is deep copied. Called internally
253          */
254         virtual void                            
255         ProcessReplica(
256                 KX_GameObject* replica
257         );
258
259         /** 
260          * Return the linear velocity of the game object.
261          */
262                 MT_Vector3 
263         GetLinearVelocity(
264                 bool local=false
265         );
266
267         /**
268          * Return the mass of the object
269          */
270                 MT_Scalar       
271         GetMass();
272
273         /** 
274          * Return the angular velocity of the game object.
275          */
276                 MT_Vector3 
277         GetAngularVelocity(
278                 bool local=false
279         );
280
281         /** 
282          * Align the object to a given normal.
283          */
284                 void 
285         AlignAxisToVect(
286                 const MT_Vector3& vect,
287                 int axis = 2,
288                 float fac = 1.0
289         );
290
291         /** 
292          * Quick'n'dirty obcolor ipo stuff
293          */
294
295                 void                            
296         SetObjectColor(
297                 const MT_Vector4& rgbavec
298         );
299
300
301                 void 
302         ResolveCombinedVelocities(
303                 const MT_Vector3 & lin_vel,
304                 const MT_Vector3 & ang_vel,
305                 bool lin_vel_local,
306                 bool ang_vel_local
307         );
308
309
310         /**
311          * @return a pointer to the physics environment in use during the game, for rayCasting
312          */
313         PHY_IPhysicsEnvironment* GetPhysicsEnvironment()
314         {
315                 return m_pPhysicsEnvironment;
316         }
317
318         void SetPhysicsEnvironment(PHY_IPhysicsEnvironment* physicsEnvironment)
319         {
320                 m_pPhysicsEnvironment = physicsEnvironment;
321         }
322
323         /**
324          * @return a pointer to the physics controller owned by this class.
325          */
326
327         KX_IPhysicsController* GetPhysicsController() ;
328
329         void    SetPhysicsController(KX_IPhysicsController*     physicscontroller,bool isDynamic) 
330         { 
331                 m_bDyna = isDynamic;
332                 m_pPhysicsController1 = physicscontroller;
333         }
334
335         virtual class RAS_Deformer* GetDeformer()
336         {
337                 return 0;
338         }
339         virtual void    SetDeformer(class RAS_Deformer* deformer)
340         {
341
342         }
343
344         /**
345          * @section Coordinate system manipulation functions
346          */
347
348         void    NodeSetLocalPosition(const MT_Point3& trans     );
349
350         void    NodeSetLocalOrientation(const MT_Matrix3x3& rot );
351
352         void    NodeSetLocalScale(      const MT_Vector3& scale );
353
354         void    NodeSetRelativeScale(   const MT_Vector3& scale );
355
356         // adapt local position so that world position is set to desired position
357         void    NodeSetWorldPosition(const MT_Point3& trans);
358
359                 void                                            
360         NodeUpdateGS(
361                 double time,
362                 bool bInitiator
363         );
364
365         const 
366                 MT_Matrix3x3&                   
367         NodeGetWorldOrientation(
368         ) const;
369
370         const 
371                 MT_Vector3&                     
372         NodeGetWorldScaling(
373         ) const;
374
375         const 
376                 MT_Point3&                      
377         NodeGetWorldPosition(
378         ) const;
379
380
381         /**
382          * @section scene graph node accessor functions.
383          */
384
385         SG_Node*        GetSGNode(      ) 
386         { 
387                 return m_pSGNode;
388         }
389
390         const   SG_Node* GetSGNode(     ) const 
391         { 
392                 return m_pSGNode;
393         }
394
395         /**
396          * @section blender object accessor functions.
397          */
398
399         struct Object* GetBlenderObject( )
400         {
401                 return m_pBlenderObject;
402         }
403
404         void SetBlenderObject( struct Object* obj)
405         {
406                 m_pBlenderObject = obj;
407         }
408
409         struct Object* GetBlenderGroupObject( )
410         {
411                 return m_pBlenderGroupObject;
412         }
413
414         void SetBlenderGroupObject( struct Object* obj)
415         {
416                 m_pBlenderGroupObject = obj;
417         }
418         
419         bool IsDupliGroup()
420         { 
421                 return (m_pBlenderObject &&
422                                 (m_pBlenderObject->transflag & OB_DUPLIGROUP) &&
423                                 m_pBlenderObject->dup_group != NULL) ? true : false;
424         }
425
426         /**
427          * Set the Scene graph node for this game object.
428          * warning - it is your responsibility to make sure
429          * all controllers look at this new node. You must
430          * also take care of the memory associated with the
431          * old node. This class takes ownership of the new
432          * node.
433          */
434                 void    SetSGNode(SG_Node* node )
435                 { 
436                         m_pSGNode = node; 
437                 }
438         
439         //Is it a dynamic/physics object ?
440         bool    IsDynamic() const 
441         { 
442                 return m_bDyna; 
443         }
444
445         /**
446          * Check if this object has a vertex parent relationship
447          */
448         bool IsVertexParent( )
449         {
450                 return (m_pSGNode && m_pSGNode->GetSGParent() && m_pSGNode->GetSGParent()->IsVertexParent());
451         }
452
453         bool RayHit(KX_ClientObjectInfo* client, KX_RayCast* result, void * const data);
454         bool NeedRayCast(KX_ClientObjectInfo* client);
455
456
457         /**
458          * @section Physics accessors for this node.
459          *
460          * All these calls get passed directly to the physics controller 
461          * owned by this object.
462          * This is real interface bloat. Why not just use the physics controller
463          * directly? I think this is because the python interface is in the wrong
464          * place.
465          */
466
467                 void                                            
468         ApplyForce(
469                 const MT_Vector3& force,        bool local
470         );
471
472                 void                                            
473         ApplyTorque(
474                 const MT_Vector3& torque,
475                 bool local
476         );
477
478                 void                                            
479         ApplyRotation(
480                 const MT_Vector3& drot,
481                 bool local
482         );
483
484                 void                                            
485         ApplyMovement(
486                 const MT_Vector3& dloc,
487                 bool local
488         );
489
490                 void                                            
491         addLinearVelocity(
492                 const MT_Vector3& lin_vel,
493                 bool local
494         );
495
496                 void                                            
497         setLinearVelocity(
498                 const MT_Vector3& lin_vel,
499                 bool local
500         );
501
502                 void                                            
503         setAngularVelocity(
504                 const MT_Vector3& ang_vel,
505                 bool local
506         );
507
508         /**     
509          * Update the physics object transform based upon the current SG_Node
510          * position.
511          */
512                 void
513         UpdateTransform(
514         );
515
516         static void UpdateTransformFunc(SG_IObject* node, void* gameobj, void* scene);
517
518         /**
519          * Only update the transform if it's a non-dynamic object
520          */
521                 void 
522         UpdateNonDynas(
523         );
524
525         /**
526          * Function to set IPO option at start of IPO
527          */ 
528                 void    
529         InitIPO(
530                 bool ipo_as_force,
531                 bool ipo_add,
532                 bool ipo_local
533         );
534
535         /**
536          * Odd function to update an ipo. ???
537          */ 
538                 void    
539         UpdateIPO(
540                 float curframetime,
541                 bool recurse
542         );
543         /**
544          * Updates Material Ipo data 
545          */
546                 void 
547         UpdateMaterialData(
548                 dword matname_hash,
549                 MT_Vector4 rgba,
550                 MT_Vector3 specrgb,
551                 MT_Scalar hard,
552                 MT_Scalar spec,
553                 MT_Scalar ref,
554                 MT_Scalar emit,
555                 MT_Scalar alpha
556         );
557
558         /**
559          * @section Mesh accessor functions.
560          */
561
562         /**     
563          * Update buckets to indicate that there is a new
564          * user of this object's meshes.
565          */
566                 void                                            
567         AddMeshUser(
568         );
569         
570         /**     
571          * Update buckets with data about the mesh after
572          * creating or duplicating the object, changing
573          * visibility, object color, .. .
574          */
575                 void                                            
576         UpdateBuckets(
577                 bool recursive
578         );
579
580         /**
581          * Clear the meshes associated with this class
582          * and remove from the bucketing system.
583          * Don't think this actually deletes any of the meshes.
584          */
585                 void                                            
586         RemoveMeshes(
587         );
588
589         /**
590          * Add a mesh to the set of meshes associated with this
591          * node. Meshes added in this way are not deleted by this class.
592          * Make sure you call RemoveMeshes() before deleting the
593          * mesh though,
594          */
595                 void                                            
596         AddMesh(
597                 RAS_MeshObject* mesh
598         ){ 
599                 m_meshes.push_back(mesh);
600         }
601
602         /**
603          * Pick out a mesh associated with the integer 'num'.
604          */
605                 RAS_MeshObject*                         
606         GetMesh(
607                 int num
608         ) const { 
609                 return m_meshes[num]; 
610         }
611
612         /**
613          * Return the number of meshes currently associated with this
614          * game object.
615          */
616                 int                                                     
617         GetMeshCount(
618         ) const { 
619                 return m_meshes.size(); 
620         }
621         
622         /**     
623          * Set the debug color of the meshes associated with this
624          * class. Does this still work?
625          */
626                 void                                            
627         SetDebugColor(
628                 unsigned int bgra
629         );
630
631         /** 
632          * Reset the debug color of meshes associated with this class.
633          */
634                 void                                            
635         ResetDebugColor(
636         );
637
638         /**
639          * Was this object marked visible? (only for the explicit
640          * visibility system).
641          */
642                 bool
643         GetVisible(
644                 void
645         );
646
647         /**
648          * Set visibility flag of this object
649          */
650                 void
651         SetVisible(
652                 bool b,
653                 bool recursive
654         );
655
656         /**
657          * Was this object culled?
658          */
659                 bool
660         GetCulled(
661                 void
662         );
663
664         /**
665          * Set culled flag of this object
666          */
667                 void
668         SetCulled(
669                 bool c
670         );
671
672         /**
673          * Change the layer of the object (when it is added in another layer
674          * than the original layer)
675          */
676                 void
677         SetLayer(
678                 int l
679         );
680
681         /**
682          * Get the object layer
683          */
684                 int
685         GetLayer(
686                 void
687         );
688                 
689         /**
690          * Get the negative scaling state
691          */
692                 bool
693         IsNegativeScaling(
694                 void
695         ) { return m_bIsNegativeScaling; }
696
697         /**
698          * Is this a light?
699          */
700                 virtual bool
701         IsLight(
702                 void
703         ) { return false; }
704
705         /**
706          * @section Logic bubbling methods.
707          */
708
709         /**
710          * Stop making progress
711          */
712         void Suspend(void);
713
714         /**
715          * Resume making progress
716          */
717         void Resume(void);
718         
719         void SuspendDynamics(void) {
720                 if (m_bSuspendDynamics)
721                 {
722                         return;
723                 }
724         
725                 if (m_pPhysicsController1)
726                 {
727                         m_pPhysicsController1->SuspendDynamics();
728                 }
729                 m_bSuspendDynamics = true;
730         }
731         
732         void RestoreDynamics(void) {    
733                 if (!m_bSuspendDynamics)
734                 {
735                         return;
736                 }
737         
738                 if (m_pPhysicsController1)
739                 {
740                         m_pPhysicsController1->RestoreDynamics();
741                 }
742                 m_bSuspendDynamics = false;
743         }
744         
745         KX_ClientObjectInfo* getClientInfo() { return m_pClient_info; }
746         /**
747          * @section Python interface functions.
748          */
749
750         virtual 
751                 PyObject*                       
752         _getattr(
753                 const STR_String& attr
754         );
755  
756         virtual 
757                 int 
758         _setattr(
759                 const STR_String& attr, 
760                 PyObject *value
761         );              // _setattr method
762
763         KX_PYMETHOD_NOARGS(KX_GameObject,GetPosition);
764         KX_PYMETHOD_O(KX_GameObject,SetPosition);
765         KX_PYMETHOD_O(KX_GameObject,SetWorldPosition);
766         KX_PYMETHOD_VARARGS(KX_GameObject,GetLinearVelocity);
767         KX_PYMETHOD_VARARGS(KX_GameObject,SetLinearVelocity);
768         KX_PYMETHOD_VARARGS(KX_GameObject,GetAngularVelocity);
769         KX_PYMETHOD_VARARGS(KX_GameObject,SetAngularVelocity);
770         KX_PYMETHOD_VARARGS(KX_GameObject,GetVelocity);
771         KX_PYMETHOD_NOARGS(KX_GameObject,GetMass);
772         KX_PYMETHOD_NOARGS(KX_GameObject,GetReactionForce);
773         KX_PYMETHOD_NOARGS(KX_GameObject,GetOrientation);
774         KX_PYMETHOD_O(KX_GameObject,SetOrientation);
775         KX_PYMETHOD_NOARGS(KX_GameObject,GetVisible);
776         KX_PYMETHOD_VARARGS(KX_GameObject,SetVisible);
777         KX_PYMETHOD_NOARGS(KX_GameObject,GetState);
778         KX_PYMETHOD_O(KX_GameObject,SetState);
779         KX_PYMETHOD_VARARGS(KX_GameObject,AlignAxisToVect);
780         KX_PYMETHOD_O(KX_GameObject,GetAxisVect);
781         KX_PYMETHOD_NOARGS(KX_GameObject,SuspendDynamics);
782         KX_PYMETHOD_NOARGS(KX_GameObject,RestoreDynamics);
783         KX_PYMETHOD_NOARGS(KX_GameObject,EnableRigidBody);
784         KX_PYMETHOD_NOARGS(KX_GameObject,DisableRigidBody);
785         KX_PYMETHOD_VARARGS(KX_GameObject,ApplyImpulse);
786         KX_PYMETHOD_O(KX_GameObject,SetCollisionMargin);
787         KX_PYMETHOD_NOARGS(KX_GameObject,GetParent);
788         KX_PYMETHOD_O(KX_GameObject,SetParent);
789         KX_PYMETHOD_NOARGS(KX_GameObject,RemoveParent);
790         KX_PYMETHOD_NOARGS(KX_GameObject,GetChildren);  
791         KX_PYMETHOD_NOARGS(KX_GameObject,GetChildrenRecursive);
792         KX_PYMETHOD_VARARGS(KX_GameObject,GetMesh);
793         KX_PYMETHOD_NOARGS(KX_GameObject,GetPhysicsId);
794         KX_PYMETHOD_NOARGS(KX_GameObject,GetPropertyNames);
795         KX_PYMETHOD_NOARGS(KX_GameObject,EndObject);
796         KX_PYMETHOD_DOC(KX_GameObject,rayCastTo);
797         KX_PYMETHOD_DOC(KX_GameObject,rayCast);
798         KX_PYMETHOD_DOC(KX_GameObject,getDistanceTo);
799         KX_PYMETHOD_DOC(KX_GameObject,getVectTo);
800         
801 private :
802
803         /**     
804          * Random internal function to convert python function arguments
805          * to 2 vectors.
806          * @return true if conversion was possible.
807          */
808
809                 bool                                            
810         ConvertPythonVectorArgs(
811                 PyObject* args,
812                 MT_Vector3& pos,
813                 MT_Vector3& pos2
814         );      
815
816 };
817
818 /* utility conversion function */
819 bool ConvertPythonToGameObject(PyObject * value, KX_GameObject **object, bool py_none_ok);
820
821 #endif //__KX_GAMEOBJECT
822