fix for bug #18898: GE perspective 3D View not working properly (missing LENS)
[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         bool numevents = false;
168         bool bIpoStart = false;
169
170         curtime -= KX_KetsjiEngine::GetSuspendedDelta();
171
172         if (frame)
173         {
174                 numevents = m_posevent || m_negevent;
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 = false;
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 #if (PY_VERSION_HEX >= 0x02060000)
417         PyVarObject_HEAD_INIT(NULL, 0)
418 #else
419         /* python 2.5 and below */
420         PyObject_HEAD_INIT( NULL )  /* required py macro */
421         0,                          /* ob_size */
422 #endif
423         "KX_IpoActuator",
424         sizeof(PyObjectPlus_Proxy),
425         0,
426         py_base_dealloc,
427         0,
428         0,
429         0,
430         0,
431         py_base_repr,
432         0,0,0,0,0,0,
433         py_base_getattro,
434         py_base_setattro,
435         0,0,0,0,0,0,0,0,0,
436         Methods
437 };
438
439 PyParentObject KX_IpoActuator::Parents[] = {
440         &KX_IpoActuator::Type,
441         &SCA_IActuator::Type,
442         &SCA_ILogicBrick::Type,
443         &CValue::Type,
444         NULL
445 };
446
447 PyMethodDef KX_IpoActuator::Methods[] = {
448         // deprecated 
449         {"set", (PyCFunction) KX_IpoActuator::sPySet, METH_VARARGS, (PY_METHODCHAR)Set_doc},
450         {"setProperty", (PyCFunction) KX_IpoActuator::sPySetProperty, METH_VARARGS, (PY_METHODCHAR)SetProperty_doc},
451         {"setStart", (PyCFunction) KX_IpoActuator::sPySetStart, METH_VARARGS, (PY_METHODCHAR)SetStart_doc},
452         {"getStart", (PyCFunction) KX_IpoActuator::sPyGetStart, METH_NOARGS, (PY_METHODCHAR)GetStart_doc},
453         {"setEnd", (PyCFunction) KX_IpoActuator::sPySetEnd, METH_VARARGS, (PY_METHODCHAR)SetEnd_doc},
454         {"getEnd", (PyCFunction) KX_IpoActuator::sPyGetEnd, METH_NOARGS, (PY_METHODCHAR)GetEnd_doc},
455         {"setIpoAsForce", (PyCFunction) KX_IpoActuator::sPySetIpoAsForce, METH_VARARGS, (PY_METHODCHAR)SetIpoAsForce_doc},
456         {"getIpoAsForce", (PyCFunction) KX_IpoActuator::sPyGetIpoAsForce, METH_NOARGS, (PY_METHODCHAR)GetIpoAsForce_doc},
457         {"setIpoAdd", (PyCFunction) KX_IpoActuator::sPySetIpoAdd, METH_VARARGS, (PY_METHODCHAR)SetIpoAdd_doc},
458         {"getIpoAdd", (PyCFunction) KX_IpoActuator::sPyGetIpoAdd, METH_NOARGS, (PY_METHODCHAR)GetIpoAdd_doc},
459         {"setForceIpoActsLocal", (PyCFunction) KX_IpoActuator::sPySetForceIpoActsLocal, METH_VARARGS, (PY_METHODCHAR)SetForceIpoActsLocal_doc},
460         {"getForceIpoActsLocal", (PyCFunction) KX_IpoActuator::sPyGetForceIpoActsLocal, METH_NOARGS, (PY_METHODCHAR)GetForceIpoActsLocal_doc},
461         {"setType", (PyCFunction) KX_IpoActuator::sPySetType, METH_VARARGS, (PY_METHODCHAR)SetType_doc},
462         {"getType", (PyCFunction) KX_IpoActuator::sPyGetType, METH_NOARGS, (PY_METHODCHAR)GetType_doc}, 
463         {NULL,NULL} //Sentinel
464 };
465
466 PyAttributeDef KX_IpoActuator::Attributes[] = {
467         KX_PYATTRIBUTE_FLOAT_RW("frameStart", 0, 300000, KX_IpoActuator, m_startframe),
468         KX_PYATTRIBUTE_FLOAT_RW("frameEnd", 0, 300000, KX_IpoActuator, m_endframe),
469         KX_PYATTRIBUTE_STRING_RW("propName", 0, 64, false, KX_IpoActuator, m_propname),
470         KX_PYATTRIBUTE_STRING_RW("framePropName", 0, 64, false, KX_IpoActuator, m_framepropname),
471         KX_PYATTRIBUTE_INT_RW("mode", KX_ACT_IPO_NODEF+1, KX_ACT_IPO_MAX-1, true, KX_IpoActuator, m_type),
472         KX_PYATTRIBUTE_BOOL_RW("useIpoAsForce", KX_IpoActuator, m_ipo_as_force),
473         KX_PYATTRIBUTE_BOOL_RW("useIpoAdd", KX_IpoActuator, m_ipo_add),
474         KX_PYATTRIBUTE_BOOL_RW("useIpoLocal", KX_IpoActuator, m_ipo_local),
475         KX_PYATTRIBUTE_BOOL_RW("useChildren", KX_IpoActuator, m_recurse),
476         
477         { NULL }        //Sentinel
478 };
479
480 PyObject* KX_IpoActuator::py_getattro(PyObject *attr) {
481         py_getattro_up(SCA_IActuator);
482 }
483
484 PyObject* KX_IpoActuator::py_getattro_dict() {
485         py_getattro_dict_up(SCA_IActuator);
486 }
487
488 int KX_IpoActuator::py_setattro(PyObject *attr, PyObject *value)        // py_setattro method
489 {
490         py_setattro_up(SCA_IActuator);
491 }
492
493 /* set --------------------------------------------------------------------- */
494 const char KX_IpoActuator::Set_doc[] = 
495 "set(type, startframe, endframe, mode?)\n"
496 "\t - type:       Play, PingPong, Flipper, LoopStop, LoopEnd or FromProp (string)\n"
497 "\t - startframe: first frame to use (int)\n"
498 "\t - endframe  : last frame to use (int)\n"
499 "\t - mode?     : special mode (0=normal, 1=interpret location as force, 2=additive)"
500 "\tSet the properties of the actuator.\n";
501 PyObject* KX_IpoActuator::PySet(PyObject* args) {
502         
503         ShowDeprecationWarning("set()", "a range properties");
504                                                                         
505         /* sets modes PLAY, PINGPONG, FLIPPER, LOOPSTOP, LOOPEND                 */
506         /* arg 1 = mode string, arg 2 = startframe, arg3 = stopframe,            */
507         /* arg4 = force toggle                                                   */
508         char* mode;
509         int forceToggle;
510         int modenum;
511         int startFrame, stopFrame;
512         if(!PyArg_ParseTuple(args, "siii:set", &mode, &startFrame, 
513                                                  &stopFrame, &forceToggle)) {
514                 return NULL;
515         }
516         modenum = string2mode(mode);
517         
518         switch (modenum) {
519         case KX_ACT_IPO_PLAY:
520         case KX_ACT_IPO_PINGPONG:
521         case KX_ACT_IPO_FLIPPER:
522         case KX_ACT_IPO_LOOPSTOP:
523         case KX_ACT_IPO_LOOPEND:
524                 m_type         = modenum;
525                 m_startframe    = startFrame;
526                 m_endframe      = stopFrame;
527                 m_ipo_as_force = forceToggle == 1;
528                 m_ipo_add = forceToggle == 2;
529                 break;
530         default:
531                 ; /* error */
532         }
533
534         Py_RETURN_NONE;
535 }
536
537 /* set property  ----------------------------------------------------------- */
538 const char KX_IpoActuator::SetProperty_doc[] = 
539 "setProperty(propname)\n"
540 "\t - propname: name of the property (string)\n"
541 "\tSet the property to be used in FromProp mode.\n";
542 PyObject* KX_IpoActuator::PySetProperty(PyObject* args) {
543
544         ShowDeprecationWarning("setProperty()", "the propName property");
545
546         /* mode is implicit here, but not supported yet... */
547         /* args: property */
548         char *propertyName;
549         if(!PyArg_ParseTuple(args, "s:setProperty", &propertyName)) {
550                 return NULL;
551         }
552
553         m_propname = propertyName;
554         
555         Py_RETURN_NONE;
556 }
557
558 /* 4. setStart:                                                              */
559 const char KX_IpoActuator::SetStart_doc[] = 
560 "setStart(frame)\n"
561 "\t - frame: first frame to use (int)\n"
562 "\tSet the frame from which the ipo starts playing.\n";
563 PyObject* KX_IpoActuator::PySetStart(PyObject* args) {
564
565         ShowDeprecationWarning("setStart()", "the frameStart property");
566
567         float startArg;
568         if(!PyArg_ParseTuple(args, "f:setStart", &startArg)) {
569                 return NULL;            
570         }
571         
572         m_startframe = startArg;
573
574         Py_RETURN_NONE;
575 }
576 /* 5. getStart:                                                              */
577 const char KX_IpoActuator::GetStart_doc[] = 
578 "getStart()\n"
579 "\tReturns the frame from which the ipo starts playing.\n";
580 PyObject* KX_IpoActuator::PyGetStart() {
581         ShowDeprecationWarning("getStart()", "the frameStart property");
582         return PyFloat_FromDouble(m_startframe);
583 }
584
585 /* 6. setEnd:                                                                */
586 const char KX_IpoActuator::SetEnd_doc[] = 
587 "setEnd(frame)\n"
588 "\t - frame: last frame to use (int)\n"
589 "\tSet the frame at which the ipo stops playing.\n";
590 PyObject* KX_IpoActuator::PySetEnd(PyObject* args) {
591         ShowDeprecationWarning("setEnd()", "the frameEnd 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() {
606         ShowDeprecationWarning("getEnd()", "the frameEnd 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* args) { 
616         ShowDeprecationWarning("setIpoAsForce()", "the useIpoAsForce property");
617         int boolArg;
618         
619         if (!PyArg_ParseTuple(args, "i:setIpoAsForce", &boolArg)) {
620                 return NULL;
621         }
622
623         m_ipo_as_force = PyArgToBool(boolArg);
624         if (m_ipo_as_force)
625                 m_ipo_add = false;
626         
627         Py_RETURN_NONE; 
628 }
629 /* 7. getIpoAsForce:                                                         */
630 const char KX_IpoActuator::GetIpoAsForce_doc[] = 
631 "getIpoAsForce()\n"
632 "\tReturns whether to interpret the ipo as a force rather than a displacement.\n";
633 PyObject* KX_IpoActuator::PyGetIpoAsForce() {
634         ShowDeprecationWarning("getIpoAsForce()", "the useIpoAsForce property");
635         return BoolToPyArg(m_ipo_as_force);
636 }
637
638 /* 6. setIpoAsForce:                                                           */
639 const char KX_IpoActuator::SetIpoAdd_doc[] = 
640 "setIpoAdd(add?)\n"
641 "\t - add?    : add flag (KX_TRUE, KX_FALSE)\n"
642 "\tSet whether to interpret the ipo as additive rather than absolute.\n";
643 PyObject* KX_IpoActuator::PySetIpoAdd(PyObject* args) { 
644         ShowDeprecationWarning("setIpoAdd()", "the useIpoAdd property");
645         int boolArg;
646         
647         if (!PyArg_ParseTuple(args, "i:setIpoAdd", &boolArg)) {
648                 return NULL;
649         }
650
651         m_ipo_add = PyArgToBool(boolArg);
652         if (m_ipo_add)
653                 m_ipo_as_force = false;
654         
655         Py_RETURN_NONE; 
656 }
657 /* 7. getIpoAsForce:                                                         */
658 const char KX_IpoActuator::GetIpoAdd_doc[] = 
659 "getIpoAsAdd()\n"
660 "\tReturns whether to interpret the ipo as additive rather than absolute.\n";
661 PyObject* KX_IpoActuator::PyGetIpoAdd() {
662         ShowDeprecationWarning("getIpoAdd()", "the useIpoAdd property");
663         return BoolToPyArg(m_ipo_add);
664 }
665
666 /* 8. setType:                                                               */
667 const char KX_IpoActuator::SetType_doc[] = 
668 "setType(mode)\n"
669 "\t - mode: Play, PingPong, Flipper, LoopStop, LoopEnd or FromProp (string)\n"
670 "\tSet the operation mode of the actuator.\n";
671 PyObject* KX_IpoActuator::PySetType(PyObject* args) {
672         ShowDeprecationWarning("setType()", "the mode property");
673         int typeArg;
674         
675         if (!PyArg_ParseTuple(args, "i:setType", &typeArg)) {
676                 return NULL;
677         }
678         
679         if ( (typeArg > KX_ACT_IPO_NODEF) 
680                  && (typeArg < KX_ACT_IPO_MAX) ) {
681                 m_type = typeArg;
682         }
683         
684         Py_RETURN_NONE;
685 }
686 /* 9. getType:                                                               */
687 const char KX_IpoActuator::GetType_doc[] = 
688 "getType()\n"
689 "\tReturns the operation mode of the actuator.\n";
690 PyObject* KX_IpoActuator::PyGetType() {
691         ShowDeprecationWarning("getType()", "the mode property");
692         return PyInt_FromLong(m_type);
693 }
694
695 /* 10. setForceIpoActsLocal:                                                 */
696 const char KX_IpoActuator::SetForceIpoActsLocal_doc[] = 
697 "setForceIpoActsLocal(local?)\n"
698 "\t - local?    : Apply the ipo-as-force in the object's local\n"
699 "\t               coordinates? (KX_TRUE, KX_FALSE)\n"
700 "\tSet whether to apply the force in the object's local\n"
701 "\tcoordinates rather than the world global coordinates.\n";
702 PyObject* KX_IpoActuator::PySetForceIpoActsLocal(PyObject* args) { 
703         ShowDeprecationWarning("setForceIpoActsLocal()", "the useIpoLocal property");
704         int boolArg;
705         
706         if (!PyArg_ParseTuple(args, "i:setForceIpoActsLocal", &boolArg)) {
707                 return NULL;
708         }
709
710         m_ipo_local = PyArgToBool(boolArg);
711         
712         Py_RETURN_NONE; 
713 }
714 /* 11. getForceIpoActsLocal:                                                */
715 const char KX_IpoActuator::GetForceIpoActsLocal_doc[] = 
716 "getForceIpoActsLocal()\n"
717 "\tReturn whether to apply the force in the object's local\n"
718 "\tcoordinates rather than the world global coordinates.\n";
719 PyObject* KX_IpoActuator::PyGetForceIpoActsLocal() {
720         ShowDeprecationWarning("getForceIpoActsLocal()", "the useIpoLocal property");
721         return BoolToPyArg(m_ipo_local);
722 }
723
724
725 /* eof */