Working on TriangleMesh

Author: DanielChappuis

CMakeLists.txt

@@ -145,7 +145,7 @@ set (REACTPHYSICS3D_HEADERS
     "include/reactphysics3d/containers/Deque.h"
     "include/reactphysics3d/utils/Profiler.h"
     "include/reactphysics3d/utils/Logger.h"
-    "include/reactphysics3d/utils/Error.h"
+    "include/reactphysics3d/utils/Message.h"
     "include/reactphysics3d/utils/DefaultLogger.h"
     "include/reactphysics3d/utils/DebugRenderer.h"
     "include/reactphysics3d/utils/quickhull/QuickHull.h"

include/reactphysics3d/collision/ConvexMesh.h

@@ -37,7 +37,7 @@ namespace reactphysics3d {
 // Declarations
 class DefaultAllocator;
 class PolygonVertexArray;
-struct Error;
+struct Message;
 
 // Class ConvexMesh
 /**
@@ -77,16 +77,16 @@ class ConvexMesh {
         ConvexMesh(MemoryAllocator& allocator);
 
         /// Initialize a mesh and returns errors if any
-        bool init(const PolygonVertexArray& polygonVertexArray, std::vector<Error>& errors);
+        bool init(const PolygonVertexArray& polygonVertexArray, std::vector<Message>& errors);
 
         /// Copy the vertices into the mesh
-        bool copyVertices(const PolygonVertexArray& polygonVertexArray, std::vector<Error>& errors);
+        bool copyVertices(const PolygonVertexArray& polygonVertexArray, std::vector<Message>& errors);
 
         /// Create the half-edge structure of the mesh
-        bool createHalfEdgeStructure(const PolygonVertexArray& polygonVertexArray, std::vector<Error>& errors);
+        bool createHalfEdgeStructure(const PolygonVertexArray& polygonVertexArray, std::vector<Message>& errors);
 
         /// Compute the faces normals
-        bool computeFacesNormals(std::vector<Error>& errors);
+        bool computeFacesNormals(std::vector<Message>& errors);
 
         /// Compute and return the face normal (not normalized)
         Vector3 computeFaceNormal(uint32 faceIndex) const;

include/reactphysics3d/collision/TriangleMesh.h

@@ -31,12 +31,13 @@
 #include <reactphysics3d/containers/Array.h>
 #include <reactphysics3d/memory/MemoryAllocator.h>
 #include <reactphysics3d/collision/broadphase/DynamicAABBTree.h>
+#include <reactphysics3d/containers/Map.h>
 
 namespace reactphysics3d {
 
 // Declarations
 class TriangleVertexArray;
-struct Error;
+struct Message;
 
 // Class TriangleMesh
 /**
@@ -48,6 +49,9 @@ class TriangleMesh {
 
     protected:
 
+        /// Reference to the memory allocator
+        MemoryAllocator& mAllocator;
+
         /// All the vertices of the mesh
         Array<Vector3> mVertices;
 
@@ -60,24 +64,29 @@ class TriangleMesh {
         /// Dynamic AABB tree to accelerate collision with the triangles
         DynamicAABBTree mDynamicAABBTree;
 
+        /// Epsilon value for this mesh
+        decimal mEpsilon;
+
         /// Constructor
         TriangleMesh(reactphysics3d::MemoryAllocator& allocator);
 
         /// Copy the vertices into the mesh
-        bool copyVertices(const TriangleVertexArray& triangleVertexArray, std::vector<Error>& errors);
+        bool copyVertices(const TriangleVertexArray& triangleVertexArray, std::vector<Message>& messages);
 
         /// Copy or compute the vertices normals
-        bool copyOrComputeVerticesNormals(const TriangleVertexArray& triangleVertexArray,
-                                          std::vector<Error>& errors);
+        void computeVerticesNormals();
 
         /// Copy the triangles into the mesh
-        bool copyTriangles(const TriangleVertexArray& triangleVertexArray, std::vector<Error>& errors);
+        bool copyData(const TriangleVertexArray& triangleVertexArray, std::vector<Message>& 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);
+        bool init(const TriangleVertexArray& triangleVertexArray, std::vector<Message>& messages);
+
+        /// Addd a vertex to the mesh
+        uint32 addVertex(uint32 userVertexIndex, const Vector3& vertex, Map<uint32, uint32>& mapUserVertexIndexToInternal);
 
         /// Report all shapes overlapping with the AABB given in parameter.
         void reportAllShapesOverlappingWithAABB(const AABB& aabb, Array<int32>& overlappingNodes);
@@ -160,6 +169,11 @@ RP3D_FORCE_INLINE void TriangleMesh::getTriangleVerticesNormals(uint32 triangleI
     outN1 = mVerticesNormals[mTriangles[triangleIndex * 3]];
     outN2 = mVerticesNormals[mTriangles[triangleIndex * 3 + 1]];
     outN3 = mVerticesNormals[mTriangles[triangleIndex * 3 + 2]];
+
+    // TODO : REMOVE
+    assert(outN1.length() > MACHINE_EPSILON);
+    assert(outN2.length() > MACHINE_EPSILON);
+    assert(outN3.length() > MACHINE_EPSILON);
 }
 
 // Return the coordinates of a given vertex

include/reactphysics3d/collision/shapes/TriangleShape.h

@@ -31,6 +31,9 @@
 #include <reactphysics3d/collision/shapes/AABB.h>
 #include <reactphysics3d/collision/shapes/ConvexPolyhedronShape.h>
 
+// TODO : REMOVE
+#include <iostream>
+
 /// ReactPhysics3D namespace
 namespace reactphysics3d {
 
@@ -311,6 +314,9 @@ RP3D_FORCE_INLINE Vector3 TriangleShape::computeSmoothLocalContactNormalForTrian
 
     assert(mNormal.length() > decimal(0.0));
 
+    // TODO : REMOVE
+    std::cout << "mNormal: " << mNormal.to_string() << std::endl;
+
     // Compute the barycentric coordinates of the point in the triangle
     decimal u, v, w;
     computeBarycentricCoordinatesInTriangle(mPoints[0], mPoints[1], mPoints[2], localContactPoint, u, v, w);

include/reactphysics3d/engine/PhysicsCommon.h

@@ -204,7 +204,7 @@ class PhysicsCommon {
         HeightFieldShape* createHeightFieldShape(int nbGridColumns, int nbGridRows, decimal minHeight, decimal maxHeight,
                                                  const void* heightFieldData, HeightFieldShape::HeightDataType dataType,
                                                  int upAxis = 1, decimal integerHeightScale = 1.0f,
-                                                  const Vector3& scaling = Vector3(1,1,1));
+                                                 const Vector3& scaling = Vector3(1,1,1));
 
         /// Destroy a height-field shape
         void destroyHeightFieldShape(HeightFieldShape* heightFieldShape);
@@ -216,16 +216,16 @@ class PhysicsCommon {
         void destroyConcaveMeshShape(ConcaveMeshShape* concaveMeshShape);
 
         /// Create a convex mesh from a PolygonVertexArray describing vertices and faces
-        ConvexMesh* createConvexMesh(const PolygonVertexArray& polygonVertexArray, std::vector<Error>& errors);
+        ConvexMesh* createConvexMesh(const PolygonVertexArray& polygonVertexArray, std::vector<Message>& messages);
 
         /// Create a convex mesh from an array of vertices (automatically computing the convex hull using QuickHull)
-        ConvexMesh* createConvexMesh(const VertexArray& vertexArray, std::vector<Error>& errors);
+        ConvexMesh* createConvexMesh(const VertexArray& vertexArray, std::vector<Message>& messages);
 
         /// Destroy a convex mesh
         void destroyConvexMesh(ConvexMesh* convexMesh);
 
         /// Create a triangle mesh
-        TriangleMesh* createTriangleMesh(const TriangleVertexArray& triangleVertexArray, std::vector<Error>& errors);
+        TriangleMesh* createTriangleMesh(const TriangleVertexArray& triangleVertexArray, std::vector<Message>& messages);
 
         /// Destroy a triangle mesh
         void destroyTriangleMesh(TriangleMesh* triangleMesh);

include/reactphysics3d/reactphysics3d.h

@@ -66,7 +66,7 @@
 #include <reactphysics3d/constraint/HingeJoint.h>
 #include <reactphysics3d/constraint/FixedJoint.h>
 #include <reactphysics3d/containers/Array.h>
-#include <reactphysics3d/utils/Error.h>
+#include <reactphysics3d/utils/Message.h>
 
 /// Alias to the ReactPhysics3D namespace
 namespace rp3d = reactphysics3d;

include/reactphysics3d/utils/Error.h renamed to include/reactphysics3d/utils/Message.h

@@ -23,36 +23,36 @@
 *                                                                               *
 ********************************************************************************/
 
-#ifndef REACTPHYSICS3D_ERROR_H
-#define REACTPHYSICS3D_ERROR_H
+#ifndef REACTPHYSICS3D_MESSAGE_H
+#define REACTPHYSICS3D_MESSAGE_H
 
 // Libraries
 #include <string>
 
 /// ReactPhysics3D namespace
 namespace reactphysics3d {
 
-// Structure Error
+// Structure Message
 /**
- * This structure represent an error that can be returned to the user
+ * This structure represent a message that can be returned to the user
  */
-struct Error {
+struct Message {
 
     public:
 
-        /// Error level
-        enum class Level {Error = 1, Warning = 2, Information = 4};
+        /// Type of message
+        enum class Type {Error = 1, Warning = 2, Information = 4};
 
-        /// Error message
-        std::string message;
+        /// Message text
+        std::string text;
 
-        // Level (error, warning, information)
-        Level level;
+        // Type (error, warning, information)
+        Type type;
 
         // -------------------- Methods -------------------- //
 
         /// Constructor
-        Error(std::string message, Level level = Level::Error) : message(message), level(level) {
+        Message(std::string text, Type type = Type::Error) : text(text), type(type) {
 
         }
 };

include/reactphysics3d/utils/quickhull/QuickHull.h

@@ -39,7 +39,7 @@ namespace reactphysics3d {
 // Declarations
 class ConvexMesh;
 class VertexArray;
-struct Error;
+struct Message;
 template<typename T>
 class Array;
 
@@ -75,7 +75,7 @@ class QuickHull {
         static bool computeInitialHull(Array<Vector3>& points, QHHalfEdgeStructure& convexHull,
                                        Array<QHHalfEdgeStructure::Face*>& initialFaces,
                                        Array<uint32>& orphanPointsIndices,
-                                       MemoryAllocator& allocator, std::vector<Error>& errors);
+                                       MemoryAllocator& allocator, std::vector<Message>& errors);
 
         /// Extract the points from the array
         static void extractPoints(const VertexArray& vertexArray, Array<Vector3>& outArray);
@@ -170,7 +170,7 @@ class QuickHull {
         static bool computeConvexHull(const VertexArray& vertexArray, PolygonVertexArray& outPolygonVertexArray,
                                       Array<float>& outVertices, Array<unsigned int>& outIndices,
                                       Array<PolygonVertexArray::PolygonFace>& outFaces,
-                                      MemoryAllocator& allocator, std::vector<Error>& errors);
+                                      MemoryAllocator& allocator, std::vector<Message>& errors);
 
 
 

src/collision/ConvexMesh.cpp

@@ -29,7 +29,7 @@
 #include <reactphysics3d/collision/PolygonVertexArray.h>
 #include <reactphysics3d/utils/DefaultLogger.h>
 #include <reactphysics3d/engine/PhysicsCommon.h>
-#include <reactphysics3d/utils/Error.h>
+#include <reactphysics3d/utils/Message.h>
 #include <cstdlib>
 
 using namespace reactphysics3d;
@@ -54,7 +54,7 @@ ConvexMesh* ConvexMesh::create(MemoryAllocator& allocator) {
 }
 
 // Initialize a mesh and returns errors if any
-bool ConvexMesh::init(const PolygonVertexArray& polygonVertexArray, std::vector<Error>& errors) {
+bool ConvexMesh::init(const PolygonVertexArray& polygonVertexArray, std::vector<Message>& errors) {
 
     bool isValid = true;
 
@@ -80,7 +80,7 @@ bool ConvexMesh::init(const PolygonVertexArray& polygonVertexArray, std::vector<
 }
 
 // Copy the vertices into the mesh
-bool ConvexMesh::copyVertices(const PolygonVertexArray& polygonVertexArray, std::vector<Error>& errors) {
+bool ConvexMesh::copyVertices(const PolygonVertexArray& polygonVertexArray, std::vector<Message>& errors) {
 
     bool isValid = true;
 
@@ -110,7 +110,7 @@ bool ConvexMesh::copyVertices(const PolygonVertexArray& polygonVertexArray, std:
     }
     else {
 
-        errors.push_back(Error("The mesh does not have any vertices"));
+        errors.push_back(Message("The mesh does not have any vertices"));
 
         isValid = false;
     }
@@ -120,7 +120,7 @@ bool ConvexMesh::copyVertices(const PolygonVertexArray& polygonVertexArray, std:
 
 // Create the half-edge structure of the mesh
 /// This method returns true if the mesh is valid or false otherwise
-bool ConvexMesh::createHalfEdgeStructure(const PolygonVertexArray& polygonVertexArray, std::vector<Error>& errors) {
+bool ConvexMesh::createHalfEdgeStructure(const PolygonVertexArray& polygonVertexArray, std::vector<Message>& errors) {
 
     bool isValid = true;
 
@@ -152,7 +152,7 @@ bool ConvexMesh::createHalfEdgeStructure(const PolygonVertexArray& polygonVertex
         if (faceVertices.size() < 3) {
 
             // Create a new error
-            errors.push_back(Error(std::string("The face with index " + std::to_string(f) + " has less than three vertices")));
+            errors.push_back(Message(std::string("The face with index " + std::to_string(f) + " has less than three vertices")));
 
             isValid = false;
 
@@ -173,7 +173,7 @@ bool ConvexMesh::createHalfEdgeStructure(const PolygonVertexArray& polygonVertex
                  "Error when creating a ConvexMesh: input PolygonVertexArray is not valid. Mesh with duplicated vertices is not supported.",  __FILE__, __LINE__);
 
         // Create a new error
-        errors.push_back(Error(std::string("Convex Mesh might have duplicated vertices (invalid Euler formula)")));
+        errors.push_back(Message(std::string("Convex Mesh might have duplicated vertices (invalid Euler formula)")));
 
         isValid = false;
     }
@@ -188,7 +188,7 @@ bool ConvexMesh::createHalfEdgeStructure(const PolygonVertexArray& polygonVertex
 }
 
 // Compute the faces normals
-bool ConvexMesh::computeFacesNormals(std::vector<Error>& errors) {
+bool ConvexMesh::computeFacesNormals(std::vector<Message>& errors) {
 
     bool isValid = true;
 
@@ -211,7 +211,7 @@ bool ConvexMesh::computeFacesNormals(std::vector<Error>& errors) {
             }
             else {
                isValid = false;
-               errors.push_back(Error("Face with index " + std::to_string(f) + " has a zero area"));
+               errors.push_back(Message("Face with index " + std::to_string(f) + " has a zero area"));
             }
         }
     }