source: trunk/test/Physics/EasyPhysics.h @ 1702

Last change on this file since 1702 was 1702, checked in by touky, 9 years ago

Skeleton for EasyCharacterController

File size: 9.9 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 __EASYPHYSICS_EASYPHYSICS_H__
18#define __EASYPHYSICS_EASYPHYSICS_H__
19
20#ifdef HAVE_PHYS_USE_BULLET
21#include "core.h"
22#include <bullet/btBulletDynamicsCommon.h>
23#include <bullet/btBulletCollisionCommon.h>
24#include <bullet/BulletCollision/CollisionDispatch/btGhostObject.h>
25#endif
26
27namespace lol
28{
29
30namespace phys
31{
32
33class EasyPhysic
34{
35
36        friend class EasyConstraint;
37
38#ifdef HAVE_PHYS_USE_BULLET
39
40public:
41        EasyPhysic();
42        ~EasyPhysic();
43
44        virtual void SetShapeToBox(lol::vec3& box_size);
45        virtual void SetShapeToSphere(float radius);
46        virtual void SetShapeToCone(float radius, float height);
47        virtual void SetShapeToCylinder(lol::vec3& cyl_size);
48        virtual void SetShapeToCapsule(float radius, float height);
49
50        virtual bool CanChangeCollisionChannel() { return (m_rigid_body == NULL); }
51        virtual void SetTransform(const lol::vec3& base_location, const lol::quat& base_rotation=lol::quat(lol::mat4(1.0f)));
52        virtual void SetMass(float mass);
53        virtual void InitBodyToRigid(bool ZeroMassIsKinematic=false);
54        virtual void InitBodyToGhost();
55        virtual void AddToSimulation(class Simulation* current_simulation);
56        virtual void RemoveFromSimulation(class Simulation* current_simulation);
57        virtual mat4 GetTransform();
58
59protected:
60        virtual void SetLocalInertia(float mass);
61        virtual void SetShapeTo(btCollisionShape* collision_shape);
62
63        btCollisionObject*                                                      m_collision_object;
64
65        btGhostObject*                                                          m_ghost_object;
66
67        btRigidBody*                                                            m_rigid_body;
68        btVector3                                                                       m_local_inertia;
69
70        btCollisionShape*                                                       m_collision_shape;
71        btMotionState*                                                          m_motion_state;
72
73#else  // NO PHYSIC IMPLEMENTATION
74
75public:
76        EasyPhysic() { }
77
78        virtual void SetShapeToBox(lol::vec3& BoxSize) { }
79        virtual void SetShapeToSphere(float radius) { }
80        virtual void SetShapeToCone(float radius, float height) { }
81        virtual void SetShapeToCylinder(lol::vec3& cyl_size) { }
82        virtual void SetShapeToCapsule(float radius, float height) { }
83
84        virtual bool CanChangeCollisionChannel() { return true; }
85        virtual void SetTransform(const lol::vec3& base_location, const lol::quat& base_rotation=lol::quat(lol::mat4(1.0f))) { }
86        virtual void SetMass(float mass) { }
87        virtual void InitBodyToRigid() { }
88        virtual void InitBodyToGhost() { }
89        virtual void AddToSimulation(class Simulation* current_simulation) { }
90        virtual void RemoveFromSimulation(class Simulation* current_simulation) { }
91        virtual mat4 GetTransform() { return mat4(1.0f); }
92
93#endif // PHYSIC IMPLEMENTATION
94
95public:
96        //Sets the collision Group & Mask.
97        //Mask can change at runtime, not group !
98        virtual bool SetCollisionChannel(int NewGroup, int NewMask)
99        {
100                if (CanChangeCollisionChannel())
101                {
102                        m_collision_group = (1<<NewGroup);
103                        m_collision_mask = NewMask;
104                        return true;
105                }
106                return false;
107        }
108        int GetCollisionGroup() { return m_collision_group; }
109        int GetCollisionMask()  { return m_collision_mask; }
110
111protected:
112        lol::mat4                                                                       m_local_to_world;
113        float                                                                           m_mass;
114        int                                                                                     m_collision_group;
115        int                                                                                     m_collision_mask;
116};
117
118class EasyCharacterController : public EasyPhysic
119{
120
121#ifdef HAVE_PHYS_USE_BULLET
122
123public:
124        EasyCharacterController();
125        ~EasyCharacterController();
126
127        virtual void SetTransform(const lol::vec3& base_location, const lol::quat& base_rotation=lol::quat(lol::mat4(1.0f)));
128        virtual void SetMass(float mass);
129        virtual void InitBodyToRigid(bool ZeroMassIsKinematic=false);
130        virtual void InitBodyToGhost();
131        virtual void AddToSimulation(class Simulation* current_simulation);
132        virtual void RemoveFromSimulation(class Simulation* current_simulation);
133        virtual mat4 GetTransform();
134
135protected:
136
137        btPairCachingGhostObject*               m_pair_caching_object;
138
139#else  // NO PHYSIC IMPLEMENTATION
140
141#endif // PHYSIC IMPLEMENTATION
142
143};
144
145class EasyConstraint
146{
147#ifdef HAVE_PHYS_USE_BULLET
148
149public:
150        EasyConstraint() :
151                m_typed_constraint(NULL),
152                m_p2p_constraint(NULL),
153                m_hinge_constraint(NULL),
154                m_slider_constraint(NULL),
155                m_cone_twist_constraint(NULL),
156                m_6dof_constraint(NULL),
157                m_a_physobj(NULL),
158                m_b_physobj(NULL),
159                m_a_transform(lol::mat4(1.f)),
160                m_b_transform(lol::mat4(1.f)),
161                m_using_ref_a(false),
162                m_disable_a2b_collision(false)
163
164        {
165        }
166        ~EasyConstraint()
167        {
168                delete m_typed_constraint;
169                m_p2p_constraint = NULL;
170                m_hinge_constraint = NULL;
171                m_slider_constraint = NULL;
172                m_cone_twist_constraint = NULL;
173                m_6dof_constraint = NULL;
174        }
175
176        void AddToSimulation(class Simulation* current_simulation);
177        void RemoveFromSimulation(class Simulation* current_simulation);
178
179private:
180
181        //check if Init can be done
182        bool CanProceedWithInit()
183        {
184                if (!m_a_physobj || !m_b_physobj)
185                        return false;
186
187                if (!m_a_physobj->m_rigid_body || !m_b_physobj->m_rigid_body)
188                        return false;
189
190                return true;
191        }
192
193        //-------------------------------------------------------------------------
194        //Init constraint functions
195        //--
196        void CustomInitConstraintToPoint2Point()
197        {
198                m_p2p_constraint = new btPoint2PointConstraint(*m_a_physobj->m_rigid_body, *m_b_physobj->m_rigid_body,
199                                                                                                                LOL2BT_VEC3(m_a_transform.v3.xyz * LOL2BT_UNIT), LOL2BT_VEC3(m_b_transform.v3.xyz * LOL2BT_UNIT));
200                m_typed_constraint = m_p2p_constraint;
201        }
202
203        void CustomInitConstraintToHinge()
204        {
205                m_hinge_constraint = new btHingeConstraint(*m_a_physobj->m_rigid_body, *m_b_physobj->m_rigid_body,
206                                                                                                                btTransform(LOL2BT_QUAT(quat(m_a_transform)), LOL2BT_VEC3(m_a_transform.v3.xyz * LOL2BT_UNIT)),
207                                                                                                                btTransform(LOL2BT_QUAT(quat(m_b_transform)), LOL2BT_VEC3(m_b_transform.v3.xyz * LOL2BT_UNIT)),
208                                                                                                                m_using_ref_a);
209                m_typed_constraint = m_hinge_constraint;
210        }
211
212        void CustomInitConstraintToSlider()
213        {
214                m_slider_constraint = new btSliderConstraint(*m_a_physobj->m_rigid_body, *m_b_physobj->m_rigid_body,
215                                                                                                                btTransform(LOL2BT_QUAT(quat(m_a_transform)), LOL2BT_VEC3(m_a_transform.v3.xyz * LOL2BT_UNIT)),
216                                                                                                                btTransform(LOL2BT_QUAT(quat(m_b_transform)), LOL2BT_VEC3(m_b_transform.v3.xyz * LOL2BT_UNIT)),
217                                                                                                                m_using_ref_a);
218                m_typed_constraint = m_slider_constraint;
219        }
220
221        void CustomInitConstraintToConeTwist()
222        {
223                m_cone_twist_constraint = new btConeTwistConstraint(*m_a_physobj->m_rigid_body, *m_b_physobj->m_rigid_body,
224                                                                                                                btTransform(LOL2BT_QUAT(quat(m_a_transform)), LOL2BT_VEC3(m_a_transform.v3.xyz * LOL2BT_UNIT)),
225                                                                                                                btTransform(LOL2BT_QUAT(quat(m_b_transform)), LOL2BT_VEC3(m_b_transform.v3.xyz * LOL2BT_UNIT)));
226                m_typed_constraint = m_cone_twist_constraint;
227        }
228
229        void CustomInitConstraintTo6Dof()
230        {
231                m_6dof_constraint = new btGeneric6DofConstraint(*m_a_physobj->m_rigid_body, *m_b_physobj->m_rigid_body,
232                                                                                                                btTransform(LOL2BT_QUAT(quat(m_a_transform)), LOL2BT_VEC3(m_a_transform.v3.xyz * LOL2BT_UNIT)),
233                                                                                                                btTransform(LOL2BT_QUAT(quat(m_b_transform)), LOL2BT_VEC3(m_b_transform.v3.xyz * LOL2BT_UNIT)),
234                                                                                                                m_using_ref_a);
235                m_typed_constraint = m_6dof_constraint;
236        }
237
238        btTypedConstraint*                      m_typed_constraint;
239        btPoint2PointConstraint*        m_p2p_constraint;
240        btHingeConstraint*                      m_hinge_constraint;
241        btSliderConstraint*                     m_slider_constraint;
242        btConeTwistConstraint*          m_cone_twist_constraint;
243        btGeneric6DofConstraint*        m_6dof_constraint;
244
245#else  // NO PHYSIC IMPLEMENTATION
246
247public:
248        EasyConstraint() :
249                m_a_physobj(NULL),
250                m_b_physobj(NULL),
251                m_a_transform(lol::mat4(1.f)),
252                m_b_transform(lol::mat4(1.f)),
253                m_using_ref_a(false),
254                m_disable_a2b_collision(false)
255        {
256        }
257
258private:
259
260        void AddToSimulation(class Simulation* current_simulation) { }
261        void RemoveFromSimulation(class Simulation* current_simulation) { }
262
263        //check if Init can be done
264        bool CanProceedWithInit() { return false; }
265        void CustomInitConstraintToPoint2Point() { }
266        void CustomInitConstraintToHinge() { }
267        void CustomInitConstraintToSlider() { }
268        void CustomInitConstraintToConeTwist() { }
269        void CustomInitConstraintTo6Dof() { }
270
271#endif // PHYSIC IMPLEMENTATION
272
273public:
274        void InitConstraintToPoint2Point()      { if (CanProceedWithInit()) CustomInitConstraintToPoint2Point(); }
275        void InitConstraintToHinge()            { if (CanProceedWithInit()) CustomInitConstraintToHinge(); }
276        void InitConstraintToSlider()           { if (CanProceedWithInit()) CustomInitConstraintToSlider(); }
277        void InitConstraintToConeTwist()        { if (CanProceedWithInit()) CustomInitConstraintToConeTwist(); }
278        void InitConstraintTo6Dof()                     { if (CanProceedWithInit()) CustomInitConstraintTo6Dof(); }
279
280        //Set given physic object to the proper slot.
281        void SetPhysObjA(EasyPhysic* NewPhysObj, lol::mat4 NewTransform) { SetPhysObj(false, NewPhysObj, NewTransform); }
282        void SetPhysObjB(EasyPhysic* NewPhysObj, lol::mat4 NewTransform) { SetPhysObj(true, NewPhysObj, NewTransform); }
283        void SetPhysObj(bool SetToB, EasyPhysic* NewPhysObj, lol::mat4 NewTransform)
284        {
285                if (SetToB)
286                {
287                        m_b_physobj = NewPhysObj;
288                        m_b_transform = NewTransform;
289                }
290                else
291                {
292                        m_a_physobj = NewPhysObj;
293                        m_a_transform = NewTransform;
294                }
295        }
296
297        //Set whether or not the physic engine should use the A object as the reference (most constraint transform are local).
298        void SetRefAsA(bool NewUseRefA)
299        {
300                m_using_ref_a = NewUseRefA;
301        }
302
303        //Set whether or not to disable the collision between the bodies
304        void DisableCollisionBetweenObjs(bool DisableCollision)
305        {
306                m_disable_a2b_collision = DisableCollision;
307        }
308
309private:
310        EasyPhysic*                                     m_a_physobj;
311        EasyPhysic*                                     m_b_physobj;
312        lol::mat4                                       m_a_transform;
313        lol::mat4                                       m_b_transform;
314        bool                                            m_using_ref_a;
315        bool                                            m_disable_a2b_collision;
316
317};
318
319} /* namespace phys */
320
321} /* namespace lol */
322
323#endif /* __EASYPHYSICS_EASYPHYSICS_H__ */
324
Note: See TracBrowser for help on using the repository browser.