· 5 years ago · Dec 15, 2020, 07:56 PM
1// ===============================================================================
2// NVIDIA PHYSX SDK TRAINING PROGRAMS
3// LESSON 102 : MESH SHAPES
4//
5// Written by QA BJ, 6-2-2008
6// ===============================================================================
7#define _USE_MATH_DEFINES
8#include <math.h>
9#include "Lesson102.h"
10#include "Timing.h"
11#include "time.h"
12#include "tinyxml2.h"
13
14
15#define PI 3.14159265
16using namespace std;
17using namespace tinyxml2;
18
19float sphereDiameter = 3.0;
20float sphereDiameterTolerance = 2.0;
21float innerCylinderD = 20.0;
22float outerCylinderD = 60.0;
23float cylinderH = 40.0;
24float cylindersDelta = 10.0;
25float particleH = 10;
26
27NxActor* CreateSphere();
28// Physics SDK globals
29NxPhysicsSDK* gPhysicsSDK = NULL;
30NxScene* gScene = NULL;
31//NxVec3 gDefaultGravity(0,-9.8,0);
32NxVec3 gDefaultGravity(0, -18.8, 0);
33UserAllocator* gAllocator;
34// User report globals
35DebugRenderer gDebugRenderer;
36// HUD globals
37HUD hud;
38// Display globals
39int gMainHandle;
40int mx = 0;
41int my = 0;
42// Camera globals
43float gCameraAspectRatio = 1;
44NxVec3 gCameraPos(0, 5, -15);
45NxVec3 gCameraForward(0, 0, 1);
46NxVec3 gCameraRight(-1, 0, 0);
47const NxReal gCameraSpeed = 30;
48// Force globals
49NxVec3 gForceVec(0, 0, 0);
50NxReal gForceStrength = 20000;
51bool bForceMode = true;
52// Keyboard globals
53#define MAX_KEYS 256
54bool gKeys[MAX_KEYS];
55// Simulation globals
56NxReal gDeltaTime = 1.0 / 60.0;
57bool bHardwareScene = false;
58bool bPause = false;
59bool bShadows = true;
60bool bDebugWireframeMode = false;
61// Actor globals
62NxActor* groundPlane = NULL;
63NxConvexMeshDesc* convexDesc = NULL;
64NxTriangleMeshDesc* triangleMeshDesc = NULL;
65NxTriangleMeshDesc* concaveDesc = NULL;
66// Focus actor
67NxActor* gSelectedActor = NULL;
68bool IsSelectable(NxActor* actor)
69{
70 NxShape* const* shapes = gSelectedActor->getShapes();
71 NxU32 nShapes = gSelectedActor->getNbShapes();
72 while (nShapes--)
73 {
74 if (shapes[nShapes]->getFlag(NX_TRIGGER_ENABLE))
75 {
76 return false;
77 }
78 }
79 if (!actor->isDynamic())
80 return false;
81 if (actor == groundPlane)
82 return false;
83 return true;
84}
85void SelectNextActor()
86{
87 NxU32 nbActors = gScene->getNbActors();
88 NxActor** actors = gScene->getActors();
89 for (NxU32 i = 0; i < nbActors; i++)
90 {
91 if (actors[i] == gSelectedActor)
92 {
93 NxU32 j = 1;
94 gSelectedActor = actors[(i + j) % nbActors];
95 while (!IsSelectable(gSelectedActor))
96 {
97 j++;
98 gSelectedActor = actors[(i + j) % nbActors];
99 }
100 break;
101 }
102 }
103}
104void PrintControls()
105{
106 printf("\n Flight Controls:\n ----------------\n w = forward, s = back\n a = strafe left, d = strafe right\n q = up, z = down\n");
107 //printf("\n Force Controls:\n ---------------\n i = +z, k = -z\n j = +x, l = -x\n u = +y, m = -y\n");
108 printf("\n Miscellaneous:\n --------------\n p = Pause\n b = Toggle Debug Wireframe Mode\n x = Toggle Shadows\n r = Select Actor\n F10 = Reset Scene");
109}
110NxVec3 ApplyForceToActor(NxActor* actor, const NxVec3& forceDir, const NxReal forceStrength)
111{
112 NxVec3 forceVec = forceStrength * forceDir * gDeltaTime;
113 actor->addForce(forceVec);
114 return forceVec;
115}
116void ProcessCameraKeys()
117{
118 NxReal deltaTime;
119 if (bPause) deltaTime = 0.0005; else deltaTime = gDeltaTime;
120 // Process camera keys
121 for (int i = 0; i < MAX_KEYS; i++)
122 {
123 if (!gKeys[i]) { continue; }
124 switch (i)
125 {
126 // Camera controls
127 case 'w': { gCameraPos += gCameraForward * gCameraSpeed * deltaTime; break; }
128 case 's': { gCameraPos -= gCameraForward * gCameraSpeed * deltaTime; break; }
129 case 'a': { gCameraPos -= gCameraRight * gCameraSpeed * deltaTime; break; }
130 case 'd': { gCameraPos += gCameraRight * gCameraSpeed * deltaTime; break; }
131 case 'z': { gCameraPos -= NxVec3(0, 1, 0) * gCameraSpeed * deltaTime; break; }
132 case 'q': { gCameraPos += NxVec3(0, 1, 0) * gCameraSpeed * deltaTime; break; }
133 }
134 }
135}
136void SetupCamera()
137{
138 gCameraAspectRatio = (float)glutGet(GLUT_WINDOW_WIDTH) / (float)glutGet(GLUT_WINDOW_HEIGHT);
139 // Setup camera
140 glMatrixMode(GL_PROJECTION);
141 glLoadIdentity();
142 gluPerspective(60.0f, gCameraAspectRatio, 1.0f, 10000.0f);
143 gluLookAt(gCameraPos.x, gCameraPos.y, gCameraPos.z, gCameraPos.x + gCameraForward.x, gCameraPos.y + gCameraForward.y, gCameraPos.z + gCameraForward.z, 0.0f, 1.0f, 0.0f);
144 glMatrixMode(GL_MODELVIEW);
145 glLoadIdentity();
146}
147void RenderActors(bool shadows)
148{
149 // Render all the actors in the scene
150 NxU32 nbActors = gScene->getNbActors();
151 NxActor** actors = gScene->getActors();
152 while (nbActors--)
153 {
154 NxActor* actor = *actors++;
155 DrawActor(actor, gSelectedActor, false);
156 // Handle shadows
157 if (shadows)
158 {
159 DrawActorShadow(actor, false);
160 }
161 }
162}
163void DrawForce(NxActor* actor, NxVec3& forceVec, const NxVec3& color)
164{
165 // Draw only if the force is large enough
166 NxReal force = forceVec.magnitude();
167 if (force < 0.1) return;
168 forceVec = 3 * forceVec / force;
169 NxVec3 pos = actor->getCMassGlobalPosition();
170 DrawArrow(pos, pos + forceVec, color);
171}
172void ProcessInputs()
173{
174 //ProcessForceKeys();
175 // Show debug wireframes
176 if (bDebugWireframeMode)
177 {
178 if (gScene) gDebugRenderer.renderData(*gScene->getDebugRenderable());
179 }
180}
181void RenderCallback()
182{
183 // Clear buffers
184 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
185 ProcessCameraKeys();
186 SetupCamera();
187 if (gScene && !bPause)
188 {
189 GetPhysicsResults();
190 ProcessInputs();
191 StartPhysics();
192 }
193 // Display scene
194 RenderActors(bShadows);
195 DrawForce(gSelectedActor, gForceVec, NxVec3(1, 1, 0));
196 gForceVec = NxVec3(0, 0, 0);
197 // Render the HUD
198 hud.Render();
199 glFlush();
200 glutSwapBuffers();
201}
202void ReshapeCallback(int width, int height)
203{
204 glViewport(0, 0, width, height);
205 gCameraAspectRatio = float(width) / float(height);
206}
207void IdleCallback()
208{
209 glutPostRedisplay();
210}
211void KeyboardCallback(unsigned char key, int x, int y)
212{
213 gKeys[key] = true;
214 switch (key)
215 {
216 case 'r': { SelectNextActor(); break; }
217 default: { break; }
218 }
219}
220void KeyboardUpCallback(unsigned char key, int x, int y)
221{
222 gKeys[key] = false;
223 switch (key)
224 {
225 case 'p': { bPause = !bPause;
226 if (bPause)
227 hud.SetDisplayString(0, "Paused - Hit \"p\" to Unpause", 0.3f, 0.55f);
228 else
229 hud.SetDisplayString(0, "", 0.0f, 0.0f);
230 getElapsedTime();
231 break; }
232 case 'x': { bShadows = !bShadows; break; }
233 case 'b': { bDebugWireframeMode = !bDebugWireframeMode; break; }
234 case 27: { exit(0); break; }
235 case 'f': {
236 NxU32 nbActors = gScene->getNbActors();
237 NxActor** actors = gScene->getActors();
238 NxVec3 uwu;
239 /*NxActor* actor = *actors++;
240 gScene->releaseActor(*actor);
241 nbActors--; *actors++;
242 gScene->releaseActor(*actor);
243 nbActors--; *actors++;*/
244 while (nbActors--)
245 {
246 NxActor* actor = *actors++;
247 //DrawActor(actor, gSelectedActor, false);
248 uwu = actor->getGlobalPosition();
249 //uwu.x < 0.0 ? uwu.x = -uwu.x : uwu.x = uwu.x;
250 //uwu.z < 0.0 ? uwu.z = -uwu.z : uwu.z = uwu.z;
251 if (/*uwu.x > outerCylinderD / 2.0 || uwu.z > outerCylinderD / 2.0 ||*/ uwu.x * uwu.x + uwu.z * uwu.z > outerCylinderD * outerCylinderD / 4.0 || uwu.y > cylinderH || (uwu.x == 0.0 && uwu.y > 0.0)) {
252 gScene->releaseActor(*actor);
253 }
254 else {
255 actor->raiseBodyFlag(NX_BF_FROZEN);
256 }
257 }
258 break; }
259 default: { break; }
260 }
261}
262void SpecialCallback(int key, int x, int y)
263{
264 switch (key)
265 {
266 // Reset PhysX
267 case GLUT_KEY_F10: ResetNx(); return;
268 }
269}
270void MouseCallback(int button, int state, int x, int y)
271{
272 mx = x;
273 my = y;
274}
275void MotionCallback(int x, int y)
276{
277 int dx = mx - x;
278 int dy = my - y;
279 gCameraForward.normalize();
280 gCameraRight.cross(gCameraForward, NxVec3(0, 1, 0));
281 NxQuat qx(NxPiF32 * dx * 20 / 180.0f, NxVec3(0, 1, 0));
282 qx.rotate(gCameraForward);
283 NxQuat qy(NxPiF32 * dy * 20 / 180.0f, gCameraRight);
284 qy.rotate(gCameraForward);
285 mx = x;
286 my = y;
287}
288void ExitCallback()
289{
290 ReleaseNx();
291}
292void InitGlut(int argc, char** argv)
293{
294 glutInit(&argc, argv);
295 glutInitWindowSize(960, 960);
296 glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
297 gMainHandle = glutCreateWindow("Lesson 102: Mesh Shapes");
298 glutSetWindow(gMainHandle);
299 glutDisplayFunc(RenderCallback);
300 glutReshapeFunc(ReshapeCallback);
301 glutIdleFunc(IdleCallback);
302 glutKeyboardFunc(KeyboardCallback);
303 glutKeyboardUpFunc(KeyboardUpCallback);
304 glutSpecialFunc(SpecialCallback);
305 glutMouseFunc(MouseCallback);
306 glutMotionFunc(MotionCallback);
307 MotionCallback(0, 0);
308 atexit(ExitCallback);
309 // Setup default render states
310 glClearColor(0.0f, 0.0f, 0.0f, 1.0);
311 glEnable(GL_DEPTH_TEST);
312 glEnable(GL_COLOR_MATERIAL);
313 glEnable(GL_CULL_FACE);
314 // Setup lighting
315 glEnable(GL_LIGHTING);
316 float AmbientColor[] = { 0.0f, 0.1f, 0.2f, 0.0f }; glLightfv(GL_LIGHT0, GL_AMBIENT, AmbientColor);
317 float DiffuseColor[] = { 0.2f, 0.2f, 0.2f, 0.0f }; glLightfv(GL_LIGHT0, GL_DIFFUSE, DiffuseColor);
318 float SpecularColor[] = { 0.5f, 0.5f, 0.5f, 0.0f }; glLightfv(GL_LIGHT0, GL_SPECULAR, SpecularColor);
319 float Position[] = { 100.0f, 100.0f, -400.0f, 1.0f }; glLightfv(GL_LIGHT0, GL_POSITION, Position);
320 glEnable(GL_LIGHT0);
321}
322void InitializeHUD()
323{
324 bHardwareScene = (gScene->getSimType() == NX_SIMULATION_HW);
325 hud.Clear();
326 //// Add hardware/software to HUD
327 //if (bHardwareScene)
328 // hud.AddDisplayString("Hardware Scene", 0.74f, 0.92f);
329 //else
330 // hud.AddDisplayString("Software Scene", 0.74f, 0.92f);
331 // Add pause to HUD
332 if (bPause)
333 hud.AddDisplayString("Paused - Hit \"p\" to Unpause", 0.3f, 0.55f);
334 else
335 hud.AddDisplayString("", 0.0f, 0.0f);
336}
337void InitNx()
338{
339 // Initialize Camera Parameters
340 gCameraAspectRatio = 1.0f;
341 gCameraPos = NxVec3(0, 25, -120);
342 gCameraForward = NxVec3(0, 0, 1);
343 gCameraRight = NxVec3(-1, 0, 0);
344 // Create a memory allocator
345 if (!gAllocator)
346 {
347 gAllocator = new UserAllocator;
348 assert(gAllocator);
349 }
350 // Create the physics SDK
351 gPhysicsSDK = NxCreatePhysicsSDK(NX_PHYSICS_SDK_VERSION, gAllocator);
352 if (!gPhysicsSDK) return;
353 // Set the physics parameters
354 gPhysicsSDK->setParameter(NX_SKIN_WIDTH, 0.01);
355 // Set the debug visualization parameters
356 gPhysicsSDK->setParameter(NX_VISUALIZATION_SCALE, 1);
357 gPhysicsSDK->setParameter(NX_VISUALIZE_COLLISION_SHAPES, 1);
358 gPhysicsSDK->setParameter(NX_VISUALIZE_ACTOR_AXES, 1);
359 gPhysicsSDK->setParameter(NX_VISUALIZE_COLLISION_FNORMALS, 1);
360 // Create the scene
361 NxSceneDesc sceneDesc;
362 sceneDesc.simType = NX_SIMULATION_SW;
363 sceneDesc.gravity = gDefaultGravity;
364 gScene = gPhysicsSDK->createScene(sceneDesc);
365 if (!gScene)
366 {
367 sceneDesc.simType = NX_SIMULATION_SW;
368 gScene = gPhysicsSDK->createScene(sceneDesc);
369 if (!gScene) return;
370 }
371 // Create the default material
372 NxMaterial* defaultMaterial = gScene->getMaterialFromIndex(0);
373 defaultMaterial->setRestitution(0.5);
374 defaultMaterial->setStaticFriction(0.5);
375 defaultMaterial->setDynamicFriction(0.5);
376 // Create the objects in the scene
377 groundPlane = CreateGroundPlane();
378 // Create Convex Mesh
379 gSelectedActor = CreateConvexMesh();
380 gSelectedActor->raiseBodyFlag(NX_BF_FROZEN);
381 // Create Triangle Mesh
382 gSelectedActor = CreateTriangleMesh();
383 gSelectedActor->raiseBodyFlag(NX_BF_FROZEN);
384 int length = int(outerCylinderD / (sphereDiameter + sphereDiameterTolerance * 2)) + 2;
385 for (int i = 0; i < length; i++) {
386 for (int j = 0; j < length; j++) {
387 for (int k = 0; k < length; k++) {
388 gSelectedActor = CreateSphere();
389 gSelectedActor->setGlobalPosition(NxVec3(-outerCylinderD / 2.0 + i * (sphereDiameter + sphereDiameterTolerance * 2), cylinderH * 1.2 + j * (sphereDiameter + sphereDiameterTolerance * 2), -outerCylinderD / 2.0 + k * (sphereDiameter + sphereDiameterTolerance * 2)));
390 }
391 }
392 }
393 gSelectedActor = NULL;
394 // Create Concave Mesh, Actually it is too Triangle Mesh.
395 //CreateConcaveMesh();
396 // Initialize HUD
397 InitializeHUD();
398 // Get the current time
399 getElapsedTime();
400 // Start the first frame of the simulation
401 if (gScene) StartPhysics();
402}
403NxActor* CreateGroundPlane()
404{
405 // Create a plane with default descriptor
406 NxPlaneShapeDesc planeDesc;
407 NxActorDesc actorDesc;
408 actorDesc.shapes.pushBack(&planeDesc);
409 return gScene->createActor(actorDesc);
410}
411NxActor* CreateSphere()
412{
413 // Add a single-shape actor to the scene
414 NxActorDesc actorDesc;
415 NxBodyDesc bodyDesc;
416 srand(time(NULL) + rand() % 2000);
417 // The actor has one shape, a sphere, 1m on radius
418 NxSphereShapeDesc sphereDesc;
419 sphereDesc.radius = sphereDiameter / 2.0 + (1 - 2 * rand() % 2) * 0.001 * (rand() % int(sphereDiameterTolerance * 1000.0));
420 sphereDesc.localPose.t = NxVec3(0, 0, 0);
421 actorDesc.shapes.pushBack(&sphereDesc);
422 actorDesc.body = &bodyDesc;
423 actorDesc.density = 10.0f;
424 actorDesc.globalPose.t = NxVec3(0, 0, 0);
425 return gScene->createActor(actorDesc);
426}
427NxActor* CreateConvexMesh()
428{
429 NxActorDesc actorDesc;
430 NxBodyDesc bodyDesc;
431 //NxVec3 boxDim(0.5,0.75,0.5);
432 NxVec3 verts[90];
433 for (int i = 0; i < 45; i++) {
434 verts[i] = NxVec3(innerCylinderD / 2 * sin(i * 2 * M_PI / 45), 0.0, innerCylinderD / 2 * cos(i * 2 * M_PI / 45));
435 }
436 for (int i = 45; i < 90; i++) {
437 verts[i] = NxVec3(innerCylinderD / 2 * sin(i * 2 * M_PI / 45), cylinderH - cylindersDelta, innerCylinderD / 2 * cos(i * 2 * M_PI / 45));
438 }
439 // Create descriptor for convex mesh
440 if (!convexDesc)
441 {
442 convexDesc = new NxConvexMeshDesc();
443 assert(convexDesc);
444 }
445 convexDesc->numVertices = 90;
446 convexDesc->pointStrideBytes = sizeof(NxVec3);
447 convexDesc->points = verts;
448 convexDesc->flags = NX_CF_COMPUTE_CONVEX;
449 NxConvexShapeDesc convexShapeDesc;
450 convexShapeDesc.localPose.t = NxVec3(0, 0, 0);
451 convexShapeDesc.userData = convexDesc;
452 // Two ways on cooking mesh: 1. Saved in memory, 2. Saved in file
453 NxInitCooking();
454 // Cooking from memory
455 MemoryWriteBuffer buf;
456 bool status = NxCookConvexMesh(*convexDesc, buf);
457 //
458 // Please note about the created Convex Mesh, user needs to release it when no one uses it to save memory. It can be detected
459 // by API "meshData->getReferenceCount() == 0". And, the release API is "gPhysicsSDK->releaseConvexMesh(*convexShapeDesc.meshData);"
460 //
461 NxConvexMesh* pMesh = gPhysicsSDK->createConvexMesh(MemoryReadBuffer(buf.data));
462 assert(pMesh);
463 convexShapeDesc.meshData = pMesh;
464 NxCloseCooking();
465 if (pMesh)
466 {
467 // Save mesh in userData for drawing.
468 pMesh->saveToDesc(*convexDesc);
469 //
470 NxActorDesc actorDesc;
471 assert(convexShapeDesc.isValid());
472 actorDesc.shapes.pushBack(&convexShapeDesc);
473 actorDesc.body = &bodyDesc;
474 actorDesc.density = 1.0f;
475 actorDesc.globalPose.t = NxVec3(0.0f, cylindersDelta, 0.0f);
476 assert(actorDesc.isValid());
477 NxActor* actor = gScene->createActor(actorDesc);
478 assert(actor);
479 return actor;
480 }
481 return NULL;
482}
483NxActor* CreateTriangleMesh()
484{
485 // Supply hull
486 NxVec3 verts[90];
487 for (int i = 0; i < 45; i++) {
488 verts[i] = NxVec3(outerCylinderD / 2 * sin(i * 2 * M_PI / 45), cylinderH / 2.0, outerCylinderD / 2 * cos(i * 2 * M_PI / 45));
489 }
490 for (int i = 45; i < 90; i++) {
491 verts[i] = NxVec3(outerCylinderD / 2 * sin(i * 2 * M_PI / 45), -cylinderH / 2.0, outerCylinderD / 2 * cos(i * 2 * M_PI / 45));
492 }
493 NxU32 indices[90 * 3];
494 for (int i = 0; i < 45; i++) {
495 indices[6 * i + 0] = 45 + i;
496 indices[6 * i + 1] = i;
497 indices[6 * i + 2] = (i + 1) % 45;
498 indices[6 * i + 3] = (i + 1) % 45;
499 indices[6 * i + 4] = 45 + (i + 1) % 45;
500 indices[6 * i + 5] = 45 + i;
501 }
502 // Create descriptor for triangle mesh
503 if (!triangleMeshDesc)
504 {
505 triangleMeshDesc = new NxTriangleMeshDesc();
506 assert(triangleMeshDesc);
507 }
508 triangleMeshDesc->numVertices = 90;
509 triangleMeshDesc->pointStrideBytes = sizeof(NxVec3);
510 triangleMeshDesc->points = verts;
511 triangleMeshDesc->numTriangles = 90;
512 triangleMeshDesc->flags = 0;
513 triangleMeshDesc->triangles = indices;
514 triangleMeshDesc->triangleStrideBytes = 3 * sizeof(NxU32);
515 //Alternative: see NxMeshFlags
516 //triangleMeshDesc->flags = NX_MF_16_BIT_INDICES
517 //triangleMeshDesc->triangles = indices16;
518 //triangleMeshDesc->triangleStrideBytes = 3 * sizeof(NxU16);
519 // The actor has one shape, a triangle mesh
520 NxInitCooking();
521 MemoryWriteBuffer buf;
522 bool status = NxCookTriangleMesh(*triangleMeshDesc, buf);
523 NxTriangleMesh* pMesh;
524 if (status)
525 {
526 pMesh = gPhysicsSDK->createTriangleMesh(MemoryReadBuffer(buf.data));
527 }
528 else
529 {
530 assert(false);
531 pMesh = NULL;
532 }
533 NxCloseCooking();
534 // Create TriangleMesh above code segment.
535 NxTriangleMeshShapeDesc tmsd;
536 tmsd.meshData = pMesh;
537 tmsd.userData = triangleMeshDesc;
538 tmsd.localPose.t = NxVec3(0, 0, 0);
539 tmsd.meshPagingMode = NX_MESH_PAGING_AUTO;
540 NxActorDesc actorDesc;
541 NxBodyDesc bodyDesc;
542 assert(tmsd.isValid());
543 actorDesc.shapes.pushBack(&tmsd);
544 //Dynamic triangle mesh don't be supported anymore. So body = NULL
545 actorDesc.body = NULL;
546 actorDesc.globalPose.t = NxVec3(0.0f, cylinderH / 2.0, 0.0f);
547 if (pMesh)
548 {
549 // Save mesh in userData for drawing
550 pMesh->saveToDesc(*triangleMeshDesc);
551 //
552 assert(actorDesc.isValid());
553 NxActor* actor = gScene->createActor(actorDesc);
554 assert(actor);
555 return actor;
556 }
557 return NULL;
558}
559void ReleaseNx()
560{
561 GetPhysicsResults(); // Make sure to fetchResults() before shutting down
562 if (convexDesc)
563 {
564 delete convexDesc;
565 convexDesc = NULL;
566 }
567 if (triangleMeshDesc)
568 {
569 delete triangleMeshDesc;
570 triangleMeshDesc = NULL;
571 }
572 if (gScene)
573 {
574 gPhysicsSDK->releaseScene(*gScene);
575 }
576 if (gPhysicsSDK) gPhysicsSDK->release();
577}
578void ResetNx()
579{
580 ReleaseNx();
581 InitNx();
582}
583void StartPhysics()
584{
585 // Update the time step
586 gDeltaTime = getElapsedTime();
587 // Start collision and dynamics for delta time since the last frame
588 gScene->simulate(gDeltaTime);
589 gScene->flushStream();
590}
591void GetPhysicsResults()
592{
593 // Get results from gScene->simulate(gDeltaTime)
594 while (!gScene->fetchResults(NX_RIGID_BODY_FINISHED, false));
595}
596
597void get_settings()
598{
599 XMLDocument doc;
600 XMLElement* xml_root = 0;
601 XMLElement* xml_curr = 0;
602 if (!doc.LoadFile("D:/settings.xml"))
603 {
604 printf("Can't open settings file\n");
605 return;
606 }
607 printf("File loaded\n");
608 xml_root = doc.FirstChildElement("root");
609 xml_curr = xml_root->FirstChildElement("outerCylinderD");
610 outerCylinderD = atof(xml_curr->GetText());
611 xml_curr = xml_root->FirstChildElement("innerCylinderD");
612 innerCylinderD = atof(xml_curr->GetText());
613 xml_curr = xml_root->FirstChildElement("cylinderH");
614 cylinderH = atof(xml_curr->GetText());
615 xml_curr = xml_root->FirstChildElement("cylindersDelta");
616 cylindersDelta = atof(xml_curr->GetText());
617 xml_curr = xml_root->FirstChildElement("sphereDiameter");
618 sphereDiameter = atof(xml_curr->GetText());
619 xml_curr = xml_root->FirstChildElement("sphereDiameterTolerance");
620 sphereDiameterTolerance = atof(xml_curr->GetText());
621 xml_curr = xml_root->FirstChildElement("particlesH");
622 printf("Settings loaded\n");
623}
624
625int main(int argc, char** argv)
626{
627 get_settings();
628 PrintControls();
629 InitGlut(argc, argv);
630 InitNx();
631 glutMainLoop();
632 ReleaseNx();
633 return 0;
634}