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