cauterize more stuff, start working on the Geometry Creator

Author: devsh

include/nbl/asset/IAssetManager.h

@@ -1,9 +1,8 @@
-// Copyright (C) 2018-2020 - DevSH Graphics Programming Sp. z O.O.
+// Copyright (C) 2018-2025 - DevSH Graphics Programming Sp. z O.O.
 // This file is part of the "Nabla Engine".
 // For conditions of distribution and use, see copyright notice in nabla.h
-
-#ifndef __NBL_ASSET_I_ASSET_MANAGER_H_INCLUDED__
-#define __NBL_ASSET_I_ASSET_MANAGER_H_INCLUDED__
+#ifndef _NBL_ASSET_I_ASSET_MANAGER_H_INCLUDED_
+#define _NBL_ASSET_I_ASSET_MANAGER_H_INCLUDED_
 
 #include <array>
 #include <ostream>
@@ -18,7 +17,7 @@
 #include "nbl/asset/interchange/IAssetWriter.h"
 
 #include "nbl/asset/utils/CCompilerSet.h"
-#include "nbl/asset/utils/IGeometryCreator.h"
+#include "nbl/asset/utils/CGeometryCreator.h"
 
 
 #define USE_MAPS_FOR_PATH_BASED_CACHE //benchmark and choose, paths can be full system paths
@@ -115,7 +114,7 @@ class NBL_API2 IAssetManager : public core::IReferenceCounted
         friend class IAssetLoader::IAssetLoaderOverride; // for access to non-const findAssets
 
         core::smart_refctd_ptr<IGeometryCreator> m_geometryCreator;
-        core::smart_refctd_ptr<IMeshManipulator> m_meshManipulator;
+        core::smart_refctd_ptr<CPolygonGeometryManipulator> m_meshManipulator;
         core::smart_refctd_ptr<CCompilerSet> m_compilerSet;
         // called as a part of constructor only
         void initializeMeshTools();
@@ -139,8 +138,8 @@ class NBL_API2 IAssetManager : public core::IReferenceCounted
 
 		inline system::ISystem* getSystem() const { return m_system.get(); }
 
-        const IGeometryCreator* getGeometryCreator() const;
-        IMeshManipulator* getMeshManipulator();
+        const CGeometryCreator* getGeometryCreator() const;
+        CPolygonGeometryManipulator* getPolygonGeometryManipulator();
         CCompilerSet* getCompilerSet() const { return m_compilerSet.get(); }
 
     protected:

include/nbl/asset/ICPUPolygonGeometry.h

@@ -160,7 +160,7 @@ class NBL_API2 ICPUPolygonGeometry final : public IAsset, public IPolygonGeometr
         template<typename Out>
         inline bool getPrimitiveIndices(Out* out, const uint32_t primitiveID) const
         {
-            return getPrimitiveIndices(out,primtiveID,primtiveID+1);
+            return getPrimitiveIndices(out,primitiveID,primitiveID+1);
         }
 
     protected:

include/nbl/asset/IPolygonGeometry.h

@@ -6,6 +6,7 @@
 
 
 #include "nbl/asset/IGeometry.h"
+#include "nbl/asset/RasterizationStates.h"
 #include "nbl/asset/IAccelerationStructure.h"
 
 #include <span>
@@ -253,7 +254,7 @@ class NBL_API2 IPolygonGeometry : public IIndexableGeometry<BufferType>, public
                 if (view.getElementCount()>(1u<<31))
                     return false;
             }
-            m_indexView = std::move(view);
+            base_t::m_indexView = std::move(view);
             return true;
         }
 

include/nbl/asset/asset.h

@@ -51,7 +51,7 @@
 #include "nbl/asset/ICPUSkeleton.h"
 
 // geometry
-#include "nbl/asset/utils/IGeometryCreator.h"
+#include "nbl/asset/utils/CGeometryCreator.h"
 #include "nbl/asset/ICPUGeometryCollection.h"
 #include "nbl/asset/ICPUMorphTargets.h"
 

include/nbl/asset/interchange/IAssetLoader.h

@@ -14,7 +14,7 @@
 namespace nbl::asset
 {
 
-class IMeshManipulator;
+class CPolygonGeometryManipulator;
 
 //! A class automating process of loading Assets from resources, eg. files
 /**
@@ -117,7 +117,7 @@ class NBL_API2 IAssetLoader : public virtual core::IReferenceCounted
 			const uint8_t* decryptionKey;
 			E_CACHING_FLAGS cacheFlags;
 			E_LOADER_PARAMETER_FLAGS loaderFlags;				//!< Flags having an impact on extraordinary tasks during loading process
-			IMeshManipulator* meshManipulatorOverride = nullptr;    //!< pointer used for specifying custom mesh manipulator to use, if nullptr - default mesh manipulator will be used
+			CPolygonGeometryManipulator* meshManipulatorOverride = nullptr;    //!< pointer used for specifying custom mesh manipulator to use, if nullptr - default mesh manipulator will be used
 			std::filesystem::path workingDirectory = "";
 			system::logger_opt_ptr logger;
 		};

include/nbl/asset/utils/IGeometryCreator.h renamed to include/nbl/asset/utils/CGeometryCreator.h

@@ -1,42 +1,31 @@
 // Copyright (C) 2018-2025 - DevSH Graphics Programming Sp. z O.O.
 // This file is part of the "Nabla Engine".
 // For conditions of distribution and use, see copyright notice in nabla.h
-#ifndef _NBL_ASSET_I_GEOMETRY_CREATOR_H_INCLUDED_
-#define _NBL_ASSET_I_GEOMETRY_CREATOR_H_INCLUDED_
+#ifndef _NBL_ASSET_C_GEOMETRY_CREATOR_H_INCLUDED_
+#define _NBL_ASSET_C_GEOMETRY_CREATOR_H_INCLUDED_
 
 
 #include "nbl/core/declarations.h"
 
-#include "nbl/asset/ICPUPolygonGeometry.h"
-#include "nbl/asset/utils/IMeshManipulator.h"
+#include "nbl/asset/utils/CPolygonGeometryManipulator.h"
 
 
 namespace nbl::asset
 {
 
 //! Helper class for creating geometry on the fly.
 /** You can get an instance of this class through ISceneManager::getGeometryCreator() */
-class IGeometryCreator : public core::IReferenceCounted
+class CGeometryCreator final : public core::IReferenceCounted
 {
-		_NBL_INTERFACE_CHILD(IGeometryCreator) {}
-	public:
-		struct return_type
-		{
-			SVertexInputParams inputParams;
-			SPrimitiveAssemblyParams assemblyParams;
-			SBufferBinding<ICPUBuffer> bindings[ICPUMeshBuffer::MAX_ATTR_BUF_BINDING_COUNT];
-			SBufferBinding<ICPUBuffer> indexBuffer;
-			E_INDEX_TYPE indexType;
-			uint32_t indexCount;
-			core::aabbox3df bbox;
-		};
+		core::smart_refctd_ptr<CPolygonGeometryManipulator> m_defaultPolygonManipulator;
 
+	public:
 		//! Creates a simple cube mesh.
 		/**
 		\param size Dimensions of the cube.
 		\return Generated mesh.
 		*/
-		virtual return_type createCubeMesh(const core::vector3df& size=core::vector3df(5.f,5.f,5.f)) const =0;
+		core::smart_refctd_ptr<ICPUPolygonGeometry> createCube(const hlsl::float32_t3 size={5.f,5.f,5.f}) const;
 
 
 		//! Create an arrow mesh, composed of a cylinder and a cone.
@@ -53,11 +42,11 @@ class IGeometryCreator : public core::IReferenceCounted
 		\param colorCone color of the cone
 		\return Generated mesh.
 		*/
-		virtual return_type createArrowMesh(const uint32_t tesselationCylinder = 4,
+		core::smart_refctd_ptr<ICPUPolygonGeometry> createArrow(const uint32_t tesselationCylinder = 4,
 				const uint32_t tesselationCone = 8, const float height = 1.f,
 				const float cylinderHeight = 0.6f, const float widthCylinder = 0.05f,
 				const float widthCone = 0.3f, const video::SColor colorCylinder = 0xFFFFFFFF,
-				const video::SColor colorCone = 0xFFFFFFFF, IMeshManipulator* const meshManipulatorOverride = nullptr) const =0;
+				const video::SColor colorCone = 0xFFFFFFFF, IMeshManipulator* const meshManipulatorOverride = nullptr) const;
 
 
 		//! Create a sphere mesh.
@@ -67,8 +56,8 @@ class IGeometryCreator : public core::IReferenceCounted
 		\param polyCountY Number of quads used for the vertical tiling
 		\return Generated mesh.
 		*/
-		virtual return_type createSphereMesh(float radius = 5.f,
-				uint32_t polyCountX = 16, uint32_t polyCountY = 16, IMeshManipulator* const meshManipulatorOverride = nullptr) const =0;
+		core::smart_refctd_ptr<ICPUPolygonGeometry> createSphere(float radius = 5.f,
+				uint32_t polyCountX = 16, uint32_t polyCountY = 16, IMeshManipulator* const meshManipulatorOverride = nullptr) const;
 
 		//! Create a cylinder mesh.
 		/**
@@ -80,9 +69,9 @@ class IGeometryCreator : public core::IReferenceCounted
 		\param oblique (to be documented)
 		\return Generated mesh.
 		*/
-		virtual return_type createCylinderMesh(float radius, float length,
+		core::smart_refctd_ptr<ICPUPolygonGeometry> createCylinder(float radius, float length,
 				uint32_t tesselation,
-				const video::SColor& color=video::SColor(0xffffffff), IMeshManipulator* const meshManipulatorOverride = nullptr) const =0;
+				const video::SColor& color=video::SColor(0xffffffff), IMeshManipulator* const meshManipulatorOverride = nullptr) const;
 
 		//! Create a cone mesh.
 		/**
@@ -94,14 +83,14 @@ class IGeometryCreator : public core::IReferenceCounted
 		\param oblique (to be documented)
 		\return Generated mesh.
 		*/
-		virtual return_type createConeMesh(float radius, float length, uint32_t tesselation,
+		core::smart_refctd_ptr<ICPUPolygonGeometry> createCone(float radius, float length, uint32_t tesselation,
 				const video::SColor& colorTop=video::SColor(0xffffffff),
 				const video::SColor& colorBottom=video::SColor(0xffffffff),
-				float oblique=0.f, IMeshManipulator* const meshManipulatorOverride = nullptr) const =0;
+				float oblique=0.f, IMeshManipulator* const meshManipulatorOverride = nullptr) const;
 
-		virtual return_type createRectangleMesh(const core::vector2df_SIMD& size = core::vector2df_SIMD(0.5f, 0.5f)) const = 0;
+		core::smart_refctd_ptr<ICPUPolygonGeometry> createRectangle(const core::vector2df_SIMD& size = core::vector2df_SIMD(0.5f, 0.5f)) const;
 
-		virtual return_type createDiskMesh(float radius, uint32_t tesselation) const = 0;
+		core::smart_refctd_ptr<ICPUPolygonGeometry> createDisk(float radius, uint32_t tesselation) const;
 
 		//! Create a icosphere geometry
 		/**
@@ -110,7 +99,7 @@ class IGeometryCreator : public core::IReferenceCounted
 			\param smooth Specifies whether vertecies should be built for smooth or flat shading.
 		*/
 
-		virtual return_type createIcoSphere(float radius = 1.0f, uint32_t subdivision = 1, bool smooth = false) const = 0;
+		core::smart_refctd_ptr<ICPUPolygonGeometry> createIcoSphere(float radius = 1.0f, uint32_t subdivision = 1, bool smooth = false) const;
 
 };
 

include/nbl/asset/utils/CPolygonGeometryManipulator.h

@@ -567,6 +567,137 @@ class NBL_API2 CPolygonGeometryManipulator
 #endif
 };
 
+#if 0
+
+//! An interface for easy manipulation of meshes.
+/** Scale, set alpha value, flip surfaces, and so on. This exists for fixing
+problems with wrong imported or exported meshes quickly after loading. It is
+not intended for doing mesh modifications and/or animations during runtime.
+*/
+class CMeshManipulator : public IMeshManipulator
+{
+		struct SAttrib
+		{
+			E_FORMAT type;
+			E_FORMAT prevType;
+			size_t size;
+			uint32_t vaid;
+			size_t offset;
+
+			SAttrib() : type(EF_UNKNOWN), size(0), vaid(ICPUMeshBuffer::MAX_VERTEX_ATTRIB_COUNT) {}
+
+			friend bool operator>(const SAttrib& _a, const SAttrib& _b) { return _a.size > _b.size; }
+		};
+		struct SAttribTypeChoice
+		{
+			E_FORMAT type;
+		};
+
+	public:
+		static core::smart_refctd_ptr<ICPUMeshBuffer> createMeshBufferFetchOptimized(const ICPUMeshBuffer* _inbuffer);
+
+		CQuantNormalCache* getQuantNormalCache() override { return &quantNormalCache; }
+		CQuantQuaternionCache* getQuantQuaternionCache() override { return &quantQuaternionCache; }
+
+	private:
+		friend class IMeshManipulator;
+
+		template<typename IdxT>
+		static void _filterInvalidTriangles(ICPUMeshBuffer* _input);
+
+		//! Meant to create 32bit index buffer from subrange of index buffer containing 16bit indices. Remember to set to index buffer offset to 0 after mapping buffer resulting from this function.
+		static inline core::smart_refctd_ptr<ICPUBuffer> create32BitFrom16BitIdxBufferSubrange(const uint16_t* _in, uint32_t _idxCount)
+		{
+			if (!_in)
+				return nullptr;
+
+			auto out = ICPUBuffer::create({ sizeof(uint32_t) * _idxCount });
+
+			auto* outPtr = reinterpret_cast<uint32_t*>(out->getPointer());
+
+			for (uint32_t i=0u; i<_idxCount; ++i)
+				outPtr[i] = _in[i];
+
+			return out;
+		}
+
+		static core::vector<core::vectorSIMDf> findBetterFormatF(E_FORMAT* _outType, size_t* _outSize, E_FORMAT* _outPrevType, const ICPUMeshBuffer* _meshbuffer, uint32_t _attrId, const SErrorMetric& _errMetric, CQuantNormalCache& _cache);
+
+		struct SIntegerAttr
+		{
+			uint32_t pointer[4];
+		};
+		static core::vector<SIntegerAttr> findBetterFormatI(E_FORMAT* _outType, size_t* _outSize, E_FORMAT* _outPrevType, const ICPUMeshBuffer* _meshbuffer, uint32_t _attrId, const SErrorMetric& _errMetric);
+
+		//E_COMPONENT_TYPE getBestTypeF(bool _normalized, E_COMPONENTS_PER_ATTRIBUTE _cpa, size_t* _outSize, E_COMPONENTS_PER_ATTRIBUTE* _outCpa, const float* _min, const float* _max) const;
+		static E_FORMAT getBestTypeI(E_FORMAT _originalType, size_t* _outSize, const uint32_t* _min, const uint32_t* _max);
+		static core::vector<SAttribTypeChoice> findTypesOfProperRangeF(E_FORMAT _type, size_t _sizeThreshold, const float* _min, const float* _max, const SErrorMetric& _errMetric);
+
+		//! Calculates quantization errors and compares them with given epsilon.
+		/** @returns false when first of calculated errors goes above epsilon or true if reached end without such. */
+		static bool calcMaxQuantizationError(const SAttribTypeChoice& _srcType, const SAttribTypeChoice& _dstType, const core::vector<core::vectorSIMDf>& _data, const SErrorMetric& _errMetric, CQuantNormalCache& _cache);
+
+		template<typename InType, typename OutType>
+		static inline core::smart_refctd_ptr<ICPUBuffer> lineStripsToLines(const void* _input, uint32_t& _idxCount)
+		{
+			const auto outputSize = _idxCount = (_idxCount - 1) * 2;
+			
+			auto output = ICPUBuffer::create({ sizeof(OutType)*outputSize });
+			const auto* iptr = reinterpret_cast<const InType*>(_input);
+			auto* optr = reinterpret_cast<OutType*>(output->getPointer());
+			for (uint32_t i = 0, j = 0; i < outputSize;)
+			{
+				optr[i++] = iptr[j++];
+				optr[i++] = iptr[j];
+			}
+			return output;
+		}
+
+		template<typename InType, typename OutType>
+		static inline core::smart_refctd_ptr<ICPUBuffer> triangleStripsToTriangles(const void* _input, uint32_t& _idxCount)
+		{
+			const auto outputSize = _idxCount = (_idxCount - 2) * 3;
+			
+			auto output = ICPUBuffer::create({ sizeof(OutType)*outputSize });
+			const auto* iptr = reinterpret_cast<const InType*>(_input);
+			auto* optr = reinterpret_cast<OutType*>(output->getPointer());
+			for (uint32_t i = 0, j = 0; i < outputSize; j += 2)
+			{
+				optr[i++] = iptr[j + 0];
+				optr[i++] = iptr[j + 1];
+				optr[i++] = iptr[j + 2];
+				if (i == outputSize)
+					break;
+				optr[i++] = iptr[j + 2];
+				optr[i++] = iptr[j + 1];
+				optr[i++] = iptr[j + 3];
+			}
+			return output;
+		}
+
+		template<typename InType, typename OutType>
+		static inline core::smart_refctd_ptr<ICPUBuffer> trianglesFanToTriangles(const void* _input, uint32_t& _idxCount)
+		{
+			const auto outputSize = _idxCount = (_idxCount - 2) * 3;
+
+			auto output = ICPUBuffer::create({ sizeof(OutType)*outputSize });
+			const auto* iptr = reinterpret_cast<const InType*>(_input);
+			auto* optr = reinterpret_cast<OutType*>(output->getPointer());
+			for (uint32_t i = 0, j = 1; i < outputSize;)
+			{
+				optr[i++] = iptr[0];
+				optr[i++] = iptr[j++];
+				optr[i++] = iptr[j];
+			}
+			return output;
+		}
+
+	private:	
+		CQuantNormalCache quantNormalCache;
+		CQuantQuaternionCache quantQuaternionCache;
+};
+#endif
+
 // TODO: Utility in another header for GeometryCollection to compute AABBs, deal with skins (joints), etc.
 
 } // end namespace nbl::asset