Move mMinBounds and mMaxBounds from ConvexMeshShape into ConvexMesh

Author: DanielChappuis

include/reactphysics3d/collision/ConvexMesh.h

@@ -64,6 +64,12 @@ 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;
+
         // -------------------- Methods -------------------- //
 
         /// Constructor
@@ -107,7 +113,13 @@ class ConvexMesh {
         const HalfEdgeStructure& getHalfEdgeStructure() const;
 
         /// Return the centroid of the mesh
-        Vector3 getCentroid() const;
+        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;
 
         /// Compute and return the volume of the mesh
         decimal getVolume() const;
@@ -165,10 +177,26 @@ RP3D_FORCE_INLINE const HalfEdgeStructure& ConvexMesh::getHalfEdgeStructure() co
 /**
  * @return The centroid of the mesh
  */
-RP3D_FORCE_INLINE Vector3 ConvexMesh::getCentroid() const {
+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;
+}
+
 }
 
 #endif

include/reactphysics3d/collision/shapes/ConvexMeshShape.h

@@ -54,25 +54,14 @@ class ConvexMeshShape : public ConvexPolyhedronShape {
         /// Convex mesh
         ConvexMesh* mConvexMesh;
 
-        // TODO : Maybe store min/max bounds in the ConvexMesh instead
-
-        /// 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;
-
-        /// Scale of the mesh
+        /// Scale to apply to the mesh
         Vector3 mScale;
 
         // -------------------- Methods -------------------- //
 
         /// Constructor
         ConvexMeshShape(ConvexMesh* convexMesh,  MemoryAllocator& allocator, const Vector3& scale = Vector3(1,1,1));
 
-        /// Recompute the bounds of the mesh
-        void recalculateBounds();
-
         /// Return a local support point in a given direction without the object margin.
         virtual Vector3 getLocalSupportPointWithoutMargin(const Vector3& direction) const override;
 
@@ -163,7 +152,6 @@ RP3D_FORCE_INLINE const Vector3& ConvexMeshShape::getScale() const {
 /// after changing the scale of a collision shape
 RP3D_FORCE_INLINE void ConvexMeshShape::setScale(const Vector3& scale) {
     mScale = scale;
-    recalculateBounds();
     notifyColliderAboutChangedSize();
 }
 
@@ -173,8 +161,8 @@ RP3D_FORCE_INLINE void ConvexMeshShape::setScale(const Vector3& scale) {
  * @param max The maximum bounds of the shape in local-space coordinates
  */
 RP3D_FORCE_INLINE void ConvexMeshShape::getLocalBounds(Vector3& min, Vector3& max) const {
-    min = mMinBounds;
-    max = mMaxBounds;
+    min = mConvexMesh->getMinBounds() * mScale;
+    max = mConvexMesh->getMaxBounds() * mScale;
 }
 
 // Return the local inertia tensor of the collision shape.
@@ -184,8 +172,11 @@ RP3D_FORCE_INLINE void ConvexMeshShape::getLocalBounds(Vector3& min, Vector3& ma
 * @param mass Mass to use to compute the inertia tensor of the collision shape
 */
 RP3D_FORCE_INLINE Vector3 ConvexMeshShape::getLocalInertiaTensor(decimal mass) const {
+
+    // 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) * (mMaxBounds - mMinBounds);
+    const Vector3 realExtent = decimal(0.5) * mScale * (mConvexMesh->getMaxBounds() - mConvexMesh->getMinBounds());
     assert(realExtent.x > 0 && realExtent.y > 0 && realExtent.z > 0);
     const decimal xSquare = realExtent.x * realExtent.x;
     const decimal ySquare = realExtent.y * realExtent.y;

src/collision/ConvexMesh.cpp

@@ -42,7 +42,7 @@ using namespace reactphysics3d;
  */
 ConvexMesh::ConvexMesh(MemoryAllocator& allocator)
                : mMemoryAllocator(allocator), mHalfEdgeStructure(allocator, 6, 8, 24),
-                 mVertices(allocator), mFacesNormals(allocator) {
+                 mVertices(allocator), mFacesNormals(allocator), mMinBounds(0, 0, 0), mMaxBounds(0, 0, 0)  {
 
 }
 
@@ -82,12 +82,23 @@ bool ConvexMesh::copyVertices(const PolygonVertexArray& polygonVertexArray, std:
     bool isValid = true;
 
     mCentroid.setToZero();
+    mMinBounds = polygonVertexArray.getVertex(0);
+    mMaxBounds = polygonVertexArray.getVertex(0);
 
     for (uint32 i=0 ; i < polygonVertexArray.getNbVertices(); i++) {
 
         const Vector3 vertex = polygonVertexArray.getVertex(i);
         mVertices.add(vertex);
         mCentroid += vertex;
+
+        if (vertex.x > mMaxBounds.x) mMaxBounds.x = vertex.x;
+        if (vertex.x < mMinBounds.x) mMinBounds.x = vertex.x;
+
+        if (vertex.y > mMaxBounds.y) mMaxBounds.y = vertex.y;
+        if (vertex.y < mMinBounds.y) mMinBounds.y = vertex.y;
+
+        if (vertex.z > mMaxBounds.z) mMaxBounds.z = vertex.z;
+        if (vertex.z < mMinBounds.z) mMinBounds.z = vertex.z;
     }
 
     if (getNbVertices() > 0) {

src/collision/shapes/ConvexMeshShape.cpp

@@ -41,10 +41,8 @@ using namespace reactphysics3d;
  */
 ConvexMeshShape::ConvexMeshShape(ConvexMesh* convexMesh, MemoryAllocator& allocator, const Vector3& scale)
                 : ConvexPolyhedronShape(CollisionShapeName::CONVEX_MESH, allocator), mConvexMesh(convexMesh),
-                  mMinBounds(0, 0, 0), mMaxBounds(0, 0, 0), mScale(scale) {
+                  mScale(scale) {
 
-    // Recalculate the bounds of the mesh
-    recalculateBounds();
 }
 
 // Return a local support point in a given direction without the object margin.
@@ -79,30 +77,6 @@ Vector3 ConvexMeshShape::getLocalSupportPointWithoutMargin(const Vector3& direct
     return mConvexMesh->getVertex(indexMaxDotProduct) * mScale;
 }
 
-// Recompute the bounds of the mesh
-void ConvexMeshShape::recalculateBounds() {
-
-    mMinBounds = mConvexMesh->getVertex(0);
-    mMaxBounds = mConvexMesh->getVertex(0);
-
-    // For each vertex of the mesh
-    for (uint32 i=1; i<mConvexMesh->getNbVertices(); i++) {
-
-        if (mConvexMesh->getVertex(i).x > mMaxBounds.x) mMaxBounds.x = mConvexMesh->getVertex(i).x;
-        if (mConvexMesh->getVertex(i).x < mMinBounds.x) mMinBounds.x = mConvexMesh->getVertex(i).x;
-
-        if (mConvexMesh->getVertex(i).y > mMaxBounds.y) mMaxBounds.y = mConvexMesh->getVertex(i).y;
-        if (mConvexMesh->getVertex(i).y < mMinBounds.y) mMinBounds.y = mConvexMesh->getVertex(i).y;
-
-        if (mConvexMesh->getVertex(i).z > mMaxBounds.z) mMaxBounds.z = mConvexMesh->getVertex(i).z;
-        if (mConvexMesh->getVertex(i).z < mMinBounds.z) mMinBounds.z = mConvexMesh->getVertex(i).z;
-    }
-
-    // Apply the local scaling factor
-    mMaxBounds = mMaxBounds * mScale;
-    mMinBounds = mMinBounds * mScale;
-}
-
 // Raycast method with feedback information
 /// This method implements the technique in the book "Real-time Collision Detection" by
 /// Christer Ericson.