[DEV] regactor the EPA triangle store

ephysics/collision/narrowphase/EPA/EdgeEPA.cpp

@@ -6,6 +6,7 @@
 #include <ephysics/collision/narrowphase/EPA/EdgeEPA.hpp>
 #include <ephysics/collision/narrowphase/EPA/TriangleEPA.hpp>
 #include <ephysics/collision/narrowphase/EPA/TrianglesStore.hpp>
+#include <etk/types.hpp>
 
 using namespace ephysics;
 
@@ -14,18 +15,22 @@ EdgeEPA::EdgeEPA() {
 	
 }
 
-EdgeEPA::EdgeEPA(TriangleEPA* ownerTriangle, int32_t index)
+EdgeEPA::EdgeEPA(TriangleEPA* ownerTriangle, int32_t index):
-		: m_ownerTriangle(ownerTriangle), m_index(index) {
+  m_ownerTriangle(ownerTriangle),
+  m_index(index) {
 	assert(index >= 0 && index < 3);
 }
 
-EdgeEPA::EdgeEPA(const EdgeEPA& edge) {
+EdgeEPA::EdgeEPA(const EdgeEPA& _obj):
-	m_ownerTriangle = edge.m_ownerTriangle;
+  m_ownerTriangle(_obj.m_ownerTriangle),
-	m_index = edge.m_index;
+  m_index(_obj.m_index) {
+	
 }
 
-EdgeEPA::~EdgeEPA() {
+EdgeEPA::EdgeEPA(EdgeEPA&& _obj):
-	
+  m_ownerTriangle(null) {
+	etk::swap(m_ownerTriangle, _obj.m_ownerTriangle);
+	etk::swap(m_index, _obj.m_index);
 }
 
 uint32_t EdgeEPA::getSourceVertexIndex() const {
@@ -72,7 +77,7 @@ bool EdgeEPA::computeSilhouette(const vec3* _vertices, uint32_t _indexNewVertex,
 				                                                                                                               _indexNewVertex,
 				                                                                                                               _triangleStore)) {
 				m_ownerTriangle->setIsObsolete(false);
-				_triangleStore.setNbTriangles(backup);
+				_triangleStore.resize(backup);
 				TriangleEPA* triangle = _triangleStore.newTriangle(_vertices, _indexNewVertex,
 																  getTargetVertexIndex(),
 																  getSourceVertexIndex());

ephysics/collision/narrowphase/EPA/EdgeEPA.hpp

@@ -26,9 +26,9 @@ class EdgeEPA {
 		/// Constructor
 		EdgeEPA(TriangleEPA* ownerTriangle, int32_t index);
 		/// Copy-constructor
-		EdgeEPA(const EdgeEPA& edge);
+		EdgeEPA(const EdgeEPA& _obj);
-		/// Destructor
+		/// Move-constructor
-		~EdgeEPA();
+		EdgeEPA(EdgeEPA&& _obj);
 		/// Return the pointer to the owner triangle
 		TriangleEPA* getOwnerTriangle() const {
 			return m_ownerTriangle;
@@ -44,9 +44,15 @@ class EdgeEPA {
 		/// Execute the recursive silhouette algorithm from this edge
 		bool computeSilhouette(const vec3* vertices, uint32_t index, TrianglesStore& triangleStore);
 		/// Assignment operator
-		EdgeEPA& operator=(const EdgeEPA& edge) {
+		EdgeEPA& operator=(const EdgeEPA& _obj) {
-			m_ownerTriangle = edge.m_ownerTriangle;
+			m_ownerTriangle = _obj.m_ownerTriangle;
-			m_index = edge.m_index;
+			m_index = _obj.m_index;
+			return *this;
+		}
+		/// Move operator
+		EdgeEPA& operator=(EdgeEPA&& _obj) {
+			etk::swap(m_ownerTriangle, _obj.m_ownerTriangle);
+			etk::swap(m_index, _obj.m_index);
 			return *this;
 		}
 };

ephysics/collision/narrowphase/EPA/TrianglesStore.cpp

@@ -6,10 +6,3 @@
 
 #include <ephysics/collision/narrowphase/EPA/TrianglesStore.hpp>
 
-ephysics::TrianglesStore::TrianglesStore() : m_numberTriangles(0) {
-	
-}
-
-ephysics::TrianglesStore::~TrianglesStore() {
-	
-}

ephysics/collision/narrowphase/EPA/TrianglesStore.hpp

@@ -5,6 +5,9 @@
  */
 #pragma once
 #include <ephysics/collision/narrowphase/EPA/TriangleEPA.hpp>
+#include <ephysics/debug.hpp>
+#include <etk/Array.hpp>
+
 namespace ephysics {
 	const uint32_t MAX_TRIANGLES = 200;	 // Maximum number of triangles
 	/**
@@ -12,48 +15,46 @@ namespace ephysics {
 	 */
 	class TrianglesStore {
 		private:
-			TriangleEPA m_triangles[MAX_TRIANGLES]; //!< Triangles
+			etk::Array<TriangleEPA, MAX_TRIANGLES> m_triangles; //!< Triangles
-			int32_t m_numberTriangles; //!< Number of triangles
 			/// Private copy-constructor
-			TrianglesStore(const TrianglesStore& triangleStore);
+			TrianglesStore(const TrianglesStore& triangleStore) = delete;
 			/// Private assignment operator
-			TrianglesStore& operator=(const TrianglesStore& triangleStore);
+			TrianglesStore& operator=(const TrianglesStore& triangleStore) = delete;
 		public:
 			/// Constructor
-			TrianglesStore();
+			TrianglesStore() = default;
-			/// Destructor
-			~TrianglesStore();
 			/// Clear all the storage
 			void clear() {
-				m_numberTriangles = 0;
+				m_triangles.clear();
 			}
 			/// Return the number of triangles
-			int32_t getNbTriangles() const {
+			size_t getNbTriangles() const {
-				return m_numberTriangles;
+				return m_triangles.size();
 			}
 			/// Set the number of triangles
-			void setNbTriangles(int32_t _backup) {
+			void resize(int32_t _backup) {
-				m_numberTriangles = _backup;
+				if (_backup > m_triangles.size()) {
+					EPHY_ERROR("RESIZE BIGGER : " <<  _backup << " > " << m_triangles.size());
+				}
+				m_triangles.resize(_backup);
 			}
 			/// Return the last triangle
 			TriangleEPA& last() {
-				assert(m_numberTriangles > 0);
+				return m_triangles.back();
-				return m_triangles[m_numberTriangles - 1];
 			}
 			/// Create a new triangle
 			TriangleEPA* newTriangle(const vec3* _vertices, uint32_t _v0, uint32_t _v1, uint32_t _v2) {
-				TriangleEPA* newTriangle = nullptr;
 				// If we have not reached the maximum number of triangles
-				if (m_numberTriangles != MAX_TRIANGLES) {
+				if (m_triangles.size() < MAX_TRIANGLES) {
-					newTriangle = &m_triangles[m_numberTriangles++];
+					TriangleEPA tmp(_v0, _v1, _v2);
-					newTriangle->set(_v0, _v1, _v2);
+					if (!tmp.computeClosestPoint(_vertices)) {
-					if (!newTriangle->computeClosestPoint(_vertices)) {
+						return null;
-						m_numberTriangles--;
-						newTriangle = nullptr;
 					}
+					m_triangles.pushBack(etk::move(tmp));
+					return &m_triangles.back();
 				}
-				// Return the new triangle
+				// We are at the limit (internal)
-				return newTriangle;
+				return null;
 			}
 			/// Access operator
 			TriangleEPA& operator[](int32_t _id) {