BGE API cleanup: ConstraintActuator.
authorBenoit Bolsee <benoit.bolsee@online.be>
Thu, 9 Apr 2009 23:10:12 +0000 (23:10 +0000)
committerBenoit Bolsee <benoit.bolsee@online.be>
Thu, 9 Apr 2009 23:10:12 +0000 (23:10 +0000)
source/gameengine/Ketsji/KX_ConstraintActuator.cpp
source/gameengine/Ketsji/KX_ConstraintActuator.h
source/gameengine/Ketsji/KX_PythonInit.cpp
source/gameengine/PyDoc/KX_ConstraintActuator.py
source/gameengine/PyDoc/KX_StateActuator.py

index feee851bb01f3a20c3ecc049652d00b9a4081628..b41435e71a1b4851b8b39ec055d074cb75a4de61 100644 (file)
@@ -36,6 +36,7 @@
 #include "MT_Matrix3x3.h"
 #include "KX_GameObject.h"
 #include "KX_RayCast.h"
+#include "blendef.h"
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
@@ -57,19 +58,21 @@ KX_ConstraintActuator::KX_ConstraintActuator(SCA_IObject *gameobj,
                                                                                         char *property,
                                                                                         PyTypeObject* T) : 
        SCA_IActuator(gameobj, T),
-       m_refDirection(refDir),
+       m_refDirVector(refDir),
        m_currentTime(0)
 {
+       m_refDirection[0] = refDir[0];
+       m_refDirection[1] = refDir[1];
+       m_refDirection[2] = refDir[2];
        m_posDampTime = posDampTime;
        m_rotDampTime = rotDampTime;
        m_locrot   = locrotxyz;
        m_option = option;
        m_activeTime = time;
        if (property) {
-               strncpy(m_property, property, sizeof(m_property));
-               m_property[sizeof(m_property)-1] = 0;
+               m_property = property;
        } else {
-               m_property[0] = 0;
+               m_property = "";
        }
        /* The units of bounds are determined by the type of constraint. To      */
        /* make the constraint application easier and more transparent later on, */
@@ -80,13 +83,16 @@ KX_ConstraintActuator::KX_ConstraintActuator(SCA_IObject *gameobj,
        case KX_ACT_CONSTRAINT_ORIY:
        case KX_ACT_CONSTRAINT_ORIZ:
                {
-                       MT_Scalar len = m_refDirection.length();
+                       MT_Scalar len = m_refDirVector.length();
                        if (MT_fuzzyZero(len)) {
                                // missing a valid direction
                                std::cout << "WARNING: Constraint actuator " << GetName() << ":  There is no valid reference direction!" << std::endl;
                                m_locrot = KX_ACT_CONSTRAINT_NODEF;
                        } else {
-                               m_refDirection /= len;
+                               m_refDirection[0] /= len;
+                               m_refDirection[1] /= len;
+                               m_refDirection[2] /= len;
+                               m_refDirVector /= len;
                        }
                        m_minimumBound = cos(minBound);
                        m_maximumBound = cos(maxBound);
@@ -116,7 +122,7 @@ bool KX_ConstraintActuator::RayHit(KX_ClientObjectInfo* client, KX_RayCast* resu
        
        bool bFound = false;
 
-       if (m_property[0] == 0)
+       if (m_property.IsEmpty())
        {
                bFound = true;
        }
@@ -126,7 +132,7 @@ bool KX_ConstraintActuator::RayHit(KX_ClientObjectInfo* client, KX_RayCast* resu
                {
                        if (client->m_auxilary_info)
                        {
-                               bFound = !strcmp(m_property, ((char*)client->m_auxilary_info));
+                               bFound = !strcmp(m_property.Ptr(), ((char*)client->m_auxilary_info));
                        }
                }
                else
@@ -209,7 +215,7 @@ bool KX_ConstraintActuator::Update(double curtime, bool frame)
                        if ((m_maximumBound < (1.0f-FLT_EPSILON)) || (m_minimumBound < (1.0f-FLT_EPSILON))) {
                                // reference direction needs to be evaluated
                                // 1. get the cosine between current direction and target
-                               cosangle = direction.dot(m_refDirection);
+                               cosangle = direction.dot(m_refDirVector);
                                if (cosangle >= (m_maximumBound-FLT_EPSILON) && cosangle <= (m_minimumBound+FLT_EPSILON)) {
                                        // no change to do
                                        result = true;
@@ -218,27 +224,27 @@ bool KX_ConstraintActuator::Update(double curtime, bool frame)
                                // 2. define a new reference direction
                                //    compute local axis with reference direction as X and
                                //    Y in direction X refDirection plane
-                               MT_Vector3 zaxis = m_refDirection.cross(direction);
+                               MT_Vector3 zaxis = m_refDirVector.cross(direction);
                                if (MT_fuzzyZero2(zaxis.length2())) {
                                        // direction and refDirection are identical,
                                        // choose any other direction to define plane
                                        if (direction[0] < 0.9999)
-                                               zaxis = m_refDirection.cross(MT_Vector3(1.0,0.0,0.0));
+                                               zaxis = m_refDirVector.cross(MT_Vector3(1.0,0.0,0.0));
                                        else
-                                               zaxis = m_refDirection.cross(MT_Vector3(0.0,1.0,0.0));
+                                               zaxis = m_refDirVector.cross(MT_Vector3(0.0,1.0,0.0));
                                }
-                               MT_Vector3 yaxis = zaxis.cross(m_refDirection);
+                               MT_Vector3 yaxis = zaxis.cross(m_refDirVector);
                                yaxis.normalize();
                                if (cosangle > m_minimumBound) {
                                        // angle is too close to reference direction,
                                        // choose a new reference that is exactly at minimum angle
-                                       refDirection = m_minimumBound * m_refDirection + m_minimumSine * yaxis;
+                                       refDirection = m_minimumBound * m_refDirVector + m_minimumSine * yaxis;
                                } else {
                                        // angle is too large, choose new reference direction at maximum angle
-                                       refDirection = m_maximumBound * m_refDirection + m_maximumSine * yaxis;
+                                       refDirection = m_maximumBound * m_refDirVector + m_maximumSine * yaxis;
                                }
                        } else {
-                               refDirection = m_refDirection;
+                               refDirection = m_refDirVector;
                        }
                        // apply damping on the direction
                        direction = filter*direction + (1.0-filter)*refDirection;
@@ -470,7 +476,7 @@ bool KX_ConstraintActuator::Update(double curtime, bool frame)
                                        // Fh force is stored in m_maximum
                                        MT_Scalar springForce = springExtent * m_maximumBound;
                                        // damping is stored in m_refDirection [0] = damping, [1] = rot damping
-                                       MT_Scalar springDamp = relativeVelocityRay * m_refDirection[0];
+                                       MT_Scalar springDamp = relativeVelocityRay * m_refDirVector[0];
                                        MT_Vector3 newVelocity = spc->GetLinearVelocity()-(springForce+springDamp)*direction;
                                        if (m_option & KX_ACT_CONSTRAINT_NORMAL)
                                        {
@@ -483,7 +489,7 @@ bool KX_ConstraintActuator::Update(double curtime, bool frame)
                                                MT_Vector3 angVelocity = spc->GetAngularVelocity();
                                                // remove component that is parallel to normal
                                                angVelocity -= angVelocity.dot(newnormal)*newnormal;
-                                               MT_Vector3 angDamp = angVelocity * ((m_refDirection[1]>MT_EPSILON)?m_refDirection[1]:m_refDirection[0]);
+                                               MT_Vector3 angDamp = angVelocity * ((m_refDirVector[1]>MT_EPSILON)?m_refDirVector[1]:m_refDirVector[0]);
                                                spc->SetAngularVelocity(spc->GetAngularVelocity()+(angSpring-angDamp), false);
                                        }
                                } else if (m_option & KX_ACT_CONSTRAINT_PERMANENT) {
@@ -587,6 +593,7 @@ PyParentObject KX_ConstraintActuator::Parents[] = {
 };
 
 PyMethodDef KX_ConstraintActuator::Methods[] = {
+       // Deprecated -->
        {"setDamp", (PyCFunction) KX_ConstraintActuator::sPySetDamp, METH_VARARGS, (PY_METHODCHAR)SetDamp_doc},
        {"getDamp", (PyCFunction) KX_ConstraintActuator::sPyGetDamp, METH_NOARGS, (PY_METHODCHAR)GetDamp_doc},
        {"setRotDamp", (PyCFunction) KX_ConstraintActuator::sPySetRotDamp, METH_VARARGS, (PY_METHODCHAR)SetRotDamp_doc},
@@ -609,17 +616,49 @@ PyMethodDef KX_ConstraintActuator::Methods[] = {
        {"getRayLength", (PyCFunction) KX_ConstraintActuator::sPyGetMax, METH_NOARGS, (PY_METHODCHAR)GetRayLength_doc},
        {"setLimit", (PyCFunction) KX_ConstraintActuator::sPySetLimit, METH_VARARGS, (PY_METHODCHAR)SetLimit_doc},
        {"getLimit", (PyCFunction) KX_ConstraintActuator::sPyGetLimit, METH_NOARGS, (PY_METHODCHAR)GetLimit_doc},
+       // <--
        {NULL,NULL} //Sentinel
 };
 
 PyAttributeDef KX_ConstraintActuator::Attributes[] = {
+       KX_PYATTRIBUTE_INT_RW("damp",0,100,true,KX_ConstraintActuator,m_posDampTime),
+       KX_PYATTRIBUTE_INT_RW("rotDamp",0,100,true,KX_ConstraintActuator,m_rotDampTime),
+       KX_PYATTRIBUTE_FLOAT_ARRAY_RW_CHECK("direction",-MAXFLOAT,MAXFLOAT,KX_ConstraintActuator,m_refDirection,3,pyattr_check_direction),
+       KX_PYATTRIBUTE_INT_RW("option",0,0xFFFF,false,KX_ConstraintActuator,m_option),
+       KX_PYATTRIBUTE_INT_RW("time",0,1000,true,KX_ConstraintActuator,m_activeTime),
+       KX_PYATTRIBUTE_STRING_RW("property",0,32,true,KX_ConstraintActuator,m_property),
+       KX_PYATTRIBUTE_FLOAT_RW("min",-MAXFLOAT,MAXFLOAT,KX_ConstraintActuator,m_minimumBound),
+       KX_PYATTRIBUTE_FLOAT_RW("distance",-MAXFLOAT,MAXFLOAT,KX_ConstraintActuator,m_minimumBound),
+       KX_PYATTRIBUTE_FLOAT_RW("max",-MAXFLOAT,MAXFLOAT,KX_ConstraintActuator,m_maximumBound),
+       KX_PYATTRIBUTE_FLOAT_RW("rayLength",0,2000.f,KX_ConstraintActuator,m_maximumBound),
+       KX_PYATTRIBUTE_INT_RW("limit",KX_ConstraintActuator::KX_ACT_CONSTRAINT_NODEF+1,KX_ConstraintActuator::KX_ACT_CONSTRAINT_MAX-1,false,KX_ConstraintActuator,m_locrot),
        { NULL }        //Sentinel
 };
 
-PyObject* KX_ConstraintActuator::py_getattro(PyObject *attr) {
+PyObject* KX_ConstraintActuator::py_getattro(PyObject *attr) 
+{
        py_getattro_up(SCA_IActuator);
 }
 
+int KX_ConstraintActuator::py_setattro(PyObject *attr, PyObject* value)
+{
+       py_setattro_up(SCA_IActuator);
+}
+
+
+int KX_ConstraintActuator::pyattr_check_direction(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef)
+{
+       KX_ConstraintActuator* act = static_cast<KX_ConstraintActuator*>(self);
+       MT_Vector3 dir(act->m_refDirection);
+       MT_Scalar len = dir.length();
+       if (MT_fuzzyZero(len)) {
+               PyErr_SetString(PyExc_ValueError, "Invalid direction");
+               return 1;
+       }
+       act->m_refDirVector = dir/len;
+       return 0;       
+}
+
 /* 2. setDamp                                                                */
 const char KX_ConstraintActuator::SetDamp_doc[] = 
 "setDamp(duration)\n"
@@ -629,6 +668,7 @@ const char KX_ConstraintActuator::SetDamp_doc[] =
 PyObject* KX_ConstraintActuator::PySetDamp(PyObject* self, 
                                                                                   PyObject* args, 
                                                                                   PyObject* kwds) {
+       ShowDeprecationWarning("setDamp()", "the damp property");
        int dampArg;
        if(!PyArg_ParseTuple(args, "i", &dampArg)) {
                return NULL;            
@@ -644,6 +684,7 @@ const char KX_ConstraintActuator::GetDamp_doc[] =
 "getDamp()\n"
 "\tReturns the damping parameter.\n";
 PyObject* KX_ConstraintActuator::PyGetDamp(PyObject* self){
+       ShowDeprecationWarning("getDamp()", "the damp property");
        return PyInt_FromLong(m_posDampTime);
 }
 
@@ -656,6 +697,7 @@ const char KX_ConstraintActuator::SetRotDamp_doc[] =
 PyObject* KX_ConstraintActuator::PySetRotDamp(PyObject* self, 
                                                                                      PyObject* args, 
                                                                                      PyObject* kwds) {
+       ShowDeprecationWarning("setRotDamp()", "the rotDamp property");
        int dampArg;
        if(!PyArg_ParseTuple(args, "i", &dampArg)) {
                return NULL;            
@@ -671,6 +713,7 @@ const char KX_ConstraintActuator::GetRotDamp_doc[] =
 "getRotDamp()\n"
 "\tReturns the damping time for application of the constraint.\n";
 PyObject* KX_ConstraintActuator::PyGetRotDamp(PyObject* self){
+       ShowDeprecationWarning("getRotDamp()", "the rotDamp property");
        return PyInt_FromLong(m_rotDampTime);
 }
 
@@ -682,6 +725,7 @@ const char KX_ConstraintActuator::SetDirection_doc[] =
 PyObject* KX_ConstraintActuator::PySetDirection(PyObject* self, 
                                                                                        PyObject* args, 
                                                                                        PyObject* kwds) {
+       ShowDeprecationWarning("setDirection()", "the direction property");
        float x, y, z;
        MT_Scalar len;
        MT_Vector3 dir;
@@ -697,7 +741,10 @@ PyObject* KX_ConstraintActuator::PySetDirection(PyObject* self,
                std::cout << "Invalid direction" << std::endl;
                return NULL;
        }
-       m_refDirection = dir/len;
+       m_refDirVector = dir/len;
+       m_refDirection[0] = x/len;
+       m_refDirection[1] = y/len;
+       m_refDirection[2] = z/len;
 
        Py_RETURN_NONE;
 }
@@ -706,6 +753,7 @@ const char KX_ConstraintActuator::GetDirection_doc[] =
 "getDirection()\n"
 "\tReturns the reference direction of the orientation constraint as a 3-tuple.\n";
 PyObject* KX_ConstraintActuator::PyGetDirection(PyObject* self){
+       ShowDeprecationWarning("getDirection()", "the direction property");
        PyObject *retVal = PyList_New(3);
 
        PyList_SetItem(retVal, 0, PyFloat_FromDouble(m_refDirection[0]));
@@ -727,6 +775,7 @@ const char KX_ConstraintActuator::SetOption_doc[] =
 PyObject* KX_ConstraintActuator::PySetOption(PyObject* self, 
                                                                                     PyObject* args, 
                                                                                     PyObject* kwds) {
+       ShowDeprecationWarning("setOption()", "the option property");
        int option;
        if(!PyArg_ParseTuple(args, "i", &option)) {
                return NULL;            
@@ -741,6 +790,7 @@ const char KX_ConstraintActuator::GetOption_doc[] =
 "getOption()\n"
 "\tReturns the option parameter.\n";
 PyObject* KX_ConstraintActuator::PyGetOption(PyObject* self){
+       ShowDeprecationWarning("getOption()", "the option property");
        return PyInt_FromLong(m_option);
 }
 
@@ -754,6 +804,7 @@ const char KX_ConstraintActuator::SetTime_doc[] =
 PyObject* KX_ConstraintActuator::PySetTime(PyObject* self, 
                                                                                   PyObject* args, 
                                                                                   PyObject* kwds) {
+       ShowDeprecationWarning("setTime()", "the time property");
        int t;
        if(!PyArg_ParseTuple(args, "i", &t)) {
                return NULL;            
@@ -770,6 +821,7 @@ const char KX_ConstraintActuator::GetTime_doc[] =
 "getTime()\n"
 "\tReturns the time parameter.\n";
 PyObject* KX_ConstraintActuator::PyGetTime(PyObject* self){
+       ShowDeprecationWarning("getTime()", "the time property");
        return PyInt_FromLong(m_activeTime);
 }
 
@@ -782,15 +834,15 @@ const char KX_ConstraintActuator::SetProperty_doc[] =
 PyObject* KX_ConstraintActuator::PySetProperty(PyObject* self, 
                                                                                       PyObject* args, 
                                                                                       PyObject* kwds) {
+       ShowDeprecationWarning("setProperty()", "the 'property' property");
        char *property;
        if (!PyArg_ParseTuple(args, "s", &property)) {
                return NULL;
        }
        if (property == NULL) {
-               m_property[0] = 0;
+               m_property = "";
        } else {
-               strncpy(m_property, property, sizeof(m_property));
-               m_property[sizeof(m_property)-1] = 0;
+               m_property = property;
        }
 
        Py_RETURN_NONE;
@@ -800,7 +852,8 @@ const char KX_ConstraintActuator::GetProperty_doc[] =
 "getProperty()\n"
 "\tReturns the property parameter.\n";
 PyObject* KX_ConstraintActuator::PyGetProperty(PyObject* self){
-       return PyString_FromString(m_property);
+       ShowDeprecationWarning("getProperty()", "the 'property' property");
+       return PyString_FromString(m_property.Ptr());
 }
 
 /* 4. setDistance                                                                 */
@@ -817,6 +870,7 @@ const char KX_ConstraintActuator::SetMin_doc[] =
 PyObject* KX_ConstraintActuator::PySetMin(PyObject* self, 
                                                                                  PyObject* args, 
                                                                                  PyObject* kwds) {
+       ShowDeprecationWarning("setMin() or setDistance()", "the min or distance property");
        float minArg;
        if(!PyArg_ParseTuple(args, "f", &minArg)) {
                return NULL;            
@@ -845,6 +899,7 @@ const char KX_ConstraintActuator::GetMin_doc[] =
 "\tReturns the lower value of the interval to which the value\n"
 "\tis clipped.\n";
 PyObject* KX_ConstraintActuator::PyGetMin(PyObject* self) {
+       ShowDeprecationWarning("getMin() or getDistance()", "the min or distance property");
        return PyFloat_FromDouble(m_minimumBound);
 }
 
@@ -862,6 +917,7 @@ const char KX_ConstraintActuator::SetMax_doc[] =
 PyObject* KX_ConstraintActuator::PySetMax(PyObject* self, 
                                                                                  PyObject* args, 
                                                                                  PyObject* kwds){
+       ShowDeprecationWarning("setMax() or setRayLength()", "the max or rayLength property");
        float maxArg;
        if(!PyArg_ParseTuple(args, "f", &maxArg)) {
                return NULL;            
@@ -890,6 +946,7 @@ const char KX_ConstraintActuator::GetMax_doc[] =
 "\tReturns the upper value of the interval to which the value\n"
 "\tis clipped.\n";
 PyObject* KX_ConstraintActuator::PyGetMax(PyObject* self) {
+       ShowDeprecationWarning("getMax() or getRayLength()", "the max or rayLength property");
        return PyFloat_FromDouble(m_maximumBound);
 }
 
@@ -915,6 +972,7 @@ const char KX_ConstraintActuator::SetLimit_doc[] =
 PyObject* KX_ConstraintActuator::PySetLimit(PyObject* self, 
                                                                                        PyObject* args, 
                                                                                        PyObject* kwds) {
+       ShowDeprecationWarning("setLimit()", "the limit property");
        int locrotArg;
        if(!PyArg_ParseTuple(args, "i", &locrotArg)) {
                return NULL;            
@@ -929,6 +987,7 @@ const char KX_ConstraintActuator::GetLimit_doc[] =
 "getLimit()\n"
 "\tReturns the type of constraint.\n";
 PyObject* KX_ConstraintActuator::PyGetLimit(PyObject* self) {
+       ShowDeprecationWarning("setLimit()", "the limit property");
        return PyInt_FromLong(m_locrot);
 }
 
index 193400fbf2b27b8390e466d279b6323c2ae5a803..7ad6e043c498c83ae0e50149a0e62dd9ce9582b8 100644 (file)
@@ -56,7 +56,8 @@ protected:
        // sinus of maximum angle
        float m_maximumSine;
        // reference direction
-       MT_Vector3 m_refDirection;
+       float m_refDirection[3];
+       MT_Vector3 m_refDirVector;      // same as m_refDirection
        // locrotxyz choice (pick one): only one choice allowed at a time!
        int m_locrot;
        // active time of actuator
@@ -65,7 +66,7 @@ protected:
        // option
        int m_option;
        // property to check
-       char m_property[32];
+       STR_String m_property;
        // hit object
        KX_GameObject* m_hitObject;
 
@@ -143,6 +144,10 @@ protected:
        /* --------------------------------------------------------------------- */
 
        virtual PyObject* py_getattro(PyObject *attr);
+       virtual int py_setattro(PyObject *attr, PyObject* value);
+
+       static int pyattr_check_direction(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef);
+       static int pyattr_check_min(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef);
 
        KX_PYMETHOD_DOC(KX_ConstraintActuator,SetDamp);
        KX_PYMETHOD_DOC_NOARGS(KX_ConstraintActuator,GetDamp);
index 4ad9853f9c45af75d2f30157d1283776fbba97f4..7ed83465c49cbc67fb812528d73b8a1b16fa8611 100644 (file)
@@ -1000,6 +1000,12 @@ PyObject* initGameLogic(KX_KetsjiEngine *engine, KX_Scene* scene) // quick hack
        KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_ORIX, KX_ConstraintActuator::KX_ACT_CONSTRAINT_ORIX);
        KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_ORIY, KX_ConstraintActuator::KX_ACT_CONSTRAINT_ORIY);
        KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_ORIZ, KX_ConstraintActuator::KX_ACT_CONSTRAINT_ORIZ);
+       KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_FHPX, KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHPX);
+       KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_FHPY, KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHPY);
+       KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_FHPZ, KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHPZ);
+       KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_FHNX, KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHNX);
+       KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_FHNY, KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHNY);
+       KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_FHNZ, KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHNZ);
 
        /* 4. Ipo actuator, simple part                                            */
        KX_MACRO_addTypesToDict(d, KX_IPOACT_PLAY,     KX_IpoActuator::KX_ACT_IPO_PLAY);
@@ -1160,6 +1166,12 @@ PyObject* initGameLogic(KX_KetsjiEngine *engine, KX_Scene* scene) // quick hack
        KX_MACRO_addTypesToDict(d, KX_STATE_OP_CLR, KX_StateActuator::OP_CLR);
        KX_MACRO_addTypesToDict(d, KX_STATE_OP_NEG, KX_StateActuator::OP_NEG);
 
+       KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_NORMAL, KX_ConstraintActuator::KX_ACT_CONSTRAINT_NORMAL);
+       KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_MATERIAL, KX_ConstraintActuator::KX_ACT_CONSTRAINT_MATERIAL);
+       KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_PERMANENT, KX_ConstraintActuator::KX_ACT_CONSTRAINT_PERMANENT);
+       KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_DISTANCE, KX_ConstraintActuator::KX_ACT_CONSTRAINT_DISTANCE);
+       KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_LOCAL, KX_ConstraintActuator::KX_ACT_CONSTRAINT_LOCAL);
+       KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_DOROTFH, KX_ConstraintActuator::KX_ACT_CONSTRAINT_DOROTFH);
 
        // Check for errors
        if (PyErr_Occurred())
index 7c7ad5aa0fac30ca5c854228f57d4c71cbeac386..a30b859548bab81ec0e2dbeb8cad11fb52b049ce 100644 (file)
@@ -5,6 +5,75 @@ from SCA_IActuator import *
 class KX_ConstraintActuator(SCA_IActuator):
        """
        A constraint actuator limits the position, rotation, distance or orientation of an object.
+       
+       Properties:
+       
+       @ivar damp: time constant of the constraint expressed in frame (not use by Force field constraint)
+       @type damp: integer
+       
+       @ivar rotDamp: time constant for the rotation expressed in frame (only for the distance constraint)
+                      0 = use damp for rotation as well
+       @type rotDamp: integer
+       
+       @ivar direction: the reference direction in world coordinate for the orientation constraint
+       @type direction: 3-tuple of float: [x,y,z]
+       
+       @ivar option: Binary combination of the following values:
+                     Applicable to Distance constraint:
+                                       KX_ACT_CONSTRAINT_NORMAL    (  64) : Activate alignment to surface
+                                       KX_ACT_CONSTRAINT_DISTANCE  ( 512) : Activate distance control
+                                       KX_ACT_CONSTRAINT_LOCAL         (1024) : direction of the ray is along the local axis
+                                 Applicable to Force field constraint:                                 
+                                       KX_ACT_CONSTRAINT_DOROTFH   (2048) : Force field act on rotation as well
+                                 Applicable to both:
+                                       KX_ACT_CONSTRAINT_MATERIAL  ( 128) : Detect material rather than property
+                                       KX_ACT_CONSTRAINT_PERMANENT ( 256) : No deactivation if ray does not hit target
+       @type option: integer
+       
+       @ivar time: activation time of the actuator. The actuator disables itself after this many frame.
+                       If set to 0, the actuator is not limited in time.
+       @type time: integer
+       
+       @ivar property: the name of the property or material for the ray detection of the distance constraint.
+       @type property: string
+       
+       @ivar min: The lower bound of the constraint
+                  For the rotation and orientation constraint, it represents radiant
+       @type min: float
+       
+       @ivar distance: the target distance of the distance constraint
+       @type distance: float
+       
+       @ivar max: the upper bound of the constraint.
+                  For rotation and orientation constraints, it represents radiant.
+       @type max: float
+       
+       @ivar rayLength: the length of the ray of the distance constraint.
+       @type rayLength: float
+       
+       @ivar limit: type of constraint, use one of the following constant:
+                     KX_ACT_CONSTRAINT_LOCX  ( 1) : limit X coord
+                     KX_ACT_CONSTRAINT_LOCY  ( 2) : limit Y coord
+                     KX_ACT_CONSTRAINT_LOCZ  ( 3) : limit Z coord
+                     KX_ACT_CONSTRAINT_ROTX  ( 4) : limit X rotation
+                     KX_ACT_CONSTRAINT_ROTY  ( 5) : limit Y rotation
+                     KX_ACT_CONSTRAINT_ROTZ  ( 6) : limit Z rotation
+                     KX_ACT_CONSTRAINT_DIRPX ( 7) : set distance along positive X axis
+                     KX_ACT_CONSTRAINT_DIRPY ( 8) : set distance along positive Y axis
+                     KX_ACT_CONSTRAINT_DIRPZ ( 9) : set distance along positive Z axis
+                     KX_ACT_CONSTRAINT_DIRNX (10) : set distance along negative X axis
+                     KX_ACT_CONSTRAINT_DIRNY (11) : set distance along negative Y axis
+                     KX_ACT_CONSTRAINT_DIRNZ (12) : set distance along negative Z axis
+                     KX_ACT_CONSTRAINT_ORIX  (13) : set orientation of X axis
+                     KX_ACT_CONSTRAINT_ORIY  (14) : set orientation of Y axis
+                     KX_ACT_CONSTRAINT_ORIZ  (15) : set orientation of Z axis
+                     KX_ACT_CONSTRAINT_FHPX  (16) : set force field along positive X axis
+                     KX_ACT_CONSTRAINT_FHPY  (17) : set force field along positive Y axis
+                     KX_ACT_CONSTRAINT_FHPZ  (18) : set force field along positive Z axis
+                     KX_ACT_CONSTRAINT_FHNX  (19) : set force field along negative X axis
+                     KX_ACT_CONSTRAINT_FHNY  (20) : set force field along negative Y axis
+                     KX_ACT_CONSTRAINT_FHNZ  (21) : set force field along negative Z axis
+       @type limit: integer
        """
        def setDamp(time):
                """
index fb6ae5a3621a8ce09514fc1f57d5ec66cc6b63df..fe3669d3809e9cdff11d7b50cf1523b60055821a 100644 (file)
@@ -5,9 +5,26 @@ from SCA_IActuator import *
 class KX_StateActuator(SCA_IActuator):
        """
        State actuator changes the state mask of parent object.
+       
+       Property:
+       
+       @ivar operation: type of bit operation to be applied on object state mask.
+                        You can use one of the following constant:
+                        KX_STATE_OP_CPY (0) : Copy state mask
+                        KX_STATE_OP_SET (1) : Add bits to state mask
+                        KX_STATE_OP_CLR (2) : Substract bits to state mask
+                        KX_STATE_OP_NEG (3) : Invert bits to state mask
+       @type operation: integer
+       
+       @ivar mask: value that defines the bits that will be modified by the operation.
+                   The bits that are 1 in the mask will be updated in the object state,
+                       the bits that are 0 are will be left unmodified expect for the Copy operation
+                       which copies the mask to the object state
+       @type mask: integer
        """
        def setOperation(op):
                """
+               DEPRECATED: Use the operation property instead.
                Set the type of bit operation to be applied on object state mask.
                Use setMask() to specify the bits that will be modified.
                
@@ -16,6 +33,7 @@ class KX_StateActuator(SCA_IActuator):
                """
        def setMask(mask):
                """
+               DEPRECATED: Use the mask property instead.
                Set the value that defines the bits that will be modified by the operation.
                The bits that are 1 in the value will be updated in the object state,
                the bits that are 0 are will be left unmodified expect for the Copy operation