Undo revision 23130 which was a merge with 2.5, a messy one because I did something...
[blender.git] / source / gameengine / Converter / BL_ShapeActionActuator.cpp
index 81ce9ff..4af9a6c 100644 (file)
@@ -40,7 +40,6 @@
 #include "STR_HashedString.h"
 #include "DNA_nla_types.h"
 #include "DNA_action_types.h"
-#include "DNA_anim_types.h"
 #include "DNA_scene_types.h"
 #include "BKE_action.h"
 #include "DNA_armature_types.h"
 #include "FloatValue.h"
 #include "PyObjectPlus.h"
 
-extern "C" {
-       #include "BKE_animsys.h"
-}
-
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
@@ -375,11 +370,8 @@ bool BL_ShapeActionActuator::Update(double curtime, bool frame)
                                        m_blendstart = curtime;
                                }
                                // only interested in shape channel
-
-                               // in 2.4x was // extract_ipochannels_from_action(&tchanbase, &key->id, m_action, "Shape", m_localtime);
-                               BKE_animsys_evaluate_animdata(&key->id, key->adt, m_localtime, ADT_RECALC_ANIM);
-
-                               // XXX - in 2.5 theres no way to do this. possibly not that important to support - Campbell
+                               // XXX extract_ipochannels_from_action(&tchanbase, &key->id, m_action, "Shape", m_localtime);
+               
                                if (0) { // XXX !execute_ipochannels(&tchanbase)) {
                                        // no update, this is possible if action does not match the keys, stop the action
                                        keepgoing = false;
@@ -442,6 +434,26 @@ PyTypeObject BL_ShapeActionActuator::Type = {
 
 
 PyMethodDef BL_ShapeActionActuator::Methods[] = {
+       {"setAction", (PyCFunction) BL_ShapeActionActuator::sPySetAction, METH_VARARGS, (const char *)SetAction_doc},
+       {"setStart", (PyCFunction) BL_ShapeActionActuator::sPySetStart, METH_VARARGS, (const char *)SetStart_doc},
+       {"setEnd", (PyCFunction) BL_ShapeActionActuator::sPySetEnd, METH_VARARGS, (const char *)SetEnd_doc},
+       {"setBlendin", (PyCFunction) BL_ShapeActionActuator::sPySetBlendin, METH_VARARGS, (const char *)SetBlendin_doc},
+       {"setPriority", (PyCFunction) BL_ShapeActionActuator::sPySetPriority, METH_VARARGS, (const char *)SetPriority_doc},
+       {"setFrame", (PyCFunction) BL_ShapeActionActuator::sPySetFrame, METH_VARARGS, (const char *)SetFrame_doc},
+       {"setProperty", (PyCFunction) BL_ShapeActionActuator::sPySetProperty, METH_VARARGS, (const char *)SetProperty_doc},
+       {"setFrameProperty", (PyCFunction) BL_ShapeActionActuator::sPySetFrameProperty, METH_VARARGS, (const char *)SetFrameProperty_doc},
+       {"setBlendtime", (PyCFunction) BL_ShapeActionActuator::sPySetBlendtime, METH_VARARGS, (const char *)SetBlendtime_doc},
+
+       {"getAction", (PyCFunction) BL_ShapeActionActuator::sPyGetAction, METH_NOARGS, (const char *)GetAction_doc},
+       {"getStart", (PyCFunction) BL_ShapeActionActuator::sPyGetStart, METH_NOARGS, (const char *)GetStart_doc},
+       {"getEnd", (PyCFunction) BL_ShapeActionActuator::sPyGetEnd, METH_NOARGS, (const char *)GetEnd_doc},
+       {"getBlendin", (PyCFunction) BL_ShapeActionActuator::sPyGetBlendin, METH_NOARGS, (const char *)GetBlendin_doc},
+       {"getPriority", (PyCFunction) BL_ShapeActionActuator::sPyGetPriority, METH_NOARGS, (const char *)GetPriority_doc},
+       {"getFrame", (PyCFunction) BL_ShapeActionActuator::sPyGetFrame, METH_NOARGS, (const char *)GetFrame_doc},
+       {"getProperty", (PyCFunction) BL_ShapeActionActuator::sPyGetProperty, METH_NOARGS, (const char *)GetProperty_doc},
+       {"getFrameProperty", (PyCFunction) BL_ShapeActionActuator::sPyGetFrameProperty, METH_NOARGS, (const char *)GetFrameProperty_doc},
+       {"getType", (PyCFunction) BL_ShapeActionActuator::sPyGetType, METH_NOARGS, (const char *)GetType_doc},  
+       {"setType", (PyCFunction) BL_ShapeActionActuator::sPySetType, METH_NOARGS, (const char *)SetType_doc},
        {NULL,NULL} //Sentinel
 };
 
@@ -459,6 +471,370 @@ PyAttributeDef BL_ShapeActionActuator::Attributes[] = {
        { NULL }        //Sentinel
 };
 
+/*     setStart                                                              */
+const char BL_ShapeActionActuator::GetAction_doc[] = 
+"getAction()\n"
+"\tReturns a string containing the name of the current action.\n";
+
+PyObject* BL_ShapeActionActuator::PyGetAction() {
+       ShowDeprecationWarning("getAction()", "the action property");
+       if (m_action){
+               return PyUnicode_FromString(m_action->id.name+2);
+       }
+       Py_RETURN_NONE;
+}
+
+/*     getProperty                                                             */
+const char BL_ShapeActionActuator::GetProperty_doc[] = 
+"getProperty()\n"
+"\tReturns the name of the property to be used in FromProp mode.\n";
+
+PyObject* BL_ShapeActionActuator::PyGetProperty() {
+       ShowDeprecationWarning("getProperty()", "the property property");
+       PyObject *result;
+       
+       result = Py_BuildValue("s", (const char *)m_propname);
+       
+       return result;
+}
+
+/*     getFrame                                                              */
+const char BL_ShapeActionActuator::GetFrame_doc[] = 
+"getFrame()\n"
+"\tReturns the current frame number.\n";
+
+PyObject* BL_ShapeActionActuator::PyGetFrame() {
+       ShowDeprecationWarning("getFrame()", "the frame property");
+       PyObject *result;
+       
+       result = Py_BuildValue("f", m_localtime);
+       
+       return result;
+}
+
+/*     getEnd                                                                */
+const char BL_ShapeActionActuator::GetEnd_doc[] = 
+"getEnd()\n"
+"\tReturns the last frame of the action.\n";
+
+PyObject* BL_ShapeActionActuator::PyGetEnd() {
+       ShowDeprecationWarning("getEnd()", "the end property");
+       PyObject *result;
+       
+       result = Py_BuildValue("f", m_endframe);
+       
+       return result;
+}
+
+/*     getStart                                                              */
+const char BL_ShapeActionActuator::GetStart_doc[] = 
+"getStart()\n"
+"\tReturns the starting frame of the action.\n";
+
+PyObject* BL_ShapeActionActuator::PyGetStart() {
+       ShowDeprecationWarning("getStart()", "the start property");
+       PyObject *result;
+       
+       result = Py_BuildValue("f", m_startframe);
+       
+       return result;
+}
+
+/*     getBlendin                                                            */
+const char BL_ShapeActionActuator::GetBlendin_doc[] = 
+"getBlendin()\n"
+"\tReturns the number of interpolation animation frames to be\n"
+"\tgenerated when this actuator is triggered.\n";
+
+PyObject* BL_ShapeActionActuator::PyGetBlendin() {
+       ShowDeprecationWarning("getBlendin()", "the blendin property");
+       PyObject *result;
+       
+       result = Py_BuildValue("f", m_blendin);
+       
+       return result;
+}
+
+/*     getPriority                                                           */
+const char BL_ShapeActionActuator::GetPriority_doc[] = 
+"getPriority()\n"
+"\tReturns the priority for this actuator.  Actuators with lower\n"
+"\tPriority numbers will override actuators with higher numbers.\n";
+
+PyObject* BL_ShapeActionActuator::PyGetPriority() {
+       ShowDeprecationWarning("getPriority()", "the priority property");
+       PyObject *result;
+       
+       result = Py_BuildValue("i", m_priority);
+       
+       return result;
+}
+
+/*     setAction                                                             */
+const char BL_ShapeActionActuator::SetAction_doc[] = 
+"setAction(action, (reset))\n"
+"\t - action    : The name of the action to set as the current action.\n"
+"\t               Should be an action with Shape channels.\n"
+"\t - reset     : Optional parameter indicating whether to reset the\n"
+"\t               blend timer or not.  A value of 1 indicates that the\n"
+"\t               timer should be reset.  A value of 0 will leave it\n"
+"\t               unchanged.  If reset is not specified, the timer will"
+"\t                  be reset.\n";
+
+PyObject* BL_ShapeActionActuator::PySetAction(PyObject* args) {
+       ShowDeprecationWarning("setAction()", "the action property");
+       char *string;
+       int     reset = 1;
+
+       if (PyArg_ParseTuple(args,"s|i:setAction",&string, &reset))
+       {
+               bAction *action;
+               
+               action = (bAction*)SCA_ILogicBrick::m_sCurrentLogicManager->GetActionByName(STR_String(string));
+               
+               if (!action){
+                       /* NOTE!  Throw an exception or something */
+                       //                      printf ("setAction failed: Action not found\n", string);
+               }
+               else{
+                       m_action=action;
+                       if (reset)
+                               m_blendframe = 0.f;
+               }
+       }
+       else {
+               return NULL;
+       }
+       
+       Py_RETURN_NONE;
+}
+
+/*     setStart                                                              */
+const char BL_ShapeActionActuator::SetStart_doc[] = 
+"setStart(start)\n"
+"\t - start     : Specifies the starting frame of the animation.\n";
+
+PyObject* BL_ShapeActionActuator::PySetStart(PyObject* args) {
+       ShowDeprecationWarning("setStart()", "the start property");
+       float start;
+       
+       if (PyArg_ParseTuple(args,"f:setStart",&start))
+       {
+               m_startframe = start;
+       }
+       else {
+               return NULL;
+       }
+       
+       Py_RETURN_NONE;
+}
+
+/*     setEnd                                                                */
+const char BL_ShapeActionActuator::SetEnd_doc[] = 
+"setEnd(end)\n"
+"\t - end       : Specifies the ending frame of the animation.\n";
+
+PyObject* BL_ShapeActionActuator::PySetEnd(PyObject* args) {
+       ShowDeprecationWarning("setEnd()", "the end property");
+       float end;
+       
+       if (PyArg_ParseTuple(args,"f:setEnd",&end))
+       {
+               m_endframe = end;
+       }
+       else {
+               return NULL;
+       }
+       
+       Py_RETURN_NONE;
+}
+
+/*     setBlendin                                                            */
+const char BL_ShapeActionActuator::SetBlendin_doc[] = 
+"setBlendin(blendin)\n"
+"\t - blendin   : Specifies the number of frames of animation to generate\n"
+"\t               when making transitions between actions.\n";
+
+PyObject* BL_ShapeActionActuator::PySetBlendin(PyObject* args) {
+       ShowDeprecationWarning("setBlendin()", "the blendin property");
+       float blendin;
+       
+       if (PyArg_ParseTuple(args,"f:setBlendin",&blendin))
+       {
+               m_blendin = blendin;
+       }
+       else {
+               return NULL;
+       }
+       
+       Py_RETURN_NONE;
+}
+
+/*     setBlendtime                                                          */
+const char BL_ShapeActionActuator::SetBlendtime_doc[] = 
+"setBlendtime(blendtime)\n"
+"\t - blendtime : Allows the script to directly modify the internal timer\n"
+"\t               used when generating transitions between actions.  This\n"
+"\t               parameter must be in the range from 0.0 to 1.0.\n";
+
+PyObject* BL_ShapeActionActuator::PySetBlendtime(PyObject* args) {
+       ShowDeprecationWarning("setBlendtime()", "the blendTime property");
+       float blendframe;
+       
+       if (PyArg_ParseTuple(args,"f:setBlendtime",&blendframe))
+       {
+               m_blendframe = blendframe * m_blendin;
+               if (m_blendframe<0.f)
+                       m_blendframe = 0.f;
+               if (m_blendframe>m_blendin)
+                       m_blendframe = m_blendin;
+       }
+       else {
+               return NULL;
+       }
+       
+       Py_RETURN_NONE;
+}
+
+/*     setPriority                                                           */
+const char BL_ShapeActionActuator::SetPriority_doc[] = 
+"setPriority(priority)\n"
+"\t - priority  : Specifies the new priority.  Actuators will lower\n"
+"\t               priority numbers will override actuators with higher\n"
+"\t               numbers.\n";
+
+PyObject* BL_ShapeActionActuator::PySetPriority(PyObject* args) {
+       ShowDeprecationWarning("setPriority()", "the priority property");
+       int priority;
+       
+       if (PyArg_ParseTuple(args,"i:setPriority",&priority))
+       {
+               m_priority = priority;
+       }
+       else {
+               return NULL;
+       }
+       
+       Py_RETURN_NONE;
+}
+
+/*     getProperty                                                             */
+const char BL_ShapeActionActuator::GetFrameProperty_doc[] = 
+"getFrameProperty()\n"
+"\tReturns the name of the property, that is set to the current frame number.\n";
+
+PyObject* BL_ShapeActionActuator::PyGetFrameProperty() {
+       ShowDeprecationWarning("getFrameProperty()", "the frameProperty property");
+       PyObject *result;
+       
+       result = Py_BuildValue("s", (const char *)m_framepropname);
+       
+       return result;
+}
+
+
+/*     setFrame                                                              */
+const char BL_ShapeActionActuator::SetFrame_doc[] = 
+"setFrame(frame)\n"
+"\t - frame     : Specifies the new current frame for the animation\n";
+
+PyObject* BL_ShapeActionActuator::PySetFrame(PyObject* args) {
+       ShowDeprecationWarning("setFrame()", "the frame property");
+       float frame;
+       
+       if (PyArg_ParseTuple(args,"f:setFrame",&frame))
+       {
+               m_localtime = frame;
+               if (m_localtime<m_startframe)
+                       m_localtime=m_startframe;
+               else if (m_localtime>m_endframe)
+                       m_localtime=m_endframe;
+       }
+       else {
+               return NULL;
+       }
+       
+       Py_RETURN_NONE;
+}
+
+/*     setProperty                                                           */
+const char BL_ShapeActionActuator::SetProperty_doc[] = 
+"setProperty(prop)\n"
+"\t - prop      : A string specifying the property name to be used in\n"
+"\t               FromProp playback mode.\n";
+
+PyObject* BL_ShapeActionActuator::PySetProperty(PyObject* args) {
+       ShowDeprecationWarning("setProperty()", "the property property");
+       char *string;
+       
+       if (PyArg_ParseTuple(args,"s:setProperty",&string))
+       {
+               m_propname = string;
+       }
+       else {
+               return NULL;
+       }
+       
+       Py_RETURN_NONE;
+}
+
+/*     setFrameProperty                                                          */
+const char BL_ShapeActionActuator::SetFrameProperty_doc[] = 
+"setFrameProperty(prop)\n"
+"\t - prop      : A string specifying the property of the frame set up update.\n";
+
+PyObject* BL_ShapeActionActuator::PySetFrameProperty(PyObject* args) {
+       ShowDeprecationWarning("setFrameProperty()", "the frameProperty property");
+       char *string;
+       
+       if (PyArg_ParseTuple(args,"s:setFrameProperty",&string))
+       {
+               m_framepropname = string;
+       }
+       else {
+               return NULL;
+       }
+       
+       Py_RETURN_NONE;
+}
+
+/* getType */
+const char BL_ShapeActionActuator::GetType_doc[] =
+"getType()\n"
+"\tReturns the operation mode of the actuator.\n";
+PyObject* BL_ShapeActionActuator::PyGetType() {
+       ShowDeprecationWarning("getType()", "the type property");
+    return Py_BuildValue("h", m_playtype);
+}
+
+/* setType */
+const char BL_ShapeActionActuator::SetType_doc[] =
+"setType(mode)\n"
+"\t - mode: Play (0), Flipper (2), LoopStop (3), LoopEnd (4) or Property (6)\n"
+"\tSet the operation mode of the actuator.\n";
+PyObject* BL_ShapeActionActuator::PySetType(PyObject* args) {
+       ShowDeprecationWarning("setType()", "the type property");
+       short typeArg;
+                                                                                                             
+    if (!PyArg_ParseTuple(args, "h:setType", &typeArg)) {
+        return NULL;
+    }
+
+       switch (typeArg) {
+       case ACT_ACTION_PLAY:
+       case ACT_ACTION_FLIPPER:
+       case ACT_ACTION_LOOP_STOP:
+       case ACT_ACTION_LOOP_END:
+       case ACT_ACTION_FROM_PROP:
+               m_playtype = typeArg;
+               break;
+       default:
+               printf("Invalid type for action actuator: %d\n", typeArg); /* error */
+    }
+       
+    Py_RETURN_NONE;
+}
+
 PyObject* BL_ShapeActionActuator::pyattr_get_action(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 {
        BL_ShapeActionActuator* self= static_cast<BL_ShapeActionActuator*>(self_v);