Move SSNGVertexData and VxCmpFunction to CSmoothNormalGenerator

Author: kevyuu

include/nbl/asset/utils/CPolygonGeometryManipulator.h

@@ -9,6 +9,7 @@
 
 #include "nbl/asset/ICPUPolygonGeometry.h"
 #include "nbl/asset/utils/CGeometryManipulator.h"
+#include "nbl/asset/utils/CSmoothNormalGenerator.h"
 #include "nbl/asset/utils/CVertexHashGrid.h"
 
 namespace nbl::asset
@@ -19,33 +20,6 @@ class NBL_API2 CPolygonGeometryManipulator
 {
 	public:
 
-    struct SSNGVertexData
-    {
-      uint32_t index;									     //offset of the vertex into index buffer
-			// TODO: check whether separating hash and position into its own vector or even rehash the position everytime we need will result in VertexHashGrid become faster.
-			uint32_t hash;
-      hlsl::float32_t3 weightedNormal;
-      hlsl::float32_t3 position;							   //position of the vertex in 3D space
-
-			hlsl::float32_t3 getPosition() const
-			{
-				return position;
-			}
-
-			void setHash(uint32_t hash)
-			{
-				this->hash = hash;
-			}
-
-			uint32_t getHash() const
-			{
-				return hash;
-			};
-
-    };
-
-		using VxCmpFunction = std::function<bool(const SSNGVertexData&, const SSNGVertexData&, const ICPUPolygonGeometry*)>;
-
 		static inline void recomputeContentHashes(ICPUPolygonGeometry* geo)
 		{
 			if (!geo)
@@ -260,8 +234,9 @@ class NBL_API2 CPolygonGeometryManipulator
 
 		static core::smart_refctd_ptr<ICPUPolygonGeometry> createUnweldedList(const ICPUPolygonGeometry* inGeo);
 
+		using SSNGVxCmpFunction = CSmoothNormalGenerator::VxCmpFunction;
 		static core::smart_refctd_ptr<ICPUPolygonGeometry> createSmoothVertexNormal(const ICPUPolygonGeometry* inbuffer, bool enableWelding = false, float epsilon = 1.525e-5f,
-				VxCmpFunction vxcmp = [](const CPolygonGeometryManipulator::SSNGVertexData& v0, const CPolygonGeometryManipulator::SSNGVertexData& v1, const ICPUPolygonGeometry* buffer) 
+				SSNGVxCmpFunction vxcmp = [](const CSmoothNormalGenerator::SSNGVertexData& v0, const CSmoothNormalGenerator::SSNGVertexData& v1, const ICPUPolygonGeometry* buffer) 
 				{ 
 					static constexpr float cosOf45Deg = 0.70710678118f;
 					return dot(normalize(v0.weightedNormal),normalize(v1.weightedNormal)) > cosOf45Deg;

src/nbl/asset/utils/CPolygonGeometryManipulator.cpp

@@ -136,7 +136,7 @@ core::smart_refctd_ptr<ICPUPolygonGeometry> CPolygonGeometryManipulator::createU
     return outGeometry;
 }
 
-core::smart_refctd_ptr<ICPUPolygonGeometry> CPolygonGeometryManipulator::createSmoothVertexNormal(const ICPUPolygonGeometry* inPolygon, bool enableWelding, float epsilon, VxCmpFunction vxcmp)
+core::smart_refctd_ptr<ICPUPolygonGeometry> CPolygonGeometryManipulator::createSmoothVertexNormal(const ICPUPolygonGeometry* inPolygon, bool enableWelding, float epsilon, SSNGVxCmpFunction vxcmp)
 {
     if (!inPolygon)
     {

src/nbl/asset/utils/CSmoothNormalGenerator.cpp

@@ -13,12 +13,12 @@ namespace nbl
 {
 namespace asset
 {
-static bool operator<(uint32_t lhs, const CPolygonGeometryManipulator::SSNGVertexData& rhs)
+static bool operator<(uint32_t lhs, const CSmoothNormalGenerator::SSNGVertexData& rhs)
 {
 	return lhs < rhs.hash;
 }
 
-static bool operator<(const CPolygonGeometryManipulator::SSNGVertexData& lhs, uint32_t rhs)
+static bool operator<(const CSmoothNormalGenerator::SSNGVertexData& lhs, uint32_t rhs)
 {
 	return lhs.hash < rhs;
 }
@@ -29,7 +29,7 @@ static bool compareVertexPosition(const hlsl::float32_t3& a, const hlsl::float32
 	return (difference.x <= epsilon && difference.y <= epsilon && difference.z <= epsilon);
 }
 
-CSmoothNormalGenerator::Result CSmoothNormalGenerator::calculateNormals(const asset::ICPUPolygonGeometry* polygon, float epsilon, CPolygonGeometryManipulator::VxCmpFunction vxcmp)
+CSmoothNormalGenerator::Result CSmoothNormalGenerator::calculateNormals(const asset::ICPUPolygonGeometry* polygon, float epsilon, VxCmpFunction vxcmp)
 {
 	VertexHashMap vertexHashMap = setupData(polygon, epsilon);
 	const auto smoothPolygon = processConnectedVertices(polygon, vertexHashMap, epsilon,vxcmp);
@@ -67,7 +67,7 @@ CSmoothNormalGenerator::VertexHashMap CSmoothNormalGenerator::setupData(const as
 	return vertices;
 }
 
-core::smart_refctd_ptr<ICPUPolygonGeometry> CSmoothNormalGenerator::processConnectedVertices(const asset::ICPUPolygonGeometry* polygon, VertexHashMap& vertexHashMap, float epsilon, CPolygonGeometryManipulator::VxCmpFunction vxcmp)
+core::smart_refctd_ptr<ICPUPolygonGeometry> CSmoothNormalGenerator::processConnectedVertices(const asset::ICPUPolygonGeometry* polygon, VertexHashMap& vertexHashMap, float epsilon, VxCmpFunction vxcmp)
 {
 	auto outPolygon = core::move_and_static_cast<ICPUPolygonGeometry>(polygon->clone(0u));
 	static constexpr auto NormalFormat = EF_R32G32B32_SFLOAT;

src/nbl/asset/utils/CSmoothNormalGenerator.h

@@ -4,8 +4,8 @@
 #ifndef _NBL_ASSET_C_SMOOTH_NORMAL_GENERATOR_H_INCLUDED_
 #define _NBL_ASSET_C_SMOOTH_NORMAL_GENERATOR_H_INCLUDED_
 
+#include "nbl/asset/utils/CVertexHashGrid.h"
 
-#include "nbl/asset/utils/CPolygonGeometryManipulator.h"
 
 namespace nbl::asset 
 {
@@ -16,19 +16,46 @@ class CSmoothNormalGenerator
 		CSmoothNormalGenerator() = delete;
 		~CSmoothNormalGenerator() = delete;
 
-		using VertexHashMap = CVertexHashGrid<CPolygonGeometryManipulator::SSNGVertexData>;
+    struct SSNGVertexData
+    {
+      uint32_t index;									     //offset of the vertex into index buffer
+			// TODO: check whether separating hash and position into its own vector or even rehash the position everytime we need will result in VertexHashGrid become faster.
+			uint32_t hash;
+      hlsl::float32_t3 weightedNormal;
+      hlsl::float32_t3 position;							   //position of the vertex in 3D space
+
+			hlsl::float32_t3 getPosition() const
+			{
+				return position;
+			}
+
+			void setHash(uint32_t hash)
+			{
+				this->hash = hash;
+			}
+
+			uint32_t getHash() const
+			{
+				return hash;
+			};
+
+    };
+
+		using VxCmpFunction = std::function<bool(const SSNGVertexData&, const SSNGVertexData&, const ICPUPolygonGeometry*)>;
+
+		using VertexHashMap = CVertexHashGrid<SSNGVertexData>;
 
 	  struct Result
 	  {
 			VertexHashMap vertexHashGrid;
 			core::smart_refctd_ptr<ICPUPolygonGeometry> geom;
 	  };
-		static Result calculateNormals(const ICPUPolygonGeometry* polygon, float epsilon, CPolygonGeometryManipulator::VxCmpFunction function);
+		static Result calculateNormals(const ICPUPolygonGeometry* polygon, float epsilon, VxCmpFunction function);
 
 	private:
 
 		static VertexHashMap setupData(const ICPUPolygonGeometry* polygon, float epsilon);
-		static core::smart_refctd_ptr<ICPUPolygonGeometry> processConnectedVertices(const ICPUPolygonGeometry* polygon, VertexHashMap& vertices, float epsilon, CPolygonGeometryManipulator::VxCmpFunction vxcmp);
+		static core::smart_refctd_ptr<ICPUPolygonGeometry> processConnectedVertices(const ICPUPolygonGeometry* polygon, VertexHashMap& vertices, float epsilon, VxCmpFunction vxcmp);
 };
 
 }