source: trunk/test/BtPhysTest.cpp @ 1633

Last change on this file since 1633 was 1633, checked in by touky, 10 years ago

Correct integration of EasyConstraint + TestDemo.

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