Context Navigation

source: trunk/test/BtPhysTest.cpp @ 1613
Tweet

Last change on this file since 1613 was 1613, checked in by touky, 11 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
41	using 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
52	using namespace lol::phys;
53
54	#define CUBE_HALF_EXTENTS .5f
55	#define EXTRA_HEIGHT 1.f
56
57	int gNumObjects = 64;
58
59	BtPhysTest::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)iCUBE_HALF_EXTENTS2.0f)/((float)colsize2.0fCUBE_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 + row8CUBE_HALF_EXTENTS+CUBE_HALF_EXTENTS+EXTRA_HEIGHT,
226	col8CUBE_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
265	void 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
346	void 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
407	BtPhysTest::~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
456	int 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.

Download in other formats: