fix most of the bugs and make all examples_tests run

Author: devshgraphicsprogramming

examples_tests

@@ -77,6 +77,7 @@ namespace nbl::asset::material_compiler3
 // polygonization. Using PN-Triangles/displacement would be the optimal solution here. 
 class CFrontendIR final : public CNodePool
 {
+		using block_allocator_type = CNodePool::obj_pool_type::block_allocator_type;
 		template<typename T>
 		using _typed_pointer_type = CNodePool::obj_pool_type::mem_pool_type::typed_pointer_type<T>;
 
@@ -124,7 +125,7 @@ class CFrontendIR final : public CNodePool
 			}
 			inline bool operator==(const SParameter& other) const {return !operator!=(other);}
 
-			NBL_API void printDot(std::ostringstream& sstr, const core::string& selfID) const;
+			NBL_API2 void printDot(std::ostringstream& sstr, const core::string& selfID) const;
 
 			// at this stage we store the multipliers in highest precision
 			float scale = std::numeric_limits<float>::infinity();
@@ -435,8 +436,8 @@ class CFrontendIR final : public CNodePool
 					return false;
 				}
 
-				NBL_API core::string getLabelSuffix() const override;
-				NBL_API void printDot(std::ostringstream& sstr, const core::string& selfID) const override;
+				NBL_API2 core::string getLabelSuffix() const override;
+				NBL_API2 void printDot(std::ostringstream& sstr, const core::string& selfID) const override;
 
 			private:
 				SCreationParams<1>* pWonky() {return reinterpret_cast<SCreationParams<1>*>(this+1);}
@@ -517,8 +518,8 @@ class CFrontendIR final : public CNodePool
 
 			protected:
 				inline typed_pointer_type<IExprNode> getChildHandle_impl(const uint8_t ix) const override {return {};}
-				NBL_API bool invalid(const SInvalidCheckArgs& args) const override;
-				NBL_API void printDot(std::ostringstream& sstr, const core::string& selfID) const override;
+				NBL_API2 bool invalid(const SInvalidCheckArgs& args) const override;
+				NBL_API2 void printDot(std::ostringstream& sstr, const core::string& selfID) const override;
 		};
 		//! Special nodes meant to be used as `CMul::rhs`, their behaviour depends on the IContributor in its MUL node relative subgraph.
 		//! If you use a different contributor node type or normal for shading, these nodes get split and duplicated into two in our Final IR.
@@ -551,7 +552,7 @@ class CFrontendIR final : public CNodePool
 				inline typed_pointer_type<IExprNode> getChildHandle_impl(const uint8_t ix) const override {return perpTransmittance;}
 
 				inline std::string_view getChildName_impl(const uint8_t ix) const override {return "Perpendicular\\nTransmittance";}
-				NBL_API bool invalid(const SInvalidCheckArgs& args) const override;
+				NBL_API2 bool invalid(const SInvalidCheckArgs& args) const override;
 		};
 		// The "oriented" in the Etas means from frontface to backface, so there's no need to reciprocate them when creating matching BTDF for BRDF
 		// @kept_secret TODO: Thin Film Interference Fresnel
@@ -572,9 +573,9 @@ class CFrontendIR final : public CNodePool
 
 			protected:
 				inline typed_pointer_type<IExprNode> getChildHandle_impl(const uint8_t ix) const override {return ix ? orientedImagEta:orientedRealEta;}
-				NBL_API bool invalid(const SInvalidCheckArgs& args) const override;
+				NBL_API2 bool invalid(const SInvalidCheckArgs& args) const override;
 				inline std::string_view getChildName_impl(const uint8_t ix) const override {return ix ? "Real":"Imaginary";}
-				NBL_API void printDot(std::ostringstream& sstr, const core::string& selfID) const override;
+				NBL_API2 void printDot(std::ostringstream& sstr, const core::string& selfID) const override;
 		};
 		// Compute Inifinite Scatter and extinction between two parallel infinite planes.
 		// It's a specialization of what would be a layer of two identical smooth BRDF and BTDF with arbitrary Fresnel function and beer's
@@ -595,7 +596,7 @@ class CFrontendIR final : public CNodePool
 		{
 			protected:
 				inline typed_pointer_type<IExprNode> getChildHandle_impl(const uint8_t ix) const override final {return ix ? (ix>1 ? reflectanceBottom:extinction):reflectanceTop;}
-				NBL_API bool invalid(const SInvalidCheckArgs& args) const override;
+				NBL_API2 bool invalid(const SInvalidCheckArgs& args) const override;
 
 				inline std::string_view getChildName_impl(const uint8_t ix) const override {return ix ? (ix>1 ? "reflectanceBottom":"extinction"):"reflectanceTop";}
 
@@ -649,7 +650,7 @@ class CFrontendIR final : public CNodePool
 					// whether the derivative map and roughness is constant regardless of UV-space texture stretching
 					inline bool stretchInvariant() const {return !(abs(hlsl::determinant(reference))>std::numeric_limits<float>::min());}
 
-					NBL_API void printDot(std::ostringstream& sstr, const core::string& selfID) const;
+					NBL_API2 void printDot(std::ostringstream& sstr, const core::string& selfID) const;
 
 					// Ignored if not invertible, otherwise its the reference "stretch" (UV derivatives) at which identity roughness and normalmapping occurs
 					hlsl::float32_t2x2 reference = hlsl::float32_t2x2(0,0,0,0);
@@ -687,8 +688,8 @@ class CFrontendIR final : public CNodePool
 
 			protected:
 				inline _typed_pointer_type<IExprNode> getChildHandle_impl(const uint8_t ix) const override {return {};}
-				NBL_API bool invalid(const SInvalidCheckArgs& args) const override;
-				NBL_API void printDot(std::ostringstream& sstr, const core::string& selfID) const override;
+				NBL_API2 bool invalid(const SInvalidCheckArgs& args) const override;
+				NBL_API2 void printDot(std::ostringstream& sstr, const core::string& selfID) const override;
 		};
 		// Supports anisotropy for all models
 		class CCookTorrance final : public IBxDF
@@ -717,11 +718,11 @@ class CFrontendIR final : public CNodePool
 
 			protected:
 				inline typed_pointer_type<IExprNode> getChildHandle_impl(const uint8_t ix) const override {return orientedRealEta;}
-				NBL_API bool invalid(const SInvalidCheckArgs& args) const override;
+				NBL_API2 bool invalid(const SInvalidCheckArgs& args) const override;
 
 				inline core::string getLabelSuffix() const override {return ndf!=NDF::GGX ? "\\nNDF = Beckmann":"\\nNDF = GGX";}
 				inline std::string_view getChildName_impl(const uint8_t ix) const override {return "Oriented η";}
-				NBL_API void printDot(std::ostringstream& sstr, const core::string& selfID) const override;
+				NBL_API2 void printDot(std::ostringstream& sstr, const core::string& selfID) const override;
 		};
 #undef TYPE_NAME_STR
 
@@ -740,16 +741,16 @@ class CFrontendIR final : public CNodePool
 		}
 
 		// To quickly make a matching backface material from a frontface or vice versa
-		NBL_API typed_pointer_type<IExprNode> reciprocate(const typed_pointer_type<const IExprNode> other);
-		NBL_API typed_pointer_type<CFresnel> createNamedFresnel(const std::string_view name);
+		NBL_API2 typed_pointer_type<IExprNode> reciprocate(const typed_pointer_type<const IExprNode> other);
+		NBL_API2 typed_pointer_type<CFresnel> createNamedFresnel(const std::string_view name);
 
 		// IMPORTANT: Two BxDFs are not allowed to be multiplied together.
 		// NOTE: Right now all Spectral Variables are required to be Monochrome or 3 bucket fixed semantics, all the same wavelength.
 		// Some things we can't check such as the compatibility of the BTDF with the BRDF (matching indices of refraction, etc.)
 		bool valid(const typed_pointer_type<const CLayer> rootHandle, system::logger_opt_ptr logger) const;
 
 		// For Debug Visualization (TODO: refactor to allow printing invalid nodes not in the `m_rootNodes` -> `printDotTree(std::ostringstream&,typed_pointer_type<const INode>)`)
-		NBL_API void printDotGraph(std::ostringstream& str) const;
+		NBL_API2 void printDotGraph(std::ostringstream& str) const;
 		inline core::string printDotGraph() const
 		{
 			std::ostringstream tmp;

include/nbl/asset/material_compiler3/CFrontendIR.h

@@ -23,11 +23,11 @@ class AddressAllocatorBasicConcurrencyAdaptor : private AddressAllocator
         AddressAllocator& getBaseRef() {return reinterpret_cast<AddressAllocator&>(*this);}
     public:
         _NBL_DECLARE_ADDRESS_ALLOCATOR_TYPEDEFS(typename AddressAllocator::size_type);
+        using extra_ctor_param_types = typename AddressAllocator::extra_ctor_param_types;
 
         typedef address_allocator_traits<AddressAllocator>              traits;
         static_assert(address_allocator_traits<AddressAllocator>::supportsArbitraryOrderFrees,"AddressAllocator does not support arbitrary order frees!");
 
-
         using AddressAllocator::AddressAllocator;
         virtual ~AddressAllocatorBasicConcurrencyAdaptor() {}
 

include/nbl/core/alloc/AddressAllocatorConcurrencyAdaptors.h

@@ -58,9 +58,10 @@ struct TypedHandle final : std::conditional_t<std::is_const_v<T>,typename _Handl
 			TypedHandle<U,_Handle> retval;
 			retval.value = base_t::value;
 			if constexpr (!std::is_void_v<U>)
+			if (*this)
 			{
 				const T* const fake_this = reinterpret_cast<const T*>(sizeof(T));
-				retval.value -= ptrdiff_t(static_cast<const U*>(fake_this)) - sizeof(T);
+				retval.value += ptrdiff_t(static_cast<const U*>(fake_this)) - sizeof(T);
 			}
 			return retval;
 		}
@@ -219,8 +220,8 @@ class SimpleBlockBasedAllocator<AddressAllocator,void*> final : protected BlockB
 		//
 		template<typename T> requires (!std::is_const_v<T>)
 		inline T* deref(typed_pointer_type<T> p) {return p;}
-		template<typename T> requires std::is_const_v<T>
-		inline T* deref(typed_pointer_type<T> p) const {return p;}
+		template<typename T>
+		inline const T* deref(typed_pointer_type<T> p) const {return p;}
 
 		// deallocates everything
         inline void	reset()
@@ -323,17 +324,22 @@ class SimpleBlockBasedAllocator<AddressAllocator,HandleValue> final : protected
 		template<typename T, typename U>
 		static inline typed_pointer_type<T> _static_cast(typed_pointer_type<U> p)
 		{
-			const U* const fake_p = reinterpret_cast<const U*>(sizeof(U));
-			HandleValue shift = ptrdiff_t(static_cast<const T*>(fake_p)) - sizeof(U);
 			typed_pointer_type<T> retval;
-			retval.value = p.value - shift;
+			retval.value = p.value;
+			if (p)
+			{
+				const auto begin = std::max(sizeof(T),sizeof(U));
+				const U* const fake_p = reinterpret_cast<const U*>(begin);
+				retval.value += ptrdiff_t(static_cast<const T*>(fake_p)) - begin;
+			}
 			return retval;
 		}
 
 		struct SCreationParams final
 		{
 			base_t::SCreationParams composed;
-			block_id_t maxBlocks = 0x1<<15;
+			// TODO: `reserved_size` probably needs to return `size_t` cause otherwise this value can't be bigger than default
+			block_id_t maxBlocks = 0x1<<13;
 		};
 		inline SimpleBlockBasedAllocator(SCreationParams&& params) : base_t(std::move(params.composed)),
 			m_blockIndexAlloc(base_t::m_mem_resource->allocate(block_id_alloc_t::reserved_size(1,params.maxBlocks,1),_NBL_SIMD_ALIGNMENT),0,0,1,params.maxBlocks,1),
@@ -362,11 +368,11 @@ class SimpleBlockBasedAllocator<AddressAllocator,HandleValue> final : protected
 		{
 			return reinterpret_cast<T*>(std::launder(getBlock(p)->data(base_t::m_blockCreationParams)+getOffsetInBlock(p)));
 		}
-		template<typename T> requires std::is_const_v<T>
-		inline T* deref(typed_pointer_type<T> p) const
+		template<typename T>
+		inline const T* deref(typed_pointer_type<T> p) const
 		{
-			auto* mut = const_cast<this_t*>(this)->deref<std::remove_const_t<T>>(p);
-			return const_cast<T*>(mut);
+			std::remove_const_t<T>* mut = const_cast<this_t*>(this)->deref<std::remove_const_t<T>>(p);
+			return mut;
 		}
 
 		// deallocates everything
@@ -401,7 +407,7 @@ class SimpleBlockBasedAllocator<AddressAllocator,HandleValue> final : protected
 			{
 				block_t* block = entry.second;
 				if (const auto addr=block->alloc(bytes,alignment); addr!=invalid_address)
-					return {.value=(entry.first<<m_blockSizeLog2)|addr};
+					return {{{.value=(entry.first<<m_blockSizeLog2)|addr}}};
 			}
 			const auto newID = m_blockIndexAlloc.alloc_addr(1,1);
 			if (newID!=block_id_alloc_t::invalid_address)
@@ -410,7 +416,7 @@ class SimpleBlockBasedAllocator<AddressAllocator,HandleValue> final : protected
 				if (const auto addr=block->alloc(bytes,alignment); addr!=invalid_address)
 				{
 					m_blocks[newID] = block;
-					return {.value=(newID<<m_blockSizeLog2)|addr};
+					return {{{.value=(newID<<m_blockSizeLog2)|addr}}};
 				}
 				else
 					base_t::deleteBlock(block);

include/nbl/core/alloc/SimpleBlockBasedAllocator.h

@@ -45,10 +45,10 @@ class CMemoryPool final : public Uncopyable
 		{
 			return m_block_alctr.deref<T>(p);
 		}
-		template<typename T> requires std::is_const_v<T>
-		inline T* deref(typed_pointer_type<T> p) const
+		template<typename T>
+		inline const T* deref(typed_pointer_type<T> p) const
 		{
-			return m_block_alctr.deref<T>(p);
+			return m_block_alctr.deref<const T>(p);
 		}
 
         //

include/nbl/core/containers/CMemoryPool.h

@@ -107,11 +107,15 @@ class CObjectPool final : public IObjectPoolBase
 			}
 			return retval;
 		}
-		template<typename T> requires std::is_const_v<T>
-		inline T* deref(const typed_pointer_type<T> h, check_t check={.value=false}) const
+		template<typename T>
+		inline const T* deref(const typed_pointer_type<T> h, check_t check={.value=false}) const
 		{
 			using non_const_t = std::remove_const_t<T>;
-			const auto mutableH = block_allocator_type::template _const_cast<non_const_t>(h);
+			typed_pointer_type<non_const_t> mutableH;
+			if constexpr (std::is_const_v<T>)
+				mutableH = block_allocator_type::template _const_cast<non_const_t>(h);
+			else
+				mutableH = h;
 			return const_cast<this_t*>(this)->deref<non_const_t>(mutableH,check);
 		}
 
@@ -139,7 +143,7 @@ class CObjectPool final : public IObjectPoolBase
 					return sizeof(T);
 			}();
 			//
-            const typed_pointer_type<T> retval = m_pool.allocate(size*n,a);
+            const auto retval = block_allocator_type::template _reinterpret_cast<T>(m_pool.allocate(size*n,a));
 			// record existence if needed
 			if constexpr (std::is_base_of_v<INonTrivial,T>)
 			{
@@ -161,7 +165,7 @@ class CObjectPool final : public IObjectPoolBase
 					if constexpr (sizeof...(FuncArgs)!=0u)
 						std::construct_at(ptr,std::forward<FuncArgs>(args)...);
 					else
-						std::uninitialized_default_construct(ptr);
+						std::uninitialized_default_construct(ptr,ptr+1);
 					// go to next object
 					ptr = reinterpret_cast<T*>(reinterpret_cast<char*>(ptr)+size);
 				}

include/nbl/core/containers/CObjectPool.h

@@ -167,6 +167,9 @@ set(NBL_ASSET_SOURCES
 	asset/interchange/IAssetWriter.cpp
 	asset/interchange/IAssetLoader.cpp
 
+# Materials
+	asset/material_compiler3/CFrontendIR.cpp
+
 # Shaders
 	asset/utils/ISPIRVOptimizer.cpp
 	asset/utils/ISPIRVEntryPointTrimmer.cpp
@@ -214,15 +217,15 @@ set(NBL_ASSET_SOURCES
 	asset/interchange/CImageLoaderJPG.cpp
 	asset/interchange/CImageLoaderPNG.cpp
 	asset/interchange/CImageLoaderTGA.cpp
-	asset/interchange/CImageLoaderOpenEXR.cpp # TODO: Nahim
+	asset/interchange/CImageLoaderOpenEXR.cpp
 	asset/interchange/CGLILoader.cpp
 
 # Image writers
 	asset/interchange/IImageWriter.cpp
 	asset/interchange/CImageWriterJPG.cpp
 	asset/interchange/CImageWriterPNG.cpp
 	asset/interchange/CImageWriterTGA.cpp
-	asset/interchange/CImageWriterOpenEXR.cpp # TODO: Nahim
+	asset/interchange/CImageWriterOpenEXR.cpp
 	asset/interchange/CGLIWriter.cpp
 
 # IES profile loaders