PhysX Basics Tutorial: A Simple Bouncing Box

In this tutorial, I will show you how to create a simple box at a specific position and let it bounce under influence of gravity. We will be adding to the code base from the previous tutorials. We first create the PhysX sdk object and store it into a global pointer like this,

#include <iostream>

#include <GL/freeglut.h>

#include <NxPhysics.h>



#pragma comment(lib, "PhysXLoader.lib")



NxPhysicsSDK* gPhysicsSDK = NULL;

NxScene* gScene = NULL;

NxActor* groundPlane; 

NxActor* box; 



NxReal myTimestep = 1.0f/60.0f;



void InitializePhysX() {

   gPhysicsSDK = NxCreatePhysicsSDK(NX_PHYSICS_SDK_VERSION);

   if(gPhysicsSDK == NULL) {

      cerr<<"Error creating PhysX device."<<endl;

      cerr<<"Exiting..."<<endl;

      exit(1);

   }

In the above lines, we just store pointers to the PhysX sdk object, the scene object and two actors (our ground plane and the box) and the timeStep value for stepping the PhysX simulation.

   //Create the scene

   NxSceneDesc sceneDesc;

   sceneDesc.gravity.set(0.0f, -9.8f, 0.0f); 

   gScene = gPhysicsSDK->createScene(sceneDesc);

In PhysX any physics object you want to make, you need to fill a relevant descriptor and then pass that descriptor to the sdk function (through the PhysX sdk pointer) responsible for creating the object for you. In this case, we ask PhysX to set up the global scene gravity to 9.8 m/s^2 The -ve sign is to make it point downwards.

   NxMaterial* defaultMaterial = gScene->getMaterialFromIndex(0);

   defaultMaterial->setRestitution(0.5);

   defaultMaterial->setStaticFriction(0.5);

   defaultMaterial->setDynamicFriction(0.5);



   gScene->setTiming(myTimestep / 4.0f, 4, NX_TIMESTEP_FIXED);

In the above lines, we set the default material's physical properties like static and dynamic friction and the coefficient of restitution. Next, we set the update timing for the PhysX sdk. We ask the sdk to use a fix time stepping. For the simple demo like this, fixed time steps should suffice.
Creating actors

   //Create actors 

   //1) Create ground plane

   NxPlaneShapeDesc planeDesc;

   NxActorDesc actorDesc, actorDesc2;

   actorDesc.shapes.pushBack(&planeDesc);

   gScene->createActor(actorDesc);



   //2) Create cube  

   NxBodyDesc bodyDesc;

   bodyDesc.angularDamping = 0.75f;

   bodyDesc.linearVelocity = NxVec3(0,0,0);

   NxBoxShapeDesc boxDesc;

   boxDesc.dimensions = NxVec3(0.5, 0.5, 0.5);

   actorDesc2.shapes.pushBack(&boxDesc);

   actorDesc2.body   = &bodyDesc;

   actorDesc2.density  = 1.0f;

   actorDesc2.globalPose.t  = NxVec3(0,10,0);

   gScene->createActor(actorDesc2);

}

In the above lines, we create two actors for the ground plane and the box. For each of these actors, their descriptors are filled first to allow us to adjust the parameters. For the ground plane, the default parameters create a ground plane at origin and a positive Y normal direction. Once created, the actor descriptor is given to the scene's createActor function. Next, the same steps are taken for the box. In case of box however the body descriptot is first filled to store the box's linear velocity and angular damping. Then the box's shape descriptor is filled to fill its dimensions. This shape is then adde to the actors shapes list. Next, the actor descriptor sets the body, density and the initial position (globalPose.t). Finally, the createActor function is invoked again. Thats it, we have successfully added the two actors to the PhysX engine.

Handling PhysX stepping loop
Once the actor stuff is done, the next thing we need to handle is the PhysX loop. This will allow the simulation to step ahead in time. We will implement an asynchronous loop which can be done using the following lines of code.

void StepPhysX() 

{ 

   gScene->simulate(myTimestep);        

   gScene->flushStream();        

   //...perform useful work here using previous frame's state data        

   while(!gScene->fetchResults(NX_RIGID_BODY_FINISHED, false) )     

   {

      // do something useful        

   }

} 

These lines were copied directly from the documentation so rather than commenting anything on these, I would ask you to go and read the asynchronous loop section in the PhysX documentation. We will call this function once from our display function.

Rendering of Actors
The next step is to render the actors. To make easier for use to work with PhysX, I have modularized the code into functions. First, the RenderActors() function is implemented as follows,

void RenderActors() 

{ 

    // Render all the actors in the scene 

    int nbActors = gScene->getNbActors(); 

    NxActor** actors = gScene->getActors(); 

    while (nbActors--) 

    { 

        NxActor* actor = *actors++; 

        DrawActor(actor); 

    } 

} 

Nothing fancy here, we first query the scene for the total number of actors it contains. Then, we loop through each actor and draw it by calling the DrawActor function. The DrawActor function is implemented as follows,

 

void DrawActor(NxActor* actor) 

{ 

    NxShape* const* shapes = actor->getShapes(); 

    NxU32 nShapes = actor->getNbShapes(); 

     

    while (nShapes--) 

    { 

        DrawShape(shapes[nShapes]); 

    } 

} 

It looks a lot like the previous function doesn't it. It basically ask the actor for the number of shapes it has and then calls the DrawShapes function with the shape parameter. The DrawShape function is implemented as follows,

void DrawShape(NxShape* shape) 

{ 

   int type = shape->getType();

   switch(type) 

   {          

      case NX_SHAPE_BOX:

         DrawBox(shape);

      break;

   } 

} 

This function first identifies the type of the shape and then uses a switch case to call the appropriate Draw function. For our case, we check for the Box object and then call the DrawBox function passing it the shape parameter. THe DrawBox function is implemented as follows,

void DrawBox(NxShape* pShape) {

   NxMat34 pose = pShape->getGlobalPose(); 

   float mat[16];

   pose.getColumnMajor44(mat);

   glPushMatrix(); 

      glMultMatrixf(mat);

      glutSolidCube(1);

   glPopMatrix(); 

}

The DrawBox function gets the current Global pose (basically the shapes tranform matrix) and then converts it into a column major form (so that we can pass this matrix to OpenGL). Next, the currnet transformation matrix is stored (glPushMatrix) and then the box's matrix is multiplied to the current matrix. Then, we draw the box's geometry (using the glutSolitCube function) and finally revert the old transformation back by calling glPopMatrix.

The Display Function
Now after these function definitions, the display function becomes this,

void Display() {

   glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

   glLoadIdentity();

   //setup the view transformation using 

   //gluLookAt(...);



   //Update PhysX 

   if (gScene) 

   { 

       StepPhysX(); 

   }   



   RenderActors();



   glutSwapBuffers();

}

That's it. Attached is the complete source code for this tutorial. Here is the snapshot of the application.


Source code for this tutorial