Merge of itasc branch. Project files, scons and cmake should be working. Makefile...
[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          * Update the blender object obmat field from the object world position
163          * if blendobj is NULL, update the object pointed by m_pBlenderObject
164          * The user must take action to restore the matrix before leaving the GE.
165          * Used in Armature evaluation
166          */
167                 void
168         UpdateBlenderObjectMatrix(Object* blendobj=NULL);
169
170         /** 
171          * Get a pointer to the game object that is the parent of 
172          * this object. Or NULL if there is no parent. The returned
173          * object is part of a reference counting scheme. Calling
174          * this function ups the reference count on the returned 
175          * object. It is the responsibility of the caller to decrement
176          * the reference count when you have finished with it.
177          */
178                 KX_GameObject*                          
179         GetParent(
180         );
181
182         /** 
183          * Sets the parent of this object to a game object
184          */                     
185         void SetParent(KX_Scene *scene, KX_GameObject *obj, bool addToCompound=true, bool ghost=true);
186
187         /** 
188          * Removes the parent of this object to a game object
189          */                     
190         void RemoveParent(KX_Scene *scene);
191
192         /**
193          * Construct a game object. This class also inherits the 
194          * default constructors - use those with care!
195          */
196
197         KX_GameObject(
198                 void* sgReplicationInfo,
199                 SG_Callbacks callbacks
200         );
201
202         virtual 
203         ~KX_GameObject(
204         );
205
206         /** 
207          * @section Stuff which is here due to poor design.
208          * Inherited from CValue and needs an implementation. 
209          * Do not expect these functions do to anything sensible.
210          */
211
212         /**
213          * Inherited from CValue -- does nothing!
214          */
215                 CValue*                         
216         Calc(
217                 VALUE_OPERATOR op,
218                 CValue *val
219         );
220
221         /**
222          * Inherited from CValue -- does nothing!
223          */
224                 CValue*                         
225         CalcFinal(
226                 VALUE_DATA_TYPE dtype,
227                 VALUE_OPERATOR op,
228                 CValue *val
229         );
230
231         /**
232          * Inherited from CValue -- does nothing!
233          */
234         const 
235                 STR_String &    
236         GetText(
237         );
238
239         /**
240          * Inherited from CValue -- does nothing!
241          */
242                 double
243         GetNumber(
244         );
245
246         /**
247          * @section Inherited from CValue. These are the useful
248          * part of the CValue interface that this class implements. 
249          */
250
251         /**
252          * Inherited from CValue -- returns the name of this object.
253          */
254                 STR_String&                     
255         GetName(
256         );
257
258         /**
259          * Inherited from CValue -- set the name of this object.
260          */
261                 void                            
262         SetName(
263                 const char *name
264         );
265
266         /** 
267          * Inherited from CValue -- return a new copy of this
268          * instance allocated on the heap. Ownership of the new 
269          * object belongs with the caller.
270          */
271         virtual CValue*                         
272         GetReplica(
273         );
274         
275         /**
276          * Inherited from CValue -- Makes sure any internal 
277          * data owned by this class is deep copied. Called internally
278          */
279         virtual void                            
280         ProcessReplica();
281
282         /** 
283          * Return the linear velocity of the game object.
284          */
285                 MT_Vector3 
286         GetLinearVelocity(
287                 bool local=false
288         );
289
290         /** 
291          * Return the linear velocity of a given point in world coordinate
292          * but relative to center of object ([0,0,0]=center of object)
293          */
294                 MT_Vector3 
295         GetVelocity(
296                 const MT_Point3& position
297         );
298
299         /**
300          * Return the mass of the object
301          */
302                 MT_Scalar       
303         GetMass();
304
305         /**
306          * Return the local inertia vector of the object
307          */
308                 MT_Vector3
309         GetLocalInertia();
310
311         /** 
312          * Return the angular velocity of the game object.
313          */
314                 MT_Vector3 
315         GetAngularVelocity(
316                 bool local=false
317         );
318
319         /** 
320          * Align the object to a given normal.
321          */
322                 void 
323         AlignAxisToVect(
324                 const MT_Vector3& vect,
325                 int axis = 2,
326                 float fac = 1.0
327         );
328
329         /** 
330          * Quick'n'dirty obcolor ipo stuff
331          */
332
333                 void                            
334         SetObjectColor(
335                 const MT_Vector4& rgbavec
336         );
337
338
339                 void 
340         ResolveCombinedVelocities(
341                 const MT_Vector3 & lin_vel,
342                 const MT_Vector3 & ang_vel,
343                 bool lin_vel_local,
344                 bool ang_vel_local
345         );
346
347         /**
348          * @return a pointer to the physics controller owned by this class.
349          */
350
351         KX_IPhysicsController* GetPhysicsController() ;
352
353         void    SetPhysicsController(KX_IPhysicsController*     physicscontroller,bool isDynamic) 
354         { 
355                 m_bDyna = isDynamic;
356                 m_pPhysicsController1 = physicscontroller;
357         }
358
359         virtual class RAS_Deformer* GetDeformer()
360         {
361                 return 0;
362         }
363         virtual void    SetDeformer(class RAS_Deformer* deformer)
364         {
365
366         }
367
368         /**
369          * @return a pointer to the graphic controller owner by this class 
370          */
371         PHY_IGraphicController* GetGraphicController()
372         {
373                 return m_pGraphicController;
374         }
375
376         void SetGraphicController(PHY_IGraphicController* graphiccontroller) 
377         { 
378                 m_pGraphicController = graphiccontroller;
379         }
380         /*
381          * @add/remove the graphic controller to the physic system
382          */
383         void ActivateGraphicController(bool recurse);
384
385         /**
386          * @section Coordinate system manipulation functions
387          */
388
389         void    NodeSetLocalPosition(const MT_Point3& trans     );
390
391         void    NodeSetLocalOrientation(const MT_Matrix3x3& rot );
392         void    NodeSetGlobalOrientation(const MT_Matrix3x3& rot        );
393
394         void    NodeSetLocalScale(      const MT_Vector3& scale );
395
396         void    NodeSetRelativeScale(   const MT_Vector3& scale );
397
398         // adapt local position so that world position is set to desired position
399         void    NodeSetWorldPosition(const MT_Point3& trans);
400
401                 void                                            
402         NodeUpdateGS(
403                 double time
404         );
405
406         const MT_Matrix3x3& NodeGetWorldOrientation(  ) const;
407         const MT_Vector3& NodeGetWorldScaling(  ) const;
408         const MT_Point3& NodeGetWorldPosition(  ) const;
409
410         const MT_Matrix3x3& NodeGetLocalOrientation(  ) const;
411         const MT_Vector3& NodeGetLocalScaling(  ) const;
412         const MT_Point3& NodeGetLocalPosition(  ) const;
413
414         /**
415          * @section scene graph node accessor functions.
416          */
417
418         SG_Node*        GetSGNode(      ) 
419         { 
420                 return m_pSGNode;
421         }
422
423         const   SG_Node* GetSGNode(     ) const 
424         { 
425                 return m_pSGNode;
426         }
427
428         /**
429          * @section blender object accessor functions.
430          */
431
432         struct Object* GetBlenderObject( )
433         {
434                 return m_pBlenderObject;
435         }
436
437         void SetBlenderObject( struct Object* obj)
438         {
439                 m_pBlenderObject = obj;
440         }
441
442         struct Object* GetBlenderGroupObject( )
443         {
444                 return m_pBlenderGroupObject;
445         }
446
447         void SetBlenderGroupObject( struct Object* obj)
448         {
449                 m_pBlenderGroupObject = obj;
450         }
451         
452         bool IsDupliGroup()
453         { 
454                 return (m_pBlenderObject &&
455                                 (m_pBlenderObject->transflag & OB_DUPLIGROUP) &&
456                                 m_pBlenderObject->dup_group != NULL) ? true : false;
457         }
458
459         /**
460          * Set the Scene graph node for this game object.
461          * warning - it is your responsibility to make sure
462          * all controllers look at this new node. You must
463          * also take care of the memory associated with the
464          * old node. This class takes ownership of the new
465          * node.
466          */
467                 void    SetSGNode(SG_Node* node )
468                 { 
469                         m_pSGNode = node; 
470                 }
471         
472         //Is it a dynamic/physics object ?
473         bool    IsDynamic() const 
474         { 
475                 return m_bDyna; 
476         }
477
478         /**
479          * Check if this object has a vertex parent relationship
480          */
481         bool IsVertexParent( )
482         {
483                 return (m_pSGNode && m_pSGNode->GetSGParent() && m_pSGNode->GetSGParent()->IsVertexParent());
484         }
485
486         bool RayHit(KX_ClientObjectInfo* client, KX_RayCast* result, void * const data);
487         bool NeedRayCast(KX_ClientObjectInfo* client);
488
489
490         /**
491          * @section Physics accessors for this node.
492          *
493          * All these calls get passed directly to the physics controller 
494          * owned by this object.
495          * This is real interface bloat. Why not just use the physics controller
496          * directly? I think this is because the python interface is in the wrong
497          * place.
498          */
499
500                 void                                            
501         ApplyForce(
502                 const MT_Vector3& force,        bool local
503         );
504
505                 void                                            
506         ApplyTorque(
507                 const MT_Vector3& torque,
508                 bool local
509         );
510
511                 void                                            
512         ApplyRotation(
513                 const MT_Vector3& drot,
514                 bool local
515         );
516
517                 void                                            
518         ApplyMovement(
519                 const MT_Vector3& dloc,
520                 bool local
521         );
522
523                 void                                            
524         addLinearVelocity(
525                 const MT_Vector3& lin_vel,
526                 bool local
527         );
528
529                 void                                            
530         setLinearVelocity(
531                 const MT_Vector3& lin_vel,
532                 bool local
533         );
534
535                 void                                            
536         setAngularVelocity(
537                 const MT_Vector3& ang_vel,
538                 bool local
539         );
540
541         /**     
542          * Update the physics object transform based upon the current SG_Node
543          * position.
544          */
545                 void
546         UpdateTransform(
547         );
548
549         static void UpdateTransformFunc(SG_IObject* node, void* gameobj, void* scene);
550
551         /**
552          * only used for sensor objects
553          */
554         void SynchronizeTransform();
555
556         static void SynchronizeTransformFunc(SG_IObject* node, void* gameobj, void* scene);
557
558         /**
559          * Function to set IPO option at start of IPO
560          */ 
561                 void    
562         InitIPO(
563                 bool ipo_as_force,
564                 bool ipo_add,
565                 bool ipo_local
566         );
567
568         /**
569          * Odd function to update an ipo. ???
570          */ 
571                 void    
572         UpdateIPO(
573                 float curframetime,
574                 bool recurse
575         );
576         /**
577          * Updates Material Ipo data 
578          */
579                 void 
580         UpdateMaterialData(
581                 dword matname_hash,
582                 MT_Vector4 rgba,
583                 MT_Vector3 specrgb,
584                 MT_Scalar hard,
585                 MT_Scalar spec,
586                 MT_Scalar ref,
587                 MT_Scalar emit,
588                 MT_Scalar alpha
589         );
590
591         /**
592          * @section Mesh accessor functions.
593          */
594
595         /**     
596          * Update buckets to indicate that there is a new
597          * user of this object's meshes.
598          */
599                 void                                            
600         AddMeshUser(
601         );
602         
603         /**     
604          * Update buckets with data about the mesh after
605          * creating or duplicating the object, changing
606          * visibility, object color, .. .
607          */
608                 void                                            
609         UpdateBuckets(
610                 bool recursive
611         );
612
613         /**
614          * Clear the meshes associated with this class
615          * and remove from the bucketing system.
616          * Don't think this actually deletes any of the meshes.
617          */
618                 void                                            
619         RemoveMeshes(
620         );
621
622         /**
623          * Add a mesh to the set of meshes associated with this
624          * node. Meshes added in this way are not deleted by this class.
625          * Make sure you call RemoveMeshes() before deleting the
626          * mesh though,
627          */
628                 void                                            
629         AddMesh(
630                 RAS_MeshObject* mesh
631         ){ 
632                 m_meshes.push_back(mesh);
633         }
634
635         /**
636          * Pick out a mesh associated with the integer 'num'.
637          */
638                 RAS_MeshObject*                         
639         GetMesh(
640                 int num
641         ) const { 
642                 return m_meshes[num]; 
643         }
644
645         /**
646          * Return the number of meshes currently associated with this
647          * game object.
648          */
649                 int                                                     
650         GetMeshCount(
651         ) const { 
652                 return m_meshes.size(); 
653         }
654         
655         /**     
656          * Set the debug color of the meshes associated with this
657          * class. Does this still work?
658          */
659                 void                                            
660         SetDebugColor(
661                 unsigned int bgra
662         );
663
664         /** 
665          * Reset the debug color of meshes associated with this class.
666          */
667                 void                                            
668         ResetDebugColor(
669         );
670
671         /**
672          * Was this object marked visible? (only for the explicit
673          * visibility system).
674          */
675                 bool
676         GetVisible(
677                 void
678         );
679
680         /**
681          * Set visibility flag of this object
682          */
683                 void
684         SetVisible(
685                 bool b,
686                 bool recursive
687         );
688
689         /**
690          * Was this object culled?
691          */
692         inline bool
693         GetCulled(
694                 void
695         ) { return m_bCulled; }
696
697         /**
698          * Set culled flag of this object
699          */
700         inline void
701         SetCulled(
702                 bool c
703         ) { m_bCulled = c; }
704         
705         /**
706          * Is this object an occluder?
707          */
708         inline bool
709         GetOccluder(
710                 void
711         ) { return m_bOccluder; }
712
713         /**
714          * Set occluder flag of this object
715          */
716         void
717         SetOccluder(
718                 bool v,
719                 bool recursive
720         );
721         
722         /**
723          * Change the layer of the object (when it is added in another layer
724          * than the original layer)
725          */
726                 void
727         SetLayer(
728                 int l
729         );
730
731         /**
732          * Get the object layer
733          */
734                 int
735         GetLayer(
736                 void
737         );
738                 
739         /**
740          * Get the negative scaling state
741          */
742                 bool
743         IsNegativeScaling(
744                 void
745         ) { return m_bIsNegativeScaling; }
746
747         /**
748          * Is this a light?
749          */
750                 virtual bool
751         IsLight(
752                 void
753         ) { return false; }
754
755         /**
756          * @section Logic bubbling methods.
757          */
758
759         /**
760          * Stop making progress
761          */
762         void Suspend(void);
763
764         /**
765          * Resume making progress
766          */
767         void Resume(void);
768         
769         void SuspendDynamics(void) {
770                 if (m_bSuspendDynamics)
771                 {
772                         return;
773                 }
774         
775                 if (m_pPhysicsController1)
776                 {
777                         m_pPhysicsController1->SuspendDynamics();
778                 }
779                 m_bSuspendDynamics = true;
780         }
781         
782         void RestoreDynamics(void) {    
783                 if (!m_bSuspendDynamics)
784                 {
785                         return;
786                 }
787         
788                 if (m_pPhysicsController1)
789                 {
790                         m_pPhysicsController1->RestoreDynamics();
791                 }
792                 m_bSuspendDynamics = false;
793         }
794         
795         KX_ClientObjectInfo* getClientInfo() { return m_pClient_info; }
796         
797         CListValue* GetChildren();
798         CListValue* GetChildrenRecursive();
799         
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_mass(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
860         static int                      pyattr_set_mass(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
861         static PyObject*        pyattr_get_lin_vel_min(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
862         static int                      pyattr_set_lin_vel_min(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
863         static PyObject*        pyattr_get_lin_vel_max(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
864         static int                      pyattr_set_lin_vel_max(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
865         static PyObject*        pyattr_get_visible(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
866         static int                      pyattr_set_visible(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
867         static PyObject*        pyattr_get_worldPosition(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
868         static int                      pyattr_set_worldPosition(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
869         static PyObject*        pyattr_get_localPosition(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
870         static int                      pyattr_set_localPosition(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
871         static PyObject*        pyattr_get_localInertia(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
872         static int                      pyattr_set_localInertia(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
873         static PyObject*        pyattr_get_worldOrientation(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
874         static int                      pyattr_set_worldOrientation(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
875         static PyObject*        pyattr_get_localOrientation(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
876         static int                      pyattr_set_localOrientation(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
877         static PyObject*        pyattr_get_worldScaling(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
878         static PyObject*        pyattr_get_localScaling(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
879         static int                      pyattr_set_localScaling(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
880         static PyObject*        pyattr_get_timeOffset(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
881         static int                      pyattr_set_timeOffset(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
882         static PyObject*        pyattr_get_state(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
883         static int                      pyattr_set_state(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
884         static PyObject*        pyattr_get_meshes(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
885         static PyObject*        pyattr_get_children(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
886         static PyObject*        pyattr_get_children_recursive(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
887         static PyObject*        pyattr_get_attrDict(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
888         
889         /* Experemental! */
890         static PyObject*        pyattr_get_sensors(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
891         static PyObject*        pyattr_get_controllers(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
892         static PyObject*        pyattr_get_actuators(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
893         
894         /* getitem/setitem */
895         static PyMappingMethods Mapping;
896         static PySequenceMethods        Sequence;
897         
898 private :
899
900         /**     
901          * Random internal function to convert python function arguments
902          * to 2 vectors.
903          * @return true if conversion was possible.
904          */
905
906                 bool                                            
907         ConvertPythonVectorArgs(
908                 PyObject* args,
909                 MT_Vector3& pos,
910                 MT_Vector3& pos2
911         );      
912
913 };
914
915
916
917 #endif //__KX_GAMEOBJECT
918