source: trunk/test/Physics/Include/EasyConstraint.h @ 1748

Last change on this file since 1748 was 1748, checked in by touky, 8 years ago

Small .h & .cpp refactor

File size: 6.4 KB
Line 
1//
2// Lol Engine
3//
4// Copyright: (c) 2010-2012 Sam Hocevar <sam@hocevar.net>
5//            (c) 2009-2012 Benjamin Huet <huet.benjamin@gmail.com>
6//   This program is free software; you can redistribute it and/or
7//   modify it under the terms of the Do What The Fuck You Want To
8//   Public License, Version 2, as published by Sam Hocevar. See
9//   http://sam.zoy.org/projects/COPYING.WTFPL for more details.
10//
11
12//
13// The EasyPhysic class
14// ------------------
15//
16
17#if !defined __EASYCONSTRAINT_EASYCONSTRAINT_H__
18#define __EASYCONSTRAINT_EASYCONSTRAINT_H__
19
20#ifdef HAVE_PHYS_USE_BULLET
21#include "EasyPhysics.h"
22#endif
23
24namespace lol
25{
26
27namespace phys
28{
29
30class EasyConstraint
31{
32#ifdef HAVE_PHYS_USE_BULLET
33
34public:
35        EasyConstraint() :
36                m_typed_constraint(NULL),
37                m_p2p_constraint(NULL),
38                m_hinge_constraint(NULL),
39                m_slider_constraint(NULL),
40                m_cone_twist_constraint(NULL),
41                m_6dof_constraint(NULL),
42                m_a_physobj(NULL),
43                m_b_physobj(NULL),
44                m_a_transform(lol::mat4(1.f)),
45                m_b_transform(lol::mat4(1.f)),
46                m_using_ref_a(false),
47                m_disable_a2b_collision(false)
48
49        {
50        }
51        ~EasyConstraint()
52        {
53                delete m_typed_constraint;
54                m_p2p_constraint = NULL;
55                m_hinge_constraint = NULL;
56                m_slider_constraint = NULL;
57                m_cone_twist_constraint = NULL;
58                m_6dof_constraint = NULL;
59        }
60
61        void AddToSimulation(class Simulation* current_simulation);
62        void RemoveFromSimulation(class Simulation* current_simulation);
63
64private:
65
66        //check if Init can be done
67        bool CanProceedWithInit()
68        {
69                if (!m_a_physobj || !m_b_physobj)
70                        return false;
71
72                if (!m_a_physobj->m_rigid_body || !m_b_physobj->m_rigid_body)
73                        return false;
74
75                return true;
76        }
77
78        //-------------------------------------------------------------------------
79        //Init constraint functions
80        //--
81        void CustomInitConstraintToPoint2Point()
82        {
83                m_p2p_constraint = new btPoint2PointConstraint(*m_a_physobj->m_rigid_body, *m_b_physobj->m_rigid_body,
84                                                                                                                LOL2BT_VEC3(m_a_transform.v3.xyz * LOL2BT_UNIT), LOL2BT_VEC3(m_b_transform.v3.xyz * LOL2BT_UNIT));
85                m_typed_constraint = m_p2p_constraint;
86        }
87
88        void CustomInitConstraintToHinge()
89        {
90                m_hinge_constraint = new btHingeConstraint(*m_a_physobj->m_rigid_body, *m_b_physobj->m_rigid_body,
91                                                                                                                btTransform(LOL2BT_QUAT(quat(m_a_transform)), LOL2BT_VEC3(m_a_transform.v3.xyz * LOL2BT_UNIT)),
92                                                                                                                btTransform(LOL2BT_QUAT(quat(m_b_transform)), LOL2BT_VEC3(m_b_transform.v3.xyz * LOL2BT_UNIT)),
93                                                                                                                m_using_ref_a);
94                m_typed_constraint = m_hinge_constraint;
95        }
96
97        void CustomInitConstraintToSlider()
98        {
99                m_slider_constraint = new btSliderConstraint(*m_a_physobj->m_rigid_body, *m_b_physobj->m_rigid_body,
100                                                                                                                btTransform(LOL2BT_QUAT(quat(m_a_transform)), LOL2BT_VEC3(m_a_transform.v3.xyz * LOL2BT_UNIT)),
101                                                                                                                btTransform(LOL2BT_QUAT(quat(m_b_transform)), LOL2BT_VEC3(m_b_transform.v3.xyz * LOL2BT_UNIT)),
102                                                                                                                m_using_ref_a);
103                m_typed_constraint = m_slider_constraint;
104        }
105
106        void CustomInitConstraintToConeTwist()
107        {
108                m_cone_twist_constraint = new btConeTwistConstraint(*m_a_physobj->m_rigid_body, *m_b_physobj->m_rigid_body,
109                                                                                                                btTransform(LOL2BT_QUAT(quat(m_a_transform)), LOL2BT_VEC3(m_a_transform.v3.xyz * LOL2BT_UNIT)),
110                                                                                                                btTransform(LOL2BT_QUAT(quat(m_b_transform)), LOL2BT_VEC3(m_b_transform.v3.xyz * LOL2BT_UNIT)));
111                m_typed_constraint = m_cone_twist_constraint;
112        }
113
114        void CustomInitConstraintTo6Dof()
115        {
116                m_6dof_constraint = new btGeneric6DofConstraint(*m_a_physobj->m_rigid_body, *m_b_physobj->m_rigid_body,
117                                                                                                                btTransform(LOL2BT_QUAT(quat(m_a_transform)), LOL2BT_VEC3(m_a_transform.v3.xyz * LOL2BT_UNIT)),
118                                                                                                                btTransform(LOL2BT_QUAT(quat(m_b_transform)), LOL2BT_VEC3(m_b_transform.v3.xyz * LOL2BT_UNIT)),
119                                                                                                                m_using_ref_a);
120                m_typed_constraint = m_6dof_constraint;
121        }
122
123        btTypedConstraint*                      m_typed_constraint;
124        btPoint2PointConstraint*        m_p2p_constraint;
125        btHingeConstraint*                      m_hinge_constraint;
126        btSliderConstraint*                     m_slider_constraint;
127        btConeTwistConstraint*          m_cone_twist_constraint;
128        btGeneric6DofConstraint*        m_6dof_constraint;
129
130#else  // NO PHYSIC IMPLEMENTATION
131
132public:
133        EasyConstraint() :
134                m_a_physobj(NULL),
135                m_b_physobj(NULL),
136                m_a_transform(lol::mat4(1.f)),
137                m_b_transform(lol::mat4(1.f)),
138                m_using_ref_a(false),
139                m_disable_a2b_collision(false)
140        {
141        }
142
143private:
144
145        void AddToSimulation(class Simulation* current_simulation) { }
146        void RemoveFromSimulation(class Simulation* current_simulation) { }
147
148        //check if Init can be done
149        bool CanProceedWithInit() { return false; }
150        void CustomInitConstraintToPoint2Point() { }
151        void CustomInitConstraintToHinge() { }
152        void CustomInitConstraintToSlider() { }
153        void CustomInitConstraintToConeTwist() { }
154        void CustomInitConstraintTo6Dof() { }
155
156#endif // PHYSIC IMPLEMENTATION
157
158public:
159        void InitConstraintToPoint2Point()      { if (CanProceedWithInit()) CustomInitConstraintToPoint2Point(); }
160        void InitConstraintToHinge()            { if (CanProceedWithInit()) CustomInitConstraintToHinge(); }
161        void InitConstraintToSlider()           { if (CanProceedWithInit()) CustomInitConstraintToSlider(); }
162        void InitConstraintToConeTwist()        { if (CanProceedWithInit()) CustomInitConstraintToConeTwist(); }
163        void InitConstraintTo6Dof()                     { if (CanProceedWithInit()) CustomInitConstraintTo6Dof(); }
164
165        //Set given physic object to the proper slot.
166        void SetPhysObjA(EasyPhysic* NewPhysObj, lol::mat4 NewTransform) { SetPhysObj(false, NewPhysObj, NewTransform); }
167        void SetPhysObjB(EasyPhysic* NewPhysObj, lol::mat4 NewTransform) { SetPhysObj(true, NewPhysObj, NewTransform); }
168        void SetPhysObj(bool SetToB, EasyPhysic* NewPhysObj, lol::mat4 NewTransform)
169        {
170                if (SetToB)
171                {
172                        m_b_physobj = NewPhysObj;
173                        m_b_transform = NewTransform;
174                }
175                else
176                {
177                        m_a_physobj = NewPhysObj;
178                        m_a_transform = NewTransform;
179                }
180        }
181
182        //Set whether or not the physic engine should use the A object as the reference (most constraint transform are local).
183        void SetRefAsA(bool NewUseRefA)
184        {
185                m_using_ref_a = NewUseRefA;
186        }
187
188        //Set whether or not to disable the collision between the bodies
189        void DisableCollisionBetweenObjs(bool DisableCollision)
190        {
191                m_disable_a2b_collision = DisableCollision;
192        }
193
194private:
195        EasyPhysic*                                     m_a_physobj;
196        EasyPhysic*                                     m_b_physobj;
197        lol::mat4                                       m_a_transform;
198        lol::mat4                                       m_b_transform;
199        bool                                            m_using_ref_a;
200        bool                                            m_disable_a2b_collision;
201
202};
203
204} /* namespace phys */
205
206} /* namespace lol */
207
208#endif /* __EASYCONSTRAINT_EASYCONSTRAINT_H__ */
209
Note: See TracBrowser for help on using the repository browser.