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