start the True IR

Author: devsh

include/nbl/asset/material_compiler3/CFrontendIR.h

@@ -74,6 +74,8 @@ class CFrontendIR : public CNodePool
 					return false;
 				}
 
+				CNodePool::TypedHandle<CNodePool::CDebugInfo> debugInfo;
+
 			protected:
 				//
 				virtual inline bool isBxDFAllowedInSubtree_impl(const uint8_t ix) const {return false;}
@@ -115,7 +117,7 @@ class CFrontendIR : public CNodePool
 				template<uint8_t Count>
 				static inline uint32_t calc_size(const SCreationParams<Count>&)
 				{
-					return sizeof(this)+sizeof(SCreationParams<Count>);
+					return sizeof(CSpectralVariable)+sizeof(SCreationParams<Count>);
 				}
 
 				inline uint8_t getKnotCount() const

include/nbl/asset/material_compiler3/CNodePool.h

@@ -61,6 +61,38 @@ class CNodePool : public core::IReferenceCounted
 					return const_cast<Handle*>(const_cast<INode*>(this)->getChildHandleStorage(ix));
 				}
 		};
+		// Debug Info node
+		class CDebugInfo : public INode
+		{
+			public:
+				inline const std::string_view getTypeName() const override {return "nbl::CNodePool::CDebugInfo";}
+				inline uint8_t getChildCount() const override {return 0;}
+				inline uint32_t getSize() const {return m_size;}
+				
+				static inline uint32_t calc_size(const void* data, const uint32_t size)
+				{
+					return sizeof(CDebugInfo)+size;
+				}
+				static inline uint32_t calc_size(const std::string_view& view)
+				{
+					return view.length();
+				}
+				inline CDebugInfo(const void* data, const uint32_t size) : m_size(size)
+				{
+					if (data)
+						memcpy(this+1,data,m_size);
+				}
+				inline CDebugInfo(const std::string_view& view) : CDebugInfo(nullptr,view.length()+1)
+				{
+					auto* out = reinterpret_cast<char*>(this+1);
+					if (m_size>1)
+						memcpy(out,view.data(),m_size);
+					out[m_size-1] = 0;
+				}
+
+			protected:
+				const uint32_t m_size;
+		};
 
 		//
 		template<typename T> requires std::is_base_of_v<INode,T>
@@ -173,7 +205,10 @@ class CNodePool : public core::IReferenceCounted
 			const auto chunkSize = 0x1u<<m_chunkSizeLog2;
 			const auto chunkAlign = 0x1u<<m_maxNodeAlignLog2;
 			for (auto& chunk : m_chunks)
+			{
+				// TODO: destroy nodes allocated from chunk
 				m_pmr->deallocate(chunk.m_data,chunkSize,chunkAlign);
+			}
 		}
 
 	private:

include/nbl/asset/material_compiler3/CTrueIR.h

@@ -0,0 +1,65 @@
+// 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_MATERIAL_COMPILER_V3_C_TRUE_IR_H_INCLUDED_
+#define _NBL_ASSET_MATERIAL_COMPILER_V3_C_TRUE_IR_H_INCLUDED_
+
+
+#include "nbl/asset/material_compiler3/CFrontendIR.h"
+
+
+namespace nbl::asset::material_compiler3
+{
+
+// You make the Materials with a classical expression IR, one Root Node per material
+class CTrueIR : public CNodePool
+{
+	public:
+		// constructor
+		inline core::smart_refctd_ptr<CTrueIR> create(const uint8_t chunkSizeLog2=19, const uint8_t maxNodeAlignLog2=4, refctd_pmr_t&& _pmr={})
+		{
+			if (chunkSizeLog2<14 || maxNodeAlignLog2<4)
+				return nullptr;
+			if (!_pmr)
+				_pmr = core::getDefaultMemoryResource();
+			return core::smart_refctd_ptr<CTrueIR>(new CFrontendIR(chunkSizeLog2,maxNodeAlignLog2,std::move(_pmr)),core::dont_grab);
+		}
+		
+
+		// basic "built-in" nodes
+		class INode : public CNodePool::INode
+		{
+			public:
+
+			protected:
+				// Each node is final and immutable, has a precomputed hash for the whole subtree beneath it.
+				// Debug info does not form part of the hash, so can get wildly replaced.
+				core::blake3_hash_t hash;
+		};
+		template<typename T> requires std::is_base_of_v<INode,T>
+		using TypedHandle = CNodePool::TypedHandle<T>;
+
+
+		// Each material comes down to this
+		struct Material
+		{
+//			TypedHandle<CRootNode> root;
+			CNodePool::TypedHandle<CNodePool::CDebugInfo> debugInfo;
+		};
+		inline std::span<const Material> getMaterials() const {return m_materials;}
+
+		// We take the trees from the forest, and canonicalize them into our weird Domain Specific IR with Upside down expression trees.
+		bool addMaterials(const CFrontendIR* forest);
+
+	protected:
+		using CNodePool::CNodePool;
+
+		core::vector<Material> m_materials;
+		core::unordered_map<core::blake3_hash_t,Handle> m_uniqueNodes;
+};
+
+//! DAG (baked)
+
+} // namespace nbl::asset::material_compiler3
+
+#endif