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