source: trunk/test/Physics/LolPhysics.h @ 1631

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

Added Collision group & mask support.
+ weird racist test : the primitives only collide with their same type.

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