merging trunk 17520:19093
[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 linear velocity of a given point in world coordinate
269          * but relative to center of object ([0,0,0]=center of object)
270          */
271                 MT_Vector3 
272         GetVelocity(
273                 const MT_Point3& position
274         );
275
276         /**
277          * Return the mass of the object
278          */
279                 MT_Scalar       
280         GetMass();
281
282         /** 
283          * Return the angular velocity of the game object.
284          */
285                 MT_Vector3 
286         GetAngularVelocity(
287                 bool local=false
288         );
289
290         /** 
291          * Align the object to a given normal.
292          */
293                 void 
294         AlignAxisToVect(
295                 const MT_Vector3& vect,
296                 int axis = 2,
297                 float fac = 1.0
298         );
299
300         /** 
301          * Quick'n'dirty obcolor ipo stuff
302          */
303
304                 void                            
305         SetObjectColor(
306                 const MT_Vector4& rgbavec
307         );
308
309
310                 void 
311         ResolveCombinedVelocities(
312                 const MT_Vector3 & lin_vel,
313                 const MT_Vector3 & ang_vel,
314                 bool lin_vel_local,
315                 bool ang_vel_local
316         );
317
318
319         /**
320          * @return a pointer to the physics environment in use during the game, for rayCasting
321          */
322         PHY_IPhysicsEnvironment* GetPhysicsEnvironment()
323         {
324                 return m_pPhysicsEnvironment;
325         }
326
327         void SetPhysicsEnvironment(PHY_IPhysicsEnvironment* physicsEnvironment)
328         {
329                 m_pPhysicsEnvironment = physicsEnvironment;
330         }
331
332         /**
333          * @return a pointer to the physics controller owned by this class.
334          */
335
336         KX_IPhysicsController* GetPhysicsController() ;
337
338         void    SetPhysicsController(KX_IPhysicsController*     physicscontroller,bool isDynamic) 
339         { 
340                 m_bDyna = isDynamic;
341                 m_pPhysicsController1 = physicscontroller;
342         }
343
344         virtual class RAS_Deformer* GetDeformer()
345         {
346                 return 0;
347         }
348         virtual void    SetDeformer(class RAS_Deformer* deformer)
349         {
350
351         }
352
353         /**
354          * @section Coordinate system manipulation functions
355          */
356
357         void    NodeSetLocalPosition(const MT_Point3& trans     );
358
359         void    NodeSetLocalOrientation(const MT_Matrix3x3& rot );
360
361         void    NodeSetLocalScale(      const MT_Vector3& scale );
362
363         void    NodeSetRelativeScale(   const MT_Vector3& scale );
364
365         // adapt local position so that world position is set to desired position
366         void    NodeSetWorldPosition(const MT_Point3& trans);
367
368                 void                                            
369         NodeUpdateGS(
370                 double time,
371                 bool bInitiator
372         );
373
374         const 
375                 MT_Matrix3x3&                   
376         NodeGetWorldOrientation(
377         ) const;
378
379         const 
380                 MT_Vector3&                     
381         NodeGetWorldScaling(
382         ) const;
383
384         const 
385                 MT_Point3&                      
386         NodeGetWorldPosition(
387         ) const;
388
389
390         /**
391          * @section scene graph node accessor functions.
392          */
393
394         SG_Node*        GetSGNode(      ) 
395         { 
396                 return m_pSGNode;
397         }
398
399         const   SG_Node* GetSGNode(     ) const 
400         { 
401                 return m_pSGNode;
402         }
403
404         /**
405          * @section blender object accessor functions.
406          */
407
408         struct Object* GetBlenderObject( )
409         {
410                 return m_pBlenderObject;
411         }
412
413         void SetBlenderObject( struct Object* obj)
414         {
415                 m_pBlenderObject = obj;
416         }
417
418         struct Object* GetBlenderGroupObject( )
419         {
420                 return m_pBlenderGroupObject;
421         }
422
423         void SetBlenderGroupObject( struct Object* obj)
424         {
425                 m_pBlenderGroupObject = obj;
426         }
427         
428         bool IsDupliGroup()
429         { 
430                 return (m_pBlenderObject &&
431                                 (m_pBlenderObject->transflag & OB_DUPLIGROUP) &&
432                                 m_pBlenderObject->dup_group != NULL) ? true : false;
433         }
434
435         /**
436          * Set the Scene graph node for this game object.
437          * warning - it is your responsibility to make sure
438          * all controllers look at this new node. You must
439          * also take care of the memory associated with the
440          * old node. This class takes ownership of the new
441          * node.
442          */
443                 void    SetSGNode(SG_Node* node )
444                 { 
445                         m_pSGNode = node; 
446                 }
447         
448         //Is it a dynamic/physics object ?
449         bool    IsDynamic() const 
450         { 
451                 return m_bDyna; 
452         }
453
454         /**
455          * Check if this object has a vertex parent relationship
456          */
457         bool IsVertexParent( )
458         {
459                 return (m_pSGNode && m_pSGNode->GetSGParent() && m_pSGNode->GetSGParent()->IsVertexParent());
460         }
461
462         bool RayHit(KX_ClientObjectInfo* client, KX_RayCast* result, void * const data);
463         bool NeedRayCast(KX_ClientObjectInfo* client);
464
465
466         /**
467          * @section Physics accessors for this node.
468          *
469          * All these calls get passed directly to the physics controller 
470          * owned by this object.
471          * This is real interface bloat. Why not just use the physics controller
472          * directly? I think this is because the python interface is in the wrong
473          * place.
474          */
475
476                 void                                            
477         ApplyForce(
478                 const MT_Vector3& force,        bool local
479         );
480
481                 void                                            
482         ApplyTorque(
483                 const MT_Vector3& torque,
484                 bool local
485         );
486
487                 void                                            
488         ApplyRotation(
489                 const MT_Vector3& drot,
490                 bool local
491         );
492
493                 void                                            
494         ApplyMovement(
495                 const MT_Vector3& dloc,
496                 bool local
497         );
498
499                 void                                            
500         addLinearVelocity(
501                 const MT_Vector3& lin_vel,
502                 bool local
503         );
504
505                 void                                            
506         setLinearVelocity(
507                 const MT_Vector3& lin_vel,
508                 bool local
509         );
510
511                 void                                            
512         setAngularVelocity(
513                 const MT_Vector3& ang_vel,
514                 bool local
515         );
516
517         /**     
518          * Update the physics object transform based upon the current SG_Node
519          * position.
520          */
521                 void
522         UpdateTransform(
523         );
524
525         static void UpdateTransformFunc(SG_IObject* node, void* gameobj, void* scene);
526
527         /**
528          * Only update the transform if it's a non-dynamic object
529          */
530                 void 
531         UpdateNonDynas(
532         );
533
534         /**
535          * Function to set IPO option at start of IPO
536          */ 
537                 void    
538         InitIPO(
539                 bool ipo_as_force,
540                 bool ipo_add,
541                 bool ipo_local
542         );
543
544         /**
545          * Odd function to update an ipo. ???
546          */ 
547                 void    
548         UpdateIPO(
549                 float curframetime,
550                 bool recurse
551         );
552         /**
553          * Updates Material Ipo data 
554          */
555                 void 
556         UpdateMaterialData(
557                 dword matname_hash,
558                 MT_Vector4 rgba,
559                 MT_Vector3 specrgb,
560                 MT_Scalar hard,
561                 MT_Scalar spec,
562                 MT_Scalar ref,
563                 MT_Scalar emit,
564                 MT_Scalar alpha
565         );
566
567         /**
568          * @section Mesh accessor functions.
569          */
570
571         /**     
572          * Update buckets to indicate that there is a new
573          * user of this object's meshes.
574          */
575                 void                                            
576         AddMeshUser(
577         );
578         
579         /**     
580          * Update buckets with data about the mesh after
581          * creating or duplicating the object, changing
582          * visibility, object color, .. .
583          */
584                 void                                            
585         UpdateBuckets(
586                 bool recursive
587         );
588
589         /**
590          * Clear the meshes associated with this class
591          * and remove from the bucketing system.
592          * Don't think this actually deletes any of the meshes.
593          */
594                 void                                            
595         RemoveMeshes(
596         );
597
598         /**
599          * Add a mesh to the set of meshes associated with this
600          * node. Meshes added in this way are not deleted by this class.
601          * Make sure you call RemoveMeshes() before deleting the
602          * mesh though,
603          */
604                 void                                            
605         AddMesh(
606                 RAS_MeshObject* mesh
607         ){ 
608                 m_meshes.push_back(mesh);
609         }
610
611         /**
612          * Pick out a mesh associated with the integer 'num'.
613          */
614                 RAS_MeshObject*                         
615         GetMesh(
616                 int num
617         ) const { 
618                 return m_meshes[num]; 
619         }
620
621         /**
622          * Return the number of meshes currently associated with this
623          * game object.
624          */
625                 int                                                     
626         GetMeshCount(
627         ) const { 
628                 return m_meshes.size(); 
629         }
630         
631         /**     
632          * Set the debug color of the meshes associated with this
633          * class. Does this still work?
634          */
635                 void                                            
636         SetDebugColor(
637                 unsigned int bgra
638         );
639
640         /** 
641          * Reset the debug color of meshes associated with this class.
642          */
643                 void                                            
644         ResetDebugColor(
645         );
646
647         /**
648          * Was this object marked visible? (only for the explicit
649          * visibility system).
650          */
651                 bool
652         GetVisible(
653                 void
654         );
655
656         /**
657          * Set visibility flag of this object
658          */
659                 void
660         SetVisible(
661                 bool b,
662                 bool recursive
663         );
664
665         /**
666          * Was this object culled?
667          */
668                 bool
669         GetCulled(
670                 void
671         );
672
673         /**
674          * Set culled flag of this object
675          */
676                 void
677         SetCulled(
678                 bool c
679         );
680
681         /**
682          * Change the layer of the object (when it is added in another layer
683          * than the original layer)
684          */
685                 void
686         SetLayer(
687                 int l
688         );
689
690         /**
691          * Get the object layer
692          */
693                 int
694         GetLayer(
695                 void
696         );
697                 
698         /**
699          * Get the negative scaling state
700          */
701                 bool
702         IsNegativeScaling(
703                 void
704         ) { return m_bIsNegativeScaling; }
705
706         /**
707          * Is this a light?
708          */
709                 virtual bool
710         IsLight(
711                 void
712         ) { return false; }
713
714         /**
715          * @section Logic bubbling methods.
716          */
717
718         /**
719          * Stop making progress
720          */
721         void Suspend(void);
722
723         /**
724          * Resume making progress
725          */
726         void Resume(void);
727         
728         void SuspendDynamics(void) {
729                 if (m_bSuspendDynamics)
730                 {
731                         return;
732                 }
733         
734                 if (m_pPhysicsController1)
735                 {
736                         m_pPhysicsController1->SuspendDynamics();
737                 }
738                 m_bSuspendDynamics = true;
739         }
740         
741         void RestoreDynamics(void) {    
742                 if (!m_bSuspendDynamics)
743                 {
744                         return;
745                 }
746         
747                 if (m_pPhysicsController1)
748                 {
749                         m_pPhysicsController1->RestoreDynamics();
750                 }
751                 m_bSuspendDynamics = false;
752         }
753         
754         KX_ClientObjectInfo* getClientInfo() { return m_pClient_info; }
755         /**
756          * @section Python interface functions.
757          */
758
759         virtual PyObject* _getattr(const char *attr);
760         virtual int _setattr(const char *attr, PyObject *value);                // _setattr method
761
762         KX_PYMETHOD_NOARGS(KX_GameObject,GetPosition);
763         KX_PYMETHOD_O(KX_GameObject,SetPosition);
764         KX_PYMETHOD_O(KX_GameObject,SetWorldPosition);
765         KX_PYMETHOD_VARARGS(KX_GameObject, ApplyForce);
766         KX_PYMETHOD_VARARGS(KX_GameObject, ApplyTorque);
767         KX_PYMETHOD_VARARGS(KX_GameObject, ApplyRotation);
768         KX_PYMETHOD_VARARGS(KX_GameObject, ApplyMovement);
769         KX_PYMETHOD_VARARGS(KX_GameObject,GetLinearVelocity);
770         KX_PYMETHOD_VARARGS(KX_GameObject,SetLinearVelocity);
771         KX_PYMETHOD_VARARGS(KX_GameObject,GetAngularVelocity);
772         KX_PYMETHOD_VARARGS(KX_GameObject,SetAngularVelocity);
773         KX_PYMETHOD_VARARGS(KX_GameObject,GetVelocity);
774         KX_PYMETHOD_NOARGS(KX_GameObject,GetMass);
775         KX_PYMETHOD_NOARGS(KX_GameObject,GetReactionForce);
776         KX_PYMETHOD_NOARGS(KX_GameObject,GetOrientation);
777         KX_PYMETHOD_O(KX_GameObject,SetOrientation);
778         KX_PYMETHOD_NOARGS(KX_GameObject,GetVisible);
779         KX_PYMETHOD_VARARGS(KX_GameObject,SetVisible);
780         KX_PYMETHOD_NOARGS(KX_GameObject,GetState);
781         KX_PYMETHOD_O(KX_GameObject,SetState);
782         KX_PYMETHOD_VARARGS(KX_GameObject,AlignAxisToVect);
783         KX_PYMETHOD_O(KX_GameObject,GetAxisVect);
784         KX_PYMETHOD_NOARGS(KX_GameObject,SuspendDynamics);
785         KX_PYMETHOD_NOARGS(KX_GameObject,RestoreDynamics);
786         KX_PYMETHOD_NOARGS(KX_GameObject,EnableRigidBody);
787         KX_PYMETHOD_NOARGS(KX_GameObject,DisableRigidBody);
788         KX_PYMETHOD_VARARGS(KX_GameObject,ApplyImpulse);
789         KX_PYMETHOD_O(KX_GameObject,SetCollisionMargin);
790         KX_PYMETHOD_NOARGS(KX_GameObject,GetParent);
791         KX_PYMETHOD_O(KX_GameObject,SetParent);
792         KX_PYMETHOD_NOARGS(KX_GameObject,RemoveParent);
793         KX_PYMETHOD_NOARGS(KX_GameObject,GetChildren);  
794         KX_PYMETHOD_NOARGS(KX_GameObject,GetChildrenRecursive);
795         KX_PYMETHOD_VARARGS(KX_GameObject,GetMesh);
796         KX_PYMETHOD_NOARGS(KX_GameObject,GetPhysicsId);
797         KX_PYMETHOD_NOARGS(KX_GameObject,GetPropertyNames);
798         KX_PYMETHOD_O(KX_GameObject,ReplaceMesh);
799         KX_PYMETHOD_NOARGS(KX_GameObject,EndObject);
800         KX_PYMETHOD_DOC(KX_GameObject,rayCastTo);
801         KX_PYMETHOD_DOC(KX_GameObject,rayCast);
802         KX_PYMETHOD_DOC_O(KX_GameObject,getDistanceTo);
803         KX_PYMETHOD_DOC_O(KX_GameObject,getVectTo);
804         
805 private :
806
807         /**     
808          * Random internal function to convert python function arguments
809          * to 2 vectors.
810          * @return true if conversion was possible.
811          */
812
813                 bool                                            
814         ConvertPythonVectorArgs(
815                 PyObject* args,
816                 MT_Vector3& pos,
817                 MT_Vector3& pos2
818         );      
819
820 };
821
822 /* utility conversion function */
823 bool ConvertPythonToGameObject(PyObject * value, KX_GameObject **object, bool py_none_ok);
824
825 #endif //__KX_GAMEOBJECT
826