2002-10-12 11:37:38 +00:00
/**
* $ Id $
*
2008-04-16 22:40:48 +00:00
* * * * * * 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
2008-04-16 22:40:48 +00:00
* 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 ,
* Inc . , 59 Temple Place - Suite 330 , Boston , MA 02111 - 1307 , 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 .
*
2008-04-16 22:40:48 +00:00
* * * * * * END GPL LICENSE BLOCK * * * * *
2002-10-12 11:37:38 +00:00
*/
# include "KX_PyConstraintBinding.h"
# include "PHY_IPhysicsEnvironment.h"
# include "KX_ConstraintWrapper.h"
2006-01-30 20:33:59 +00:00
# include "KX_VehicleWrapper.h"
2002-10-12 11:37:38 +00:00
# include "KX_PhysicsObjectWrapper.h"
# include "PHY_IPhysicsController.h"
2006-01-30 20:33:59 +00:00
# include "PHY_IVehicle.h"
2009-05-24 00:42:40 +00:00
# include "MT_Matrix3x3.h"
2002-10-12 11:37:38 +00:00
2008-09-06 14:13:31 +00:00
# include "PyObjectPlus.h"
2008-09-06 02:46:11 +00:00
2002-11-25 15:29:57 +00:00
# ifdef HAVE_CONFIG_H
# include <config.h>
# endif
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!
2005-03-25 10:33:39 +00:00
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) " ;
2005-08-02 14:59:49 +00:00
static char gPySetDebugMode__doc__ [ ] = " setDebugMode(int mode) " ;
2005-08-03 18:22:30 +00:00
static char gPySetNumIterations__doc__ [ ] = " setNumIterations(int numiter) This sets the number of iterations for an iterative constraint solver " ;
2006-05-22 21:03:43 +00:00
static char gPySetNumTimeSubSteps__doc__ [ ] = " setNumTimeSubSteps(int numsubstep) This sets the number of substeps for each physics proceed. Tradeoff quality for performance. " ;
2005-08-03 18:22:30 +00:00
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) " ;
2005-08-04 19:07:39 +00:00
static char gPySetCcdMode__doc__ [ ] = " setCcdMode(int ccdMode) Very experimental, not recommended " ;
2005-08-03 18:22:30 +00:00
static char gPySetSorConstant__doc__ [ ] = " setSorConstant(float sor) Very experimental, not recommended " ;
2005-08-04 19:07:39 +00:00
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 " ;
2005-08-03 18:22:30 +00:00
2002-10-12 11:37:38 +00:00
static char gPyCreateConstraint__doc__ [ ] = " createConstraint(ob1,ob2,float restLength,float restitution,float damping) " ;
2006-01-30 20:33:59 +00:00
static char gPyGetVehicleConstraint__doc__ [ ] = " getVehicleConstraint(int constraintId) " ;
static char gPyRemoveConstraint__doc__ [ ] = " removeConstraint(int constraintId) " ;
2006-07-03 05:58:23 +00:00
static char gPyGetAppliedImpulse__doc__ [ ] = " getAppliedImpulse(int constraintId) " ;
2002-10-12 11:37:38 +00:00
2005-08-02 14:59:49 +00:00
2005-08-03 18:22:30 +00:00
2002-10-12 11:37:38 +00:00
static PyObject * gPySetGravity ( PyObject * self ,
PyObject * args ,
PyObject * kwds )
{
float x , y , z ;
2008-07-01 16:43:46 +00:00
if ( PyArg_ParseTuple ( args , " fff " , & x , & y , & z ) )
2002-10-12 11:37:38 +00:00
{
2005-03-25 10:33:39 +00:00
if ( PHY_GetActiveEnvironment ( ) )
PHY_GetActiveEnvironment ( ) - > setGravity ( x , y , z ) ;
2002-10-12 11:37:38 +00:00
}
2008-07-01 16:43:46 +00:00
else {
return NULL ;
}
2008-08-14 03:23:36 +00:00
Py_RETURN_NONE ;
2002-10-12 11:37:38 +00:00
}
2005-08-02 14:59:49 +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 ) ;
}
}
2008-07-01 16:43:46 +00:00
else {
return NULL ;
}
2008-08-14 03:23:36 +00:00
Py_RETURN_NONE ;
2005-08-03 18:22:30 +00:00
}
2005-08-02 14:59:49 +00:00
2006-05-22 21:03:43 +00:00
static PyObject * gPySetNumTimeSubSteps ( PyObject * self ,
PyObject * args ,
PyObject * kwds )
{
int substep ;
if ( PyArg_ParseTuple ( args , " i " , & substep ) )
{
if ( PHY_GetActiveEnvironment ( ) )
{
PHY_GetActiveEnvironment ( ) - > setNumTimeSubSteps ( substep ) ;
}
}
2008-07-01 16:43:46 +00:00
else {
return NULL ;
}
2008-08-14 03:23:36 +00:00
Py_RETURN_NONE ;
2006-05-22 21:03:43 +00:00
}
2005-08-03 18:22:30 +00:00
static PyObject * gPySetNumIterations ( PyObject * self ,
PyObject * args ,
PyObject * kwds )
{
int iter ;
if ( PyArg_ParseTuple ( args , " i " , & iter ) )
{
if ( PHY_GetActiveEnvironment ( ) )
{
PHY_GetActiveEnvironment ( ) - > setNumIterations ( iter ) ;
}
}
2008-07-01 16:43:46 +00:00
else {
return NULL ;
}
2008-08-14 03:23:36 +00:00
Py_RETURN_NONE ;
2005-08-02 14:59:49 +00:00
}
2002-10-12 11:37:38 +00:00
2005-08-03 18:22:30 +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 ) ;
}
}
2008-07-01 16:43:46 +00:00
else {
return NULL ;
}
2008-08-14 03:23:36 +00:00
Py_RETURN_NONE ;
2005-08-03 18:22:30 +00:00
}
static PyObject * gPySetDeactivationLinearTreshold ( PyObject * self ,
PyObject * args ,
PyObject * kwds )
{
float linearDeactivationTreshold ;
if ( PyArg_ParseTuple ( args , " f " , & linearDeactivationTreshold ) )
{
if ( PHY_GetActiveEnvironment ( ) )
{
PHY_GetActiveEnvironment ( ) - > setDeactivationLinearTreshold ( linearDeactivationTreshold ) ;
}
}
2008-07-01 16:43:46 +00:00
else {
return NULL ;
}
2008-08-14 03:23:36 +00:00
Py_RETURN_NONE ;
2005-08-03 18:22:30 +00:00
}
static PyObject * gPySetDeactivationAngularTreshold ( PyObject * self ,
PyObject * args ,
PyObject * kwds )
{
float angularDeactivationTreshold ;
if ( PyArg_ParseTuple ( args , " f " , & angularDeactivationTreshold ) )
{
if ( PHY_GetActiveEnvironment ( ) )
{
PHY_GetActiveEnvironment ( ) - > setDeactivationAngularTreshold ( angularDeactivationTreshold ) ;
}
}
2008-07-01 16:43:46 +00:00
else {
return NULL ;
}
2008-08-14 03:23:36 +00:00
Py_RETURN_NONE ;
2005-08-03 18:22:30 +00:00
}
static PyObject * gPySetContactBreakingTreshold ( PyObject * self ,
PyObject * args ,
PyObject * kwds )
{
float contactBreakingTreshold ;
if ( PyArg_ParseTuple ( args , " f " , & contactBreakingTreshold ) )
{
if ( PHY_GetActiveEnvironment ( ) )
{
PHY_GetActiveEnvironment ( ) - > setContactBreakingTreshold ( contactBreakingTreshold ) ;
}
}
2008-07-01 16:43:46 +00:00
else {
return NULL ;
}
2008-08-14 03:23:36 +00:00
Py_RETURN_NONE ;
2005-08-03 18:22:30 +00:00
}
static PyObject * gPySetCcdMode ( PyObject * self ,
PyObject * args ,
PyObject * kwds )
{
float ccdMode ;
if ( PyArg_ParseTuple ( args , " f " , & ccdMode ) )
{
if ( PHY_GetActiveEnvironment ( ) )
{
PHY_GetActiveEnvironment ( ) - > setCcdMode ( ccdMode ) ;
}
}
2008-07-01 16:43:46 +00:00
else {
return NULL ;
}
2008-08-14 03:23:36 +00:00
Py_RETURN_NONE ;
2005-08-03 18:22:30 +00:00
}
static PyObject * gPySetSorConstant ( PyObject * self ,
PyObject * args ,
PyObject * kwds )
{
float sor ;
if ( PyArg_ParseTuple ( args , " f " , & sor ) )
{
if ( PHY_GetActiveEnvironment ( ) )
{
PHY_GetActiveEnvironment ( ) - > setSolverSorConstant ( sor ) ;
}
}
2008-07-01 16:43:46 +00:00
else {
return NULL ;
}
2008-08-14 03:23:36 +00:00
Py_RETURN_NONE ;
2005-08-03 18:22:30 +00:00
}
2005-08-04 19:07:39 +00:00
static PyObject * gPySetSolverTau ( PyObject * self ,
2005-08-03 18:22:30 +00:00
PyObject * args ,
PyObject * kwds )
{
float tau ;
if ( PyArg_ParseTuple ( args , " f " , & tau ) )
{
if ( PHY_GetActiveEnvironment ( ) )
{
2005-08-04 19:07:39 +00:00
PHY_GetActiveEnvironment ( ) - > setSolverTau ( tau ) ;
2005-08-03 18:22:30 +00:00
}
}
2008-07-01 16:43:46 +00:00
else {
return NULL ;
}
2008-08-14 03:23:36 +00:00
Py_RETURN_NONE ;
2005-08-03 18:22:30 +00:00
}
2005-08-04 19:07:39 +00:00
static PyObject * gPySetSolverDamping ( PyObject * self ,
2005-08-03 18:22:30 +00:00
PyObject * args ,
PyObject * kwds )
{
float damping ;
if ( PyArg_ParseTuple ( args , " f " , & damping ) )
{
if ( PHY_GetActiveEnvironment ( ) )
{
2005-08-04 19:07:39 +00:00
PHY_GetActiveEnvironment ( ) - > setSolverDamping ( damping ) ;
2005-08-03 18:22:30 +00:00
}
}
2008-07-01 16:43:46 +00:00
else {
return NULL ;
}
2008-08-14 03:23:36 +00:00
Py_RETURN_NONE ;
2005-08-03 18:22:30 +00:00
}
2002-10-12 11:37:38 +00:00
2005-08-04 19:07:39 +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 ) ;
}
}
2008-07-01 16:43:46 +00:00
else {
return NULL ;
}
2008-08-14 03:23:36 +00:00
Py_RETURN_NONE ;
2005-08-04 19:07:39 +00:00
}
static PyObject * gPySetUseEpa ( PyObject * self ,
PyObject * args ,
PyObject * kwds )
{
int epa ;
if ( PyArg_ParseTuple ( args , " i " , & epa ) )
{
if ( PHY_GetActiveEnvironment ( ) )
{
PHY_GetActiveEnvironment ( ) - > setUseEpa ( epa ) ;
}
}
2008-07-01 16:43:46 +00:00
else {
return NULL ;
}
2008-08-14 03:23:36 +00:00
Py_RETURN_NONE ;
2005-08-04 19:07:39 +00:00
}
static PyObject * gPySetSolverType ( PyObject * self ,
PyObject * args ,
PyObject * kwds )
{
int solverType ;
if ( PyArg_ParseTuple ( args , " i " , & solverType ) )
{
if ( PHY_GetActiveEnvironment ( ) )
{
PHY_GetActiveEnvironment ( ) - > setSolverType ( solverType ) ;
}
}
2008-07-01 16:43:46 +00:00
else {
return NULL ;
}
2008-08-14 03:23:36 +00:00
Py_RETURN_NONE ;
2005-08-04 19:07:39 +00:00
}
2006-01-30 20:33:59 +00:00
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 ( ) ) ;
2009-04-19 12:46:39 +00:00
return pyWrapper - > NewProxy ( true ) ;
2006-01-30 20:33:59 +00:00
}
}
}
2008-07-01 16:43:46 +00:00
else {
return NULL ;
}
2006-01-30 20:33:59 +00:00
2008-08-14 03:23:36 +00:00
Py_RETURN_NONE ;
2006-01-30 20:33:59 +00:00
}
2005-08-04 19:07:39 +00:00
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 ;
PhysicsConstraints.createConstraint:
allow to dynamically create rigid body constraints while disable collision detection between connected bodies, pass as 10th argument the flag 128
PhysiPython KX_ConstraintWrapper, setParam
export setParam(paramIndex,paramValue0,paramValue1) for Physics constraints
paramIndex 0,1,2 are linear limits, 3,4,5 are angular limits, 6,7,8 are linear motors, 9,10,11 are angular motors
For example:
disableConnectedBodies=128
cons = PhysicsConstraints.createConstraint(oid,rid,generic6dof,pivotInAx,pivotInAy,pivotInAz,angleX,angleY,angleZ,disableConnectedBodies)
#params 0,1,2 are linear limits, low,high value. if low > high then disable limit
cons.setParam(0,0,0)
I will provide an example .blend for Blender 2.49
2009-05-24 01:55:24 +00:00
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 ) ;
}
PhysicsConstraints.createConstraint:
allow to dynamically create rigid body constraints while disable collision detection between connected bodies, pass as 10th argument the flag 128
PhysiPython KX_ConstraintWrapper, setParam
export setParam(paramIndex,paramValue0,paramValue1) for Physics constraints
paramIndex 0,1,2 are linear limits, 3,4,5 are angular limits, 6,7,8 are linear motors, 9,10,11 are angular motors
For example:
disableConnectedBodies=128
cons = PhysicsConstraints.createConstraint(oid,rid,generic6dof,pivotInAx,pivotInAy,pivotInAz,angleX,angleY,angleZ,disableConnectedBodies)
#params 0,1,2 are linear limits, low,high value. if low > high then disable limit
cons.setParam(0,0,0)
I will provide an example .blend for Blender 2.49
2009-05-24 01:55:24 +00:00
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 )
{
2005-03-25 10:33:39 +00:00
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 existance of this pointer!
{
2009-05-24 00:42:40 +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 ( ) ,
PhysicsConstraints.createConstraint:
allow to dynamically create rigid body constraints while disable collision detection between connected bodies, pass as 10th argument the flag 128
PhysiPython KX_ConstraintWrapper, setParam
export setParam(paramIndex,paramValue0,paramValue1) for Physics constraints
paramIndex 0,1,2 are linear limits, 3,4,5 are angular limits, 6,7,8 are linear motors, 9,10,11 are angular motors
For example:
disableConnectedBodies=128
cons = PhysicsConstraints.createConstraint(oid,rid,generic6dof,pivotInAx,pivotInAy,pivotInAz,angleX,angleY,angleZ,disableConnectedBodies)
#params 0,1,2 are linear limits, low,high value. if low > high then disable limit
cons.setParam(0,0,0)
I will provide an example .blend for Blender 2.49
2009-05-24 01:55:24 +00:00
( float ) axis2 . x ( ) , ( float ) axis2 . y ( ) , ( float ) axis2 . z ( ) , flag ) ;
2009-05-24 00:42:40 +00:00
} 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
2005-03-25 10:33:39 +00:00
KX_ConstraintWrapper * wrap = new KX_ConstraintWrapper ( ( enum PHY_ConstraintType ) constrainttype , constraintid , PHY_GetActiveEnvironment ( ) ) ;
2002-10-12 11:37:38 +00:00
2009-04-19 12:46:39 +00:00
return wrap - > NewProxy ( true ) ;
2002-10-12 11:37:38 +00:00
}
}
}
2008-07-01 16:43:46 +00:00
else {
return NULL ;
}
2002-10-12 11:37:38 +00:00
2008-08-14 03:23:36 +00:00
Py_RETURN_NONE ;
2002-10-12 11:37:38 +00:00
}
2006-07-03 05:58:23 +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 ) ;
}
}
2008-07-01 16:43:46 +00:00
else {
return NULL ;
}
2006-07-03 05:58:23 +00:00
return PyFloat_FromDouble ( appliedImpulse ) ;
}
2002-10-12 11:37:38 +00:00
static PyObject * gPyRemoveConstraint ( PyObject * self ,
PyObject * args ,
PyObject * kwds )
{
2005-11-28 06:51:54 +00:00
# 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
{
2005-03-25 10:33:39 +00:00
if ( PHY_GetActiveEnvironment ( ) )
2002-10-12 11:37:38 +00:00
{
2006-01-15 11:34:55 +00:00
PHY_GetActiveEnvironment ( ) - > removeConstraint ( constraintid ) ;
2002-10-12 11:37:38 +00:00
}
}
2008-07-01 16:43:46 +00:00
else {
return NULL ;
}
2008-08-14 03:23:36 +00:00
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__ } ,
2005-08-02 14:59:49 +00:00
{ " setDebugMode " , ( PyCFunction ) gPySetDebugMode ,
2009-08-10 00:07:34 +00:00
METH_VARARGS , ( const char * ) gPySetDebugMode__doc__ } ,
2005-08-02 14:59:49 +00:00
2005-08-03 18:22:30 +00:00
/// 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__ } ,
2005-08-03 18:22:30 +00:00
2006-05-22 21:03:43 +00:00
{ " setNumTimeSubSteps " , ( PyCFunction ) gPySetNumTimeSubSteps ,
2009-08-10 00:07:34 +00:00
METH_VARARGS , ( const char * ) gPySetNumTimeSubSteps__doc__ } ,
2006-05-22 21:03:43 +00:00
2005-08-03 18:22:30 +00:00
{ " setDeactivationTime " , ( PyCFunction ) gPySetDeactivationTime ,
2009-08-10 00:07:34 +00:00
METH_VARARGS , ( const char * ) gPySetDeactivationTime__doc__ } ,
2005-08-03 18:22:30 +00:00
{ " setDeactivationLinearTreshold " , ( PyCFunction ) gPySetDeactivationLinearTreshold ,
2009-08-10 00:07:34 +00:00
METH_VARARGS , ( const char * ) gPySetDeactivationLinearTreshold__doc__ } ,
2005-08-03 18:22:30 +00:00
{ " setDeactivationAngularTreshold " , ( PyCFunction ) gPySetDeactivationAngularTreshold ,
2009-08-10 00:07:34 +00:00
METH_VARARGS , ( const char * ) gPySetDeactivationAngularTreshold__doc__ } ,
2005-08-03 18:22:30 +00:00
{ " setContactBreakingTreshold " , ( PyCFunction ) gPySetContactBreakingTreshold ,
2009-08-10 00:07:34 +00:00
METH_VARARGS , ( const char * ) gPySetContactBreakingTreshold__doc__ } ,
2005-08-03 18:22:30 +00:00
{ " setCcdMode " , ( PyCFunction ) gPySetCcdMode ,
2009-08-10 00:07:34 +00:00
METH_VARARGS , ( const char * ) gPySetCcdMode__doc__ } ,
2005-08-03 18:22:30 +00:00
{ " setSorConstant " , ( PyCFunction ) gPySetSorConstant ,
2009-08-10 00:07:34 +00:00
METH_VARARGS , ( const char * ) gPySetSorConstant__doc__ } ,
2005-08-04 19:07:39 +00:00
{ " setSolverTau " , ( PyCFunction ) gPySetSolverTau ,
2009-08-10 00:07:34 +00:00
METH_VARARGS , ( const char * ) gPySetSolverTau__doc__ } ,
2005-08-04 19:07:39 +00:00
{ " setSolverDamping " , ( PyCFunction ) gPySetSolverDamping ,
2009-08-10 00:07:34 +00:00
METH_VARARGS , ( const char * ) gPySetSolverDamping__doc__ } ,
2005-08-04 19:07:39 +00:00
{ " setLinearAirDamping " , ( PyCFunction ) gPySetLinearAirDamping ,
2009-08-10 00:07:34 +00:00
METH_VARARGS , ( const char * ) gPySetLinearAirDamping__doc__ } ,
2005-08-04 19:07:39 +00:00
{ " setUseEpa " , ( PyCFunction ) gPySetUseEpa ,
2009-08-10 00:07:34 +00:00
METH_VARARGS , ( const char * ) gPySetUseEpa__doc__ } ,
2005-08-04 19:07:39 +00:00
{ " setSolverType " , ( PyCFunction ) gPySetSolverType ,
2009-08-10 00:07:34 +00:00
METH_VARARGS , ( const char * ) gPySetSolverType__doc__ } ,
2005-08-03 18:22:30 +00:00
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__ } ,
2006-01-30 20:33:59 +00:00
{ " getVehicleConstraint " , ( PyCFunction ) gPyGetVehicleConstraint ,
2009-08-10 00:07:34 +00:00
METH_VARARGS , ( const char * ) gPyGetVehicleConstraint__doc__ } ,
2006-01-30 20:33:59 +00:00
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__ } ,
2006-07-03 05:58:23 +00:00
{ " getAppliedImpulse " , ( PyCFunction ) gPyGetAppliedImpulse ,
2009-08-10 00:07:34 +00:00
METH_VARARGS , ( const char * ) gPyGetAppliedImpulse__doc__ } ,
2006-07-03 05:58:23 +00:00
2002-10-12 11:37:38 +00:00
//sentinel
{ NULL , ( PyCFunction ) NULL , 0 , NULL }
} ;
2009-04-29 16:54:45 +00:00
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 ;
2009-04-29 23:39:27 +00:00
/* 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
2009-04-29 23:39:27 +00:00
m = PyModule_Create ( & PhysicsConstraints_module_def ) ;
2009-06-16 07:16:51 +00:00
PyDict_SetItemString ( PySys_GetObject ( " modules " ) , PhysicsConstraints_module_def . m_name , m ) ;
2009-04-29 23:39:27 +00:00
}
2002-10-12 11:37:38 +00:00
// Add some symbolic constants to the module
d = PyModule_GetDict ( m ) ;
2009-06-29 02:25:54 +00:00
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 )
{
2005-03-25 10:33:39 +00:00
g_CurrentActivePhysicsEnvironment = env ;
2002-10-12 11:37:38 +00:00
}
2005-03-25 10:33:39 +00:00
PHY_IPhysicsEnvironment * PHY_GetActiveEnvironment ( )
{
return g_CurrentActivePhysicsEnvironment ;
}