pull from asset-conversion-v3

Author: tad1

examples_tests

@@ -59,15 +59,15 @@ class IDeviceMemoryBacked : public IBackendObject
         struct SDeviceMemoryRequirements
         {
             // the allocation size required to back the resource
-            size_t   size; // TODO: C++23 default-initialize to 0ull
+            size_t   size = 0ull;
             // a bitmask of all memory type IDs (one bit per ID) which are compatible with the resource
-            uint32_t memoryTypeBits; // TODO: C++23 default-initialize to 0x0u
+            uint32_t memoryTypeBits = 0x0u;
             // what alignment should be memory allocation should have, encoded as Log2 as alignments need to be PoT
-            uint32_t alignmentLog2 : 6; // TODO: C++23 default-initialize to 63
+            uint32_t alignmentLog2 : 6 = 63;
             // whether you'll get better performance from having one allocation exclusively bound to this resource
-            uint32_t prefersDedicatedAllocation : 1; // TODO: C++23 default-initialize to true
+            uint32_t prefersDedicatedAllocation : 1 = true;
             // whether you need to have one allocation exclusively bound to this resource, always true in OpenGL
-            uint32_t requiresDedicatedAllocation : 1; // TODO: C++23 default-initialize to true
+            uint32_t requiresDedicatedAllocation : 1 = true;
         };
         static_assert(sizeof(SDeviceMemoryRequirements)==16);
         //! Before allocating memory from the driver or trying to bind a range of an existing allocation
@@ -113,6 +113,9 @@ class IDeviceMemoryBacked : public IBackendObject
         SDeviceMemoryRequirements m_cachedMemoryReqs;
 };
 
+template<typename T>
+concept DeviceMemoryBacked = std::is_base_of_v<IDeviceMemoryBacked,T>;
+
 } // end namespace nbl::video
 
 #endif

include/nbl/video/IDeviceMemoryBacked.h

@@ -106,10 +106,33 @@ struct asset_traits<asset::ICPUComputePipeline>
 	using lookup_t = const video_t*;
 };
 
-/*
+
 template<>
-struct asset_traits<asset::ICPUDescriptorSetLayout> { using GPUObjectType = IGPUDescriptorSetLayout; };
-*/
+struct asset_traits<asset::ICPURenderpass>
+{
+	// the asset type
+	using asset_t = asset::ICPURenderpass;
+	// we don't need to descend during DFS into other assets
+	constexpr static inline bool HasChildren = false;
+	// the video type
+	using video_t = IGPURenderpass;
+	// lookup type
+	using lookup_t = const video_t*;
+};
+
+template<>
+struct asset_traits<asset::ICPUGraphicsPipeline>
+{
+	// the asset type
+	using asset_t = asset::ICPUGraphicsPipeline;
+	// we reference a pipeline layout and a renderpass
+	constexpr static inline bool HasChildren = true;
+	// the video type
+	using video_t = IGPUGraphicsPipeline;
+	// lookup type
+	using lookup_t = const video_t*;
+};
+
 
 template<>
 struct asset_traits<asset::ICPUBuffer>
@@ -138,25 +161,81 @@ struct asset_traits<asset::ICPUBufferView>
 };
 
 
-/*
 template<>
-struct asset_traits<asset::ICPUImage> { using GPUObjectType = IGPUImage; };
+struct asset_traits<asset::ICPUImage>
+{
+	// the asset type
+	using asset_t = asset::ICPUImage;
+	// we don't need to descend during DFS into other assets
+	constexpr static inline bool HasChildren = false;
+	// the video type
+	using video_t = IGPUImage;
+	// lookup type
+	using lookup_t = const video_t*;
+};
 
 template<>
-struct asset_traits<asset::ICPUImageView> { using GPUObjectType = IGPUImageView; };
-*/
+struct asset_traits<asset::ICPUImageView>
+{
+	// the asset type
+	using asset_t = asset::ICPUImageView;
+	// depends on ICPUImage
+	constexpr static inline bool HasChildren = true;
+	// the video type
+	using video_t = IGPUImageView;
+	// lookup type
+	using lookup_t = const video_t*;
+};
+
+
+template<>
+struct asset_traits<asset::ICPUBottomLevelAccelerationStructure>
+{
+	// the asset type
+	using asset_t = asset::ICPUBottomLevelAccelerationStructure;
+	// we don't need to descend during DFS into other assets
+	constexpr static inline bool HasChildren = true;
+	// the video type
+	using video_t = IGPUImageView;
+	// lookup type
+	using lookup_t = const video_t*;
+};
 
-/*
 template<>
-struct asset_traits<asset::ICPUShader> { using GPUObjectType = IGPUShader; };
+struct asset_traits<asset::ICPUTopLevelAccelerationStructure>
+{
+	// the asset type
+	using asset_t = asset::ICPUTopLevelAccelerationStructure;
+	// depends on ICPUBottomLevelAccelerationStructure
+	constexpr static inline bool HasChildren = true;
+	// the video type
+	using video_t = IGPUTopLevelAccelerationStructure;
+	// lookup type
+	using lookup_t = const video_t*;
+};
+
 
 template<>
-struct asset_traits<asset::ICPUDescriptorSet> { using GPUObjectType = IGPUDescriptorSet; };
+struct asset_traits<asset::ICPUDescriptorSet>
+{
+	// the asset type
+	using asset_t = asset::ICPUDescriptorSet;
+	// depends on a lot of `IDescriptor` ICPU... types
+	constexpr static inline bool HasChildren = true;
+	// the video type
+	using video_t = IGPUDescriptorSet;
+	// lookup type
+	using lookup_t = const video_t*;
+};
 
+
+/* TODO
 template<>
-struct asset_traits<asset::ICPUAccelerationStructure> { using GPUObjectType = IGPUAccelerationStructure; };
+struct asset_traits<asset::ICPUFramebuffer>;
 */
 
+// Every other ICPU type not present in the list here is deprecated
+
 
 // Slight wrapper to allow copyable smart pointers
 template<asset::Asset AssetType>