Refactor TriangleMesh and ConcaveMeshShape

Author: DanielChappuis

CHANGELOG.md

@@ -15,12 +15,23 @@
  - The PolyhedronMesh class has been renamed to ConvexMesh
  - The PhysicsCommon::createPolyhedronMesh() method has been renamed to PhysicsCommon::createConvexMesh()
  - The PhysicsCommon::destroyPolyhedronMesh() method has been renamed to PhysicsCommon::destroyConvexMesh()
- - The PhysicsCommon::createConvexMesh() nows returns a list of errors that might have happened during the mesh creation
+ - The PhysicsCommon::createConvexMesh() nows outputs a list of errors that might have happened during the mesh creation
  - The PhysicsCommon::createConvexMesh() method now takes a reference to PolygonVertexArray
- - The input data (vertices, indices, ...) are now copied into the ConvexMesh, TriangularMesh and HeighField and not shared anymore.
+ - The input data (vertices, indices, ...) are now copied into the ConvexMesh, TriangularMesh and HeighField and not shared anymore
+ - The PhysicsCommon::createTriangleMesh() method now directly takes a TriangleVertexArray
+ - The PhysicsCommon::createTriangleMesh() nows outputs a list of errors that might have happened during the mesh creation
+ - The signature of the TriangleVertexArray::getTriangleVerticesIndices() method has changed
+ - The signature of the TriangleVertexArray::getNormal() method has changed
+ - The getLocalBounds() methods of the collision shapes now returns an AABB
 
 ### Removed
 
+ - The TriangleMesh does not support adding multiple parts of a mesh anymore. 
+ - The TriangleMesh::addSubpart() method has been removed. The PhysicsCommon::createTriangleMesh() method should be used instead
+ - The TriangleMesh::getSubpart() method has been removed. 
+ - The TriangleMesh::getNbSubparts() method has been removed.
+
+
 ### Fixed
 
 - Issue [#237](https://github.com/DanielChappuis/reactphysics3d/issues/237) Wrong assert has been removed 

include/reactphysics3d/collision/ConvexMesh.h

@@ -29,6 +29,7 @@
 // Libraries
 #include <reactphysics3d/mathematics/mathematics.h>
 #include <reactphysics3d/containers/Array.h>
+#include <reactphysics3d/collision/shapes/AABB.h>
 #include "HalfEdgeStructure.h"
 
 namespace reactphysics3d {
@@ -55,7 +56,7 @@ class ConvexMesh {
         /// Half-edge structure of the mesh
         HalfEdgeStructure mHalfEdgeStructure;
 
-        // All the vertices of the mesh
+        /// All the vertices of the mesh
         Array<Vector3> mVertices;
 
         /// Array with the face normals
@@ -64,11 +65,8 @@ class ConvexMesh {
         /// Centroid of the mesh
         Vector3 mCentroid;
 
-        /// Mesh minimum bounds in the three local x, y and z directions
-        Vector3 mMinBounds;
-
-        /// Mesh maximum bounds in the three local x, y and z directions
-        Vector3 mMaxBounds;
+        /// Mesh minimum/maximum bounds in the three local x, y and z directions
+        AABB mBounds;
 
         /// Volume of the mesh
         decimal mVolume;
@@ -121,11 +119,8 @@ class ConvexMesh {
         /// Return the centroid of the mesh
         const Vector3& getCentroid() const;
 
-        /// Return the minimum bounds of the mesh in the x,y,z direction
-        const Vector3& getMinBounds() const;
-
-        /// Return the maximum bounds of the mesh in the x,y,z direction
-        const Vector3& getMaxBounds() const;
+        /// Return the bounds of the mesh in the x,y,z direction
+        const AABB& getBounds() const;
 
         /// Compute and return the volume of the mesh
         decimal getVolume() const;
@@ -190,22 +185,6 @@ RP3D_FORCE_INLINE const Vector3& ConvexMesh::getCentroid() const {
     return mCentroid;
 }
 
-// Return the minimum bounds of the mesh in the x,y,z direction
-/**
- * @return The three mimimum bounds of the mesh in the x,y,z direction
- */
-RP3D_FORCE_INLINE const Vector3& ConvexMesh::getMinBounds() const {
-    return mMinBounds;
-}
-
-// Return the maximum bounds of the mesh in the x,y,z direction
-/**
- * @return The three maximum bounds of the mesh in the x,y,z direction
- */
-RP3D_FORCE_INLINE const Vector3& ConvexMesh::getMaxBounds() const {
-    return mMaxBounds;
-}
-
 // Return the volume of the convex mesh
 /**
  * @return The volume of the mesh
@@ -226,7 +205,7 @@ RP3D_FORCE_INLINE Vector3 ConvexMesh::getLocalInertiaTensor(decimal mass, Vector
     // TODO: We should compute a much better inertia tensor here (not using a box)
 
     const decimal factor = (decimal(1.0) / decimal(3.0)) * mass;
-    const Vector3 realExtent = decimal(0.5) * scale * (getMaxBounds() - getMinBounds());
+    const Vector3 realExtent = decimal(0.5) * scale * (mBounds.getMax() - mBounds.getMin());
     assert(realExtent.x > 0 && realExtent.y > 0 && realExtent.z > 0);
     const decimal xSquare = realExtent.x * realExtent.x;
     const decimal ySquare = realExtent.y * realExtent.y;

include/reactphysics3d/collision/RaycastInfo.h

@@ -60,9 +60,6 @@ struct RaycastInfo {
         /// The hit point "p" is such that p = point1 + hitFraction * (point2 - point1)
         decimal hitFraction;
 
-        /// Mesh subpart index that has been hit (only used for triangles mesh and -1 otherwise)
-        int meshSubpart;
-
         /// Hit triangle index (only used for triangles mesh and -1 otherwise)
         int triangleIndex;
 
@@ -75,7 +72,7 @@ struct RaycastInfo {
         // -------------------- Methods -------------------- //
 
         /// Constructor
-        RaycastInfo() : meshSubpart(-1), triangleIndex(-1), body(nullptr), collider(nullptr) {
+        RaycastInfo() : triangleIndex(-1), body(nullptr), collider(nullptr) {
 
         }
 

include/reactphysics3d/collision/TriangleMesh.h

@@ -30,74 +30,148 @@
 #include <cassert>
 #include <reactphysics3d/containers/Array.h>
 #include <reactphysics3d/memory/MemoryAllocator.h>
+#include <reactphysics3d/collision/broadphase/DynamicAABBTree.h>
 
 namespace reactphysics3d {
 
 // Declarations
 class TriangleVertexArray;
+struct Error;
 
 // Class TriangleMesh
 /**
- * This class represents a mesh made of triangles. A TriangleMesh contains
- * one or several parts. Each part is a set of triangles represented in a
- * TriangleVertexArray object describing all the triangles vertices of the part.
- * A TriangleMesh object can be used to create a ConcaveMeshShape from a triangle
- * mesh for instance.
+ * This class represents a mesh made of triangles.
+ * A single TriangleMesh object can be used to create one or many ConcaveMeshShape (with
+ * different scaling for instance).
  */
 class TriangleMesh {
 
     protected:
 
-        /// All the triangle arrays of the mesh (one triangle array per part)
-        Array<TriangleVertexArray*> mTriangleArrays;
+        /// All the vertices of the mesh
+        Array<Vector3> mVertices;
+
+        /// The three vertices indices for each triangle face of the mesh
+        Array<uint32> mTriangles;
+
+        /// The normal vector at each vertex of the mesh
+        Array<Vector3> mVerticesNormals;
+
+        /// Dynamic AABB tree to accelerate collision with the triangles
+        DynamicAABBTree mDynamicAABBTree;
 
         /// Constructor
         TriangleMesh(reactphysics3d::MemoryAllocator& allocator);
 
+        /// Copy the vertices into the mesh
+        bool copyVertices(const TriangleVertexArray& triangleVertexArray, std::vector<Error>& errors);
+
+        /// Copy or compute the vertices normals
+        bool copyOrComputeVerticesNormals(const TriangleVertexArray& triangleVertexArray,
+                                          std::vector<Error>& errors);
+
+        /// Copy the triangles into the mesh
+        bool copyTriangles(const TriangleVertexArray& triangleVertexArray, std::vector<Error>& errors);
+
+        /// Insert all the triangles into the dynamic AABB tree
+        void initBVHTree();
+
+        /// Initialize the mesh using a TriangleVertexArray
+        bool init(const TriangleVertexArray& triangleVertexArray, std::vector<Error>& errors);
+
+        /// Report all shapes overlapping with the AABB given in parameter.
+        void reportAllShapesOverlappingWithAABB(const AABB& aabb, Array<int32>& overlappingNodes);
+
+        /// Return the integer data of leaf node of the dynamic AABB tree
+        int32 getDynamicAABBTreeNodeDataInt(int32 nodeID) const;
+
+        /// Ray casting method
+        void raycast(const Ray& ray, DynamicAABBTreeRaycastCallback& callback) const;
+
     public:
 
-        /// Destructor
-        ~TriangleMesh();
+        /// Return the number of vertices in the mesh
+        uint32 getNbVertices() const;
+
+        /// Return the number of triangles faces of the mesh
+        uint32 getNbTriangles() const;
 
-        /// Add a subpart of the mesh
-        void addSubpart(TriangleVertexArray* triangleVertexArray);
+        /// Return the bounds of the mesh in the x,y,z direction
+        const AABB& getBounds() const;
 
-        /// Return a pointer to a given subpart (triangle vertex array) of the mesh
-        TriangleVertexArray* getSubpart(uint32 indexSubpart) const;
+        /// Return the three vertex indices of a given triangle face
+        void getTriangleVerticesIndices(uint32 triangleIndex, uint32& outV1Index, uint32& outV2Index,
+                                      uint32& outV3Index) const;
 
-        /// Return the number of subparts of the mesh
-        uint32 getNbSubparts() const;
+        /// Return the coordinates of the three vertices of a given triangle face
+        void getTriangleVertices(uint32 triangleIndex, Vector3& outV1, Vector3& outV2, Vector3& outV3) const;
 
+        /// Return the normals of the three vertices of a given triangle face
+        void getTriangleVerticesNormals(uint32 triangleIndex, Vector3& outN1,
+                                        Vector3& outN2, Vector3& outN3) const;
+
+        /// Return the coordinates of a given vertex
+        const Vector3& getVertex(uint32 vertexIndex) const;
+
+        /// Return the normal of a given vertex
+        const Vector3& getVertexNormal(uint32 vertexIndex) const;
 
         // ---------- Friendship ---------- //
 
         friend class PhysicsCommon;
+        friend class ConcaveMeshShape;
 };
 
-// Add a subpart of the mesh
-/**
- * @param triangleVertexArray Pointer to the TriangleVertexArray to add into the mesh
- */
-RP3D_FORCE_INLINE void TriangleMesh::addSubpart(TriangleVertexArray* triangleVertexArray) {
-    mTriangleArrays.add(triangleVertexArray );
+// Return the number of vertices in the mesh
+RP3D_FORCE_INLINE uint32 TriangleMesh::getNbVertices() const {
+    return mVertices.size();
 }
 
-// Return a pointer to a given subpart (triangle vertex array) of the mesh
-/**
- * @param indexSubpart The index of the sub-part of the mesh
- * @return A pointer to the triangle vertex array of a given sub-part of the mesh
- */
-RP3D_FORCE_INLINE TriangleVertexArray* TriangleMesh::getSubpart(uint32 indexSubpart) const {
-   assert(indexSubpart < mTriangleArrays.size());
-   return mTriangleArrays[indexSubpart];
+// Return the number of triangles faces of the mesh
+RP3D_FORCE_INLINE uint32 TriangleMesh::getNbTriangles() const {
+    return mTriangles.size() / 3;
 }
 
-// Return the number of sub-parts of the mesh
-/**
- * @return The number of sub-parts of the mesh
- */
-RP3D_FORCE_INLINE uint32 TriangleMesh::getNbSubparts() const {
-    return static_cast<uint32>(mTriangleArrays.size());
+// Return the three vertex indices of a given triangle face
+RP3D_FORCE_INLINE void TriangleMesh::getTriangleVerticesIndices(uint32 triangleIndex, uint32& outV1Index,
+                                                                uint32& outV2Index, uint32& outV3Index) const {
+   assert(triangleIndex < mTriangles.size() / 3);
+
+   outV1Index = mTriangles[triangleIndex * 3];
+   outV2Index = mTriangles[triangleIndex * 3 + 1];
+   outV3Index = mTriangles[triangleIndex * 3 + 2];
+}
+
+// Return the coordinates of the three vertices of a given triangle face
+RP3D_FORCE_INLINE void TriangleMesh::getTriangleVertices(uint32 triangleIndex, Vector3& outV1, Vector3& outV2,
+                                                         Vector3& outV3) const {
+    assert(triangleIndex < mTriangles.size() / 3);
+
+    outV1 = mVertices[mTriangles[triangleIndex * 3]];
+    outV2 = mVertices[mTriangles[triangleIndex * 3 + 1]];
+    outV3 = mVertices[mTriangles[triangleIndex * 3 + 2]];
+}
+
+// Return the normals of the three vertices of a given triangle face
+RP3D_FORCE_INLINE void TriangleMesh::getTriangleVerticesNormals(uint32 triangleIndex, Vector3& outN1,
+                                                                Vector3& outN2, Vector3& outN3) const {
+    assert(triangleIndex < mTriangles.size() / 3);
+
+    outN1 = mVerticesNormals[mTriangles[triangleIndex * 3]];
+    outN2 = mVerticesNormals[mTriangles[triangleIndex * 3 + 1]];
+    outN3 = mVerticesNormals[mTriangles[triangleIndex * 3 + 2]];
+}
+
+// Return the coordinates of a given vertex
+RP3D_FORCE_INLINE const Vector3& TriangleMesh::getVertex(uint32 vertexIndex) const {
+    assert(vertexIndex < mVertices.size());
+    return mVertices[vertexIndex];
+}
+
+// Return the normal of a given vertex
+RP3D_FORCE_INLINE const Vector3& TriangleMesh::getVertexNormal(uint32 vertexIndex) const {
+    assert(vertexIndex < mVertices.size());
+   return mVerticesNormals[vertexIndex];
 }
 
 }

include/reactphysics3d/collision/TriangleVertexArray.h

@@ -39,8 +39,7 @@ struct Vector3;
  * This class is used to describe the vertices and faces of a triangular mesh.
  * A TriangleVertexArray represents a continuous array of vertices and indexes
  * of a triangular mesh. When you create a TriangleVertexArray, no data is copied
- * into the array. It only stores pointer to the data. The purpose is to allow
- * the user to share vertices data between the physics engine and the rendering
+ * into the array. It only stores pointer to the data.
  * part. Therefore, make sure that the data pointed by a TriangleVertexArray
  * remains valid during the TriangleVertexArray life.
  */
@@ -97,13 +96,10 @@ class TriangleVertexArray {
         IndexDataType mIndexDataType;
 
         /// True if the vertices normals are provided by the user
-        bool mAreVerticesNormalsProvidedByUser;
+        bool mHasNormals;
 
         // -------------------- Methods -------------------- //
 
-        /// Compute the vertices normals when they are not provided by the user
-        void computeVerticesNormals();
-
     public:
 
         // -------------------- Methods -------------------- //
@@ -120,9 +116,6 @@ class TriangleVertexArray {
                             VertexDataType vertexDataType, NormalDataType normalDataType,
                             IndexDataType indexDataType);
 
-        /// Destructor
-        ~TriangleVertexArray();
-
         /// Deleted assignment operator
         TriangleVertexArray& operator=(const TriangleVertexArray& triangleVertexArray) = delete;
 
@@ -135,6 +128,9 @@ class TriangleVertexArray {
         /// Return the vertex normal data type
         NormalDataType getVertexNormalDataType() const;
 
+        /// Return true if the vertices normal have been provided by the user
+        bool getHasNormals() const;
+
         /// Return the index data type
         IndexDataType getIndexDataType() const;
 
@@ -162,20 +158,15 @@ class TriangleVertexArray {
         /// Return the pointer to the start of the indices array
         const void* getIndicesStart() const;
 
-        /// Return the vertices coordinates of a triangle
-        void getTriangleVertices(uint32 triangleIndex, Vector3* outTriangleVertices) const;
-
-        /// Return the three vertices normals of a triangle
-        void getTriangleVerticesNormals(uint32 triangleIndex, Vector3* outTriangleVerticesNormals) const;
-
-        /// Return the indices of the three vertices of a given triangle in the array
-        void getTriangleVerticesIndices(uint32 triangleIndex, uint32* outVerticesIndices) const;
+        /// Return the three vertex indices of a given triangle face
+        void getTriangleVerticesIndices(uint32 triangleIndex, uint32& outV1Index, uint32& outV2Index,
+                                      uint32& outV3Index) const;
 
         /// Return a vertex of the array
-        void getVertex(uint32 vertexIndex, Vector3* outVertex);
+        Vector3 getVertex(uint32 vertexIndex) const;
 
         /// Return a vertex normal of the array
-        void getNormal(uint32 vertexIndex, Vector3* outNormal);
+        Vector3 getVertexNormal(uint32 vertexIndex) const;
 };
 
 // Return the vertex data type
@@ -266,6 +257,14 @@ RP3D_FORCE_INLINE const void* TriangleVertexArray::getIndicesStart() const {
     return mIndicesStart;
 }
 
+// Return true if the vertices normals have been provided by the user
+/**
+ * @return True if the vertices normals have been provided by the user
+ */
+RP3D_FORCE_INLINE bool TriangleVertexArray::getHasNormals() const {
+    return mHasNormals;
+}
+
 }
 
 #endif