← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty

« back to all changes in this revision

Viewing changes to source/gameengine/Ketsji/KX_ObjectActuator.cpp

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-03-06 12:08:47 UTC
  • mfrom: (1.5.1) (14.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20130306120847-frjfaryb2zrotwcg
Tags: 2.66a-1ubuntu1
https://launchpad.net/bugs/1076930
https://launchpad.net/bugs/1089256
https://launchpad.net/bugs/1052743
https://launchpad.net/bugs/999024
* Resynchronize with Debian (LP: #1076930, #1089256, #1052743, #999024,
  #1122888, #1147084)
* debian/control:
  - Lower build-depends on libavcodec-dev since we're not
    doing the libav9 transition in Ubuntu yet

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/gameengine/Ketsji/KX_ObjectActuator.cpp
81
81
 
82
82
                m_pid = m_torque;
83
83
        }
 
84
        if (m_bitLocalFlag.CharacterMotion)
 
85
        {
 
86
                KX_GameObject *parent = static_cast<KX_GameObject *>(GetParent());
 
87
 
 
88
                if (!parent->GetPhysicsController() || !parent->GetPhysicsController()->IsCharacter())
 
89
                {
 
90
                        printf("Character motion enabled on non-character object (%s), falling back to simple motion.\n", parent->GetName().Ptr());
 
91
                        m_bitLocalFlag.CharacterMotion = false;
 
92
                }
 
93
        }
84
94
        if (m_reference)
85
95
                m_reference->RegisterActuator(this);
86
96
        UpdateFuzzyFlags();
114
124
                                                (m_bitLocalFlag.AngularVelocity) != 0
115
125
                                        );
116
126
                        m_active_combined_velocity = false;
117
 
                } 
 
127
                }
 
128
 
 
129
                // Explicitly stop the movement if we're using character motion
 
130
                if (m_bitLocalFlag.CharacterMotion) {
 
131
                        MT_Vector3 vec(0.0, 0.0, 0.0);
 
132
                        parent->GetPhysicsController()->SetWalkDirection(vec, true);
 
133
                }
 
134
 
118
135
                m_linear_damping_active = false;
119
136
                m_angular_damping_active = false;
120
137
                m_error_accumulator.setValue(0.0,0.0,0.0);
198
215
                        m_previous_error = e;
199
216
                        m_error_accumulator = I;
200
217
                        parent->ApplyForce(m_force,(m_bitLocalFlag.LinearVelocity) != 0);
201
 
                } else
 
218
                } else if(m_bitLocalFlag.CharacterMotion)
202
219
                {
 
220
                        MT_Vector3 dir = m_dloc;
 
221
 
 
222
                        if (m_bitLocalFlag.AddOrSetCharLoc) {
 
223
                                MT_Vector3 old_dir = parent->GetPhysicsController()->GetWalkDirection();
 
224
 
 
225
                                if (!old_dir.fuzzyZero()) {
 
226
                                        MT_Scalar mag = old_dir.length();
 
227
 
 
228
                                        dir = dir + old_dir;
 
229
                                        if (!dir.fuzzyZero())
 
230
                                                dir = dir.normalized() * mag;
 
231
                                }
 
232
                        }
 
233
 
 
234
                        // We always want to set the walk direction since a walk direction of (0, 0, 0) should stop the character
 
235
                        parent->GetPhysicsController()->SetWalkDirection(dir, (m_bitLocalFlag.DLoc) != 0);
 
236
 
 
237
                        if (!m_bitLocalFlag.ZeroDRot)
 
238
                        {
 
239
                                parent->ApplyRotation(m_drot,(m_bitLocalFlag.DRot) != 0);
 
240
                        }
 
241
                        if (m_bitLocalFlag.CharacterJump)
 
242
                        {
 
243
                                parent->GetPhysicsController()->Jump();
 
244
                        }
 
245
                }
 
246
                else {
203
247
                        if (!m_bitLocalFlag.ZeroForce)
204
248
                        {
205
249
                                parent->ApplyForce(m_force,(m_bitLocalFlag.Force) != 0);
389
433
 
390
434
static int mathutils_obactu_generic_check(BaseMathObject *bmo)
391
435
{
392
 
        KX_ObjectActuator* self= static_cast<KX_ObjectActuator*>BGE_PROXY_REF(bmo->cb_user);
393
 
        if (self==NULL)
 
436
        KX_ObjectActuator* self = static_cast<KX_ObjectActuator*>BGE_PROXY_REF(bmo->cb_user);
 
437
        if (self == NULL)
394
438
                return -1;
395
439
 
396
440
        return 0;
398
442
 
399
443
static int mathutils_obactu_vector_get(BaseMathObject *bmo, int subtype)
400
444
{
401
 
        KX_ObjectActuator* self= static_cast<KX_ObjectActuator*>BGE_PROXY_REF(bmo->cb_user);
402
 
        if (self==NULL)
 
445
        KX_ObjectActuator* self = static_cast<KX_ObjectActuator*>BGE_PROXY_REF(bmo->cb_user);
 
446
        if (self == NULL)
403
447
                return -1;
404
448
 
405
 
        switch(subtype) {
 
449
        switch (subtype) {
406
450
                case MATHUTILS_VEC_CB_LINV:
407
451
                        self->m_linear_velocity.getValue(bmo->data);
408
452
                        break;
416
460
 
417
461
static int mathutils_obactu_vector_set(BaseMathObject *bmo, int subtype)
418
462
{
419
 
        KX_ObjectActuator* self= static_cast<KX_ObjectActuator*>BGE_PROXY_REF(bmo->cb_user);
420
 
        if (self==NULL)
 
463
        KX_ObjectActuator* self = static_cast<KX_ObjectActuator*>BGE_PROXY_REF(bmo->cb_user);
 
464
        if (self == NULL)
421
465
                return -1;
422
466
 
423
 
        switch(subtype) {
 
467
        switch (subtype) {
424
468
                case MATHUTILS_VEC_CB_LINV:
425
469
                        self->m_linear_velocity.setValue(bmo->data);
426
470
                        break;
442
486
 
443
487
static int mathutils_obactu_vector_set_index(BaseMathObject *bmo, int subtype, int index)
444
488
{
445
 
        float f= bmo->data[index];
 
489
        float f = bmo->data[index];
446
490
 
447
491
        /* lazy, avoid repeteing the case statement */
448
492
        if (mathutils_obactu_vector_get(bmo, subtype) == -1)
449
493
                return -1;
450
494
 
451
 
        bmo->data[index]= f;
 
495
        bmo->data[index] = f;
452
496
        return mathutils_obactu_vector_set(bmo, subtype);
453
497
}
454
498
 
460
504
        mathutils_obactu_vector_set_index
461
505
};
462
506
 
463
 
PyObject* KX_ObjectActuator::pyattr_get_linV(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 
507
PyObject *KX_ObjectActuator::pyattr_get_linV(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
464
508
{
465
509
        return Vector_CreatePyObject_cb(BGE_PROXY_FROM_REF(self_v), 3, mathutils_kxobactu_vector_cb_index, MATHUTILS_VEC_CB_LINV);
466
510
}
467
511
 
468
512
int KX_ObjectActuator::pyattr_set_linV(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
469
513
{
470
 
        KX_ObjectActuator* self= static_cast<KX_ObjectActuator*>(self_v);
 
514
        KX_ObjectActuator* self = static_cast<KX_ObjectActuator*>(self_v);
471
515
        if (!PyVecTo(value, self->m_linear_velocity))
472
516
                return PY_SET_ATTR_FAIL;
473
517
 
476
520
        return PY_SET_ATTR_SUCCESS;
477
521
}
478
522
 
479
 
PyObject* KX_ObjectActuator::pyattr_get_angV(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 
523
PyObject *KX_ObjectActuator::pyattr_get_angV(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
480
524
{
481
525
        return Vector_CreatePyObject_cb(BGE_PROXY_FROM_REF(self_v), 3, mathutils_kxobactu_vector_cb_index, MATHUTILS_VEC_CB_ANGV);
482
526
}
483
527
 
484
528
int KX_ObjectActuator::pyattr_set_angV(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
485
529
{
486
 
        KX_ObjectActuator* self= static_cast<KX_ObjectActuator*>(self_v);
 
530
        KX_ObjectActuator* self = static_cast<KX_ObjectActuator*>(self_v);
487
531
        if (!PyVecTo(value, self->m_angular_velocity))
488
532
                return PY_SET_ATTR_FAIL;
489
533
 
501
545
 
502
546
#endif // USE_MATHUTILS
503
547
 
504
 
PyObject* KX_ObjectActuator::pyattr_get_forceLimitX(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 
548
PyObject *KX_ObjectActuator::pyattr_get_forceLimitX(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
505
549
{
506
550
        KX_ObjectActuator* self = reinterpret_cast<KX_ObjectActuator*>(self_v);
507
551
        PyObject *retVal = PyList_New(3);
517
561
{
518
562
        KX_ObjectActuator* self = reinterpret_cast<KX_ObjectActuator*>(self_v);
519
563
 
520
 
        PyObject* seq = PySequence_Fast(value, "");
 
564
        PyObject *seq = PySequence_Fast(value, "");
521
565
        if (seq && PySequence_Fast_GET_SIZE(seq) == 3)
522
566
        {
523
567
                self->m_drot[0] = PyFloat_AsDouble(PySequence_Fast_GET_ITEM(value, 0));
524
568
                self->m_dloc[0] = PyFloat_AsDouble(PySequence_Fast_GET_ITEM(value, 1));
525
 
                self->m_bitLocalFlag.Torque = (PyLong_AsSsize_t(PySequence_Fast_GET_ITEM(value, 2)) != 0);
 
569
                self->m_bitLocalFlag.Torque = (PyLong_AsLong(PySequence_Fast_GET_ITEM(value, 2)) != 0);
526
570
 
527
571
                if (!PyErr_Occurred())
528
572
                {
537
581
        return PY_SET_ATTR_FAIL;
538
582
}
539
583
 
540
 
PyObject* KX_ObjectActuator::pyattr_get_forceLimitY(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 
584
PyObject *KX_ObjectActuator::pyattr_get_forceLimitY(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
541
585
{
542
586
        KX_ObjectActuator* self = reinterpret_cast<KX_ObjectActuator*>(self_v);
543
587
        PyObject *retVal = PyList_New(3);
553
597
{
554
598
        KX_ObjectActuator* self = reinterpret_cast<KX_ObjectActuator*>(self_v);
555
599
 
556
 
        PyObject* seq = PySequence_Fast(value, "");
 
600
        PyObject *seq = PySequence_Fast(value, "");
557
601
        if (seq && PySequence_Fast_GET_SIZE(seq) == 3)
558
602
        {
559
603
                self->m_drot[1] = PyFloat_AsDouble(PySequence_Fast_GET_ITEM(value, 0));
560
604
                self->m_dloc[1] = PyFloat_AsDouble(PySequence_Fast_GET_ITEM(value, 1));
561
 
                self->m_bitLocalFlag.DLoc = (PyLong_AsSsize_t(PySequence_Fast_GET_ITEM(value, 2)) != 0);
 
605
                self->m_bitLocalFlag.DLoc = (PyLong_AsLong(PySequence_Fast_GET_ITEM(value, 2)) != 0);
562
606
 
563
607
                if (!PyErr_Occurred())
564
608
                {
573
617
        return PY_SET_ATTR_FAIL;
574
618
}
575
619
 
576
 
PyObject* KX_ObjectActuator::pyattr_get_forceLimitZ(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 
620
PyObject *KX_ObjectActuator::pyattr_get_forceLimitZ(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
577
621
{
578
622
        KX_ObjectActuator* self = reinterpret_cast<KX_ObjectActuator*>(self_v);
579
623
        PyObject *retVal = PyList_New(3);
589
633
{
590
634
        KX_ObjectActuator* self = reinterpret_cast<KX_ObjectActuator*>(self_v);
591
635
 
592
 
        PyObject* seq = PySequence_Fast(value, "");
 
636
        PyObject *seq = PySequence_Fast(value, "");
593
637
        if (seq && PySequence_Fast_GET_SIZE(seq) == 3)
594
638
        {
595
639
                self->m_drot[2] = PyFloat_AsDouble(PySequence_Fast_GET_ITEM(value, 0));
596
640
                self->m_dloc[2] = PyFloat_AsDouble(PySequence_Fast_GET_ITEM(value, 1));
597
 
                self->m_bitLocalFlag.DRot = (PyLong_AsSsize_t(PySequence_Fast_GET_ITEM(value, 2)) != 0);
 
641
                self->m_bitLocalFlag.DRot = (PyLong_AsLong(PySequence_Fast_GET_ITEM(value, 2)) != 0);
598
642
 
599
643
                if (!PyErr_Occurred())
600
644
                {
609
653
        return PY_SET_ATTR_FAIL;
610
654
}
611
655
 
612
 
PyObject* KX_ObjectActuator::pyattr_get_reference(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef)
 
656
PyObject *KX_ObjectActuator::pyattr_get_reference(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef)
613
657
{
614
658
        KX_ObjectActuator* actuator = static_cast<KX_ObjectActuator*>(self);
615
659
        if (!actuator->m_reference)
632
676
        if (refOb==NULL) {
633
677
                actuator->m_reference= NULL;
634
678
        }
635
 
        else {  
 
679
        else {
636
680
                actuator->m_reference = refOb;
637
681
                actuator->m_reference->RegisterActuator(actuator);
638
682
        }