Implemented model material/texture import and reuse on model/scene load

Sources/OvCore/include/OvCore/ECS/Components/CMaterialRenderer.h

@@ -86,6 +86,11 @@ namespace OvCore::ECS::Components
 		*/
 		void UpdateMaterialList();
 
+		/**
+		* Apply embedded model materials for empty/default slots
+		*/
+		void ApplyEmbeddedMaterialFallback();
+
 		/**
 		* Defines an element of the user matrix
 		* @param p_row
@@ -161,4 +166,4 @@ namespace OvCore::ECS::Components
 	{
 		static constexpr std::string_view Name = "class OvCore::ECS::Components::CMaterialRenderer";
 	};
-}
+}

Sources/OvCore/src/OvCore/ECS/Components/CMaterialRenderer.cpp

@@ -4,14 +4,17 @@
 * @licence: MIT
 */
 
+#include <algorithm>
 #include <format>
+#include <string_view>
 #include <tinyxml2.h>
 
 #include <OvCore/ECS/Actor.h>
 #include <OvCore/ECS/Components/CMaterialRenderer.h>
 #include <OvCore/ECS/Components/CModelRenderer.h>
 #include <OvCore/Global/ServiceLocator.h>
 #include <OvCore/ResourceManagement/MaterialManager.h>
+#include <OvRendering/Resources/Parsers/EmbeddedAssetPath.h>
 
 #include <OvTools/Utils/PathParser.h>
 
@@ -24,6 +27,11 @@
 #include <OvUI/Widgets/Texts/TextColored.h>
 #include <OvUI/Widgets/Visual/Separator.h>
 
+namespace
+{
+	constexpr std::string_view kDefaultMaterialPath = ":Materials\\Default.ovmat";
+}
+
 OvCore::ECS::Components::CMaterialRenderer::CMaterialRenderer(ECS::Actor & p_owner) : AComponent(p_owner)
 {
 	m_materials.fill(nullptr);
@@ -142,6 +150,7 @@ void OvCore::ECS::Components::CMaterialRenderer::OnDeserialize(tinyxml2::XMLDocu
 	}
 
 	UpdateMaterialList();
+	ApplyEmbeddedMaterialFallback();
 
 	OvCore::Helpers::Serializer::DeserializeUint32(p_doc, p_node, "visibility_flags", reinterpret_cast<uint32_t&>(m_visibilityFlags));
 }
@@ -249,6 +258,49 @@ void OvCore::ECS::Components::CMaterialRenderer::UpdateMaterialList()
 	}
 }
 
+void OvCore::ECS::Components::CMaterialRenderer::ApplyEmbeddedMaterialFallback()
+{
+	auto* modelRenderer = owner.GetComponent<CModelRenderer>();
+	if (!modelRenderer)
+	{
+		return;
+	}
+
+	const auto* model = modelRenderer->GetModel();
+	if (!model)
+	{
+		return;
+	}
+
+	auto& materialManager = Global::ServiceLocator::Get<ResourceManagement::MaterialManager>();
+	auto* defaultMaterial = materialManager.GetResource(std::string{ kDefaultMaterialPath });
+
+	const uint8_t materialCount = static_cast<uint8_t>(std::min(
+		model->GetMaterialNames().size(),
+		static_cast<size_t>(kMaxMaterialCount)
+	));
+
+	for (uint8_t i = 0; i < materialCount; ++i)
+	{
+		auto* currentMaterial = GetMaterialAtIndex(i);
+		const bool shouldOverride = !currentMaterial;
+		if (!shouldOverride)
+		{
+			continue;
+		}
+
+		const auto embeddedMaterialPath = OvRendering::Resources::Parsers::MakeEmbeddedMaterialPath(model->path, i);
+		if (auto* embeddedMaterial = materialManager.GetResource(embeddedMaterialPath))
+		{
+			SetMaterialAtIndex(i, *embeddedMaterial);
+		}
+		else if (defaultMaterial)
+		{
+			SetMaterialAtIndex(i, *defaultMaterial);
+		}
+	}
+}
+
 void OvCore::ECS::Components::CMaterialRenderer::SetUserMatrixElement(uint32_t p_row, uint32_t p_column, float p_value)
 {
 	if (p_row < 4 && p_column < 4)

Sources/OvCore/src/OvCore/ECS/Components/CModelRenderer.cpp

@@ -26,7 +26,10 @@ OvCore::ECS::Components::CModelRenderer::CModelRenderer(ECS::Actor& p_owner) : A
 	m_modelChangedEvent += [this]
 	{
 		if (auto materialRenderer = owner.GetComponent<CMaterialRenderer>())
+		{
 			materialRenderer->UpdateMaterialList();
+			materialRenderer->ApplyEmbeddedMaterialFallback();
+		}
 
 		if (auto skinnedMeshRenderer = owner.GetComponent<CSkinnedMeshRenderer>())
 			skinnedMeshRenderer->NotifyModelChanged();

Sources/OvCore/src/OvCore/ResourceManagement/MaterialManager.cpp

@@ -6,8 +6,156 @@
 
 #include "OvCore/ResourceManagement/MaterialManager.h"
 
+#include <optional>
+#include <string_view>
+
+#include <OvCore/Global/ServiceLocator.h>
+#include <OvCore/ResourceManagement/ModelManager.h>
+#include <OvCore/ResourceManagement/ShaderManager.h>
+#include <OvCore/ResourceManagement/TextureManager.h>
+#include <OvRendering/Resources/Parsers/EmbeddedAssetPath.h>
+
+namespace
+{
+	constexpr std::string_view kStandardShaderPath = ":Shaders\\Standard.ovfx";
+
+	struct EmbeddedMaterialContext
+	{
+		std::string modelPath;
+		const OvRendering::Resources::Model* model = nullptr;
+		const OvRendering::Resources::EmbeddedMaterialData* materialData = nullptr;
+	};
+
+	std::optional<EmbeddedMaterialContext> ResolveEmbeddedMaterialContext(const std::filesystem::path& p_path)
+	{
+		using namespace OvRendering::Resources::Parsers;
+
+		const auto embeddedAssetPath = ParseEmbeddedAssetPath(p_path.string());
+		if (!embeddedAssetPath)
+		{
+			return std::nullopt;
+		}
+
+		const auto materialIndex = ParseEmbeddedMaterialIndex(embeddedAssetPath->assetName);
+		if (!materialIndex)
+		{
+			return std::nullopt;
+		}
+
+		auto* model = OvCore::Global::ServiceLocator::Get<OvCore::ResourceManagement::ModelManager>().GetResource(embeddedAssetPath->modelPath);
+		if (!model)
+		{
+			return std::nullopt;
+		}
+
+		const auto* embeddedMaterial = model->GetEmbeddedMaterial(materialIndex.value());
+		if (!embeddedMaterial)
+		{
+			return std::nullopt;
+		}
+
+		return EmbeddedMaterialContext{
+			.modelPath = embeddedAssetPath->modelPath,
+			.model = model,
+			.materialData = embeddedMaterial
+		};
+	}
+
+	bool BindEmbeddedTextureProperty(
+		OvCore::Resources::Material& p_material,
+		const EmbeddedMaterialContext& p_context,
+		const std::optional<uint32_t>& p_textureIndex,
+		const std::string_view p_uniformName
+	)
+	{
+		if (!p_textureIndex.has_value())
+		{
+			return false;
+		}
+
+		const auto* embeddedTexture = p_context.model->GetEmbeddedTexture(p_textureIndex.value());
+		if (!embeddedTexture)
+		{
+			return false;
+		}
+
+		const std::string extension = embeddedTexture->extension.empty() ? "bin" : embeddedTexture->extension;
+		const std::string texturePath = OvRendering::Resources::Parsers::MakeEmbeddedTexturePath(
+			p_context.modelPath,
+			p_textureIndex.value(),
+			extension
+		);
+
+		if (auto* texture = OvCore::Global::ServiceLocator::Get<OvCore::ResourceManagement::TextureManager>().GetResource(texturePath))
+		{
+			p_material.TrySetProperty(std::string{ p_uniformName }, texture);
+			return true;
+		}
+
+		return false;
+	}
+
+	bool ConfigureEmbeddedMaterial(
+		OvCore::Resources::Material& p_material,
+		const EmbeddedMaterialContext& p_context
+	)
+	{
+		auto* shader = OvCore::Global::ServiceLocator::Get<OvCore::ResourceManagement::ShaderManager>()[std::string{ kStandardShaderPath }];
+		if (!shader)
+		{
+			return false;
+		}
+
+		const auto& materialData = *p_context.materialData;
+
+		p_material.SetShader(shader);
+		p_material.SetFeatures(OvRendering::Data::FeatureSet{});
+
+		p_material.TrySetProperty("u_Albedo", materialData.albedo);
+		p_material.TrySetProperty("u_Metallic", materialData.metallic);
+		p_material.TrySetProperty("u_Roughness", materialData.roughness);
+		p_material.TrySetProperty("u_EmissiveColor", materialData.emissiveColor);
+		p_material.TrySetProperty("u_EmissiveIntensity", materialData.emissiveIntensity);
+
+		const bool normalTextureBound = BindEmbeddedTextureProperty(p_material, p_context, materialData.normalTexture, "u_NormalMap");
+		const bool heightTextureBound = BindEmbeddedTextureProperty(p_material, p_context, materialData.heightTexture, "u_HeightMap");
+
+		BindEmbeddedTextureProperty(p_material, p_context, materialData.albedoTexture, "u_AlbedoMap");
+		BindEmbeddedTextureProperty(p_material, p_context, materialData.metallicTexture, "u_MetallicMap");
+		BindEmbeddedTextureProperty(p_material, p_context, materialData.roughnessTexture, "u_RoughnessMap");
+		BindEmbeddedTextureProperty(p_material, p_context, materialData.ambientOcclusionTexture, "u_AmbientOcclusionMap");
+		BindEmbeddedTextureProperty(p_material, p_context, materialData.emissiveTexture, "u_EmissiveMap");
+		BindEmbeddedTextureProperty(p_material, p_context, materialData.opacityTexture, "u_MaskMap");
+
+		if (materialData.normalMapping || normalTextureBound)
+		{
+			p_material.AddFeature("NORMAL_MAPPING");
+		}
+
+		if (materialData.parallaxMapping || heightTextureBound)
+		{
+			p_material.AddFeature("PARALLAX_MAPPING");
+		}
+
+		return true;
+	}
+}
+
 OvCore::Resources::Material * OvCore::ResourceManagement::MaterialManager::CreateResource(const std::filesystem::path & p_path)
 {
+	if (const auto embeddedMaterialContext = ResolveEmbeddedMaterialContext(p_path))
+	{
+		auto* material = new OvCore::Resources::Material{};
+		if (ConfigureEmbeddedMaterial(*material, embeddedMaterialContext.value()))
+		{
+			const_cast<std::string&>(material->path) = p_path.string(); // Force the resource path to fit the given path
+			return material;
+		}
+
+		delete material;
+		return nullptr;
+	}
+
 	std::string realPath = GetRealPath(p_path).string();
 
 	Resources::Material* material = OvCore::Resources::Loaders::MaterialLoader::Create(realPath);
@@ -26,6 +174,12 @@ void OvCore::ResourceManagement::MaterialManager::DestroyResource(OvCore::Resour
 
 void OvCore::ResourceManagement::MaterialManager::ReloadResource(OvCore::Resources::Material* p_resource, const std::filesystem::path& p_path)
 {
+	if (const auto embeddedMaterialContext = ResolveEmbeddedMaterialContext(p_path))
+	{
+		ConfigureEmbeddedMaterial(*p_resource, embeddedMaterialContext.value());
+		return;
+	}
+
 	std::string realPath = GetRealPath(p_path).string();
 	OvCore::Resources::Loaders::MaterialLoader::Reload(*p_resource, realPath);
 }

Sources/OvCore/src/OvCore/ResourceManagement/ModelManager.cpp

@@ -6,6 +6,10 @@
 
 #include "OvCore/ResourceManagement/ModelManager.h"
 
+#include <OvCore/Global/ServiceLocator.h>
+#include <OvCore/ResourceManagement/MaterialManager.h>
+#include <OvCore/ResourceManagement/TextureManager.h>
+#include <OvRendering/Resources/Parsers/EmbeddedAssetPath.h>
 #include <OvTools/Filesystem/IniFile.h>
 
 OvRendering::Resources::Parsers::EModelParserFlags GetAssetMetadata(const std::string& p_path)
@@ -49,10 +53,60 @@ OvRendering::Resources::Parsers::EModelParserFlags GetAssetMetadata(const std::s
 	return flags;
 }
 
+bool ShouldGenerateEmbeddedAssets(const std::string& p_path)
+{
+	auto metaFile = OvTools::Filesystem::IniFile(p_path + ".meta");
+	return metaFile.GetOrDefault("GENERATE_EMBEDDED_ASSETS", true);
+}
+
+template<typename TResourceManager, typename TIndexParser>
+void ReloadEmbeddedResourcesForModelByType(
+	TResourceManager& p_resourceManager,
+	const std::string& p_modelPath,
+	TIndexParser p_parseIndex
+)
+{
+	for (auto& [resourcePath, resource] : p_resourceManager.GetResources())
+	{
+		(void)resource;
+		const auto embeddedAssetPath = OvRendering::Resources::Parsers::ParseEmbeddedAssetPath(resourcePath.string());
+		if (!embeddedAssetPath || embeddedAssetPath->modelPath != p_modelPath)
+		{
+			continue;
+		}
+
+		if (!p_parseIndex(embeddedAssetPath->assetName))
+		{
+			continue;
+		}
+
+		p_resourceManager.AResourceManager::ReloadResource(resourcePath);
+	}
+}
+
+void ReloadEmbeddedModelResources(const std::string& p_modelPath)
+{
+	ReloadEmbeddedResourcesForModelByType(
+		OvCore::Global::ServiceLocator::Get<OvCore::ResourceManagement::MaterialManager>(),
+		p_modelPath,
+		[](const std::string& p_assetName) { return OvRendering::Resources::Parsers::ParseEmbeddedMaterialIndex(p_assetName).has_value(); }
+	);
+
+	ReloadEmbeddedResourcesForModelByType(
+		OvCore::Global::ServiceLocator::Get<OvCore::ResourceManagement::TextureManager>(),
+		p_modelPath,
+		[](const std::string& p_assetName) { return OvRendering::Resources::Parsers::ParseEmbeddedTextureIndex(p_assetName).has_value(); }
+	);
+}
+
 OvRendering::Resources::Model* OvCore::ResourceManagement::ModelManager::CreateResource(const std::filesystem::path& p_path)
 {
 	std::string realPath = GetRealPath(p_path).string();
-	auto model = OvRendering::Resources::Loaders::ModelLoader::Create(realPath, GetAssetMetadata(realPath));
+	auto model = OvRendering::Resources::Loaders::ModelLoader::Create(
+		realPath,
+		GetAssetMetadata(realPath),
+		ShouldGenerateEmbeddedAssets(realPath)
+	);
 	if (model)
 	{
 		const_cast<std::string&>(model->path) = p_path.string(); // Force the resource path to fit the given path
@@ -69,5 +123,12 @@ void OvCore::ResourceManagement::ModelManager::DestroyResource(OvRendering::Reso
 void OvCore::ResourceManagement::ModelManager::ReloadResource(OvRendering::Resources::Model* p_resource, const std::filesystem::path& p_path)
 {
 	std::string realPath = GetRealPath(p_path).string();
-	OvRendering::Resources::Loaders::ModelLoader::Reload(*p_resource, realPath, GetAssetMetadata(realPath));
+	OvRendering::Resources::Loaders::ModelLoader::Reload(
+		*p_resource,
+		realPath,
+		GetAssetMetadata(realPath),
+		ShouldGenerateEmbeddedAssets(realPath)
+	);
+
+	ReloadEmbeddedModelResources(p_path.string());
 }