source: proiecte/SIMEO/Simeo/src/SimeoEngine/SimpleDemo.cpp @ 167

///create 125 (5x5x5) dynamic object
#include "SimpleDemo.h"
#include "btBulletDynamicsCommon.h"
#include "GLDebugDrawer.h"

#include <mpi.h>
#include <stdio.h>
#include <map>
#include <string>
#include <vector>

using namespace std;

btCollisionShape* groundShape;
btTransform groundTransform;
btCollisionShape* colShape;

bool enable1, enable2;
bool simpleSimulation;
bool debugConstraints;


void SimpleDemo::clientMoveAndDisplay()
{
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        //simple dynamics world doesn't handle fixed-time-stepping
        float ms = getDeltaTimeMicroseconds();
        ///step the simulation
        if (m_dynamicsWorld)
        {
                m_dynamicsWorld->stepSimulation(ms / 1000000.f);
                //optional but useful: debug drawing
                m_dynamicsWorld->debugDrawWorld();
        }

        renderme();

        glFlush();
        glutSwapBuffers();
}


void SimpleDemo::displayCallback(void) {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        renderme();
        //optional but useful: debug drawing to detect problems
        if (m_dynamicsWorld)
                m_dynamicsWorld->debugDrawWorld();
        glFlush();
        glutSwapBuffers();
}

void SimpleDemo::initPhysics() {

        m_ele = 75;
        updateCamera();

        setTexturing(true);
        setShadows(true);
        setCameraDistance(btScalar(40.));

        m_collisionConfiguration = new btDefaultCollisionConfiguration();
        m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration);
        m_broadphase = new btDbvtBroadphase();
        btSequentialImpulseConstraintSolver* sol = new btSequentialImpulseConstraintSolver;
        m_solver = sol;

        m_dynamicsWorld = new btDiscreteDynamicsWorld(m_dispatcher,m_broadphase,m_solver,m_collisionConfiguration);
        m_dynamicsWorld->setGravity(btVector3(0,-10,0));

        groundShape = new btBoxShape(btVector3(btScalar(50.),btScalar(50.),btScalar(50.)));
        m_collisionShapes.push_back(groundShape);

        groundTransform.setIdentity();
        groundTransform.setOrigin(btVector3(0,-50,0));

        btScalar mass(0.);
        //rigidbody is dynamic if and only if mass is non zero, otherwise static
        bool isDynamic = (mass != 0.f);
        btVector3 localInertia(0,0,0);
        if (isDynamic)
                groundShape->calculateLocalInertia(mass,localInertia);

        //using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
        btDefaultMotionState* myMotionState = new btDefaultMotionState(groundTransform);
        btRigidBody::btRigidBodyConstructionInfo rbInfo(mass,myMotionState,groundShape,localInertia);
        btRigidBody* body = new btRigidBody(rbInfo);

        //add the body to the dynamics world
        m_dynamicsWorld->addRigidBody(body);

        m_dynamicsWorld->setDebugDrawer(new GLDebugDrawer());
}

void SimpleDemo::exitPhysics()
{
        int i;
        for (i=m_dynamicsWorld->getNumCollisionObjects()-1; i>=0 ;i--)
        {
                btCollisionObject* obj = m_dynamicsWorld->getCollisionObjectArray()[i];
                btRigidBody* body = btRigidBody::upcast(obj);
                if (body && body->getMotionState())
                {
                        delete body->getMotionState();
                }
                m_dynamicsWorld->removeCollisionObject( obj );
                delete obj;
        }

        //delete collision shapes
        for (int j=0;j<m_collisionShapes.size();j++)
        {
                btCollisionShape* shape = m_collisionShapes[j];
                delete shape;
        }

        delete m_dynamicsWorld;
        delete m_solver;
        delete m_broadphase;
        delete m_dispatcher;
        delete m_collisionConfiguration;
}