644f8ac81132fcf7ef8ba08a801999c9cfb70729
[blender.git] / source / gameengine / Ketsji / KX_IpoActuator.cpp
1 /**
2  * Do Ipo stuff
3  *
4  * $Id$
5  *
6  * ***** BEGIN GPL LICENSE BLOCK *****
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * The Original Code is: all of this file.
26  *
27  * Contributor(s): none yet.
28  *
29  * ***** END GPL LICENSE BLOCK *****
30  */
31
32 #if defined (__sgi)
33 #include <math.h>
34 #else
35 #include <cmath>
36 #endif
37  
38 #include "KX_IpoActuator.h"
39 #include "KX_GameObject.h"
40 #include "FloatValue.h"
41
42 #ifdef HAVE_CONFIG_H
43 #include <config.h>
44 #endif
45
46 #include "KX_KetsjiEngine.h"
47
48 /* ------------------------------------------------------------------------- */
49 /* Type strings                                                              */
50 /* ------------------------------------------------------------------------- */
51
52 STR_String KX_IpoActuator::S_KX_ACT_IPO_PLAY_STRING      = "Play";
53 STR_String KX_IpoActuator::S_KX_ACT_IPO_PINGPONG_STRING  = "PingPong";
54 STR_String KX_IpoActuator::S_KX_ACT_IPO_FLIPPER_STRING   = "Flipper";
55 STR_String KX_IpoActuator::S_KX_ACT_IPO_LOOPSTOP_STRING  = "LoopStop";
56 STR_String KX_IpoActuator::S_KX_ACT_IPO_LOOPEND_STRING   = "LoopEnd";
57 STR_String KX_IpoActuator::S_KX_ACT_IPO_KEY2KEY_STRING   = "Key2key";
58 STR_String KX_IpoActuator::S_KX_ACT_IPO_FROM_PROP_STRING = "FromProp";
59
60 /* ------------------------------------------------------------------------- */
61 /* Native functions                                                          */
62 /* ------------------------------------------------------------------------- */
63
64 KX_IpoActuator::KX_IpoActuator(SCA_IObject* gameobj,
65                                                            const STR_String& propname,
66                                                            const STR_String& framePropname,
67                                                            float starttime,
68                                                            float endtime,
69                                                            bool recurse,
70                                                            int acttype,
71                                                            bool ipo_as_force,
72                                                            bool ipo_add,
73                                                            bool ipo_local,
74                                                            PyTypeObject* T) 
75         : SCA_IActuator(gameobj,T),
76         m_bNegativeEvent(false),
77         m_startframe (starttime),
78         m_endframe(endtime),
79         m_recurse(recurse),
80         m_localtime(starttime),
81         m_direction(1),
82         m_propname(propname),
83         m_framepropname(framePropname),
84         m_ipo_as_force(ipo_as_force),
85         m_ipo_add(ipo_add),
86         m_ipo_local(ipo_local),
87         m_type(acttype)
88 {
89         m_starttime = -2.0*fabs(m_endframe - m_startframe) - 1.0;
90         m_bIpoPlaying = false;
91 }
92
93 void KX_IpoActuator::SetStart(float starttime) 
94
95         m_startframe=starttime;
96 }
97
98 void KX_IpoActuator::SetEnd(float endtime) 
99
100         m_endframe=endtime;
101 }
102
103 bool KX_IpoActuator::ClampLocalTime()
104 {
105         if (m_startframe < m_endframe)
106         {
107                 if (m_localtime < m_startframe)
108                 {
109                         m_localtime = m_startframe;
110                         return true;
111                 } 
112                 else if (m_localtime > m_endframe)
113                 {
114                         m_localtime = m_endframe;
115                         return true;
116                 }
117         } else {
118                 if (m_localtime > m_startframe)
119                 {
120                         m_localtime = m_startframe;
121                         return true;
122                 }
123                 else if (m_localtime < m_endframe)
124                 {
125                         m_localtime = m_endframe;
126                         return true;
127                 }
128         }
129         return false;
130 }
131
132 void KX_IpoActuator::SetStartTime(float curtime)
133 {
134         float direction = m_startframe < m_endframe ? 1.0f : -1.0f;
135
136         if (m_direction > 0)
137                 m_starttime = curtime - direction*(m_localtime - m_startframe)/KX_KetsjiEngine::GetAnimFrameRate();
138         else
139                 m_starttime = curtime - direction*(m_endframe - m_localtime)/KX_KetsjiEngine::GetAnimFrameRate();
140 }
141
142 void KX_IpoActuator::SetLocalTime(float curtime)
143 {
144         float delta_time = (curtime - m_starttime)*KX_KetsjiEngine::GetAnimFrameRate();
145         
146         // negative delta_time is caused by floating point inaccuracy
147         // perhaps the inaccuracy could be reduced a bit
148         if ((m_localtime==m_startframe || m_localtime==m_endframe) && delta_time<0.0)
149         {
150                 delta_time = 0.0;
151         }
152         
153         if (m_endframe < m_startframe)
154                 delta_time = -delta_time;
155
156         if (m_direction > 0)
157                 m_localtime = m_startframe + delta_time;
158         else
159                 m_localtime = m_endframe - delta_time;
160 }
161
162 bool KX_IpoActuator::Update(double curtime, bool frame)
163 {
164         // result = true if animation has to be continued, false if animation stops
165         // maybe there are events for us in the queue !
166         bool bNegativeEvent = false;
167         int numevents = 0;
168         bool bIpoStart = false;
169
170         curtime -= KX_KetsjiEngine::GetSuspendedDelta();
171
172         if (frame)
173         {
174                 numevents = m_events.size();
175                 bNegativeEvent = IsNegativeEvent();
176                 RemoveAllEvents();
177         }
178         
179         float  start_smaller_then_end = ( m_startframe < m_endframe ? 1.0f : -1.0f);
180
181         bool result=true;
182         if (!bNegativeEvent)
183         {
184                 if (m_starttime < -2.0f*start_smaller_then_end*(m_endframe - m_startframe))
185                 {
186                         // start for all Ipo, initial start for LOOP_STOP
187                         m_starttime = curtime;
188                         m_bIpoPlaying = true;
189                         bIpoStart = true;
190                 }
191         }       
192
193         switch ((IpoActType)m_type)
194         {
195                 
196         case KX_ACT_IPO_PLAY:
197         {
198                 // Check if playing forwards.  result = ! finished
199                 
200                 if (start_smaller_then_end > 0.f)
201                         result = (m_localtime < m_endframe && m_bIpoPlaying);
202                 else
203                         result = (m_localtime > m_endframe && m_bIpoPlaying);
204                 
205                 if (result)
206                 {
207                         SetLocalTime(curtime);
208                 
209                         /* Perform clamping */
210                         ClampLocalTime();
211         
212                         if (bIpoStart)
213                                 ((KX_GameObject*)GetParent())->InitIPO(m_ipo_as_force, m_ipo_add, m_ipo_local);
214                         ((KX_GameObject*)GetParent())->UpdateIPO(m_localtime,m_recurse);
215                 } else
216                 {
217                         m_localtime=m_startframe;
218                         m_direction=1;
219                 }
220                 break;
221         }
222         case KX_ACT_IPO_PINGPONG:
223         {
224                 result = true;
225                 if (bNegativeEvent && !m_bIpoPlaying)
226                         result = false;
227                 else
228                         SetLocalTime(curtime);
229                         
230                 if (ClampLocalTime())
231                 {
232                         result = false;
233                         m_direction = -m_direction;
234                 }
235                 
236                 if (bIpoStart && m_direction > 0)
237                         ((KX_GameObject*)GetParent())->InitIPO(m_ipo_as_force, m_ipo_add, m_ipo_local);
238                 ((KX_GameObject*)GetParent())->UpdateIPO(m_localtime,m_recurse);
239                 break;
240         }
241         case KX_ACT_IPO_FLIPPER:
242         {
243                 if (bNegativeEvent && !m_bIpoPlaying)
244                         result = false;
245                 if (numevents)
246                 {
247                         float oldDirection = m_direction;
248                         if (bNegativeEvent)
249                                 m_direction = -1;
250                         else
251                                 m_direction = 1;
252                         if (m_direction != oldDirection)
253                                 // changing direction, reset start time
254                                 SetStartTime(curtime);
255                 }
256                 
257                 SetLocalTime(curtime);
258                 
259                 if (ClampLocalTime() && m_localtime == m_startframe)
260                         result = false;
261
262                 if (bIpoStart)
263                         ((KX_GameObject*)GetParent())->InitIPO(m_ipo_as_force, m_ipo_add, m_ipo_local);                 
264                 ((KX_GameObject*)GetParent())->UpdateIPO(m_localtime,m_recurse);
265                 break;
266         }
267
268         case KX_ACT_IPO_LOOPSTOP:
269         {
270                 if (numevents)
271                 {
272                         if (bNegativeEvent)
273                         {
274                                 result = false;
275                                 m_bNegativeEvent = false;
276                                 numevents = 0;
277                         }
278                         if (!m_bIpoPlaying)
279                         {
280                                 // Ipo was stopped, make sure we will restart from where it stopped
281                                 SetStartTime(curtime);
282                                 if (!bNegativeEvent)
283                                         // positive signal will restart the Ipo
284                                         m_bIpoPlaying = true;
285                         }
286
287                 } // fall through to loopend, and quit the ipo animation immediatly 
288         }
289         case KX_ACT_IPO_LOOPEND:
290         {
291                 if (numevents){
292                         if (bNegativeEvent && m_bIpoPlaying){
293                                 m_bNegativeEvent = true;
294                         }
295                 }
296                 
297                 if (bNegativeEvent && !m_bIpoPlaying){
298                         result = false;
299                 } 
300                 else
301                 {
302                         if (m_localtime*start_smaller_then_end < m_endframe*start_smaller_then_end)
303                         {
304                                 SetLocalTime(curtime);
305                         }
306                         else{
307                                 if (!m_bNegativeEvent){
308                                         /* Perform wraparound */
309                                         SetLocalTime(curtime);
310                                         if (start_smaller_then_end > 0.f)
311                                                 m_localtime = m_startframe + fmod(m_localtime - m_startframe, m_endframe - m_startframe);
312                                         else
313                                                 m_localtime = m_startframe - fmod(m_startframe - m_localtime, m_startframe - m_endframe);
314                                         SetStartTime(curtime);
315                                         bIpoStart = true;
316                                 }
317                                 else
318                                 {       
319                                         /* Perform clamping */
320                                         m_localtime=m_endframe;
321                                         result = false;
322                                         m_bNegativeEvent = false;
323                                 }
324                         }
325                 }
326                 
327                 if (m_bIpoPlaying && bIpoStart)
328                         ((KX_GameObject*)GetParent())->InitIPO(m_ipo_as_force, m_ipo_add, m_ipo_local);
329                 ((KX_GameObject*)GetParent())->UpdateIPO(m_localtime,m_recurse);
330                 break;
331         }
332         
333         case KX_ACT_IPO_KEY2KEY:
334         {
335                 // not implemented yet
336                 result = false;
337                 break;
338         }
339         
340         case KX_ACT_IPO_FROM_PROP:
341         {
342                 result = !bNegativeEvent;
343
344                 CValue* propval = GetParent()->GetProperty(m_propname);
345                 if (propval)
346                 {
347                         m_localtime = propval->GetNumber(); 
348         
349                         if (bIpoStart)
350                                 ((KX_GameObject*)GetParent())->InitIPO(m_ipo_as_force, m_ipo_add, m_ipo_local);
351                         ((KX_GameObject*)GetParent())->UpdateIPO(m_localtime,m_recurse);
352                 } else
353                 {
354                         result = false;
355                 }
356                 break;
357         }
358                 
359         default:
360                 result = false;
361         }
362
363         /* Set the property if its defined */
364         if (m_framepropname[0] != '\0') {
365                 CValue* propowner = GetParent();
366                 CValue* oldprop = propowner->GetProperty(m_framepropname);
367                 CValue* newval = new CFloatValue(m_localtime);
368                 if (oldprop) {
369                         oldprop->SetValue(newval);
370                 } else {
371                         propowner->SetProperty(m_framepropname, newval);
372                 }
373                 newval->Release();
374         }
375
376         if (!result)
377         {
378                 if (m_type != KX_ACT_IPO_LOOPSTOP)
379                         m_starttime = -2.0*start_smaller_then_end*(m_endframe - m_startframe) - 1.0;
380                 m_bIpoPlaying = false;
381         }
382
383         return result;
384 }
385
386 int KX_IpoActuator::string2mode(char* modename) {
387         IpoActType res = KX_ACT_IPO_NODEF;
388
389         if (modename == S_KX_ACT_IPO_PLAY_STRING) { 
390                 res = KX_ACT_IPO_PLAY;
391         } else if (modename == S_KX_ACT_IPO_PINGPONG_STRING) {
392                 res = KX_ACT_IPO_PINGPONG;
393         } else if (modename == S_KX_ACT_IPO_FLIPPER_STRING) {
394                 res = KX_ACT_IPO_FLIPPER;
395         } else if (modename == S_KX_ACT_IPO_LOOPSTOP_STRING) {
396                 res = KX_ACT_IPO_LOOPSTOP;
397         } else if (modename == S_KX_ACT_IPO_LOOPEND_STRING) {
398                 res = KX_ACT_IPO_LOOPEND;
399         } else if (modename == S_KX_ACT_IPO_KEY2KEY_STRING) {
400                 res = KX_ACT_IPO_KEY2KEY;
401         } else if (modename == S_KX_ACT_IPO_FROM_PROP_STRING) {
402                 res = KX_ACT_IPO_FROM_PROP;
403         }
404
405         return res;
406 }
407
408 /* ------------------------------------------------------------------------- */
409 /* Python functions                                                          */
410 /* ------------------------------------------------------------------------- */
411
412
413
414 /* Integration hooks ------------------------------------------------------- */
415 PyTypeObject KX_IpoActuator::Type = {
416         PyObject_HEAD_INIT(NULL)
417         0,
418         "KX_IpoActuator",
419         sizeof(KX_IpoActuator),
420         0,
421         PyDestructor,
422         0,
423         0,
424         0,
425         0,
426         py_base_repr,
427         0,0,0,0,0,0,
428         py_base_getattro,
429         py_base_setattro,
430         0,0,0,0,0,0,0,0,0,
431         Methods
432 };
433
434 PyParentObject KX_IpoActuator::Parents[] = {
435         &KX_IpoActuator::Type,
436         &SCA_IActuator::Type,
437         &SCA_ILogicBrick::Type,
438         &CValue::Type,
439         NULL
440 };
441
442 PyMethodDef KX_IpoActuator::Methods[] = {
443         {"set", (PyCFunction) KX_IpoActuator::sPySet, METH_VARARGS, (PY_METHODCHAR)Set_doc},
444         
445         // deprecated 
446         {"setProperty", (PyCFunction) KX_IpoActuator::sPySetProperty, METH_VARARGS, (PY_METHODCHAR)SetProperty_doc},
447         {"setStart", (PyCFunction) KX_IpoActuator::sPySetStart, METH_VARARGS, (PY_METHODCHAR)SetStart_doc},
448         {"getStart", (PyCFunction) KX_IpoActuator::sPyGetStart, METH_NOARGS, (PY_METHODCHAR)GetStart_doc},
449         {"setEnd", (PyCFunction) KX_IpoActuator::sPySetEnd, METH_VARARGS, (PY_METHODCHAR)SetEnd_doc},
450         {"getEnd", (PyCFunction) KX_IpoActuator::sPyGetEnd, METH_NOARGS, (PY_METHODCHAR)GetEnd_doc},
451         {"setIpoAsForce", (PyCFunction) KX_IpoActuator::sPySetIpoAsForce, METH_VARARGS, (PY_METHODCHAR)SetIpoAsForce_doc},
452         {"getIpoAsForce", (PyCFunction) KX_IpoActuator::sPyGetIpoAsForce, METH_NOARGS, (PY_METHODCHAR)GetIpoAsForce_doc},
453         {"setIpoAdd", (PyCFunction) KX_IpoActuator::sPySetIpoAdd, METH_VARARGS, (PY_METHODCHAR)SetIpoAdd_doc},
454         {"getIpoAdd", (PyCFunction) KX_IpoActuator::sPyGetIpoAdd, METH_NOARGS, (PY_METHODCHAR)GetIpoAdd_doc},
455         {"setForceIpoActsLocal", (PyCFunction) KX_IpoActuator::sPySetForceIpoActsLocal, METH_VARARGS, (PY_METHODCHAR)SetForceIpoActsLocal_doc},
456         {"getForceIpoActsLocal", (PyCFunction) KX_IpoActuator::sPyGetForceIpoActsLocal, METH_NOARGS, (PY_METHODCHAR)GetForceIpoActsLocal_doc},
457         {"setType", (PyCFunction) KX_IpoActuator::sPySetType, METH_VARARGS, (PY_METHODCHAR)SetType_doc},
458         {"getType", (PyCFunction) KX_IpoActuator::sPyGetType, METH_NOARGS, (PY_METHODCHAR)GetType_doc}, 
459         {NULL,NULL} //Sentinel
460 };
461
462 PyAttributeDef KX_IpoActuator::Attributes[] = {
463         KX_PYATTRIBUTE_FLOAT_RW("startFrame", 0, 300000, KX_IpoActuator, m_startframe),
464         KX_PYATTRIBUTE_FLOAT_RW("endFrame", 0, 300000, KX_IpoActuator, m_endframe),
465         KX_PYATTRIBUTE_STRING_RW("propName", 0, 64, false, KX_IpoActuator, m_propname),
466         KX_PYATTRIBUTE_STRING_RW("framePropName", 0, 64, false, KX_IpoActuator, m_framepropname),
467         KX_PYATTRIBUTE_INT_RW("type", KX_ACT_IPO_NODEF+1, KX_ACT_IPO_MAX-1, true, KX_IpoActuator, m_type),
468         KX_PYATTRIBUTE_BOOL_RW("useIpoAsForce", KX_IpoActuator, m_ipo_as_force),
469         KX_PYATTRIBUTE_BOOL_RW("useIpoAdd", KX_IpoActuator, m_ipo_add),
470         KX_PYATTRIBUTE_BOOL_RW("useIpoLocal", KX_IpoActuator, m_ipo_local),
471         KX_PYATTRIBUTE_BOOL_RW("useChildren", KX_IpoActuator, m_recurse),
472         
473         { NULL }        //Sentinel
474 };
475
476 PyObject* KX_IpoActuator::py_getattro(PyObject *attr) {
477         py_getattro_up(SCA_IActuator);
478 }
479
480 int KX_IpoActuator::py_setattro(PyObject *attr, PyObject *value)        // py_setattro method
481 {
482         py_setattro_up(SCA_IActuator);
483 }
484
485 /* set --------------------------------------------------------------------- */
486 const char KX_IpoActuator::Set_doc[] = 
487 "set(type, startframe, endframe, mode?)\n"
488 "\t - type:       Play, PingPong, Flipper, LoopStop, LoopEnd or FromProp (string)\n"
489 "\t - startframe: first frame to use (int)\n"
490 "\t - endframe  : last frame to use (int)\n"
491 "\t - mode?     : special mode (0=normal, 1=interpret location as force, 2=additive)"
492 "\tSet the properties of the actuator.\n";
493 PyObject* KX_IpoActuator::PySet(PyObject* self, 
494                                                                 PyObject* args, 
495                                                                 PyObject* kwds) {
496         
497         ShowDeprecationWarning("set()", "a number properties");
498                                                                         
499         /* sets modes PLAY, PINGPONG, FLIPPER, LOOPSTOP, LOOPEND                 */
500         /* arg 1 = mode string, arg 2 = startframe, arg3 = stopframe,            */
501         /* arg4 = force toggle                                                   */
502         char* mode;
503         int forceToggle;
504         int modenum;
505         int startFrame, stopFrame;
506         if(!PyArg_ParseTuple(args, "siii:set", &mode, &startFrame, 
507                                                  &stopFrame, &forceToggle)) {
508                 return NULL;
509         }
510         modenum = string2mode(mode);
511         
512         switch (modenum) {
513         case KX_ACT_IPO_PLAY:
514         case KX_ACT_IPO_PINGPONG:
515         case KX_ACT_IPO_FLIPPER:
516         case KX_ACT_IPO_LOOPSTOP:
517         case KX_ACT_IPO_LOOPEND:
518                 m_type         = modenum;
519                 m_startframe    = startFrame;
520                 m_endframe      = stopFrame;
521                 m_ipo_as_force = forceToggle == 1;
522                 m_ipo_add = forceToggle == 2;
523                 break;
524         default:
525                 ; /* error */
526         }
527
528         Py_RETURN_NONE;
529 }
530
531 /* set property  ----------------------------------------------------------- */
532 const char KX_IpoActuator::SetProperty_doc[] = 
533 "setProperty(propname)\n"
534 "\t - propname: name of the property (string)\n"
535 "\tSet the property to be used in FromProp mode.\n";
536 PyObject* KX_IpoActuator::PySetProperty(PyObject* self, 
537                                                                                 PyObject* args, 
538                                                                                 PyObject* kwds) {
539
540         ShowDeprecationWarning("setProperty()", "the propName property");
541
542         /* mode is implicit here, but not supported yet... */
543         /* args: property */
544         char *propertyName;
545         if(!PyArg_ParseTuple(args, "s:setProperty", &propertyName)) {
546                 return NULL;
547         }
548
549         m_propname = propertyName;
550         
551         Py_RETURN_NONE;
552 }
553
554 /* 4. setStart:                                                              */
555 const char KX_IpoActuator::SetStart_doc[] = 
556 "setStart(frame)\n"
557 "\t - frame: first frame to use (int)\n"
558 "\tSet the frame from which the ipo starts playing.\n";
559 PyObject* KX_IpoActuator::PySetStart(PyObject* self, 
560                                                                          PyObject* args, 
561                                                                          PyObject* kwds) {
562
563         ShowDeprecationWarning("setStart()", "the startFrame property");
564
565         float startArg;
566         if(!PyArg_ParseTuple(args, "f:setStart", &startArg)) {
567                 return NULL;            
568         }
569         
570         m_startframe = startArg;
571
572         Py_RETURN_NONE;
573 }
574 /* 5. getStart:                                                              */
575 const char KX_IpoActuator::GetStart_doc[] = 
576 "getStart()\n"
577 "\tReturns the frame from which the ipo starts playing.\n";
578 PyObject* KX_IpoActuator::PyGetStart(PyObject* self) {
579         ShowDeprecationWarning("getStart()", "the startFrame property");
580         return PyFloat_FromDouble(m_startframe);
581 }
582
583 /* 6. setEnd:                                                                */
584 const char KX_IpoActuator::SetEnd_doc[] = 
585 "setEnd(frame)\n"
586 "\t - frame: last frame to use (int)\n"
587 "\tSet the frame at which the ipo stops playing.\n";
588 PyObject* KX_IpoActuator::PySetEnd(PyObject* self, 
589                                                                    PyObject* args, 
590                                                                    PyObject* kwds) {
591         ShowDeprecationWarning("setEnd()", "the endFrame property");
592         float endArg;
593         if(!PyArg_ParseTuple(args, "f:setEnd", &endArg)) {
594                 return NULL;            
595         }
596         
597         m_endframe = endArg;
598
599         Py_RETURN_NONE;
600 }
601 /* 7. getEnd:                                                                */
602 const char KX_IpoActuator::GetEnd_doc[] = 
603 "getEnd()\n"
604 "\tReturns the frame at which the ipo stops playing.\n";
605 PyObject* KX_IpoActuator::PyGetEnd(PyObject* self) {
606         ShowDeprecationWarning("getEnd()", "the endFrame property");
607         return PyFloat_FromDouble(m_endframe);
608 }
609
610 /* 6. setIpoAsForce:                                                           */
611 const char KX_IpoActuator::SetIpoAsForce_doc[] = 
612 "setIpoAsForce(force?)\n"
613 "\t - force?    : interpret this ipo as a force? (KX_TRUE, KX_FALSE)\n"
614 "\tSet whether to interpret the ipo as a force rather than a displacement.\n";
615 PyObject* KX_IpoActuator::PySetIpoAsForce(PyObject* self, 
616                                                                                   PyObject* args, 
617                                                                                   PyObject* kwds) { 
618         ShowDeprecationWarning("setIpoAsForce()", "the useIpoAsForce property");
619         int boolArg;
620         
621         if (!PyArg_ParseTuple(args, "i:setIpoAsForce", &boolArg)) {
622                 return NULL;
623         }
624
625         m_ipo_as_force = PyArgToBool(boolArg);
626         if (m_ipo_as_force)
627                 m_ipo_add = false;
628         
629         Py_RETURN_NONE; 
630 }
631 /* 7. getIpoAsForce:                                                         */
632 const char KX_IpoActuator::GetIpoAsForce_doc[] = 
633 "getIpoAsForce()\n"
634 "\tReturns whether to interpret the ipo as a force rather than a displacement.\n";
635 PyObject* KX_IpoActuator::PyGetIpoAsForce(PyObject* self) {
636         ShowDeprecationWarning("getIpoAsForce()", "the useIpoAsForce property");
637         return BoolToPyArg(m_ipo_as_force);
638 }
639
640 /* 6. setIpoAsForce:                                                           */
641 const char KX_IpoActuator::SetIpoAdd_doc[] = 
642 "setIpoAdd(add?)\n"
643 "\t - add?    : add flag (KX_TRUE, KX_FALSE)\n"
644 "\tSet whether to interpret the ipo as additive rather than absolute.\n";
645 PyObject* KX_IpoActuator::PySetIpoAdd(PyObject* self, 
646                                                                           PyObject* args, 
647                                                                           PyObject* kwds) { 
648         ShowDeprecationWarning("setIpoAdd()", "the useIpoAdd property");
649         int boolArg;
650         
651         if (!PyArg_ParseTuple(args, "i:setIpoAdd", &boolArg)) {
652                 return NULL;
653         }
654
655         m_ipo_add = PyArgToBool(boolArg);
656         if (m_ipo_add)
657                 m_ipo_as_force = false;
658         
659         Py_RETURN_NONE; 
660 }
661 /* 7. getIpoAsForce:                                                         */
662 const char KX_IpoActuator::GetIpoAdd_doc[] = 
663 "getIpoAsAdd()\n"
664 "\tReturns whether to interpret the ipo as additive rather than absolute.\n";
665 PyObject* KX_IpoActuator::PyGetIpoAdd(PyObject* self) {
666         ShowDeprecationWarning("getIpoAdd()", "the useIpoAdd property");
667         return BoolToPyArg(m_ipo_add);
668 }
669
670 /* 8. setType:                                                               */
671 const char KX_IpoActuator::SetType_doc[] = 
672 "setType(mode)\n"
673 "\t - mode: Play, PingPong, Flipper, LoopStop, LoopEnd or FromProp (string)\n"
674 "\tSet the operation mode of the actuator.\n";
675 PyObject* KX_IpoActuator::PySetType(PyObject* self, 
676                                                                         PyObject* args, 
677                                                                         PyObject* kwds) {
678         ShowDeprecationWarning("setType()", "the type property");
679         int typeArg;
680         
681         if (!PyArg_ParseTuple(args, "i:setType", &typeArg)) {
682                 return NULL;
683         }
684         
685         if ( (typeArg > KX_ACT_IPO_NODEF) 
686                  && (typeArg < KX_ACT_IPO_MAX) ) {
687                 m_type = typeArg;
688         }
689         
690         Py_RETURN_NONE;
691 }
692 /* 9. getType:                                                               */
693 const char KX_IpoActuator::GetType_doc[] = 
694 "getType()\n"
695 "\tReturns the operation mode of the actuator.\n";
696 PyObject* KX_IpoActuator::PyGetType(PyObject* self) {
697         ShowDeprecationWarning("getType()", "the type property");
698         return PyInt_FromLong(m_type);
699 }
700
701 /* 10. setForceIpoActsLocal:                                                 */
702 const char KX_IpoActuator::SetForceIpoActsLocal_doc[] = 
703 "setForceIpoActsLocal(local?)\n"
704 "\t - local?    : Apply the ipo-as-force in the object's local\n"
705 "\t               coordinates? (KX_TRUE, KX_FALSE)\n"
706 "\tSet whether to apply the force in the object's local\n"
707 "\tcoordinates rather than the world global coordinates.\n";
708 PyObject* KX_IpoActuator::PySetForceIpoActsLocal(PyObject* self, 
709                                                                                          PyObject* args, 
710                                                                                      PyObject* kwds) { 
711         ShowDeprecationWarning("setForceIpoActsLocal()", "the useIpoLocal property");
712         int boolArg;
713         
714         if (!PyArg_ParseTuple(args, "i:setForceIpoActsLocal", &boolArg)) {
715                 return NULL;
716         }
717
718         m_ipo_local = PyArgToBool(boolArg);
719         
720         Py_RETURN_NONE; 
721 }
722 /* 11. getForceIpoActsLocal:                                                */
723 const char KX_IpoActuator::GetForceIpoActsLocal_doc[] = 
724 "getForceIpoActsLocal()\n"
725 "\tReturn whether to apply the force in the object's local\n"
726 "\tcoordinates rather than the world global coordinates.\n";
727 PyObject* KX_IpoActuator::PyGetForceIpoActsLocal(PyObject* self) {
728         ShowDeprecationWarning("getForceIpoActsLocal()", "the useIpoLocal property");
729         return BoolToPyArg(m_ipo_local);
730 }
731
732
733 /* eof */