diff --git a/src/collision/CollisionDetection.cpp b/src/collision/CollisionDetection.cpp
index 0c21240a..3c4b771b 100644
--- a/src/collision/CollisionDetection.cpp
+++ b/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();
- const CollisionShapeType shape2Type = shape2->getCollisionShape()->getType();
+ bool isShape1Convex = shape1->getCollisionShape()->isConvex();
+ 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)) ||
- (!CollisionShape::isConvex(shape2Type) && CollisionShape::isConvex(shape1Type))) {
+ else if ((!isShape1Convex && isShape2Convex) || (!isShape2Convex && isShape1Convex)) {
NarrowPhaseInfo* narrowPhaseInfo = nullptr;
computeConvexVsConcaveMiddlePhase(pair, mSingleFrameAllocator, &narrowPhaseInfo);
@@ -410,22 +409,14 @@ 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()) {
+ // Add all the potential contact manifolds as actual contact manifolds to the pair
+ ContactManifoldInfo* potentialManifold = pair->getPotentialContactManifolds();
+ while (potentialManifold != nullptr) {
- processSmoothMeshContacts(pair);
- }
- else { // If both collision shapes are convex
+ pair->addContactManifold(potentialManifold);
- // Add all the potential contact manifolds as actual contact manifolds to the pair
- ContactManifoldInfo* potentialManifold = pair->getPotentialContactManifolds();
- while (potentialManifold != nullptr) {
-
- pair->addContactManifold(potentialManifold);
-
- potentialManifold = potentialManifold->mNext;
- }
- }
+ 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 CollisionShapeType shape2Type = shape2->getCollisionShape()->getType();
+ const bool isShape1Convex = shape1->getCollisionShape()->isConvex();
+ 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)) ||
- (!CollisionShape::isConvex(shape2Type) && CollisionShape::isConvex(shape1Type))) {
+ else if ((!isShape1Convex && isShape2Convex) || (!isShape2Convex && isShape1Convex)) {
// 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 shape2Type = shape2->getCollisionShape()->getType();
+ 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);
diff --git a/src/collision/MiddlePhaseTriangleCallback.cpp b/src/collision/MiddlePhaseTriangleCallback.cpp
index e99da461..a1a183ac 100644
--- a/src/collision/MiddlePhaseTriangleCallback.cpp
+++ b/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;
}
diff --git a/src/collision/NarrowPhaseInfo.cpp b/src/collision/NarrowPhaseInfo.cpp
index 22ee6666..b4a92a38 100644
--- a/src/collision/NarrowPhaseInfo.cpp
+++ b/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,
- const CollisionShape* shape2, const Transform& shape1Transform,
- const Transform& shape2Transform, void** cachedData1, void** cachedData2)
+NarrowPhaseInfo::NarrowPhaseInfo(OverlappingPair* pair, CollisionShape* shape1,
+ CollisionShape* shape2, const Transform& shape1Transform,
+ 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
diff --git a/src/collision/NarrowPhaseInfo.h b/src/collision/NarrowPhaseInfo.h
index 29bc6c9d..c9b18094 100644
--- a/src/collision/NarrowPhaseInfo.h
+++ b/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,
- const CollisionShape* shape2, const Transform& shape1Transform,
- const Transform& shape2Transform, void** cachedData1, void** cachedData2);
+ NarrowPhaseInfo(OverlappingPair* pair, CollisionShape* shape1,
+ CollisionShape* shape2, const Transform& shape1Transform,
+ const Transform& shape2Transform, void** cachedData1, void** cachedData2, Allocator& shapeAllocator);
/// Destructor
~NarrowPhaseInfo();
diff --git a/src/collision/ProxyShape.h b/src/collision/ProxyShape.h
index d9575b3d..36bec740 100644
--- a/src/collision/ProxyShape.h
+++ b/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
diff --git a/src/collision/narrowphase/DefaultCollisionDispatch.cpp b/src/collision/narrowphase/DefaultCollisionDispatch.cpp
index df1828ad..05616b27 100644
--- a/src/collision/narrowphase/DefaultCollisionDispatch.cpp
+++ b/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;
}
diff --git a/src/collision/narrowphase/SAT/SATAlgorithm.cpp b/src/collision/narrowphase/SAT/SATAlgorithm.cpp
index 23ce86e0..c5210c64 100644
--- a/src/collision/narrowphase/SAT/SATAlgorithm.cpp
+++ b/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) {
diff --git a/src/collision/shapes/BoxShape.cpp b/src/collision/shapes/BoxShape.cpp
index af6a30b8..54666136 100644
--- a/src/collision/shapes/BoxShape.cpp
+++ b/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);
diff --git a/src/collision/shapes/CapsuleShape.cpp b/src/collision/shapes/CapsuleShape.cpp
index f9f442ce..32ea146c 100644
--- a/src/collision/shapes/CapsuleShape.cpp
+++ b/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));
}
diff --git a/src/collision/shapes/CollisionShape.cpp b/src/collision/shapes/CollisionShape.cpp
index 301c97d2..d03b4a1c 100644
--- a/src/collision/shapes/CollisionShape.cpp
+++ b/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) {
}
diff --git a/src/collision/shapes/CollisionShape.h b/src/collision/shapes/CollisionShape.h
index 78b82ae0..77f96dfb 100644
--- a/src/collision/shapes/CollisionShape.h
+++ b/src/collision/shapes/CollisionShape.h
@@ -39,9 +39,12 @@
/// ReactPhysics3D namespace
namespace reactphysics3d {
-/// Type of the collision shape
-enum class CollisionShapeType {TRIANGLE, SPHERE, CAPSULE, CONVEX_POLYHEDRON, CONCAVE_MESH, HEIGHTFIELD};
-const int NB_COLLISION_SHAPE_TYPES = 6;
+/// Type of collision shapes
+enum class CollisionShapeType {SPHERE, CAPSULE, CONVEX_POLYHEDRON, CONCAVE_SHAPE};
+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;
diff --git a/src/collision/shapes/ConcaveMeshShape.cpp b/src/collision/shapes/ConcaveMeshShape.cpp
index 8cb5235a..0a9e1fd6 100644
--- a/src/collision/shapes/ConcaveMeshShape.cpp
+++ b/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[2] *= mScaling.x;
+ outTriangleVertices[1] *= mScaling.y;
+ outTriangleVertices[2] *= mScaling.z;
}
// Return the three vertex normals (in the array outVerticesNormals) of a triangle
diff --git a/src/collision/shapes/ConcaveMeshShape.h b/src/collision/shapes/ConcaveMeshShape.h
index 309ec27c..b99f2b4a 100644
--- a/src/collision/shapes/ConcaveMeshShape.h
+++ b/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
diff --git a/src/collision/shapes/ConcaveShape.cpp b/src/collision/shapes/ConcaveShape.cpp
index 3f691468..e8c032d2 100644
--- a/src/collision/shapes/ConcaveShape.cpp
+++ b/src/collision/shapes/ConcaveShape.cpp
@@ -31,8 +31,7 @@
using namespace reactphysics3d;
// Constructor
-ConcaveShape::ConcaveShape(CollisionShapeType type)
- : CollisionShape(type), mIsSmoothMeshCollisionEnabled(false),
- mTriangleMargin(0), mRaycastTestType(TriangleRaycastSide::FRONT) {
+ConcaveShape::ConcaveShape(CollisionShapeName name)
+ : CollisionShape(name, CollisionShapeType::CONCAVE_SHAPE), mTriangleMargin(0), mRaycastTestType(TriangleRaycastSide::FRONT) {
}
diff --git a/src/collision/shapes/ConcaveShape.h b/src/collision/shapes/ConcaveShape.h
index 6e07187f..34e347e0 100644
--- a/src/collision/shapes/ConcaveShape.h
+++ b/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;
diff --git a/src/collision/shapes/ConvexMeshShape.cpp b/src/collision/shapes/ConvexMeshShape.cpp
index 263bb736..c8f03fa3 100644
--- a/src/collision/shapes/ConvexMeshShape.cpp
+++ b/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();
diff --git a/src/collision/shapes/ConvexPolyhedronShape.cpp b/src/collision/shapes/ConvexPolyhedronShape.cpp
index e73a7cd7..0db54a85 100644
--- a/src/collision/shapes/ConvexPolyhedronShape.cpp
+++ b/src/collision/shapes/ConvexPolyhedronShape.cpp
@@ -31,7 +31,7 @@
using namespace reactphysics3d;
// Constructor
-ConvexPolyhedronShape::ConvexPolyhedronShape(decimal margin)
- : ConvexShape(CollisionShapeType::CONVEX_POLYHEDRON, margin) {
+ConvexPolyhedronShape::ConvexPolyhedronShape(CollisionShapeName name, decimal margin)
+ : ConvexShape(name, CollisionShapeType::CONVEX_POLYHEDRON, margin) {
}
diff --git a/src/collision/shapes/ConvexPolyhedronShape.h b/src/collision/shapes/ConvexPolyhedronShape.h
index 6c1de4d5..fe1f07a9 100644
--- a/src/collision/shapes/ConvexPolyhedronShape.h
+++ b/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;
diff --git a/src/collision/shapes/ConvexShape.cpp b/src/collision/shapes/ConvexShape.cpp
index f077cdcb..649e50f5 100644
--- a/src/collision/shapes/ConvexShape.cpp
+++ b/src/collision/shapes/ConvexShape.cpp
@@ -31,8 +31,8 @@
using namespace reactphysics3d;
// Constructor
-ConvexShape::ConvexShape(CollisionShapeType type, decimal margin)
- : CollisionShape(type), mMargin(margin) {
+ConvexShape::ConvexShape(CollisionShapeName name, CollisionShapeType type, decimal margin)
+ : CollisionShape(name, type), mMargin(margin) {
}
diff --git a/src/collision/shapes/ConvexShape.h b/src/collision/shapes/ConvexShape.h
index 94acc7f9..4bf4b718 100644
--- a/src/collision/shapes/ConvexShape.h
+++ b/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;
diff --git a/src/collision/shapes/HeightFieldShape.cpp b/src/collision/shapes/HeightFieldShape.cpp
index c8fc97f2..b13cf69b 100644
--- a/src/collision/shapes/HeightFieldShape.cpp
+++ b/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) {
diff --git a/src/collision/shapes/SphereShape.cpp b/src/collision/shapes/SphereShape.cpp
index 73fe49aa..8583e80d 100644
--- a/src/collision/shapes/SphereShape.cpp
+++ b/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));
}
diff --git a/src/collision/shapes/TriangleShape.cpp b/src/collision/shapes/TriangleShape.cpp
index 72eb93d3..c72dd133 100644
--- a/src/collision/shapes/TriangleShape.cpp
+++ b/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;
- if (isShape1Triangle || shape2->getType() == CollisionShapeType::TRIANGLE) {
+ bool isShape1Triangle = shape1->getName() == CollisionShapeName::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();
}
diff --git a/src/collision/shapes/TriangleShape.h b/src/collision/shapes/TriangleShape.h
index 900b71db..609d5892 100644
--- a/src/collision/shapes/TriangleShape.h
+++ b/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);
diff --git a/src/engine/OverlappingPair.cpp b/src/engine/OverlappingPair.cpp
index a23857e3..f3f85fa1 100644
--- a/src/engine/OverlappingPair.cpp
+++ b/src/engine/OverlappingPair.cpp
@@ -36,7 +36,12 @@ OverlappingPair::OverlappingPair(ProxyShape* shape1, ProxyShape* shape2,
: mContactManifoldSet(shape1, shape2, manifoldsAllocator), mPotentialContactManifolds(nullptr),
mTempMemoryAllocator(temporaryMemoryAllocator) {
-}
+}
+
+// Destructor
+OverlappingPair::~OverlappingPair() {
+ assert(mPotentialContactManifolds == nullptr);
+}
// Create a new potential contact manifold using contact-points from narrow-phase
void OverlappingPair::addPotentialContactPoints(NarrowPhaseInfo* narrowPhaseInfo) {
diff --git a/src/engine/OverlappingPair.h b/src/engine/OverlappingPair.h
index 906cddb7..e8c89dda 100644
--- a/src/engine/OverlappingPair.h
+++ b/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;
diff --git a/testbed/common/ConcaveMesh.cpp b/testbed/common/ConcaveMesh.cpp
index 608e0020..d6a6bbe3 100644
--- a/testbed/common/ConcaveMesh.cpp
+++ b/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();
diff --git a/testbed/scenes/collisiondetection/CollisionDetectionScene.cpp b/testbed/scenes/collisiondetection/CollisionDetectionScene.cpp
index a99d494d..7606a61e 100755
--- a/testbed/scenes/collisiondetection/CollisionDetectionScene.cpp
+++ b/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->setSleepingColor(mRedColorDemo);
+ mConcaveMesh->setColor(mGreyColorDemo);
+ 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);
*/
diff --git a/testbed/scenes/collisiondetection/CollisionDetectionScene.h b/testbed/scenes/collisiondetection/CollisionDetectionScene.h
index d0f1b569..8e94eaf5 100755
--- a/testbed/scenes/collisiondetection/CollisionDetectionScene.h
+++ b/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;