Triangles.cpp

Go to the documentation of this file.

/*
 * Triangles.cpp
 *
 * Copyright (C) 2009  Thomas A. Vaughan
 * All rights reserved.
 *
 * Quick demo to test loading of triangle meshes.
 */

#include "physics-demo/physics-demo.h"

#include <fstream>

#include "DemoApplication.h"
#include "GLDebugDrawer.h"              // bullet demo file

#include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h"
#include "BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h"

#include "common/wave_ex.h"
#include "geometry/geometry_3d.h"
#include "threadsafe/smart_ptr.h"
#include "trimesh/trimesh.h"
#include "util/token_stream.h"



static void
dumpVector
(
IN const btVector3& v,
IN const char * title
)
throw()
{
        ASSERT(title, "null");

        DPRINTF("%s: (%f, %f, %f)", title, v.x(), v.y(), v.z());
}



//
//      Triangles class -- Demo class for triangle mesh functionality
//

class Triangles : public DemoApplication {
public:
        // DemoApplication class interface methods -----------------------------
        virtual void clientMoveAndDisplay();
        virtual void displayCallback();
        virtual void keyboardCallback(unsigned char key, int x, int y);
        virtual void initPhysics(void) {}

        // static factory methods ----------------------------------------------        
        static DemoApplication * create(IN const char * filename) {
                        ASSERT(filename, "null");
                        Triangles * tri = new Triangles();
                        ASSERT(tri, "out of memory");
                        tri->initialize(filename);
                        return tri;
                }

private:
        // private helper methods ----------------------------------------------
        void initialize(IN const char * filename);

        // private member data -------------------------------------------------
        btAlignedObjectArray<btCollisionShape*> m_collisionShapes;
        smart_ptr<btTriangleIndexVertexArray>   m_indexVertexArrays;
        smart_ptr<btBroadphaseInterface>        m_broadphase;
        smart_ptr<btCollisionDispatcher>        m_dispatcher;
        smart_ptr<btConstraintSolver>           m_solver;
        smart_ptr<btDefaultCollisionConfiguration> m_collisionConfiguration;
        smart_ptr<GLDebugDrawer>                m_debugDrawer;
        smart_ptr<trimesh::Trimesh>             m_trimesh;
};

void Triangles::keyboardCallback(unsigned char key, int x, int y)
{
    DemoApplication::keyboardCallback(key,x,y);

}

void
Triangles::initialize
(
IN const char * filename
)
{
        ASSERT(filename, "null");

        // get the data
        m_trimesh = trimesh::Trimesh::load(filename);
        ASSERT(m_trimesh, "failed to create triangle mesh object");

        // set up the world
        m_collisionConfiguration = new btDefaultCollisionConfiguration();
        m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration);
        btVector3 worldMin(-1000,-1000,-1000);
        btVector3 worldMax(1000,1000,1000);
        m_broadphase = new btAxisSweep3(worldMin,worldMax);
        m_solver = new btSequentialImpulseConstraintSolver();
        m_dynamicsWorld = new btDiscreteDynamicsWorld(m_dispatcher,m_broadphase,m_solver,m_collisionConfiguration);

        // Create the array structure
        int triangleStride = 3 * sizeof(int);
        int vertexStride = sizeof(point3d_t);
        m_indexVertexArrays = new btTriangleIndexVertexArray(
            m_trimesh->getTriangleCount(), (int *) m_trimesh->getTriangleArray(), triangleStride,
            m_trimesh->getVertexCount(), (btScalar *) m_trimesh->getVertexArray(), vertexStride);
        ASSERT(m_indexVertexArrays, "out of memory");

        // Create the triangle mesh shape
        btBvhTriangleMeshShape * mesh = new btBvhTriangleMeshShape(m_indexVertexArrays, true);
        ASSERT(mesh, "out of memory");

        m_collisionShapes.push_back(mesh);

        btCollisionShape * groundShape = mesh;

        // add to world
        btTransform T;
        T.setIdentity();
        btRigidBody * ground = this->localCreateRigidBody(0.0, T, groundShape);
        ASSERT(ground, "null");

        // debug
        float invmass = ground->getInvMass();
        DPRINTF("Inverse mass: %f", invmass);
        btVector3 v = ground->getCenterOfMassPosition();
        dumpVector(v, "center of mass");
        btVector3 min, max;
        ground->getAabb(min, max);
        DPRINTF("AABB: (%f, %f, %f) - (%f, %f, %f)",
            min.x(), min.y(), min.z(), max.x(), max.y(), max.z());
        DPRINTF("ground %s in world", ground->isInWorld() ? "is" : "is NOT");

        // set up debug drawing
        m_debugDrawer = new GLDebugDrawer;
        ASSERT(m_debugDrawer, "null");
        this->getDynamicsWorld()->setDebugDrawer(m_debugDrawer);
}



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

    float dt = getDeltaTimeMicroseconds() * 0.000001f;

    m_dynamicsWorld->stepSimulation(dt);

    //optional but useful: debug drawing
    m_dynamicsWorld->debugDrawWorld();

    renderme();

    glFlush();
    glutSwapBuffers();
}




void Triangles::displayCallback(void) {

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

    renderme();

    glFlush();
    glutSwapBuffers();
}



//
//      entry point
//

int
main
(
IN int argc,
IN char ** argv
)
{
        ASSERT(2 == argc, "usage: physics-demo-Triangles <data-file>");
        const char * filename = argv[1];

        DemoApplication * demo = Triangles::create(filename);
        ASSERT(demo, "null");

        return glutmain(argc, argv, 640, 480, "Triangles Demo", demo);
}