source: trunk/test/BtPhysTest.cpp @ 1768

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

Added Attachment/base logic with working attachment with EasyCharacterController.
Added RayCastResult & a naïve integration for EasyCharacterController.
Enjoy !

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