~diresu/blender/blender-command-port

/**

 *

 * ***** BEGIN GPL LICENSE BLOCK *****

 *

#include "RAS_IPolygonMaterial.h"

#include "KX_BlenderMaterial.h"

#include "KX_GameObject.h"

#include "RAS_MeshObject.h"

#include "KX_MeshProxy.h"

#include "KX_PolyProxy.h"

        

}

 

{

        // check on valid node in case a python controller holds a reference to a deleted object

        if (obj && GetSGNode() && obj->GetSGNode() && GetSGNode()->GetSGParent() != obj->GetSGNode())

 

                if (m_pPhysicsController1) 

                {

                }

                // Set us to our new scale, position, and orientation

                scale2[0] = 1.0/scale2[0];

                        Release();

                // if the new parent is a compound object, add this object shape to the compound shape.

                // step 0: verify this object has physical controller

                {

                        // step 1: find the top parent (not necessarily obj)

                        KX_GameObject* rootobj = (KX_GameObject*)obj->GetSGNode()->GetRootSGParent()->GetSGClientObject();

                                rootobj->m_pPhysicsController1->RemoveCompoundChild(m_pPhysicsController1);

                        }

                        m_pPhysicsController1->RestoreDynamics();

                }

                // graphically, the object hasn't change place, no need to update m_pGraphicController

        }

                

}

 

{

        NodeList& children = node->GetSGChildren();

 

                SG_Node* childnode = (*childit);

                KX_GameObject *clientgameobj = static_cast<KX_GameObject*>( (*childit)->GetSGClientObject());

                if (clientgameobj != NULL) // This is a GameObject

                

                // if the childobj is NULL then this may be an inverse parent link

                // so a non recursive search should still look down this node.

        }

}

 

 

{

        if (m_pGraphicController)

        {

        }

        if (recurse)

        {

        }

}

 

{

        for (size_t i=0;i<m_meshes.size();i++)

        {

        }

        // set the part of the mesh slot that never change

        double* fl = GetOpenGLMatrixPtr()->getPointer();

 

        SG_QList::iterator<RAS_MeshSlot> mit(m_meshSlots);

        for(mit.begin(); !mit.end(); ++mit)

        {

                (*mit)->m_OpenGLMatrix = fl;

        }

        UpdateBuckets(false);

}

        ((KX_GameObject*)gameobj)->UpdateTransform();

}

 

 

void KX_GameObject::SetDebugColor(unsigned int bgra)

{

        {"disableRigidBody", (PyCFunction)KX_GameObject::sPyDisableRigidBody,METH_NOARGS},

        {"applyImpulse", (PyCFunction) KX_GameObject::sPyApplyImpulse, METH_VARARGS},

        {"setCollisionMargin", (PyCFunction) KX_GameObject::sPySetCollisionMargin, METH_O},

        {"setVisible",(PyCFunction) KX_GameObject::sPySetVisible, METH_VARARGS},

        {"setOcclusion",(PyCFunction) KX_GameObject::sPySetOcclusion, METH_VARARGS},

        {"removeParent", (PyCFunction)KX_GameObject::sPyRemoveParent,METH_NOARGS},

        KX_PYMETHODTABLE_O(KX_GameObject, getDistanceTo),

        KX_PYMETHODTABLE_O(KX_GameObject, getVectTo),

        KX_PYMETHODTABLE(KX_GameObject, sendMessage),

        // deprecated

        {"getPosition", (PyCFunction) KX_GameObject::sPyGetPosition, METH_NOARGS},

        {"setPosition", (PyCFunction) KX_GameObject::sPySetPosition, METH_O},

        KX_PYATTRIBUTE_RW_FUNCTION("worldOrientation",KX_GameObject,pyattr_get_worldOrientation,pyattr_set_worldOrientation),

        KX_PYATTRIBUTE_RW_FUNCTION("localPosition",     KX_GameObject, pyattr_get_localPosition,        pyattr_set_localPosition),

        KX_PYATTRIBUTE_RW_FUNCTION("worldPosition",     KX_GameObject, pyattr_get_worldPosition,    pyattr_set_worldPosition),

        KX_PYATTRIBUTE_RO_FUNCTION("attrDict",  KX_GameObject, pyattr_get_attrDict),

        

        /* Experemental, dont rely on these yet */

                

                if (del==0) {

                        if(attr_str)    PyErr_Format(PyExc_KeyError, "gameOb[key] = value: KX_GameObject, key \"%s\" could not be set", attr_str);

                        return -1;

                }

                else if (self->m_attr_dict) {

        MT_Scalar val = PyFloat_AsDouble(value);

        if (val < 0.0f) { /* also accounts for non float */

                PyErr_SetString(PyExc_AttributeError, "gameOb.mass = float: KX_GameObject, expected a float zero or above");

        }

 

        if (spc)

                spc->SetMass(val);

 

}

 

PyObject* KX_GameObject::pyattr_get_lin_vel_min(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)

        MT_Scalar val = PyFloat_AsDouble(value);

        if (val < 0.0f) { /* also accounts for non float */

                PyErr_SetString(PyExc_AttributeError, "gameOb.linVelocityMin = float: KX_GameObject, expected a float zero or above");

        }

 

        if (spc)

                spc->SetLinVelocityMin(val);

 

}

 

PyObject* KX_GameObject::pyattr_get_lin_vel_max(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)

        MT_Scalar val = PyFloat_AsDouble(value);

        if (val < 0.0f) { /* also accounts for non float */

                PyErr_SetString(PyExc_AttributeError, "gameOb.linVelocityMax = float: KX_GameObject, expected a float zero or above");

        }

 

        if (spc)

                spc->SetLinVelocityMax(val);

 

}

 

 

        int param = PyObject_IsTrue( value );

        if (param == -1) {

                PyErr_SetString(PyExc_AttributeError, "gameOb.visible = bool: KX_GameObject, expected True or False");

        }

 

        self->SetVisible(param, false);

        self->UpdateBuckets(false);

}

 

PyObject* KX_GameObject::pyattr_get_worldPosition(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)

        KX_GameObject* self= static_cast<KX_GameObject*>(self_v);

        MT_Point3 pos;

        if (!PyVecTo(value, pos))

        

        self->NodeSetWorldPosition(pos);

        self->NodeUpdateGS(0.f);

}

 

PyObject* KX_GameObject::pyattr_get_localPosition(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)

        KX_GameObject* self= static_cast<KX_GameObject*>(self_v);

        MT_Point3 pos;

        if (!PyVecTo(value, pos))

        

        self->NodeSetLocalPosition(pos);

        self->NodeUpdateGS(0.f);

}

 

PyObject* KX_GameObject::pyattr_get_localInertia(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)

        /* if value is not a sequence PyOrientationTo makes an error */

        MT_Matrix3x3 rot;

        if (!PyOrientationTo(value, rot, "gameOb.worldOrientation = sequence: KX_GameObject, "))

 

        if (self->GetSGNode() && self->GetSGNode()->GetSGParent()) {

                self->NodeSetLocalOrientation(self->GetSGNode()->GetSGParent()->GetWorldOrientation().inverse()*rot);

        }

        

        self->NodeUpdateGS(0.f);

}

 

PyObject* KX_GameObject::pyattr_get_localOrientation(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)

        /* if value is not a sequence PyOrientationTo makes an error */

        MT_Matrix3x3 rot;

        if (!PyOrientationTo(value, rot, "gameOb.localOrientation = sequence: KX_GameObject, "))

 

        self->NodeSetLocalOrientation(rot);

        self->NodeUpdateGS(0.f);

}

 

PyObject* KX_GameObject::pyattr_get_worldScaling(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)

        KX_GameObject* self= static_cast<KX_GameObject*>(self_v);

        MT_Vector3 scale;

        if (!PyVecTo(value, scale))

 

        self->NodeSetLocalScale(scale);

        self->NodeUpdateGS(0.f);

}

 

PyObject* KX_GameObject::pyattr_get_timeOffset(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)

                SG_Node* sg_parent= self->GetSGNode()->GetSGParent();

                if (val < 0.0f) { /* also accounts for non float */

                        PyErr_SetString(PyExc_AttributeError, "gameOb.timeOffset = float: KX_GameObject, expected a float zero or above");

                }

                if (sg_parent && sg_parent->IsSlowParent())

                        static_cast<KX_SlowParentRelation *>(sg_parent->GetParentRelation())->SetTimeOffset(val);

        }

}

 

PyObject* KX_GameObject::pyattr_get_state(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)

        

        if (state_i == -1 && PyErr_Occurred()) {

                PyErr_SetString(PyExc_TypeError, "gameOb.state = int: KX_GameObject, expected an int bit field");

        }

        

        state |= state_i;

        if ((state & ((1<<30)-1)) == 0) {

                PyErr_SetString(PyExc_AttributeError, "gameOb.state = int: KX_GameObject, state bitfield was not between 0 and 30 (1<<0 and 1<<29)");

        }

        self->SetState(state);

}

 

PyObject* KX_GameObject::pyattr_get_meshes(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)

        return KX_PythonSeq_CreatePyObject((static_cast<KX_GameObject*>(self_v))->m_proxy, KX_PYGENSEQ_OB_TYPE_ACTUATORS);

}

 

PyObject* KX_GameObject::pyattr_get_attrDict(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)

{

        KX_GameObject* self= static_cast<KX_GameObject*>(self_v);

 

int KX_GameObject::py_setattro(PyObject *attr, PyObject *value) // py_setattro method

{

        

        if (ret==PY_SET_ATTR_SUCCESS) {

                /* remove attribute in our own dict to avoid double ups */

 

int     KX_GameObject::py_delattro(PyObject *attr)

{

        char *attr_str= PyString_AsString(attr); 

        

        if (RemoveProperty(attr_str)) // XXX - should call CValues instead but its only 2 lines here

        

        if (m_attr_dict && (PyDict_DelItem(m_attr_dict, attr) == 0))

        

        PyErr_Format(PyExc_AttributeError, "del gameOb.myAttr: KX_GameObject, attribute \"%s\" dosnt exist", attr_str);

}

 

 

        MT_Point3 point(0.0,0.0,0.0);

        PyObject* pypos = NULL;

        

                return NULL;

        

        if (m_pPhysicsController1)

        {

        Py_RETURN_NONE;

}

 

{

        KX_Scene *scene = KX_GetActiveScene();

        KX_GameObject *obj;

        

                return NULL;

        Py_RETURN_NONE;

}

 

 

PyObject* KX_GameObject::PyGetChildren()

{

        return GetChildren()->NewProxy(true);

}

 

PyObject* KX_GameObject::PyGetChildrenRecursive()

{

        return GetChildrenRecursive()->NewProxy(true);

}

 

 

PyObject* KX_GameObject::PySetPosition(PyObject* value)

{

        MT_Point3 pos;

        if (PyVecTo(value, pos))

        {

        Py_RETURN_NONE;

}

 

KX_PYMETHODDEF_DOC(KX_GameObject, rayCast,

                                   "rayCast(to,from,dist,prop,face,xray,poly): cast a ray and return 3-tuple (object,hit,normal) or 4-tuple (object,hit,normal,polygon) of contact point with object within dist that matches prop.\n"

                                   " If no hit, return (None,None,None) or (None,None,None,None).\n"

        if (dist != 0.0f) {

                MT_Vector3 toDir = toPoint-fromPoint;

                if (MT_fuzzyZero(toDir.length2())) {

                }

                toDir.normalize();

                toPoint = fromPoint + (dist) * toDir;

        } else if (MT_fuzzyZero((toPoint-fromPoint).length2())) {

        }

        

        PHY_IPhysicsEnvironment* pe = GetPhysicsEnvironment();

        }

        // no hit

        if (poly)

        else

}

 

KX_PYMETHODDEF_DOC_VARARGS(KX_GameObject, sendMessage, 

        Py_RETURN_NONE;

}

 

/* --------------------------------------------------------------------- 

 * Some stuff taken from the header

 * --------------------------------------------------------------------- */

        }

}

 

bool ConvertPythonToGameObject(PyObject * value, KX_GameObject **object, bool py_none_ok, const char *error_prefix)

{

        if (value==NULL) {

                }

        }

        

                *object = static_cast<KX_GameObject*>BGE_PROXY_REF(value);

                

                /* sets the error */