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