source: trunk/test/BtPhysTest.cpp @ 1613

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

BtPhysTest : Container box now moves.

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