Merge remote-tracking branch 'remotes/origin/smooth_normal_calculation'

Author: devsh

examples_tests

@@ -31,6 +31,7 @@ class NBL_API2 ICPUPolygonGeometry final : public IPolygonGeometry<ICPUBuffer>
         {
             const auto nextDepth = _depth ? (_depth-1):0;
             auto retval = core::smart_refctd_ptr<ICPUPolygonGeometry>(new ICPUPolygonGeometry());
+            retval->m_indexing = m_indexing;
             retval->m_positionView = m_positionView.clone(nextDepth);
             retval->m_jointOBBView = m_jointOBBView.clone(nextDepth);
             retval->m_indexView = m_indexView.clone(nextDepth);
@@ -96,6 +97,14 @@ class NBL_API2 ICPUPolygonGeometry final : public IPolygonGeometry<ICPUBuffer>
             }
             return false;
         }
+        inline void* getNormalPtr()
+        {
+            if (isMutable())
+            {
+              return m_normalView.getPointer();
+            }
+            return nullptr;
+        }
 
         //
         template<typename Visitor>

include/nbl/asset/ICPUPolygonGeometry.h

@@ -103,6 +103,8 @@ class NBL_API2 CGeometryCreator final : public core::IReferenceCounted
 		core::smart_refctd_ptr<ICPUPolygonGeometry> createCone(float radius, float length, uint16_t tesselation,
 				float oblique=0.f, CQuantNormalCache* const quantNormalCacheOverride=nullptr) const;
 
+		core::smart_refctd_ptr<ICPUPolygonGeometry> createPrism(float radius, float length, uint16_t sideCount) const;
+
 		core::smart_refctd_ptr<ICPUPolygonGeometry> createRectangle(const hlsl::float32_t2 size={0.5f,0.5f}) const;
 
 		core::smart_refctd_ptr<ICPUPolygonGeometry> createDisk(const float radius, const uint32_t tesselation) const;

include/nbl/asset/utils/CGeometryCreator.h

@@ -9,16 +9,26 @@
 
 #include "nbl/asset/ICPUPolygonGeometry.h"
 #include "nbl/asset/utils/CGeometryManipulator.h"
-#include "nbl/asset/utils/CQuantNormalCache.h"
-#include "nbl/asset/utils/CQuantQuaternionCache.h"
 
 namespace nbl::asset
 {
 
 //! An interface for easy manipulation of polygon geometries.
-class CPolygonGeometryManipulator
+class NBL_API2 CPolygonGeometryManipulator
 {
 	public:
+		//vertex data needed for CSmoothNormalGenerator
+		struct SSNGVertexData
+		{
+			uint32_t index;									     //offset of the vertex into index buffer
+			uint32_t hash;											       //
+			float wage;												         //angle wage of the vertex
+			hlsl::float32_t3 position;							   //position of the vertex in 3D space
+			hlsl::float32_t3 parentTriangleFaceNormal; //
+		};
+
+		using VxCmpFunction = std::function<bool(const SSNGVertexData&, const SSNGVertexData&, const ICPUPolygonGeometry*)>;
+
 		static inline void recomputeContentHashes(ICPUPolygonGeometry* geo)
 		{
 			if (!geo)
@@ -230,6 +240,16 @@ class CPolygonGeometryManipulator
 			EEM_QUATERNION,
 			EEM_COUNT
 		};
+
+		static core::smart_refctd_ptr<ICPUPolygonGeometry> createUnweldedList(const ICPUPolygonGeometry* inGeo);
+
+		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) 
+				{ 
+					static constexpr float cosOf45Deg = 0.70710678118f;
+					return dot(v0.parentTriangleFaceNormal,v1.parentTriangleFaceNormal) > cosOf45Deg;
+				});
+
 #if 0 // TODO: REDO
 		//! Struct used to pass chosen comparison method and epsilon to functions performing error metrics.
 		/**

include/nbl/asset/utils/CPolygonGeometryManipulator.h

@@ -662,6 +662,72 @@ core::smart_refctd_ptr<ICPUPolygonGeometry> CGeometryCreator::createCone(
 	return retval;
 }
 
+core::smart_refctd_ptr<ICPUPolygonGeometry> CGeometryCreator::createPrism(
+	float radius, float length, uint16_t sideCount) const
+{
+	using namespace hlsl;
+
+	if (sideCount < 3) return nullptr;
+
+	const auto halfIx = sideCount;
+	const uint32_t u32_vertexCount = 2 * sideCount;
+	if (u32_vertexCount > std::numeric_limits<uint16_t>::max())
+		return nullptr;
+	const auto vertexCount = static_cast<uint16_t>(u32_vertexCount);
+
+	auto retval = core::make_smart_refctd_ptr<ICPUPolygonGeometry>();
+	retval->setIndexing(IPolygonGeometryBase::TriangleList());
+
+	// Create indices
+	using index_t = uint16_t;
+	{
+		constexpr uint32_t RowCount = 2u;
+		const auto IndexCount = RowCount * 3 * sideCount;
+		auto indexView = createIndexView<index_t>(IndexCount, vertexCount - 1);
+		auto u = reinterpret_cast<index_t*>(indexView.src.buffer->getPointer());
+
+		for (uint16_t i = 0u, j = 0u; i < halfIx; ++i)
+		{
+			u[j++] = i;
+			u[j++] = (i + 1u) != halfIx ? (i + 1u):0u;
+			u[j++] = i + halfIx;
+			u[j++] = i + halfIx;
+			u[j++] = (i + 1u)!= halfIx ? (i + 1u):0u;
+			u[j++] = (i + 1u)!= halfIx ? (i + 1u + halfIx) : halfIx;
+		}
+
+		retval->setIndexView(std::move(indexView));
+	}
+
+	// Create vertex attributes with NONE usage because we have no clue how they'll be used
+	hlsl::float32_t3* positions;
+
+  {
+    shapes::AABB<4, float32_t> aabb;
+    aabb.maxVx = float32_t4(radius, radius, length, 0.0f);
+    aabb.minVx = float32_t4(-radius, -radius, 0.0f, 0.0f);
+    auto positionView = createPositionView(vertexCount, aabb);
+    positions = reinterpret_cast<decltype(positions)>(positionView.src.buffer->getPointer());
+    retval->setPositionView(std::move(positionView));
+  }
+
+	const float invSideCount = 1.f / static_cast<float>(sideCount);
+	const float step = 2.f * numbers::pi<float32_t> * invSideCount;
+	for (uint32_t i = 0u; i < sideCount; ++i)
+	{
+		const auto f_i = static_cast<float>(i);
+		hlsl::float32_t3 p(std::cos(f_i * step), std::sin(f_i * step), 0.f);
+		p *= radius;
+
+		positions[i] = { p.x, p.y, p.z };
+
+		positions[i + halfIx] = { p.x, p.y, length };
+	}
+
+	CPolygonGeometryManipulator::recomputeContentHashes(retval.get());
+	return retval;
+}
+
 core::smart_refctd_ptr<ICPUGeometryCollection> CGeometryCreator::createArrow(
 	const uint16_t tesselationCylinder,
 	const uint16_t tesselationCone,