Ignore:
Timestamp:
Jul 15, 2012, 6:07:12 PM (10 years ago)
Author:
touky
Message:

Correct integration of EasyConstraint + TestDemo.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/test/Physics/EasyPhysics.h

    r1632 r1633  
    3333{
    3434
     35        friend class EasyConstraint;
     36
    3537#ifdef HAVE_PHYS_USE_BULLET
    3638
     
    5052        void InitBodyToRigid(bool ZeroMassIsKinematic=false);
    5153        void AddToSimulation(class Simulation* current_simulation);
     54        void RemoveFromSimulation(class Simulation* current_simulation);
    5255        mat4 GetTransform();
    5356
     
    8083        void InitBodyToRigid() { }
    8184        void AddToSimulation(class Simulation* current_simulation) { }
     85        void RemoveFromSimulation(class Simulation* current_simulation) { }
    8286        mat4 GetTransform() { return mat4(1.0f); }
    8387
     
    109113class EasyConstraint
    110114{
    111         EasyConstraint()
    112         {
    113                 //btPoint2PointConstraint(bA, bB, PivotA, PivotB)
    114                 //btHingeConstraint(bA, bB, TransfA, TransfB, UseRefA)
    115                 //btSliderConstraint(bA, bB, TransfA, TransfB, UseRefA)
    116                 //btConeTwistConstraint(bA, bB, TransfA, TransfB)
    117                 //btGeneric6DofConstraint(bA, bB, TransfA, TransfB, UseRefA)
    118         }
    119 
    120115#ifdef HAVE_PHYS_USE_BULLET
    121116
     117public:
     118        EasyConstraint() :
     119                m_typed_constraint(NULL),
     120                m_p2p_constraint(NULL),
     121                m_hinge_constraint(NULL),
     122                m_slider_constraint(NULL),
     123                m_cone_twist_constraint(NULL),
     124                m_6dof_constraint(NULL),
     125                m_a_physobj(NULL),
     126                m_b_physobj(NULL),
     127                m_a_transform(lol::mat4(1.f)),
     128                m_b_transform(lol::mat4(1.f)),
     129                m_using_ref_a(false),
     130                m_disable_a2b_collision(false)
     131
     132        {
     133        }
     134        ~EasyConstraint()
     135        {
     136                delete m_typed_constraint;
     137                m_p2p_constraint = NULL;
     138                m_hinge_constraint = NULL;
     139                m_slider_constraint = NULL;
     140                m_cone_twist_constraint = NULL;
     141                m_6dof_constraint = NULL;
     142        }
     143
     144        void AddToSimulation(class Simulation* current_simulation);
     145        void RemoveFromSimulation(class Simulation* current_simulation);
     146
     147private:
     148
     149        //check if Init can be done
     150        bool CanProceedWithInit()
     151        {
     152                if (!m_a_physobj || !m_b_physobj)
     153                        return false;
     154
     155                if (!m_a_physobj->m_rigid_body || !m_b_physobj->m_rigid_body)
     156                        return false;
     157
     158                return true;
     159        }
     160
     161        //-------------------------------------------------------------------------
     162        //Init constraint functions
     163        //--
     164        void CustomInitConstraintToPoint2Point()
     165        {
     166                m_p2p_constraint = new btPoint2PointConstraint(*m_a_physobj->m_rigid_body, *m_b_physobj->m_rigid_body,
     167                                                                                                                LOL2BT_VEC3(m_a_transform.v3.xyz * LOL2BT_UNIT), LOL2BT_VEC3(m_b_transform.v3.xyz * LOL2BT_UNIT));
     168                m_typed_constraint = m_p2p_constraint;
     169        }
     170
     171        void CustomInitConstraintToHinge()
     172        {
     173                m_hinge_constraint = new btHingeConstraint(*m_a_physobj->m_rigid_body, *m_b_physobj->m_rigid_body,
     174                                                                                                                btTransform(LOL2BT_QUAT(quat(m_a_transform)), LOL2BT_VEC3(m_a_transform.v3.xyz * LOL2BT_UNIT)),
     175                                                                                                                btTransform(LOL2BT_QUAT(quat(m_b_transform)), LOL2BT_VEC3(m_b_transform.v3.xyz * LOL2BT_UNIT)),
     176                                                                                                                m_using_ref_a);
     177                m_typed_constraint = m_hinge_constraint;
     178        }
     179
     180        void CustomInitConstraintToSlider()
     181        {
     182                m_slider_constraint = new btSliderConstraint(*m_a_physobj->m_rigid_body, *m_b_physobj->m_rigid_body,
     183                                                                                                                btTransform(LOL2BT_QUAT(quat(m_a_transform)), LOL2BT_VEC3(m_a_transform.v3.xyz * LOL2BT_UNIT)),
     184                                                                                                                btTransform(LOL2BT_QUAT(quat(m_b_transform)), LOL2BT_VEC3(m_b_transform.v3.xyz * LOL2BT_UNIT)),
     185                                                                                                                m_using_ref_a);
     186                m_typed_constraint = m_slider_constraint;
     187        }
     188
     189        void CustomInitConstraintToConeTwist()
     190        {
     191                m_cone_twist_constraint = new btConeTwistConstraint(*m_a_physobj->m_rigid_body, *m_b_physobj->m_rigid_body,
     192                                                                                                                btTransform(LOL2BT_QUAT(quat(m_a_transform)), LOL2BT_VEC3(m_a_transform.v3.xyz * LOL2BT_UNIT)),
     193                                                                                                                btTransform(LOL2BT_QUAT(quat(m_b_transform)), LOL2BT_VEC3(m_b_transform.v3.xyz * LOL2BT_UNIT)));
     194                m_typed_constraint = m_cone_twist_constraint;
     195        }
     196
     197        void CustomInitConstraintTo6Dof()
     198        {
     199                m_6dof_constraint = new btGeneric6DofConstraint(*m_a_physobj->m_rigid_body, *m_b_physobj->m_rigid_body,
     200                                                                                                                btTransform(LOL2BT_QUAT(quat(m_a_transform)), LOL2BT_VEC3(m_a_transform.v3.xyz * LOL2BT_UNIT)),
     201                                                                                                                btTransform(LOL2BT_QUAT(quat(m_b_transform)), LOL2BT_VEC3(m_b_transform.v3.xyz * LOL2BT_UNIT)),
     202                                                                                                                m_using_ref_a);
     203                m_typed_constraint = m_6dof_constraint;
     204        }
     205
    122206        btTypedConstraint*                      m_typed_constraint;
     207        btPoint2PointConstraint*        m_p2p_constraint;
     208        btHingeConstraint*                      m_hinge_constraint;
     209        btSliderConstraint*                     m_slider_constraint;
     210        btConeTwistConstraint*          m_cone_twist_constraint;
     211        btGeneric6DofConstraint*        m_6dof_constraint;
    123212
    124213#else  // NO PHYSIC IMPLEMENTATION
    125214
     215public:
     216        EasyConstraint() :
     217                m_a_physobj(NULL),
     218                m_b_physobj(NULL),
     219                m_a_transform(lol::mat4(1.f)),
     220                m_b_transform(lol::mat4(1.f)),
     221                m_using_ref_a(false),
     222                m_disable_a2b_collision(false)
     223        {
     224        }
     225
     226private:
     227
     228        void AddToSimulation(class Simulation* current_simulation) { }
     229        void RemoveFromSimulation(class Simulation* current_simulation) { }
     230
     231        //check if Init can be done
     232        bool CanProceedWithInit() { return false; }
     233        void CustomInitConstraintToPoint2Point() { }
     234        void CustomInitConstraintToHinge() { }
     235        void CustomInitConstraintToSlider() { }
     236        void CustomInitConstraintToConeTwist() { }
     237        void CustomInitConstraintTo6Dof() { }
     238
    126239#endif // PHYSIC IMPLEMENTATION
    127240
     241public:
     242        void InitConstraintToPoint2Point()      { if (CanProceedWithInit()) CustomInitConstraintToPoint2Point(); }
     243        void InitConstraintToHinge()            { if (CanProceedWithInit()) CustomInitConstraintToHinge(); }
     244        void InitConstraintToSlider()           { if (CanProceedWithInit()) CustomInitConstraintToSlider(); }
     245        void InitConstraintToConeTwist()        { if (CanProceedWithInit()) CustomInitConstraintToConeTwist(); }
     246        void InitConstraintTo6Dof()                     { if (CanProceedWithInit()) CustomInitConstraintTo6Dof(); }
     247
     248        //Set given physic object to the proper slot.
     249        void SetPhysObjA(EasyPhysic* NewPhysObj, lol::mat4 NewTransform) { SetPhysObj(false, NewPhysObj, NewTransform); }
     250        void SetPhysObjB(EasyPhysic* NewPhysObj, lol::mat4 NewTransform) { SetPhysObj(true, NewPhysObj, NewTransform); }
     251        void SetPhysObj(bool SetToB, EasyPhysic* NewPhysObj, lol::mat4 NewTransform)
     252        {
     253                if (SetToB)
     254                {
     255                        m_b_physobj = NewPhysObj;
     256                        m_b_transform = NewTransform;
     257                }
     258                else
     259                {
     260                        m_a_physobj = NewPhysObj;
     261                        m_a_transform = NewTransform;
     262                }
     263        }
     264
     265        //Set whether or not the physic engine should use the A object as the reference (most constraint transform are local).
     266        void SetRefAsA(bool NewUseRefA)
     267        {
     268                m_using_ref_a = NewUseRefA;
     269        }
     270
     271        //Set whether or not to disable the collision between the bodies
     272        void DisableCollisionBetweenObjs(bool DisableCollision)
     273        {
     274                m_disable_a2b_collision = DisableCollision;
     275        }
     276
     277private:
     278        EasyPhysic*                                     m_a_physobj;
     279        EasyPhysic*                                     m_b_physobj;
     280        lol::mat4                                       m_a_transform;
     281        lol::mat4                                       m_b_transform;
     282        bool                                            m_using_ref_a;
     283        bool                                            m_disable_a2b_collision;
     284
    128285};
    129286
Note: See TracChangeset for help on using the changeset viewer.