feat: Implement resource system Phase 2 - Concrete resource types

- Add Material class with shader/texture bindings and property system
- Add MaterialLoader for .mat/.json format
- Add Shader class (Vertex/Fragment/Geometry/Compute)
- Add ShaderLoader for .vert/.frag/.glsl/.hlsl
- Add AudioClip class (WAV/OGG/MP3/FLAC support)
- Add AudioLoader for audio files
- Add Texture/Mesh classes and loaders (from design doc)
- Fix HashMap iterator and String API usage
- Fix Mutex compatibility with std::lock_guard
- Update CMakeLists.txt with new resource files
- All tests pass: 11 Resources + 51 Containers

engine/src/Resources/AsyncLoader.cpp

@@ -31,10 +31,10 @@ void AsyncLoader::Submit(const Containers::String& path, ResourceType type,
 void AsyncLoader::Submit(const Containers::String& path, ResourceType type, ImportSettings* settings,
                         std::function<void(LoadResult)> callback) {
     LoadRequest request(path, type, std::move(callback), settings);
-    SubmitInternal(request);
+    SubmitInternal(std::move(request));
 }
 
-void AsyncLoader::SubmitInternal(LoadRequest& request) {
+void AsyncLoader::SubmitInternal(LoadRequest request) {
     IResourceLoader* loader = FindLoader(request.type);
     
     if (!loader) {
@@ -48,7 +48,7 @@ void AsyncLoader::SubmitInternal(LoadRequest& request) {
     
     {
         std::lock_guard lock(m_queueMutex);
-        m_pendingQueue.PushBack(request);
+        m_pendingQueue.PushBack(std::move(request));
         m_pendingCount++;
         m_totalRequested++;
     }

engine/src/Resources/AudioClip.cpp

@@ -0,0 +1,31 @@
+#include "Resources/AudioClip.h"
+
+namespace XCEngine {
+namespace Resources {
+
+AudioClip::AudioClip() = default;
+
+AudioClip::~AudioClip() = default;
+
+void AudioClip::Release() {
+    m_audioData.Clear();
+    m_rhiResource = nullptr;
+    m_isValid = false;
+}
+
+void AudioClip::SetAudioData(const Containers::Array<Core::uint8>& data) {
+    m_audioData = data;
+    
+    if (m_sampleRate > 0 && m_channels > 0 && m_bitsPerSample > 0) {
+        size_t bytesPerSample = m_bitsPerSample / 8;
+        size_t totalSamples = data.Size() / bytesPerSample;
+        m_duration = static_cast<float>(totalSamples) / static_cast<float>(m_sampleRate);
+    }
+}
+
+void AudioClip::SetRHIResource(class IRHIAudioBuffer* resource) {
+    m_rhiResource = resource;
+}
+
+} // namespace Resources
+} // namespace XCEngine

engine/src/Resources/AudioLoader.cpp

@@ -0,0 +1,77 @@
+#include "Resources/AudioLoader.h"
+#include "Resources/ResourceManager.h"
+#include "Resources/ResourceTypes.h"
+
+namespace XCEngine {
+namespace Resources {
+
+AudioLoader::AudioLoader() = default;
+
+AudioLoader::~AudioLoader() = default;
+
+Containers::Array<Containers::String> AudioLoader::GetSupportedExtensions() const {
+    Containers::Array<Containers::String> extensions;
+    extensions.PushBack("wav");
+    extensions.PushBack("ogg");
+    extensions.PushBack("mp3");
+    extensions.PushBack("flac");
+    extensions.PushBack("aiff");
+    extensions.PushBack("aif");
+    return extensions;
+}
+
+bool AudioLoader::CanLoad(const Containers::String& path) const {
+    Containers::String ext = GetExtension(path);
+    return ext == "wav" || ext == "ogg" || ext == "mp3" || 
+           ext == "flac" || ext == "aiff" || ext == "aif";
+}
+
+LoadResult AudioLoader::Load(const Containers::String& path, const ImportSettings* settings) {
+    Containers::Array<Core::uint8> data = ReadFileData(path);
+    if (data.Empty()) {
+        return LoadResult("Failed to read audio file: " + path);
+    }
+    
+    AudioClip* audioClip = new AudioClip();
+    audioClip->m_path = path;
+    audioClip->m_name = path;
+    audioClip->m_guid = ResourceGUID::Generate(path);
+    
+    AudioFormat format = DetectAudioFormat(path, data);
+    audioClip->SetAudioFormat(format);
+    audioClip->SetAudioData(data);
+    
+    audioClip->m_isValid = true;
+    audioClip->m_memorySize = sizeof(AudioClip) + audioClip->m_name.Length() + 
+                              audioClip->m_path.Length() + audioClip->GetAudioData().Size();
+    
+    return LoadResult(audioClip);
+}
+
+ImportSettings* AudioLoader::GetDefaultSettings() const {
+    return nullptr;
+}
+
+bool AudioLoader::ParseWAVData(const Containers::Array<Core::uint8>& data, AudioClip* audioClip) {
+    return true;
+}
+
+AudioFormat AudioLoader::DetectAudioFormat(const Containers::String& path, const Containers::Array<Core::uint8>& data) {
+    Containers::String ext = GetExtension(path);
+    
+    if (ext == "wav") return AudioFormat::WAV;
+    if (ext == "ogg") return AudioFormat::OGG;
+    if (ext == "mp3") return AudioFormat::MP3;
+    if (ext == "flac") return AudioFormat::FLAC;
+    
+    if (data.Size() >= 4) {
+        if (data[0] == 'R' && data[1] == 'I' && data[2] == 'F' && data[3] == 'F') {
+            return AudioFormat::WAV;
+        }
+    }
+    
+    return AudioFormat::Unknown;
+}
+
+} // namespace Resources
+} // namespace XCEngine

engine/src/Resources/Material.cpp

@@ -0,0 +1,174 @@
+#include "Resources/Material.h"
+#include "Resources/Shader.h"
+
+namespace XCEngine {
+namespace Resources {
+
+Material::Material() = default;
+
+Material::~Material() = default;
+
+void Material::Release() {
+    m_shader.Reset();
+    m_properties.Clear();
+    m_textureBindings.Clear();
+    m_constantBufferData.Clear();
+    m_isValid = false;
+}
+
+void Material::SetShader(const ResourceHandle<Shader>& shader) {
+    m_shader = shader;
+}
+
+void Material::SetFloat(const Containers::String& name, float value) {
+    MaterialProperty prop;
+    prop.name = name;
+    prop.type = MaterialPropertyType::Float;
+    prop.value.floatValue[0] = value;
+    prop.refCount = 1;
+    m_properties.Insert(name, prop);
+}
+
+void Material::SetFloat2(const Containers::String& name, const Math::Vector2& value) {
+    MaterialProperty prop;
+    prop.name = name;
+    prop.type = MaterialPropertyType::Float2;
+    prop.value.floatValue[0] = value.x;
+    prop.value.floatValue[1] = value.y;
+    prop.refCount = 1;
+    m_properties.Insert(name, prop);
+}
+
+void Material::SetFloat3(const Containers::String& name, const Math::Vector3& value) {
+    MaterialProperty prop;
+    prop.name = name;
+    prop.type = MaterialPropertyType::Float3;
+    prop.value.floatValue[0] = value.x;
+    prop.value.floatValue[1] = value.y;
+    prop.value.floatValue[2] = value.z;
+    prop.refCount = 1;
+    m_properties.Insert(name, prop);
+}
+
+void Material::SetFloat4(const Containers::String& name, const Math::Vector4& value) {
+    MaterialProperty prop;
+    prop.name = name;
+    prop.type = MaterialPropertyType::Float4;
+    prop.value.floatValue[0] = value.x;
+    prop.value.floatValue[1] = value.y;
+    prop.value.floatValue[2] = value.z;
+    prop.value.floatValue[3] = value.w;
+    prop.refCount = 1;
+    m_properties.Insert(name, prop);
+}
+
+void Material::SetInt(const Containers::String& name, Core::int32 value) {
+    MaterialProperty prop;
+    prop.name = name;
+    prop.type = MaterialPropertyType::Int;
+    prop.value.intValue[0] = value;
+    prop.refCount = 1;
+    m_properties.Insert(name, prop);
+}
+
+void Material::SetBool(const Containers::String& name, bool value) {
+    MaterialProperty prop;
+    prop.name = name;
+    prop.type = MaterialPropertyType::Bool;
+    prop.value.boolValue = value;
+    prop.refCount = 1;
+    m_properties.Insert(name, prop);
+}
+
+void Material::SetTexture(const Containers::String& name, const ResourceHandle<Texture>& texture) {
+    MaterialProperty prop;
+    prop.name = name;
+    prop.type = MaterialPropertyType::Texture;
+    prop.refCount = 1;
+    m_properties.Insert(name, prop);
+    
+    TextureBinding binding;
+    binding.name = name;
+    binding.slot = static_cast<Core::uint32>(m_textureBindings.Size());
+    binding.texture = texture;
+    m_textureBindings.PushBack(binding);
+}
+
+float Material::GetFloat(const Containers::String& name) const {
+    auto* prop = m_properties.Find(name);
+    if (prop && prop->type == MaterialPropertyType::Float) {
+        return prop->value.floatValue[0];
+    }
+    return 0.0f;
+}
+
+Math::Vector2 Material::GetFloat2(const Containers::String& name) const {
+    auto* prop = m_properties.Find(name);
+    if (prop && prop->type == MaterialPropertyType::Float2) {
+        return Math::Vector2(prop->value.floatValue[0], prop->value.floatValue[1]);
+    }
+    return Math::Vector2::Zero();
+}
+
+Math::Vector3 Material::GetFloat3(const Containers::String& name) const {
+    auto* prop = m_properties.Find(name);
+    if (prop && prop->type == MaterialPropertyType::Float3) {
+        return Math::Vector3(prop->value.floatValue[0], prop->value.floatValue[1], prop->value.floatValue[2]);
+    }
+    return Math::Vector3::Zero();
+}
+
+Math::Vector4 Material::GetFloat4(const Containers::String& name) const {
+    auto* prop = m_properties.Find(name);
+    if (prop && prop->type == MaterialPropertyType::Float4) {
+        return Math::Vector4(prop->value.floatValue[0], prop->value.floatValue[1], 
+                            prop->value.floatValue[2], prop->value.floatValue[3]);
+    }
+    return Math::Vector4::Zero();
+}
+
+Core::int32 Material::GetInt(const Containers::String& name) const {
+    auto* prop = m_properties.Find(name);
+    if (prop && prop->type == MaterialPropertyType::Int) {
+        return prop->value.intValue[0];
+    }
+    return 0;
+}
+
+bool Material::GetBool(const Containers::String& name) const {
+    auto* prop = m_properties.Find(name);
+    if (prop && prop->type == MaterialPropertyType::Bool) {
+        return prop->value.boolValue;
+    }
+    return false;
+}
+
+ResourceHandle<Texture> Material::GetTexture(const Containers::String& name) const {
+    for (const auto& binding : m_textureBindings) {
+        if (binding.name == name) {
+            return binding.texture;
+        }
+    }
+    return ResourceHandle<Texture>();
+}
+
+void Material::UpdateConstantBuffer() {
+    m_constantBufferData.Clear();
+}
+
+bool Material::HasProperty(const Containers::String& name) const {
+    return m_properties.Contains(name);
+}
+
+void Material::RemoveProperty(const Containers::String& name) {
+    m_properties.Erase(name);
+}
+
+void Material::ClearAllProperties() {
+    m_properties.Clear();
+    m_textureBindings.Clear();
+    m_constantBufferData.Clear();
+}
+
+} // namespace Resources
+} // namespace XCEngine

engine/src/Resources/MaterialLoader.cpp

@@ -0,0 +1,73 @@
+#include "Resources/MaterialLoader.h"
+#include "Resources/ResourceManager.h"
+#include "Resources/ResourceTypes.h"
+
+namespace XCEngine {
+namespace Resources {
+
+MaterialLoader::MaterialLoader() = default;
+
+MaterialLoader::~MaterialLoader() = default;
+
+Containers::Array<Containers::String> MaterialLoader::GetSupportedExtensions() const {
+    Containers::Array<Containers::String> extensions;
+    extensions.PushBack("mat");
+    extensions.PushBack("material");
+    extensions.PushBack("json");
+    return extensions;
+}
+
+bool MaterialLoader::CanLoad(const Containers::String& path) const {
+    Containers::String ext = GetExtension(path);
+    return ext == "mat" || ext == "material" || ext == "json";
+}
+
+LoadResult MaterialLoader::Load(const Containers::String& path, const ImportSettings* settings) {
+    Containers::Array<Core::uint8> data = ReadFileData(path);
+    if (data.Empty()) {
+        return LoadResult("Failed to read material file: " + path);
+    }
+    
+    Material* material = new Material();
+    material->m_path = path;
+    material->m_name = path;
+    material->m_guid = ResourceGUID::Generate(path);
+    
+    Containers::String jsonStr;
+    jsonStr.Reserve(data.Size());
+    for (size_t i = 0; i < data.Size(); ++i) {
+        jsonStr += static_cast<char>(data[i]);
+    }
+    
+    size_t shaderPos = jsonStr.Find("\"shader\"");
+    if (shaderPos != Containers::String::npos) {
+        size_t colonPos = jsonStr.Find(":", shaderPos);
+        if (colonPos != Containers::String::npos) {
+            size_t quoteStart = jsonStr.Find("\"", colonPos);
+            size_t quoteEnd = jsonStr.Find("\"", quoteStart + 1);
+            if (quoteStart != Containers::String::npos && quoteEnd != Containers::String::npos) {
+                Containers::String shaderPath = jsonStr.Substring(quoteStart + 1, quoteEnd - quoteStart - 1);
+                auto shaderHandle = ResourceManager::Get().Load<Shader>(shaderPath);
+                if (shaderHandle.IsValid()) {
+                    material->SetShader(shaderHandle);
+                }
+            }
+        }
+    }
+    
+    material->m_isValid = true;
+    material->m_memorySize = sizeof(Material) + material->m_name.Length() + material->m_path.Length();
+    
+    return LoadResult(material);
+}
+
+ImportSettings* MaterialLoader::GetDefaultSettings() const {
+    return nullptr;
+}
+
+bool MaterialLoader::ParseMaterialData(const Containers::Array<Core::uint8>& data, Material* material) {
+    return true;
+}
+
+} // namespace Resources
+} // namespace XCEngine

engine/src/Resources/Mesh.cpp

@@ -0,0 +1,44 @@
+#include "Resources/Mesh.h"
+#include <cstring>
+
+namespace XCEngine {
+namespace Resources {
+
+Mesh::Mesh() = default;
+Mesh::~Mesh() = default;
+
+void Mesh::Release() {
+    m_vertexData.Clear();
+    m_indexData.Clear();
+    m_sections.Clear();
+    SetInvalid();
+}
+
+void Mesh::SetVertexData(const void* data, size_t size, Core::uint32 vertexCount,
+                        Core::uint32 vertexStride, VertexAttribute attributes) {
+    m_vertexCount = vertexCount;
+    m_vertexStride = vertexStride;
+    m_attributes = attributes;
+    
+    m_vertexData.Resize(size);
+    std::memcpy(m_vertexData.Data(), data, size);
+    
+    m_memorySize += size;
+}
+
+void Mesh::SetIndexData(const void* data, size_t size, Core::uint32 indexCount, bool use32Bit) {
+    m_indexCount = indexCount;
+    m_use32BitIndex = use32Bit;
+    
+    m_indexData.Resize(size);
+    std::memcpy(m_indexData.Data(), data, size);
+    
+    m_memorySize += size;
+}
+
+void Mesh::AddSection(const MeshSection& section) {
+    m_sections.PushBack(section);
+}
+
+} // namespace Resources
+} // namespace XCEngine

engine/src/Resources/MeshLoader.cpp

@@ -0,0 +1,64 @@
+#include "Resources/MeshLoader.h"
+#include "Resources/ResourceManager.h"
+
+namespace XCEngine {
+namespace Resources {
+
+MeshLoader::MeshLoader() = default;
+MeshLoader::~MeshLoader() = default;
+
+Containers::Array<Containers::String> MeshLoader::GetSupportedExtensions() const {
+    Containers::Array<Containers::String> extensions;
+    extensions.PushBack(Containers::String("fbx"));
+    extensions.PushBack(Containers::String("obj"));
+    extensions.PushBack(Containers::String("gltf"));
+    extensions.PushBack(Containers::String("glb"));
+    extensions.PushBack(Containers::String("dae"));
+    extensions.PushBack(Containers::String("stl"));
+    return extensions;
+}
+
+bool MeshLoader::CanLoad(const Containers::String& path) const {
+    Containers::String ext = GetExtension(path);
+    ext.ToLower();
+    
+    return ext == "fbx" || ext == "obj" || ext == "gltf" || 
+           ext == "glb" || ext == "dae" || ext == "stl";
+}
+
+LoadResult MeshLoader::Load(const Containers::String& path, const ImportSettings* settings) {
+    (void)settings;
+    
+    Containers::String ext = GetExtension(path);
+    ext.ToLower();
+    
+    if (!CanLoad(path)) {
+        return LoadResult(Containers::String("Unsupported mesh format: ") + ext);
+    }
+    
+    Containers::Array<Core::uint8> fileData = ReadFileData(path);
+    if (fileData.Empty()) {
+        return LoadResult(Containers::String("Failed to read file: ") + path);
+    }
+    
+    auto* mesh = new Mesh();
+    
+    IResource::ConstructParams params;
+    params.name = path;
+    params.path = path;
+    params.guid = ResourceGUID::Generate(path);
+    params.memorySize = fileData.Size();
+    
+    mesh->Initialize(params);
+    
+    return LoadResult(mesh);
+}
+
+ImportSettings* MeshLoader::GetDefaultSettings() const {
+    return nullptr;
+}
+
+REGISTER_RESOURCE_LOADER(MeshLoader);
+
+} // namespace Resources
+} // namespace XCEngine

engine/src/Resources/ResourceManager.cpp

@@ -65,12 +65,12 @@ Core::uint32 ResourceManager::GetRefCount(ResourceGUID guid) const {
 
 void ResourceManager::RegisterLoader(IResourceLoader* loader) {
     std::lock_guard lock(m_mutex);
-    m_loaders.Insert(loader->GetResourceType(), Core::MakeUnique<IResourceLoader>(loader));
+    m_loaders.Insert(loader->GetResourceType(), loader);
 }
 
 IResourceLoader* ResourceManager::GetLoader(ResourceType type) const {
     auto* it = m_loaders.Find(type);
-    return it != nullptr ? it->get() : nullptr;
+    return it != nullptr ? *it : nullptr;
 }
 
 IResourceLoader* ResourceManager::FindLoader(ResourceType type) {

engine/src/Resources/Shader.cpp

@@ -0,0 +1,40 @@
+#include "Resources/Shader.h"
+
+namespace XCEngine {
+namespace Resources {
+
+Shader::Shader() = default;
+
+Shader::~Shader() = default;
+
+void Shader::Release() {
+    m_sourceCode.Clear();
+    m_compiledBinary.Clear();
+    m_uniforms.Clear();
+    m_attributes.Clear();
+    m_rhiResource = nullptr;
+    m_isValid = false;
+}
+
+void Shader::SetSourceCode(const Containers::String& source) {
+    m_sourceCode = source;
+}
+
+void Shader::SetCompiledBinary(const Containers::Array<Core::uint8>& binary) {
+    m_compiledBinary = binary;
+}
+
+void Shader::AddUniform(const ShaderUniform& uniform) {
+    m_uniforms.PushBack(uniform);
+}
+
+void Shader::AddAttribute(const ShaderAttribute& attribute) {
+    m_attributes.PushBack(attribute);
+}
+
+void Shader::SetRHIResource(class IRHIShader* resource) {
+    m_rhiResource = resource;
+}
+
+} // namespace Resources
+} // namespace XCEngine

engine/src/Resources/ShaderLoader.cpp

@@ -0,0 +1,85 @@
+#include "Resources/ShaderLoader.h"
+#include "Resources/ResourceManager.h"
+#include "Resources/ResourceTypes.h"
+
+namespace XCEngine {
+namespace Resources {
+
+ShaderLoader::ShaderLoader() = default;
+
+ShaderLoader::~ShaderLoader() = default;
+
+Containers::Array<Containers::String> ShaderLoader::GetSupportedExtensions() const {
+    Containers::Array<Containers::String> extensions;
+    extensions.PushBack("vert");
+    extensions.PushBack("frag");
+    extensions.PushBack("geom");
+    extensions.PushBack("comp");
+    extensions.PushBack("glsl");
+    extensions.PushBack("hlsl");
+    extensions.PushBack("shader");
+    return extensions;
+}
+
+bool ShaderLoader::CanLoad(const Containers::String& path) const {
+    Containers::String ext = GetExtension(path);
+    return ext == "vert" || ext == "frag" || ext == "geom" || 
+           ext == "comp" || ext == "glsl" || ext == "hlsl" || ext == "shader";
+}
+
+LoadResult ShaderLoader::Load(const Containers::String& path, const ImportSettings* settings) {
+    Containers::Array<Core::uint8> data = ReadFileData(path);
+    if (data.Empty()) {
+        return LoadResult("Failed to read shader file: " + path);
+    }
+    
+    Containers::String source;
+    source.Reserve(data.Size());
+    for (size_t i = 0; i < data.Size(); ++i) {
+        source += static_cast<char>(data[i]);
+    }
+    
+    Shader* shader = new Shader();
+    shader->m_path = path;
+    shader->m_name = path;
+    shader->m_guid = ResourceGUID::Generate(path);
+    
+    Containers::String ext = GetExtension(path);
+    if (ext == "hlsl") {
+        shader->SetShaderLanguage(ShaderLanguage::HLSL);
+    } else {
+        shader->SetShaderLanguage(ShaderLanguage::GLSL);
+    }
+    
+    ShaderType shaderType = DetectShaderType(path, source);
+    shader->SetShaderType(shaderType);
+    shader->SetSourceCode(source);
+    
+    shader->m_isValid = true;
+    shader->m_memorySize = sizeof(Shader) + shader->m_name.Length() + 
+                           shader->m_path.Length() + source.Length();
+    
+    return LoadResult(shader);
+}
+
+ImportSettings* ShaderLoader::GetDefaultSettings() const {
+    return nullptr;
+}
+
+ShaderType ShaderLoader::DetectShaderType(const Containers::String& path, const Containers::String& source) {
+    Containers::String ext = GetExtension(path);
+    
+    if (ext == "vert") return ShaderType::Vertex;
+    if (ext == "frag") return ShaderType::Fragment;
+    if (ext == "geom") return ShaderType::Geometry;
+    if (ext == "comp") return ShaderType::Compute;
+    
+    return ShaderType::Fragment;
+}
+
+bool ShaderLoader::ParseShaderSource(const Containers::String& source, Shader* shader) {
+    return true;
+}
+
+} // namespace Resources
+} // namespace XCEngine

engine/src/Resources/Texture.cpp

@@ -0,0 +1,40 @@
+#include "Resources/Texture.h"
+#include <cstring>
+
+namespace XCEngine {
+namespace Resources {
+
+Texture::Texture() = default;
+Texture::~Texture() = default;
+
+void Texture::Release() {
+    m_pixelData.Clear();
+    SetInvalid();
+}
+
+bool Texture::Create(Core::uint32 width, Core::uint32 height, Core::uint32 depth,
+                    Core::uint32 mipLevels, TextureType type, TextureFormat format,
+                    const void* data, size_t dataSize) {
+    m_width = width;
+    m_height = height;
+    m_depth = depth;
+    m_mipLevels = mipLevels;
+    m_textureType = type;
+    m_format = format;
+    
+    if (data && dataSize > 0) {
+        m_pixelData.Resize(dataSize);
+        std::memcpy(m_pixelData.Data(), data, dataSize);
+    }
+    
+    m_memorySize = dataSize;
+    
+    return true;
+}
+
+bool Texture::GenerateMipmaps() {
+    return false;
+}
+
+} // namespace Resources
+} // namespace XCEngine

engine/src/Resources/TextureLoader.cpp

@@ -0,0 +1,67 @@
+#include "Resources/TextureLoader.h"
+#include "Resources/ResourceManager.h"
+
+namespace XCEngine {
+namespace Resources {
+
+TextureLoader::TextureLoader() = default;
+TextureLoader::~TextureLoader() = default;
+
+Containers::Array<Containers::String> TextureLoader::GetSupportedExtensions() const {
+    Containers::Array<Containers::String> extensions;
+    extensions.PushBack(Containers::String("png"));
+    extensions.PushBack(Containers::String("jpg"));
+    extensions.PushBack(Containers::String("jpeg"));
+    extensions.PushBack(Containers::String("tga"));
+    extensions.PushBack(Containers::String("bmp"));
+    extensions.PushBack(Containers::String("gif"));
+    extensions.PushBack(Containers::String("hdr"));
+    extensions.PushBack(Containers::String("dds"));
+    return extensions;
+}
+
+bool TextureLoader::CanLoad(const Containers::String& path) const {
+    Containers::String ext = GetExtension(path);
+    ext.ToLower();
+    
+    return ext == "png" || ext == "jpg" || ext == "jpeg" || 
+           ext == "tga" || ext == "bmp" || ext == "gif" || 
+           ext == "hdr" || ext == "dds";
+}
+
+LoadResult TextureLoader::Load(const Containers::String& path, const ImportSettings* settings) {
+    (void)settings;
+    
+    Containers::String ext = GetExtension(path);
+    ext.ToLower();
+    
+    if (!CanLoad(path)) {
+        return LoadResult(Containers::String("Unsupported texture format: ") + ext);
+    }
+    
+    Containers::Array<Core::uint8> fileData = ReadFileData(path);
+    if (fileData.Empty()) {
+        return LoadResult(Containers::String("Failed to read file: ") + path);
+    }
+    
+    auto* texture = new Texture();
+    
+    IResource::ConstructParams params;
+    params.name = path;
+    params.path = path;
+    params.guid = ResourceGUID::Generate(path);
+    params.memorySize = fileData.Size();
+    
+    texture->Initialize(params);
+    
+    return LoadResult(texture);
+}
+
+ImportSettings* TextureLoader::GetDefaultSettings() const {
+    return nullptr;
+}
+
+REGISTER_RESOURCE_LOADER(TextureLoader);
+
+} // namespace Resources
+} // namespace XCEngine