KX_VehicleWrapper.cpp

Go to the documentation of this file.

#include "PyObjectPlus.h"

#include "KX_VehicleWrapper.h"
#include "PHY_IPhysicsEnvironment.h"
#include "PHY_IVehicle.h"
#include "KX_PyMath.h"
#include "KX_GameObject.h"
#include "KX_MotionState.h"

KX_VehicleWrapper::KX_VehicleWrapper(
                        PHY_IVehicle* vehicle,
                        PHY_IPhysicsEnvironment* physenv) :
        PyObjectPlus(),
        m_vehicle(vehicle),
        m_physenv(physenv)
{
}

KX_VehicleWrapper::~KX_VehicleWrapper()
{
    int numMotion = m_motionStates.size();
    for (int i=0;i<numMotion;i++)
    {
        PHY_IMotionState* motionState = m_motionStates[i];
        delete motionState;
    }
    m_motionStates.clear();
}

#ifdef WITH_PYTHON

PyObject* KX_VehicleWrapper::PyAddWheel(PyObject* args)
{
    
    PyObject* pylistPos,*pylistDir,*pylistAxleDir;
    PyObject* wheelGameObject;
    float suspensionRestLength,wheelRadius;
    int hasSteering;

    
    if (PyArg_ParseTuple(args,"OOOOffi:addWheel",&wheelGameObject,&pylistPos,&pylistDir,&pylistAxleDir,&suspensionRestLength,&wheelRadius,&hasSteering))
    {
        KX_GameObject *gameOb;
        if (!ConvertPythonToGameObject(wheelGameObject, &gameOb, false, "vehicle.addWheel(...): KX_VehicleWrapper (first argument)"))
            return NULL;
        

        if (gameOb->GetSGNode())
        {
            PHY_IMotionState* motionState = new KX_MotionState(gameOb->GetSGNode());
            
            /* TODO - no error checking here! - bad juju */
            MT_Vector3 attachPos,attachDir,attachAxle;
            PyVecTo(pylistPos,attachPos);
            PyVecTo(pylistDir,attachDir);
            PyVecTo(pylistAxleDir,attachAxle);
            PHY__Vector3 aPos,aDir,aAxle;
            aPos[0] = attachPos[0];
            aPos[1] = attachPos[1];
            aPos[2] = attachPos[2];
            aDir[0] = attachDir[0];
            aDir[1] = attachDir[1];
            aDir[2] = attachDir[2];
            aAxle[0] = -attachAxle[0];//someone reverse some conventions inside Bullet (axle winding)
            aAxle[1] = -attachAxle[1];
            aAxle[2] = -attachAxle[2];
            
            printf("attempt for addWheel: suspensionRestLength%f wheelRadius %f, hasSteering:%d\n",suspensionRestLength,wheelRadius,hasSteering);
            m_vehicle->AddWheel(motionState,aPos,aDir,aAxle,suspensionRestLength,wheelRadius,hasSteering);
        }
        
    } else {
        return NULL;
    }
    Py_RETURN_NONE;
}




PyObject* KX_VehicleWrapper::PyGetWheelPosition(PyObject* args)
{
    
    int wheelIndex;

    if (PyArg_ParseTuple(args,"i:getWheelPosition",&wheelIndex))
    {
        float position[3];
        m_vehicle->GetWheelPosition(wheelIndex,position[0],position[1],position[2]);
        MT_Vector3 pos(position[0],position[1],position[2]);
        return PyObjectFrom(pos);
    }
    return NULL;
}

PyObject* KX_VehicleWrapper::PyGetWheelRotation(PyObject* args)
{
    int wheelIndex;
    if (PyArg_ParseTuple(args,"i:getWheelRotation",&wheelIndex))
    {
        return PyFloat_FromDouble(m_vehicle->GetWheelRotation(wheelIndex));
    }
    return NULL;
}

PyObject* KX_VehicleWrapper::PyGetWheelOrientationQuaternion(PyObject* args)
{
    int wheelIndex;
    if (PyArg_ParseTuple(args,"i:getWheelOrientationQuaternion",&wheelIndex))
    {
        float orn[4];
        m_vehicle->GetWheelOrientationQuaternion(wheelIndex,orn[0],orn[1],orn[2],orn[3]);
        MT_Quaternion   quatorn(orn[0],orn[1],orn[2],orn[3]);
        MT_Matrix3x3 ornmat(quatorn);
        return PyObjectFrom(ornmat);
    }
    return NULL;

}


PyObject* KX_VehicleWrapper::PyGetNumWheels(PyObject* args)
{
    return PyLong_FromSsize_t(m_vehicle->GetNumWheels());
}


PyObject* KX_VehicleWrapper::PyGetConstraintId(PyObject* args)
{
    return PyLong_FromSsize_t(m_vehicle->GetUserConstraintId());
}



PyObject* KX_VehicleWrapper::PyApplyEngineForce(PyObject* args)
{
    float force;
    int wheelIndex;

    if (PyArg_ParseTuple(args,"fi:applyEngineForce",&force,&wheelIndex))
    {
        force *= -1.f;//someone reverse some conventions inside Bullet (axle winding)
        m_vehicle->ApplyEngineForce(force,wheelIndex);
    }
    else {
        return NULL;
    }
    Py_RETURN_NONE;
}

PyObject* KX_VehicleWrapper::PySetTyreFriction(PyObject* args)
{
    float wheelFriction;
    int wheelIndex;

    if (PyArg_ParseTuple(args,"fi:setTyreFriction",&wheelFriction,&wheelIndex))
    {
        m_vehicle->SetWheelFriction(wheelFriction,wheelIndex);
    }
    else {
        return NULL;
    }
    Py_RETURN_NONE;
}

PyObject* KX_VehicleWrapper::PySetSuspensionStiffness(PyObject* args)
{
    float suspensionStiffness;
    int wheelIndex;

    if (PyArg_ParseTuple(args,"fi:setSuspensionStiffness",&suspensionStiffness,&wheelIndex))
    {
        m_vehicle->SetSuspensionStiffness(suspensionStiffness,wheelIndex);
    }
    else {
        return NULL;
    }
    Py_RETURN_NONE;
}

PyObject* KX_VehicleWrapper::PySetSuspensionDamping(PyObject* args)
{
    float suspensionDamping;
    int wheelIndex;

    if (PyArg_ParseTuple(args,"fi:setSuspensionDamping",&suspensionDamping,&wheelIndex))
    {
        m_vehicle->SetSuspensionDamping(suspensionDamping,wheelIndex);
    } else {
        return NULL;
    }
    Py_RETURN_NONE;
}

PyObject* KX_VehicleWrapper::PySetSuspensionCompression(PyObject* args)
{
    float suspensionCompression;
    int wheelIndex;

    if (PyArg_ParseTuple(args,"fi:setSuspensionCompression",&suspensionCompression,&wheelIndex))
    {
        m_vehicle->SetSuspensionCompression(suspensionCompression,wheelIndex);
    } else {
        return NULL;
    }
    Py_RETURN_NONE;
}

PyObject* KX_VehicleWrapper::PySetRollInfluence(PyObject* args)
{
    float rollInfluence;
    int wheelIndex;

    if (PyArg_ParseTuple(args,"fi:setRollInfluence",&rollInfluence,&wheelIndex))
    {
        m_vehicle->SetRollInfluence(rollInfluence,wheelIndex);
    }
    else {
        return NULL;
    }
    Py_RETURN_NONE;
}


PyObject* KX_VehicleWrapper::PyApplyBraking(PyObject* args)
{
    float braking;
    int wheelIndex;

    if (PyArg_ParseTuple(args,"fi:applyBraking",&braking,&wheelIndex))
    {
        m_vehicle->ApplyBraking(braking,wheelIndex);
    }
    else {
        return NULL;
    }
    Py_RETURN_NONE;
}




PyObject* KX_VehicleWrapper::PySetSteeringValue(PyObject* args)
{
    float steeringValue;
    int wheelIndex;

    if (PyArg_ParseTuple(args,"fi:setSteeringValue",&steeringValue,&wheelIndex))
    {
        m_vehicle->SetSteeringValue(steeringValue,wheelIndex);
    }
    else {
        return NULL;
    }
    Py_RETURN_NONE;
}


PyObject* KX_VehicleWrapper::PyGetConstraintType(PyObject* args)
{
    return PyLong_FromSsize_t(m_vehicle->GetUserConstraintType());
}





//python specific stuff
PyTypeObject KX_VehicleWrapper::Type = {
    PyVarObject_HEAD_INIT(NULL, 0)
    "KX_VehicleWrapper",
    sizeof(PyObjectPlus_Proxy),
    0,
    py_base_dealloc,
    0,
    0,
    0,
    0,
    py_base_repr,
    0,0,0,0,0,0,0,0,0,
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    0,0,0,0,0,0,0,
    Methods,
    0,
    0,
    &PyObjectPlus::Type,
    0,0,0,0,0,0,
    py_base_new
};

PyMethodDef KX_VehicleWrapper::Methods[] = {
    {"addWheel",(PyCFunction) KX_VehicleWrapper::sPyAddWheel, METH_VARARGS},
    {"getNumWheels",(PyCFunction) KX_VehicleWrapper::sPyGetNumWheels, METH_VARARGS},
    {"getWheelOrientationQuaternion",(PyCFunction) KX_VehicleWrapper::sPyGetWheelOrientationQuaternion, METH_VARARGS},
    {"getWheelRotation",(PyCFunction) KX_VehicleWrapper::sPyGetWheelRotation, METH_VARARGS},
    {"getWheelPosition",(PyCFunction) KX_VehicleWrapper::sPyGetWheelPosition, METH_VARARGS},
    {"getConstraintId",(PyCFunction) KX_VehicleWrapper::sPyGetConstraintId, METH_VARARGS},
    {"getConstraintType",(PyCFunction) KX_VehicleWrapper::sPyGetConstraintType, METH_VARARGS},
    {"setSteeringValue",(PyCFunction) KX_VehicleWrapper::sPySetSteeringValue, METH_VARARGS},
    {"applyEngineForce",(PyCFunction) KX_VehicleWrapper::sPyApplyEngineForce, METH_VARARGS},
    {"applyBraking",(PyCFunction) KX_VehicleWrapper::sPyApplyBraking, METH_VARARGS},

    {"setTyreFriction",(PyCFunction) KX_VehicleWrapper::sPySetTyreFriction, METH_VARARGS},

    {"setSuspensionStiffness",(PyCFunction) KX_VehicleWrapper::sPySetSuspensionStiffness, METH_VARARGS},

    {"setSuspensionDamping",(PyCFunction) KX_VehicleWrapper::sPySetSuspensionDamping, METH_VARARGS},

    {"setSuspensionCompression",(PyCFunction) KX_VehicleWrapper::sPySetSuspensionCompression, METH_VARARGS},

    {"setRollInfluence",(PyCFunction) KX_VehicleWrapper::sPySetRollInfluence, METH_VARARGS},

    {NULL,NULL} //Sentinel
};

PyAttributeDef KX_VehicleWrapper::Attributes[] = {
    { NULL }    //Sentinel
};

#endif // WITH_PYTHON