Add material render metadata and loader parsing

tests/Resources/Material/test_material.cpp

@@ -34,6 +34,76 @@ TEST(Material, SetGetShader) {
     EXPECT_EQ(material.GetShader(), shader);
 }
 
+TEST(Material, DefaultRenderMetadata) {
+    Material material;
+    EXPECT_EQ(material.GetRenderQueue(), static_cast<XCEngine::Core::int32>(MaterialRenderQueue::Geometry));
+    EXPECT_TRUE(material.GetShaderPass().Empty());
+    EXPECT_EQ(material.GetTagCount(), 0u);
+}
+
+TEST(Material, SetGetRenderQueue) {
+    Material material;
+
+    material.SetRenderQueue(MaterialRenderQueue::Transparent);
+    EXPECT_EQ(material.GetRenderQueue(), static_cast<XCEngine::Core::int32>(MaterialRenderQueue::Transparent));
+
+    material.SetRenderQueue(2600);
+    EXPECT_EQ(material.GetRenderQueue(), 2600);
+}
+
+TEST(Material, SetGetShaderPass) {
+    Material material;
+
+    material.SetShaderPass("ForwardLit");
+    EXPECT_EQ(material.GetShaderPass(), "ForwardLit");
+}
+
+TEST(Material, SetGetTags) {
+    Material material;
+
+    material.SetTag("LightMode", "ForwardBase");
+    material.SetTag("RenderType", "Opaque");
+
+    EXPECT_TRUE(material.HasTag("LightMode"));
+    EXPECT_EQ(material.GetTag("LightMode"), "ForwardBase");
+    EXPECT_EQ(material.GetTag("RenderType"), "Opaque");
+    EXPECT_EQ(material.GetTagCount(), 2u);
+}
+
+TEST(Material, SetTagReplacesExistingValue) {
+    Material material;
+
+    material.SetTag("LightMode", "ForwardBase");
+    material.SetTag("LightMode", "ShadowCaster");
+
+    EXPECT_EQ(material.GetTagCount(), 1u);
+    EXPECT_EQ(material.GetTag("LightMode"), "ShadowCaster");
+}
+
+TEST(Material, RemoveTag) {
+    Material material;
+
+    material.SetTag("LightMode", "ForwardBase");
+    EXPECT_TRUE(material.HasTag("LightMode"));
+
+    material.RemoveTag("LightMode");
+    EXPECT_FALSE(material.HasTag("LightMode"));
+    EXPECT_TRUE(material.GetTag("LightMode").Empty());
+}
+
+TEST(Material, ClearTags) {
+    Material material;
+
+    material.SetTag("LightMode", "ForwardBase");
+    material.SetTag("RenderType", "Opaque");
+    ASSERT_EQ(material.GetTagCount(), 2u);
+
+    material.ClearTags();
+    EXPECT_EQ(material.GetTagCount(), 0u);
+    EXPECT_FALSE(material.HasTag("LightMode"));
+    EXPECT_FALSE(material.HasTag("RenderType"));
+}
+
 TEST(Material, SetGetFloat) {
     Material material;
     

tests/Resources/Material/test_material_loader.cpp

@@ -1,8 +1,13 @@
 #include <gtest/gtest.h>
 #include <XCEngine/Resources/Material/MaterialLoader.h>
+#include <XCEngine/Core/Asset/ResourceManager.h>
 #include <XCEngine/Core/Asset/ResourceTypes.h>
 #include <XCEngine/Core/Containers/Array.h>
 
+#include <cstdio>
+#include <filesystem>
+#include <fstream>
+
 using namespace XCEngine::Resources;
 using namespace XCEngine::Containers;
 
@@ -33,4 +38,76 @@ TEST(MaterialLoader, LoadInvalidPath) {
     EXPECT_FALSE(result);
 }
 
+TEST(MaterialLoader, ResourceManagerRegistersMaterialAndShaderLoaders) {
+    ResourceManager& manager = ResourceManager::Get();
+    manager.Initialize();
+
+    EXPECT_NE(manager.GetLoader(ResourceType::Material), nullptr);
+    EXPECT_NE(manager.GetLoader(ResourceType::Shader), nullptr);
+
+    manager.Shutdown();
+}
+
+TEST(MaterialLoader, LoadValidMaterialParsesRenderMetadata) {
+    const std::filesystem::path shaderPath =
+        std::filesystem::current_path() / "material_loader_valid_shader.hlsl";
+    const std::filesystem::path materialPath =
+        std::filesystem::current_path() / "material_loader_valid.material";
+
+    {
+        std::ofstream shaderFile(shaderPath);
+        ASSERT_TRUE(shaderFile.is_open());
+        shaderFile << "float4 MainPS() : SV_TARGET { return float4(1, 1, 1, 1); }";
+    }
+
+    {
+        std::ofstream materialFile(materialPath);
+        ASSERT_TRUE(materialFile.is_open());
+        materialFile << "{\n";
+        materialFile << "  \"shader\": \"" << shaderPath.generic_string() << "\",\n";
+        materialFile << "  \"renderQueue\": \"Transparent\",\n";
+        materialFile << "  \"shaderPass\": \"ForwardLit\",\n";
+        materialFile << "  \"tags\": {\n";
+        materialFile << "    \"LightMode\": \"ForwardBase\",\n";
+        materialFile << "    \"RenderType\": \"Transparent\"\n";
+        materialFile << "  }\n";
+        materialFile << "}";
+    }
+
+    MaterialLoader loader;
+    LoadResult result = loader.Load(materialPath.string().c_str());
+    ASSERT_TRUE(result);
+    ASSERT_NE(result.resource, nullptr);
+
+    Material* material = static_cast<Material*>(result.resource);
+    ASSERT_NE(material, nullptr);
+    EXPECT_TRUE(material->IsValid());
+    EXPECT_NE(material->GetShader(), nullptr);
+    EXPECT_EQ(material->GetRenderQueue(), static_cast<XCEngine::Core::int32>(MaterialRenderQueue::Transparent));
+    EXPECT_EQ(material->GetShaderPass(), "ForwardLit");
+    EXPECT_EQ(material->GetTag("LightMode"), "ForwardBase");
+    EXPECT_EQ(material->GetTag("RenderType"), "Transparent");
+
+    delete material;
+    std::remove(materialPath.string().c_str());
+    std::remove(shaderPath.string().c_str());
+}
+
+TEST(MaterialLoader, RejectsUnknownRenderQueueName) {
+    const std::filesystem::path materialPath =
+        std::filesystem::current_path() / "material_loader_invalid_queue.material";
+
+    {
+        std::ofstream materialFile(materialPath);
+        ASSERT_TRUE(materialFile.is_open());
+        materialFile << "{ \"renderQueue\": \"NotAQueue\" }";
+    }
+
+    MaterialLoader loader;
+    LoadResult result = loader.Load(materialPath.string().c_str());
+    EXPECT_FALSE(result);
+
+    std::remove(materialPath.string().c_str());
+}
+
 } // namespace