whitespace edits, had odd space/tab mix
[blender.git] / source / gameengine / Ketsji / KX_PyConstraintBinding.cpp
index a7d213bff791905fed2f364b3a1bbe6897622d86..0600e59a1ecb728c805a6d0c906d5455f9e4930b 100644 (file)
@@ -92,8 +92,8 @@ static char gPyGetAppliedImpulse__doc__[] = "getAppliedImpulse(int constraintId)
 
 
 static PyObject* gPySetGravity(PyObject* self,
-                                                                                PyObject* args, 
-                                                                                PyObject* kwds)
+                               PyObject* args,
+                               PyObject* kwds)
 {
        float x,y,z;
        if (PyArg_ParseTuple(args,"fff",&x,&y,&z))
@@ -109,8 +109,8 @@ static PyObject* gPySetGravity(PyObject* self,
 }
 
 static PyObject* gPySetDebugMode(PyObject* self,
-                                                                                PyObject* args, 
-                                                                                PyObject* kwds)
+                                 PyObject* args,
+                                 PyObject* kwds)
 {
        int mode;
        if (PyArg_ParseTuple(args,"i",&mode))
@@ -132,8 +132,8 @@ static PyObject* gPySetDebugMode(PyObject* self,
 
 
 static PyObject* gPySetNumTimeSubSteps(PyObject* self,
-                                                                                PyObject* args, 
-                                                                                PyObject* kwds)
+                                       PyObject* args,
+                                       PyObject* kwds)
 {
        int substep;
        if (PyArg_ParseTuple(args,"i",&substep))
@@ -151,8 +151,8 @@ static PyObject* gPySetNumTimeSubSteps(PyObject* self,
 
 
 static PyObject* gPySetNumIterations(PyObject* self,
-                                                                                PyObject* args, 
-                                                                                PyObject* kwds)
+                                     PyObject* args,
+                                     PyObject* kwds)
 {
        int iter;
        if (PyArg_ParseTuple(args,"i",&iter))
@@ -169,10 +169,9 @@ static PyObject* gPySetNumIterations(PyObject* self,
 }
 
 
-
 static PyObject* gPySetDeactivationTime(PyObject* self,
-                                                                                PyObject* args, 
-                                                                                PyObject* kwds)
+                                        PyObject* args,
+                                        PyObject* kwds)
 {
        float deactive_time;
        if (PyArg_ParseTuple(args,"f",&deactive_time))
@@ -190,8 +189,8 @@ static PyObject* gPySetDeactivationTime(PyObject* self,
 
 
 static PyObject* gPySetDeactivationLinearTreshold(PyObject* self,
-                                                                                PyObject* args, 
-                                                                                PyObject* kwds)
+                                                  PyObject* args,
+                                                  PyObject* kwds)
 {
        float linearDeactivationTreshold;
        if (PyArg_ParseTuple(args,"f",&linearDeactivationTreshold))
@@ -209,8 +208,8 @@ static PyObject* gPySetDeactivationLinearTreshold(PyObject* self,
 
 
 static PyObject* gPySetDeactivationAngularTreshold(PyObject* self,
-                                                                                PyObject* args, 
-                                                                                PyObject* kwds)
+                                                   PyObject* args,
+                                                   PyObject* kwds)
 {
        float angularDeactivationTreshold;
        if (PyArg_ParseTuple(args,"f",&angularDeactivationTreshold))
@@ -227,8 +226,8 @@ static PyObject* gPySetDeactivationAngularTreshold(PyObject* self,
 }
 
 static PyObject* gPySetContactBreakingTreshold(PyObject* self,
-                                                                                PyObject* args, 
-                                                                                PyObject* kwds)
+                                               PyObject* args,
+                                               PyObject* kwds)
 {
        float contactBreakingTreshold;
        if (PyArg_ParseTuple(args,"f",&contactBreakingTreshold))
@@ -246,8 +245,8 @@ static PyObject* gPySetContactBreakingTreshold(PyObject* self,
 
 
 static PyObject* gPySetCcdMode(PyObject* self,
-                                                                                PyObject* args, 
-                                                                                PyObject* kwds)
+                               PyObject* args,
+                               PyObject* kwds)
 {
        float ccdMode;
        if (PyArg_ParseTuple(args,"f",&ccdMode))
@@ -264,8 +263,8 @@ static PyObject* gPySetCcdMode(PyObject* self,
 }
 
 static PyObject* gPySetSorConstant(PyObject* self,
-                                                                                PyObject* args, 
-                                                                                PyObject* kwds)
+                                   PyObject* args,
+                                   PyObject* kwds)
 {
        float sor;
        if (PyArg_ParseTuple(args,"f",&sor))
@@ -282,8 +281,8 @@ static PyObject* gPySetSorConstant(PyObject* self,
 }
 
 static PyObject* gPySetSolverTau(PyObject* self,
-                                                                                PyObject* args, 
-                                                                                PyObject* kwds)
+                                 PyObject* args,
+                                 PyObject* kwds)
 {
        float tau;
        if (PyArg_ParseTuple(args,"f",&tau))
@@ -301,8 +300,8 @@ static PyObject* gPySetSolverTau(PyObject* self,
 
 
 static PyObject* gPySetSolverDamping(PyObject* self,
-                                                                                PyObject* args, 
-                                                                                PyObject* kwds)
+                                     PyObject* args,
+                                     PyObject* kwds)
 {
        float damping;
        if (PyArg_ParseTuple(args,"f",&damping))
@@ -319,8 +318,8 @@ static PyObject* gPySetSolverDamping(PyObject* self,
 }
 
 static PyObject* gPySetLinearAirDamping(PyObject* self,
-                                                                                PyObject* args, 
-                                                                                PyObject* kwds)
+                                        PyObject* args,
+                                        PyObject* kwds)
 {
        float damping;
        if (PyArg_ParseTuple(args,"f",&damping))
@@ -338,8 +337,8 @@ static PyObject* gPySetLinearAirDamping(PyObject* self,
 
 
 static PyObject* gPySetUseEpa(PyObject* self,
-                                                                                PyObject* args, 
-                                                                                PyObject* kwds)
+                              PyObject* args,
+                              PyObject* kwds)
 {
        int     epa;
        if (PyArg_ParseTuple(args,"i",&epa))
@@ -355,8 +354,8 @@ static PyObject* gPySetUseEpa(PyObject* self,
        Py_RETURN_NONE;
 }
 static PyObject* gPySetSolverType(PyObject* self,
-                                                                                PyObject* args, 
-                                                                                PyObject* kwds)
+                                  PyObject* args,
+                                  PyObject* kwds)
 {
        int     solverType;
        if (PyArg_ParseTuple(args,"i",&solverType))
@@ -375,8 +374,8 @@ static PyObject* gPySetSolverType(PyObject* self,
 
 
 static PyObject* gPyGetVehicleConstraint(PyObject* self,
-                                                                                PyObject* args, 
-                                                                                PyObject* kwds)
+                                         PyObject* args,
+                                         PyObject* kwds)
 {
 #if defined(_WIN64)
        __int64 constraintid;
@@ -406,9 +405,6 @@ static PyObject* gPyGetVehicleConstraint(PyObject* self,
 }
 
 
-
-
-
 static PyObject* gPyCreateConstraint(PyObject* self,
                                                                                 PyObject* args, 
                                                                                 PyObject* kwds)
@@ -433,48 +429,48 @@ static PyObject* gPyCreateConstraint(PyObject* self,
                success = PyArg_ParseTuple(args,"lli",&physicsid,&physicsid2,&constrainttype);
 #endif
        }
-       else
-       if (len ==6)
-       {
+       else {
+               if (len ==6) {
 #if defined(_WIN64)
-               success = PyArg_ParseTuple(args,"LLifff",&physicsid,&physicsid2,&constrainttype,
-                       &pivotX,&pivotY,&pivotZ);
+                       success = PyArg_ParseTuple(args,"LLifff",&physicsid,&physicsid2,&constrainttype,
+                                                  &pivotX,&pivotY,&pivotZ);
 #else
-               success = PyArg_ParseTuple(args,"llifff",&physicsid,&physicsid2,&constrainttype,
-                                                                  &pivotX,&pivotY,&pivotZ);            
+                       success = PyArg_ParseTuple(args,"llifff",&physicsid,&physicsid2,&constrainttype,
+                                                  &pivotX,&pivotY,&pivotZ);
 #endif 
-       }
-       else if (len == 9)
-       {
+               }
+               else if (len == 9)
+               {
 #if defined(_WIN64)
-               success = PyArg_ParseTuple(args,"LLiffffff",&physicsid,&physicsid2,&constrainttype,
-                       &pivotX,&pivotY,&pivotZ,&axisX,&axisY,&axisZ);
+                       success = PyArg_ParseTuple(args,"LLiffffff",&physicsid,&physicsid2,&constrainttype,
+                                                  &pivotX,&pivotY,&pivotZ,&axisX,&axisY,&axisZ);
 #else
-               success = PyArg_ParseTuple(args,"lliffffff",&physicsid,&physicsid2,&constrainttype,
-                                                                  &pivotX,&pivotY,&pivotZ,&axisX,&axisY,&axisZ);
+                       success = PyArg_ParseTuple(args,"lliffffff",&physicsid,&physicsid2,&constrainttype,
+                                                  &pivotX,&pivotY,&pivotZ,&axisX,&axisY,&axisZ);
 #endif
-       
-       }
-       else if (len == 10)
-       {
+
+               }
+               else if (len == 10)
+               {
 #if defined(_WIN64)
-               success = PyArg_ParseTuple(args,"LLiffffffi",&physicsid,&physicsid2,&constrainttype,
-                       &pivotX,&pivotY,&pivotZ,&axisX,&axisY,&axisZ,&flag);
+                       success = PyArg_ParseTuple(args,"LLiffffffi",&physicsid,&physicsid2,&constrainttype,
+                                                  &pivotX,&pivotY,&pivotZ,&axisX,&axisY,&axisZ,&flag);
 #else
-               success = PyArg_ParseTuple(args,"lliffffffi",&physicsid,&physicsid2,&constrainttype,
-                                                                  &pivotX,&pivotY,&pivotZ,&axisX,&axisY,&axisZ,&flag);
+                       success = PyArg_ParseTuple(args,"lliffffffi",&physicsid,&physicsid2,&constrainttype,
+                                                  &pivotX,&pivotY,&pivotZ,&axisX,&axisY,&axisZ,&flag);
 #endif
-       }
-       else if (len==4)
-       {
+               }
+               else if (len==4)
+               {
 #if defined(_WIN64)
-               success = PyArg_ParseTuple(args,"LLii",&physicsid,&physicsid2,&constrainttype,&extrainfo);
+                       success = PyArg_ParseTuple(args,"LLii",&physicsid,&physicsid2,&constrainttype,&extrainfo);
 #else
-               success = PyArg_ParseTuple(args,"llii",&physicsid,&physicsid2,&constrainttype,&extrainfo);
+                       success = PyArg_ParseTuple(args,"llii",&physicsid,&physicsid2,&constrainttype,&extrainfo);
 #endif
-               pivotX=extrainfo;
+                       pivotX=extrainfo;
+               }
        }
-       
+
        if (success)
        {
                if (PHY_GetActiveEnvironment())
@@ -498,20 +494,18 @@ static PyObject* gPyCreateConstraint(PyObject* self,
                                        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,
+                                                                                                   (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);
                                }
                                
                                KX_ConstraintWrapper* wrap = new KX_ConstraintWrapper((enum PHY_ConstraintType)constrainttype,constraintid,PHY_GetActiveEnvironment());
-                               
 
                                return wrap->NewProxy(true);
                        }
@@ -530,8 +524,8 @@ static PyObject* gPyCreateConstraint(PyObject* self,
 
 
 static PyObject* gPyGetAppliedImpulse(PyObject* self,
-                                                                                PyObject* args, 
-                                                                                PyObject* kwds)
+                                      PyObject* args,
+                                      PyObject* kwds)
 {
        float   appliedImpulse = 0.f;
 
@@ -557,8 +551,8 @@ static PyObject* gPyGetAppliedImpulse(PyObject* self,
 
 
 static PyObject* gPyRemoveConstraint(PyObject* self,
-                                                                                PyObject* args, 
-                                                                                PyObject* kwds)
+                                     PyObject* args,
+                                     PyObject* kwds)
 {
 #if defined(_WIN64)
        __int64 constraintid;
@@ -585,7 +579,7 @@ static PyObject* gPyExportBulletFile(PyObject*, PyObject* args)
        char* filename;
        if (!PyArg_ParseTuple(args,"s:exportBulletFile",&filename))
                return NULL;
-               
+
        if (PHY_GetActiveEnvironment())
        {
                PHY_GetActiveEnvironment()->exportFile(filename);
@@ -594,62 +588,61 @@ static PyObject* gPyExportBulletFile(PyObject*, PyObject* args)
 }
 
 static struct PyMethodDef physicsconstraints_methods[] = {
-  {"setGravity",(PyCFunction) gPySetGravity,
-   METH_VARARGS, (const char *)gPySetGravity__doc__},
-  {"setDebugMode",(PyCFunction) gPySetDebugMode,
-   METH_VARARGS, (const char *)gPySetDebugMode__doc__},
-
-   /// settings that influence quality of the rigidbody dynamics
-  {"setNumIterations",(PyCFunction) gPySetNumIterations,
-   METH_VARARGS, (const char *)gPySetNumIterations__doc__},
-
-   {"setNumTimeSubSteps",(PyCFunction) gPySetNumTimeSubSteps,
-   METH_VARARGS, (const char *)gPySetNumTimeSubSteps__doc__},
-
-  {"setDeactivationTime",(PyCFunction) gPySetDeactivationTime,
-   METH_VARARGS, (const char *)gPySetDeactivationTime__doc__},
-
-  {"setDeactivationLinearTreshold",(PyCFunction) gPySetDeactivationLinearTreshold,
-   METH_VARARGS, (const char *)gPySetDeactivationLinearTreshold__doc__},
-  {"setDeactivationAngularTreshold",(PyCFunction) gPySetDeactivationAngularTreshold,
-   METH_VARARGS, (const char *)gPySetDeactivationAngularTreshold__doc__},
-
-   {"setContactBreakingTreshold",(PyCFunction) gPySetContactBreakingTreshold,
-   METH_VARARGS, (const char *)gPySetContactBreakingTreshold__doc__},
-     {"setCcdMode",(PyCFunction) gPySetCcdMode,
-   METH_VARARGS, (const char *)gPySetCcdMode__doc__},
-     {"setSorConstant",(PyCFunction) gPySetSorConstant,
-   METH_VARARGS, (const char *)gPySetSorConstant__doc__},
-       {"setSolverTau",(PyCFunction) gPySetSolverTau,
-   METH_VARARGS, (const char *)gPySetSolverTau__doc__},
-        {"setSolverDamping",(PyCFunction) gPySetSolverDamping,
-   METH_VARARGS, (const char *)gPySetSolverDamping__doc__},
-
-         {"setLinearAirDamping",(PyCFunction) gPySetLinearAirDamping,
-   METH_VARARGS, (const char *)gPySetLinearAirDamping__doc__},
-
-    {"setUseEpa",(PyCFunction) gPySetUseEpa,
-   METH_VARARGS, (const char *)gPySetUseEpa__doc__},
+       {"setGravity",(PyCFunction) gPySetGravity,
+        METH_VARARGS, (const char*)gPySetGravity__doc__},
+       {"setDebugMode",(PyCFunction) gPySetDebugMode,
+        METH_VARARGS, (const char *)gPySetDebugMode__doc__},
+
+       /// settings that influence quality of the rigidbody dynamics
+       {"setNumIterations",(PyCFunction) gPySetNumIterations,
+        METH_VARARGS, (const char *)gPySetNumIterations__doc__},
+
+       {"setNumTimeSubSteps",(PyCFunction) gPySetNumTimeSubSteps,
+        METH_VARARGS, (const char *)gPySetNumTimeSubSteps__doc__},
+
+       {"setDeactivationTime",(PyCFunction) gPySetDeactivationTime,
+        METH_VARARGS, (const char *)gPySetDeactivationTime__doc__},
+
+       {"setDeactivationLinearTreshold",(PyCFunction) gPySetDeactivationLinearTreshold,
+        METH_VARARGS, (const char *)gPySetDeactivationLinearTreshold__doc__},
+       {"setDeactivationAngularTreshold",(PyCFunction) gPySetDeactivationAngularTreshold,
+        METH_VARARGS, (const char *)gPySetDeactivationAngularTreshold__doc__},
+
+       {"setContactBreakingTreshold",(PyCFunction) gPySetContactBreakingTreshold,
+        METH_VARARGS, (const char *)gPySetContactBreakingTreshold__doc__},
+       {"setCcdMode",(PyCFunction) gPySetCcdMode,
+        METH_VARARGS, (const char *)gPySetCcdMode__doc__},
+       {"setSorConstant",(PyCFunction) gPySetSorConstant,
+        METH_VARARGS, (const char *)gPySetSorConstant__doc__},
+       {"setSolverTau",(PyCFunction) gPySetSolverTau,
+        METH_VARARGS, (const char *)gPySetSolverTau__doc__},
+       {"setSolverDamping",(PyCFunction) gPySetSolverDamping,
+        METH_VARARGS, (const char *)gPySetSolverDamping__doc__},
+
+       {"setLinearAirDamping",(PyCFunction) gPySetLinearAirDamping,
+        METH_VARARGS, (const char *)gPySetLinearAirDamping__doc__},
+
+       {"setUseEpa",(PyCFunction) gPySetUseEpa,
+        METH_VARARGS, (const char *)gPySetUseEpa__doc__},
        {"setSolverType",(PyCFunction) gPySetSolverType,
-   METH_VARARGS, (const char *)gPySetSolverType__doc__},
+        METH_VARARGS, (const char *)gPySetSolverType__doc__},
 
 
-  {"createConstraint",(PyCFunction) gPyCreateConstraint,
-   METH_VARARGS, (const char *)gPyCreateConstraint__doc__},
-     {"getVehicleConstraint",(PyCFunction) gPyGetVehicleConstraint,
-   METH_VARARGS, (const char *)gPyGetVehicleConstraint__doc__},
+       {"createConstraint",(PyCFunction) gPyCreateConstraint,
+        METH_VARARGS, (const char *)gPyCreateConstraint__doc__},
+       {"getVehicleConstraint",(PyCFunction) gPyGetVehicleConstraint,
+        METH_VARARGS, (const char *)gPyGetVehicleConstraint__doc__},
 
-  {"removeConstraint",(PyCFunction) gPyRemoveConstraint,
-   METH_VARARGS, (const char *)gPyRemoveConstraint__doc__},
+       {"removeConstraint",(PyCFunction) gPyRemoveConstraint,
+        METH_VARARGS, (const char *)gPyRemoveConstraint__doc__},
        {"getAppliedImpulse",(PyCFunction) gPyGetAppliedImpulse,
-   METH_VARARGS, (const char *)gPyGetAppliedImpulse__doc__},
-
-     {"exportBulletFile",(PyCFunction)gPyExportBulletFile,
-       METH_VARARGS, "export a .bullet file"},
+        METH_VARARGS, (const char *)gPyGetAppliedImpulse__doc__},
 
+       {"exportBulletFile",(PyCFunction)gPyExportBulletFile,
+        METH_VARARGS, "export a .bullet file"},
 
-   //sentinel
-  { NULL, (PyCFunction) NULL, 0, NULL }
+       //sentinel
+       { NULL, (PyCFunction) NULL, 0, NULL }
 };
 
 static struct PyModuleDef PhysicsConstraints_module_def = {
@@ -664,13 +657,13 @@ static struct PyModuleDef PhysicsConstraints_module_def = {
        0,  /* m_free */
 };
 
-PyObject*      initPythonConstraintBinding()
+PyObject* initPythonConstraintBinding()
 {
 
-  PyObject* ErrorObject;
-  PyObject* m;
-  PyObject* d;
-  PyObject* item;
+       PyObject* ErrorObject;
+       PyObject* m;
+       PyObject* d;
+       PyObject* item;
 
        /* Use existing module where possible
         * be careful not to init any runtime vars after this */
@@ -686,44 +679,43 @@ PyObject* initPythonConstraintBinding()
                PyDict_SetItemString(PySys_GetObject("modules"), PhysicsConstraints_module_def.m_name, m);
        }
 
-  // Add some symbolic constants to the module
-  d = PyModule_GetDict(m);
-  ErrorObject = PyUnicode_FromString("PhysicsConstraints.error");
-  PyDict_SetItemString(d, "error", ErrorObject);
-  Py_DECREF(ErrorObject);
+       // Add some symbolic constants to the module
+       d = PyModule_GetDict(m);
+       ErrorObject = PyUnicode_FromString("PhysicsConstraints.error");
+       PyDict_SetItemString(d, "error", ErrorObject);
+       Py_DECREF(ErrorObject);
 
 #ifdef USE_BULLET
-  //Debug Modes constants to be used with setDebugMode() python function
-  KX_MACRO_addTypesToDict(d, DBG_NODEBUG, btIDebugDraw::DBG_NoDebug);
-  KX_MACRO_addTypesToDict(d, DBG_DRAWWIREFRAME, btIDebugDraw::DBG_DrawWireframe);
-  KX_MACRO_addTypesToDict(d, DBG_DRAWAABB, btIDebugDraw::DBG_DrawAabb);
-  KX_MACRO_addTypesToDict(d, DBG_DRAWFREATURESTEXT, btIDebugDraw::DBG_DrawFeaturesText);
-  KX_MACRO_addTypesToDict(d, DBG_DRAWCONTACTPOINTS, btIDebugDraw::DBG_DrawContactPoints);
-  KX_MACRO_addTypesToDict(d, DBG_NOHELPTEXT, btIDebugDraw::DBG_NoHelpText);
-  KX_MACRO_addTypesToDict(d, DBG_DRAWTEXT, btIDebugDraw::DBG_DrawText);
-  KX_MACRO_addTypesToDict(d, DBG_PROFILETIMINGS, btIDebugDraw::DBG_ProfileTimings);
-  KX_MACRO_addTypesToDict(d, DBG_ENABLESATCOMPARISION, btIDebugDraw::DBG_EnableSatComparison);
-  KX_MACRO_addTypesToDict(d, DBG_DISABLEBULLETLCP, btIDebugDraw::DBG_DisableBulletLCP);
-  KX_MACRO_addTypesToDict(d, DBG_ENABLECDD, btIDebugDraw::DBG_EnableCCD);
-  KX_MACRO_addTypesToDict(d, DBG_DRAWCONSTRAINTS, btIDebugDraw::DBG_DrawConstraints);
-  KX_MACRO_addTypesToDict(d, DBG_DRAWCONSTRAINTLIMITS, btIDebugDraw::DBG_DrawConstraintLimits);
-  KX_MACRO_addTypesToDict(d, DBG_FASTWIREFRAME, btIDebugDraw::DBG_FastWireframe);
+       //Debug Modes constants to be used with setDebugMode() python function
+       KX_MACRO_addTypesToDict(d, DBG_NODEBUG, btIDebugDraw::DBG_NoDebug);
+       KX_MACRO_addTypesToDict(d, DBG_DRAWWIREFRAME, btIDebugDraw::DBG_DrawWireframe);
+       KX_MACRO_addTypesToDict(d, DBG_DRAWAABB, btIDebugDraw::DBG_DrawAabb);
+       KX_MACRO_addTypesToDict(d, DBG_DRAWFREATURESTEXT, btIDebugDraw::DBG_DrawFeaturesText);
+       KX_MACRO_addTypesToDict(d, DBG_DRAWCONTACTPOINTS, btIDebugDraw::DBG_DrawContactPoints);
+       KX_MACRO_addTypesToDict(d, DBG_NOHELPTEXT, btIDebugDraw::DBG_NoHelpText);
+       KX_MACRO_addTypesToDict(d, DBG_DRAWTEXT, btIDebugDraw::DBG_DrawText);
+       KX_MACRO_addTypesToDict(d, DBG_PROFILETIMINGS, btIDebugDraw::DBG_ProfileTimings);
+       KX_MACRO_addTypesToDict(d, DBG_ENABLESATCOMPARISION, btIDebugDraw::DBG_EnableSatComparison);
+       KX_MACRO_addTypesToDict(d, DBG_DISABLEBULLETLCP, btIDebugDraw::DBG_DisableBulletLCP);
+       KX_MACRO_addTypesToDict(d, DBG_ENABLECDD, btIDebugDraw::DBG_EnableCCD);
+       KX_MACRO_addTypesToDict(d, DBG_DRAWCONSTRAINTS, btIDebugDraw::DBG_DrawConstraints);
+       KX_MACRO_addTypesToDict(d, DBG_DRAWCONSTRAINTLIMITS, btIDebugDraw::DBG_DrawConstraintLimits);
+       KX_MACRO_addTypesToDict(d, DBG_FASTWIREFRAME, btIDebugDraw::DBG_FastWireframe);
 #endif // USE_BULLET
 
-  //Constraint types to be used with createConstraint() python function
-  KX_MACRO_addTypesToDict(d, POINTTOPOINT_CONSTRAINT, PHY_POINT2POINT_CONSTRAINT);
-  KX_MACRO_addTypesToDict(d, LINEHINGE_CONSTRAINT, PHY_LINEHINGE_CONSTRAINT);
-  KX_MACRO_addTypesToDict(d, ANGULAR_CONSTRAINT, PHY_ANGULAR_CONSTRAINT);
-  KX_MACRO_addTypesToDict(d, CONETWIST_CONSTRAINT, PHY_CONE_TWIST_CONSTRAINT);
-  KX_MACRO_addTypesToDict(d, VEHICLE_CONSTRAINT, PHY_VEHICLE_CONSTRAINT);
+       //Constraint types to be used with createConstraint() python function
+       KX_MACRO_addTypesToDict(d, POINTTOPOINT_CONSTRAINT, PHY_POINT2POINT_CONSTRAINT);
+       KX_MACRO_addTypesToDict(d, LINEHINGE_CONSTRAINT, PHY_LINEHINGE_CONSTRAINT);
+       KX_MACRO_addTypesToDict(d, ANGULAR_CONSTRAINT, PHY_ANGULAR_CONSTRAINT);
+       KX_MACRO_addTypesToDict(d, CONETWIST_CONSTRAINT, PHY_CONE_TWIST_CONSTRAINT);
+       KX_MACRO_addTypesToDict(d, VEHICLE_CONSTRAINT, PHY_VEHICLE_CONSTRAINT);
 
-  // Check for errors
-  if (PyErr_Occurred())
-    {
-      Py_FatalError("can't initialize module PhysicsConstraints");
-    }
+       // Check for errors
+       if (PyErr_Occurred()) {
+               Py_FatalError("can't initialize module PhysicsConstraints");
+       }
 
-  return d;
+       return d;
 }
 
 
@@ -741,7 +733,4 @@ PHY_IPhysicsEnvironment*    PHY_GetActiveEnvironment()
        return g_CurrentActivePhysicsEnvironment;
 }
 
-
-
 #endif // WITH_PYTHON
-