KX_GameObject.h

Go to the documentation of this file.

/*
 * ***** BEGIN GPL LICENSE BLOCK *****
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 *
 * The Original Code is: all of this file.
 *
 * Contributor(s): none yet.
 *
 * ***** END GPL LICENSE BLOCK *****
 */

#ifndef __KX_GAMEOBJECT
#define __KX_GAMEOBJECT

#if defined(WIN32) && !defined(FREE_WINDOWS)
// get rid of this stupid "warning 'this' used in initialiser list", generated by VC when including Solid/Sumo
#pragma warning (disable : 4355) 
#endif 

#include <stddef.h>

#include "ListValue.h"
#include "SCA_IObject.h"
#include "SG_Node.h"
#include "MT_Transform.h"
#include "MT_CmMatrix4x4.h"
#include "CTR_Map.h"
#include "CTR_HashedPtr.h"
#include "KX_Scene.h"
#include "KX_KetsjiEngine.h" /* for m_anim_framerate */
#include "KX_IPhysicsController.h" /* for suspend/resume */
#include "DNA_object_types.h"
#include "SCA_LogicManager.h" /* for ConvertPythonToGameObject to search object names */
#define KX_OB_DYNAMIC 1

//Forward declarations.
struct KX_ClientObjectInfo;
class KX_RayCast;
class RAS_MeshObject;
class KX_IPhysicsController;
class PHY_IGraphicController;
class PHY_IPhysicsEnvironment;
class BL_ActionManager;
struct Object;
class KX_ObstacleSimulation;
struct bAction;

#ifdef WITH_PYTHON
/* utility conversion function */
bool ConvertPythonToGameObject(PyObject * value, KX_GameObject **object, bool py_none_ok, const char *error_prefix);
#endif

#ifdef USE_MATHUTILS
void KX_GameObject_Mathutils_Callback_Init(void);
#endif

class KX_GameObject : public SCA_IObject
{
    Py_Header
protected:

    bool                                m_bDyna;
    KX_ClientObjectInfo*                m_pClient_info;
    STR_String                          m_name;
    STR_String                          m_text;
    int                                 m_layer;
    std::vector<RAS_MeshObject*>        m_meshes;
    SG_QList                            m_meshSlots;    // head of mesh slots of this 
    struct Object*                      m_pBlenderObject;
    struct Object*                      m_pBlenderGroupObject;
    
    bool                                m_bSuspendDynamics;
    bool                                m_bUseObjectColor;
    bool                                m_bIsNegativeScaling;
    MT_Vector4                          m_objectColor;

    // visible = user setting
    // culled = while rendering, depending on camera
    bool                                m_bVisible; 
    bool                                m_bCulled; 
    bool                                m_bOccluder;

    KX_IPhysicsController*              m_pPhysicsController1;
    PHY_IGraphicController*             m_pGraphicController;
    STR_String                          m_testPropName;
    bool                                m_xray;
    KX_GameObject*                      m_pHitObject;

    SG_Node*                            m_pSGNode;

    MT_CmMatrix4x4                      m_OpenGL_4x4Matrix;

    KX_ObstacleSimulation*              m_pObstacleSimulation;


    // The action manager is used to play/stop/update actions
    BL_ActionManager*               m_actionManager;

    BL_ActionManager* GetActionManager();
    
public:
    bool                                m_isDeformable;

    static KX_GameObject* GetClientObject(KX_ClientObjectInfo* info);

#ifdef WITH_PYTHON
    // Python attributes that wont convert into CValue
    // 
    // there are 2 places attributes can be stored, in the CValue,
    // where attributes are converted into BGE's CValue types
    // these can be used with property actuators
    //
    // For the python API, For types that cannot be converted into CValues (lists, dicts, GameObjects)
    // these will be put into "m_attr_dict", logic bricks cannot access them.
    // 
    // rules for setting attributes.
    // 
    // * there should NEVER be a CValue and a m_attr_dict attribute with matching names. get/sets make sure of this.
    // * if CValue conversion fails, use a PyObject in "m_attr_dict"
    // * when assigning a value, first see if it can be a CValue, if it can remove the "m_attr_dict" and set the CValue
    // 
    PyObject*                           m_attr_dict; 
#endif

    virtual void    /* This function should be virtual - derived classed override it */
    Relink(
        CTR_Map<CTR_HashedPtr, void*> *map
    );

        double*                     
    GetOpenGLMatrix(
    );

        MT_CmMatrix4x4*             
    GetOpenGLMatrixPtr(
    ) { 
        return &m_OpenGL_4x4Matrix;
    };

        void
    UpdateBlenderObjectMatrix(Object* blendobj=NULL);

        KX_GameObject*              
    GetParent(
    );

    void SetParent(KX_Scene *scene, KX_GameObject *obj, bool addToCompound=true, bool ghost=true);

    void RemoveParent(KX_Scene *scene);

    /*********************************
     * Animation API
     *********************************/

    bool PlayAction(const char* name,
                    float start,
                    float end,
                    short layer=0,
                    short priority=0,
                    float blendin=0.f,
                    short play_mode=0,
                    float layer_weight=0.f,
                    short ipo_flags=0,
                    float playback_speed=1.f);

    float GetActionFrame(short layer);

    void SetActionFrame(short layer, float frame);

    bAction *GetCurrentAction(short layer);

    void SetPlayMode(short layer, short mode);

    void SetTimes(short layer, float start, float end);

    void StopAction(short layer);

    bool IsActionDone(short layer);

    void UpdateActionManager(float curtime);

    /*********************************
     * End Animation API
     *********************************/

    KX_GameObject(
        void* sgReplicationInfo,
        SG_Callbacks callbacks
    );

    virtual 
    ~KX_GameObject(
    );

        CValue*             
    Calc(
        VALUE_OPERATOR op,
        CValue *val
    );

        CValue*             
    CalcFinal(
        VALUE_DATA_TYPE dtype,
        VALUE_OPERATOR op,
        CValue *val
    );

    const 
        STR_String &    
    GetText(
    );

        double
    GetNumber(
    );

        STR_String&         
    GetName(
    );

        void                
    SetName(
        const char *name
    );

    virtual CValue*             
    GetReplica(
    );
    
    virtual void                
    ProcessReplica();

        MT_Vector3 
    GetLinearVelocity(
        bool local=false
    );

        MT_Vector3 
    GetVelocity(
        const MT_Point3& position
    );

        MT_Scalar   
    GetMass();

        MT_Vector3
    GetLocalInertia();

        MT_Vector3 
    GetAngularVelocity(
        bool local=false
    );

        void 
    AlignAxisToVect(
        const MT_Vector3& vect,
        int axis = 2,
        float fac = 1.0
    );

        void                
    SetObjectColor(
        const MT_Vector4& rgbavec
    );

        const MT_Vector4&
    GetObjectColor();


        void 
    ResolveCombinedVelocities(
        const MT_Vector3 & lin_vel,
        const MT_Vector3 & ang_vel,
        bool lin_vel_local,
        bool ang_vel_local
    );

    KX_IPhysicsController* GetPhysicsController() ;

    void    SetPhysicsController(KX_IPhysicsController* physicscontroller,bool isDynamic) 
    { 
        m_bDyna = isDynamic;
        m_pPhysicsController1 = physicscontroller;
    }

    virtual class RAS_Deformer* GetDeformer()
    {
        return 0;
    }
    virtual void    SetDeformer(class RAS_Deformer* deformer)
    {

    }

    PHY_IGraphicController* GetGraphicController()
    {
        return m_pGraphicController;
    }

    void SetGraphicController(PHY_IGraphicController* graphiccontroller) 
    { 
        m_pGraphicController = graphiccontroller;
    }
    /*
     * @add/remove the graphic controller to the physic system
     */
    void ActivateGraphicController(bool recurse);

    void    NodeSetLocalPosition(const MT_Point3& trans );

    void    NodeSetLocalOrientation(const MT_Matrix3x3& rot );
    void    NodeSetGlobalOrientation(const MT_Matrix3x3& rot    );

    void    NodeSetLocalScale(  const MT_Vector3& scale );

    void    NodeSetRelativeScale(   const MT_Vector3& scale );

    // adapt local position so that world position is set to desired position
    void    NodeSetWorldPosition(const MT_Point3& trans);

        void                        
    NodeUpdateGS(
        double time
    );

    const MT_Matrix3x3& NodeGetWorldOrientation(  ) const;
    const MT_Vector3& NodeGetWorldScaling(  ) const;
    const MT_Point3& NodeGetWorldPosition(  ) const;

    const MT_Matrix3x3& NodeGetLocalOrientation(  ) const;
    const MT_Vector3& NodeGetLocalScaling(  ) const;
    const MT_Point3& NodeGetLocalPosition(  ) const;

    SG_Node*    GetSGNode(  ) 
    { 
        return m_pSGNode;
    }

    const   SG_Node* GetSGNode( ) const 
    { 
        return m_pSGNode;
    }

    struct Object* GetBlenderObject( )
    {
        return m_pBlenderObject;
    }

    void SetBlenderObject( struct Object* obj)
    {
        m_pBlenderObject = obj;
    }

    struct Object* GetBlenderGroupObject( )
    {
        return m_pBlenderGroupObject;
    }

    void SetBlenderGroupObject( struct Object* obj)
    {
        m_pBlenderGroupObject = obj;
    }
    
    bool IsDupliGroup()
    { 
        return (m_pBlenderObject &&
                (m_pBlenderObject->transflag & OB_DUPLIGROUP) &&
                m_pBlenderObject->dup_group != NULL) ? true : false;
    }

        void    SetSGNode(SG_Node* node )
        { 
            m_pSGNode = node; 
        }
    
    //Is it a dynamic/physics object ?
    bool    IsDynamic() const 
    { 
        return m_bDyna; 
    }

    bool IsVertexParent( )
    {
        return (m_pSGNode && m_pSGNode->GetSGParent() && m_pSGNode->GetSGParent()->IsVertexParent());
    }

    bool RayHit(KX_ClientObjectInfo* client, KX_RayCast* result, void * const data);
    bool NeedRayCast(KX_ClientObjectInfo* client);


        void                        
    ApplyForce(
        const MT_Vector3& force,    bool local
    );

        void                        
    ApplyTorque(
        const MT_Vector3& torque,
        bool local
    );

        void                        
    ApplyRotation(
        const MT_Vector3& drot,
        bool local
    );

        void                        
    ApplyMovement(
        const MT_Vector3& dloc,
        bool local
    );

        void                        
    addLinearVelocity(
        const MT_Vector3& lin_vel,
        bool local
    );

        void                        
    setLinearVelocity(
        const MT_Vector3& lin_vel,
        bool local
    );

        void                        
    setAngularVelocity(
        const MT_Vector3& ang_vel,
        bool local
    );

        void
    UpdateTransform(
    );

    static void UpdateTransformFunc(SG_IObject* node, void* gameobj, void* scene);

    void SynchronizeTransform();

    static void SynchronizeTransformFunc(SG_IObject* node, void* gameobj, void* scene);

        void    
    InitIPO(
        bool ipo_as_force,
        bool ipo_add,
        bool ipo_local
    );

        void    
    UpdateIPO(
        float curframetime,
        bool recurse
    );
        void 
    UpdateMaterialData(
        dword matname_hash,
        MT_Vector4 rgba,
        MT_Vector3 specrgb,
        MT_Scalar hard,
        MT_Scalar spec,
        MT_Scalar ref,
        MT_Scalar emit,
        MT_Scalar alpha
    );

        void                        
    AddMeshUser(
    );
    
        void                        
    UpdateBuckets(
        bool recursive
    );

        void                        
    RemoveMeshes(
    );

        void                        
    AddMesh(
        RAS_MeshObject* mesh
    ){ 
        m_meshes.push_back(mesh);
    }

        RAS_MeshObject*             
    GetMesh(
        int num
    ) const { 
        return m_meshes[num]; 
    }

        int                         
    GetMeshCount(
    ) const { 
        return m_meshes.size(); 
    }
    
        void                        
    SetDebugColor(
        unsigned int bgra
    );

        void                        
    ResetDebugColor(
    );

        bool
    GetVisible(
        void
    );

        void
    SetVisible(
        bool b,
        bool recursive
    );

    inline bool
    GetCulled(
        void
    ) { return m_bCulled; }

    inline void
    SetCulled(
        bool c
    ) { m_bCulled = c; }
    
    inline bool
    GetOccluder(
        void
    ) { return m_bOccluder; }

    void
    SetOccluder(
        bool v,
        bool recursive
    );
    
        void
    SetLayer(
        int l
    );

        int
    GetLayer(
        void
    );
        
        bool
    IsNegativeScaling(
        void
    ) { return m_bIsNegativeScaling; }

    void Suspend(void);

    void Resume(void);
    
    void SuspendDynamics(void) {
        if (m_bSuspendDynamics)
        {
            return;
        }
    
        if (m_pPhysicsController1)
        {
            m_pPhysicsController1->SuspendDynamics();
        }
        m_bSuspendDynamics = true;
    }
    
    void RestoreDynamics(void) {    
        if (!m_bSuspendDynamics)
        {
            return;
        }
    
        if (m_pPhysicsController1)
        {
            m_pPhysicsController1->RestoreDynamics();
        }
        m_bSuspendDynamics = false;
    }

    void RegisterObstacle(KX_ObstacleSimulation* obstacleSimulation)
    {
        m_pObstacleSimulation = obstacleSimulation;
    }

    void UnregisterObstacle()
    {
        m_pObstacleSimulation = NULL;
    }
    
    KX_ClientObjectInfo* getClientInfo() { return m_pClient_info; }
    
    CListValue* GetChildren();
    CListValue* GetChildrenRecursive();

#ifdef WITH_PYTHON

    virtual PyObject* py_repr(void)
    {
        return PyUnicode_From_STR_String(GetName());
    }

    KX_PYMETHOD_O(KX_GameObject,SetWorldPosition);
    KX_PYMETHOD_VARARGS(KX_GameObject, ApplyForce);
    KX_PYMETHOD_VARARGS(KX_GameObject, ApplyTorque);
    KX_PYMETHOD_VARARGS(KX_GameObject, ApplyRotation);
    KX_PYMETHOD_VARARGS(KX_GameObject, ApplyMovement);
    KX_PYMETHOD_VARARGS(KX_GameObject,GetLinearVelocity);
    KX_PYMETHOD_VARARGS(KX_GameObject,SetLinearVelocity);
    KX_PYMETHOD_VARARGS(KX_GameObject,GetAngularVelocity);
    KX_PYMETHOD_VARARGS(KX_GameObject,SetAngularVelocity);
    KX_PYMETHOD_VARARGS(KX_GameObject,GetVelocity);

    KX_PYMETHOD_NOARGS(KX_GameObject,GetReactionForce);


    KX_PYMETHOD_NOARGS(KX_GameObject,GetVisible);
    KX_PYMETHOD_VARARGS(KX_GameObject,SetVisible);
    KX_PYMETHOD_VARARGS(KX_GameObject,SetOcclusion);
    KX_PYMETHOD_NOARGS(KX_GameObject,GetState);
    KX_PYMETHOD_O(KX_GameObject,SetState);
    KX_PYMETHOD_VARARGS(KX_GameObject,AlignAxisToVect);
    KX_PYMETHOD_O(KX_GameObject,GetAxisVect);
    KX_PYMETHOD_NOARGS(KX_GameObject,SuspendDynamics);
    KX_PYMETHOD_NOARGS(KX_GameObject,RestoreDynamics);
    KX_PYMETHOD_NOARGS(KX_GameObject,EnableRigidBody);
    KX_PYMETHOD_NOARGS(KX_GameObject,DisableRigidBody);
    KX_PYMETHOD_VARARGS(KX_GameObject,ApplyImpulse);
    KX_PYMETHOD_O(KX_GameObject,SetCollisionMargin);
    KX_PYMETHOD_NOARGS(KX_GameObject,GetParent);
    KX_PYMETHOD_VARARGS(KX_GameObject,SetParent);
    KX_PYMETHOD_NOARGS(KX_GameObject,RemoveParent);
    KX_PYMETHOD_NOARGS(KX_GameObject,GetChildren);
    KX_PYMETHOD_NOARGS(KX_GameObject,GetChildrenRecursive);
    KX_PYMETHOD_VARARGS(KX_GameObject,GetMesh);
    KX_PYMETHOD_NOARGS(KX_GameObject,GetPhysicsId);
    KX_PYMETHOD_NOARGS(KX_GameObject,GetPropertyNames);
    KX_PYMETHOD_VARARGS(KX_GameObject,ReplaceMesh);
    KX_PYMETHOD_NOARGS(KX_GameObject,EndObject);
    KX_PYMETHOD_DOC(KX_GameObject,rayCastTo);
    KX_PYMETHOD_DOC(KX_GameObject,rayCast);
    KX_PYMETHOD_DOC_O(KX_GameObject,getDistanceTo);
    KX_PYMETHOD_DOC_O(KX_GameObject,getVectTo);
    KX_PYMETHOD_DOC_VARARGS(KX_GameObject, sendMessage);
    KX_PYMETHOD_VARARGS(KX_GameObject, ReinstancePhysicsMesh);

    KX_PYMETHOD_DOC(KX_GameObject, playAction);
    KX_PYMETHOD_DOC(KX_GameObject, stopAction);
    KX_PYMETHOD_DOC(KX_GameObject, getActionFrame);
    KX_PYMETHOD_DOC(KX_GameObject, setActionFrame);
    KX_PYMETHOD_DOC(KX_GameObject, isPlayingAction);
    
    /* Dict access */
    KX_PYMETHOD_VARARGS(KX_GameObject,get);
    
    /* attributes */
    static PyObject*    pyattr_get_name(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static PyObject*    pyattr_get_parent(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);

    static PyObject*    pyattr_get_life(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static PyObject*    pyattr_get_mass(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static int          pyattr_set_mass(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
    static PyObject*    pyattr_get_lin_vel_min(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static int          pyattr_set_lin_vel_min(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
    static PyObject*    pyattr_get_lin_vel_max(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static int          pyattr_set_lin_vel_max(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
    static PyObject*    pyattr_get_visible(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static int          pyattr_set_visible(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
    static PyObject*    pyattr_get_worldPosition(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static int          pyattr_set_worldPosition(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
    static PyObject*    pyattr_get_localPosition(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static int          pyattr_set_localPosition(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
    static PyObject*    pyattr_get_localInertia(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static int          pyattr_set_localInertia(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
    static PyObject*    pyattr_get_worldOrientation(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static int          pyattr_set_worldOrientation(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
    static PyObject*    pyattr_get_localOrientation(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static int          pyattr_set_localOrientation(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
    static PyObject*    pyattr_get_worldScaling(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static PyObject*    pyattr_get_localScaling(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static int          pyattr_set_localScaling(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
    static PyObject*    pyattr_get_worldLinearVelocity(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static int          pyattr_set_worldLinearVelocity(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
    static PyObject*    pyattr_get_localLinearVelocity(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static int          pyattr_set_localLinearVelocity(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
    static PyObject*    pyattr_get_worldAngularVelocity(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static int          pyattr_set_worldAngularVelocity(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
    static PyObject*    pyattr_get_localAngularVelocity(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static int          pyattr_set_localAngularVelocity(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);  
    static PyObject*    pyattr_get_timeOffset(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static int          pyattr_set_timeOffset(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
    static PyObject*    pyattr_get_state(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static int          pyattr_set_state(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
    static PyObject*    pyattr_get_meshes(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static PyObject*    pyattr_get_children(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static PyObject*    pyattr_get_children_recursive(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static PyObject*    pyattr_get_attrDict(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static PyObject*    pyattr_get_obcolor(void *selv_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static int          pyattr_set_obcolor(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
    
    /* Experemental! */
    static PyObject*    pyattr_get_sensors(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static PyObject*    pyattr_get_controllers(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    static PyObject*    pyattr_get_actuators(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
    
    /* getitem/setitem */
    static PyMappingMethods Mapping;
    static PySequenceMethods    Sequence;
#endif
};



#endif //__KX_GAMEOBJECT