NLA SoC: Merge from 2.5
[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 //Forward declarations.
55 struct KX_ClientObjectInfo;
56 class KX_RayCast;
57 class RAS_MeshObject;
58 class KX_IPhysicsController;
59 class PHY_IGraphicController;
60 class PHY_IPhysicsEnvironment;
61 struct Object;
62
63 /* utility conversion function */
64 bool ConvertPythonToGameObject(PyObject * value, KX_GameObject **object, bool py_none_ok, const char *error_prefix);
65
66 /**
67  * KX_GameObject is the main class for dynamic objects.
68  */
69 class KX_GameObject : public SCA_IObject
70 {
71         Py_Header;
72 protected:
73
74         bool                                                            m_bDyna;
75         KX_ClientObjectInfo*                            m_pClient_info;
76         STR_String                                                      m_name;
77         STR_String                                                      m_text;
78         int                                                                     m_layer;
79         std::vector<RAS_MeshObject*>            m_meshes;
80         SG_QList                                                        m_meshSlots;    // head of mesh slots of this 
81         struct Object*                                          m_pBlenderObject;
82         struct Object*                                          m_pBlenderGroupObject;
83         
84         bool                                                            m_bSuspendDynamics;
85         bool                                                            m_bUseObjectColor;
86         bool                                                            m_bIsNegativeScaling;
87         MT_Vector4                                                      m_objectColor;
88
89         // visible = user setting
90         // culled = while rendering, depending on camera
91         bool                                                            m_bVisible; 
92         bool                                                            m_bCulled; 
93         bool                                                            m_bOccluder;
94
95         KX_IPhysicsController*                          m_pPhysicsController1;
96         PHY_IGraphicController*                         m_pGraphicController;
97         // used for ray casting
98         PHY_IPhysicsEnvironment*                        m_pPhysicsEnvironment;
99         STR_String                                                      m_testPropName;
100         bool                                                            m_xray;
101         KX_GameObject*                                          m_pHitObject;
102
103         SG_Node*                                                        m_pSGNode;
104
105         MT_CmMatrix4x4                                          m_OpenGL_4x4Matrix;
106         
107 public:
108         bool                                                            m_isDeformable;
109
110         /**
111          * Helper function for modules that can't include KX_ClientObjectInfo.h
112          */
113         static KX_GameObject* GetClientObject(KX_ClientObjectInfo* info);
114
115         // Python attributes that wont convert into CValue
116         // 
117         // there are 2 places attributes can be stored, in the CValue,
118         // where attributes are converted into BGE's CValue types
119         // these can be used with property actuators
120         //
121         // For the python API, For types that cannot be converted into CValues (lists, dicts, GameObjects)
122         // these will be put into "m_attr_dict", logic bricks cannot access them.
123         // 
124         // rules for setting attributes.
125         // 
126         // * there should NEVER be a CValue and a m_attr_dict attribute with matching names. get/sets make sure of this.
127         // * if CValue conversion fails, use a PyObject in "m_attr_dict"
128         // * when assigning a value, first see if it can be a CValue, if it can remove the "m_attr_dict" and set the CValue
129         // 
130         PyObject*                                                       m_attr_dict; 
131
132         virtual void    /* This function should be virtual - derived classed override it */
133         Relink(
134                 GEN_Map<GEN_HashedPtr, void*> *map
135         );
136
137         /**
138          * Compute an OpenGl compatable 4x4 matrix. Has the
139          * side effect of storing the result internally. The
140          * memory for the matrix remains the property of this class.
141          */ 
142                 double*                                         
143         GetOpenGLMatrix(
144         );
145
146         /**
147          * Return a pointer to a MT_CmMatrix4x4 storing the 
148          * opengl transformation for this object. This is updated
149          * by a call to GetOpenGLMatrix(). This class owns the 
150          * memory for the returned matrix.
151          */
152
153                 MT_CmMatrix4x4*                         
154         GetOpenGLMatrixPtr(
155         ) { 
156                 return &m_OpenGL_4x4Matrix;
157         };
158
159         /** 
160          * Get a pointer to the game object that is the parent of 
161          * this object. Or NULL if there is no parent. The returned
162          * object is part of a reference counting scheme. Calling
163          * this function ups the reference count on the returned 
164          * object. It is the responsibility of the caller to decrement
165          * the reference count when you have finished with it.
166          */
167                 KX_GameObject*                          
168         GetParent(
169         );
170
171         /** 
172          * Sets the parent of this object to a game object
173          */                     
174         void SetParent(KX_Scene *scene, KX_GameObject *obj, bool addToCompound=true, bool ghost=true);
175
176         /** 
177          * Removes the parent of this object to a game object
178          */                     
179         void RemoveParent(KX_Scene *scene);
180
181         /**
182          * Construct a game object. This class also inherits the 
183          * default constructors - use those with care!
184          */
185
186         KX_GameObject(
187                 void* sgReplicationInfo,
188                 SG_Callbacks callbacks
189         );
190
191         virtual 
192         ~KX_GameObject(
193         );
194
195         /** 
196          * @section Stuff which is here due to poor design.
197          * Inherited from CValue and needs an implementation. 
198          * Do not expect these functions do to anything sensible.
199          */
200
201         /**
202          * Inherited from CValue -- does nothing!
203          */
204                 CValue*                         
205         Calc(
206                 VALUE_OPERATOR op,
207                 CValue *val
208         );
209
210         /**
211          * Inherited from CValue -- does nothing!
212          */
213                 CValue*                         
214         CalcFinal(
215                 VALUE_DATA_TYPE dtype,
216                 VALUE_OPERATOR op,
217                 CValue *val
218         );
219
220         /**
221          * Inherited from CValue -- does nothing!
222          */
223         const 
224                 STR_String &    
225         GetText(
226         );
227
228         /**
229          * Inherited from CValue -- does nothing!
230          */
231                 double
232         GetNumber(
233         );
234
235         /**
236          * @section Inherited from CValue. These are the useful
237          * part of the CValue interface that this class implements. 
238          */
239
240         /**
241          * Inherited from CValue -- returns the name of this object.
242          */
243                 STR_String&                     
244         GetName(
245         );
246
247         /**
248          * Inherited from CValue -- set the name of this object.
249          */
250                 void                            
251         SetName(
252                 const char *name
253         );
254
255         /** 
256          * Inherited from CValue -- return a new copy of this
257          * instance allocated on the heap. Ownership of the new 
258          * object belongs with the caller.
259          */
260         virtual CValue*                         
261         GetReplica(
262         );
263         
264         /**
265          * Inherited from CValue -- Makes sure any internal 
266          * data owned by this class is deep copied. Called internally
267          */
268         virtual void                            
269         ProcessReplica();
270
271         /** 
272          * Return the linear velocity of the game object.
273          */
274                 MT_Vector3 
275         GetLinearVelocity(
276                 bool local=false
277         );
278
279         /** 
280          * Return the linear velocity of a given point in world coordinate
281          * but relative to center of object ([0,0,0]=center of object)
282          */
283                 MT_Vector3 
284         GetVelocity(
285                 const MT_Point3& position
286         );
287
288         /**
289          * Return the mass of the object
290          */
291                 MT_Scalar       
292         GetMass();
293
294         /**
295          * Return the local inertia vector of the object
296          */
297                 MT_Vector3
298         GetLocalInertia();
299
300         /** 
301          * Return the angular velocity of the game object.
302          */
303                 MT_Vector3 
304         GetAngularVelocity(
305                 bool local=false
306         );
307
308         /** 
309          * Align the object to a given normal.
310          */
311                 void 
312         AlignAxisToVect(
313                 const MT_Vector3& vect,
314                 int axis = 2,
315                 float fac = 1.0
316         );
317
318         /** 
319          * Quick'n'dirty obcolor ipo stuff
320          */
321
322                 void                            
323         SetObjectColor(
324                 const MT_Vector4& rgbavec
325         );
326
327
328                 void 
329         ResolveCombinedVelocities(
330                 const MT_Vector3 & lin_vel,
331                 const MT_Vector3 & ang_vel,
332                 bool lin_vel_local,
333                 bool ang_vel_local
334         );
335
336
337         /**
338          * @return a pointer to the physics environment in use during the game, for rayCasting
339          */
340         PHY_IPhysicsEnvironment* GetPhysicsEnvironment()
341         {
342                 return m_pPhysicsEnvironment;
343         }
344
345         void SetPhysicsEnvironment(PHY_IPhysicsEnvironment* physicsEnvironment)
346         {
347                 m_pPhysicsEnvironment = physicsEnvironment;
348         }
349
350         /**
351          * @return a pointer to the physics controller owned by this class.
352          */
353
354         KX_IPhysicsController* GetPhysicsController() ;
355
356         void    SetPhysicsController(KX_IPhysicsController*     physicscontroller,bool isDynamic) 
357         { 
358                 m_bDyna = isDynamic;
359                 m_pPhysicsController1 = physicscontroller;
360         }
361
362         virtual class RAS_Deformer* GetDeformer()
363         {
364                 return 0;
365         }
366         virtual void    SetDeformer(class RAS_Deformer* deformer)
367         {
368
369         }
370
371         /**
372          * @return a pointer to the graphic controller owner by this class 
373          */
374         PHY_IGraphicController* GetGraphicController()
375         {
376                 return m_pGraphicController;
377         }
378
379         void SetGraphicController(PHY_IGraphicController* graphiccontroller) 
380         { 
381                 m_pGraphicController = graphiccontroller;
382         }
383         /*
384          * @add/remove the graphic controller to the physic system
385          */
386         void ActivateGraphicController(bool recurse);
387
388         /**
389          * @section Coordinate system manipulation functions
390          */
391
392         void    NodeSetLocalPosition(const MT_Point3& trans     );
393
394         void    NodeSetLocalOrientation(const MT_Matrix3x3& rot );
395         void    NodeSetGlobalOrientation(const MT_Matrix3x3& rot        );
396
397         void    NodeSetLocalScale(      const MT_Vector3& scale );
398
399         void    NodeSetRelativeScale(   const MT_Vector3& scale );
400
401         // adapt local position so that world position is set to desired position
402         void    NodeSetWorldPosition(const MT_Point3& trans);
403
404                 void                                            
405         NodeUpdateGS(
406                 double time
407         );
408
409         const MT_Matrix3x3& NodeGetWorldOrientation(  ) const;
410         const MT_Vector3& NodeGetWorldScaling(  ) const;
411         const MT_Point3& NodeGetWorldPosition(  ) const;
412
413         const MT_Matrix3x3& NodeGetLocalOrientation(  ) const;
414         const MT_Vector3& NodeGetLocalScaling(  ) const;
415         const MT_Point3& NodeGetLocalPosition(  ) const;
416
417         /**
418          * @section scene graph node accessor functions.
419          */
420
421         SG_Node*        GetSGNode(      ) 
422         { 
423                 return m_pSGNode;
424         }
425
426         const   SG_Node* GetSGNode(     ) const 
427         { 
428                 return m_pSGNode;
429         }
430
431         /**
432          * @section blender object accessor functions.
433          */
434
435         struct Object* GetBlenderObject( )
436         {
437                 return m_pBlenderObject;
438         }
439
440         void SetBlenderObject( struct Object* obj)
441         {
442                 m_pBlenderObject = obj;
443         }
444
445         struct Object* GetBlenderGroupObject( )
446         {
447                 return m_pBlenderGroupObject;
448         }
449
450         void SetBlenderGroupObject( struct Object* obj)
451         {
452                 m_pBlenderGroupObject = obj;
453         }
454         
455         bool IsDupliGroup()
456         { 
457                 return (m_pBlenderObject &&
458                                 (m_pBlenderObject->transflag & OB_DUPLIGROUP) &&
459                                 m_pBlenderObject->dup_group != NULL) ? true : false;
460         }
461
462         /**
463          * Set the Scene graph node for this game object.
464          * warning - it is your responsibility to make sure
465          * all controllers look at this new node. You must
466          * also take care of the memory associated with the
467          * old node. This class takes ownership of the new
468          * node.
469          */
470                 void    SetSGNode(SG_Node* node )
471                 { 
472                         m_pSGNode = node; 
473                 }
474         
475         //Is it a dynamic/physics object ?
476         bool    IsDynamic() const 
477         { 
478                 return m_bDyna; 
479         }
480
481         /**
482          * Check if this object has a vertex parent relationship
483          */
484         bool IsVertexParent( )
485         {
486                 return (m_pSGNode && m_pSGNode->GetSGParent() && m_pSGNode->GetSGParent()->IsVertexParent());
487         }
488
489         bool RayHit(KX_ClientObjectInfo* client, KX_RayCast* result, void * const data);
490         bool NeedRayCast(KX_ClientObjectInfo* client);
491
492
493         /**
494          * @section Physics accessors for this node.
495          *
496          * All these calls get passed directly to the physics controller 
497          * owned by this object.
498          * This is real interface bloat. Why not just use the physics controller
499          * directly? I think this is because the python interface is in the wrong
500          * place.
501          */
502
503                 void                                            
504         ApplyForce(
505                 const MT_Vector3& force,        bool local
506         );
507
508                 void                                            
509         ApplyTorque(
510                 const MT_Vector3& torque,
511                 bool local
512         );
513
514                 void                                            
515         ApplyRotation(
516                 const MT_Vector3& drot,
517                 bool local
518         );
519
520                 void                                            
521         ApplyMovement(
522                 const MT_Vector3& dloc,
523                 bool local
524         );
525
526                 void                                            
527         addLinearVelocity(
528                 const MT_Vector3& lin_vel,
529                 bool local
530         );
531
532                 void                                            
533         setLinearVelocity(
534                 const MT_Vector3& lin_vel,
535                 bool local
536         );
537
538                 void                                            
539         setAngularVelocity(
540                 const MT_Vector3& ang_vel,
541                 bool local
542         );
543
544         /**     
545          * Update the physics object transform based upon the current SG_Node
546          * position.
547          */
548                 void
549         UpdateTransform(
550         );
551
552         static void UpdateTransformFunc(SG_IObject* node, void* gameobj, void* scene);
553
554         /**
555          * only used for sensor objects
556          */
557         void SynchronizeTransform();
558
559         static void SynchronizeTransformFunc(SG_IObject* node, void* gameobj, void* scene);
560
561         /**
562          * Function to set IPO option at start of IPO
563          */ 
564                 void    
565         InitIPO(
566                 bool ipo_as_force,
567                 bool ipo_add,
568                 bool ipo_local
569         );
570
571         /**
572          * Odd function to update an ipo. ???
573          */ 
574                 void    
575         UpdateIPO(
576                 float curframetime,
577                 bool recurse
578         );
579         /**
580          * Updates Material Ipo data 
581          */
582                 void 
583         UpdateMaterialData(
584                 dword matname_hash,
585                 MT_Vector4 rgba,
586                 MT_Vector3 specrgb,
587                 MT_Scalar hard,
588                 MT_Scalar spec,
589                 MT_Scalar ref,
590                 MT_Scalar emit,
591                 MT_Scalar alpha
592         );
593
594         /**
595          * @section Mesh accessor functions.
596          */
597
598         /**     
599          * Update buckets to indicate that there is a new
600          * user of this object's meshes.
601          */
602                 void                                            
603         AddMeshUser(
604         );
605         
606         /**     
607          * Update buckets with data about the mesh after
608          * creating or duplicating the object, changing
609          * visibility, object color, .. .
610          */
611                 void                                            
612         UpdateBuckets(
613                 bool recursive
614         );
615
616         /**
617          * Clear the meshes associated with this class
618          * and remove from the bucketing system.
619          * Don't think this actually deletes any of the meshes.
620          */
621                 void                                            
622         RemoveMeshes(
623         );
624
625         /**
626          * Add a mesh to the set of meshes associated with this
627          * node. Meshes added in this way are not deleted by this class.
628          * Make sure you call RemoveMeshes() before deleting the
629          * mesh though,
630          */
631                 void                                            
632         AddMesh(
633                 RAS_MeshObject* mesh
634         ){ 
635                 m_meshes.push_back(mesh);
636         }
637
638         /**
639          * Pick out a mesh associated with the integer 'num'.
640          */
641                 RAS_MeshObject*                         
642         GetMesh(
643                 int num
644         ) const { 
645                 return m_meshes[num]; 
646         }
647
648         /**
649          * Return the number of meshes currently associated with this
650          * game object.
651          */
652                 int                                                     
653         GetMeshCount(
654         ) const { 
655                 return m_meshes.size(); 
656         }
657         
658         /**     
659          * Set the debug color of the meshes associated with this
660          * class. Does this still work?
661          */
662                 void                                            
663         SetDebugColor(
664                 unsigned int bgra
665         );
666
667         /** 
668          * Reset the debug color of meshes associated with this class.
669          */
670                 void                                            
671         ResetDebugColor(
672         );
673
674         /**
675          * Was this object marked visible? (only for the explicit
676          * visibility system).
677          */
678                 bool
679         GetVisible(
680                 void
681         );
682
683         /**
684          * Set visibility flag of this object
685          */
686                 void
687         SetVisible(
688                 bool b,
689                 bool recursive
690         );
691
692         /**
693          * Was this object culled?
694          */
695         inline bool
696         GetCulled(
697                 void
698         ) { return m_bCulled; }
699
700         /**
701          * Set culled flag of this object
702          */
703         inline void
704         SetCulled(
705                 bool c
706         ) { m_bCulled = c; }
707         
708         /**
709          * Is this object an occluder?
710          */
711         inline bool
712         GetOccluder(
713                 void
714         ) { return m_bOccluder; }
715
716         /**
717          * Set occluder flag of this object
718          */
719         void
720         SetOccluder(
721                 bool v,
722                 bool recursive
723         );
724         
725         /**
726          * Change the layer of the object (when it is added in another layer
727          * than the original layer)
728          */
729                 void
730         SetLayer(
731                 int l
732         );
733
734         /**
735          * Get the object layer
736          */
737                 int
738         GetLayer(
739                 void
740         );
741                 
742         /**
743          * Get the negative scaling state
744          */
745                 bool
746         IsNegativeScaling(
747                 void
748         ) { return m_bIsNegativeScaling; }
749
750         /**
751          * Is this a light?
752          */
753                 virtual bool
754         IsLight(
755                 void
756         ) { return false; }
757
758         /**
759          * @section Logic bubbling methods.
760          */
761
762         /**
763          * Stop making progress
764          */
765         void Suspend(void);
766
767         /**
768          * Resume making progress
769          */
770         void Resume(void);
771         
772         void SuspendDynamics(void) {
773                 if (m_bSuspendDynamics)
774                 {
775                         return;
776                 }
777         
778                 if (m_pPhysicsController1)
779                 {
780                         m_pPhysicsController1->SuspendDynamics();
781                 }
782                 m_bSuspendDynamics = true;
783         }
784         
785         void RestoreDynamics(void) {    
786                 if (!m_bSuspendDynamics)
787                 {
788                         return;
789                 }
790         
791                 if (m_pPhysicsController1)
792                 {
793                         m_pPhysicsController1->RestoreDynamics();
794                 }
795                 m_bSuspendDynamics = false;
796         }
797         
798         KX_ClientObjectInfo* getClientInfo() { return m_pClient_info; }
799         
800         CListValue* GetChildren();
801         CListValue* GetChildrenRecursive();
802         
803         /**
804          * @section Python interface functions.
805          */
806         virtual PyObject* py_repr(void)
807         {
808                 return PyUnicode_FromString(GetName().ReadPtr());
809         }
810                 
811         KX_PYMETHOD_NOARGS(KX_GameObject,GetPosition);
812         KX_PYMETHOD_O(KX_GameObject,SetPosition);
813         KX_PYMETHOD_O(KX_GameObject,SetWorldPosition);
814         KX_PYMETHOD_VARARGS(KX_GameObject, ApplyForce);
815         KX_PYMETHOD_VARARGS(KX_GameObject, ApplyTorque);
816         KX_PYMETHOD_VARARGS(KX_GameObject, ApplyRotation);
817         KX_PYMETHOD_VARARGS(KX_GameObject, ApplyMovement);
818         KX_PYMETHOD_VARARGS(KX_GameObject,GetLinearVelocity);
819         KX_PYMETHOD_VARARGS(KX_GameObject,SetLinearVelocity);
820         KX_PYMETHOD_VARARGS(KX_GameObject,GetAngularVelocity);
821         KX_PYMETHOD_VARARGS(KX_GameObject,SetAngularVelocity);
822         KX_PYMETHOD_VARARGS(KX_GameObject,GetVelocity);
823         KX_PYMETHOD_NOARGS(KX_GameObject,GetMass);
824         KX_PYMETHOD_NOARGS(KX_GameObject,GetReactionForce);
825         KX_PYMETHOD_NOARGS(KX_GameObject,GetOrientation);
826         KX_PYMETHOD_O(KX_GameObject,SetOrientation);
827         KX_PYMETHOD_NOARGS(KX_GameObject,GetVisible);
828         KX_PYMETHOD_VARARGS(KX_GameObject,SetVisible);
829         KX_PYMETHOD_VARARGS(KX_GameObject,SetOcclusion);
830         KX_PYMETHOD_NOARGS(KX_GameObject,GetState);
831         KX_PYMETHOD_O(KX_GameObject,SetState);
832         KX_PYMETHOD_VARARGS(KX_GameObject,AlignAxisToVect);
833         KX_PYMETHOD_O(KX_GameObject,GetAxisVect);
834         KX_PYMETHOD_NOARGS(KX_GameObject,SuspendDynamics);
835         KX_PYMETHOD_NOARGS(KX_GameObject,RestoreDynamics);
836         KX_PYMETHOD_NOARGS(KX_GameObject,EnableRigidBody);
837         KX_PYMETHOD_NOARGS(KX_GameObject,DisableRigidBody);
838         KX_PYMETHOD_VARARGS(KX_GameObject,ApplyImpulse);
839         KX_PYMETHOD_O(KX_GameObject,SetCollisionMargin);
840         KX_PYMETHOD_NOARGS(KX_GameObject,GetParent);
841         KX_PYMETHOD_VARARGS(KX_GameObject,SetParent);
842         KX_PYMETHOD_NOARGS(KX_GameObject,RemoveParent);
843         KX_PYMETHOD_NOARGS(KX_GameObject,GetChildren);  
844         KX_PYMETHOD_NOARGS(KX_GameObject,GetChildrenRecursive);
845         KX_PYMETHOD_VARARGS(KX_GameObject,GetMesh);
846         KX_PYMETHOD_NOARGS(KX_GameObject,GetPhysicsId);
847         KX_PYMETHOD_NOARGS(KX_GameObject,GetPropertyNames);
848         KX_PYMETHOD_O(KX_GameObject,ReplaceMesh);
849         KX_PYMETHOD_NOARGS(KX_GameObject,EndObject);
850         KX_PYMETHOD_DOC(KX_GameObject,rayCastTo);
851         KX_PYMETHOD_DOC(KX_GameObject,rayCast);
852         KX_PYMETHOD_DOC_O(KX_GameObject,getDistanceTo);
853         KX_PYMETHOD_DOC_O(KX_GameObject,getVectTo);
854         KX_PYMETHOD_DOC_VARARGS(KX_GameObject, sendMessage);
855         
856         /* Dict access */
857         KX_PYMETHOD_VARARGS(KX_GameObject,get);
858         KX_PYMETHOD_O(KX_GameObject,has_key);
859         
860         /* attributes */
861         static PyObject*        pyattr_get_name(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
862         static PyObject*        pyattr_get_parent(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
863
864         static PyObject*        pyattr_get_mass(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
865         static int                      pyattr_set_mass(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
866         static PyObject*        pyattr_get_lin_vel_min(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
867         static int                      pyattr_set_lin_vel_min(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
868         static PyObject*        pyattr_get_lin_vel_max(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
869         static int                      pyattr_set_lin_vel_max(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
870         static PyObject*        pyattr_get_visible(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
871         static int                      pyattr_set_visible(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
872         static PyObject*        pyattr_get_worldPosition(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
873         static int                      pyattr_set_worldPosition(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
874         static PyObject*        pyattr_get_localPosition(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
875         static int                      pyattr_set_localPosition(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
876         static PyObject*        pyattr_get_localInertia(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
877         static int                      pyattr_set_localInertia(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
878         static PyObject*        pyattr_get_worldOrientation(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
879         static int                      pyattr_set_worldOrientation(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
880         static PyObject*        pyattr_get_localOrientation(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
881         static int                      pyattr_set_localOrientation(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
882         static PyObject*        pyattr_get_worldScaling(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
883         static PyObject*        pyattr_get_localScaling(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
884         static int                      pyattr_set_localScaling(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
885         static PyObject*        pyattr_get_timeOffset(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
886         static int                      pyattr_set_timeOffset(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
887         static PyObject*        pyattr_get_state(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
888         static int                      pyattr_set_state(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
889         static PyObject*        pyattr_get_meshes(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
890         static PyObject*        pyattr_get_children(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
891         static PyObject*        pyattr_get_children_recursive(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
892         static PyObject*        pyattr_get_attrDict(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
893         
894         /* Experemental! */
895         static PyObject*        pyattr_get_sensors(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
896         static PyObject*        pyattr_get_controllers(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
897         static PyObject*        pyattr_get_actuators(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
898         
899         /* getitem/setitem */
900         static PyMappingMethods Mapping;
901         static PySequenceMethods        Sequence;
902         
903 private :
904
905         /**     
906          * Random internal function to convert python function arguments
907          * to 2 vectors.
908          * @return true if conversion was possible.
909          */
910
911                 bool                                            
912         ConvertPythonVectorArgs(
913                 PyObject* args,
914                 MT_Vector3& pos,
915                 MT_Vector3& pos2
916         );      
917
918 };
919
920
921
922 #endif //__KX_GAMEOBJECT
923