add IGPUPolygonGeometry and attempt AssetConverter implementation for it

Author: devsh

include/nbl/asset/ICPUPolygonGeometry.h

@@ -17,10 +17,9 @@ class NBL_API2 ICPUPolygonGeometry final : public IPolygonGeometry<ICPUBuffer>
 {
         using base_t = IPolygonGeometry<ICPUBuffer>;
 
-    protected:
+    public:
         using SDataView = base_t::SDataView;
 
-    public:
         inline ICPUPolygonGeometry() = default;
 
         constexpr static inline auto AssetType = ET_GEOMETRY;
@@ -73,7 +72,7 @@ class NBL_API2 ICPUPolygonGeometry final : public IPolygonGeometry<ICPUBuffer>
             return false;
         }
 
-        // 
+        //
         inline bool setJointOBBView(SDataView&& view)
         {
             if (isMutable())

include/nbl/video/IGPUPolygonGeometry.h

@@ -0,0 +1,66 @@
+// Copyright (C) 2018-2023 - 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_VIDEO_I_GPU_POLYGON_GEOMETRY_H_INCLUDED_
+#define _NBL_VIDEO_I_GPU_POLYGON_GEOMETRY_H_INCLUDED_
+
+
+#include "nbl/asset/IPolygonGeometry.h"
+
+#include "nbl/video/IGPUBuffer.h"
+
+
+namespace nbl::video
+{
+
+//
+class IGPUPolygonGeometry final : public asset::IPolygonGeometry<const IGPUBuffer>
+{
+        using base_t = asset::IPolygonGeometry<const IGPUBuffer>;
+
+	public:
+        using SDataView = base_t::SDataView;
+        struct SCreationParams
+        {
+            SDataView positionView = {};
+            SDataView jointOBBView = {};
+            SDataView indexView = {};
+            const IIndexingCallback* indexing = nullptr;
+            SDataView normalView = {};
+            std::span<const SJointWeight> jointWeightViews = {};
+            std::span<const SDataView> auxAttributeViews = {};
+            uint32_t jointCount = 0;
+        };
+        static inline core::smart_refctd_ptr<IGPUPolygonGeometry> create(SCreationParams&& params)
+        {
+            auto retval = core::smart_refctd_ptr<IGPUPolygonGeometry>(new IGPUPolygonGeometry(),core::dont_grab);
+            retval->m_positionView = params.positionView;
+            if (params.jointCount)
+                retval->m_jointOBBView = params.jointOBBView;
+            retval->m_indexView = params.indexView;
+            retval->m_indexing = params.indexing;
+            if (params.jointCount)
+                retval->m_jointWeightViews.insert(retval->m_jointWeightViews.begin(),params.jointWeightViews.begin(),params.jointWeightViews.end());
+            retval->m_normalView = params.normalView;
+            retval->m_auxAttributeViews.insert(retval->m_auxAttributeViews.begin(),params.auxAttributeViews.begin(),params.auxAttributeViews.end());
+            retval->m_jointCount = params.jointCount;
+            if (!retval->valid())
+                return nullptr;
+            return retval;
+        }
+
+        // passthrough
+#if 0
+        inline const SDataView& getNormalView() const {return base_t::getNormalView();}
+        inline const core::vector<SJointWeight>& getJointWeightViews() const {return base_t::getJointWeightViews();}
+        inline const core::vector<SDataView>& getAuxAttributeViews() const {return base_t::getAuxAttributeViews();}        
+#endif
+
+	private:
+        inline IGPUPolygonGeometry() = default;
+        inline ~IGPUPolygonGeometry() = default;
+};
+
+}
+
+#endif

include/nbl/video/asset_traits.h

@@ -20,6 +20,8 @@
 #include "nbl/video/IGPUImageView.h"
 #include "nbl/asset/ICPUAccelerationStructure.h"
 #include "nbl/video/IGPUAccelerationStructure.h"
+#include "nbl/asset/ICPUPolygonGeometry.h"
+#include "nbl/video/IGPUPolygonGeometry.h"
 
 
 namespace nbl::video
@@ -229,6 +231,20 @@ struct asset_traits<asset::ICPUDescriptorSet>
 };
 
 
+template<>
+struct asset_traits<asset::ICPUPolygonGeometry>
+{
+	// the asset type
+	using asset_t = asset::ICPUPolygonGeometry;
+	// depends on `ICPUBuffer`
+	constexpr static inline bool HasChildren = true;
+	// the video type
+	using video_t = IGPUPolygonGeometry;
+	// lookup type
+	using lookup_t = const video_t*;
+};
+
+
 /* TODO
 template<>
 struct asset_traits<asset::ICPUFramebuffer>;

include/nbl/video/utilities/CAssetConverter.h

@@ -50,8 +50,9 @@ class CAssetConverter : public core::IReferenceCounted
 			asset::ICPUComputePipeline,
 			asset::ICPURenderpass,
 			asset::ICPUGraphicsPipeline,
-			asset::ICPUDescriptorSet
+			asset::ICPUDescriptorSet,
 			//asset::ICPUFramebuffer doesn't exist yet XD
+			asset::ICPUPolygonGeometry
 		>;
 
 		struct SCreationParams
@@ -430,6 +431,29 @@ class CAssetConverter : public core::IReferenceCounted
 
 				bool invalid = true;
 		};
+		template<>
+		struct NBL_API2 patch_impl_t<asset::ICPUPolygonGeometry>
+		{
+			public:
+				PATCH_IMPL_BOILERPLATE(asset::ICPUPolygonGeometry);
+
+				using usage_flags_t = IGPUBuffer::E_USAGE_FLAGS;
+				// assume programmable pulling for all attributes
+				core::bitflag<usage_flags_t> positionBufferUsages = usage_flags_t::EUF_SHADER_DEVICE_ADDRESS_BIT;
+				// assume nothing
+				core::bitflag<usage_flags_t> indexBufferUsages = usage_flags_t::EUF_NONE;
+				core::bitflag<usage_flags_t> otherBufferUsages = usage_flags_t::EUF_SHADER_DEVICE_ADDRESS_BIT;
+				
+			protected:
+				inline std::pair<bool,this_t> combine(const this_t& other) const
+				{
+					this_t retval = *this;
+					retval.indexBufferUsages |= other.indexBufferUsages;
+					retval.positionBufferUsages |= other.positionBufferUsages;
+					retval.otherBufferUsages |= other.otherBufferUsages;
+					return {true,retval};
+				}
+		};
 #undef PATCH_IMPL_BOILERPLATE
 		// The default specialization provides simple equality operations and hash operations, this will work as long as your patch_impl_t doesn't:
 		// - use a container like `core::vector<T>`, etc.
@@ -554,6 +578,7 @@ class CAssetConverter : public core::IReferenceCounted
 						virtual const patch_t<asset::ICPUBufferView>* operator()(const lookup_t<asset::ICPUBufferView>&) const = 0;
 						virtual const patch_t<asset::ICPUImageView>* operator()(const lookup_t<asset::ICPUImageView>&) const = 0;
 						virtual const patch_t<asset::ICPUPipelineLayout>* operator()(const lookup_t<asset::ICPUPipelineLayout>&) const = 0;
+						virtual const patch_t<asset::ICPUPolygonGeometry>* operator()(const lookup_t<asset::ICPUPolygonGeometry>&) const = 0;
 
 						// certain items are not patchable, so there's no `patch_t` with non zero size
 						inline const patch_t<asset::ICPUDescriptorSetLayout>* operator()(const lookup_t<asset::ICPUDescriptorSetLayout>& unpatchable) const
@@ -568,7 +593,7 @@ class CAssetConverter : public core::IReferenceCounted
 						{
 							return unpatchable.patch;
 						}
-
+						
 						// while other things are top level assets in the graph and `operator()` would never be called on their patch
 				};
 				// `cacheMistrustLevel` is how deep from `asset` do we start trusting the cache to contain correct non stale hashes
@@ -681,6 +706,7 @@ class CAssetConverter : public core::IReferenceCounted
 					bool operator()(lookup_t<asset::ICPURenderpass>);
 					bool operator()(lookup_t<asset::ICPUGraphicsPipeline>);
 					bool operator()(lookup_t<asset::ICPUDescriptorSet>);
+					bool operator()(lookup_t<asset::ICPUPolygonGeometry>);
 				};
 
 				//