blender/source/gameengine/Ketsji/KX_VehicleWrapper.cpp

338 lines
8.3 KiB
C++
Raw Normal View History

2013-07-02 09:47:22 +00:00
/*
* ***** 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.
*
* ***** END GPL LICENSE BLOCK *****
*/
2011-02-25 13:35:59 +00:00
/** \file gameengine/Ketsji/KX_VehicleWrapper.cpp
* \ingroup ketsji
*/
#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
2012-09-16 04:58:18 +00:00
PyObject *KX_VehicleWrapper::PyAddWheel(PyObject *args)
{
2012-09-16 04:58:18 +00:00
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);
//someone reverse some conventions inside Bullet (axle winding)
attachAxle = -attachAxle;
printf("attempt for addWheel: suspensionRestLength%f wheelRadius %f, hasSteering:%d\n",suspensionRestLength,wheelRadius,hasSteering);
m_vehicle->AddWheel(motionState,attachPos,attachDir,attachAxle,suspensionRestLength,wheelRadius,hasSteering);
}
} else {
return NULL;
}
Py_RETURN_NONE;
}
2012-09-16 04:58:18 +00:00
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;
}
2012-09-16 04:58:18 +00:00
PyObject *KX_VehicleWrapper::PyGetWheelRotation(PyObject *args)
{
int wheelIndex;
if (PyArg_ParseTuple(args,"i:getWheelRotation",&wheelIndex))
{
return PyFloat_FromDouble(m_vehicle->GetWheelRotation(wheelIndex));
}
return NULL;
}
2012-09-16 04:58:18 +00:00
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;
}
2012-09-16 04:58:18 +00:00
PyObject *KX_VehicleWrapper::PyGetNumWheels(PyObject *args)
{
return PyLong_FromLong(m_vehicle->GetNumWheels());
}
2012-09-16 04:58:18 +00:00
PyObject *KX_VehicleWrapper::PyGetConstraintId(PyObject *args)
{
return PyLong_FromLong(m_vehicle->GetUserConstraintId());
}
2012-09-16 04:58:18 +00:00
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;
}
2012-09-16 04:58:18 +00:00
PyObject *KX_VehicleWrapper::PySetTyreFriction(PyObject *args)
2006-02-21 07:08:23 +00:00
{
float wheelFriction;
int wheelIndex;
if (PyArg_ParseTuple(args,"fi:setTyreFriction",&wheelFriction,&wheelIndex))
2006-02-21 07:08:23 +00:00
{
m_vehicle->SetWheelFriction(wheelFriction,wheelIndex);
}
else {
return NULL;
}
Py_RETURN_NONE;
2006-02-21 07:08:23 +00:00
}
2012-09-16 04:58:18 +00:00
PyObject *KX_VehicleWrapper::PySetSuspensionStiffness(PyObject *args)
2006-02-21 07:08:23 +00:00
{
float suspensionStiffness;
int wheelIndex;
if (PyArg_ParseTuple(args,"fi:setSuspensionStiffness",&suspensionStiffness,&wheelIndex))
2006-02-21 07:08:23 +00:00
{
m_vehicle->SetSuspensionStiffness(suspensionStiffness,wheelIndex);
}
else {
return NULL;
}
Py_RETURN_NONE;
2006-02-21 07:08:23 +00:00
}
2012-09-16 04:58:18 +00:00
PyObject *KX_VehicleWrapper::PySetSuspensionDamping(PyObject *args)
2006-02-21 07:08:23 +00:00
{
float suspensionDamping;
int wheelIndex;
if (PyArg_ParseTuple(args,"fi:setSuspensionDamping",&suspensionDamping,&wheelIndex))
2006-02-21 07:08:23 +00:00
{
m_vehicle->SetSuspensionDamping(suspensionDamping,wheelIndex);
} else {
return NULL;
2006-02-21 07:08:23 +00:00
}
Py_RETURN_NONE;
2006-02-21 07:08:23 +00:00
}
2012-09-16 04:58:18 +00:00
PyObject *KX_VehicleWrapper::PySetSuspensionCompression(PyObject *args)
2006-02-21 07:08:23 +00:00
{
float suspensionCompression;
int wheelIndex;
if (PyArg_ParseTuple(args,"fi:setSuspensionCompression",&suspensionCompression,&wheelIndex))
2006-02-21 07:08:23 +00:00
{
m_vehicle->SetSuspensionCompression(suspensionCompression,wheelIndex);
} else {
return NULL;
2006-02-21 07:08:23 +00:00
}
Py_RETURN_NONE;
2006-02-21 07:08:23 +00:00
}
2012-09-16 04:58:18 +00:00
PyObject *KX_VehicleWrapper::PySetRollInfluence(PyObject *args)
2006-02-21 07:08:23 +00:00
{
float rollInfluence;
int wheelIndex;
if (PyArg_ParseTuple(args,"fi:setRollInfluence",&rollInfluence,&wheelIndex))
2006-02-21 07:08:23 +00:00
{
m_vehicle->SetRollInfluence(rollInfluence,wheelIndex);
}
else {
return NULL;
}
Py_RETURN_NONE;
2006-02-21 07:08:23 +00:00
}
2012-09-16 04:58:18 +00:00
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;
}
2012-09-16 04:58:18 +00:00
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;
}
2012-09-16 04:58:18 +00:00
PyObject *KX_VehicleWrapper::PyGetConstraintType(PyObject *args)
{
return PyLong_FromLong(m_vehicle->GetUserConstraintType());
}
//python specific stuff
PyTypeObject KX_VehicleWrapper::Type = {
PyVarObject_HEAD_INIT(NULL, 0)
2009-08-10 00:07:34 +00:00
"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},
2006-02-21 07:08:23 +00:00
{"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},
2006-02-21 07:08:23 +00:00
{"setRollInfluence",(PyCFunction) KX_VehicleWrapper::sPySetRollInfluence, METH_VARARGS},
{NULL,NULL} //Sentinel
};
PyAttributeDef KX_VehicleWrapper::Attributes[] = {
{ NULL } //Sentinel
};
#endif // WITH_PYTHON