source: trunk/test/BtPhysTest.cpp @ 1803

Last change on this file since 1803 was 1803, checked in by sam, 7 years ago

input: switch all key names to camel case, like our other enums.

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#include "core.h"
32#include "loldebug.h"
33
34using namespace lol;
35
36#ifndef HAVE_PHYS_USE_BULLET
37#define HAVE_PHYS_USE_BULLET
38#endif /* HAVE_PHYS_USE_BULLET */
39
40#include "Physics/Include/LolPhysics.h"
41#include "Physics/Include/EasyPhysics.h"
42#include "PhysicObject.h"
43#include "BtPhysTest.h"
44
45using namespace lol::phys;
46
47#define CUBE_HALF_EXTENTS .5f
48#define EXTRA_HEIGHT 1.f
49
50int gNumObjects = 64;
51
52#define USE_WALL                1
53#define USE_PLATFORM    1
54#define USE_ROPE                0
55#define USE_BODIES              0
56#define USE_ROTATION    0
57#define USE_CHARACTER   1
58
59#define IPT_MOVE_FORWARD                "Move_Forward"
60#define IPT_MOVE_BACKWARD               "Move_Backward"
61#define IPT_MOVE_STRAFE_LEFT    "Strafe_Left"
62#define IPT_MOVE_STRAFE_RIGHT   "Strafe_right"
63#define IPT_MOVE_JUMP                   "Move_Jump"
64
65BtPhysTest::BtPhysTest(bool editor)
66{
67        m_loop_value = .0f;
68
69    /* Create a camera that matches the settings of XNA BtPhysTest */
70    m_camera = new Camera(vec3(0.f, 600.f, 0.f),
71                          vec3(0.f, 0.f, 0.f),
72                          vec3(0, 1, 0));
73    m_camera->SetRotation(quat::fromeuler_xyz(0.f, 0.f, 0.f));
74    m_camera->SetPerspective(45.f, 1280.f, 960.f, .1f, 1000.f);
75        //m_camera->SetOrtho(1280.f / 6, 960.f / 6, -1000.f, 1000.f);
76    Ticker::Ref(m_camera);
77
78    m_ready = false;
79
80        m_simulation = new Simulation();
81        m_simulation->SetWorldLimit(vec3(-1000.0f, -1000.0f, -1000.0f), vec3(1000.0f, 1000.0f, 1000.0f));
82        m_simulation->Init();
83        vec3 NewGravity = vec3(.0f, -10.0f, .0f);
84        m_simulation->SetGravity(NewGravity);
85        m_simulation->SetContinuousDetection(true);
86        m_simulation->SetTimestep(1.f / 120.f);
87    Ticker::Ref(m_simulation);
88
89        float offset = 29.5f;
90        vec3 pos_offset = vec3(.0f, 30.f, .0f);
91        if (USE_WALL)
92        {
93                for (int i=0; i < 6; i++)
94                {
95                        vec3 NewPosition = vec3(.0f);
96                        quat NewRotation = quat(1.f);
97
98                        PhysicsObject* NewPhyobj = new PhysicsObject(m_simulation, NewPosition, NewRotation);
99
100                        int idx = i/2;
101                        NewPosition = pos_offset;
102                        NewPosition[idx] += offset;
103                        offset *= -1.f;
104
105                        if (idx != 1)
106                        {
107                                vec3 axis = vec3(.0f);
108                                axis[2 - idx] = 1;
109                                NewRotation = quat::rotate(90.f, axis);
110                        }
111
112                        NewPhyobj->SetTransform(NewPosition, NewRotation);
113                        Ticker::Ref(NewPhyobj);
114                        m_ground_list << NewPhyobj;
115                }
116        }
117
118        PhysicsObject* BasePhyobj = NULL;
119        if (USE_PLATFORM)
120        {
121                quat NewRotation = quat::fromeuler_xyz(0.f, 0.f, 0.f);
122                vec3 NewPosition = pos_offset + vec3(5.0f, -25.0f, -15.0f);
123
124                PhysicsObject* NewPhyobj = new PhysicsObject(m_simulation, NewPosition, NewRotation, 1);
125
126                m_platform_list << NewPhyobj;
127                Ticker::Ref(NewPhyobj);
128
129                NewPosition = pos_offset + vec3(-15.0f, -25.0f, 5.0f);
130
131                NewPhyobj = new PhysicsObject(m_simulation, NewPosition, NewRotation, 1);
132                BasePhyobj = NewPhyobj;
133
134                m_platform_list << NewPhyobj;
135                Ticker::Ref(NewPhyobj);
136
137                NewRotation = quat::fromeuler_xyz(0.f, 0.f, 90.f);
138                NewPosition = pos_offset + vec3(-20.0f, -25.0f, 5.0f);
139
140                NewPhyobj = new PhysicsObject(m_simulation, NewPosition, NewRotation, 1);
141
142                NewPhyobj->GetPhysic()->AttachTo(BasePhyobj->GetPhysic(), true, true);
143                m_platform_list << NewPhyobj;
144                Ticker::Ref(NewPhyobj);
145
146                //NewPosition += vec3(-0.0f, .0f, .0f);
147                //NewPhyobj = new PhysicsObject(m_simulation, NewPosition, NewRotation, 1);
148
149                //NewPhyobj->GetPhysic()->AttachTo(BasePhyobj->GetPhysic(), true, false);
150                //m_platform_list << NewPhyobj;
151                //Ticker::Ref(NewPhyobj);
152
153                //NewPosition += vec3(-2.0f, .0f, .0f);
154                //NewPhyobj = new PhysicsObject(m_simulation, NewPosition, NewRotation, 1);
155
156                //NewPhyobj->GetPhysic()->AttachTo(BasePhyobj->GetPhysic(), false, false);
157                //m_platform_list << NewPhyobj;
158                //Ticker::Ref(NewPhyobj);
159        }
160
161        if (USE_CHARACTER)
162        {
163                quat NewRotation = quat::fromeuler_xyz(0.f, 0.f, 0.f);
164                vec3 NewPosition = pos_offset + vec3(-15.0f, -10.0f, .0f);
165
166                PhysicsObject* NewPhyobj = new PhysicsObject(m_simulation, NewPosition, NewRotation, 2);
167
168                m_character_list << NewPhyobj;
169                Ticker::Ref(NewPhyobj);
170
171
172                Input::LinkActionToKey(IPT_MOVE_FORWARD,                Key::Up);
173                Input::LinkActionToKey(IPT_MOVE_BACKWARD,               Key::Down);
174                Input::LinkActionToKey(IPT_MOVE_STRAFE_LEFT,    Key::Left);
175                Input::LinkActionToKey(IPT_MOVE_STRAFE_RIGHT,   Key::Right);
176                Input::LinkActionToKey(IPT_MOVE_JUMP,                   Key::Space);
177
178                //NewPhyobj->GetCharacter()->AttachTo(BasePhyobj->GetPhysic(), true, true);
179        }
180
181        if (USE_BODIES)
182        {
183                for (int x=0; x < 6; x++)
184                {
185                        for (int y=0; y < 6; y++)
186                        {
187                                for (int z=0; z < 5; z++)
188                                {
189                                        PhysicsObject* new_physobj = new PhysicsObject(m_simulation, 1000.f,
190                                                vec3(-20.f, 15.f, -20.f) +
191                                                vec3(8.f * (float)x, 8.f * (float)y, 8.f * (float)z));
192                                        m_physobj_list << new_physobj;
193                                        Ticker::Ref(new_physobj);
194                                }
195                        }
196                }
197        }
198
199        if (USE_ROPE)
200        {
201                Array<PhysicsObject*> RopeElements;
202                for (int i = 0; i < 14; i++)
203                {
204                        PhysicsObject* new_physobj = new PhysicsObject(m_simulation, 1000.f,
205                                vec3(0.f, 15.f, -20.f) +
206                                vec3(0.f, 0.f, 2.f * (float)i), 1);
207                        RopeElements << new_physobj;
208                        m_physobj_list << new_physobj;
209                        Ticker::Ref(new_physobj);
210                        if (RopeElements.Count() > 1)
211                        {
212                                EasyConstraint* new_constraint = new EasyConstraint();
213
214                                vec3 A2B = .5f * (RopeElements[i]->GetPhysic()->GetTransform().v3.xyz -
215                                                        RopeElements[i - 1]->GetPhysic()->GetTransform().v3.xyz);
216                                new_constraint->SetPhysObjA(RopeElements[i - 1]->GetPhysic(), lol::mat4::translate(A2B));
217                                new_constraint->SetPhysObjB(RopeElements[i]->GetPhysic(), lol::mat4::translate(-A2B));
218                                new_constraint->InitConstraintToPoint2Point();
219                                new_constraint->DisableCollisionBetweenObjs(true);
220                                new_constraint->AddToSimulation(m_simulation);
221                                m_constraint_list << new_constraint;
222                        }
223                }
224        }
225}
226
227void BtPhysTest::TickGame(float seconds)
228{
229    WorldEntity::TickGame(seconds);
230
231    if (Input::WasReleased(Key::Escape))
232        Ticker::Shutdown();
233
234        m_loop_value += seconds;
235        if (m_loop_value > M_PI * 2.0f)
236                m_loop_value -= M_PI * 2.0f;
237
238        vec3 GroundBarycenter = vec3(.0f);
239        vec3 PhysObjBarycenter = vec3(.0f);
240        float factor = .0f;
241
242        if (USE_WALL)
243        {
244                for (int i = 0; i < m_ground_list.Count(); i++)
245                {
246                        PhysicsObject* PhysObj = m_ground_list[i];
247                        mat4 GroundMat = PhysObj->GetTransform();
248
249                        GroundBarycenter += GroundMat.v3.xyz;
250                        factor += 1.f;
251                }
252
253                GroundBarycenter /= factor;
254
255                for (int i = 0; i < m_ground_list.Count(); i++)
256                {
257                        PhysicsObject* PhysObj = m_ground_list[i];
258
259                        mat4 GroundMat = PhysObj->GetTransform();
260                        vec3 CenterToGround = GroundMat.v3.xyz - GroundBarycenter;
261                        vec3 CenterToCam = m_camera->m_position - GroundBarycenter;
262
263                        if (dot(normalize(CenterToCam - CenterToGround),
264                                        normalize(CenterToGround)) > 0.f)
265                                PhysObj->SetRender(false);
266                        else
267                                PhysObj->SetRender(true);
268                }
269        }
270
271        if (USE_ROTATION)
272        {
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                        mat4 CenterMx = mat4::translate(GroundBarycenter);
279                        GroundMat = inverse(CenterMx) * GroundMat;
280                        GroundMat = CenterMx *
281                                                mat4(quat::fromeuler_xyz(vec3(.0f, 20.f, 20.0f) * seconds))
282                                                * GroundMat;
283                        PhysObj->SetTransform(GroundMat.v3.xyz, quat(GroundMat));
284                }
285        }
286
287        if (USE_PLATFORM)
288        {
289                for (int i = 0; i < m_platform_list.Count(); i++)
290                {
291                        PhysicsObject* PhysObj = m_platform_list[i];
292
293                        mat4 GroundMat = PhysObj->GetTransform();
294                        if (i == 0)
295                        {
296                                GroundMat = GroundMat * mat4(quat::fromeuler_xyz(vec3(20.f, .0f, .0f) * seconds));
297                                PhysObj->SetTransform(GroundMat.v3.xyz, quat(GroundMat));
298                        }
299                        else if (i == 1)
300                        {
301                                GroundMat =
302                                        mat4::translate(vec3(-15.0f, 5.0f, lol::cos(m_loop_value) * 8.f)) *
303                                        mat4(quat::fromeuler_xyz(vec3(.0f, lol::cos(m_loop_value) * 20.f, .0f)));
304                                PhysObj->SetTransform(GroundMat.v3.xyz, quat(GroundMat));
305                        }
306                }
307        }
308
309        if (USE_CHARACTER)
310        {
311                for (int i = 0; i < m_character_list.Count(); i++)
312                {
313                        PhysicsObject* PhysObj = m_character_list[i];
314                        EasyCharacterController* Character = (EasyCharacterController*)PhysObj->GetCharacter();
315                        mat4 CtlrMx = Character->GetTransform();
316                       
317                        int HMovement = Input::GetStatus(IPT_MOVE_STRAFE_RIGHT) - Input::GetStatus(IPT_MOVE_STRAFE_LEFT);
318                        int VMovement = Input::GetStatus(IPT_MOVE_FORWARD) - Input::GetStatus(IPT_MOVE_BACKWARD);
319                        int RMovement = 0;//Input::GetButtonState(280 /*SDLK_PAGEUP*/) - Input::GetButtonState(281 /*SDLK_PAGEDOWN*/);
320                        vec3 CharMove = vec3((float)VMovement * seconds * 4.f, (float)RMovement * seconds * 10.f, (float)HMovement * seconds * 4.f);
321
322                        if (Input::WasReleased(IPT_MOVE_JUMP))
323                                Character->Jump();
324                        Character->SetMovementForFrame(CharMove);
325
326                        RayCastResult HitResult;
327                        if (m_simulation->RayHits(HitResult, ERT_Closest, Character->GetTransform().v3.xyz, (Character->GetTransform().v3.xyz + vec3(.0f, -1.f, .0f)), Character))
328                                Character->AttachTo(HitResult.m_collider_list[0], true, true);
329                        else
330                                Character->AttachTo(NULL);
331                }
332        }
333
334        if (USE_CHARACTER)
335        {
336                PhysObjBarycenter = vec3(.0f);
337                factor = .0f;
338
339                for (int i = 0; i < m_character_list.Count(); i++)
340                {
341                        PhysicsObject* PhysObj = m_character_list[i];
342                        mat4 GroundMat = PhysObj->GetTransform();
343
344                        PhysObjBarycenter += GroundMat.v3.xyz;
345                        factor += 1.f;
346                }
347
348                PhysObjBarycenter /= factor;
349
350                m_camera->SetTarget(m_camera->GetTarget() + (seconds / (seconds + 0.18f)) * (PhysObjBarycenter - m_camera->GetTarget()));
351                vec3 CamPosCenter = m_camera->GetTarget() + vec3(.0f, 5.0f, .0f);
352                m_camera->SetPosition(CamPosCenter + normalize(m_camera->GetPosition() - CamPosCenter) * 20.0f);
353        }
354        else
355        {
356                PhysObjBarycenter = vec3(.0f);
357                for (int i = 0; i < m_physobj_list.Count(); i++)
358                {
359                        PhysicsObject* PhysObj = m_physobj_list[i];
360                        mat4 GroundMat = PhysObj->GetTransform();
361
362                        PhysObjBarycenter += GroundMat.v3.xyz;
363                        factor += 1.f;
364                }
365
366                PhysObjBarycenter /= factor;
367
368                m_camera->SetTarget(PhysObjBarycenter);
369                m_camera->SetPosition(GroundBarycenter + normalize(GroundBarycenter - PhysObjBarycenter) * 60.0f);
370        }
371
372}
373
374void BtPhysTest::TickDraw(float seconds)
375{
376    WorldEntity::TickDraw(seconds);
377
378    if (!m_ready)
379    {
380        /* FIXME: this object never cleans up */
381        m_ready = true;
382    }
383
384    //Video::SetClearColor(vec4(0.0f, 0.0f, 0.12f, 1.0f));
385
386}
387
388BtPhysTest::~BtPhysTest()
389{
390        Ticker::Unref(m_camera);
391       
392        while (m_constraint_list.Count())
393        {
394                EasyConstraint* CurPop = m_constraint_list.Last();
395                m_constraint_list.Pop();
396                CurPop->RemoveFromSimulation(m_simulation);
397                delete CurPop;
398        }
399        while (m_ground_list.Count())
400        {
401                PhysicsObject* CurPop = m_ground_list.Last();
402                m_ground_list.Pop();
403                CurPop->GetPhysic()->RemoveFromSimulation(m_simulation);
404                Ticker::Unref(CurPop);
405        }
406        while (m_character_list.Count())
407        {
408                PhysicsObject* CurPop = m_character_list.Last();
409                m_character_list.Pop();
410                CurPop->GetCharacter()->RemoveFromSimulation(m_simulation);
411                Ticker::Unref(CurPop);
412        }
413        while (m_platform_list.Count())
414        {
415                PhysicsObject* CurPop = m_platform_list.Last();
416                m_platform_list.Pop();
417                CurPop->GetPhysic()->RemoveFromSimulation(m_simulation);
418                Ticker::Unref(CurPop);
419        }
420        while (m_physobj_list.Count())
421        {
422                PhysicsObject* CurPop = m_physobj_list.Last();
423                m_physobj_list.Pop();
424                CurPop->GetPhysic()->RemoveFromSimulation(m_simulation);
425                Ticker::Unref(CurPop);
426        }
427    Ticker::Unref(m_simulation);
428
429}
430
431int main(int argc, char **argv)
432{
433    Application app("BtPhysTest", ivec2(1280, 720), 60.0f);
434
435#if defined _MSC_VER && !defined _XBOX
436    _chdir("..");
437#elif defined _WIN32 && !defined _XBOX
438    _chdir("../..");
439#endif
440
441    new BtPhysTest(argc > 1);
442    app.ShowPointer(false);
443
444    app.Run();
445
446    return EXIT_SUCCESS;
447}
448
Note: See TracBrowser for help on using the repository browser.