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

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

Small .h & .cpp refactor

File size: 5.1 KB
Line 
1//
2// LolPhysics
3//
4// Copyright: (c) 2009-2012 Benjamin Huet <huet.benjamin@gmail.com>
5//            (c) 2012 Sam Hocevar <sam@hocevar.net>
6//
7
8#if !defined __LOLPHYSICS_H__
9#define __LOLPHYSICS_H__
10
11#ifdef HAVE_PHYS_USE_BULLET
12#include <bullet/btBulletDynamicsCommon.h>
13#include <bullet/btBulletCollisionCommon.h>
14#include <bullet/BulletCollision/CollisionDispatch/btGhostObject.h>
15#include "LolBtPhysicsIntegration.h"
16#endif
17
18namespace lol
19{
20
21namespace phys
22{
23
24class Simulation : public Entity
25{
26public:
27        Simulation() :
28                m_broadphase(0),
29                m_collision_configuration(0),
30                m_dispatcher(0),
31                m_solver(0),
32                m_dynamics_world(0),
33                m_timestep(1.f/60.f)
34        {
35        }
36        ~Simulation()
37        {
38                Exit();
39        }
40
41        char const *GetName() { return "<Simulation>"; }
42
43#ifdef HAVE_PHYS_USE_BULLET
44public:
45        void Init()
46        {
47                // Build the broadphase
48                if (1)
49                {
50                        m_Sweep_broadphase = new btAxisSweep3(LOL2BT_VEC3(m_world_min), LOL2BT_VEC3(m_world_max));
51                        m_Sweep_broadphase->getOverlappingPairCache()->setInternalGhostPairCallback(new btGhostPairCallback());
52                        m_broadphase = m_Sweep_broadphase;
53                }
54                else
55                        m_broadphase = new btDbvtBroadphase();
56 
57                // Set up the collision configuration and dispatcher
58                m_collision_configuration = new btDefaultCollisionConfiguration();
59                m_dispatcher = new btCollisionDispatcher(m_collision_configuration);
60 
61                // The actual physics solver
62                m_solver = new btSequentialImpulseConstraintSolver;
63 
64                // The world.
65                m_dynamics_world = new btDiscreteDynamicsWorld(m_dispatcher, m_broadphase, m_solver, m_collision_configuration);
66        }
67
68        virtual void TickGame(float seconds)
69        {
70                Entity::TickGame(seconds);
71
72                //step the simulation
73                if (m_dynamics_world)
74                {
75                        //the "+1" is to have at least one Timestep and to ensure float to int .5f conversion.
76                        int steps = (int)(seconds / m_timestep) + 1;
77                        m_dynamics_world->stepSimulation(seconds, steps, m_timestep);
78                }
79        }
80
81        void Exit()
82        {
83                delete m_dynamics_world;
84                delete m_solver;
85                delete m_dispatcher;
86                delete m_collision_configuration;
87                delete m_broadphase;
88        }
89
90        btDiscreteDynamicsWorld* GetWorld()
91        {
92                return m_dynamics_world;
93        }
94
95private:
96        void CustomSetContinuousDetection(bool ShouldUseCCD)
97        {
98                if (m_dynamics_world)
99                        m_dynamics_world->getDispatchInfo().m_useContinuous = ShouldUseCCD;
100        }
101
102        void CustomSetGravity(vec3 &NewGravity)
103        {
104                if (m_dynamics_world)
105                        m_dynamics_world->setGravity(LOL2BT_VEC3(NewGravity * LOL2BT_UNIT));
106        }
107
108        void CustomSetWorldLimit(vec3 const &NewWorldMin, vec3 const &NewWorldMax)
109        {
110        }
111
112        void CustomSetTimestep(float NewTimestep) { }
113
114        //broadphase
115        btBroadphaseInterface*                                  m_broadphase;
116        btAxisSweep3*                                                   m_Sweep_broadphase;
117        // Set up the collision configuration and dispatc
118        btDefaultCollisionConfiguration*                m_collision_configuration;
119        btCollisionDispatcher*                                  m_dispatcher;
120        // The actual physics solver
121        btSequentialImpulseConstraintSolver*    m_solver;
122        // The world.
123        btDiscreteDynamicsWorld*                                m_dynamics_world;
124
125#else  // NO PHYSIC IMPLEMENTATION
126
127public:
128        void Init() { }
129        void TickGame(float seconds) { }
130        void Exit() { }
131private:
132        void CustomSetContinuousDetection(bool ShouldUseCCD) { }
133        void CustomSetGravity(vec3 &NewGravity) { }
134        void CustomSetWorldLimit(vec3 &NewWorldMin, vec3 &NewWorldMax) { }
135        void CustomSetTimestep(float NewTimestep) { }
136
137#endif // PHYSIC IMPLEMENTATION
138
139public:
140        //Main logic :
141        //The Set*() functions do the all-lib-independent data storage.
142        //And then it calls the CustomSet*() which are the specialized versions.
143
144        //Sets the continuous collision detection flag.
145        void SetContinuousDetection(bool ShouldUseCCD)
146        {
147                m_using_CCD = ShouldUseCCD;
148                CustomSetContinuousDetection(ShouldUseCCD);
149        }
150
151        //Sets the simulation gravity.
152        void SetGravity(vec3 &NewGravity)
153        {
154                m_gravity = NewGravity;
155                CustomSetGravity(NewGravity);
156        }
157
158        //Sets the simulation gravity.
159        void SetWorldLimit(vec3 const &NewWorldMin, vec3 const &NewWorldMax)
160        {
161                m_world_min = NewWorldMin;
162                m_world_max = NewWorldMax;
163                CustomSetWorldLimit(NewWorldMin, NewWorldMax);
164        }
165
166        //Sets the simulation fixed timestep.
167        void SetTimestep(float NewTimestep)
168        {
169                if (NewTimestep > .0f)
170                {
171                        m_timestep = NewTimestep;
172                        CustomSetTimestep(NewTimestep);
173                }
174        }
175
176private:
177        friend class EasyPhysic;
178        friend class EasyConstraint;
179
180        //Adds the given EasyPhysic to the correct list.
181        void AddToDynamic(EasyPhysic* NewEPDynamic)     { m_dynamic_list << NewEPDynamic; }
182        void AddToStatic(EasyPhysic* NewEPStatic)       { m_static_list << NewEPStatic; }
183        void AddToGhost(EasyPhysic* NewEPGhost)         { m_ghost_list << NewEPGhost; }
184        void AddToConstraint(EasyConstraint* NewEC)     { m_constraint_list     << NewEC; }
185
186        //Easy Physics body List
187        Array<EasyPhysic*>                                              m_dynamic_list;
188        Array<EasyPhysic*>                                              m_static_list;
189        Array<EasyPhysic*>                                              m_ghost_list;
190        Array<EasyConstraint*>                                  m_constraint_list;
191
192        //Easy Physics data storage
193        float                                                                   m_timestep;
194        bool                                                                    m_using_CCD;
195        vec3                                                                    m_gravity;
196        vec3                                                                    m_world_min;
197        vec3                                                                    m_world_max;
198};
199
200} /* namespace phys */
201
202} /* namespace lol */
203
204#endif // __LOLPHYSICS_H__
205
Note: See TracBrowser for help on using the repository browser.