From 8e62837bbbb2a4b4bff7e98394ab94bd02ae3be1 Mon Sep 17 00:00:00 2001
From: Ziyu <theorhythm@gmail.com>
Date: Mon, 19 May 2025 16:22:09 +0800
Subject: [PATCH] =?UTF-8?q?=E5=AE=8C=E6=88=90=E8=B5=84=E6=BA=90=E7=AE=A1?=
 =?UTF-8?q?=E7=90=86=E6=A8=A1=E5=9D=97?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CMakeLists.txt                           |   4 +
 src/engine/core/game_app.cpp             |  84 ++++++++++---
 src/engine/core/game_app.h               |  13 +++
 src/engine/resource/audio_manager.cpp    | 143 +++++++++++++++++++++++
 src/engine/resource/audio_manager.h      |  74 ++++++++++++
 src/engine/resource/font_manager.cpp     |  82 +++++++++++++
 src/engine/resource/font_manager.h       |  72 ++++++++++++
 src/engine/resource/resource_manager.cpp | 103 ++++++++++++++++
 src/engine/resource/resource_manager.h   |  75 ++++++++++++
 src/engine/resource/texture_manager.cpp  |  84 +++++++++++++
 src/engine/resource/texture_manager.h    |  58 +++++++++
 src/main.cpp                             |   3 +
 12 files changed, 777 insertions(+), 18 deletions(-)
 create mode 100644 src/engine/resource/audio_manager.cpp
 create mode 100644 src/engine/resource/audio_manager.h
 create mode 100644 src/engine/resource/font_manager.cpp
 create mode 100644 src/engine/resource/font_manager.h
 create mode 100644 src/engine/resource/resource_manager.cpp
 create mode 100644 src/engine/resource/resource_manager.h
 create mode 100644 src/engine/resource/texture_manager.cpp
 create mode 100644 src/engine/resource/texture_manager.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index ed5a2fd..6df8dd1 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -33,6 +33,10 @@ add_executable(${TARGET}
                 src/main.cpp
                 src/engine/core/game_app.cpp
                 src/engine/core/time.cpp
+                src/engine/resource/resource_manager.cpp
+                src/engine/resource/texture_manager.cpp
+                src/engine/resource/audio_manager.cpp
+                src/engine/resource/font_manager.cpp
                 )
 
 # 链接库
diff --git a/src/engine/core/game_app.cpp b/src/engine/core/game_app.cpp
index 51e5b1e..0d665b6 100644
--- a/src/engine/core/game_app.cpp
+++ b/src/engine/core/game_app.cpp
@@ -1,13 +1,12 @@
 #include "game_app.h"
 #include "time.h"
+#include "../resource/resource_manager.h"
 #include <SDL3/SDL.h>
 #include <spdlog/spdlog.h>
 
 namespace engine::core {
 
-GameApp::GameApp() {
-    time_ = std::make_unique<Time>();
-}
+GameApp::GameApp() = default;
 
 GameApp::~GameApp() {
     if (is_running_) {
@@ -38,24 +37,15 @@ void GameApp::run() {
 
 bool GameApp::init() {
     spdlog::trace("初始化 GameApp ...");
-    if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO)) {
-        spdlog::error("SDL 初始化失败! SDL错误: {}", SDL_GetError());
-        return false;
-    }
+    if (!initSDL())  return false;
+    if (!initTime()) return false;
+    if (!initResourceManager()) return false;
 
-    window_ = SDL_CreateWindow("SunnyLand", 1280, 720, SDL_WINDOW_RESIZABLE);
-    if (window_ == nullptr) {
-        spdlog::error("无法创建窗口! SDL错误: {}", SDL_GetError());
-        return false;
-    }
-
-    sdl_renderer_ = SDL_CreateRenderer(window_, nullptr);
-    if (sdl_renderer_ == nullptr) {
-        spdlog::error("无法创建渲染器! SDL错误: {}", SDL_GetError());
-        return false;
-    }
+    // 测试资源管理器
+    testResourceManager();
 
     is_running_ = true;
+    spdlog::trace("GameApp 初始化成功。");
     return true;
 }
 
@@ -78,6 +68,10 @@ void GameApp::render() {
 
 void GameApp::close() {
     spdlog::trace("关闭 GameApp ...");
+
+    // 为了确保正确的销毁顺序，有些智能指针对象也需要手动管理
+    resource_manager_.reset();
+
     if (sdl_renderer_ != nullptr) {
         SDL_DestroyRenderer(sdl_renderer_);
         sdl_renderer_ = nullptr;
@@ -90,4 +84,58 @@ void GameApp::close() {
     is_running_ = false;
 }
 
+bool GameApp::initSDL() {
+    if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO)) {
+        spdlog::error("SDL 初始化失败! SDL错误: {}", SDL_GetError());
+        return false;
+    }
+
+    window_ = SDL_CreateWindow("SunnyLand", 1280, 720, SDL_WINDOW_RESIZABLE);
+    if (window_ == nullptr) {
+        spdlog::error("无法创建窗口! SDL错误: {}", SDL_GetError());
+        return false;
+    }
+
+    sdl_renderer_ = SDL_CreateRenderer(window_, nullptr);
+    if (sdl_renderer_ == nullptr) {
+        spdlog::error("无法创建渲染器! SDL错误: {}", SDL_GetError());
+        return false;
+    }
+    spdlog::trace("SDL 初始化成功。");
+    return true;
+}
+
+bool GameApp::initTime() {
+    try {
+        time_ = std::make_unique<Time>();
+    } catch (const std::exception& e) {
+        spdlog::error("初始化时间管理失败: {}", e.what());
+        return false;
+    }
+    spdlog::trace("时间管理初始化成功。");
+    return true;
+}
+
+bool GameApp::initResourceManager() {
+    try {
+        resource_manager_ = std::make_unique<engine::resource::ResourceManager>(sdl_renderer_);
+    } catch (const std::exception& e) {
+        spdlog::error("初始化资源管理器失败: {}", e.what());
+        return false;
+    }
+    spdlog::trace("资源管理器初始化成功。");
+    return true;
+}
+
+void GameApp::testResourceManager()
+{
+    resource_manager_->getTexture("assets/textures/Actors/eagle-attack.png");
+    resource_manager_->getFont("assets/fonts/VonwaonBitmap-16px.ttf", 16);
+    resource_manager_->getSound("assets/audio/button_click.wav");
+
+    resource_manager_->unloadTexture("assets/textures/Actors/eagle-attack.png");
+    resource_manager_->unloadFont("assets/fonts/VonwaonBitmap-16px.ttf", 16);
+    resource_manager_->unloadSound("assets/audio/button_click.wav");
+}
+
 } // namespace engine::core
\ No newline at end of file
diff --git a/src/engine/core/game_app.h b/src/engine/core/game_app.h
index 4e9f253..60ea3f4 100644
--- a/src/engine/core/game_app.h
+++ b/src/engine/core/game_app.h
@@ -5,6 +5,10 @@
 struct SDL_Window;
 struct SDL_Renderer;
 
+namespace engine::resource {
+class ResourceManager;
+}
+
 namespace engine::core {        // 命名空间的最佳实践：与文件路径一致
 class Time;
 
@@ -19,6 +23,7 @@ private:
 
     // 引擎组件
     std::unique_ptr<engine::core::Time> time_;
+    std::unique_ptr<engine::resource::ResourceManager> resource_manager_;
 
 public:
     GameApp();
@@ -41,6 +46,14 @@ private:
     void update(float delta_time);
     void render();
     void close();
+
+    // 各模块的初始化/创建函数，在init()中调用
+    bool initSDL();
+    bool initTime();
+    bool initResourceManager();
+
+    // 测试用函数
+    void testResourceManager();
 };
 
 } // namespace engine::core
diff --git a/src/engine/resource/audio_manager.cpp b/src/engine/resource/audio_manager.cpp
new file mode 100644
index 0000000..61248e1
--- /dev/null
+++ b/src/engine/resource/audio_manager.cpp
@@ -0,0 +1,143 @@
+#include "audio_manager.h"
+#include <spdlog/spdlog.h>
+#include <stdexcept>
+
+namespace engine::resource {
+
+// 构造函数：初始化SDL_mixer
+AudioManager::AudioManager() {
+    // 使用所需的格式初始化SDL_mixer（推荐OGG、MP3）
+    MIX_InitFlags flags = MIX_INIT_OGG | MIX_INIT_MP3;
+    if ((Mix_Init(flags) & flags) != flags) {
+        throw std::runtime_error("AudioManager 错误: Mix_Init 失败: " + std::string(SDL_GetError()));
+    }
+
+    // SDL3打开音频设备的方法。默认值：44100 Hz，默认格式，2声道（立体声），2048采样块大小
+    if (!Mix_OpenAudio(0, nullptr)) {
+        Mix_Quit(); // 如果OpenAudio失败，先清理Mix_Init，再抛出异常
+        throw std::runtime_error("AudioManager 错误: Mix_OpenAudio 失败: " + std::string(SDL_GetError()));
+    }
+    spdlog::trace("AudioManager 构造成功。");
+}
+
+AudioManager::~AudioManager()
+{
+    // 立即停止所有音频播放
+    Mix_HaltChannel(-1); // 停止所有音效
+    Mix_HaltMusic();     // 停止音乐
+
+    // 清理资源映射（unique_ptrs会调用删除器）
+    clearSounds();
+    clearMusic();
+
+    // 关闭音频设备
+    Mix_CloseAudio();
+
+    // 退出SDL_mixer子系统
+    Mix_Quit();
+    spdlog::trace("AudioManager 析构成功。");
+}
+
+// --- 音效管理 ---
+Mix_Chunk* AudioManager::loadSound(const std::string& file_path) {
+    // 首先检查缓存
+    auto it = sounds_.find(file_path);
+    if (it != sounds_.end()) {
+        return it->second.get();
+    }
+
+    // 加载音效块
+    spdlog::debug("加载音效: {}", file_path);
+    Mix_Chunk* raw_chunk = Mix_LoadWAV(file_path.c_str());
+    if (!raw_chunk) {
+        spdlog::error("加载音效失败: '{}': {}", file_path, SDL_GetError());
+        return nullptr;
+    }
+
+    // 使用unique_ptr存储在缓存中
+    sounds_.emplace(file_path, std::unique_ptr<Mix_Chunk, SDLMixChunkDeleter>(raw_chunk));
+    spdlog::debug("成功加载并缓存音效: {}", file_path);
+    return raw_chunk;
+}
+
+Mix_Chunk* AudioManager::getSound(const std::string& file_path) {
+    auto it = sounds_.find(file_path);
+    if (it != sounds_.end()) {
+        return it->second.get();
+    }
+    spdlog::warn("音效 '{}' 未找到缓存，尝试加载。", file_path);
+    return loadSound(file_path);
+}
+
+void AudioManager::unloadSound(const std::string& file_path) {
+    auto it = sounds_.find(file_path);
+    if (it != sounds_.end()) {
+        spdlog::debug("卸载音效: {}", file_path);
+        sounds_.erase(it);      // unique_ptr处理Mix_FreeChunk
+    } else {
+        spdlog::warn("尝试卸载不存在的音效: {}", file_path);
+    }
+}
+
+void AudioManager::clearSounds() {
+    if (!sounds_.empty()) {
+        spdlog::debug("正在清除所有 {} 个缓存的音效。", sounds_.size());
+        sounds_.clear(); // unique_ptr处理删除
+    }
+}
+
+// --- 音乐管理 ---
+Mix_Music* AudioManager::loadMusic(const std::string& file_path) {
+    // 首先检查缓存
+    auto it = music_.find(file_path);
+    if (it != music_.end()) {
+        return it->second.get();
+    }
+
+    // 加载音乐
+    spdlog::debug("加载音乐: {}", file_path);
+    Mix_Music* raw_music = Mix_LoadMUS(file_path.c_str());
+    if (!raw_music) {
+        spdlog::error("加载音乐失败: '{}': {}", file_path, SDL_GetError());
+        return nullptr;
+    }
+
+    // 使用unique_ptr存储在缓存中
+    music_.emplace(file_path, std::unique_ptr<Mix_Music, SDLMixMusicDeleter>(raw_music));
+    spdlog::debug("成功加载并缓存音乐: {}", file_path);
+    return raw_music;
+}
+
+Mix_Music* AudioManager::getMusic(const std::string& file_path) {
+    auto it = music_.find(file_path);
+    if (it != music_.end()) {
+        return it->second.get();
+    }
+    spdlog::warn("音乐 '{}' 未找到缓存，尝试加载。", file_path);
+    return loadMusic(file_path);
+}
+
+void AudioManager::unloadMusic(const std::string& file_path) {
+    auto it = music_.find(file_path);
+    if (it != music_.end()) {
+        spdlog::debug("卸载音乐: {}", file_path);
+        music_.erase(it); // unique_ptr处理Mix_FreeMusic
+    } else {
+        spdlog::warn("尝试卸载不存在的音乐: {}", file_path);
+    }
+}
+
+void AudioManager::clearMusic() {
+    if (!music_.empty()) {
+        spdlog::debug("正在清除所有 {} 个缓存的音乐曲目。", music_.size());
+        music_.clear(); // unique_ptr处理删除
+    }
+}
+
+void AudioManager::clearAudio()
+{
+    clearSounds();
+    clearMusic();
+}
+
+} // namespace engine::resource
diff --git a/src/engine/resource/audio_manager.h b/src/engine/resource/audio_manager.h
new file mode 100644
index 0000000..6596764
--- /dev/null
+++ b/src/engine/resource/audio_manager.h
@@ -0,0 +1,74 @@
+#pragma once
+#include <memory>       // 用于 std::unique_ptr
+#include <stdexcept>    // 用于 std::runtime_error
+#include <string>       // 用于 std::string
+#include <unordered_map> // 用于 std::unordered_map
+
+#include <SDL3_mixer/SDL_mixer.h> // SDL_mixer 主头文件
+
+namespace engine::resource {
+
+/**
+ * @brief 管理 SDL_mixer 音效 (Mix_Chunk) 和音乐 (Mix_Music)。
+ *
+ * 提供音频资源的加载和缓存功能。构造失败时会抛出异常。
+ * 仅供 ResourceManager 内部使用。
+ */
+class AudioManager final{
+    friend class ResourceManager;
+
+private:
+    // Mix_Chunk 的自定义删除器
+    struct SDLMixChunkDeleter {
+        void operator()(Mix_Chunk* chunk) const {
+            if (chunk) {
+                Mix_FreeChunk(chunk);
+            }
+        }
+    };
+
+    // Mix_Music 的自定义删除器
+    struct SDLMixMusicDeleter {
+        void operator()(Mix_Music* music) const {
+            if (music) {
+                Mix_FreeMusic(music);
+            }
+        }
+    };
+
+    // 音效存储 (文件路径 -> Mix_Chunk)
+    std::unordered_map<std::string, std::unique_ptr<Mix_Chunk, SDLMixChunkDeleter>> sounds_;
+    // 音乐存储 (文件路径 -> Mix_Music)
+    std::unordered_map<std::string, std::unique_ptr<Mix_Music, SDLMixMusicDeleter>> music_;
+
+public:
+    /**
+     * @brief 构造函数。初始化 SDL_mixer 并打开音频设备。
+     * @throws std::runtime_error 如果 SDL_mixer 初始化或打开音频设备失败。
+     */
+    AudioManager();
+
+    ~AudioManager();            ///< @brief 需要手动添加析构函数，清理资源并关闭 SDL_mixer。
+
+    // 当前设计中，我们只需要一个AudioManager，所有权不变，所以不需要拷贝、移动相关构造及赋值运算符
+    AudioManager(const AudioManager&) = delete;
+    AudioManager& operator=(const AudioManager&) = delete;
+    AudioManager(AudioManager&&) = delete;
+    AudioManager& operator=(AudioManager&&) = delete;
+
+private:  // 仅供 ResourceManager 访问的方法
+
+    Mix_Chunk* loadSound(const std::string& file_path);     ///< @brief 从文件路径加载音效
+    Mix_Chunk* getSound(const std::string& file_path);      ///< @brief 尝试获取已加载音效的指针，如果未加载则尝试加载
+    void unloadSound(const std::string& file_path);         ///< @brief 卸载指定的音效资源
+    void clearSounds();                                      ///< @brief 清空所有音效资源
+
+    Mix_Music* loadMusic(const std::string& file_path);     ///< @brief 从文件路径加载音乐
+    Mix_Music* getMusic(const std::string& file_path);      ///< @brief 尝试获取已加载音乐的指针，如果未加载则尝试加载
+    void unloadMusic(const std::string& file_path);         ///< @brief 卸载指定的音乐资源
+    void clearMusic();                                      ///< @brief 清空所有音乐资源
+
+    void clearAudio();                                      ///< @brief 清空所有音频资源
+};
+
+} // namespace engine::resource
diff --git a/src/engine/resource/font_manager.cpp b/src/engine/resource/font_manager.cpp
new file mode 100644
index 0000000..e871369
--- /dev/null
+++ b/src/engine/resource/font_manager.cpp
@@ -0,0 +1,82 @@
+#include "font_manager.h"
+#include <spdlog/spdlog.h>
+#include <stdexcept>
+
+namespace engine::resource {
+
+FontManager::FontManager() {
+    if (!TTF_WasInit() && !TTF_Init()) {
+        throw std::runtime_error("FontManager 错误: TTF_Init 失败：" + std::string(SDL_GetError()));
+    }
+    spdlog::trace("FontManager 构造成功。");
+}
+
+FontManager::~FontManager() {
+    if (!fonts_.empty()) {
+        spdlog::debug("FontManager 不为空，调用 clearFonts 处理清理逻辑。");
+        clearFonts();       // 调用 clearFonts 处理清理逻辑
+    }
+    TTF_Quit();
+    spdlog::trace("FontManager 析构成功。");
+}
+
+TTF_Font* FontManager::loadFont(const std::string& file_path, int point_size) {
+    // 检查点大小是否有效
+    if (point_size <= 0) {
+        spdlog::error("无法加载字体 '{}'：无效的点大小 {}。", file_path, point_size);
+        return nullptr;
+    }
+
+    // 创建映射表的键
+    FontKey key = {file_path, point_size};
+
+    // 首先检查缓存
+    auto it = fonts_.find(key);
+    if (it != fonts_.end()) {
+        return it->second.get();
+    }
+
+    // 缓存中不存在，则加载字体
+    spdlog::debug("正在加载字体：{} ({}pt)", file_path, point_size);
+    TTF_Font* raw_font = TTF_OpenFont(file_path.c_str(), point_size);
+    if (!raw_font) {
+        spdlog::error("加载字体 '{}' ({}pt) 失败：{}", file_path, point_size, SDL_GetError());
+        return nullptr;
+    }
+
+    // 使用 unique_ptr 存储到缓存中
+    fonts_.emplace(key, std::unique_ptr<TTF_Font, SDLFontDeleter>(raw_font));
+    spdlog::debug("成功加载并缓存字体：{} ({}pt)", file_path, point_size);
+    return raw_font;
+}
+
+TTF_Font* FontManager::getFont(const std::string& file_path, int point_size) {
+    FontKey key = {file_path, point_size};
+    auto it = fonts_.find(key);
+    if (it != fonts_.end()) {
+        return it->second.get();
+    }
+
+    spdlog::warn("字体 '{}' ({}pt) 不在缓存中，尝试加载。", file_path, point_size);
+    return loadFont(file_path, point_size);
+}
+
+void FontManager::unloadFont(const std::string& file_path, int point_size) {
+    FontKey key = {file_path, point_size};
+    auto it = fonts_.find(key);
+    if (it != fonts_.end()) {
+        spdlog::debug("卸载字体：{} ({}pt)", file_path, point_size);
+        fonts_.erase(it);       // unique_ptr 会处理 TTF_CloseFont
+    } else {
+        spdlog::warn("尝试卸载不存在的字体：{} ({}pt)", file_path, point_size);
+    }
+}
+
+void FontManager::clearFonts() {
+    if (!fonts_.empty()) {
+        spdlog::debug("正在清理所有 {} 个缓存的字体。", fonts_.size());
+        fonts_.clear();         // unique_ptr 会处理删除
+    }
+}
+
+} // namespace engine::resource
diff --git a/src/engine/resource/font_manager.h b/src/engine/resource/font_manager.h
new file mode 100644
index 0000000..7120ce7
--- /dev/null
+++ b/src/engine/resource/font_manager.h
@@ -0,0 +1,72 @@
+#pragma once
+#include <memory>       // 用于 std::unique_ptr
+#include <stdexcept>    // 用于 std::runtime_error
+#include <string>       // 用于 std::string
+#include <unordered_map> // 用于 std::unordered_map
+#include <utility>      // 用于 std::pair
+#include <functional>   // 用于 std::hash
+
+#include <SDL3_ttf/SDL_ttf.h> // SDL_ttf 主头文件
+
+namespace engine::resource {
+
+// 定义字体键类型（路径 + 大小）
+using FontKey = std::pair<std::string, int>;        // std::pair 是标准库中的一个类模板，用于将两个值组合成一个单元
+
+// FontKey 的自定义哈希函数（std::pair<std::string, int>），用于 std::unordered_map
+struct FontKeyHash {
+    std::size_t operator()(const FontKey& key) const {
+        std::hash<std::string> string_hasher;
+        std::hash<int> int_hasher;
+        return string_hasher(key.first) ^ int_hasher(key.second);       // 异或运算符 ^ 按位计算，每一位的两个值不同为1，相同为0，这是合并两个哈希值的简单方法
+    }
+};
+
+/**
+ * @brief 管理 SDL_ttf 字体资源（TTF_Font）。
+ *
+ * 提供字体的加载和缓存功能，通过文件路径和点大小来标识。
+ * 构造失败会抛出异常。仅供 ResourceManager 内部使用。
+ */
+class FontManager final{
+    friend class ResourceManager;
+
+private:
+    // TTF_Font 的自定义删除器
+    struct SDLFontDeleter {
+        void operator()(TTF_Font* font) const {
+            if (font) {
+                TTF_CloseFont(font);
+            }
+        }
+    };
+
+    // 字体存储（FontKey -> TTF_Font）。  
+    // unordered_map 的键需要能转换为哈希值，对于基础数据类型，系统会自动转换
+    // 但是对于对于自定义类型（系统无法自动转化），则需要提供自定义哈希函数（第三个模版参数）
+    std::unordered_map<FontKey, std::unique_ptr<TTF_Font, SDLFontDeleter>, FontKeyHash> fonts_;
+
+public:
+    /**
+     * @brief 构造函数。初始化 SDL_ttf。
+     * @throws std::runtime_error 如果 SDL_ttf 初始化失败。
+     */
+    FontManager();
+    
+    ~FontManager();            ///< @brief 需要手动添加析构函数，清理资源并关闭 SDL_ttf。
+
+    // 当前设计中，我们只需要一个FontManager，所有权不变，所以不需要拷贝、移动相关构造及赋值运算符
+    FontManager(const FontManager&) = delete;
+    FontManager& operator=(const FontManager&) = delete;
+    FontManager(FontManager&&) = delete;
+    FontManager& operator=(FontManager&&) = delete;
+
+private: // 仅由 ResourceManager（和内部）访问的方法
+
+    TTF_Font* loadFont(const std::string& file_path, int point_size);     ///< @brief 从文件路径加载指定点大小的字体
+    TTF_Font* getFont(const std::string& file_path, int point_size);      ///< @brief 尝试获取已加载字体的指针，如果未加载则尝试加载
+    void unloadFont(const std::string& file_path, int point_size);        ///< @brief 卸载特定字体（通过路径和大小标识）
+    void clearFonts();                                                    ///< @brief 清空所有缓存的字体
+};
+
+} // namespace engine::resource
diff --git a/src/engine/resource/resource_manager.cpp b/src/engine/resource/resource_manager.cpp
new file mode 100644
index 0000000..12658b5
--- /dev/null
+++ b/src/engine/resource/resource_manager.cpp
@@ -0,0 +1,103 @@
+#include "resource_manager.h"
+#include "texture_manager.h"
+#include "audio_manager.h"
+#include "font_manager.h" 
+#include <SDL3_mixer/SDL_mixer.h>
+#include <SDL3_ttf/SDL_ttf.h> 
+#include <glm/glm.hpp>
+#include <spdlog/spdlog.h>
+ 
+namespace engine::resource {
+
+ResourceManager::~ResourceManager() = default;
+
+ResourceManager::ResourceManager(SDL_Renderer* renderer) {
+    // --- 初始化各个子系统 --- (如果出现错误会抛出异常，由上层捕获)
+    texture_manager_ = std::make_unique<TextureManager>(renderer);
+    audio_manager_ = std::make_unique<AudioManager>();
+    font_manager_ = std::make_unique<FontManager>();
+
+    spdlog::trace("ResourceManager 构造成功。");
+    // RAII: 构造成功即代表资源管理器可以正常工作，无需再初始化，无需检查指针是否为空
+}
+
+void ResourceManager::clear() {
+    font_manager_->clearFonts();
+    audio_manager_->clearSounds();
+    texture_manager_->clearTextures();
+    spdlog::trace("ResourceManager 中的资源通过 clear() 清空。");
+}
+
+// --- 纹理接口实现 ---
+SDL_Texture* ResourceManager::loadTexture(const std::string& file_path) {
+    // 构造函数已经确保了 texture_manager_ 不为空，因此不需要再进行if检查，以免性能浪费
+    return texture_manager_->loadTexture(file_path);
+}
+
+SDL_Texture* ResourceManager::getTexture(const std::string& file_path) {
+    return texture_manager_->getTexture(file_path);
+}
+
+glm::vec2 ResourceManager::getTextureSize(const std::string& file_path) {
+    return texture_manager_->getTextureSize(file_path);
+}
+
+void ResourceManager::unloadTexture(const std::string& file_path) {
+    texture_manager_->unloadTexture(file_path);
+}
+
+void ResourceManager::clearTextures() {
+    texture_manager_->clearTextures();
+}
+
+// --- 音频接口实现 ---
+Mix_Chunk* ResourceManager::loadSound(const std::string& file_path) {
+    return audio_manager_->loadSound(file_path);
+}
+
+Mix_Chunk* ResourceManager::getSound(const std::string& file_path) {
+    return audio_manager_->getSound(file_path);
+}
+
+void ResourceManager::unloadSound(const std::string& file_path) {
+    audio_manager_->unloadSound(file_path);
+}
+
+void ResourceManager::clearSounds() {
+    audio_manager_->clearSounds();
+}
+
+Mix_Music* ResourceManager::loadMusic(const std::string& file_path) {
+    return audio_manager_->loadMusic(file_path);
+}
+
+Mix_Music* ResourceManager::getMusic(const std::string& file_path) {
+    return audio_manager_->getMusic(file_path);
+}
+
+void ResourceManager::unloadMusic(const std::string& file_path) {
+    audio_manager_->unloadMusic(file_path);
+}
+
+void ResourceManager::clearMusic() {
+    audio_manager_->clearMusic();
+}
+
+// --- 字体接口实现 ---
+TTF_Font* ResourceManager::loadFont(const std::string& file_path, int point_size) {
+    return font_manager_->loadFont(file_path, point_size);
+}
+
+TTF_Font* ResourceManager::getFont(const std::string& file_path, int point_size) {
+    return font_manager_->getFont(file_path, point_size);
+}
+
+void ResourceManager::unloadFont(const std::string& file_path, int point_size) {
+    font_manager_->unloadFont(file_path, point_size);
+}
+
+void ResourceManager::clearFonts() {
+    font_manager_->clearFonts();
+}
+
+} // namespace engine::resource
diff --git a/src/engine/resource/resource_manager.h b/src/engine/resource/resource_manager.h
new file mode 100644
index 0000000..44e470b
--- /dev/null
+++ b/src/engine/resource/resource_manager.h
@@ -0,0 +1,75 @@
+#pragma once
+#include <memory> // 用于 std::unique_ptr
+#include <string> // 用于 std::string
+#include <glm/glm.hpp>
+
+// 前向声明 SDL 类型
+struct SDL_Renderer;
+struct SDL_Texture;
+struct Mix_Chunk;
+struct Mix_Music;
+struct TTF_Font;
+
+namespace engine::resource {
+
+// 前向声明内部管理器
+class TextureManager;
+class AudioManager;
+class FontManager;
+
+/**
+ * @brief 作为访问各种资源管理器的中央控制点（外观模式 Facade）。
+ * 在构造时初始化其管理的子系统。构造失败会抛出异常。
+ */
+class ResourceManager final{
+private:
+    // 使用 unique_ptr 确保所有权和自动清理
+    std::unique_ptr<TextureManager> texture_manager_;
+    std::unique_ptr<AudioManager> audio_manager_;
+    std::unique_ptr<FontManager> font_manager_;
+
+public:
+    /**
+     * @brief 构造函数，执行初始化。
+     * @param renderer SDL_Renderer 的指针，传递给需要它的子管理器。不能为空。
+     */
+    explicit ResourceManager(SDL_Renderer* renderer);       // explicit 关键字用于防止隐式转换, 对于单一参数的构造函数，通常考虑添加
+
+    ~ResourceManager();  // 显式声明析构函数，这是为了能让智能指针正确管理仅有前向声明的类
+
+    void clear();        ///< @brief 清空所有资源
+
+    // 当前设计中，我们只需要一个ResourceManager，所有权不变，所以不需要拷贝、移动相关构造及赋值运算符
+    ResourceManager(const ResourceManager&) = delete;
+    ResourceManager& operator=(const ResourceManager&) = delete;
+    ResourceManager(ResourceManager&&) = delete;
+    ResourceManager& operator=(ResourceManager&&) = delete;
+
+    // --- 统一资源访问接口 ---
+    // -- Texture --
+    SDL_Texture* loadTexture(const std::string& file_path);     ///< @brief 载入纹理资源
+    SDL_Texture* getTexture(const std::string& file_path);      ///< @brief 尝试获取已加载纹理的指针，如果未加载则尝试加载
+    void unloadTexture(const std::string& file_path);          ///< @brief 卸载指定的纹理资源
+    glm::vec2 getTextureSize(const std::string& file_path);    ///< @brief 获取指定纹理的尺寸
+    void clearTextures();                                      ///< @brief 清空所有纹理资源
+
+    // -- Sound Effects (Chunks) --
+    Mix_Chunk* loadSound(const std::string& file_path);         ///< @brief 载入音效资源
+    Mix_Chunk* getSound(const std::string& file_path);          ///< @brief 尝试获取已加载音效的指针，如果未加载则尝试加载
+    void unloadSound(const std::string& file_path);             ///< @brief 卸载指定的音效资源
+    void clearSounds();                                         ///< @brief 清空所有音效资源
+
+    // -- Music --
+    Mix_Music* loadMusic(const std::string& file_path);         ///< @brief 载入音乐资源
+    Mix_Music* getMusic(const std::string& file_path);          ///< @brief 尝试获取已加载音乐的指针，如果未加载则尝试加载
+    void unloadMusic(const std::string& file_path);             ///< @brief 卸载指定的音乐资源
+    void clearMusic();                                          ///< @brief 清空所有音乐资源
+
+    // -- Fonts --
+    TTF_Font* loadFont(const std::string& file_path, int point_size);     ///< @brief 载入字体资源
+    TTF_Font* getFont(const std::string& file_path, int point_size);      ///< @brief 尝试获取已加载字体的指针，如果未加载则尝试加载
+    void unloadFont(const std::string& file_path, int point_size);        ///< @brief 卸载指定的字体资源
+    void clearFonts();                                                  ///< @brief 清空所有字体资源
+};
+
+} // namespace engine::resource
diff --git a/src/engine/resource/texture_manager.cpp b/src/engine/resource/texture_manager.cpp
new file mode 100644
index 0000000..0a6f4b5
--- /dev/null
+++ b/src/engine/resource/texture_manager.cpp
@@ -0,0 +1,84 @@
+#include "texture_manager.h"
+#include <SDL3_image/SDL_image.h> // 用于 IMG_LoadTexture, IMG_Init, IMG_Quit
+#include <spdlog/spdlog.h>
+#include <stdexcept>
+
+namespace engine::resource {
+TextureManager::TextureManager(SDL_Renderer* renderer) : renderer_(renderer) {
+    if (!renderer_) {
+        // 关键错误，无法继续，抛出异常 （它将由catch语句捕获（位于GameApp），并进行处理）
+        throw std::runtime_error("TextureManager 构造失败: 渲染器指针为空。");
+    }
+    // SDL3中不再需要手动调用IMG_Init/IMG_Quit
+    spdlog::trace("TextureManager 构造成功。");
+}
+
+SDL_Texture* TextureManager::loadTexture(const std::string& file_path) {
+    // 检查是否已加载
+    auto it = textures_.find(file_path);
+    if (it != textures_.end()) {
+        return it->second.get();
+    }
+
+    // 如果没加载则尝试加载纹理
+    SDL_Texture* raw_texture = IMG_LoadTexture(renderer_, file_path.c_str());
+
+    if (!raw_texture) {
+        spdlog::error("加载纹理失败: '{}': {}", file_path, SDL_GetError());
+        return nullptr;
+    }
+
+    // 使用带有自定义删除器的 unique_ptr 存储加载的纹理
+    textures_.emplace(file_path, std::unique_ptr<SDL_Texture, SDLTextureDeleter>(raw_texture));
+    spdlog::debug("成功加载并缓存纹理: {}", file_path);
+
+    return raw_texture;
+}
+
+SDL_Texture* TextureManager::getTexture(const std::string& file_path) {
+    // 查找现有纹理
+    auto it = textures_.find(file_path);
+    if (it != textures_.end()) {
+        return it->second.get();
+    }
+
+    // 如果未找到，尝试加载它
+    spdlog::warn("纹理 '{}' 未找到缓存，尝试加载。", file_path);
+    return loadTexture(file_path);
+}
+
+glm::vec2 TextureManager::getTextureSize(const std::string& file_path) {
+    // 获取纹理
+    SDL_Texture* texture = getTexture(file_path);
+    if (!texture) {
+        spdlog::error("无法获取纹理: {}", file_path);
+        return glm::vec2(0);
+    }
+
+    // 获取纹理尺寸
+    glm::vec2 size;
+    if (!SDL_GetTextureSize(texture, &size.x, &size.y)) {
+        spdlog::error("无法查询纹理尺寸: {}", file_path);
+        return glm::vec2(0);
+    }
+    return size;
+}
+
+void TextureManager::unloadTexture(const std::string& file_path) {
+    auto it = textures_.find(file_path);
+    if (it != textures_.end()) {
+        spdlog::debug("卸载纹理: {}", file_path);
+        textures_.erase(it); // unique_ptr 通过自定义删除器处理删除
+    } else {
+        spdlog::warn("尝试卸载不存在的纹理: {}", file_path);
+    }
+}
+
+void TextureManager::clearTextures() {
+    if (!textures_.empty()) {
+        spdlog::debug("正在清除所有 {} 个缓存的纹理。", textures_.size());
+        textures_.clear(); // unique_ptr 处理所有元素的删除
+    }
+}
+
+} // namespace engine::resource
diff --git a/src/engine/resource/texture_manager.h b/src/engine/resource/texture_manager.h
new file mode 100644
index 0000000..3b75c14
--- /dev/null
+++ b/src/engine/resource/texture_manager.h
@@ -0,0 +1,58 @@
+#pragma once
+#include <memory>       // 用于 std::unique_ptr
+#include <stdexcept>    // 用于 std::runtime_error
+#include <string>       // 用于 std::string
+#include <unordered_map> // 用于 std::unordered_map
+#include <SDL3/SDL_render.h> // 用于 SDL_Texture 和 SDL_Renderer
+#include <glm/glm.hpp>
+
+namespace engine::resource {
+
+/**
+ * @brief 管理 SDL_Texture 资源的加载、存储和检索。
+ *
+ * 在构造时初始化。使用文件路径作为键，确保纹理只加载一次并正确释放。
+ * 依赖于一个有效的 SDL_Renderer，构造失败会抛出异常。
+ */
+class TextureManager final{
+    friend class ResourceManager;
+
+private:
+    // SDL_Texture 的删除器函数对象，用于智能指针管理
+    struct SDLTextureDeleter {
+        void operator()(SDL_Texture* texture) const {
+            if (texture) {
+                SDL_DestroyTexture(texture);
+            }
+        }
+    };
+
+    // 存储文件路径和指向管理纹理的 unique_ptr 的映射。
+    std::unordered_map<std::string, std::unique_ptr<SDL_Texture, SDLTextureDeleter>> textures_;
+
+    SDL_Renderer* renderer_ = nullptr; // 指向主渲染器的非拥有指针
+
+public:
+    /**
+     * @brief 构造函数，执行初始化。
+     * @param renderer 指向有效的 SDL_Renderer 上下文的指针。不能为空。
+     * @throws std::runtime_error 如果 renderer 为 nullptr 或初始化失败。
+     */
+    explicit TextureManager(SDL_Renderer* renderer);
+
+    // 当前设计中，我们只需要一个TextureManager，所有权不变，所以不需要拷贝、移动相关构造及赋值运算符
+    TextureManager(const TextureManager&) = delete;
+    TextureManager& operator=(const TextureManager&) = delete;
+    TextureManager(TextureManager&&) = delete;
+    TextureManager& operator=(TextureManager&&) = delete;
+
+private: // 仅供 ResourceManager 访问的方法
+
+    SDL_Texture* loadTexture(const std::string& file_path);      ///< @brief 从文件路径加载纹理
+    SDL_Texture* getTexture(const std::string& file_path);       ///< @brief 尝试获取已加载纹理的指针，如果未加载则尝试加载
+    glm::vec2 getTextureSize(const std::string& file_path);      ///< @brief 获取指定纹理的尺寸
+    void unloadTexture(const std::string& file_path);            ///< @brief 卸载指定的纹理资源
+    void clearTextures();                                        ///< @brief 清空所有纹理资源
+};
+
+} // namespace engine::resource
diff --git a/src/main.cpp b/src/main.cpp
index 8aac225..ce76ce5 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,6 +1,9 @@
 #include "engine/core/game_app.h"
+#include <spdlog/spdlog.h>
 
 int main(int /* argc */, char* /* argv */[]) {
+    spdlog::set_level(spdlog::level::debug);
+
     engine::core::GameApp app;
     app.run();
     return 0;