Add Concave Mesh scene in testbed application

testbed/CMakeLists.txt

@@ -66,6 +66,8 @@ SET(COMMON_SOURCES
     common/Capsule.cpp
     common/ConvexMesh.h
     common/ConvexMesh.cpp
+    common/ConcaveMesh.h
+    common/ConcaveMesh.cpp
     common/Cylinder.h
     common/Cylinder.cpp
     common/Dumbbell.h
@@ -86,6 +88,8 @@ SET(SCENES_SOURCES
     scenes/raycast/RaycastScene.cpp
     scenes/collisionshapes/CollisionShapesScene.h
     scenes/collisionshapes/CollisionShapesScene.cpp
+    scenes/concavemesh/ConcaveMeshScene.h
+    scenes/concavemesh/ConcaveMeshScene.cpp
 )
 
 # Create the executable

testbed/common/ConcaveMesh.cpp

@@ -0,0 +1,345 @@
+/********************************************************************************
+* ReactPhysics3D physics library, http://www.reactphysics3d.com                 *
+* Copyright (c) 2010-2015 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 "ConcaveMesh.h"
+
+// Constructor
+ConcaveMesh::ConcaveMesh(const openglframework::Vector3 &position,
+                       reactphysics3d::CollisionWorld* world,
+                       const std::string& meshFolderPath)
+           : openglframework::Mesh(), mVBOVertices(GL_ARRAY_BUFFER),
+             mVBONormals(GL_ARRAY_BUFFER), mVBOTextureCoords(GL_ARRAY_BUFFER),
+             mVBOIndices(GL_ELEMENT_ARRAY_BUFFER) {
+
+    // Load the mesh from a file
+    openglframework::MeshReaderWriter::loadMeshFromFile(meshFolderPath + "concavemesh.obj", *this);
+
+    // Calculate the normals of the mesh
+    calculateNormals();
+
+    // Initialize the position where the sphere will be rendered
+    translateWorld(position);
+
+    // Convert the vertices array to the rp3d::decimal type
+    /*rp3d::decimal* vertices = new rp3d::decimal[3 * mVertices.size()];
+    for (int i=0; i < mVertices.size(); i++) {
+        vertices[3 * i] = static_cast<rp3d::decimal>(mVertices[i].x);
+        vertices[3 * i + 1] = static_cast<rp3d::decimal>(mVertices[i].y);
+        vertices[3 * i + 2] = static_cast<rp3d::decimal>(mVertices[i].z);
+    }
+    */
+
+    // For each subpart of the mesh
+    for (int i=0; i<getNbParts(); i++) {
+
+        // Vertex and Indices array for the triangle mesh (data in shared and not copied)
+        rp3d::TriangleVertexArray* vertexArray =
+                new rp3d::TriangleVertexArray(getNbVertices(), &(mVertices[0]), sizeof(openglframework::Vector3),
+                                              getNbFaces(i), &(mIndices[i][0]), sizeof(int),
+                                              rp3d::TriangleVertexArray::VERTEX_FLOAT_TYPE,
+                                              rp3d::TriangleVertexArray::INDEX_INTEGER_TYPE);
+
+        // Add the triangle vertex array of the subpart to the triangle mesh
+        mPhysicsTriangleMesh.addSubpart(vertexArray);
+    }
+
+    // Create the collision shape for the rigid body (convex mesh shape) and
+    // do not forget to delete it at the end
+    mCollisionShape = new rp3d::ConcaveMeshShape(&mPhysicsTriangleMesh);
+
+    //delete[] vertices;
+
+    /*
+    // Add the edges information of the mesh into the convex mesh collision shape.
+    // This is optional but it really speed up the convex mesh collision detection at the
+    // cost of some additional memory to store the edges inside the collision shape.
+    for (unsigned int i=0; i<getNbFaces(); i++) { // For each triangle face of the mesh
+
+        // Get the three vertex IDs of the vertices of the face
+        unsigned int v1 = getVertexIndexInFace(i, 0);
+        unsigned int v2 = getVertexIndexInFace(i, 1);
+        unsigned int v3 = getVertexIndexInFace(i, 2);
+
+        // Add the three edges into the collision shape
+        mCollisionShape->addEdge(v1, v2);
+        mCollisionShape->addEdge(v1, v3);
+        mCollisionShape->addEdge(v2, v3);
+    }
+    mCollisionShape->setIsEdgesInformationUsed(true);// Enable the fast collision detection with edges
+    */
+
+    // Initial position and orientation of the rigid body
+    rp3d::Vector3 initPosition(position.x, position.y, position.z);
+    rp3d::Quaternion initOrientation = rp3d::Quaternion::identity();
+    rp3d::Transform transform(initPosition, initOrientation);
+
+    mPreviousTransform = transform;
+
+    // Create a rigid body corresponding to the sphere in the dynamics world
+    mBody = world->createCollisionBody(transform);
+
+    // Add a collision shape to the body and specify the mass of the collision shape
+    mBody->addCollisionShape(mCollisionShape, rp3d::Transform::identity());
+
+    // Create the VBOs and VAO
+    createVBOAndVAO();
+}
+
+// Constructor
+ConcaveMesh::ConcaveMesh(const openglframework::Vector3 &position, float mass,
+                       reactphysics3d::DynamicsWorld* dynamicsWorld,
+                       const std::string& meshFolderPath)
+           : openglframework::Mesh(), mVBOVertices(GL_ARRAY_BUFFER),
+             mVBONormals(GL_ARRAY_BUFFER), mVBOTextureCoords(GL_ARRAY_BUFFER),
+             mVBOIndices(GL_ELEMENT_ARRAY_BUFFER) {
+
+    // Load the mesh from a file
+    openglframework::MeshReaderWriter::loadMeshFromFile(meshFolderPath + "concavemesh.obj", *this);
+
+    // Calculate the normals of the mesh
+    calculateNormals();
+
+    // Initialize the position where the sphere will be rendered
+    translateWorld(position);
+
+    /*
+    // Convert the vertices array to the rp3d::decimal type
+    rp3d::decimal* vertices = new rp3d::decimal[3 * mVertices.size()];
+    for (int i=0; i < mVertices.size(); i++) {
+        vertices[3 * i] = static_cast<rp3d::decimal>(mVertices[i].x);
+        vertices[3 * i + 1] = static_cast<rp3d::decimal>(mVertices[i].y);
+        vertices[3 * i + 2] = static_cast<rp3d::decimal>(mVertices[i].z);
+    }
+    */
+
+    // For each subpart of the mesh
+    for (int i=0; i<getNbParts(); i++) {
+
+        // Vertex and Indices array for the triangle mesh (data in shared and not copied)
+        rp3d::TriangleVertexArray* vertexArray =
+                new rp3d::TriangleVertexArray(getNbVertices(), &(mVertices[0]), sizeof(openglframework::Vector3),
+                                              getNbFaces(i), &(mIndices[i][0]), sizeof(int),
+                                              rp3d::TriangleVertexArray::VERTEX_FLOAT_TYPE,
+                                              rp3d::TriangleVertexArray::INDEX_INTEGER_TYPE);
+
+        // Add the triangle vertex array of the subpart to the triangle mesh
+        mPhysicsTriangleMesh.addSubpart(vertexArray);
+    }
+
+    // Create the collision shape for the rigid body (convex mesh shape) and
+    // do not forget to delete it at the end
+    mCollisionShape = new rp3d::ConcaveMeshShape(&mPhysicsTriangleMesh);
+
+    //delete[] vertices;
+
+    /*
+    // Add the edges information of the mesh into the convex mesh collision shape.
+    // This is optional but it really speed up the convex mesh collision detection at the
+    // cost of some additional memory to store the edges inside the collision shape.
+    for (unsigned int i=0; i<getNbFaces(); i++) { // For each triangle face of the mesh
+
+        // Get the three vertex IDs of the vertices of the face
+        unsigned int v1 = getVertexIndexInFace(i, 0);
+        unsigned int v2 = getVertexIndexInFace(i, 1);
+        unsigned int v3 = getVertexIndexInFace(i, 2);
+
+        // Add the three edges into the collision shape
+        mCollisionShape->addEdge(v1, v2);
+        mCollisionShape->addEdge(v1, v3);
+        mCollisionShape->addEdge(v2, v3);
+    }
+    mCollisionShape->setIsEdgesInformationUsed(true);// Enable the fast collision detection with edges
+    */
+
+    // Initial position and orientation of the rigid body
+    rp3d::Vector3 initPosition(position.x, position.y, position.z);
+    rp3d::Quaternion initOrientation = rp3d::Quaternion::identity();
+    rp3d::Transform transform(initPosition, initOrientation);
+
+    // Create a rigid body corresponding to the sphere in the dynamics world
+    rp3d::RigidBody* body = dynamicsWorld->createRigidBody(transform);
+
+    // Add a collision shape to the body and specify the mass of the collision shape
+    body->addCollisionShape(mCollisionShape, rp3d::Transform::identity(), mass);
+
+    mBody = body;
+
+    // Create the VBOs and VAO
+    createVBOAndVAO();
+}
+
+// Destructor
+ConcaveMesh::~ConcaveMesh() {
+
+    // Destroy the triangle mesh data for the physics engine
+    for (int i=0; i<mPhysicsTriangleMesh.getNbSubparts(); i++) {
+        delete mPhysicsTriangleMesh.getSubpart(i);
+    }
+
+    // Destroy the mesh
+    destroy();
+
+    // Destroy the VBOs and VAO
+    mVBOIndices.destroy();
+    mVBOVertices.destroy();
+    mVBONormals.destroy();
+    mVBOTextureCoords.destroy();
+    mVAO.destroy();
+
+    delete mCollisionShape;
+}
+
+// Render the sphere at the correct position and with the correct orientation
+void ConcaveMesh::render(openglframework::Shader& shader,
+                    const openglframework::Matrix4& worldToCameraMatrix) {
+
+    // Bind the shader
+    shader.bind();
+
+    // Set the model to camera matrix
+    shader.setMatrix4x4Uniform("localToWorldMatrix", mTransformMatrix);
+    shader.setMatrix4x4Uniform("worldToCameraMatrix", worldToCameraMatrix);
+
+    // Set the normal matrix (inverse transpose of the 3x3 upper-left sub matrix of the
+    // model-view matrix)
+    const openglframework::Matrix4 localToCameraMatrix = worldToCameraMatrix * mTransformMatrix;
+    const openglframework::Matrix3 normalMatrix =
+                       localToCameraMatrix.getUpperLeft3x3Matrix().getInverse().getTranspose();
+    shader.setMatrix3x3Uniform("normalMatrix", normalMatrix, false);
+
+    // Set the vertex color
+    openglframework::Vector4 color(mColor.r, mColor.g, mColor.b, mColor.a);
+    shader.setVector4Uniform("vertexColor", color, false);
+
+    // Bind the VAO
+    mVAO.bind();
+
+    mVBOVertices.bind();
+
+    // Get the location of shader attribute variables
+    GLint vertexPositionLoc = shader.getAttribLocation("vertexPosition");
+    GLint vertexNormalLoc = shader.getAttribLocation("vertexNormal", false);
+
+    glEnableVertexAttribArray(vertexPositionLoc);
+    glVertexAttribPointer(vertexPositionLoc, 3, GL_FLOAT, GL_FALSE, 0, (char*)NULL);
+
+    mVBONormals.bind();
+
+    if (vertexNormalLoc != -1) glVertexAttribPointer(vertexNormalLoc, 3, GL_FLOAT, GL_FALSE, 0, (char*)NULL);
+    if (vertexNormalLoc != -1) glEnableVertexAttribArray(vertexNormalLoc);
+
+    // For each part of the mesh
+    for (unsigned int i=0; i<getNbParts(); i++) {
+        glDrawElements(GL_TRIANGLES, getNbFaces(i) * 3, GL_UNSIGNED_INT, (char*)NULL);
+    }
+
+    glDisableVertexAttribArray(vertexPositionLoc);
+    if (vertexNormalLoc != -1) glDisableVertexAttribArray(vertexNormalLoc);
+
+    mVBONormals.unbind();
+    mVBOVertices.unbind();
+
+    // Unbind the VAO
+    mVAO.unbind();
+
+    // Unbind the shader
+    shader.unbind();
+}
+
+// Create the Vertex Buffer Objects used to render with OpenGL.
+/// We create two VBOs (one for vertices and one for indices)
+void ConcaveMesh::createVBOAndVAO() {
+
+    // Create the VBO for the vertices data
+    mVBOVertices.create();
+    mVBOVertices.bind();
+    size_t sizeVertices = mVertices.size() * sizeof(openglframework::Vector3);
+    mVBOVertices.copyDataIntoVBO(sizeVertices, getVerticesPointer(), GL_STATIC_DRAW);
+    mVBOVertices.unbind();
+
+    // Create the VBO for the normals data
+    mVBONormals.create();
+    mVBONormals.bind();
+    size_t sizeNormals = mNormals.size() * sizeof(openglframework::Vector3);
+    mVBONormals.copyDataIntoVBO(sizeNormals, getNormalsPointer(), GL_STATIC_DRAW);
+    mVBONormals.unbind();
+
+    if (hasTexture()) {
+        // Create the VBO for the texture co data
+        mVBOTextureCoords.create();
+        mVBOTextureCoords.bind();
+        size_t sizeTextureCoords = mUVs.size() * sizeof(openglframework::Vector2);
+        mVBOTextureCoords.copyDataIntoVBO(sizeTextureCoords, getUVTextureCoordinatesPointer(), GL_STATIC_DRAW);
+        mVBOTextureCoords.unbind();
+    }
+
+    // Create th VBO for the indices data
+    mVBOIndices.create();
+    mVBOIndices.bind();
+    size_t sizeIndices = mIndices[0].size() * sizeof(unsigned int);
+    mVBOIndices.copyDataIntoVBO(sizeIndices, getIndicesPointer(), GL_STATIC_DRAW);
+    mVBOIndices.unbind();
+
+    // Create the VAO for both VBOs
+    mVAO.create();
+    mVAO.bind();
+
+    // Bind the VBO of vertices
+    mVBOVertices.bind();
+
+    // Bind the VBO of normals
+    mVBONormals.bind();
+
+    if (hasTexture()) {
+        // Bind the VBO of texture coords
+        mVBOTextureCoords.bind();
+    }
+
+    // Bind the VBO of indices
+    mVBOIndices.bind();
+
+    // Unbind the VAO
+    mVAO.unbind();
+}
+
+// Reset the transform
+void ConcaveMesh::resetTransform(const rp3d::Transform& transform) {
+
+    // Reset the transform
+    mBody->setTransform(transform);
+
+    mBody->setIsSleeping(false);
+
+    // Reset the velocity of the rigid body
+    rp3d::RigidBody* rigidBody = dynamic_cast<rp3d::RigidBody*>(mBody);
+    if (rigidBody != NULL) {
+        rigidBody->setLinearVelocity(rp3d::Vector3(0, 0, 0));
+        rigidBody->setAngularVelocity(rp3d::Vector3(0, 0, 0));
+    }
+
+    updateTransform(1.0f);
+}
+

testbed/common/ConcaveMesh.h

@@ -0,0 +1,101 @@
+/********************************************************************************
+* ReactPhysics3D physics library, http://www.reactphysics3d.com                 *
+* Copyright (c) 2010-2015 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.    *
+*                                                                               *
+********************************************************************************/
+
+#ifndef CONCAVE_MESH_H
+#define CONCAVE_MESH_H
+
+// Libraries
+#include "openglframework.h"
+#include "reactphysics3d.h"
+#include "PhysicsObject.h"
+
+// Class ConcaveMesh
+class ConcaveMesh : public openglframework::Mesh, public PhysicsObject {
+
+    private :
+
+        // -------------------- Attributes -------------------- //
+
+        /// Previous transform (for interpolation)
+        rp3d::Transform mPreviousTransform;
+
+        /// Collision shape
+        rp3d::ConcaveMeshShape* mCollisionShape;
+
+        /// Vertex Buffer Object for the vertices data
+        openglframework::VertexBufferObject mVBOVertices;
+
+        /// Vertex Buffer Object for the normals data
+        openglframework::VertexBufferObject mVBONormals;
+
+        /// Vertex Buffer Object for the texture coords
+        openglframework::VertexBufferObject mVBOTextureCoords;
+
+        /// Vertex Buffer Object for the indices
+        openglframework::VertexBufferObject mVBOIndices;
+
+        /// Vertex Array Object for the vertex data
+        openglframework::VertexArrayObject mVAO;
+
+        /// Structure with pointer to the shared mesh data (vertices, indices, ...)
+        rp3d::TriangleMesh mPhysicsTriangleMesh;
+
+        // -------------------- Methods -------------------- //
+
+        // Create the Vertex Buffer Objects used to render with OpenGL.
+        void createVBOAndVAO();
+
+    public :
+
+        // -------------------- Methods -------------------- //
+
+        /// Constructor
+        ConcaveMesh(const openglframework::Vector3& position,
+                   rp3d::CollisionWorld* world, const std::string& meshFolderPath);
+
+        /// Constructor
+        ConcaveMesh(const openglframework::Vector3& position, float mass,
+                   rp3d::DynamicsWorld* dynamicsWorld, const std::string& meshFolderPath);
+
+        /// Destructor
+        ~ConcaveMesh();
+
+        /// Render the mesh at the correct position and with the correct orientation
+        void render(openglframework::Shader& shader,
+                    const openglframework::Matrix4& worldToCameraMatrix);
+
+        /// Set the position of the box
+        void resetTransform(const rp3d::Transform& transform);
+
+        /// Update the transform matrix of the object
+        virtual void updateTransform(float interpolationFactor);
+};
+
+// Update the transform matrix of the object
+inline void ConcaveMesh::updateTransform(float interpolationFactor) {
+    mTransformMatrix = computeTransform(interpolationFactor, openglframework::Matrix4::identity());
+}
+
+#endif

testbed/meshes/concavemesh.obj

@@ -0,0 +1,9 @@
+# Blender v2.72 (sub 0) OBJ File: ''
+# www.blender.org
+v -10.000000 0.000000 10.000000
+v 10.000000 0.000000 10.000000
+v -10.000000 0.000000 -10.000000
+v 10.000000 0.000000 -10.000000
+s off
+f 2 4 3
+f 1 2 3

testbed/scenes/concavemesh/ConcaveMeshScene.cpp

@@ -0,0 +1,171 @@
+
+/********************************************************************************
+* ReactPhysics3D physics library, http://www.reactphysics3d.com                 *
+* Copyright (c) 2010-2015 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 "ConcaveMeshScene.h"
+
+// Namespaces
+using namespace openglframework;
+using namespace trianglemeshscene;
+
+// Constructor
+ConcaveMeshScene::ConcaveMeshScene(const std::string& name)
+      : SceneDemo(name, SCENE_RADIUS) {
+
+    std::string meshFolderPath("meshes/");
+
+    // Compute the radius and the center of the scene
+    openglframework::Vector3 center(0, 5, 0);
+
+    // Set the center of the scene
+    setScenePosition(center, SCENE_RADIUS);
+
+    // Gravity vector in the dynamics world
+    rp3d::Vector3 gravity(0, rp3d::decimal(-9.81), 0);
+
+    // Create the dynamics world for the physics simulation
+    mDynamicsWorld = new rp3d::DynamicsWorld(gravity);
+
+    // Set the number of iterations of the constraint solver
+    mDynamicsWorld->setNbIterationsVelocitySolver(15);
+
+    // ---------- Create the sphere ----------- //
+
+    // Position
+    rp3d::decimal radius = 2.0;
+    openglframework::Vector3 spherePos(0, 10, 0);
+
+    // Create a sphere and a corresponding rigid in the dynamics world
+    mSphere = new Sphere(radius, spherePos , 1.0, mDynamicsWorld, meshFolderPath);
+
+    // Set the sphere color
+    mSphere->setColor(mDemoColors[1]);
+    mSphere->setSleepingColor(mRedColorDemo);
+
+    // Change the material properties of the rigid body
+    rp3d::Material& sphereMat = mSphere->getRigidBody()->getMaterial();
+    sphereMat.setBounciness(rp3d::decimal(0.2));
+
+    // ---------- Create the triangular mesh ---------- //
+
+    // Position
+    openglframework::Vector3 position(0, 0, 0);
+    rp3d::decimal mass = 1.0;
+
+    // Create a convex mesh and a corresponding rigid in the dynamics world
+    mConcaveMesh = new ConcaveMesh(position, mass, mDynamicsWorld, meshFolderPath);
+
+    // Set the mesh as beeing static
+    mConcaveMesh->getRigidBody()->setType(rp3d::STATIC);
+
+    // Set the box color
+    mConcaveMesh->setColor(mDemoColors[0]);
+    mConcaveMesh->setSleepingColor(mRedColorDemo);
+
+    // Change the material properties of the rigid body
+    rp3d::Material& material = mConcaveMesh->getRigidBody()->getMaterial();
+    material.setBounciness(rp3d::decimal(0.2));
+
+    // Get the physics engine parameters
+    mEngineSettings.isGravityEnabled = mDynamicsWorld->isGravityEnabled();
+    rp3d::Vector3 gravityVector = mDynamicsWorld->getGravity();
+    mEngineSettings.gravity = openglframework::Vector3(gravityVector.x, gravityVector.y, gravityVector.z);
+    mEngineSettings.isSleepingEnabled = mDynamicsWorld->isSleepingEnabled();
+    mEngineSettings.sleepLinearVelocity = mDynamicsWorld->getSleepLinearVelocity();
+    mEngineSettings.sleepAngularVelocity = mDynamicsWorld->getSleepAngularVelocity();
+    mEngineSettings.nbPositionSolverIterations = mDynamicsWorld->getNbIterationsPositionSolver();
+    mEngineSettings.nbVelocitySolverIterations = mDynamicsWorld->getNbIterationsVelocitySolver();
+    mEngineSettings.timeBeforeSleep = mDynamicsWorld->getTimeBeforeSleep();
+}
+
+// Destructor
+ConcaveMeshScene::~ConcaveMeshScene() {
+
+    mDynamicsWorld->destroyRigidBody(mSphere->getRigidBody());
+    // Destroy the corresponding rigid body from the dynamics world
+    mDynamicsWorld->destroyRigidBody(mConcaveMesh->getRigidBody());
+
+    delete mSphere;
+
+    // Destroy the convex mesh
+    delete mConcaveMesh;
+
+    // Destroy the dynamics world
+    delete mDynamicsWorld;
+}
+
+// Update the physics world (take a simulation step)
+void ConcaveMeshScene::updatePhysics() {
+
+    // Update the physics engine parameters
+    mDynamicsWorld->setIsGratityEnabled(mEngineSettings.isGravityEnabled);
+    rp3d::Vector3 gravity(mEngineSettings.gravity.x, mEngineSettings.gravity.y,
+                                     mEngineSettings.gravity.z);
+    mDynamicsWorld->setGravity(gravity);
+    mDynamicsWorld->enableSleeping(mEngineSettings.isSleepingEnabled);
+    mDynamicsWorld->setSleepLinearVelocity(mEngineSettings.sleepLinearVelocity);
+    mDynamicsWorld->setSleepAngularVelocity(mEngineSettings.sleepAngularVelocity);
+    mDynamicsWorld->setNbIterationsPositionSolver(mEngineSettings.nbPositionSolverIterations);
+    mDynamicsWorld->setNbIterationsVelocitySolver(mEngineSettings.nbVelocitySolverIterations);
+    mDynamicsWorld->setTimeBeforeSleep(mEngineSettings.timeBeforeSleep);
+
+    // Take a simulation step
+    mDynamicsWorld->update(mEngineSettings.timeStep);
+}
+
+// Update the scene
+void ConcaveMeshScene::update() {
+
+    SceneDemo::update();
+
+    // Update the transform used for the rendering
+    mConcaveMesh->updateTransform(mInterpolationFactor);
+    mSphere->updateTransform(mInterpolationFactor);
+}
+
+// Render the scene in a single pass
+void ConcaveMeshScene::renderSinglePass(Shader& shader, const openglframework::Matrix4& worldToCameraMatrix) {
+
+    // Bind the shader
+    shader.bind();
+
+    mConcaveMesh->render(shader, worldToCameraMatrix);
+    mSphere->render(shader, worldToCameraMatrix);
+
+    // Unbind the shader
+    shader.unbind();
+}
+
+// Reset the scene
+void ConcaveMeshScene::reset() {
+
+    // Reset the transform
+    mConcaveMesh->resetTransform(rp3d::Transform::identity());
+
+    rp3d::Vector3 spherePos(10.1, 10, 0);
+    rp3d::Transform sphereTransform(spherePos, rp3d::Quaternion::identity());
+    mSphere->resetTransform(sphereTransform);
+}

testbed/scenes/concavemesh/ConcaveMeshScene.h

@@ -0,0 +1,92 @@
+/********************************************************************************
+* ReactPhysics3D physics library, http://www.reactphysics3d.com                 *
+* Copyright (c) 2010-2015 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.    *
+*                                                                               *
+********************************************************************************/
+
+#ifndef TRIANGLE_MESH_SCENE_H
+#define TRIANGLE_MESH_SCENE_H
+
+// Libraries
+#include "openglframework.h"
+#include "reactphysics3d.h"
+#include "Box.h"
+#include "SceneDemo.h"
+#include "ConcaveMesh.h"
+#include "Sphere.h"
+
+namespace trianglemeshscene {
+
+// Constants
+const float SCENE_RADIUS = 30.0f;                           // Radius of the scene in meters
+
+// Class TriangleMeshScene
+class ConcaveMeshScene : public SceneDemo {
+
+    protected :
+
+        // -------------------- Attributes -------------------- //
+
+        Sphere* mSphere;
+
+        /// Concave triangles mesh
+        ConcaveMesh* mConcaveMesh;
+
+        /// Dynamics world used for the physics simulation
+        rp3d::DynamicsWorld* mDynamicsWorld;
+
+    public:
+
+        // -------------------- Methods -------------------- //
+
+        /// Constructor
+        ConcaveMeshScene(const std::string& name);
+
+        /// Destructor
+        virtual ~ConcaveMeshScene();
+
+        /// Update the physics world (take a simulation step)
+        /// Can be called several times per frame
+        virtual void updatePhysics();
+
+        /// Update the scene (take a simulation step)
+        virtual void update();
+
+        /// Render the scene in a single pass
+        virtual void renderSinglePass(openglframework::Shader& shader,
+                                      const openglframework::Matrix4& worldToCameraMatrix);
+
+        /// Reset the scene
+        virtual void reset();
+
+        /// Return all the contact points of the scene
+        virtual std::vector<ContactPoint> getContactPoints() const;
+};
+
+// Return all the contact points of the scene
+inline std::vector<ContactPoint> ConcaveMeshScene::getContactPoints() const {
+    return computeContactPointsOfWorld(mDynamicsWorld);
+}
+
+}
+
+#endif

testbed/src/TestbedApplication.cpp

@@ -33,12 +33,14 @@
 #include "joints/JointsScene.h"
 #include "collisionshapes/CollisionShapesScene.h"
 #include "raycast/RaycastScene.h"
+#include "concavemesh/ConcaveMeshScene.h"
 
 using namespace openglframework;
 using namespace jointsscene;
 using namespace cubesscene;
 using namespace raycastscene;
 using namespace collisionshapesscene;
+using namespace trianglemeshscene;
 
 // Initialization of static variables
 const float TestbedApplication::SCROLL_SENSITIVITY = 0.02f;
@@ -166,6 +168,10 @@ void TestbedApplication::createScenes() {
     RaycastScene* raycastScene = new RaycastScene("Raycast");
     mScenes.push_back(raycastScene);
 
+    // Raycast scene
+    ConcaveMeshScene* concaveMeshScene = new ConcaveMeshScene("Concave Mesh");
+    mScenes.push_back(concaveMeshScene);
+
     assert(mScenes.size() > 0);
     mCurrentScene = mScenes[0];