reactphysics3d/examples/fallingcubes/main.cpp

/********************************************************************************
* ReactPhysics3D physics library, http://code.google.com/p/reactphysics3d/      *
* Copyright (c) 2010-2013 Daniel Chappuis                                       *
*********************************************************************************
*                                                                               *
* This software is provided 'as-is', without any express or implied warranty.   *
* In no event will the authors be held liable for any damages arising from the  *
* use of this software.                                                         *
*                                                                               *
* Permission is granted to anyone to use this software for any purpose,         *
* including commercial applications, and to alter it and redistribute it        *
* freely, subject to the following restrictions:                                *
*                                                                               *
* 1. The origin of this software must not be misrepresented; you must not claim *
*    that you wrote the original software. If you use this software in a        *
*    product, an acknowledgment in the product documentation would be           *
*    appreciated but is not required.                                           *
*                                                                               *
* 2. Altered source versions must be plainly marked as such, and must not be    *
*    misrepresented as being the original software.                             *
*                                                                               *
* 3. This notice may not be removed or altered from any source distribution.    *
*                                                                               *
********************************************************************************/

// Libraries
#include <stdlib.h>
#include <reactphysics3d.h>
#include "Box.h"

// Prototypes
void init();
void display();
void simulate();
void clean();
void reshape(int w, int h);

// Use the ReactPhysics3D namespace
using namespace reactphysics3d;

// Constants
const double FLOOR_SIZE = 20;
const double FLOOR_THICKNESS = 0.02;

// Global variables
DynamicsWorld* dynamicsWorld;   // Dynamics world
Box* boxes[2];                  // Falling boxes
BoxShape* collisionShapeBox1;   // Collision shape of the first box
BoxShape* collisionShapeBox2;   // Collision shape of the second box
BoxShape* collisionShapeFloor;  // Collision shape of the floor
RigidBody* floorRigidBody;      // Rigid body corresponding the floor


// Simulation function
void simulate() {

    // Update the physics simulation
    dynamicsWorld->update();

    // Display the scene
    display();
}

// Main function
int main(int argc, char** argv) {

    // Initialize GLUT
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
    glutInitWindowSize(800, 600);
    glutInitWindowPosition(100, 100);
    glutCreateWindow("ReactPhysics3D Example - Falling Cubes");

    init();

    glutIdleFunc(simulate);
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutMainLoop();

    // Stop the physics simulation
    dynamicsWorld->stop();

    clean();
    
    return 0;
}

// Initialization function
void init() {

    glClearColor(0.0, 0.0, 0.0, 0.0);

    // Light
    glShadeModel(GL_SMOOTH);
    GLfloat light_position[] = {5.0f, 5.0f, 5.0f, 1.0f};
    glLightfv(GL_LIGHT0, GL_POSITION, light_position);

    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glEnable(GL_DEPTH_TEST);

    // Gravity vector of the physics world
    Vector3 gravity(0.0, -9.81, 0.0);

    // Timestep of the simulation
    decimal timeStep = 1.0/60.0;

    // Create the dynamics world
    dynamicsWorld = new DynamicsWorld(gravity, timeStep);

    // --- Create a falling box with a size of 1m and weight of 3kg --- //

    float size = 1.0f;

    // Initial position and orientation of the box
    Vector3 positionBox1(-2.0f, 7.0f, 0.0f);
    Quaternion orientationBox1(0.3, 1.0, 0.8, 0.0);
    Transform initTransform(positionBox1, orientationBox1);

    // Create a box collision shape for the box (used for collision detection)
    collisionShapeBox1 = new BoxShape(Vector3(size/2.0f, size/2.0f, size/2.0f));

    // Compute the inertia tensor of the box using the collision shape
    Matrix3x3 inertiaTensorBox1;
    float massBox1 = 3.0f;
    collisionShapeBox1->computeLocalInertiaTensor(inertiaTensorBox1, massBox1);

    // Create the rigid body associated with the box in the dynamics world
    RigidBody* rigidBody = dynamicsWorld->createRigidBody(initTransform, massBox1,
                                                          inertiaTensorBox1, collisionShapeBox1);

    // Set the contact velocity restitution factor of the rigid body
    rigidBody->setRestitution(0.5f);

    // Create the box object (used for display)
    boxes[0] = new Box(size, rigidBody);

    // --- Create a second falling box with a size of 1.5m and weight of 4.5kg --- //

    size = 1.5;

    // Initial position and orientation of the box
    Vector3 positionBox2(2.0, 4.0, 0.0);
    Quaternion orientationBox2(1.0, 1.0, 0.5, 0.0);
    Transform initTransform2(positionBox2, orientationBox2);

    // Create a box collision shape for the box (used for collision detection)
    collisionShapeBox2 = new BoxShape(Vector3(size/2.0f, size/2.0f, size/2.0f));

    // Compute the inertia tensor using the collision shape
    Matrix3x3 inertiaTensorBox2;
    float massBox2 = 4.5f;
    collisionShapeBox2->computeLocalInertiaTensor(inertiaTensorBox2, massBox2);

    // Create the rigid body associated with the box in the dynamcis world
    RigidBody* rigidBody2 = dynamicsWorld->createRigidBody(initTransform2, massBox2,
                                                           inertiaTensorBox2, collisionShapeBox2);

    // Set the contact velocity restitution factor of the rigid body
    rigidBody2->setRestitution(0.5);

    // Create the box object (used for display)
    boxes[1] = new Box(size, rigidBody2);

    // --- Create the rigid body corresponding to the floor --- //

    // Initial position and orientation of the floor
    Vector3 positionFloor(0.0, 0.0, 0.0);
    Quaternion orientationFloor(0.0, 1.0, 0.0, 0.0);
    Transform initTransformFloor(positionFloor, orientationFloor);

    // Create a box collision shape for the floor (used for collision detection)
    collisionShapeFloor = new BoxShape(Vector3(FLOOR_SIZE, FLOOR_THICKNESS, FLOOR_SIZE));

    // Compute the inertia tensor of the floor using the collision shape
    float massFloor = 100.0f;
    rp3d::Matrix3x3 inertiaTensorFloor;
    collisionShapeFloor->computeLocalInertiaTensor(inertiaTensorFloor, massFloor);

    // Create the rigid body associated with the floor in the dynamcis world
    floorRigidBody = dynamicsWorld->createRigidBody(initTransformFloor, massFloor,
                                                    inertiaTensorFloor, collisionShapeFloor);

    // The floor is a rigid body that cannot move
    floorRigidBody->setIsMotionEnabled(false);

    // Set the contact velocity restitution factor of the floor
    floorRigidBody->setRestitution(0.5);

    // Start the dynamics simulation
    dynamicsWorld->start();
}

// Display function
void display() {

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // Display each falling box of the scene
    for (int i=0; i<2; i++) {
        boxes[i]->draw();
    }

    // Display the plane for the floor
    glBegin(GL_POLYGON);
        glNormal3f(0.0, 1.0, 0.0);
        glVertex3f(-FLOOR_SIZE/2, 0.0, -FLOOR_SIZE/2);
        glVertex3f(-FLOOR_SIZE/2, 0.0, FLOOR_SIZE/2);
        glVertex3f(FLOOR_SIZE/2, 0.0, FLOOR_SIZE/2);
        glVertex3f(FLOOR_SIZE/2, 0.0, -FLOOR_SIZE/2);
    glEnd();

    glutSwapBuffers();
}

// Reshape function
void reshape(int w, int h) {
    float ratio = ((float)w / h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glViewport(0, 0, w, h);
    gluPerspective(45, ratio,1,1000);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(20.0, 4.0, 20.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
}

// Clean the memory allocation
void clean() {

    // Destroy the rigid bodies from the dynamics world
    dynamicsWorld->destroyRigidBody(boxes[0]->getRigidBodyPointer());
    dynamicsWorld->destroyRigidBody(boxes[1]->getRigidBodyPointer());
    dynamicsWorld->destroyRigidBody(floorRigidBody);

    // Destroy the dynamics world
    delete dynamicsWorld;

    // Destroy the boxes
    delete boxes[0];
    delete boxes[1];

    // Destroy the collision shapes
    delete collisionShapeBox1;
    delete collisionShapeBox2;
    delete collisionShapeFloor;
}