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