Got the first XML Scene to Parse its Materials!

Author: devshgraphicsprogramming

include/nbl/asset/material_compiler3/CFrontendIR.h

@@ -749,14 +749,33 @@ class CFrontendIR final : public CNodePool
 		// 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_API2 void printDotGraph(std::ostringstream& str) const;
-		inline core::string printDotGraph() const
+		// For Debug Visualization
+		struct SDotPrinter final
 		{
-			std::ostringstream tmp;
-			printDotGraph(tmp);
-			return tmp.str();
-		}
+			public:
+				inline SDotPrinter(const CFrontendIR* ir) : m_ir(ir) {}
+				// assign in reverse because we want materials to print in order
+				inline SDotPrinter(const CFrontendIR* ir, std::span<const typed_pointer_type<const CLayer>> roots) : m_ir(ir), layerStack(roots.rbegin(),roots.rend())
+				{
+					// should probably size it better, if I knew total node count allocated or live
+					visitedNodes.reserve(roots.size()<<3);
+				}
+
+				NBL_API2 void operator()(std::ostringstream& output);
+				inline core::string operator()()
+				{
+					std::ostringstream tmp;
+					operator()(tmp);
+					return tmp.str();
+				}
+			
+				core::unordered_set<typed_pointer_type<const INode>> visitedNodes;
+				// TODO: track layering depth and indent accordingly?
+				core::vector<typed_pointer_type<const CLayer>> layerStack;
+				core::stack<typed_pointer_type<const IExprNode>> exprStack;
+			private:
+				const CFrontendIR* m_ir;
+		};
 
 	protected:
 		using CNodePool::CNodePool;

include/nbl/core/alloc/SimpleBlockBasedAllocator.h

@@ -29,6 +29,9 @@ struct ConstHandle
 	// God, I love C++20
 	inline auto operator<=>(const ConstHandle&) const = default;
 
+// TODO: would have to forward declare Handle template
+//	Handle<ConstHandle> _const_cast() const;
+
 	// LSB is the offset in the block, MSB is the block index
 	value_t value = Invalid;
 };
@@ -38,20 +41,32 @@ struct Handle : _ConstHandle
 	using const_type = _ConstHandle;
 
 	inline auto operator<=>(const Handle& other) const {return _ConstHandle::operator<=>(other);}
+
+//	inline _ConstHandle _const_cast() const {return *this;}
 };
 
 template<typename T, typename _Handle> requires std::is_same_v<Handle<ConstHandle<typename _Handle::value_t,_Handle::Invalid>>,_Handle>
 struct TypedHandle final : std::conditional_t<std::is_const_v<T>,typename _Handle::const_type,_Handle>
 {
 	private:
-		using base_t = std::conditional_t<std::is_const_v<T>,typename _Handle::const_type,_Handle>;
+		constexpr static inline bool IsConst = std::is_const_v<T>;
+		using base_t = std::conditional_t<IsConst,typename _Handle::const_type,_Handle>;
 
 	public:
 		inline auto operator<=>(const _Handle& other) const {return base_t::operator<=>(other);}
 		inline auto operator<=>(const typename _Handle::const_type& other) const {return base_t::operator<=>(other);}
 
+		// implicit const_cast
 		inline operator TypedHandle<const T,_Handle>() const {return {{.value=base_t::value}};}
+		// explicit const_cast
+		inline auto _const_cast() const
+		{
+			TypedHandle<std::conditional_t<IsConst,std::remove_const_t<T>,const T>,_Handle> retval;
+			retval.value = base_t::value;
+			return retval;
+		}
 
+		// implicit static_cast
 		template<typename U> requires ((std::is_void_v<U> || std::is_base_of_v<U,T>) && (!std::is_const_v<T> || std::is_const_v<U>))
 		inline operator TypedHandle<U,_Handle>() const
 		{
@@ -308,12 +323,8 @@ class SimpleBlockBasedAllocator<AddressAllocator,HandleValue> final : protected
 
 		//
 		template<typename T, typename U> requires std::is_same_v<std::remove_cv_t<T>,std::remove_cv_t<U>>
-		static inline typed_pointer_type<T> _const_cast(typed_pointer_type<U> p)
-		{
-			typed_pointer_type<T> retval;
-			retval.value = p.value;
-			return retval;
-		}
+		static inline typed_pointer_type<T> _const_cast(typed_pointer_type<U> p) {return p._const_cast();}
+		// TODO: add `_reinrepret_cast` and `_static_cast` to the TypedHandle` and do in terms of that
 		template<typename T, typename U> requires (!std::is_const_v<U> || std::is_const_v<T>)
 		static inline typed_pointer_type<T> _reinterpret_cast(typed_pointer_type<U> p)
 		{

include/nbl/ext/MitsubaLoader/CElementShape.h

@@ -249,14 +249,14 @@ class CElementShape final : public IElement
 			return local;
 		}
 
-		inline CElementEmitter obtainEmitter() const
+		inline const CElementEmitter* obtainEmitter() const
 		{
 			if (emitter)
-				return *emitter;
+				return emitter;
 			if (type==CElementShape::INSTANCE && instance.parent && instance.parent->emitter)
-				return *instance.parent->emitter;
+				return instance.parent->emitter;
 
-			return CElementEmitter("");
+			return nullptr;
 		}
 
 

include/nbl/ext/MitsubaLoader/CMitsubaLoader.h

@@ -21,16 +21,9 @@ class CMitsubaMaterialCompilerFrontend;
 
 #if 0 // TODO
 //#include "nbl/builtin/glsl/ext/MitsubaLoader/instance_data_struct.glsl"
-#define uint uint32_t
-#define uvec2 uint64_t
-#define mat4x3 nbl::core::matrix3x4SIMD
 #define nbl_glsl_MC_material_data_t asset::material_compiler::material_data_t
 struct nbl_glsl_ext_Mitsuba_Loader_instance_data_t
 {
-	struct vec3
-	{
-		float x, y, z;
-	};
 	mat4x3 tform;
 	vec3 normalMatrixRow0;
 	uint padding0;
@@ -40,9 +33,6 @@ struct nbl_glsl_ext_Mitsuba_Loader_instance_data_t
 	uint determinantSignBit;
 	nbl_glsl_MC_material_data_t material;
 };
-#undef uint
-#undef uvec2
-#undef mat4x3
 #undef nbl_glsl_MC_material_data_t
 using instance_data_t = nbl_glsl_ext_Mitsuba_Loader_instance_data_t;
 #endif
@@ -61,9 +51,6 @@ class CMitsubaLoader final : public asset::ISceneLoader
 		void									cacheTexture(SContext& ctx, uint32_t hierarchyLevel, const CElementTexture* texture, const CMitsubaMaterialCompilerFrontend::E_IMAGE_VIEW_SEMANTIC semantic);
 		void cacheEmissionProfile(SContext& ctx, const CElementEmissionProfile* profile);
 
-		SContext::bsdf_type getBSDFtreeTraversal(SContext& ctx, const CElementBSDF* bsdf, const CElementEmitter* emitter, core::matrix4SIMD tform);
-		SContext::bsdf_type genBSDFtreeTraversal(SContext& ctx, const CElementBSDF* bsdf);
-
 		template <typename Iter>
 		core::smart_refctd_ptr<asset::ICPUDescriptorSet> createDS0(const SContext& _ctx, asset::ICPUPipelineLayout* _layout, const asset::material_compiler::CMaterialCompilerGLSLBackendCommon::result_t& _compResult, Iter meshBegin, Iter meshEnd);
 #endif

include/nbl/ext/MitsubaLoader/CMitsubaMaterialCompilerFrontend.h

@@ -33,12 +33,6 @@ class CMitsubaMaterialCompilerFrontend
             EIVS_COUNT
         };
 
-        struct front_and_back_t
-        {
-            IRNode* front;
-            IRNode* back;
-        };
-
         explicit CMitsubaMaterialCompilerFrontend(const SContext* _ctx) : m_loaderContext(_ctx) {}
 
         front_and_back_t compileToIRTree(asset::material_compiler::IR* ir, const CElementBSDF* _bsdf);
@@ -57,8 +51,6 @@ class CMitsubaMaterialCompilerFrontend
         emission_profile_type getEmissionProfile(const CElementEmissionProfile* _element);
 
         tex_ass_type getErrorTexture(const E_IMAGE_VIEW_SEMANTIC semantic) const;
-
-        IRNode* createIRNode(asset::material_compiler::IR* ir, const CElementBSDF* _bsdf);
 #endif
 };
 

include/nbl/ext/MitsubaLoader/SContext.h

@@ -32,6 +32,16 @@ struct SContext final
 		// the `shape` will have to be `Type::SHAPEGROUP`
 		shape_ass_type loadShapeGroup(const CElementShape* shape);
 
+		// Mitsuba XML Materials do not support emission from a BSDF node (i.e. emitter behind a coating or glass screen), its purely additive and cannot be backface emitting
+		using material_t = asset::material_compiler3::CFrontendIR::typed_pointer_type<const asset::material_compiler3::CFrontendIR::CLayer>; // TODO: change to true IR
+		material_t getMaterial(const CElementBSDF* bsdf, const CElementEmitter* frontFaceEmitter, const hlsl::float32_t3x3& iesProfileOrientation, const core::string& debugName, system::ISystem* debugFileWriter=nullptr);
+
+		inline void writeFrontendForestDot3(system::ISystem* system, const system::path& filepath)
+		{
+			asset::material_compiler3::CFrontendIR::SDotPrinter printer = {frontIR.get(),frontIR->getMaterials()};
+			writeDot3File(system,filepath,printer);
+		}
+
 		inline void transferMetadata()
 		{
 			meta->setGeometryCollectionMeta(std::move(shapeCache));
@@ -45,10 +55,23 @@ struct SContext final
 		core::smart_refctd_ptr<asset::ICPUScene> scene;
 
 	private:
+		using frontend_ir_t = asset::material_compiler3::CFrontendIR;
+		using frontend_material_t = frontend_ir_t::typed_pointer_type<const frontend_ir_t::CLayer>;
+		// not `frontend_ir_t::CEmitter` because the color factor gets multiplied in
+		using frontend_emitter_t = frontend_ir_t::typed_pointer_type<const frontend_ir_t::CMul>;
+		frontend_material_t genMaterial(const CElementBSDF* bsdf, system::ISystem* debugFileWriter);
+		frontend_emitter_t getEmitter(const CElementEmitter* emitter, const hlsl::float32_t3x3& iesProfileOrientation, system::ISystem* debugFileWriter);
+		frontend_emitter_t genEmitter(const CElementEmitter* emitter, system::ISystem* debugFileWriter);
+		//
+		void writeDot3File(system::ISystem* system, const system::path& filepath, frontend_ir_t::SDotPrinter& printer);
+
 		//
 		core::unordered_map<const CElementShape*,CMitsubaMetadata::SGeometryCollectionMetaPair> shapeCache;
 		//
 		core::unordered_map<const CElementShape::ShapeGroup*,CMitsubaMetadata::SGeometryCollectionMetaPair> groupCache;
+		//
+		core::unordered_map<const CElementBSDF*,frontend_material_t> bsdfCache;
+		core::unordered_map<const CElementEmitter*,frontend_emitter_t> emitterCache;
 
 #if 0 // stuff that belongs in the Material Compiler backend
 		//image, sampler
@@ -121,13 +144,15 @@ struct SContext final
 			params.MinLod = 0.f;
 			return params;
 		}
-
-		//index of root node in IR
-		using bsdf_type = const CMitsubaMaterialCompilerFrontend::front_and_back_t;
-		//caches instr buffer instr-wise offset (.first) and instruction count (.second) for each bsdf node
-		core::unordered_map<const CElementBSDF*, bsdf_type> instrStreamCache;
 #endif
-		core::smart_refctd_ptr<asset::material_compiler3::CFrontendIR> frontIR;
+		core::smart_refctd_ptr<frontend_ir_t> frontIR;
+		// Common Debug Names
+		enum class ECommonDebug : uint16_t
+		{
+			Albedo,
+			Count
+		};
+		frontend_ir_t::obj_pool_type::typed_pointer_type<const frontend_ir_t::CDebugInfo> commonDebugNames[uint16_t(ECommonDebug::Count)];
 };
 
 }

src/nbl/asset/material_compiler3/CFrontendIR.cpp

@@ -220,17 +220,42 @@ auto CFrontendIR::createNamedFresnel(const std::string_view name) -> typed_point
 	return frH;
 }
 
-void CFrontendIR::printDotGraph(std::ostringstream& str) const
+void CFrontendIR::SDotPrinter::operator()(std::ostringstream& str)
 {
 	str << "digraph {\n";
+
+	auto drainExprStack = [&]()->void
+	{			
+		while (!exprStack.empty())
+		{
+			const auto entry = exprStack.top();
+			exprStack.pop();
+			const auto nodeID = m_ir->getNodeID(entry);
+			str << "\n\t" << m_ir->getLabelledNodeID(entry);
+			const auto* node = m_ir->getObjectPool().deref(entry);
+			const auto childCount = node->getChildCount();
+			if (childCount)
+			{
+				for (auto childIx=0; childIx<childCount; childIx++)
+				{
+					const auto childHandle = node->getChildHandle(childIx);
+					if (const auto child=m_ir->getObjectPool().deref(childHandle); child)
+					{
+						str << "\n\t" << nodeID << " -> " << m_ir->getNodeID(childHandle) << "[label=\"" << node->getChildName_impl(childIx) << "\"]";
+						const auto visited = visitedNodes.find(childHandle);
+						if (visited!=visitedNodes.end())
+							continue;
+						exprStack.push(childHandle);
+						visitedNodes.insert(childHandle);
+					}
+				}
+			}
+			// special printing
+			node->printDot(str,nodeID);
+		}
+	};
+	drainExprStack();
 
-	core::unordered_set<typed_pointer_type<const INode>> visitedNodes;
-	// should probably size it better, if I knew total node count allocated or live
-	visitedNodes.reserve(m_rootNodes.size()<<3);
-	// TODO: track layering depth and indent accordingly?
-	// assign in reverse because we want materials to print in order
-	core::vector<typed_pointer_type<const CLayer>> layerStack(m_rootNodes.rbegin(),m_rootNodes.rend());
-	core::stack<typed_pointer_type<const IExprNode>> exprStack;
 	while (!layerStack.empty())
 	{
 		const auto layerHandle = layerStack.back();
@@ -240,22 +265,22 @@ void CFrontendIR::printDotGraph(std::ostringstream& str) const
 		if (visited!=visitedNodes.end())
 			continue;
 		visitedNodes.insert(layerHandle);
-		const auto* layerNode = getObjectPool().deref(layerHandle);
+		const auto* layerNode = m_ir->getObjectPool().deref(layerHandle);
 		//
-		const auto layerID = getNodeID(layerHandle);
-		str << "\n\t" << getLabelledNodeID(layerHandle);
+		const auto layerID = m_ir->getNodeID(layerHandle);
+		str << "\n\t" << m_ir->getLabelledNodeID(layerHandle);
 		//
 		if (layerNode->coated)
 		{
-			str << "\n\t" << layerID << " -> " << getNodeID(layerNode->coated) << "[label=\"coats\"]\n";
+			str << "\n\t" << layerID << " -> " << m_ir->getNodeID(layerNode->coated) << "[label=\"coats\"]\n";
 			layerStack.push_back(layerNode->coated);
 		}
 		auto pushExprRoot = [&](const typed_pointer_type<const IExprNode> root, const std::string_view edgeLabel)->void
 		{
 			if (!root)
 				return;
 			// print the link from the layer to the expression
-			str << "\n\t" << layerID << " -> " << getNodeID(root) << "[label=\"" << edgeLabel << "\"]";
+			str << "\n\t" << layerID << " -> " << m_ir->getNodeID(root) << "[label=\"" << edgeLabel << "\"]";
 			// but not the expression again
 			const auto visited = visitedNodes.find(root);
 			if (visited!=visitedNodes.end())
@@ -266,33 +291,7 @@ void CFrontendIR::printDotGraph(std::ostringstream& str) const
 		pushExprRoot(layerNode->brdfTop,"Top BRDF");
 		pushExprRoot(layerNode->btdf,"BTDF");
 		pushExprRoot(layerNode->brdfBottom,"Bottom BRDF");
-		while (!exprStack.empty())
-		{
-			const auto entry = exprStack.top();
-			exprStack.pop();
-			const auto nodeID = getNodeID(entry);
-			str << "\n\t" << getLabelledNodeID(entry);
-			const auto* node = getObjectPool().deref(entry);
-			const auto childCount = node->getChildCount();
-			if (childCount)
-			{
-				for (auto childIx=0; childIx<childCount; childIx++)
-				{
-					const auto childHandle = node->getChildHandle(childIx);
-					if (const auto child=getObjectPool().deref(childHandle); child)
-					{
-						str << "\n\t" << nodeID << " -> " << getNodeID(childHandle) << "[label=\"" << node->getChildName_impl(childIx) << "\"]";
-						const auto visited = visitedNodes.find(childHandle);
-						if (visited!=visitedNodes.end())
-							continue;
-						exprStack.push(childHandle);
-						visitedNodes.insert(childHandle);
-					}
-				}
-			}
-			// special printing
-			node->printDot(str,nodeID);
-		}
+		drainExprStack();
 	}
 
 	// TODO: print image views