source: trunk/test/BtPhysTest.cpp @ 1607

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

Added walls and better context to the physics.

File size: 12.3 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#ifndef HAVE_PHYS_USE_BULLET
44#define HAVE_PHYS_USE_BULLET
45#endif /* HAVE_PHYS_USE_BULLET */
46
47#include "Physics/LolPhysics.h"
48#include "Physics/EasyPhysics.h"
49#include "PhysicObject.h"
50#include "BtPhysTest.h"
51
52using namespace lol::phys;
53
54#define CUBE_HALF_EXTENTS .5f
55#define EXTRA_HEIGHT 1.f
56
57int gNumObjects = 64;
58
59BtPhysTest::BtPhysTest(bool editor)
60{
61    /* Create a camera that matches the settings of XNA BtPhysTest */
62    m_camera = new Camera(vec3(0.f, 600.f, 0.f),
63                          vec3(0.f, 0.f, 0.f),
64                          vec3(0, 1, 0));
65    m_camera->SetRotation(quat::fromeuler_xyz(0.f, 0.f, 0.f));
66    m_camera->SetPerspective(90.f, 1280.f, 960.f, .1f, 1000.f);
67        //m_camera->SetOrtho(1280.f / 6, 960.f / 6, -1000.f, 1000.f);
68    Ticker::Ref(m_camera);
69
70    m_ready = false;
71
72        m_simulation = new Simulation();
73        m_simulation->InitContext();
74        vec3 NewGravity = vec3(.0f, -10.0f, .0f);
75        m_simulation->SetGravity(NewGravity);
76
77        float offset = 30.f;
78        vec3 pos_offset = vec3(.0f, 30.f, .0f);
79        for (int i=0; i < 6; i++)
80        {
81                int idx = i/2;
82                vec3 NewPosition = pos_offset;
83                NewPosition[idx] += offset;
84                offset *= -1.f;
85
86                quat NewRotation = quat(mat4(1.f));
87                PhysicsObject* NewPhyobj = new PhysicsObject(m_simulation, NewPosition, NewRotation);
88
89                if (idx != 1)
90                {
91                        vec3 axis = vec3(.0f);
92                        axis[idx] = 1;
93                        NewRotation = quat::rotate(90.f, axis);
94                }
95
96                NewPhyobj->SetTransform(NewPosition, NewRotation);
97                Ticker::Ref(NewPhyobj);
98                m_ground_list << NewPhyobj;
99        }
100
101        for (int x=0; x < 5; x++)
102        {
103                for (int y=0; y < 5; y++)
104                {
105                        for (int z=0; z < 4; z++)
106                        {
107                                PhysicsObject* new_physobj = new PhysicsObject(m_simulation, 10.f,
108                                        vec3(-20.f, 40.f, -20.f) +
109                                        vec3(4.f * (float)x, 4.f * (float)y, 4.f * (float)z));
110                                m_physobj_list << new_physobj;
111                                Ticker::Ref(new_physobj);
112                        }
113                }
114        }
115
116#if 0
117        //init Physics
118        {
119                m_bt_ccd_mode = USE_CCD;
120
121                //collision configuration contains default setup for memory, collision setup
122                m_bt_collision_config = new btDefaultCollisionConfiguration();
123
124                //use the default collision dispatcher. For parallel processing you can use a diffent dispatcher (see Extras/BulletMultiThreaded)
125                m_bt_dispatcher = new btCollisionDispatcher(m_bt_collision_config);
126                m_bt_dispatcher->registerCollisionCreateFunc(BOX_SHAPE_PROXYTYPE,
127                                                                                                        BOX_SHAPE_PROXYTYPE,
128                                                                                                        m_bt_collision_config->getCollisionAlgorithmCreateFunc(CONVEX_SHAPE_PROXYTYPE,
129                                                                                                                                                                                                                        CONVEX_SHAPE_PROXYTYPE));
130
131                m_bt_broadphase = new btDbvtBroadphase();
132
133                ///the default constraint solver. For parallel processing you can use a different solver (see Extras/BulletMultiThreaded)
134                m_bt_solver = new btSequentialImpulseConstraintSolver;
135
136                m_bt_world = new btDiscreteDynamicsWorld(m_bt_dispatcher, m_bt_broadphase, m_bt_solver, m_bt_collision_config);
137                //m_bt_world->setDebugDrawer(&sDebugDrawer);
138                m_bt_world->getSolverInfo().m_splitImpulse = true;
139                m_bt_world->getSolverInfo().m_numIterations = 20;
140
141                m_bt_world->getDispatchInfo().m_useContinuous = (m_bt_ccd_mode == USE_CCD);
142                m_bt_world->setGravity(btVector3(0,-10,0));
143
144                ///create a few basic rigid bodies
145                btBoxShape* box = new btBoxShape(btVector3(btScalar(110.),btScalar(1.),btScalar(110.)));
146                btCollisionShape* groundShape = box;
147                m_bt_collision_shapes << groundShape;
148        m_ground_mesh.Compile("[sc#ddd afcb220 2 220 -1]");
149
150                //m_bt_collision_shapes << new btCylinderShape(btVector3(.5f,.5f,.5f));
151
152                btTransform groundTransform;
153                groundTransform.setIdentity();
154
155                //We can also use DemoApplication::localCreateRigidBody, but for clarity it is provided here:
156                {
157                        btScalar mass(0.);
158
159                        //rigidbody is dynamic if and only if mass is non zero, otherwise static
160                        bool isDynamic = (mass != 0.f);
161
162                        btVector3 localInertia(0,0,0);
163                        if (isDynamic)
164                                groundShape->calculateLocalInertia(mass,localInertia);
165
166                        //using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
167                        btDefaultMotionState* myMotionState = new btDefaultMotionState(groundTransform);
168                        btRigidBody::btRigidBodyConstructionInfo rbInfo(mass,myMotionState,groundShape,localInertia);
169                        btRigidBody* body = new btRigidBody(rbInfo);
170
171                        //add the body to the dynamics world
172                        m_bt_world->addRigidBody(body);
173                }
174
175                //Adding Shapes
176                {
177                        //create a few dynamic rigidbodies
178                        // Re-using the same collision is better for memory usage and performance
179                        btCollisionShape* colShape = new btBoxShape(btVector3(1,1,1));
180                        m_rigid_mesh[0].Compile("[sc#add afcb2 2 2 -.1]");
181                        m_rigid_mesh[1].Compile("[sc#dad afcb2 2 2 -.1]");
182                        m_rigid_mesh[2].Compile("[sc#dda afcb2 2 2 -.1]");
183                        m_rigid_mesh[3].Compile("[sc#daa afcb2 2 2 -.1]");
184                        m_rigid_mesh[4].Compile("[sc#ada afcb2 2 2 -.1]");
185                        m_rigid_mesh[5].Compile("[sc#aad afcb2 2 2 -.1]");
186
187                        m_bt_collision_shapes << colShape;
188                        m_bt_dynamic_shapes << colShape;
189
190                        /// Create Dynamic Objects
191                        btTransform startTransform;
192                        startTransform.setIdentity();
193                        btScalar mass(1.f);
194
195                        //rigidbody is dynamic if and only if mass is non zero, otherwise static
196                        bool isDynamic = (mass != 0.f);
197
198                        btVector3 localInertia(0,0,0);
199                        if (isDynamic)
200                                colShape->calculateLocalInertia(mass,localInertia);
201
202                        int i;
203                        for (i=0;i<gNumObjects;i++)
204                        {
205                                btCollisionShape* shape = colShape;
206                                btTransform trans;
207                                trans.setIdentity();
208
209                                //stack them
210                                int colsize = 10;
211                                int row = int(((float)i*CUBE_HALF_EXTENTS*2.0f)/((float)colsize*2.0f*CUBE_HALF_EXTENTS));
212                                int row2 = row;
213                                int col = (i)%(colsize)-colsize/2;
214
215                                if (col>3)
216                                {
217                                        col=11;
218                                        row2 |=1;
219                                }
220
221                                btVector3 pos(((row+col+row2) % 4)*CUBE_HALF_EXTENTS,
222                                              20.0f + row*8*CUBE_HALF_EXTENTS+CUBE_HALF_EXTENTS+EXTRA_HEIGHT,
223                                              col*8*CUBE_HALF_EXTENTS + 2 * (row2%2)*CUBE_HALF_EXTENTS);
224
225                                trans.setOrigin(pos);
226       
227                                float mass = 1.f;
228
229
230                                btAssert((!shape || shape->getShapeType() != INVALID_SHAPE_PROXYTYPE));
231
232                                //rigidbody is dynamic if and only if mass is non zero, otherwise static
233                                bool isDynamic = (mass != 0.f);
234
235                                btVector3 localInertia(0,0,0);
236                                if (isDynamic)
237                                        shape->calculateLocalInertia(mass,localInertia);
238
239                                //using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
240
241                                btDefaultMotionState* myMotionState = new btDefaultMotionState(trans);
242
243                                btRigidBody::btRigidBodyConstructionInfo cInfo(mass,myMotionState,shape,localInertia);
244
245                                btRigidBody* body = new btRigidBody(cInfo);
246                                body->setContactProcessingThreshold(BT_LARGE_FLOAT);
247
248                                m_bt_world->addRigidBody(body);
249
250                                ///when using m_ccdMode
251                                if (m_bt_ccd_mode == USE_CCD)
252                                {
253                                        body->setCcdMotionThreshold(CUBE_HALF_EXTENTS);
254                                        body->setCcdSweptSphereRadius(0.9*CUBE_HALF_EXTENTS);
255                                }
256                        }
257                }
258        }
259#endif
260}
261
262void BtPhysTest::TickGame(float seconds)
263{
264    WorldEntity::TickGame(seconds);
265
266    if (Input::GetButtonState(27 /*SDLK_ESCAPE*/))
267        Ticker::Shutdown();
268
269        m_simulation->TickContext(seconds);
270
271        vec3 barycenter = vec3(.0f);
272        float factor = .0f;
273        for (int i = 0; i < m_ground_list.Count(); i++)
274        {
275                PhysicsObject* PhysObj = m_ground_list[i];
276
277                mat4 GroundMat = PhysObj->GetTransform();
278                vec3 CenterToGround = GroundMat.v3.xyz - vec3(.0f, 50.f, .0f);
279                vec3 CenterToCam = m_camera->m_position - vec3(.0f, 50.f, .0f);
280                if (dot(CenterToCam, CenterToGround) > .0f)
281                        PhysObj->SetRender(false);
282                else
283                        PhysObj->SetRender(true);
284
285                barycenter += GroundMat.v3.xyz;
286                factor += 1.f;
287        }
288
289        barycenter /= factor;
290
291        for (int i = 0; i < m_ground_list.Count(); i++)
292        {
293                PhysicsObject* PhysObj = m_ground_list[i];
294
295                mat4 GroundMat = PhysObj->GetTransform();
296                mat4 CenterMx = mat4::translate(barycenter);
297                //GroundMat = inverse(CenterMx) * GroundMat;
298                //GroundMat = CenterMx * GroundMat;
299                                        //mat4(quat::rotate(seconds * 10.0f, vec3(0, 1, 0))) * CenterMx;
300                //PhysObj->SetTransform(GroundMat.v3.xyz, quat(GroundMat));
301        }
302
303        m_camera->SetTarget(barycenter);
304        m_camera->SetPosition(vec3(-40.0f, 60.0f, -40.0f));
305
306#if 0
307        ///step the simulation
308        if (m_bt_world)
309        {
310                //int steps = (int)(seconds / 0.005f);
311                //for (int i = 0; i < steps; i++)
312                        m_bt_world->stepSimulation(seconds /*/ steps*/);
313                //optional but useful: debug drawing
314                //m_bt_world->debugDrawWorld();
315        }
316#endif
317}
318
319void BtPhysTest::TickDraw(float seconds)
320{
321    WorldEntity::TickDraw(seconds);
322
323    if (!m_ready)
324    {
325#if 0
326                m_ground_mesh.MeshConvert();
327                m_rigid_mesh[0].MeshConvert();
328                m_rigid_mesh[1].MeshConvert();
329                m_rigid_mesh[2].MeshConvert();
330                m_rigid_mesh[3].MeshConvert();
331                m_rigid_mesh[4].MeshConvert();
332                m_rigid_mesh[5].MeshConvert();
333#endif
334        /* FIXME: this object never cleans up */
335        m_ready = true;
336    }
337
338    Video::SetClearColor(vec4(0.0f, 0.0f, 0.12f, 1.0f));
339
340#if 0
341        vec3 BarycenterLocation = vec3(.0f);
342        float BarycenterFactor = 0.0f;
343        for(int i=0;i<gNumObjects;i++)
344        {
345                mat4 m(1.0f);
346                btMatrix3x3     rot; rot.setIdentity();
347                btCollisionObject*      colObj = m_bt_world->getCollisionObjectArray()[i];
348                btRigidBody*            body = btRigidBody::upcast(colObj);
349                if(body && body->getMotionState())
350                {
351                        btDefaultMotionState* myMotionState = (btDefaultMotionState*)body->getMotionState();
352                        myMotionState->m_graphicsWorldTrans.getOpenGLMatrix(&m[0][0]);
353                        rot = myMotionState->m_graphicsWorldTrans.getBasis();
354                }
355                else
356                {
357                        colObj->getWorldTransform().getOpenGLMatrix(&m[0][0]);
358                        rot = colObj->getWorldTransform().getBasis();
359                }
360                if (i > 0)
361                {
362                        BarycenterLocation += m.v3.xyz;
363                        BarycenterFactor += 1.0f;
364                }
365                if (i == 0)
366                        m_ground_mesh.Render(m);
367                else
368                        m_rigid_mesh[i % 6].Render(m);
369        }
370        if (BarycenterFactor > .0f)
371        {
372                BarycenterLocation /= BarycenterFactor;
373
374                m_camera->SetTarget(BarycenterLocation);
375                m_camera->SetPosition(BarycenterLocation + vec3(-20.0f, 8.0f, .0f));
376        }
377#endif
378}
379
380BtPhysTest::~BtPhysTest()
381{
382        Ticker::Unref(m_camera);
383        while (m_ground_list.Count())
384        {
385                PhysicsObject* CurPop = m_ground_list.Last();
386                m_ground_list.Pop();
387                Ticker::Unref(CurPop);
388        }
389        while (m_physobj_list.Count())
390        {
391                PhysicsObject* CurPop = m_physobj_list.Last();
392                m_physobj_list.Pop();
393                Ticker::Unref(CurPop);
394        }
395
396#if 0
397        //Exit Physics
398        {
399                //cleanup in the reverse order of creation/initialization
400                //remove the rigidbodies from the dynamics world and delete them
401                for (int i = m_bt_world->getNumCollisionObjects() - 1; i >= 0 ;i--)
402                {
403                        btCollisionObject* obj = m_bt_world->getCollisionObjectArray()[i];
404                        btRigidBody* body = btRigidBody::upcast(obj);
405                        if (body && body->getMotionState())
406                                delete body->getMotionState();
407
408                        m_bt_world->removeCollisionObject(obj);
409                        delete obj;
410                }
411
412                //delete collision shapes
413                for (int j = 0; j < m_bt_collision_shapes.Count(); j++)
414                {
415                        btCollisionShape* shape = m_bt_collision_shapes[j];
416                        delete shape;
417                }
418                m_bt_collision_shapes.Empty();
419
420                delete m_bt_world;
421                delete m_bt_solver;
422                delete m_bt_broadphase;
423                delete m_bt_dispatcher;
424                delete m_bt_collision_config;
425        }
426#endif
427}
428
429int main(int argc, char **argv)
430{
431    Application app("BtPhysTest", ivec2(1280, 720), 60.0f);
432
433#if defined _MSC_VER && !defined _XBOX
434    _chdir("..");
435#elif defined _WIN32 && !defined _XBOX
436    _chdir("../..");
437#endif
438
439    new BtPhysTest(argc > 1);
440    app.ShowPointer(false);
441
442    app.Run();
443
444    return EXIT_SUCCESS;
445}
446
Note: See TracBrowser for help on using the repository browser.