source: trunk/test/BtPhysTest.cpp @ 1581

Last change on this file since 1581 was 1581, checked in by sam, 10 years ago

test: minor tweaks to the Bullet demo.

File size: 9.5 KB
Line 
1//
2// BtPhysTest
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 HAVE_CONFIG_H
9#   include "config.h"
10#endif
11
12#if defined _WIN32
13#   include <direct.h>
14#endif
15
16#if defined _XBOX
17#   define _USE_MATH_DEFINES /* for M_PI */
18#   include <xtl.h>
19#   undef near /* Fuck Microsoft */
20#   undef far /* Fuck Microsoft again */
21#elif defined _WIN32
22#   define _USE_MATH_DEFINES /* for M_PI */
23#   define WIN32_LEAN_AND_MEAN
24#   include <windows.h>
25#   undef near /* Fuck Microsoft */
26#   undef far /* Fuck Microsoft again */
27#else
28#   include <cmath>
29#endif
30
31#if USE_SDL && defined __APPLE__
32#   include <SDL_main.h>
33#endif
34
35#include <bullet/btBulletDynamicsCommon.h>
36#include <bullet/btBulletCollisionCommon.h>
37
38#include "core.h"
39#include "loldebug.h"
40
41using namespace lol;
42
43#include "BtPhysTest.h"
44
45#define CUBE_HALF_EXTENTS .5f
46#define EXTRA_HEIGHT 1.f
47
48int gNumObjects = 64;
49
50BtPhysTest::BtPhysTest(bool editor)
51{
52    /* Create a camera that matches the settings of XNA BtPhysTest */
53    m_camera = new Camera(vec3(0.f, 600.f, 0.f),
54                          vec3(0.f, 0.f, 0.f),
55                          vec3(0, 1, 0));
56    m_camera->SetRotation(quat::fromeuler_xyz(0.f, 0.f, 0.f));
57    m_camera->SetPerspective(90.f, 1280.f, 960.f, .1f, 1000.f);
58        //m_camera->SetOrtho(1280.f / 6, 960.f / 6, -1000.f, 1000.f);
59    Ticker::Ref(m_camera);
60
61    m_ready = false;
62
63        //init Physics
64        {
65                m_bt_ccd_mode = USE_CCD;
66
67                //collision configuration contains default setup for memory, collision setup
68                m_bt_collision_config = new btDefaultCollisionConfiguration();
69
70                //use the default collision dispatcher. For parallel processing you can use a diffent dispatcher (see Extras/BulletMultiThreaded)
71                m_bt_dispatcher = new btCollisionDispatcher(m_bt_collision_config);
72                m_bt_dispatcher->registerCollisionCreateFunc(BOX_SHAPE_PROXYTYPE,BOX_SHAPE_PROXYTYPE,m_bt_collision_config->getCollisionAlgorithmCreateFunc(CONVEX_SHAPE_PROXYTYPE,CONVEX_SHAPE_PROXYTYPE));
73
74                m_bt_broadphase = new btDbvtBroadphase();
75
76                ///the default constraint solver. For parallel processing you can use a different solver (see Extras/BulletMultiThreaded)
77                m_bt_solver = new btSequentialImpulseConstraintSolver;
78
79                m_bt_world = new btDiscreteDynamicsWorld(m_bt_dispatcher, m_bt_broadphase, m_bt_solver, m_bt_collision_config);
80                //m_bt_world->setDebugDrawer(&sDebugDrawer);
81                m_bt_world->getSolverInfo().m_splitImpulse = true;
82                m_bt_world->getSolverInfo().m_numIterations = 20;
83
84                m_bt_world->getDispatchInfo().m_useContinuous = (m_bt_ccd_mode == USE_CCD);
85                m_bt_world->setGravity(btVector3(0,-10,0));
86
87                ///create a few basic rigid bodies
88                btBoxShape* box = new btBoxShape(btVector3(btScalar(110.),btScalar(1.),btScalar(110.)));
89                btCollisionShape* groundShape = box;
90                m_bt_collision_shapes << groundShape;
91        m_ground_mesh.Compile("[sc#ddd afcb110 1 110 -1]");
92
93                //m_bt_collision_shapes << new btCylinderShape(btVector3(.5f,.5f,.5f));
94
95                btTransform groundTransform;
96                groundTransform.setIdentity();
97
98                //We can also use DemoApplication::localCreateRigidBody, but for clarity it is provided here:
99                {
100                        btScalar mass(0.);
101
102                        //rigidbody is dynamic if and only if mass is non zero, otherwise static
103                        bool isDynamic = (mass != 0.f);
104
105                        btVector3 localInertia(0,0,0);
106                        if (isDynamic)
107                                groundShape->calculateLocalInertia(mass,localInertia);
108
109                        //using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
110                        btDefaultMotionState* myMotionState = new btDefaultMotionState(groundTransform);
111                        btRigidBody::btRigidBodyConstructionInfo rbInfo(mass,myMotionState,groundShape,localInertia);
112                        btRigidBody* body = new btRigidBody(rbInfo);
113
114                        //add the body to the dynamics world
115                        m_bt_world->addRigidBody(body);
116                }
117
118                //Adding Shapes
119                {
120                        //create a few dynamic rigidbodies
121                        // Re-using the same collision is better for memory usage and performance
122                        btCollisionShape* colShape = new btBoxShape(btVector3(1,1,1));
123                        m_rigid_mesh[0].Compile("[sc#add afcb2 2 2 -.1]");
124                        m_rigid_mesh[1].Compile("[sc#dad afcb2 2 2 -.1]");
125                        m_rigid_mesh[2].Compile("[sc#dda afcb2 2 2 -.1]");
126                        m_rigid_mesh[3].Compile("[sc#daa afcb2 2 2 -.1]");
127                        m_rigid_mesh[4].Compile("[sc#ada afcb2 2 2 -.1]");
128                        m_rigid_mesh[5].Compile("[sc#aad afcb2 2 2 -.1]");
129
130                        m_bt_collision_shapes << colShape;
131                        m_bt_dynamic_shapes << colShape;
132
133                        /// Create Dynamic Objects
134                        btTransform startTransform;
135                        startTransform.setIdentity();
136                        btScalar mass(1.f);
137
138                        //rigidbody is dynamic if and only if mass is non zero, otherwise static
139                        bool isDynamic = (mass != 0.f);
140
141                        btVector3 localInertia(0,0,0);
142                        if (isDynamic)
143                                colShape->calculateLocalInertia(mass,localInertia);
144
145                        int i;
146                        for (i=0;i<gNumObjects;i++)
147                        {
148                                btCollisionShape* shape = colShape;
149                                btTransform trans;
150                                trans.setIdentity();
151
152                                //stack them
153                                int colsize = 10;
154                                int row = (i*CUBE_HALF_EXTENTS*2)/(colsize*2*CUBE_HALF_EXTENTS);
155                                int row2 = row;
156                                int col = (i)%(colsize)-colsize/2;
157
158                                if (col>3)
159                                {
160                                        col=11;
161                                        row2 |=1;
162                                }
163
164                                btVector3 pos(((row+col+row2) % 4)*CUBE_HALF_EXTENTS,
165                                              20.0f + row*8*CUBE_HALF_EXTENTS+CUBE_HALF_EXTENTS+EXTRA_HEIGHT,
166                                              col*8*CUBE_HALF_EXTENTS + 2 * (row2%2)*CUBE_HALF_EXTENTS);
167
168                                trans.setOrigin(pos);
169       
170                                float mass = 1.f;
171
172
173                                btAssert((!shape || shape->getShapeType() != INVALID_SHAPE_PROXYTYPE));
174
175                                //rigidbody is dynamic if and only if mass is non zero, otherwise static
176                                bool isDynamic = (mass != 0.f);
177
178                                btVector3 localInertia(0,0,0);
179                                if (isDynamic)
180                                        shape->calculateLocalInertia(mass,localInertia);
181
182                                //using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
183
184                                btDefaultMotionState* myMotionState = new btDefaultMotionState(trans);
185
186                                btRigidBody::btRigidBodyConstructionInfo cInfo(mass,myMotionState,shape,localInertia);
187
188                                btRigidBody* body = new btRigidBody(cInfo);
189                                body->setContactProcessingThreshold(BT_LARGE_FLOAT);
190
191                                m_bt_world->addRigidBody(body);
192
193                                ///when using m_ccdMode
194                                if (m_bt_ccd_mode == USE_CCD)
195                                {
196                                        body->setCcdMotionThreshold(CUBE_HALF_EXTENTS);
197                                        body->setCcdSweptSphereRadius(0.9*CUBE_HALF_EXTENTS);
198                                }
199                        }
200                }
201        }
202}
203
204void BtPhysTest::TickGame(float seconds)
205{
206    WorldEntity::TickGame(seconds);
207
208    if (Input::GetButtonState(27 /*SDLK_ESCAPE*/))
209        Ticker::Shutdown();
210
211        ///step the simulation
212        if (m_bt_world)
213        {
214                int steps = (int)(seconds / 0.005f);
215                for (int i = 0; i < steps; i++)
216                        m_bt_world->stepSimulation(seconds / steps);
217                //optional but useful: debug drawing
218                //m_bt_world->debugDrawWorld();
219        }
220}
221
222void BtPhysTest::TickDraw(float seconds)
223{
224    WorldEntity::TickDraw(seconds);
225
226    if (!m_ready)
227    {
228                m_ground_mesh.MeshConvert();
229                m_rigid_mesh[0].MeshConvert();
230                m_rigid_mesh[1].MeshConvert();
231                m_rigid_mesh[2].MeshConvert();
232                m_rigid_mesh[3].MeshConvert();
233                m_rigid_mesh[4].MeshConvert();
234                m_rigid_mesh[5].MeshConvert();
235        /* FIXME: this object never cleans up */
236        m_ready = true;
237    }
238
239    Video::SetClearColor(vec4(0.0f, 0.0f, 0.12f, 1.0f));
240
241        vec3 BarycenterLocation = vec3(.0f);
242        float BarycenterFactor = 0.0f;
243        for(int i=0;i<gNumObjects;i++)
244        {
245                mat4 m(1.0f);
246                btMatrix3x3     rot; rot.setIdentity();
247                btCollisionObject*      colObj = m_bt_world->getCollisionObjectArray()[i];
248                btRigidBody*            body = btRigidBody::upcast(colObj);
249                if(body && body->getMotionState())
250                {
251                        btDefaultMotionState* myMotionState = (btDefaultMotionState*)body->getMotionState();
252                        myMotionState->m_graphicsWorldTrans.getOpenGLMatrix(&m[0][0]);
253                        rot = myMotionState->m_graphicsWorldTrans.getBasis();
254                }
255                else
256                {
257                        colObj->getWorldTransform().getOpenGLMatrix(&m[0][0]);
258                        rot = colObj->getWorldTransform().getBasis();
259                }
260                if (i > 0)
261                {
262                        BarycenterLocation += m.v3.xyz;
263                        BarycenterFactor += 1.0f;
264                }
265                if (i == 0)
266                        m_ground_mesh.Render(m);
267                else
268                        m_rigid_mesh[i % 6].Render(m);
269        }
270        if (BarycenterFactor > .0f)
271        {
272                BarycenterLocation /= BarycenterFactor;
273
274                m_camera->SetTarget(BarycenterLocation);
275                m_camera->SetPosition(BarycenterLocation + vec3(-20.0f, 8.0f, .0f));
276        }
277}
278
279BtPhysTest::~BtPhysTest()
280{
281        Ticker::Unref(m_camera);
282
283        //Exit Physics
284        {
285                //cleanup in the reverse order of creation/initialization
286                //remove the rigidbodies from the dynamics world and delete them
287                for (int i = m_bt_world->getNumCollisionObjects() - 1; i >= 0 ;i--)
288                {
289                        btCollisionObject* obj = m_bt_world->getCollisionObjectArray()[i];
290                        btRigidBody* body = btRigidBody::upcast(obj);
291                        if (body && body->getMotionState())
292                                delete body->getMotionState();
293
294                        m_bt_world->removeCollisionObject(obj);
295                        delete obj;
296                }
297
298                //delete collision shapes
299                for (int j = 0; j < m_bt_collision_shapes.Count(); j++)
300                {
301                        btCollisionShape* shape = m_bt_collision_shapes[j];
302                        delete shape;
303                }
304                m_bt_collision_shapes.Empty();
305
306                delete m_bt_world;
307                delete m_bt_solver;
308                delete m_bt_broadphase;
309                delete m_bt_dispatcher;
310                delete m_bt_collision_config;
311        }
312}
313
314int main(int argc, char **argv)
315{
316    Application app("BtPhysTest", ivec2(1280, 720), 60.0f);
317
318#if defined _MSC_VER && !defined _XBOX
319    _chdir("..");
320#elif defined _WIN32 && !defined _XBOX
321    _chdir("../..");
322#endif
323
324    new BtPhysTest(argc > 1);
325    app.ShowPointer(false);
326
327    app.Run();
328
329    return EXIT_SUCCESS;
330}
331
Note: See TracBrowser for help on using the repository browser.