blender/source/gameengine/Ketsji/KX_PyConstraintBinding.cpp

664 lines
16 KiB
C++
Raw Normal View History

2002-10-12 11:37:38 +00:00
/**
* $Id$
*
* ***** BEGIN GPL LICENSE BLOCK *****
2002-10-12 11:37:38 +00:00
*
* 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.
2002-10-12 11:37:38 +00:00
*
* 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,
2010-02-12 13:34:04 +00:00
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
2002-10-12 11:37:38 +00:00
*
* 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 *****
2002-10-12 11:37:38 +00:00
*/
#include "KX_PyConstraintBinding.h"
#include "PHY_IPhysicsEnvironment.h"
#include "KX_ConstraintWrapper.h"
#include "KX_VehicleWrapper.h"
2002-10-12 11:37:38 +00:00
#include "KX_PhysicsObjectWrapper.h"
#include "PHY_IPhysicsController.h"
#include "PHY_IVehicle.h"
#include "MT_Matrix3x3.h"
2002-10-12 11:37:38 +00:00
#include "PyObjectPlus.h"
#ifdef WITH_PYTHON
2002-10-12 11:37:38 +00:00
// nasty glob variable to connect scripting language
// if there is a better way (without global), please do so!
static PHY_IPhysicsEnvironment* g_CurrentActivePhysicsEnvironment = NULL;
2002-10-12 11:37:38 +00:00
static char PhysicsConstraints_module_documentation[] =
"This is the Python API for the Physics Constraints";
static char gPySetGravity__doc__[] = "setGravity(float x,float y,float z)";
static char gPySetDebugMode__doc__[] = "setDebugMode(int mode)";
static char gPySetNumIterations__doc__[] = "setNumIterations(int numiter) This sets the number of iterations for an iterative constraint solver";
static char gPySetNumTimeSubSteps__doc__[] = "setNumTimeSubSteps(int numsubstep) This sets the number of substeps for each physics proceed. Tradeoff quality for performance.";
static char gPySetDeactivationTime__doc__[] = "setDeactivationTime(float time) This sets the time after which a resting rigidbody gets deactived";
static char gPySetDeactivationLinearTreshold__doc__[] = "setDeactivationLinearTreshold(float linearTreshold)";
static char gPySetDeactivationAngularTreshold__doc__[] = "setDeactivationAngularTreshold(float angularTreshold)";
static char gPySetContactBreakingTreshold__doc__[] = "setContactBreakingTreshold(float breakingTreshold) Reasonable default is 0.02 (if units are meters)";
static char gPySetCcdMode__doc__[] = "setCcdMode(int ccdMode) Very experimental, not recommended";
static char gPySetSorConstant__doc__[] = "setSorConstant(float sor) Very experimental, not recommended";
static char gPySetSolverTau__doc__[] = "setTau(float tau) Very experimental, not recommended";
static char gPySetSolverDamping__doc__[] = "setDamping(float damping) Very experimental, not recommended";
static char gPySetLinearAirDamping__doc__[] = "setLinearAirDamping(float damping) Very experimental, not recommended";
static char gPySetUseEpa__doc__[] = "setUseEpa(int epa) Very experimental, not recommended";
static char gPySetSolverType__doc__[] = "setSolverType(int solverType) Very experimental, not recommended";
2002-10-12 11:37:38 +00:00
static char gPyCreateConstraint__doc__[] = "createConstraint(ob1,ob2,float restLength,float restitution,float damping)";
static char gPyGetVehicleConstraint__doc__[] = "getVehicleConstraint(int constraintId)";
static char gPyRemoveConstraint__doc__[] = "removeConstraint(int constraintId)";
static char gPyGetAppliedImpulse__doc__[] = "getAppliedImpulse(int constraintId)";
2002-10-12 11:37:38 +00:00
2002-10-12 11:37:38 +00:00
static PyObject* gPySetGravity(PyObject* self,
PyObject* args,
PyObject* kwds)
{
float x,y,z;
if (PyArg_ParseTuple(args,"fff",&x,&y,&z))
2002-10-12 11:37:38 +00:00
{
if (PHY_GetActiveEnvironment())
PHY_GetActiveEnvironment()->setGravity(x,y,z);
2002-10-12 11:37:38 +00:00
}
else {
return NULL;
}
Py_RETURN_NONE;
2002-10-12 11:37:38 +00:00
}
static PyObject* gPySetDebugMode(PyObject* self,
PyObject* args,
PyObject* kwds)
{
int mode;
if (PyArg_ParseTuple(args,"i",&mode))
{
if (PHY_GetActiveEnvironment())
{
PHY_GetActiveEnvironment()->setDebugMode(mode);
}
}
else {
return NULL;
}
Py_RETURN_NONE;
}
static PyObject* gPySetNumTimeSubSteps(PyObject* self,
PyObject* args,
PyObject* kwds)
{
int substep;
if (PyArg_ParseTuple(args,"i",&substep))
{
if (PHY_GetActiveEnvironment())
{
PHY_GetActiveEnvironment()->setNumTimeSubSteps(substep);
}
}
else {
return NULL;
}
Py_RETURN_NONE;
}
static PyObject* gPySetNumIterations(PyObject* self,
PyObject* args,
PyObject* kwds)
{
int iter;
if (PyArg_ParseTuple(args,"i",&iter))
{
if (PHY_GetActiveEnvironment())
{
PHY_GetActiveEnvironment()->setNumIterations(iter);
}
}
else {
return NULL;
}
Py_RETURN_NONE;
}
2002-10-12 11:37:38 +00:00
static PyObject* gPySetDeactivationTime(PyObject* self,
PyObject* args,
PyObject* kwds)
{
float deactive_time;
if (PyArg_ParseTuple(args,"f",&deactive_time))
{
if (PHY_GetActiveEnvironment())
{
PHY_GetActiveEnvironment()->setDeactivationTime(deactive_time);
}
}
else {
return NULL;
}
Py_RETURN_NONE;
}
static PyObject* gPySetDeactivationLinearTreshold(PyObject* self,
PyObject* args,
PyObject* kwds)
{
float linearDeactivationTreshold;
if (PyArg_ParseTuple(args,"f",&linearDeactivationTreshold))
{
if (PHY_GetActiveEnvironment())
{
PHY_GetActiveEnvironment()->setDeactivationLinearTreshold( linearDeactivationTreshold);
}
}
else {
return NULL;
}
Py_RETURN_NONE;
}
static PyObject* gPySetDeactivationAngularTreshold(PyObject* self,
PyObject* args,
PyObject* kwds)
{
float angularDeactivationTreshold;
if (PyArg_ParseTuple(args,"f",&angularDeactivationTreshold))
{
if (PHY_GetActiveEnvironment())
{
PHY_GetActiveEnvironment()->setDeactivationAngularTreshold( angularDeactivationTreshold);
}
}
else {
return NULL;
}
Py_RETURN_NONE;
}
static PyObject* gPySetContactBreakingTreshold(PyObject* self,
PyObject* args,
PyObject* kwds)
{
float contactBreakingTreshold;
if (PyArg_ParseTuple(args,"f",&contactBreakingTreshold))
{
if (PHY_GetActiveEnvironment())
{
PHY_GetActiveEnvironment()->setContactBreakingTreshold( contactBreakingTreshold);
}
}
else {
return NULL;
}
Py_RETURN_NONE;
}
static PyObject* gPySetCcdMode(PyObject* self,
PyObject* args,
PyObject* kwds)
{
float ccdMode;
if (PyArg_ParseTuple(args,"f",&ccdMode))
{
if (PHY_GetActiveEnvironment())
{
PHY_GetActiveEnvironment()->setCcdMode( ccdMode);
}
}
else {
return NULL;
}
Py_RETURN_NONE;
}
static PyObject* gPySetSorConstant(PyObject* self,
PyObject* args,
PyObject* kwds)
{
float sor;
if (PyArg_ParseTuple(args,"f",&sor))
{
if (PHY_GetActiveEnvironment())
{
PHY_GetActiveEnvironment()->setSolverSorConstant( sor);
}
}
else {
return NULL;
}
Py_RETURN_NONE;
}
static PyObject* gPySetSolverTau(PyObject* self,
PyObject* args,
PyObject* kwds)
{
float tau;
if (PyArg_ParseTuple(args,"f",&tau))
{
if (PHY_GetActiveEnvironment())
{
PHY_GetActiveEnvironment()->setSolverTau( tau);
}
}
else {
return NULL;
}
Py_RETURN_NONE;
}
static PyObject* gPySetSolverDamping(PyObject* self,
PyObject* args,
PyObject* kwds)
{
float damping;
if (PyArg_ParseTuple(args,"f",&damping))
{
if (PHY_GetActiveEnvironment())
{
PHY_GetActiveEnvironment()->setSolverDamping( damping);
}
}
else {
return NULL;
}
Py_RETURN_NONE;
}
2002-10-12 11:37:38 +00:00
static PyObject* gPySetLinearAirDamping(PyObject* self,
PyObject* args,
PyObject* kwds)
{
float damping;
if (PyArg_ParseTuple(args,"f",&damping))
{
if (PHY_GetActiveEnvironment())
{
PHY_GetActiveEnvironment()->setLinearAirDamping( damping);
}
}
else {
return NULL;
}
Py_RETURN_NONE;
}
static PyObject* gPySetUseEpa(PyObject* self,
PyObject* args,
PyObject* kwds)
{
int epa;
if (PyArg_ParseTuple(args,"i",&epa))
{
if (PHY_GetActiveEnvironment())
{
PHY_GetActiveEnvironment()->setUseEpa(epa);
}
}
else {
return NULL;
}
Py_RETURN_NONE;
}
static PyObject* gPySetSolverType(PyObject* self,
PyObject* args,
PyObject* kwds)
{
int solverType;
if (PyArg_ParseTuple(args,"i",&solverType))
{
if (PHY_GetActiveEnvironment())
{
PHY_GetActiveEnvironment()->setSolverType(solverType);
}
}
else {
return NULL;
}
Py_RETURN_NONE;
}
static PyObject* gPyGetVehicleConstraint(PyObject* self,
PyObject* args,
PyObject* kwds)
{
#if defined(_WIN64)
__int64 constraintid;
if (PyArg_ParseTuple(args,"L",&constraintid))
#else
long constraintid;
if (PyArg_ParseTuple(args,"l",&constraintid))
#endif
{
if (PHY_GetActiveEnvironment())
{
PHY_IVehicle* vehicle = PHY_GetActiveEnvironment()->getVehicleConstraint(constraintid);
if (vehicle)
{
KX_VehicleWrapper* pyWrapper = new KX_VehicleWrapper(vehicle,PHY_GetActiveEnvironment());
return pyWrapper->NewProxy(true);
}
}
}
else {
return NULL;
}
Py_RETURN_NONE;
}
2002-10-12 11:37:38 +00:00
static PyObject* gPyCreateConstraint(PyObject* self,
PyObject* args,
PyObject* kwds)
{
int physicsid=0,physicsid2 = 0,constrainttype=0,extrainfo=0;
int len = PyTuple_Size(args);
int success = 1;
int flag = 0;
2002-10-12 11:37:38 +00:00
float pivotX=1,pivotY=1,pivotZ=1,axisX=0,axisY=0,axisZ=1;
if (len == 3)
{
success = PyArg_ParseTuple(args,"iii",&physicsid,&physicsid2,&constrainttype);
}
else
if (len ==6)
{
success = PyArg_ParseTuple(args,"iiifff",&physicsid,&physicsid2,&constrainttype,
&pivotX,&pivotY,&pivotZ);
}
else if (len == 9)
{
success = PyArg_ParseTuple(args,"iiiffffff",&physicsid,&physicsid2,&constrainttype,
&pivotX,&pivotY,&pivotZ,&axisX,&axisY,&axisZ);
}
else if (len == 10)
{
success = PyArg_ParseTuple(args,"iiiffffffi",&physicsid,&physicsid2,&constrainttype,
&pivotX,&pivotY,&pivotZ,&axisX,&axisY,&axisZ,&flag);
}
2002-10-12 11:37:38 +00:00
else if (len==4)
{
success = PyArg_ParseTuple(args,"iiii",&physicsid,&physicsid2,&constrainttype,&extrainfo);
pivotX=extrainfo;
}
if (success)
{
if (PHY_GetActiveEnvironment())
2002-10-12 11:37:38 +00:00
{
PHY_IPhysicsController* physctrl = (PHY_IPhysicsController*) physicsid;
PHY_IPhysicsController* physctrl2 = (PHY_IPhysicsController*) physicsid2;
if (physctrl) //TODO:check for existence of this pointer!
2002-10-12 11:37:38 +00:00
{
PHY_ConstraintType ct = (PHY_ConstraintType) constrainttype;
int constraintid =0;
if (ct == PHY_GENERIC_6DOF_CONSTRAINT)
{
//convert from euler angle into axis
float radsPerDeg = 6.283185307179586232f / 360.f;
//we need to pass a full constraint frame, not just axis
//localConstraintFrameBasis
MT_Matrix3x3 localCFrame(MT_Vector3(radsPerDeg*axisX,radsPerDeg*axisY,radsPerDeg*axisZ));
MT_Vector3 axis0 = localCFrame.getColumn(0);
MT_Vector3 axis1 = localCFrame.getColumn(1);
MT_Vector3 axis2 = localCFrame.getColumn(2);
constraintid = PHY_GetActiveEnvironment()->createConstraint(physctrl,physctrl2,(enum PHY_ConstraintType)constrainttype,
pivotX,pivotY,pivotZ,
(float)axis0.x(),(float)axis0.y(),(float)axis0.z(),
(float)axis1.x(),(float)axis1.y(),(float)axis1.z(),
(float)axis2.x(),(float)axis2.y(),(float)axis2.z(),flag);
} else
{
constraintid = PHY_GetActiveEnvironment()->createConstraint(physctrl,physctrl2,(enum PHY_ConstraintType)constrainttype,pivotX,pivotY,pivotZ,axisX,axisY,axisZ,0);
}
2002-10-12 11:37:38 +00:00
KX_ConstraintWrapper* wrap = new KX_ConstraintWrapper((enum PHY_ConstraintType)constrainttype,constraintid,PHY_GetActiveEnvironment());
2002-10-12 11:37:38 +00:00
return wrap->NewProxy(true);
2002-10-12 11:37:38 +00:00
}
}
}
else {
return NULL;
}
2002-10-12 11:37:38 +00:00
Py_RETURN_NONE;
2002-10-12 11:37:38 +00:00
}
static PyObject* gPyGetAppliedImpulse(PyObject* self,
PyObject* args,
PyObject* kwds)
{
float appliedImpulse = 0.f;
#if defined(_WIN64)
__int64 constraintid;
if (PyArg_ParseTuple(args,"L",&constraintid))
#else
long constraintid;
if (PyArg_ParseTuple(args,"l",&constraintid))
#endif
{
if (PHY_GetActiveEnvironment())
{
appliedImpulse = PHY_GetActiveEnvironment()->getAppliedImpulse(constraintid);
}
}
else {
return NULL;
}
return PyFloat_FromDouble(appliedImpulse);
}
2002-10-12 11:37:38 +00:00
static PyObject* gPyRemoveConstraint(PyObject* self,
PyObject* args,
PyObject* kwds)
{
#if defined(_WIN64)
__int64 constraintid;
if (PyArg_ParseTuple(args,"L",&constraintid))
#else
long constraintid;
if (PyArg_ParseTuple(args,"l",&constraintid))
#endif
2002-10-12 11:37:38 +00:00
{
if (PHY_GetActiveEnvironment())
2002-10-12 11:37:38 +00:00
{
PHY_GetActiveEnvironment()->removeConstraint(constraintid);
2002-10-12 11:37:38 +00:00
}
}
else {
return NULL;
}
Py_RETURN_NONE;
2002-10-12 11:37:38 +00:00
}
static struct PyMethodDef physicsconstraints_methods[] = {
{"setGravity",(PyCFunction) gPySetGravity,
2009-08-10 00:07:34 +00:00
METH_VARARGS, (const char *)gPySetGravity__doc__},
{"setDebugMode",(PyCFunction) gPySetDebugMode,
2009-08-10 00:07:34 +00:00
METH_VARARGS, (const char *)gPySetDebugMode__doc__},
/// settings that influence quality of the rigidbody dynamics
{"setNumIterations",(PyCFunction) gPySetNumIterations,
2009-08-10 00:07:34 +00:00
METH_VARARGS, (const char *)gPySetNumIterations__doc__},
{"setNumTimeSubSteps",(PyCFunction) gPySetNumTimeSubSteps,
2009-08-10 00:07:34 +00:00
METH_VARARGS, (const char *)gPySetNumTimeSubSteps__doc__},
{"setDeactivationTime",(PyCFunction) gPySetDeactivationTime,
2009-08-10 00:07:34 +00:00
METH_VARARGS, (const char *)gPySetDeactivationTime__doc__},
{"setDeactivationLinearTreshold",(PyCFunction) gPySetDeactivationLinearTreshold,
2009-08-10 00:07:34 +00:00
METH_VARARGS, (const char *)gPySetDeactivationLinearTreshold__doc__},
{"setDeactivationAngularTreshold",(PyCFunction) gPySetDeactivationAngularTreshold,
2009-08-10 00:07:34 +00:00
METH_VARARGS, (const char *)gPySetDeactivationAngularTreshold__doc__},
{"setContactBreakingTreshold",(PyCFunction) gPySetContactBreakingTreshold,
2009-08-10 00:07:34 +00:00
METH_VARARGS, (const char *)gPySetContactBreakingTreshold__doc__},
{"setCcdMode",(PyCFunction) gPySetCcdMode,
2009-08-10 00:07:34 +00:00
METH_VARARGS, (const char *)gPySetCcdMode__doc__},
{"setSorConstant",(PyCFunction) gPySetSorConstant,
2009-08-10 00:07:34 +00:00
METH_VARARGS, (const char *)gPySetSorConstant__doc__},
{"setSolverTau",(PyCFunction) gPySetSolverTau,
2009-08-10 00:07:34 +00:00
METH_VARARGS, (const char *)gPySetSolverTau__doc__},
{"setSolverDamping",(PyCFunction) gPySetSolverDamping,
2009-08-10 00:07:34 +00:00
METH_VARARGS, (const char *)gPySetSolverDamping__doc__},
{"setLinearAirDamping",(PyCFunction) gPySetLinearAirDamping,
2009-08-10 00:07:34 +00:00
METH_VARARGS, (const char *)gPySetLinearAirDamping__doc__},
{"setUseEpa",(PyCFunction) gPySetUseEpa,
2009-08-10 00:07:34 +00:00
METH_VARARGS, (const char *)gPySetUseEpa__doc__},
{"setSolverType",(PyCFunction) gPySetSolverType,
2009-08-10 00:07:34 +00:00
METH_VARARGS, (const char *)gPySetSolverType__doc__},
2002-10-12 11:37:38 +00:00
{"createConstraint",(PyCFunction) gPyCreateConstraint,
2009-08-10 00:07:34 +00:00
METH_VARARGS, (const char *)gPyCreateConstraint__doc__},
{"getVehicleConstraint",(PyCFunction) gPyGetVehicleConstraint,
2009-08-10 00:07:34 +00:00
METH_VARARGS, (const char *)gPyGetVehicleConstraint__doc__},
2002-10-12 11:37:38 +00:00
{"removeConstraint",(PyCFunction) gPyRemoveConstraint,
2009-08-10 00:07:34 +00:00
METH_VARARGS, (const char *)gPyRemoveConstraint__doc__},
{"getAppliedImpulse",(PyCFunction) gPyGetAppliedImpulse,
2009-08-10 00:07:34 +00:00
METH_VARARGS, (const char *)gPyGetAppliedImpulse__doc__},
2002-10-12 11:37:38 +00:00
//sentinel
{ NULL, (PyCFunction) NULL, 0, NULL }
};
static struct PyModuleDef PhysicsConstraints_module_def = {
{}, /* m_base */
"PhysicsConstraints", /* m_name */
PhysicsConstraints_module_documentation, /* m_doc */
0, /* m_size */
physicsconstraints_methods, /* m_methods */
0, /* m_reload */
0, /* m_traverse */
0, /* m_clear */
0, /* m_free */
};
2002-10-12 11:37:38 +00:00
PyObject* initPythonConstraintBinding()
{
PyObject* ErrorObject;
PyObject* m;
PyObject* d;
/* Use existing module where possible
* be careful not to init any runtime vars after this */
m = PyImport_ImportModule( "PhysicsConstraints" );
if(m) {
Py_DECREF(m);
return m;
}
else {
PyErr_Clear();
2009-08-10 00:07:34 +00:00
m = PyModule_Create(&PhysicsConstraints_module_def);
PyDict_SetItemString(PySys_GetObject("modules"), PhysicsConstraints_module_def.m_name, m);
}
2002-10-12 11:37:38 +00:00
// Add some symbolic constants to the module
d = PyModule_GetDict(m);
ErrorObject = PyUnicode_FromString("PhysicsConstraints.error");
2002-10-12 11:37:38 +00:00
PyDict_SetItemString(d, "error", ErrorObject);
2009-04-06 08:17:04 +00:00
Py_DECREF(ErrorObject);
2002-10-12 11:37:38 +00:00
// XXXX Add constants here
// Check for errors
if (PyErr_Occurred())
{
Py_FatalError("can't initialize module PhysicsConstraints");
}
return d;
}
void KX_RemovePythonConstraintBinding()
{
}
void PHY_SetActiveEnvironment(class PHY_IPhysicsEnvironment* env)
{
g_CurrentActivePhysicsEnvironment = env;
2002-10-12 11:37:38 +00:00
}
PHY_IPhysicsEnvironment* PHY_GetActiveEnvironment()
{
return g_CurrentActivePhysicsEnvironment;
}
#endif // WITH_PYTHON