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