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