feat(Resources): 添加资源系统基础框架

- ResourceTypes: 资源类型枚举、ResourceGUID生成
- IResource: 资源基类接口
- ResourceHandle: 资源句柄智能指针
- IResourceLoader: 加载器接口
- ResourceManager: 资源管理器(单例模式)
- ResourceCache: LRU缓存实现
- AsyncLoader: 异步加载器
- 测试框架: test_resource_types, test_resource_guid

Note: 当前与现有容器API存在编译差异,需要后续修复

engine/src/Resources/AsyncLoader.cpp

@@ -0,0 +1,103 @@
+#include "Resources/AsyncLoader.h"
+#include "Resources/ResourceManager.h"
+#include "Resources/ResourceTypes.h"
+
+namespace XCEngine {
+namespace Resources {
+
+Core::uint64 LoadRequest::GenerateRequestId() {
+    static std::atomic<Core::uint64> s_requestId{0};
+    return ++s_requestId;
+}
+
+AsyncLoader& AsyncLoader::Get() {
+    static AsyncLoader instance;
+    return instance;
+}
+
+void AsyncLoader::Initialize(Core::uint32 workerThreadCount) {
+    (void)workerThreadCount;
+}
+
+void AsyncLoader::Shutdown() {
+    CancelAll();
+}
+
+void AsyncLoader::Submit(const Containers::String& path, ResourceType type,
+                        std::function<void(LoadResult)> callback) {
+    Submit(path, type, nullptr, std::move(callback));
+}
+
+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);
+}
+
+void AsyncLoader::SubmitInternal(LoadRequest& request) {
+    IResourceLoader* loader = FindLoader(request.type);
+    
+    if (!loader) {
+        if (request.callback) {
+            LoadResult result(Containers::String("No loader for type: ") + 
+                           GetResourceTypeName(request.type));
+            request.callback(result);
+        }
+        return;
+    }
+    
+    {
+        std::lock_guard lock(m_queueMutex);
+        m_pendingQueue.PushBack(request);
+        m_pendingCount++;
+        m_totalRequested++;
+    }
+}
+
+void AsyncLoader::Update() {
+    Containers::Array<LoadRequest> completed;
+    
+    {
+        std::lock_guard lock(m_completedMutex);
+        completed = std::move(m_completedQueue);
+        m_completedQueue.Clear();
+    }
+    
+    for (auto& request : completed) {
+        m_pendingCount--;
+        
+        if (request.callback) {
+            LoadResult result(true);
+            request.callback(result);
+        }
+    }
+}
+
+float AsyncLoader::GetProgress() const {
+    if (m_totalRequested == 0) return 1.0f;
+    return static_cast<float>(m_totalRequested - m_pendingCount.load()) / m_totalRequested;
+}
+
+void AsyncLoader::CancelAll() {
+    std::lock_guard lock(m_queueMutex);
+    m_pendingQueue.Clear();
+    m_pendingCount = 0;
+}
+
+void AsyncLoader::Cancel(Core::uint64 requestId) {
+    std::lock_guard lock(m_queueMutex);
+    (void)requestId;
+}
+
+IResourceLoader* AsyncLoader::FindLoader(ResourceType type) const {
+    return ResourceManager::Get().GetLoader(type);
+}
+
+void AsyncLoader::QueueCompleted(LoadRequest request, LoadResult result) {
+    std::lock_guard lock(m_completedMutex);
+    (void)request;
+    (void)result;
+}
+
+} // namespace Resources
+} // namespace XCEngine