Fix issues and refactor collision shape type and collision shape name

src/collision/CollisionDetection.cpp

@@ -148,11 +148,11 @@ void CollisionDetection::computeMiddlePhase() {
             bodyindexpair bodiesIndex = OverlappingPair::computeBodiesIndexPair(body1, body2);
             if (mNoCollisionPairs.count(bodiesIndex) > 0) continue;
 
-            const CollisionShapeType shape1Type = shape1->getCollisionShape()->getType();
+			bool isShape1Convex = shape1->getCollisionShape()->isConvex();
-            const CollisionShapeType shape2Type = shape2->getCollisionShape()->getType();
+			bool isShape2Convex = shape2->getCollisionShape()->isConvex();
 
             // If both shapes are convex
-            if ((CollisionShape::isConvex(shape1Type) && CollisionShape::isConvex(shape2Type))) {
+            if (isShape1Convex && isShape2Convex) {
 
                 // No middle-phase is necessary, simply create a narrow phase info
                 // for the narrow-phase collision detection
@@ -161,13 +161,12 @@ void CollisionDetection::computeMiddlePhase() {
                                        NarrowPhaseInfo(pair, shape1->getCollisionShape(),
                                        shape2->getCollisionShape(), shape1->getLocalToWorldTransform(),
                                        shape2->getLocalToWorldTransform(), shape1->getCachedCollisionData(),
-                                       shape2->getCachedCollisionData());
+                                       shape2->getCachedCollisionData(), mSingleFrameAllocator);
                 mNarrowPhaseInfoList->next = firstNarrowPhaseInfo;
 
             }
             // Concave vs Convex algorithm
-            else if ((!CollisionShape::isConvex(shape1Type) && CollisionShape::isConvex(shape2Type)) ||
+            else if ((!isShape1Convex && isShape2Convex) || (!isShape2Convex && isShape1Convex)) {
-                     (!CollisionShape::isConvex(shape2Type) && CollisionShape::isConvex(shape1Type))) {
 
                 NarrowPhaseInfo* narrowPhaseInfo = nullptr;
                 computeConvexVsConcaveMiddlePhase(pair, mSingleFrameAllocator, &narrowPhaseInfo);
@@ -410,13 +409,6 @@ void CollisionDetection::processPotentialContacts(OverlappingPair* pair) {
     // Reduce the number of contact points of the manifold
     pair->reducePotentialContactManifolds();
 
-    // If there is a concave mesh shape in the pair
-    if (pair->hasConcaveShape()) {
-
-        processSmoothMeshContacts(pair);
-    }
-    else {   // If both collision shapes are convex
-
 	// Add all the potential contact manifolds as actual contact manifolds to the pair
 	ContactManifoldInfo* potentialManifold = pair->getPotentialContactManifolds();
 	while (potentialManifold != nullptr) {
@@ -425,7 +417,6 @@ void CollisionDetection::processPotentialContacts(OverlappingPair* pair) {
 
 		potentialManifold = potentialManifold->mNext;
 	}
-    }
 
     // Clear the obselete contact manifolds and contact points
     pair->clearObseleteManifoldsAndContactPoints();
@@ -544,25 +535,24 @@ NarrowPhaseInfo* CollisionDetection::computeMiddlePhaseForProxyShapes(Overlappin
 
     // -------------------------------------------------------
 
-    const CollisionShapeType shape1Type = shape1->getCollisionShape()->getType();
+    const bool isShape1Convex = shape1->getCollisionShape()->isConvex();
-    const CollisionShapeType shape2Type = shape2->getCollisionShape()->getType();
+    const bool isShape2Convex = shape2->getCollisionShape()->isConvex();
 
     NarrowPhaseInfo* narrowPhaseInfo = nullptr;
 
     // If both shapes are convex
-    if ((CollisionShape::isConvex(shape1Type) && CollisionShape::isConvex(shape2Type))) {
+    if ((isShape1Convex && isShape2Convex)) {
 
         // No middle-phase is necessary, simply create a narrow phase info
         // for the narrow-phase collision detection
         narrowPhaseInfo = new (mPoolAllocator.allocate(sizeof(NarrowPhaseInfo))) NarrowPhaseInfo(pair, shape1->getCollisionShape(),
                                        shape2->getCollisionShape(), shape1->getLocalToWorldTransform(),
                                        shape2->getLocalToWorldTransform(), shape1->getCachedCollisionData(),
-                                       shape2->getCachedCollisionData());
+                                       shape2->getCachedCollisionData(), mPoolAllocator);
 
     }
     // Concave vs Convex algorithm
-    else if ((!CollisionShape::isConvex(shape1Type) && CollisionShape::isConvex(shape2Type)) ||
+    else if ((!isShape1Convex && isShape2Convex) || (!isShape2Convex && isShape1Convex)) {
-             (!CollisionShape::isConvex(shape2Type) && CollisionShape::isConvex(shape1Type))) {
 
         // Run the middle-phase collision detection algorithm to find the triangles of the concave
         // shape we need to use during the narrow-phase collision detection
@@ -630,9 +620,6 @@ bool CollisionDetection::testOverlap(CollisionBody* body1, CollisionBody* body2)
             // Test if the AABBs of the two proxy shapes overlap
             if (aabb1.testCollision(aabb2)) {
 
-                const CollisionShapeType shape1Type = body1ProxyShape->getCollisionShape()->getType();
-                const CollisionShapeType shape2Type = body2ProxyShape->getCollisionShape()->getType();
-
                 // Create a temporary overlapping pair
                 OverlappingPair pair(body1ProxyShape, body2ProxyShape, mPoolAllocator, mPoolAllocator);
 
@@ -647,6 +634,9 @@ bool CollisionDetection::testOverlap(CollisionBody* body1, CollisionBody* body2)
                     // If we have not found a collision yet
                     if (!isColliding) {
 
+						const CollisionShapeType shape1Type = narrowPhaseInfo->collisionShape1->getType();
+						const CollisionShapeType shape2Type = narrowPhaseInfo->collisionShape2->getType();
+
                         // Select the narrow phase algorithm to use according to the two collision shapes
                         NarrowPhaseAlgorithm* narrowPhaseAlgorithm = selectNarrowPhaseAlgorithm(shape1Type, shape2Type);
 
@@ -723,9 +713,6 @@ void CollisionDetection::testOverlap(CollisionBody* body, OverlapCallback* overl
                 // Check if the collision filtering allows collision between the two shapes
                 if ((proxyShape->getCollisionCategoryBits() & categoryMaskBits) != 0) {
 
-                    const CollisionShapeType shape1Type = bodyProxyShape->getCollisionShape()->getType();
-                    const CollisionShapeType shape2Type = proxyShape->getCollisionShape()->getType();
-
                     // Create a temporary overlapping pair
                     OverlappingPair pair(bodyProxyShape, proxyShape, mPoolAllocator, mPoolAllocator);
 
@@ -740,6 +727,9 @@ void CollisionDetection::testOverlap(CollisionBody* body, OverlapCallback* overl
                         // If we have not found a collision yet
                         if (!isColliding) {
 
+							const CollisionShapeType shape1Type = narrowPhaseInfo->collisionShape1->getType();
+							const CollisionShapeType shape2Type = narrowPhaseInfo->collisionShape2->getType();
+
                             // Select the narrow phase algorithm to use according to the two collision shapes
                             NarrowPhaseAlgorithm* narrowPhaseAlgorithm = selectNarrowPhaseAlgorithm(shape1Type, shape2Type);
 
@@ -812,12 +802,12 @@ void CollisionDetection::testCollision(CollisionBody* body1, CollisionBody* body
                 // Compute the middle-phase collision detection between the two shapes
                 NarrowPhaseInfo* narrowPhaseInfo = computeMiddlePhaseForProxyShapes(&pair);
 
-                const CollisionShapeType shape1Type = body1ProxyShape->getCollisionShape()->getType();
-                const CollisionShapeType shape2Type = body2ProxyShape->getCollisionShape()->getType();
-
                 // For each narrow-phase info object
                 while (narrowPhaseInfo != nullptr) {
 
+					const CollisionShapeType shape1Type = narrowPhaseInfo->collisionShape1->getType();
+					const CollisionShapeType shape2Type = narrowPhaseInfo->collisionShape2->getType();
+
                     // Select the narrow phase algorithm to use according to the two collision shapes
                     NarrowPhaseAlgorithm* narrowPhaseAlgorithm = selectNarrowPhaseAlgorithm(shape1Type, shape2Type);
 
@@ -896,9 +886,6 @@ void CollisionDetection::testCollision(CollisionBody* body, CollisionCallback* c
                 // Check if the collision filtering allows collision between the two shapes
                 if ((proxyShape->getCollisionCategoryBits() & categoryMaskBits) != 0) {
 
-                    const CollisionShapeType shape1Type = bodyProxyShape->getCollisionShape()->getType();
-                    const CollisionShapeType shape2Type = proxyShape->getCollisionShape()->getType();
-
                     // Create a temporary overlapping pair
                     OverlappingPair pair(bodyProxyShape, proxyShape, mPoolAllocator, mPoolAllocator);
 
@@ -908,6 +895,9 @@ void CollisionDetection::testCollision(CollisionBody* body, CollisionCallback* c
                     // For each narrow-phase info object
                     while (narrowPhaseInfo != nullptr) {
 
+						const CollisionShapeType shape1Type = narrowPhaseInfo->collisionShape1->getType();
+						const CollisionShapeType shape2Type = narrowPhaseInfo->collisionShape2->getType();
+
                         // Select the narrow phase algorithm to use according to the two collision shapes
                         NarrowPhaseAlgorithm* narrowPhaseAlgorithm = selectNarrowPhaseAlgorithm(shape1Type, shape2Type);
 
@@ -988,8 +978,8 @@ void CollisionDetection::testCollision(CollisionCallback* callback) {
             // For each narrow-phase info object
             while (narrowPhaseInfo != nullptr) {
 
-                const CollisionShapeType shape1Type = shape1->getCollisionShape()->getType();
+                const CollisionShapeType shape1Type = narrowPhaseInfo->collisionShape1->getType();
-                const CollisionShapeType shape2Type = shape2->getCollisionShape()->getType();
+                const CollisionShapeType shape2Type = narrowPhaseInfo->collisionShape2->getType();
 
                 // Select the narrow phase algorithm to use according to the two collision shapes
                 NarrowPhaseAlgorithm* narrowPhaseAlgorithm = selectNarrowPhaseAlgorithm(shape1Type, shape2Type);

src/collision/MiddlePhaseTriangleCallback.cpp

@@ -32,7 +32,8 @@ using namespace reactphysics3d;
 void MiddlePhaseTriangleCallback::testTriangle(uint meshSubPart, uint triangleIndex, const Vector3* trianglePoints,
                                                const Vector3* verticesNormals) {
 
-    // Create a triangle collision shape
+    // Create a triangle collision shape (the allocated memory for the TriangleShape will be released in the
+	// destructor of the corresponding NarrowPhaseInfo.
     decimal margin = mConcaveShape->getTriangleMargin();
     TriangleShape* triangleShape = new (mAllocator.allocate(sizeof(TriangleShape)))
                                    TriangleShape(trianglePoints[0], trianglePoints[1], trianglePoints[2],
@@ -44,6 +45,6 @@ void MiddlePhaseTriangleCallback::testTriangle(uint meshSubPart, uint triangleIn
                            NarrowPhaseInfo(mOverlappingPair, mConvexProxyShape->getCollisionShape(),
                            triangleShape, mConvexProxyShape->getLocalToWorldTransform(),
                            mConcaveProxyShape->getLocalToWorldTransform(), mConvexProxyShape->getCachedCollisionData(),
-                           mConcaveProxyShape->getCachedCollisionData());
+                           mConcaveProxyShape->getCachedCollisionData(), mAllocator);
     narrowPhaseInfoList->next = firstNarrowPhaseInfo;
 }

src/collision/NarrowPhaseInfo.cpp

@@ -27,18 +27,19 @@
 #include <iostream>
 #include "NarrowPhaseInfo.h"
 #include "ContactPointInfo.h"
+#include "collision/shapes/TriangleShape.h"
 #include "engine/OverlappingPair.h"
 
 using namespace reactphysics3d;
 
 // Constructor
-NarrowPhaseInfo::NarrowPhaseInfo(OverlappingPair* pair, const CollisionShape* shape1,
+NarrowPhaseInfo::NarrowPhaseInfo(OverlappingPair* pair, CollisionShape* shape1,
-                const CollisionShape* shape2, const Transform& shape1Transform,
+                CollisionShape* shape2, const Transform& shape1Transform,
-                const Transform& shape2Transform, void** cachedData1, void** cachedData2)
+                const Transform& shape2Transform, void** cachedData1, void** cachedData2, Allocator& shapeAllocator)
       : overlappingPair(pair), collisionShape1(shape1), collisionShape2(shape2),
         shape1ToWorldTransform(shape1Transform), shape2ToWorldTransform(shape2Transform),
         contactPoints(nullptr), cachedCollisionData1(cachedData1),
-        cachedCollisionData2(cachedData2), next(nullptr) {
+        cachedCollisionData2(cachedData2), collisionShapeAllocator(shapeAllocator), next(nullptr) {
 
 }
 
@@ -46,6 +47,15 @@ NarrowPhaseInfo::NarrowPhaseInfo(OverlappingPair* pair, const CollisionShape* sh
 NarrowPhaseInfo::~NarrowPhaseInfo() {
 
     assert(contactPoints == nullptr);
+
+	// Release the memory of the TriangleShape (this memory was allocated in the
+	// MiddlePhaseTriangleCallback::testTriangle() method)
+	if (collisionShape1->getName() == CollisionShapeName::TRIANGLE) {
+		collisionShapeAllocator.release(collisionShape1, sizeof(TriangleShape));
+	}
+	if (collisionShape2->getName() == CollisionShapeName::TRIANGLE) {
+		collisionShapeAllocator.release(collisionShape2, sizeof(TriangleShape));
+	}
 }
 
 // Add a new contact point

src/collision/NarrowPhaseInfo.h

@@ -48,10 +48,10 @@ struct NarrowPhaseInfo {
         OverlappingPair* overlappingPair;
 
         /// Pointer to the first collision shape to test collision with
-        const CollisionShape* collisionShape1;
+        CollisionShape* collisionShape1;
 
         /// Pointer to the second collision shape to test collision with
-        const CollisionShape* collisionShape2;
+        CollisionShape* collisionShape2;
 
         /// Transform that maps from collision shape 1 local-space to world-space
         Transform shape1ToWorldTransform;
@@ -70,13 +70,16 @@ struct NarrowPhaseInfo {
         // TODO : Check if we can use separating axis in OverlappingPair instead of cachedCollisionData1 and cachedCollisionData2
         void** cachedCollisionData2;
 
+		/// Memory allocator for the collision shape (Used to release TriangleShape memory in destructor)
+		Allocator& collisionShapeAllocator;
+
         /// Pointer to the next element in the linked list
         NarrowPhaseInfo* next;
 
         /// Constructor
-        NarrowPhaseInfo(OverlappingPair* pair, const CollisionShape* shape1,
+        NarrowPhaseInfo(OverlappingPair* pair, CollisionShape* shape1,
-                        const CollisionShape* shape2, const Transform& shape1Transform,
+                        CollisionShape* shape2, const Transform& shape1Transform,
-                        const Transform& shape2Transform, void** cachedData1, void** cachedData2);
+                        const Transform& shape2Transform, void** cachedData1, void** cachedData2, Allocator& shapeAllocator);
 
         /// Destructor
         ~NarrowPhaseInfo();

src/collision/ProxyShape.h

@@ -85,6 +85,11 @@ class ProxyShape {
         /// proxy shape will collide with every collision categories by default.
         unsigned short mCollideWithMaskBits;
 
+		// -------------------- Methods -------------------- //
+
+		/// Return the collision shape
+		CollisionShape* getCollisionShape();
+
     public:
 
         // -------------------- Methods -------------------- //
@@ -177,6 +182,8 @@ class ProxyShape {
         friend class DynamicsWorld;
         friend class GJKAlgorithm;
         friend class ConvexMeshShape;
+		friend class ContactManifoldSet;
+		friend class MiddlePhaseTriangleCallback;
 
 };
 
@@ -193,6 +200,14 @@ inline const CollisionShape* ProxyShape::getCollisionShape() const {
     return mCollisionShape;
 }
 
+// Return the collision shape
+/**
+* @return Pointer to the internal collision shape
+*/
+inline CollisionShape* ProxyShape::getCollisionShape() {
+	return mCollisionShape;
+}
+
 // Return the parent body
 /**
  * @return Pointer to the parent body

src/collision/narrowphase/DefaultCollisionDispatch.cpp

@@ -36,7 +36,6 @@ NarrowPhaseAlgorithm* DefaultCollisionDispatch::selectAlgorithm(int type1, int t
     CollisionShapeType shape1Type = static_cast<CollisionShapeType>(type1);
     CollisionShapeType shape2Type = static_cast<CollisionShapeType>(type2);
 
-    // Convex vs Convex algorithm (GJK algorithm)
     if (type1 > type2) {
         return nullptr;
     }

src/collision/narrowphase/SAT/SATAlgorithm.cpp

@@ -82,7 +82,7 @@ bool SATAlgorithm::testCollisionSphereVsConvexPolyhedron(NarrowPhaseInfo* narrow
 
     // If the shapes are not triangles (no temporal coherence for triangle collision because we do not store previous
     // frame collision data per triangle)
-    if (polyhedron->getType() != CollisionShapeType::TRIANGLE) {
+    if (polyhedron->getName() != CollisionShapeName::TRIANGLE) {
 
         // If the last frame collision info is valid and was also using SAT algorithm
         if (lastFrameInfo.isValid && lastFrameInfo.wasUsingSAT) {
@@ -225,7 +225,7 @@ bool SATAlgorithm::testCollisionCapsuleVsConvexPolyhedron(NarrowPhaseInfo* narro
 
     // If the shapes are not triangles (no temporal coherence for triangle collision because we do not store previous
     // frame collision data per triangle)
-    if (polyhedron->getType() != CollisionShapeType::TRIANGLE) {
+    if (polyhedron->getName() != CollisionShapeName::TRIANGLE) {
 
         // If the last frame collision info is valid and was also using SAT algorithm
         if (lastFrameInfo.isValid && lastFrameInfo.wasUsingSAT) {
@@ -609,7 +609,7 @@ bool SATAlgorithm::testCollisionConvexPolyhedronVsConvexPolyhedron(NarrowPhaseIn
 
     // If the shapes are not triangles (no temporal coherence for triangle collision because we do not store previous
     // frame collision data per triangle)
-    if (polyhedron1->getType() != CollisionShapeType::TRIANGLE && polyhedron2->getType() != CollisionShapeType::TRIANGLE) {
+    if (polyhedron1->getName() != CollisionShapeName::TRIANGLE && polyhedron2->getName() != CollisionShapeName::TRIANGLE) {
 
         // If the last frame collision info is valid and was also using SAT algorithm
         if (lastFrameInfo.isValid && lastFrameInfo.wasUsingSAT) {

src/collision/shapes/BoxShape.cpp

@@ -38,7 +38,7 @@ using namespace reactphysics3d;
  * @param margin The collision margin (in meters) around the collision shape
  */
 BoxShape::BoxShape(const Vector3& extent, decimal margin)
-         : ConvexPolyhedronShape(margin), mExtent(extent - Vector3(margin, margin, margin)) {
+         : ConvexPolyhedronShape(CollisionShapeName::BOX, margin), mExtent(extent - Vector3(margin, margin, margin)) {
     assert(extent.x > decimal(0.0) && extent.x > margin);
     assert(extent.y > decimal(0.0) && extent.y > margin);
     assert(extent.z > decimal(0.0) && extent.z > margin);

src/collision/shapes/CapsuleShape.cpp

@@ -37,7 +37,7 @@ using namespace reactphysics3d;
  * @param height The height of the capsule (in meters)
  */
 CapsuleShape::CapsuleShape(decimal radius, decimal height)
-            : ConvexShape(CollisionShapeType::CAPSULE, radius), mHalfHeight(height * decimal(0.5)) {
+            : ConvexShape(CollisionShapeName::CAPSULE, CollisionShapeType::CAPSULE, radius), mHalfHeight(height * decimal(0.5)) {
     assert(radius > decimal(0.0));
     assert(height > decimal(0.0));
 }

src/collision/shapes/CollisionShape.cpp

@@ -32,7 +32,7 @@
 using namespace reactphysics3d;
 
 // Constructor
-CollisionShape::CollisionShape(CollisionShapeType type) : mType(type), mScaling(1.0, 1.0, 1.0) {
+CollisionShape::CollisionShape(CollisionShapeName name, CollisionShapeType type) : mName(name), mType(type), mScaling(1.0, 1.0, 1.0) {
     
 }
 

src/collision/shapes/CollisionShape.h

@@ -39,9 +39,12 @@
 /// ReactPhysics3D namespace
 namespace reactphysics3d {
     
-/// Type of the collision shape
+/// Type of collision shapes
-enum class CollisionShapeType {TRIANGLE, SPHERE, CAPSULE, CONVEX_POLYHEDRON, CONCAVE_MESH, HEIGHTFIELD};
+enum class CollisionShapeType {SPHERE, CAPSULE, CONVEX_POLYHEDRON, CONCAVE_SHAPE};
-const int NB_COLLISION_SHAPE_TYPES = 6;
+const int NB_COLLISION_SHAPE_TYPES = 4;
+
+/// Names of collision shapes
+enum class CollisionShapeName { TRIANGLE, SPHERE, CAPSULE, BOX, CONVEX_MESH, TRIANGLE_MESH, HEIGHTFIELD };
 
 // Declarations
 class ProxyShape;
@@ -61,6 +64,9 @@ class CollisionShape {
         /// Type of the collision shape
         CollisionShapeType mType;
 
+		/// Name of the colision shape
+		CollisionShapeName mName;
+
         /// Scaling vector of the collision shape
         Vector3 mScaling;
         
@@ -80,7 +86,7 @@ class CollisionShape {
         // -------------------- Methods -------------------- //
 
         /// Constructor
-        CollisionShape(CollisionShapeType type);
+        CollisionShape(CollisionShapeName name, CollisionShapeType type);
 
         /// Destructor
         virtual ~CollisionShape() = default;
@@ -91,7 +97,10 @@ class CollisionShape {
         /// Deleted assignment operator
         CollisionShape& operator=(const CollisionShape& shape) = delete;
 
-        /// Return the type of the collision shapes
+		/// Return the name of the collision shape
+		CollisionShapeName getName() const;
+
+        /// Return the type of the collision shape
         CollisionShapeType getType() const;
 
         /// Return true if the collision shape is convex, false if it is concave
@@ -115,28 +124,28 @@ class CollisionShape {
         /// Compute the world-space AABB of the collision shape given a transform
         virtual void computeAABB(AABB& aabb, const Transform& transform) const;
 
-        /// Return true if the collision shape type is a convex shape
-        static bool isConvex(CollisionShapeType shapeType);
-
         // -------------------- Friendship -------------------- //
 
         friend class ProxyShape;
         friend class CollisionWorld;
 };
 
+// Return the name of the collision shape
+/**
+* @return The name of the collision shape (box, sphere, triangle, ...)
+*/
+inline CollisionShapeName CollisionShape::getName() const {
+	return mName;
+}
+
 // Return the type of the collision shape
 /**
- * @return The type of the collision shape (box, sphere, cylinder, ...)
+ * @return The type of the collision shape (sphere, capsule, convex polyhedron, concave mesh)
  */
 inline CollisionShapeType CollisionShape::getType() const {
     return mType;
 }
 
-// Return true if the collision shape type is a convex shape
-inline bool CollisionShape::isConvex(CollisionShapeType shapeType) {
-    return shapeType != CollisionShapeType::CONCAVE_MESH && shapeType != CollisionShapeType::HEIGHTFIELD;
-}
-
 // Return the scaling vector of the collision shape
 inline Vector3 CollisionShape::getScaling() const {
     return mScaling;

src/collision/shapes/ConcaveMeshShape.cpp

@@ -30,7 +30,7 @@ using namespace reactphysics3d;
 
 // Constructor
 ConcaveMeshShape::ConcaveMeshShape(TriangleMesh* triangleMesh)
-                 : ConcaveShape(CollisionShapeType::CONCAVE_MESH) {
+                 : ConcaveShape(CollisionShapeName::TRIANGLE_MESH) {
     mTriangleMesh = triangleMesh;
     mRaycastTestType = TriangleRaycastSide::FRONT;
 
@@ -79,8 +79,8 @@ void ConcaveMeshShape::getTriangleVertices(uint subPart, uint triangleIndex,
 
     // Apply the scaling factor to the vertices
     outTriangleVertices[0] *= mScaling.x;
-    outTriangleVertices[1] *= mScaling.x;
+    outTriangleVertices[1] *= mScaling.y;
-    outTriangleVertices[2] *= mScaling.x;
+    outTriangleVertices[2] *= mScaling.z;
 }
 
 // Return the three vertex normals (in the array outVerticesNormals) of a triangle

src/collision/shapes/ConcaveMeshShape.h

@@ -139,9 +139,6 @@ class ConcaveMeshShape : public ConcaveShape {
         /// Return the three vertex normals (in the array outVerticesNormals) of a triangle
         void getTriangleVerticesNormals(uint subPart, uint triangleIndex, Vector3* outVerticesNormals) const;
 
-        /// Get a smooth contact normal for collision for a triangle of the mesh
-        Vector3 computeSmoothLocalContactNormalForTriangle(TriangleShape* triangleShape, const Vector3& localContactPoint) const;
-
     public:
 
         /// Constructor

src/collision/shapes/ConcaveShape.cpp

@@ -31,8 +31,7 @@
 using namespace reactphysics3d;
 
 // Constructor
-ConcaveShape::ConcaveShape(CollisionShapeType type)
+ConcaveShape::ConcaveShape(CollisionShapeName name)
-             : CollisionShape(type), mIsSmoothMeshCollisionEnabled(false),
+             : CollisionShape(name, CollisionShapeType::CONCAVE_SHAPE), mTriangleMargin(0), mRaycastTestType(TriangleRaycastSide::FRONT) {
-               mTriangleMargin(0), mRaycastTestType(TriangleRaycastSide::FRONT) {
 
 }

src/collision/shapes/ConcaveShape.h

@@ -63,9 +63,6 @@ class ConcaveShape : public CollisionShape {
 
         // -------------------- Attributes -------------------- //
 
-        /// True if the smooth mesh collision algorithm is enabled
-        bool mIsSmoothMeshCollisionEnabled;
-
         // Margin use for collision detection for each triangle
         decimal mTriangleMargin;
 
@@ -82,7 +79,7 @@ class ConcaveShape : public CollisionShape {
         // -------------------- Methods -------------------- //
 
         /// Constructor
-        ConcaveShape(CollisionShapeType type);
+        ConcaveShape(CollisionShapeName name);
 
         /// Destructor
         virtual ~ConcaveShape() override = default;
@@ -110,12 +107,6 @@ class ConcaveShape : public CollisionShape {
 
         /// Use a callback method on all triangles of the concave shape inside a given AABB
         virtual void testAllTriangles(TriangleCallback& callback, const AABB& localAABB) const=0;
-
-        /// Return true if the smooth mesh collision is enabled
-        bool getIsSmoothMeshCollisionEnabled() const;
-
-        /// Enable/disable the smooth mesh collision algorithm
-        void setIsSmoothMeshCollisionEnabled(bool isEnabled);
 };
 
 // Return the triangle margin
@@ -138,19 +129,6 @@ inline bool ConcaveShape::testPointInside(const Vector3& localPoint, ProxyShape*
     return false;
 }
 
-// Return true if the smooth mesh collision is enabled
-inline bool ConcaveShape::getIsSmoothMeshCollisionEnabled() const {
-    return mIsSmoothMeshCollisionEnabled;
-}
-
-// Enable/disable the smooth mesh collision algorithm
-/// Smooth mesh collision is used to avoid collisions against some internal edges
-/// of the triangle mesh. If it is enabled, collsions with the mesh will be smoother
-/// but collisions computation is a bit more expensive.
-inline void ConcaveShape::setIsSmoothMeshCollisionEnabled(bool isEnabled) {
-    mIsSmoothMeshCollisionEnabled = isEnabled;
-}
-
 // Return the raycast test type (front, back, front-back)
 inline TriangleRaycastSide ConcaveShape::getRaycastTestType() const {
     return mRaycastTestType;

src/collision/shapes/ConvexMeshShape.cpp

@@ -42,7 +42,7 @@ using namespace reactphysics3d;
  * @param margin Collision margin (in meters) around the collision shape
  */
 ConvexMeshShape::ConvexMeshShape(PolyhedronMesh* polyhedronMesh, decimal margin)
-                : ConvexPolyhedronShape(margin), mPolyhedronMesh(polyhedronMesh), mMinBounds(0, 0, 0), mMaxBounds(0, 0, 0) {
+                : ConvexPolyhedronShape(CollisionShapeName::CONVEX_MESH, margin), mPolyhedronMesh(polyhedronMesh), mMinBounds(0, 0, 0), mMaxBounds(0, 0, 0) {
 
     // Recalculate the bounds of the mesh
     recalculateBounds();

src/collision/shapes/ConvexPolyhedronShape.cpp

@@ -31,7 +31,7 @@
 using namespace reactphysics3d;
 
 // Constructor
-ConvexPolyhedronShape::ConvexPolyhedronShape(decimal margin)
+ConvexPolyhedronShape::ConvexPolyhedronShape(CollisionShapeName name, decimal margin)
-            : ConvexShape(CollisionShapeType::CONVEX_POLYHEDRON, margin) {
+            : ConvexShape(name, CollisionShapeType::CONVEX_POLYHEDRON, margin) {
 
 }

src/collision/shapes/ConvexPolyhedronShape.h

@@ -47,7 +47,7 @@ class ConvexPolyhedronShape : public ConvexShape {
         // -------------------- Methods -------------------- //
 
         /// Constructor
-        ConvexPolyhedronShape(decimal margin);
+        ConvexPolyhedronShape(CollisionShapeName name, decimal margin);
 
         /// Destructor
         virtual ~ConvexPolyhedronShape() override = default;

src/collision/shapes/ConvexShape.cpp

@@ -31,8 +31,8 @@
 using namespace reactphysics3d;
 
 // Constructor
-ConvexShape::ConvexShape(CollisionShapeType type, decimal margin)
+ConvexShape::ConvexShape(CollisionShapeName name, CollisionShapeType type, decimal margin)
-            : CollisionShape(type), mMargin(margin) {
+            : CollisionShape(name, type), mMargin(margin) {
 
 }
 

src/collision/shapes/ConvexShape.h

@@ -63,7 +63,7 @@ class ConvexShape : public CollisionShape {
         // -------------------- Methods -------------------- //
 
         /// Constructor
-        ConvexShape(CollisionShapeType type, decimal margin);
+        ConvexShape(CollisionShapeName name, CollisionShapeType type, decimal margin);
 
         /// Destructor
         virtual ~ConvexShape() override = default;

src/collision/shapes/HeightFieldShape.cpp

@@ -42,7 +42,7 @@ using namespace reactphysics3d;
 HeightFieldShape::HeightFieldShape(int nbGridColumns, int nbGridRows, decimal minHeight, decimal maxHeight,
                                    const void* heightFieldData, HeightDataType dataType, int upAxis,
                                    decimal integerHeightScale)
-                 : ConcaveShape(CollisionShapeType::HEIGHTFIELD), mNbColumns(nbGridColumns), mNbRows(nbGridRows),
+                 : ConcaveShape(CollisionShapeName::HEIGHTFIELD), mNbColumns(nbGridColumns), mNbRows(nbGridRows),
                    mWidth(nbGridColumns - 1), mLength(nbGridRows - 1), mMinHeight(minHeight),
                    mMaxHeight(maxHeight), mUpAxis(upAxis), mIntegerHeightScale(integerHeightScale),
                    mHeightDataType(dataType) {

src/collision/shapes/SphereShape.cpp

@@ -35,7 +35,7 @@ using namespace reactphysics3d;
 /**
  * @param radius Radius of the sphere (in meters)
  */
-SphereShape::SphereShape(decimal radius) : ConvexShape(CollisionShapeType::SPHERE, radius) {
+SphereShape::SphereShape(decimal radius) : ConvexShape(CollisionShapeName::SPHERE, CollisionShapeType::SPHERE, radius) {
     assert(radius > decimal(0.0));
 }
 

src/collision/shapes/TriangleShape.cpp

@@ -45,7 +45,7 @@ using namespace reactphysics3d;
  */
 TriangleShape::TriangleShape(const Vector3& point1, const Vector3& point2, const Vector3& point3,
                              const Vector3* verticesNormals, uint meshSubPart, uint triangleIndex, decimal margin)
-              : ConvexPolyhedronShape(margin), mMeshSubPart(meshSubPart), mTriangleIndex(triangleIndex) {
+              : ConvexPolyhedronShape(CollisionShapeName::TRIANGLE, margin), mMeshSubPart(meshSubPart), mTriangleIndex(triangleIndex) {
 
     mPoints[0] = point1;
     mPoints[1] = point2;
@@ -68,15 +68,15 @@ TriangleShape::TriangleShape(const Vector3& point1, const Vector3& point2, const
 // This method will return the new smooth world contact
 // normal of the triangle and the the local contact point on the other shape.
 void TriangleShape::computeSmoothTriangleMeshContact(const CollisionShape* shape1, const CollisionShape* shape2,
-                                                     Vector3& localContactPointShape1, Vector3 localContactPointShape2,
+                                                     Vector3& localContactPointShape1, Vector3& localContactPointShape2,
                                                      const Transform& shape1ToWorld, const Transform& shape2ToWorld,
                                                      decimal penetrationDepth, Vector3& outSmoothVertexNormal) {
 
-    assert(shape1->getType() != CollisionShapeType::TRIANGLE || shape2->getType() != CollisionShapeType::TRIANGLE);
+    assert(shape1->getName() != CollisionShapeName::TRIANGLE || shape2->getName() != CollisionShapeName::TRIANGLE);
 
     // If one the shape is a triangle
-    bool isShape1Triangle = shape1->getType() == CollisionShapeType::TRIANGLE;
+    bool isShape1Triangle = shape1->getName() == CollisionShapeName::TRIANGLE;
-    if (isShape1Triangle || shape2->getType() == CollisionShapeType::TRIANGLE) {
+    if (isShape1Triangle || shape2->getName() == CollisionShapeName::TRIANGLE) {
 
         const TriangleShape* triangleShape = isShape1Triangle ? static_cast<const TriangleShape*>(shape1):
                                                                 static_cast<const TriangleShape*>(shape2);
@@ -140,14 +140,6 @@ Vector3 TriangleShape::computeSmoothLocalContactNormalForTriangle(const Vector3&
     decimal u, v, w;
     computeBarycentricCoordinatesInTriangle(mPoints[0], mPoints[1], mPoints[2], localContactPoint, u, v, w);
 
-    int nbZeros = 0;
-    bool isUZero = approxEqual(u, decimal(0), decimal(0.0001));
-    bool isVZero = approxEqual(v, decimal(0), decimal(0.0001));
-    bool isWZero = approxEqual(w, decimal(0), decimal(0.0001));
-    if (isUZero) nbZeros++;
-    if (isVZero) nbZeros++;
-    if (isWZero) nbZeros++;
-
     // We compute the contact normal as the barycentric interpolation of the three vertices normals
     return (u * mVerticesNormals[0] + v * mVerticesNormals[1] + w * mVerticesNormals[2]).getUnit();
 }

src/collision/shapes/TriangleShape.h

@@ -173,7 +173,7 @@ class TriangleShape : public ConvexPolyhedronShape {
 
         /// This method compute the smooth mesh contact with a triangle in case one of the two collision shapes is a triangle. The idea in this case is to use a smooth vertex normal of the triangle mesh
         static void computeSmoothTriangleMeshContact(const CollisionShape* shape1, const CollisionShape* shape2,
-                                                     Vector3& localContactPointShape1, Vector3 localContactPointShape2,
+                                                     Vector3& localContactPointShape1, Vector3& localContactPointShape2,
                                                      const Transform& shape1ToWorld, const Transform& shape2ToWorld,
                                                      decimal penetrationDepth, Vector3& outSmoothVertexNormal);
 

src/engine/OverlappingPair.cpp

@@ -38,6 +38,11 @@ OverlappingPair::OverlappingPair(ProxyShape* shape1, ProxyShape* shape2,
     
 }         
 
+// Destructor
+OverlappingPair::~OverlappingPair() {
+	assert(mPotentialContactManifolds == nullptr);
+}
+
 // Create a new potential contact manifold using contact-points from narrow-phase
 void OverlappingPair::addPotentialContactPoints(NarrowPhaseInfo* narrowPhaseInfo) {
 

src/engine/OverlappingPair.h

@@ -117,7 +117,7 @@ class OverlappingPair {
                         Allocator& memoryAllocator, Allocator& temporaryMemoryAllocator);
 
         /// Destructor
-        ~OverlappingPair() = default;
+        ~OverlappingPair();
 
         /// Deleted copy-constructor
         OverlappingPair(const OverlappingPair& pair) = delete;

testbed/common/ConcaveMesh.cpp

@@ -109,8 +109,6 @@ ConcaveMesh::ConcaveMesh(const openglframework::Vector3 &position, float mass,
     // do not forget to delete it at the end
     mConcaveShape = new rp3d::ConcaveMeshShape(&mPhysicsTriangleMesh);
 
-    mConcaveShape->setIsSmoothMeshCollisionEnabled(false);
-
     // Initial position and orientation of the rigid body
     rp3d::Vector3 initPosition(position.x, position.y, position.z);
     rp3d::Quaternion initOrientation = rp3d::Quaternion::identity();

testbed/scenes/collisiondetection/CollisionDetectionScene.cpp

@@ -94,7 +94,7 @@ CollisionDetectionScene::CollisionDetectionScene(const std::string& name)
     mCapsule2->setSleepingColor(mRedColorDemo);
 
 	// ---------- Box 1 ---------- //
-	openglframework::Vector3 position5(0, -0, 0);
+	openglframework::Vector3 position5(-4, -7, 0);
 
 	// Create a cylinder and a corresponding collision body in the dynamics world
 	mBox1 = new Box(BOX_SIZE, position5, mCollisionWorld, mMeshFolderPath);
@@ -127,14 +127,15 @@ CollisionDetectionScene::CollisionDetectionScene(const std::string& name)
     mConvexMesh->setSleepingColor(mRedColorDemo);
 
     // ---------- Concave Mesh ---------- //
-    //openglframework::Vector3 position8(0, 0, 0);
+    openglframework::Vector3 position8(0, 0, 0);
 
     // Create a convex mesh and a corresponding collision body in the dynamics world
-    //mConcaveMesh = new ConcaveMesh(position8, mCollisionWorld, mMeshFolderPath + "city.obj");
+    mConcaveMesh = new ConcaveMesh(position8, mCollisionWorld, mMeshFolderPath + "city.obj");
+	mAllShapes.push_back(mConcaveMesh);
 
     // Set the color
-    //mConcaveMesh->setColor(mGreyColorDemo);
+    mConcaveMesh->setColor(mGreyColorDemo);
-    //mConcaveMesh->setSleepingColor(mRedColorDemo);
+    mConcaveMesh->setSleepingColor(mRedColorDemo);
 
     // ---------- Heightfield ---------- //
     //openglframework::Vector3 position9(0, 0, 0);
@@ -183,6 +184,9 @@ CollisionDetectionScene::~CollisionDetectionScene() {
 	mCollisionWorld->destroyCollisionBody(mConvexMesh->getCollisionBody());
 	delete mConvexMesh;
 
+	mCollisionWorld->destroyCollisionBody(mConcaveMesh->getCollisionBody());
+	delete mConcaveMesh;
+
     /*
     // Destroy the corresponding rigid body from the dynamics world
     mCollisionWorld->destroyCollisionBody(mCone->getCollisionBody());
@@ -206,12 +210,6 @@ CollisionDetectionScene::~CollisionDetectionScene() {
     // Destroy the dumbbell
     delete mDumbbell;
 
-    // Destroy the corresponding rigid body from the dynamics world
-    mCollisionWorld->destroyCollisionBody(mConcaveMesh->getCollisionBody());
-
-    // Destroy the convex mesh
-    delete mConcaveMesh;
-
     // Destroy the corresponding rigid body from the dynamics world
     mCollisionWorld->destroyCollisionBody(mHeightField->getCollisionBody());
 
@@ -256,6 +254,7 @@ void CollisionDetectionScene::renderSinglePass(openglframework::Shader& shader,
 	if (mBox1->getCollisionBody()->isActive()) mBox1->render(shader, worldToCameraMatrix, mIsWireframeEnabled);
 	if (mBox2->getCollisionBody()->isActive()) mBox2->render(shader, worldToCameraMatrix, mIsWireframeEnabled);
 	if (mConvexMesh->getCollisionBody()->isActive()) mConvexMesh->render(shader, worldToCameraMatrix, mIsWireframeEnabled);
+	if (mConcaveMesh->getCollisionBody()->isActive()) mConcaveMesh->render(shader, worldToCameraMatrix, mIsWireframeEnabled);
 
     /*
     if (mBox->getCollisionBody()->isActive()) mBox->render(shader, worldToCameraMatrix);
@@ -263,7 +262,6 @@ void CollisionDetectionScene::renderSinglePass(openglframework::Shader& shader,
     if (mCylinder->getCollisionBody()->isActive()) mCylinder->render(shader, worldToCameraMatrix);
     if (mCapsule->getCollisionBody()->isActive()) mCapsule->render(shader, worldToCameraMatrix);
     if (mDumbbell->getCollisionBody()->isActive()) mDumbbell->render(shader, worldToCameraMatrix);
-    if (mConcaveMesh->getCollisionBody()->isActive()) mConcaveMesh->render(shader, worldToCameraMatrix);
     if (mHeightField->getCollisionBody()->isActive()) mHeightField->render(shader, worldToCameraMatrix);
     */
 

testbed/scenes/collisiondetection/CollisionDetectionScene.h

@@ -147,7 +147,7 @@ class CollisionDetectionScene : public SceneDemo {
 		Box* mBox2;
         ConvexMesh* mConvexMesh;
         //Dumbbell* mDumbbell;
-        //ConcaveMesh* mConcaveMesh;
+        ConcaveMesh* mConcaveMesh;
         //HeightField* mHeightField;
 
         std::vector<PhysicsObject*> mAllShapes;