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

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

BUILD fuck

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