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