diff --git a/include/app/application.h b/include/app/application.h
index b03e658..56c953e 100644
--- a/include/app/application.h
+++ b/include/app/application.h
@@ -2,7 +2,6 @@
 
 #include <core/types.h>
 #include <string>
-#include <renderer/renderer.h>
 #include <memory>
 #include <platform/window.h>
 
@@ -11,12 +10,9 @@ namespace extra2d {
 // 前向声明
 class Input;
 class AudioEngine;
-class SceneManager;
-class ResourceManager;
 class TimerManager;
 class EventQueue;
 class EventDispatcher;
-class Camera;
 
 // ============================================================================
 // Application 配置
@@ -32,12 +28,10 @@ struct AppConfig {
   bool resizable = true;
   bool vsync = true;
   int fpsLimit = 0;
-  BackendType Renderer = BackendType::OpenGL;
   int msaaSamples = 0;
   PlatformType platform = PlatformType::Auto;
-  // 窗口高级配置
-  bool enableCursors = true;   // 是否启用光标
-  bool enableDpiScale = false; // 是否启用DPI缩放
+  bool enableCursors = true;
+  bool enableDpiScale = false;
 };
 
 // ============================================================================
@@ -45,53 +39,32 @@ struct AppConfig {
 // ============================================================================
 class Application {
 public:
-  // Meyer's 单例
   static Application &instance();
 
-  // 禁止拷贝
   Application(const Application &) = delete;
   Application &operator=(const Application &) = delete;
 
-  // ------------------------------------------------------------------------
-  // 生命周期
-  // ------------------------------------------------------------------------
   bool init(const AppConfig &config);
   void shutdown();
   void run();
   void quit();
 
-  // ------------------------------------------------------------------------
-  // 状态控制
-  // ------------------------------------------------------------------------
   void pause();
   void resume();
   bool isPaused() const { return paused_; }
   bool isRunning() const { return running_; }
 
-  // ------------------------------------------------------------------------
-  // 子系统访问
-  // ------------------------------------------------------------------------
   Window &window() { return *window_; }
-  Renderer &renderer() { return *renderer_; }
   Input &input();
   AudioEngine &audio();
-  SceneManager &scenes();
-  ResourceManager &resources();
   TimerManager &timers();
   EventQueue &eventQueue();
   EventDispatcher &eventDispatcher();
-  Camera &camera();
-
-  // ------------------------------------------------------------------------
-  // 便捷方法
-  // ------------------------------------------------------------------------
-  void enterScene(IntrusivePtr<class Scene> scene);
 
   float deltaTime() const { return deltaTime_; }
   float totalTime() const { return totalTime_; }
   int fps() const { return currentFps_; }
 
-  // 获取配置
   const AppConfig &getConfig() const { return config_; }
 
 private:
@@ -100,28 +73,19 @@ private:
 
   void mainLoop();
   void update();
-  void render();
 
-  // 配置
   AppConfig config_;
 
-  // 子系统
   UniquePtr<Window> window_;
-  UniquePtr<Renderer> renderer_;
-  UniquePtr<SceneManager> sceneManager_;
-  UniquePtr<ResourceManager> resourceManager_;
   UniquePtr<TimerManager> timerManager_;
   UniquePtr<EventQueue> eventQueue_;
   UniquePtr<EventDispatcher> eventDispatcher_;
-  UniquePtr<Camera> camera_;
 
-  // 状态
   bool initialized_ = false;
   bool running_ = false;
   bool paused_ = false;
   bool shouldQuit_ = false;
 
-  // 时间
   float deltaTime_ = 0.0f;
   float totalTime_ = 0.0f;
   double lastFrameTime_ = 0.0;
diff --git a/include/audio/audio_engine.h b/include/audio/audio_engine.h
index 8da0ec4..2230c73 100644
--- a/include/audio/audio_engine.h
+++ b/include/audio/audio_engine.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include <core/intrusive_ptr.h>
-#include <memory>
 #include <string>
 #include <unordered_map>
 
@@ -11,37 +10,38 @@ class Sound;
 
 class AudioEngine {
 public:
-    static AudioEngine& getInstance();
+  static AudioEngine &getInstance();
 
-    AudioEngine(const AudioEngine&) = delete;
-    AudioEngine& operator=(const AudioEngine&) = delete;
-    AudioEngine(AudioEngine&&) = delete;
-    AudioEngine& operator=(AudioEngine&&) = delete;
+  AudioEngine(const AudioEngine &) = delete;
+  AudioEngine &operator=(const AudioEngine &) = delete;
+  AudioEngine(AudioEngine &&) = delete;
+  AudioEngine &operator=(AudioEngine &&) = delete;
 
-    bool initialize();
-    void shutdown();
+  bool initialize();
+  void shutdown();
 
-    IntrusivePtr<Sound> loadSound(const std::string& filePath);
-    IntrusivePtr<Sound> loadSound(const std::string& name, const std::string& filePath);
+  IntrusivePtr<Sound> loadSound(const std::string &filePath);
+  IntrusivePtr<Sound> loadSound(const std::string &name,
+                                const std::string &filePath);
 
-    IntrusivePtr<Sound> getSound(const std::string& name);
-    void unloadSound(const std::string& name);
-    void unloadAllSounds();
+  IntrusivePtr<Sound> getSound(const std::string &name);
+  void unloadSound(const std::string &name);
+  void unloadAllSounds();
 
-    void setMasterVolume(float volume);
-    float getMasterVolume() const;
+  void setMasterVolume(float volume);
+  float getMasterVolume() const;
 
-    void pauseAll();
-    void resumeAll();
-    void stopAll();
+  void pauseAll();
+  void resumeAll();
+  void stopAll();
 
 private:
-    AudioEngine() = default;
-    ~AudioEngine();
+  AudioEngine() = default;
+  ~AudioEngine();
 
-    std::unordered_map<std::string, IntrusivePtr<Sound>> sounds_;
-    float masterVolume_ = 1.0f;
-    bool initialized_ = false;
+  std::unordered_map<std::string, IntrusivePtr<Sound>> sounds_;
+  float masterVolume_ = 1.0f;
+  bool initialized_ = false;
 };
 
 } // namespace extra2d
diff --git a/include/extra2d.h b/include/extra2d.h
index c1eab85..cce5229 100644
--- a/include/extra2d.h
+++ b/include/extra2d.h
@@ -16,23 +16,6 @@
 #include <platform/input.h>
 #include <platform/window.h>
 
-// Graphics
-#include <graphics/font.h>
-#include <graphics/texture.h>
-#include <graphics/vram_manager.h>
-
-// Renderer
-#include <renderer/camera.h>
-#include <renderer/render_target.h>
-#include <renderer/renderer.h>
-
-// Scene
-#include <scene/node.h>
-#include <scene/scene.h>
-#include <scene/scene_manager.h>
-#include <scene/shape.h>
-#include <scene/sprite.h>
-
 // Event
 #include <event/event.h>
 #include <event/event_dispatcher.h>
@@ -43,9 +26,6 @@
 #include <audio/audio_engine.h>
 #include <audio/sound.h>
 
-// Resource
-#include <resource/resource_manager.h>
-
 // Utils
 #include <utils/data.h>
 #include <utils/logger.h>
@@ -57,4 +37,4 @@
 
 #ifdef __SWITCH__
 #include <switch.h>
-#endif
\ No newline at end of file
+#endif
diff --git a/include/graphics/alpha_mask.h b/include/graphics/alpha_mask.h
deleted file mode 100644
index 4f6f0c6..0000000
--- a/include/graphics/alpha_mask.h
+++ /dev/null
@@ -1,50 +0,0 @@
-#pragma once
-
-#include <core/rect.h>
-#include <core/types.h>
-#include <core/vec2.h>
-#include <vector>
-
-namespace extra2d {
-
-// ============================================================================
-// Alpha 遮罩 - 存储图片的非透明区域信息
-// ============================================================================
-class AlphaMask {
-public:
-  AlphaMask() = default;
-  AlphaMask(int width, int height);
-
-  /// 从像素数据创建遮罩
-  static AlphaMask createFromPixels(const uint8_t *pixels, int width,
-                                    int height, int channels);
-
-  /// 获取指定位置的透明度（0-255）
-  uint8_t getAlpha(int x, int y) const;
-
-  /// 检查指定位置是否不透明
-  bool isOpaque(int x, int y, uint8_t threshold = 128) const;
-
-  /// 检查指定位置是否在遮罩范围内
-  bool isValid(int x, int y) const;
-
-  /// 获取遮罩尺寸
-  int width() const { return width_; }
-  int height() const { return height_; }
-  Size size() const {
-    return Size(static_cast<float>(width_), static_cast<float>(height_));
-  }
-
-  /// 获取原始数据
-  const std::vector<uint8_t> &getData() const { return data_; }
-
-  /// 检查遮罩是否有效
-  bool isValid() const { return !data_.empty() && width_ > 0 && height_ > 0; }
-
-private:
-  int width_ = 0;
-  int height_ = 0;
-  std::vector<uint8_t> data_; // Alpha值数组
-};
-
-} // namespace extra2d
diff --git a/include/graphics/font.h b/include/graphics/font.h
deleted file mode 100644
index 0f4aa18..0000000
--- a/include/graphics/font.h
+++ /dev/null
@@ -1,51 +0,0 @@
-#pragma once
-
-#include <core/color.h>
-#include <core/rect.h>
-#include <core/ref_counted.h>
-#include <core/vec2.h>
-
-namespace extra2d {
-
-// ============================================================================
-// 字形信息
-// ============================================================================
-struct Glyph {
-  float u0, v0;   // 纹理坐标左下角
-  float u1, v1;   // 纹理坐标右上角
-  float width;    // 字形宽度（像素）
-  float height;   // 字形高度（像素）
-  float bearingX; // 水平偏移
-  float bearingY; // 垂直偏移
-  float advance;  // 前进距离
-};
-
-// ============================================================================
-// 字体图集接口
-// ============================================================================
-class FontAtlas : public RefCounted {
-public:
-  virtual ~FontAtlas() = default;
-
-  // 获取字形信息
-  virtual const Glyph *getGlyph(char32_t codepoint) const = 0;
-
-  // 获取纹理
-  virtual class Texture *getTexture() const = 0;
-
-  // 获取字体大小
-  virtual int getFontSize() const = 0;
-
-  virtual float getAscent() const = 0;
-  virtual float getDescent() const = 0;
-  virtual float getLineGap() const = 0;
-  virtual float getLineHeight() const = 0;
-
-  // 计算文字尺寸
-  virtual Vec2 measureText(const std::string &text) = 0;
-
-  // 是否支持 SDF 渲染
-  virtual bool isSDF() const = 0;
-};
-
-} // namespace extra2d
diff --git a/include/graphics/gpu_context.h b/include/graphics/gpu_context.h
deleted file mode 100644
index ecd9809..0000000
--- a/include/graphics/gpu_context.h
+++ /dev/null
@@ -1,36 +0,0 @@
-#pragma once
-
-#include <atomic>
-
-namespace extra2d {
-
-// ============================================================================
-// GPU 上下文状态管理器
-// 用于跟踪 OpenGL/Vulkan 等 GPU 上下文的生命周期状态
-// 确保在 GPU 资源析构时能安全地检查上下文是否有效
-// ============================================================================
-
-class GPUContext {
-public:
-    /// 获取单例实例
-    static GPUContext& getInstance();
-
-    /// 标记 GPU 上下文为有效（在初始化完成后调用）
-    void markValid();
-
-    /// 标记 GPU 上下文为无效（在销毁前调用）
-    void markInvalid();
-
-    /// 检查 GPU 上下文是否有效
-    bool isValid() const;
-
-private:
-    GPUContext() = default;
-    ~GPUContext() = default;
-    GPUContext(const GPUContext&) = delete;
-    GPUContext& operator=(const GPUContext&) = delete;
-
-    std::atomic<bool> valid_{false};
-};
-
-} // namespace extra2d
diff --git a/include/graphics/opengl/gl_font_atlas.h b/include/graphics/opengl/gl_font_atlas.h
deleted file mode 100644
index 1e2f881..0000000
--- a/include/graphics/opengl/gl_font_atlas.h
+++ /dev/null
@@ -1,68 +0,0 @@
-#pragma once
-
-#include <core/color.h>
-#include <core/rect.h>
-#include <core/types.h>
-#include <core/vec2.h>
-#include <graphics/font.h>
-#include <graphics/opengl/gl_texture.h>
-#include <graphics/texture.h>
-#include <memory>
-#include <stb/stb_rect_pack.h>
-#include <stb/stb_truetype.h>
-#include <unordered_map>
-#include <vector>
-
-namespace extra2d {
-
-// ============================================================================
-// OpenGL 字体图集实现 - 使用 stb_rect_pack 进行矩形打包
-// ============================================================================
-class GLFontAtlas : public FontAtlas {
-public:
-  GLFontAtlas(const std::string &filepath, int fontSize, bool useSDF = false);
-  ~GLFontAtlas();
-
-  // FontAtlas 接口实现
-  const Glyph *getGlyph(char32_t codepoint) const override;
-  Texture *getTexture() const override { return texture_.get(); }
-  int getFontSize() const override { return fontSize_; }
-  float getAscent() const override { return ascent_; }
-  float getDescent() const override { return descent_; }
-  float getLineGap() const override { return lineGap_; }
-  float getLineHeight() const override { return ascent_ - descent_ + lineGap_; }
-  Vec2 measureText(const std::string &text) override;
-  bool isSDF() const override { return useSDF_; }
-
-private:
-  // 图集配置 - 增大尺寸以支持更多字符
-  static constexpr int ATLAS_WIDTH = 1024;
-  static constexpr int ATLAS_HEIGHT = 1024;
-  static constexpr int PADDING = 2; // 字形之间的间距
-
-  int fontSize_;
-  bool useSDF_;
-  mutable std::unique_ptr<GLTexture> texture_;
-  mutable std::unordered_map<char32_t, Glyph> glyphs_;
-
-  // stb_rect_pack 上下文
-  mutable stbrp_context packContext_;
-  mutable std::vector<stbrp_node> packNodes_;
-  mutable int currentY_;
-
-  std::vector<unsigned char> fontData_;
-  stbtt_fontinfo fontInfo_;
-  float scale_;
-  float ascent_;
-  float descent_;
-  float lineGap_;
-  
-  // 预分配字形位图缓冲区，避免每次动态分配
-  mutable std::vector<uint8_t> glyphBitmapCache_;
-  mutable std::vector<uint8_t> glyphRgbaCache_;
-
-  void createAtlas();
-  void cacheGlyph(char32_t codepoint) const;
-};
-
-} // namespace extra2d
diff --git a/include/graphics/opengl/gl_renderer.h b/include/graphics/opengl/gl_renderer.h
deleted file mode 100644
index c0826b5..0000000
--- a/include/graphics/opengl/gl_renderer.h
+++ /dev/null
@@ -1,131 +0,0 @@
-#pragma once
-
-#include <graphics/opengl/gl_shader.h>
-#include <graphics/opengl/gl_sprite_batch.h>
-#include <renderer/renderer.h>
-
-#include <array>
-#include <glad/glad.h>
-#include <vector>
-
-namespace extra2d {
-
-class Window;
-
-// ============================================================================
-// OpenGL 渲染器实现
-// ============================================================================
-class GLRenderer : public Renderer {
-public:
-  GLRenderer();
-  ~GLRenderer() override;
-
-  // Renderer 接口实现
-  bool init(Window *window) override;
-  void shutdown() override;
-
-  void beginFrame(const Color &clearColor) override;
-  void endFrame() override;
-  void setViewport(int x, int y, int width, int height) override;
-  void setVSync(bool enabled) override;
-
-  void setBlendMode(BlendMode mode) override;
-  void setViewProjection(const glm::mat4 &matrix) override;
-
-  // 变换矩阵栈
-  void pushTransform(const glm::mat4 &transform) override;
-  void popTransform() override;
-  glm::mat4 getCurrentTransform() const override;
-
-  IntrusivePtr<Texture> createTexture(int width, int height, const uint8_t *pixels,
-                             int channels) override;
-  IntrusivePtr<Texture> loadTexture(const std::string &filepath) override;
-
-  void beginSpriteBatch() override;
-  void drawSprite(const Texture &texture, const Rect &destRect,
-                  const Rect &srcRect, const Color &tint, float rotation,
-                  const Vec2 &anchor) override;
-  void drawSprite(const Texture &texture, const Vec2 &position,
-                  const Color &tint) override;
-  void endSpriteBatch() override;
-
-  void drawLine(const Vec2 &start, const Vec2 &end, const Color &color,
-                float width) override;
-  void drawRect(const Rect &rect, const Color &color, float width) override;
-  void fillRect(const Rect &rect, const Color &color) override;
-  void drawCircle(const Vec2 &center, float radius, const Color &color,
-                  int segments, float width) override;
-  void fillCircle(const Vec2 &center, float radius, const Color &color,
-                  int segments) override;
-  void drawTriangle(const Vec2 &p1, const Vec2 &p2, const Vec2 &p3,
-                    const Color &color, float width) override;
-  void fillTriangle(const Vec2 &p1, const Vec2 &p2, const Vec2 &p3,
-                    const Color &color) override;
-  void drawPolygon(const std::vector<Vec2> &points, const Color &color,
-                   float width) override;
-  void fillPolygon(const std::vector<Vec2> &points,
-                   const Color &color) override;
-
-  IntrusivePtr<FontAtlas> createFontAtlas(const std::string &filepath, int fontSize,
-                                 bool useSDF = false) override;
-  void drawText(const FontAtlas &font, const std::string &text,
-                const Vec2 &position, const Color &color) override;
-  void drawText(const FontAtlas &font, const std::string &text, float x,
-                float y, const Color &color) override;
-
-  Stats getStats() const override { return stats_; }
-  void resetStats() override;
-
-private:
-  // 形状批处理常量
-  static constexpr size_t MAX_CIRCLE_SEGMENTS = 128;
-  static constexpr size_t MAX_SHAPE_VERTICES = 8192; // 最大形状顶点数
-  static constexpr size_t MAX_LINE_VERTICES = 16384; // 最大线条顶点数
-
-  // 形状顶点结构（包含颜色）
-  struct ShapeVertex {
-    float x, y;
-    float r, g, b, a;
-  };
-
-  Window *window_;
-  GLSpriteBatch spriteBatch_;
-  GLShader shapeShader_;
-
-  GLuint shapeVao_;
-  GLuint shapeVbo_;
-  GLuint lineVao_; // 线条专用 VAO
-  GLuint lineVbo_; // 线条专用 VBO
-
-  glm::mat4 viewProjection_;
-  std::vector<glm::mat4> transformStack_;
-  Stats stats_;
-  bool vsync_;
-
-  // 形状批处理缓冲区（预分配，避免每帧内存分配）
-  std::array<ShapeVertex, MAX_SHAPE_VERTICES> shapeVertexCache_;
-  size_t shapeVertexCount_ = 0;
-  GLenum currentShapeMode_ = GL_TRIANGLES;
-
-  // 线条批处理缓冲区
-  std::array<ShapeVertex, MAX_LINE_VERTICES> lineVertexCache_;
-  size_t lineVertexCount_ = 0;
-  float currentLineWidth_ = 1.0f;
-
-  // OpenGL 状态缓存
-  BlendMode cachedBlendMode_ = BlendMode::None;
-  bool blendEnabled_ = false;
-  int cachedViewportX_ = 0;
-  int cachedViewportY_ = 0;
-  int cachedViewportWidth_ = 0;
-  int cachedViewportHeight_ = 0;
-
-  void initShapeRendering();
-  void flushShapeBatch();
-  void flushLineBatch();
-  void addShapeVertex(float x, float y, const Color &color);
-  void addLineVertex(float x, float y, const Color &color);
-  void submitShapeBatch(GLenum mode);
-};
-
-} // namespace extra2d
diff --git a/include/graphics/opengl/gl_shader.h b/include/graphics/opengl/gl_shader.h
deleted file mode 100644
index 2f63818..0000000
--- a/include/graphics/opengl/gl_shader.h
+++ /dev/null
@@ -1,55 +0,0 @@
-#pragma once
-
-#include <glad/glad.h>
-
-#include <string>
-#include <unordered_map>
-#include <glm/mat4x4.hpp>
-#include <glm/vec2.hpp>
-#include <glm/vec3.hpp>
-#include <glm/vec4.hpp>
-
-namespace extra2d {
-
-// ============================================================================
-// OpenGL Shader 程序
-// ============================================================================
-class GLShader {
-public:
-    GLShader();
-    ~GLShader();
-
-    // 从源码编译
-    bool compileFromSource(const char* vertexSource, const char* fragmentSource);
-    
-    // 从文件加载并编译
-    bool compileFromFile(const std::string& vertexPath, const std::string& fragmentPath);
-
-    // 使用/激活
-    void bind() const;
-    void unbind() const;
-
-    // Uniform 设置
-    void setBool(const std::string& name, bool value);
-    void setInt(const std::string& name, int value);
-    void setFloat(const std::string& name, float value);
-    void setVec2(const std::string& name, const glm::vec2& value);
-    void setVec3(const std::string& name, const glm::vec3& value);
-    void setVec4(const std::string& name, const glm::vec4& value);
-    void setMat4(const std::string& name, const glm::mat4& value);
-
-    // 获取程序 ID
-    GLuint getProgramID() const { return programID_; }
-
-    // 检查是否有效
-    bool isValid() const { return programID_ != 0; }
-
-private:
-    GLuint programID_;
-    std::unordered_map<std::string, GLint> uniformCache_;
-
-    GLuint compileShader(GLenum type, const char* source);
-    GLint getUniformLocation(const std::string& name);
-};
-
-} // namespace extra2d
diff --git a/include/graphics/opengl/gl_sprite_batch.h b/include/graphics/opengl/gl_sprite_batch.h
deleted file mode 100644
index e63d080..0000000
--- a/include/graphics/opengl/gl_sprite_batch.h
+++ /dev/null
@@ -1,97 +0,0 @@
-#pragma once
-
-#include <core/color.h>
-#include <core/types.h>
-#include <core/vec2.h>
-#include <graphics/opengl/gl_shader.h>
-#include <graphics/texture.h>
-#include <glm/mat4x4.hpp>
-#include <vector>
-#include <array>
-
-#include <glad/glad.h>
-
-namespace extra2d {
-
-// ============================================================================
-// OpenGL 精灵批渲染器 - 优化版本
-// ============================================================================
-class GLSpriteBatch {
-public:
-  static constexpr size_t MAX_SPRITES = 10000;
-  static constexpr size_t VERTICES_PER_SPRITE = 4;
-  static constexpr size_t INDICES_PER_SPRITE = 6;
-  static constexpr size_t MAX_VERTICES = MAX_SPRITES * VERTICES_PER_SPRITE;
-  static constexpr size_t MAX_INDICES = MAX_SPRITES * INDICES_PER_SPRITE;
-
-  struct Vertex {
-    glm::vec2 position;
-    glm::vec2 texCoord;
-    glm::vec4 color;
-  };
-
-  struct SpriteData {
-    glm::vec2 position;
-    glm::vec2 size;
-    glm::vec2 texCoordMin;
-    glm::vec2 texCoordMax;
-    glm::vec4 color;
-    float rotation;
-    glm::vec2 anchor;
-    bool isSDF = false;
-  };
-
-  GLSpriteBatch();
-  ~GLSpriteBatch();
-
-  bool init();
-  void shutdown();
-
-  void begin(const glm::mat4 &viewProjection);
-  void draw(const Texture &texture, const SpriteData &data);
-  void end();
-
-  // 批量绘制接口 - 用于自动批处理
-  void drawBatch(const Texture& texture, const std::vector<SpriteData>& sprites);
-  
-  // 立即绘制（不缓存）
-  void drawImmediate(const Texture& texture, const SpriteData& data);
-
-  // 统计
-  uint32_t getDrawCallCount() const { return drawCallCount_; }
-  uint32_t getSpriteCount() const { return spriteCount_; }
-  uint32_t getBatchCount() const { return batchCount_; }
-
-  // 检查是否需要刷新
-  bool needsFlush(const Texture& texture, bool isSDF) const;
-
-private:
-  GLuint vao_;
-  GLuint vbo_;
-  GLuint ibo_;
-  GLShader shader_;
-
-  // 使用固定大小数组减少内存分配
-  std::array<Vertex, MAX_VERTICES> vertexBuffer_;
-  size_t vertexCount_;
-
-  const Texture *currentTexture_;
-  bool currentIsSDF_;
-  glm::mat4 viewProjection_;
-  
-  // 缓存上一帧的 viewProjection，避免重复设置
-  glm::mat4 cachedViewProjection_;
-  bool viewProjectionDirty_ = true;
-
-  uint32_t drawCallCount_;
-  uint32_t spriteCount_;
-  uint32_t batchCount_;
-
-  void flush();
-  void setupShader();
-  
-  // 添加顶点到缓冲区
-  void addVertices(const SpriteData& data);
-};
-
-} // namespace extra2d
diff --git a/include/graphics/opengl/gl_texture.h b/include/graphics/opengl/gl_texture.h
deleted file mode 100644
index 117f183..0000000
--- a/include/graphics/opengl/gl_texture.h
+++ /dev/null
@@ -1,78 +0,0 @@
-#pragma once
-
-#include <graphics/alpha_mask.h>
-#include <graphics/texture.h>
-
-#include <glad/glad.h>
-
-#include <memory>
-#include <string>
-
-namespace extra2d {
-
-// ============================================================================
-// OpenGL 纹理实现
-// ============================================================================
-class GLTexture : public Texture {
-public:
-  GLTexture(int width, int height, const uint8_t *pixels, int channels);
-  GLTexture(const std::string &filepath);
-  ~GLTexture();
-
-  // Texture 接口实现
-  int width() const override { return width_; }
-  int height() const override { return height_; }
-  Size size() const override {
-    return Size(static_cast<float>(width_), static_cast<float>(height_));
-  }
-  int getChannels() const override { return channels_; }
-  PixelFormat getFormat() const override;
-  void *getNativeHandle() const override {
-    return reinterpret_cast<void *>(static_cast<uintptr_t>(textureID_));
-  }
-  bool isValid() const override { return textureID_ != 0; }
-  void setFilter(bool linear) override;
-  void setWrap(bool repeat) override;
-
-  // 从参数创建纹理的工厂方法
-  static IntrusivePtr<Texture> create(int width, int height, PixelFormat format);
-
-  // 加载压缩纹理（KTX/DDS 格式）
-  bool loadCompressed(const std::string &filepath);
-
-  // OpenGL 特定
-  GLuint getTextureID() const { return textureID_; }
-  void bind(unsigned int slot = 0) const;
-  void unbind() const;
-
-  // 获取纹理数据大小（字节），用于 VRAM 跟踪
-  size_t getDataSize() const { return dataSize_; }
-
-  // Alpha 遮罩
-  bool hasAlphaMask() const {
-    return alphaMask_ != nullptr && alphaMask_->isValid();
-  }
-  const AlphaMask *getAlphaMask() const { return alphaMask_.get(); }
-  void generateAlphaMask(); // 从当前纹理数据生成遮罩
-
-private:
-  GLuint textureID_;
-  int width_;
-  int height_;
-  int channels_;
-  PixelFormat format_;
-  size_t dataSize_;
-
-  // 原始像素数据（用于生成遮罩）
-  std::vector<uint8_t> pixelData_;
-  std::unique_ptr<AlphaMask> alphaMask_;
-
-  void createTexture(const uint8_t *pixels);
-
-  // KTX 文件加载
-  bool loadKTX(const std::string &filepath);
-  // DDS 文件加载
-  bool loadDDS(const std::string &filepath);
-};
-
-} // namespace extra2d
diff --git a/include/graphics/texture.h b/include/graphics/texture.h
deleted file mode 100644
index a2233ca..0000000
--- a/include/graphics/texture.h
+++ /dev/null
@@ -1,64 +0,0 @@
-#pragma once
-
-#include <core/ref_counted.h>
-#include <core/size.h>
-
-namespace extra2d {
-
-// ============================================================================
-// 像素格式枚举
-// ============================================================================
-enum class PixelFormat {
-  R8,              // 单通道灰度
-  RG8,             // 双通道
-  RGB8,            // RGB 24位
-  RGBA8,           // RGBA 32位（默认）
-  RGB16F,          // RGB 半精度浮点
-  RGBA16F,         // RGBA 半精度浮点
-  RGB32F,          // RGB 全精度浮点
-  RGBA32F,         // RGBA 全精度浮点
-  Depth16,         // 16位深度
-  Depth24,         // 24位深度
-  Depth32F,        // 32位浮点深度
-  Depth24Stencil8, // 24位深度 + 8位模板
-
-  // 压缩纹理格式
-  ETC2_RGB8,  // ETC2 RGB 压缩
-  ETC2_RGBA8, // ETC2 RGBA 压缩
-  ASTC_4x4,   // ASTC 4x4 压缩
-  ASTC_6x6,   // ASTC 6x6 压缩
-  ASTC_8x8    // ASTC 8x8 压缩
-};
-
-// ============================================================================
-// 纹理接口
-// ============================================================================
-class Texture : public RefCounted {
-public:
-  virtual ~Texture() = default;
-
-  // 获取尺寸
-  virtual int width() const = 0;
-  virtual int height() const = 0;
-  virtual Size size() const = 0;
-
-  // 获取通道数
-  virtual int getChannels() const = 0;
-
-  // 获取像素格式
-  virtual PixelFormat getFormat() const = 0;
-
-  // 获取原始句柄（用于底层渲染）
-  virtual void *getNativeHandle() const = 0;
-
-  // 是否有效
-  virtual bool isValid() const = 0;
-
-  // 设置过滤模式
-  virtual void setFilter(bool linear) = 0;
-
-  // 设置环绕模式
-  virtual void setWrap(bool repeat) = 0;
-};
-
-} // namespace extra2d
diff --git a/include/graphics/vram_manager.h b/include/graphics/vram_manager.h
deleted file mode 100644
index 1375413..0000000
--- a/include/graphics/vram_manager.h
+++ /dev/null
@@ -1,62 +0,0 @@
-#pragma once
-
-#include <cstddef>
-#include <cstdint>
-#include <mutex>
-
-namespace extra2d {
-
-// ============================================================================
-// VRAM 管理器 - 跟踪显存使用情况
-// ============================================================================
-class VRAMManager {
-public:
-    static VRAMManager& getInstance();
-
-    // 纹理显存跟踪
-    void allocTexture(size_t size);
-    void freeTexture(size_t size);
-
-    // VBO/FBO 显存跟踪
-    void allocBuffer(size_t size);
-    void freeBuffer(size_t size);
-
-    // 查询显存使用情况
-    size_t getUsedVRAM() const;
-    size_t getTextureVRAM() const;
-    size_t getBufferVRAM() const;
-    size_t getAvailableVRAM() const;
-
-    // 显存预算管理
-    void setVRAMBudget(size_t budget);
-    size_t getVRAMBudget() const;
-    bool isOverBudget() const;
-
-    // 统计信息
-    void printStats() const;
-
-    // 重置计数器
-    void reset();
-
-private:
-    VRAMManager();
-    ~VRAMManager() = default;
-    VRAMManager(const VRAMManager&) = delete;
-    VRAMManager& operator=(const VRAMManager&) = delete;
-
-    mutable std::mutex mutex_;
-
-    size_t textureVRAM_;
-    size_t bufferVRAM_;
-    size_t vramBudget_;
-
-    // 统计
-    uint32_t textureAllocCount_;
-    uint32_t textureFreeCount_;
-    uint32_t bufferAllocCount_;
-    uint32_t bufferFreeCount_;
-    size_t peakTextureVRAM_;
-    size_t peakBufferVRAM_;
-};
-
-} // namespace extra2d
diff --git a/include/renderer/camera.h b/include/renderer/camera.h
deleted file mode 100644
index 6ed242b..0000000
--- a/include/renderer/camera.h
+++ /dev/null
@@ -1,95 +0,0 @@
-#pragma once
-
-#include <core/color.h>
-#include <core/rect.h>
-#include <core/ref_counted.h>
-#include <core/size.h>
-#include <core/vec2.h>
-#include <glm/mat4x4.hpp>
-
-namespace extra2d {
-
-// ============================================================================
-// 2D 正交相机
-// ============================================================================
-class Camera : public RefCounted {
-public:
-  Camera();
-  Camera(float left, float right, float bottom, float top);
-  Camera(const Size &viewport);
-  ~Camera() = default;
-
-  // ------------------------------------------------------------------------
-  // 位置和变换
-  // ------------------------------------------------------------------------
-  void setPosition(const Vec2 &position);
-  void setPosition(float x, float y);
-  Vec2 pos() const { return position_; }
-
-  void setRotation(float degrees);
-  float rot() const { return rotation_; }
-
-  void setZoom(float zoom);
-  float getZoom() const { return zoom_; }
-
-  // ------------------------------------------------------------------------
-  // 视口设置
-  // ------------------------------------------------------------------------
-  void setViewport(float left, float right, float bottom, float top);
-  void setViewport(const Rect &rect);
-  Rect getViewport() const;
-
-  // ------------------------------------------------------------------------
-  // 矩阵获取
-  // ------------------------------------------------------------------------
-  glm::mat4 getViewMatrix() const;
-  glm::mat4 getProjectionMatrix() const;
-  glm::mat4 getViewProjectionMatrix() const;
-
-  // ------------------------------------------------------------------------
-  // 坐标转换
-  // ------------------------------------------------------------------------
-  Vec2 screenToWorld(const Vec2 &screenPos) const;
-  Vec2 worldToScreen(const Vec2 &worldPos) const;
-  Vec2 screenToWorld(float x, float y) const;
-  Vec2 worldToScreen(float x, float y) const;
-
-  // ------------------------------------------------------------------------
-  // 移动相机
-  // ------------------------------------------------------------------------
-  void move(const Vec2 &offset);
-  void move(float x, float y);
-
-  // ------------------------------------------------------------------------
-  // 边界限制
-  // ------------------------------------------------------------------------
-  void setBounds(const Rect &bounds);
-  void clearBounds();
-  void clampToBounds();
-
-  // ------------------------------------------------------------------------
-  // 快捷方法：看向某点
-  // ------------------------------------------------------------------------
-  void lookAt(const Vec2 &target);
-
-private:
-  Vec2 position_ = Vec2::Zero();
-  float rotation_ = 0.0f;
-  float zoom_ = 1.0f;
-
-  float left_ = -1.0f;
-  float right_ = 1.0f;
-  float bottom_ = -1.0f;
-  float top_ = 1.0f;
-
-  Rect bounds_;
-  bool hasBounds_ = false;
-
-  mutable glm::mat4 viewMatrix_;
-  mutable glm::mat4 projMatrix_;
-  mutable glm::mat4 vpMatrix_;
-  mutable bool viewDirty_ = true;
-  mutable bool projDirty_ = true;
-};
-
-} // namespace extra2d
diff --git a/include/renderer/render_command.h b/include/renderer/render_command.h
deleted file mode 100644
index 38aed2a..0000000
--- a/include/renderer/render_command.h
+++ /dev/null
@@ -1,226 +0,0 @@
-#pragma once
-
-#include <core/color.h>
-#include <core/rect.h>
-#include <core/types.h>
-#include <core/vec2.h>
-#include <cstdint>
-#include <glm/mat4x4.hpp>
-#include <graphics/texture.h>
-#include <string>
-#include <variant>
-
-
-namespace extra2d {
-
-// 前向声明
-class Texture;
-class FontAtlas;
-
-/**
- * @brief 渲染命令类型枚举
- */
-enum class RenderCommandType : uint8_t {
-  None = 0,
-  Sprite,         // 精灵绘制
-  Line,           // 线条绘制
-  Rect,           // 矩形绘制
-  FilledRect,     // 填充矩形
-  Circle,         // 圆形绘制
-  FilledCircle,   // 填充圆形
-  Triangle,       // 三角形绘制
-  FilledTriangle, // 填充三角形
-  Polygon,        // 多边形绘制
-  FilledPolygon,  // 填充多边形
-  Text,           // 文本绘制
-  Custom          // 自定义绘制
-};
-
-/**
- * @brief 精灵渲染命令数据
- */
-struct SpriteCommandData {
-  const Texture *texture;
-  Rect destRect;
-  Rect srcRect;
-  Color tint;
-  float rotation;
-  Vec2 anchor;
-  uint32_t sortKey; // 用于自动排序的键值
-
-  SpriteCommandData()
-      : texture(nullptr), destRect(), srcRect(), tint(Colors::White),
-        rotation(0.0f), anchor(0.0f, 0.0f), sortKey(0) {}
-  SpriteCommandData(const Texture *tex, const Rect &dest, const Rect &src,
-                    const Color &t, float rot, const Vec2 &anc, uint32_t key)
-      : texture(tex), destRect(dest), srcRect(src), tint(t), rotation(rot),
-        anchor(anc), sortKey(key) {}
-};
-
-/**
- * @brief 线条渲染命令数据
- */
-struct LineCommandData {
-  Vec2 start;
-  Vec2 end;
-  Color color;
-  float width;
-
-  LineCommandData() : start(), end(), color(Colors::White), width(1.0f) {}
-  LineCommandData(const Vec2 &s, const Vec2 &e, const Color &c, float w)
-      : start(s), end(e), color(c), width(w) {}
-};
-
-/**
- * @brief 矩形渲染命令数据
- */
-struct RectCommandData {
-  Rect rect;
-  Color color;
-  float width;
-  bool filled;
-
-  RectCommandData()
-      : rect(), color(Colors::White), width(1.0f), filled(false) {}
-  RectCommandData(const Rect &r, const Color &c, float w, bool f)
-      : rect(r), color(c), width(w), filled(f) {}
-};
-
-/**
- * @brief 圆形渲染命令数据
- */
-struct CircleCommandData {
-  Vec2 center;
-  float radius;
-  Color color;
-  int segments;
-  float width;
-  bool filled;
-
-  CircleCommandData()
-      : center(), radius(0.0f), color(Colors::White), segments(32), width(1.0f),
-        filled(false) {}
-  CircleCommandData(const Vec2 &c, float r, const Color &col, int seg, float w,
-                    bool f)
-      : center(c), radius(r), color(col), segments(seg), width(w), filled(f) {}
-};
-
-/**
- * @brief 三角形渲染命令数据
- */
-struct TriangleCommandData {
-  Vec2 p1, p2, p3;
-  Color color;
-  float width;
-  bool filled;
-
-  TriangleCommandData()
-      : p1(), p2(), p3(), color(Colors::White), width(1.0f), filled(false) {}
-  TriangleCommandData(const Vec2 &a, const Vec2 &b, const Vec2 &c,
-                      const Color &col, float w, bool f)
-      : p1(a), p2(b), p3(c), color(col), width(w), filled(f) {}
-};
-
-/**
- * @brief 多边形渲染命令数据
- */
-struct PolygonCommandData {
-  std::vector<Vec2> points;
-  Color color;
-  float width;
-  bool filled;
-
-  PolygonCommandData() : color(Colors::White), width(1.0f), filled(false) {}
-  PolygonCommandData(std::vector<Vec2> pts, const Color &col, float w, bool f)
-      : points(std::move(pts)), color(col), width(w), filled(f) {}
-};
-
-/**
- * @brief 文本渲染命令数据
- */
-struct TextCommandData {
-  const FontAtlas *font;
-  std::string text;
-  Vec2 position;
-  Color color;
-
-  TextCommandData() : font(nullptr), text(), position(), color(Colors::White) {}
-};
-
-/**
- * @brief 统一渲染命令结构
- * 使用 variant 存储不同类型的命令数据，减少内存分配
- */
-struct RenderCommand {
-  RenderCommandType type;
-  uint32_t layer;      // 渲染层级，用于排序
-  uint32_t order;      // 提交顺序，保证同层级内稳定排序
-  glm::mat4 transform; // 变换矩阵
-
-  // 使用 variant 存储具体数据
-  std::variant<SpriteCommandData, LineCommandData, RectCommandData,
-               CircleCommandData, TriangleCommandData, PolygonCommandData,
-               TextCommandData>
-      data;
-
-  RenderCommand()
-      : type(RenderCommandType::None), layer(0), order(0), transform(1.0f) {}
-
-  // 便捷构造函数
-  static RenderCommand makeSprite(const Texture *tex, const Rect &dest,
-                                  const Rect &src, const Color &tint,
-                                  float rot = 0.0f,
-                                  const Vec2 &anc = Vec2(0, 0),
-                                  uint32_t lyr = 0);
-  static RenderCommand makeLine(const Vec2 &s, const Vec2 &e, const Color &c,
-                                float w = 1.0f, uint32_t lyr = 0);
-  static RenderCommand makeRect(const Rect &r, const Color &c, float w = 1.0f,
-                                bool fill = false, uint32_t lyr = 0);
-};
-
-/**
- * @brief 渲染命令缓冲区
- * 用于收集和批量处理渲染命令
- */
-class RenderCommandBuffer {
-public:
-  static constexpr size_t INITIAL_CAPACITY = 1024;
-  static constexpr size_t MAX_CAPACITY = 65536;
-
-  RenderCommandBuffer();
-  ~RenderCommandBuffer();
-
-  // 添加渲染命令
-  void addCommand(const RenderCommand &cmd);
-  void addCommand(RenderCommand &&cmd);
-
-  // 批量添加（预留空间后使用）
-  RenderCommand &emplaceCommand();
-
-  // 排序命令（按纹理、层级等）
-  void sortCommands();
-
-  // 清空缓冲区
-  void clear();
-
-  // 获取命令列表
-  const std::vector<RenderCommand> &getCommands() const { return commands_; }
-  std::vector<RenderCommand> &getCommands() { return commands_; }
-
-  // 统计
-  size_t size() const { return commands_.size(); }
-  bool empty() const { return commands_.empty(); }
-  size_t capacity() const { return commands_.capacity(); }
-
-  // 预分配空间
-  void reserve(size_t capacity);
-
-private:
-  std::vector<RenderCommand> commands_;
-  uint32_t nextOrder_;
-
-  // 排序比较函数
-  static bool compareCommands(const RenderCommand &a, const RenderCommand &b);
-};
-
-} // namespace extra2d
diff --git a/include/renderer/render_target.h b/include/renderer/render_target.h
deleted file mode 100644
index ef0ce30..0000000
--- a/include/renderer/render_target.h
+++ /dev/null
@@ -1,333 +0,0 @@
-#pragma once
-
-#include <core/color.h>
-#include <core/ref_counted.h>
-#include <graphics/opengl/gl_texture.h>
-#include <graphics/texture.h>
-#include <mutex>
-
-namespace extra2d {
-
-// ============================================================================
-// 渲染目标配置
-// ============================================================================
-struct RenderTargetConfig {
-  int width = 800;                              // 宽度
-  int height = 600;                             // 高度
-  PixelFormat colorFormat = PixelFormat::RGBA8; // 颜色格式
-  bool hasDepth = true;                         // 是否包含深度缓冲
-  bool hasDepthBuffer = true;                   // 兼容旧API的别名 (同hasDepth)
-  bool hasStencil = false;                      // 是否包含模板缓冲
-  int samples = 1;                              // 多重采样数 (1 = 无MSAA)
-  bool autoResize = true;                       // 是否自动调整大小
-};
-
-// ============================================================================
-// 渲染目标 - 基于FBO的离屏渲染
-// ============================================================================
-class RenderTarget : public RefCounted {
-public:
-  RenderTarget();
-  ~RenderTarget();
-
-  // 禁止拷贝
-  RenderTarget(const RenderTarget &) = delete;
-  RenderTarget &operator=(const RenderTarget &) = delete;
-
-  // 允许移动
-  RenderTarget(RenderTarget &&other) noexcept;
-  RenderTarget &operator=(RenderTarget &&other) noexcept;
-
-  // ------------------------------------------------------------------------
-  // 创建和销毁
-  // ------------------------------------------------------------------------
-
-  /**
-   * @brief 创建渲染目标
-   */
-  bool create(const RenderTargetConfig &config);
-
-  /**
-   * @brief 初始化渲染目标（create的别名，兼容旧API）
-   */
-  bool init(const RenderTargetConfig &config) { return create(config); }
-
-  /**
-   * @brief 从现有纹理创建渲染目标
-   */
-  bool createFromTexture(IntrusivePtr<Texture> texture, bool hasDepth = false);
-
-  /**
-   * @brief 销毁渲染目标
-   */
-  void destroy();
-
-  /**
-   * @brief 关闭渲染目标（destroy的别名，兼容旧API）
-   */
-  void shutdown() { destroy(); }
-
-  /**
-   * @brief 检查是否有效
-   */
-  bool isValid() const { return fbo_ != 0; }
-
-  // ------------------------------------------------------------------------
-  // 尺寸和格式
-  // ------------------------------------------------------------------------
-
-  int width() const { return width_; }
-  int height() const { return height_; }
-  Vec2 size() const {
-    return Vec2(static_cast<float>(width_), static_cast<float>(height_));
-  }
-  PixelFormat getColorFormat() const { return colorFormat_; }
-
-  // ------------------------------------------------------------------------
-  // 绑定和解绑
-  // ------------------------------------------------------------------------
-
-  /**
-   * @brief 绑定为当前渲染目标
-   */
-  void bind();
-
-  /**
-   * @brief 解绑（恢复默认渲染目标）
-   */
-  void unbind();
-
-  /**
-   * @brief 清除渲染目标
-   */
-  void clear(const Color &color = Colors::Transparent);
-
-  // ------------------------------------------------------------------------
-  // 纹理访问
-  // ------------------------------------------------------------------------
-
-  /**
-   * @brief 获取颜色纹理
-   */
-  IntrusivePtr<Texture> getColorTexture() const { return colorTexture_; }
-
-  /**
-   * @brief 获取深度纹理（如果有）
-   */
-  IntrusivePtr<Texture> getDepthTexture() const { return depthTexture_; }
-
-  // ------------------------------------------------------------------------
-  // 视口和裁剪
-  // ------------------------------------------------------------------------
-
-  /**
-   * @brief 设置视口（相对于渲染目标）
-   */
-  void setViewport(int x, int y, int width, int height);
-
-  /**
-   * @brief 获取完整视口
-   */
-  void getFullViewport(int &x, int &y, int &width, int &height) const;
-
-  // ------------------------------------------------------------------------
-  // 工具方法
-  // ------------------------------------------------------------------------
-
-  /**
-   * @brief 调整大小（会销毁并重新创建）
-   */
-  bool resize(int width, int height);
-
-  /**
-   * @brief 复制到另一个渲染目标
-   */
-  void copyTo(RenderTarget &target);
-
-  /**
-   * @brief 复制到另一个渲染目标（blitTo的别名，兼容旧API）
-   * @param target 目标渲染目标
-   * @param color 是否复制颜色缓冲
-   * @param depth 是否复制深度缓冲
-   */
-  void blitTo(RenderTarget &target, bool color = true, bool depth = false);
-
-  /**
-   * @brief 复制到屏幕
-   */
-  void copyToScreen(int screenWidth, int screenHeight);
-
-  /**
-   * @brief 保存为图像文件
-   */
-  bool saveToFile(const std::string &filepath);
-
-  // ------------------------------------------------------------------------
-  // 静态方法
-  // ------------------------------------------------------------------------
-
-  /**
-   * @brief 创建渲染目标的静态工厂方法
-   */
-  static IntrusivePtr<RenderTarget> createFromConfig(const RenderTargetConfig &config);
-
-  /**
-   * @brief 获取当前绑定的渲染目标ID
-   */
-  static GLuint getCurrentFBO();
-
-  /**
-   * @brief 绑定默认渲染目标（屏幕）
-   */
-  static void bindDefault();
-
-  /**
-   * @brief 获取FBO ID（供内部使用）
-   */
-  GLuint getFBO() const { return fbo_; }
-
-protected:
-  GLuint fbo_ = 0; // 帧缓冲对象
-  GLuint rbo_ = 0; // 渲染缓冲对象（深度/模板）
-
-  IntrusivePtr<Texture> colorTexture_; // 颜色纹理
-  IntrusivePtr<Texture> depthTexture_; // 深度纹理（可选）
-
-  int width_ = 0;
-  int height_ = 0;
-  PixelFormat colorFormat_ = PixelFormat::RGBA8;
-  bool hasDepth_ = false;
-  bool hasStencil_ = false;
-  int samples_ = 1;
-
-  bool createFBO();
-  void deleteFBO();
-};
-
-// ============================================================================
-// 多重采样渲染目标（用于MSAA）
-// ============================================================================
-class MultisampleRenderTarget : public RenderTarget {
-public:
-  /**
-   * @brief 创建多重采样渲染目标
-   */
-  bool create(int width, int height, int samples = 4);
-
-  /**
-   * @brief 解析到普通渲染目标（用于显示）
-   */
-  void resolveTo(RenderTarget &target);
-
-  /**
-   * @brief 销毁渲染目标
-   */
-  void destroy();
-
-private:
-  GLuint colorRBO_ = 0; // 多重采样颜色渲染缓冲
-};
-
-// ============================================================================
-// 渲染目标栈（用于嵌套渲染）
-// ============================================================================
-class RenderTargetStack {
-public:
-  static RenderTargetStack &getInstance();
-
-  /**
-   * @brief 压入渲染目标
-   */
-  void push(RenderTarget *target);
-
-  /**
-   * @brief 弹出渲染目标
-   */
-  void pop();
-
-  /**
-   * @brief 获取当前渲染目标
-   */
-  RenderTarget *getCurrent() const;
-
-  /**
-   * @brief 获取栈大小
-   */
-  size_t size() const;
-
-  /**
-   * @brief 清空栈
-   */
-  void clear();
-
-private:
-  RenderTargetStack() = default;
-  ~RenderTargetStack() = default;
-
-  std::vector<RenderTarget *> stack_;
-  mutable std::mutex mutex_;
-};
-
-// ============================================================================
-// 渲染目标管理器 - 全局渲染目标管理
-// ============================================================================
-class RenderTargetManager {
-public:
-  /**
-   * @brief 获取单例实例
-   */
-  static RenderTargetManager &getInstance();
-
-  /**
-   * @brief 初始化渲染目标管理器
-   * @param width 默认宽度
-   * @param height 默认高度
-   */
-  bool init(int width, int height);
-
-  /**
-   * @brief 关闭渲染目标管理器
-   */
-  void shutdown();
-
-  /**
-   * @brief 创建新的渲染目标
-   */
-  IntrusivePtr<RenderTarget> createRenderTarget(const RenderTargetConfig &config);
-
-  /**
-   * @brief 获取默认渲染目标
-   */
-  RenderTarget *getDefaultRenderTarget() const {
-    return defaultRenderTarget_.get();
-  }
-
-  /**
-   * @brief 调整所有受管渲染目标的大小
-   */
-  void resize(int width, int height);
-
-  /**
-   * @brief 检查是否已初始化
-   */
-  bool isInitialized() const { return initialized_; }
-
-private:
-  RenderTargetManager() = default;
-  ~RenderTargetManager() = default;
-  RenderTargetManager(const RenderTargetManager &) = delete;
-  RenderTargetManager &operator=(const RenderTargetManager &) = delete;
-
-  IntrusivePtr<RenderTarget> defaultRenderTarget_;
-  std::vector<IntrusivePtr<RenderTarget>> renderTargets_;
-  bool initialized_ = false;
-};
-
-// ============================================================================
-// 便捷宏
-// ============================================================================
-#define E2D_RENDER_TARGET_STACK() ::extra2d::RenderTargetStack::getInstance()
-#define E2D_RENDER_TARGET_MANAGER()                                            \
-  ::extra2d::RenderTargetManager::getInstance()
-
-} // namespace extra2d
diff --git a/include/renderer/renderer.h b/include/renderer/renderer.h
deleted file mode 100644
index 10d6d27..0000000
--- a/include/renderer/renderer.h
+++ /dev/null
@@ -1,140 +0,0 @@
-#pragma once
-
-#include <core/color.h>
-#include <core/rect.h>
-#include <core/transform.h>
-#include <core/types.h>
-#include <core/vec2.h>
-#include <glm/mat4x4.hpp>
-
-namespace extra2d {
-
-// 前向声明
-class Window;
-class Texture;
-class FontAtlas;
-class Shader;
-
-// ============================================================================
-// 渲染后端类型
-// ============================================================================
-enum class BackendType {
-  OpenGL,
-  // Vulkan,
-  // Metal,
-  // D3D11,
-  // D3D12
-};
-
-// ============================================================================
-// 混合模式
-// ============================================================================
-enum class BlendMode {
-  None,     // 不混合
-  Alpha,    // 标准 Alpha 混合
-  Additive, // 加法混合
-  Multiply  // 乘法混合
-};
-
-// ============================================================================
-// 渲染后端抽象接口
-// ============================================================================
-class Renderer {
-public:
-  virtual ~Renderer() = default;
-
-  // ------------------------------------------------------------------------
-  // 生命周期
-  // ------------------------------------------------------------------------
-  virtual bool init(Window *window) = 0;
-  virtual void shutdown() = 0;
-
-  // ------------------------------------------------------------------------
-  // 帧管理
-  // ------------------------------------------------------------------------
-  virtual void beginFrame(const Color &clearColor) = 0;
-  virtual void endFrame() = 0;
-  virtual void setViewport(int x, int y, int width, int height) = 0;
-  virtual void setVSync(bool enabled) = 0;
-
-  // ------------------------------------------------------------------------
-  // 状态设置
-  // ------------------------------------------------------------------------
-  virtual void setBlendMode(BlendMode mode) = 0;
-  virtual void setViewProjection(const glm::mat4 &matrix) = 0;
-
-  // ------------------------------------------------------------------------
-  // 变换矩阵栈
-  // ------------------------------------------------------------------------
-  virtual void pushTransform(const glm::mat4 &transform) = 0;
-  virtual void popTransform() = 0;
-  virtual glm::mat4 getCurrentTransform() const = 0;
-
-  // ------------------------------------------------------------------------
-  // 纹理
-  // ------------------------------------------------------------------------
-  virtual IntrusivePtr<Texture> createTexture(int width, int height,
-                                     const uint8_t *pixels, int channels) = 0;
-  virtual IntrusivePtr<Texture> loadTexture(const std::string &filepath) = 0;
-
-  // ------------------------------------------------------------------------
-  // 精灵批渲染
-  // ------------------------------------------------------------------------
-  virtual void beginSpriteBatch() = 0;
-  virtual void drawSprite(const Texture &texture, const Rect &destRect,
-                          const Rect &srcRect, const Color &tint,
-                          float rotation, const Vec2 &anchor) = 0;
-  virtual void drawSprite(const Texture &texture, const Vec2 &position,
-                          const Color &tint) = 0;
-  virtual void endSpriteBatch() = 0;
-
-  // ------------------------------------------------------------------------
-  // 形状渲染
-  // ------------------------------------------------------------------------
-  virtual void drawLine(const Vec2 &start, const Vec2 &end, const Color &color,
-                        float width = 1.0f) = 0;
-  virtual void drawRect(const Rect &rect, const Color &color,
-                        float width = 1.0f) = 0;
-  virtual void fillRect(const Rect &rect, const Color &color) = 0;
-  virtual void drawCircle(const Vec2 &center, float radius, const Color &color,
-                          int segments = 32, float width = 1.0f) = 0;
-  virtual void fillCircle(const Vec2 &center, float radius, const Color &color,
-                          int segments = 32) = 0;
-  virtual void drawTriangle(const Vec2 &p1, const Vec2 &p2, const Vec2 &p3,
-                            const Color &color, float width = 1.0f) = 0;
-  virtual void fillTriangle(const Vec2 &p1, const Vec2 &p2, const Vec2 &p3,
-                            const Color &color) = 0;
-  virtual void drawPolygon(const std::vector<Vec2> &points, const Color &color,
-                           float width = 1.0f) = 0;
-  virtual void fillPolygon(const std::vector<Vec2> &points,
-                           const Color &color) = 0;
-
-  // ------------------------------------------------------------------------
-  // 文字渲染
-  // ------------------------------------------------------------------------
-  virtual IntrusivePtr<FontAtlas> createFontAtlas(const std::string &filepath,
-                                         int fontSize, bool useSDF = false) = 0;
-  virtual void drawText(const FontAtlas &font, const std::string &text,
-                        const Vec2 &position, const Color &color) = 0;
-  virtual void drawText(const FontAtlas &font, const std::string &text, float x,
-                        float y, const Color &color) = 0;
-
-  // ------------------------------------------------------------------------
-  // 统计信息
-  // ------------------------------------------------------------------------
-  struct Stats {
-    uint32_t drawCalls = 0;
-    uint32_t triangleCount = 0;
-    uint32_t textureBinds = 0;
-    uint32_t shaderBinds = 0;
-  };
-  virtual Stats getStats() const = 0;
-  virtual void resetStats() = 0;
-
-  // ------------------------------------------------------------------------
-  // 工厂方法
-  // ------------------------------------------------------------------------
-  static UniquePtr<Renderer> create(BackendType type);
-};
-
-} // namespace extra2d
diff --git a/include/resource/resource_manager.h b/include/resource/resource_manager.h
deleted file mode 100644
index a15cc0f..0000000
--- a/include/resource/resource_manager.h
+++ /dev/null
@@ -1,362 +0,0 @@
-#pragma once
-
-#include <atomic>
-#include <audio/sound.h>
-#include <core/types.h>
-#include <functional>
-#include <future>
-#include <graphics/alpha_mask.h>
-#include <graphics/font.h>
-#include <graphics/texture.h>
-#include <mutex>
-#include <queue>
-#include <string>
-#include <thread>
-#include <unordered_map>
-#include <vector>
-
-
-namespace extra2d {
-
-// ============================================================================
-// 资源管理器 - 统一管理纹理、字体、音效等资源
-// 支持异步加载和纹理压缩
-// ============================================================================
-
-// 纹理格式枚举
-enum class TextureFormat {
-  Auto = 0, // 自动选择最佳格式
-  RGBA8,    // 32位 RGBA
-  RGB8,     // 24位 RGB
-  DXT1,     // BC1/DXT1 压缩（1 bit alpha）
-  DXT5,     // BC3/DXT5 压缩（完整 alpha）
-  ETC2,     // ETC2 压缩（移动平台）
-  ASTC4x4,  // ASTC 4x4 压缩（高质量）
-  ASTC8x8,  // ASTC 8x8 压缩（高压缩率）
-};
-
-// ============================================================================
-// 纹理LRU缓存项
-// ============================================================================
-struct TextureCacheEntry {
-  IntrusivePtr<Texture> texture;
-  size_t size = 0;             // 纹理大小（字节）
-  float lastAccessTime = 0.0f; // 最后访问时间
-  uint32_t accessCount = 0;    // 访问次数
-};
-
-// 异步加载回调类型
-using TextureLoadCallback = std::function<void(IntrusivePtr<Texture>)>;
-
-class ResourceManager {
-public:
-  // ------------------------------------------------------------------------
-  // 单例访问
-  // ------------------------------------------------------------------------
-  static ResourceManager &getInstance();
-
-  // ------------------------------------------------------------------------
-  // 纹理资源 - 同步加载
-  // ------------------------------------------------------------------------
-
-  /// 加载纹理（带缓存）
-  IntrusivePtr<Texture> loadTexture(const std::string &filepath);
-
-  /// 加载纹理（指定是否异步）
-  IntrusivePtr<Texture> loadTexture(const std::string &filepath, bool async);
-
-  /// 加载纹理（完整参数：异步 + 压缩格式）
-  IntrusivePtr<Texture> loadTexture(const std::string &filepath, bool async,
-                           TextureFormat format);
-
-  /// 异步加载纹理（带回调）
-  void loadTextureAsync(const std::string &filepath,
-                        TextureLoadCallback callback);
-
-  /// 异步加载纹理（指定格式 + 回调）
-  void loadTextureAsync(const std::string &filepath, TextureFormat format,
-                        TextureLoadCallback callback);
-
-  /// 加载纹理并生成Alpha遮罩（用于不规则形状图片）
-  IntrusivePtr<Texture> loadTextureWithAlphaMask(const std::string &filepath);
-
-  /// 通过key获取已缓存的纹理
-  IntrusivePtr<Texture> getTexture(const std::string &key) const;
-
-  /// 检查纹理是否已缓存
-  bool hasTexture(const std::string &key) const;
-
-  /// 卸载指定纹理
-  void unloadTexture(const std::string &key);
-
-  // ------------------------------------------------------------------------
-  // Alpha遮罩资源
-  // ------------------------------------------------------------------------
-
-  /// 获取纹理的Alpha遮罩（如果已生成）
-  const AlphaMask *getAlphaMask(const std::string &textureKey) const;
-
-  /// 为已加载的纹理生成Alpha遮罩
-  bool generateAlphaMask(const std::string &textureKey);
-
-  /// 检查纹理是否有Alpha遮罩
-  bool hasAlphaMask(const std::string &textureKey) const;
-
-  // ------------------------------------------------------------------------
-  // 字体图集资源
-  // ------------------------------------------------------------------------
-
-  /// 加载字体图集（带缓存）
-  IntrusivePtr<FontAtlas> loadFont(const std::string &filepath, int fontSize,
-                          bool useSDF = false);
-
-  /// 通过key获取已缓存的字体图集
-  IntrusivePtr<FontAtlas> getFont(const std::string &key) const;
-
-  /// 检查字体是否已缓存
-  bool hasFont(const std::string &key) const;
-
-  /// 卸载指定字体
-  void unloadFont(const std::string &key);
-
-  // ------------------------------------------------------------------------
-  // 音效资源
-  // ------------------------------------------------------------------------
-
-  /// 加载音效（带缓存）
-  IntrusivePtr<Sound> loadSound(const std::string &filepath);
-  IntrusivePtr<Sound> loadSound(const std::string &name, const std::string &filepath);
-
-  /// 通过key获取已缓存的音效
-  IntrusivePtr<Sound> getSound(const std::string &key) const;
-
-  /// 检查音效是否已缓存
-  bool hasSound(const std::string &key) const;
-
-  /// 卸载指定音效
-  void unloadSound(const std::string &key);
-
-  // ------------------------------------------------------------------------
-  // 文本文件资源
-  // ------------------------------------------------------------------------
-
-  /// 加载文本文件（带缓存）
-  /// @param filepath 文件路径，支持 romfs:/ 前缀
-  /// @return 文件内容字符串，加载失败返回空字符串
-  std::string loadTextFile(const std::string &filepath);
-
-  /// 加载文本文件（指定编码）
-  /// @param filepath 文件路径
-  /// @param encoding 文件编码（默认 UTF-8）
-  /// @return 文件内容字符串
-  std::string loadTextFile(const std::string &filepath,
-                           const std::string &encoding);
-
-  /// 通过key获取已缓存的文本内容
-  std::string getTextFile(const std::string &key) const;
-
-  /// 检查文本文件是否已缓存
-  bool hasTextFile(const std::string &key) const;
-
-  /// 卸载指定文本文件
-  void unloadTextFile(const std::string &key);
-
-  /// 清理所有文本文件缓存
-  void clearTextFileCache();
-
-  // ------------------------------------------------------------------------
-  // JSON 文件资源
-  // ------------------------------------------------------------------------
-
-  /// 加载并解析 JSON 文件
-  /// @param filepath 文件路径，支持 romfs:/ 前缀
-  /// @return JSON 字符串内容，加载或解析失败返回空字符串
-  /// @note 返回的是原始 JSON 字符串，需要自行解析
-  std::string loadJsonFile(const std::string &filepath);
-
-  /// 通过key获取已缓存的 JSON 内容
-  std::string getJsonFile(const std::string &key) const;
-
-  /// 检查 JSON 文件是否已缓存
-  bool hasJsonFile(const std::string &key) const;
-
-  /// 卸载指定 JSON 文件
-  void unloadJsonFile(const std::string &key);
-
-  /// 清理所有 JSON 文件缓存
-  void clearJsonFileCache();
-
-  // ------------------------------------------------------------------------
-  // 缓存清理
-  // ------------------------------------------------------------------------
-
-  /// 清理所有失效的弱引用（自动清理已释放的资源）
-  void purgeUnused();
-
-  /// 清理指定类型的所有缓存
-  void clearTextureCache();
-  void clearFontCache();
-  void clearSoundCache();
-
-  /// 清理所有资源缓存
-  void clearAllCaches();
-
-  /// 获取各类资源的缓存数量
-  size_t getTextureCacheSize() const;
-  size_t getFontCacheSize() const;
-  size_t getSoundCacheSize() const;
-  size_t getTextFileCacheSize() const;
-  size_t getJsonFileCacheSize() const;
-
-  // ------------------------------------------------------------------------
-  // LRU 缓存管理
-  // ------------------------------------------------------------------------
-
-  /// 设置纹理缓存参数
-  void setTextureCache(size_t maxCacheSize, size_t maxTextureCount,
-                       float unloadInterval);
-
-  /// 获取当前缓存的总大小（字节）
-  size_t getTextureCacheMemoryUsage() const;
-
-  /// 获取缓存命中率
-  float getTextureCacheHitRate() const;
-
-  /// 打印缓存统计信息
-  void printTextureCacheStats() const;
-
-  /// 更新缓存（在主循环中调用，用于自动清理）
-  void update(float dt);
-
-  // ------------------------------------------------------------------------
-  // 异步加载控制
-  // ------------------------------------------------------------------------
-
-  /// 初始化异步加载系统（可选，自动在首次异步加载时初始化）
-  void initAsyncLoader();
-
-  /// 关闭异步加载系统
-  void shutdownAsyncLoader();
-
-  /// 等待所有异步加载完成
-  void waitForAsyncLoads();
-
-  /// 检查是否有正在进行的异步加载
-  bool hasPendingAsyncLoads() const;
-
-  ResourceManager();
-  ~ResourceManager();
-  ResourceManager(const ResourceManager &) = delete;
-  ResourceManager &operator=(const ResourceManager &) = delete;
-
-private:
-  // 生成字体缓存key
-  std::string makeFontKey(const std::string &filepath, int fontSize,
-                          bool useSDF) const;
-
-  // 内部加载实现
-  IntrusivePtr<Texture> loadTextureInternal(const std::string &filepath,
-                                   TextureFormat format);
-
-  // 选择最佳纹理格式
-  TextureFormat selectBestFormat(TextureFormat requested) const;
-
-  // 压缩纹理数据
-  std::vector<uint8_t> compressTexture(const uint8_t *data, int width,
-                                       int height, int channels,
-                                       TextureFormat format);
-
-  // 互斥锁保护缓存
-  mutable std::mutex textureMutex_;
-  mutable std::mutex fontMutex_;
-  mutable std::mutex soundMutex_;
-  mutable std::mutex textFileMutex_;
-  mutable std::mutex jsonFileMutex_;
-
-  // 资源缓存 - 使用 IntrusivePtr 强引用
-  std::unordered_map<std::string, IntrusivePtr<FontAtlas>> fontCache_;
-  std::unordered_map<std::string, IntrusivePtr<Sound>> soundCache_;
-
-  // 文本文件缓存 - 使用强引用（字符串值类型）
-  std::unordered_map<std::string, std::string> textFileCache_;
-  std::unordered_map<std::string, std::string> jsonFileCache_;
-
-  // ============================================================================
-  // 纹理LRU缓存
-  // ============================================================================
-
-  // LRU链表节点
-  struct LRUNode {
-    std::string key;
-    uint32_t prev = 0; // 数组索引，0表示无效
-    uint32_t next = 0; // 数组索引，0表示无效
-    bool valid = false;
-  };
-
-  // 纹理缓存配置
-  size_t maxCacheSize_ = 64 * 1024 * 1024; // 最大缓存大小 (64MB)
-  size_t maxTextureCount_ = 256;           // 最大纹理数量
-  float unloadInterval_ = 30.0f;           // 自动清理间隔 (秒)
-
-  // 纹理缓存 - 使用强指针保持引用
-  std::unordered_map<std::string, TextureCacheEntry> textureCache_;
-
-  // 侵入式LRU链表 - 使用数组索引代替指针，提高缓存局部性
-  std::vector<LRUNode> lruNodes_;
-  uint32_t lruHead_ = 0;  // 最近使用
-  uint32_t lruTail_ = 0;  // 最久未使用
-  uint32_t freeList_ = 0; // 空闲节点链表
-
-  // 统计
-  size_t totalTextureSize_ = 0;
-  uint64_t textureHitCount_ = 0;
-  uint64_t textureMissCount_ = 0;
-  float autoUnloadTimer_ = 0.0f;
-
-  // 异步加载相关
-  struct AsyncLoadTask {
-    std::string filepath;
-    TextureFormat format;
-    TextureLoadCallback callback;
-    std::promise<IntrusivePtr<Texture>> promise;
-  };
-
-  std::queue<AsyncLoadTask> asyncTaskQueue_;
-  std::mutex asyncQueueMutex_;
-  std::condition_variable asyncCondition_;
-  std::unique_ptr<std::thread> asyncThread_;
-  std::atomic<bool> asyncRunning_{false};
-  std::atomic<int> pendingAsyncLoads_{0};
-
-  void asyncLoadLoop();
-
-  // ============================================================================
-  // LRU 缓存内部方法
-  // ============================================================================
-
-  /// 分配LRU节点
-  uint32_t allocateLRUNode(const std::string &key);
-
-  /// 释放LRU节点
-  void freeLRUNode(uint32_t index);
-
-  /// 将节点移到链表头部（最近使用）
-  void moveToFront(uint32_t index);
-
-  /// 从链表中移除节点
-  void removeFromList(uint32_t index);
-
-  /// 驱逐最久未使用的纹理
-  std::string evictLRU();
-
-  /// 访问纹理（更新LRU位置）
-  void touchTexture(const std::string &key);
-
-  /// 驱逐纹理直到满足大小限制
-  void evictTexturesIfNeeded();
-
-  /// 计算纹理大小
-  size_t calculateTextureSize(int width, int height, PixelFormat format) const;
-};
-
-} // namespace extra2d
diff --git a/include/scene/node.h b/include/scene/node.h
deleted file mode 100644
index 9630ab5..0000000
--- a/include/scene/node.h
+++ /dev/null
@@ -1,239 +0,0 @@
-#pragma once
-
-#include <core/color.h>
-#include <core/rect.h>
-#include <core/types.h>
-#include <core/vec2.h>
-#include <event/event_dispatcher.h>
-#include <renderer/renderer.h>
-#include <string>
-#include <vector>
-
-namespace extra2d {
-
-// 前向声明
-class Scene;
-class Renderer;
-struct RenderCommand;
-
-// ============================================================================
-// 节点基类 - 场景图的基础
-// ============================================================================
-class Node : public RefCounted {
-public:
-  Node();
-  virtual ~Node();
-
-  // ------------------------------------------------------------------------
-  // 层级管理
-  // ------------------------------------------------------------------------
-  void addChild(IntrusivePtr<Node> child);
-
-  /**
-   * @brief 批量添加子节点
-   * @param children 子节点列表
-   */
-  void addChildren(std::vector<IntrusivePtr<Node>> &&children);
-
-  void removeChild(IntrusivePtr<Node> child);
-  void removeChildByName(const std::string &name);
-  void removeFromParent();
-  void removeAllChildren();
-
-  Node* parent() const { return parent_; }
-  const std::vector<IntrusivePtr<Node>> &children() const { return children_; }
-  IntrusivePtr<Node> childByName(const std::string &name) const;
-  IntrusivePtr<Node> childByTag(int tag) const;
-
-  // ------------------------------------------------------------------------
-  // 变换属性
-  // ------------------------------------------------------------------------
-  void setPosition(const Vec2 &pos);
-  void setPosition(float x, float y);
-  Vec2 pos() const { return position_; }
-
-  void setRotation(float degrees);
-  float rot() const { return rotation_; }
-
-  void setScale(const Vec2 &scale);
-  void setScale(float scale);
-  void setScale(float x, float y);
-  Vec2 scale() const { return scale_; }
-
-  void setAnchor(const Vec2 &anchor);
-  void setAnchor(float x, float y);
-  Vec2 anchor() const { return anchor_; }
-
-  void setSkew(const Vec2 &skew);
-  void setSkew(float x, float y);
-  Vec2 skew() const { return skew_; }
-
-  void setOpacity(float opacity);
-  float opacity() const { return opacity_; }
-
-  void setVisible(bool visible);
-  bool visible() const { return visible_; }
-
-  /**
-   * @brief 设置颜色
-   * @param color RGB颜色
-   */
-  void setColor(const Color3B &color);
-  Color3B getColor() const { return color_; }
-
-  /**
-   * @brief 设置X轴翻转
-   */
-  void setFlipX(bool flipX);
-  bool flipX() const { return flipX_; }
-
-  /**
-   * @brief 设置Y轴翻转
-   */
-  void setFlipY(bool flipY);
-  bool flipY() const { return flipY_; }
-
-  void setZOrder(int zOrder);
-  int zOrder() const { return zOrder_; }
-
-  // ------------------------------------------------------------------------
-  // 世界变换
-  // ------------------------------------------------------------------------
-  Vec2 convertToWorldSpace(const Vec2 &localPos) const;
-  Vec2 convertToNodeSpace(const Vec2 &worldPos) const;
-
-  glm::mat4 getLocalTransform() const;
-  glm::mat4 getWorldTransform() const;
-
-  /**
-   * @brief 标记变换矩阵为脏状态，并传播到所有子节点
-   */
-  void markTransformDirty();
-
-  /**
-   * @brief 批量更新变换矩阵
-   * 在渲染前统一计算所有脏节点的变换矩阵，避免逐节点计算时的重复递归
-   */
-  void batchUpdateTransforms();
-
-  /**
-   * @brief 获取变换脏标记状态
-   */
-  bool isTransformDirty() const { return transformDirty_; }
-  bool isWorldTransformDirty() const { return worldTransformDirty_; }
-
-  // ------------------------------------------------------------------------
-  // 名称和标签
-  // ------------------------------------------------------------------------
-  void setName(const std::string &name) { name_ = name; }
-  const std::string &name() const { return name_; }
-
-  void setTag(int tag) { tag_ = tag; }
-  int tag() const { return tag_; }
-
-  // ------------------------------------------------------------------------
-  // 生命周期回调
-  // ------------------------------------------------------------------------
-  virtual void onEnter();
-  virtual void onExit();
-  virtual void onUpdate(float dt);
-  virtual void onRender(Renderer &renderer);
-  virtual void onAttachToScene(Scene *scene);
-  virtual void onDetachFromScene();
-
-  // ------------------------------------------------------------------------
-  // 边界框
-  // ------------------------------------------------------------------------
-  virtual Rect boundingBox() const;
-
-  // ------------------------------------------------------------------------
-  // 事件系统
-  // ------------------------------------------------------------------------
-  EventDispatcher &getEventDispatcher() { return eventDispatcher_; }
-
-  // ------------------------------------------------------------------------
-  // 内部方法
-  // ------------------------------------------------------------------------
-  void update(float dt);
-  void render(Renderer &renderer);
-  void sortChildren();
-
-  bool isRunning() const { return running_; }
-  Scene *getScene() const { return scene_; }
-
-  // 多线程渲染命令收集
-  virtual void collectRenderCommands(std::vector<RenderCommand> &commands,
-                                     int parentZOrder = 0);
-
-protected:
-  // 子类重写
-  virtual void onDraw(Renderer &renderer) {}
-  virtual void onUpdateNode(float dt) {}
-  virtual void generateRenderCommand(std::vector<RenderCommand> &commands,
-                                     int zOrder) {};
-
-  // 供子类访问的内部状态
-  Vec2 &getPositionRef() { return position_; }
-  Vec2 &getScaleRef() { return scale_; }
-  Vec2 &getAnchorRef() { return anchor_; }
-  float getRotationRef() { return rotation_; }
-  float getOpacityRef() { return opacity_; }
-
-private:
-  // ==========================================================================
-  // 成员变量按类型大小降序排列，减少内存对齐填充
-  // 64位系统对齐：std::string(32) > glm::mat4(64) > std::vector(24) >
-  //              double(8) > float(4) > int(4) > bool(1)
-  // ==========================================================================
-
-  // 1. 大块内存（64字节）
-  mutable glm::mat4 localTransform_; // 64 bytes
-  mutable glm::mat4 worldTransform_; // 64 bytes
-
-  // 2. 字符串和容器（24-32字节）
-  std::string name_;                // 32 bytes
-  std::vector<IntrusivePtr<Node>> children_; // 24 bytes
-
-  // 3. 子节点索引（加速查找）
-  std::unordered_map<std::string, Node*> nameIndex_; // 56 bytes
-  std::unordered_map<int, Node*> tagIndex_;          // 56 bytes
-
-  // 4. 事件分发器
-  EventDispatcher eventDispatcher_; // 大小取决于实现
-
-  // 5. 父节点引用
-  Node* parent_ = nullptr; // 8 bytes
-
-  // 7. 变换属性（按访问频率分组）
-  Vec2 position_ = Vec2::Zero();   // 8 bytes
-  Vec2 scale_ = Vec2(1.0f, 1.0f);  // 8 bytes
-  Vec2 anchor_ = Vec2(0.5f, 0.5f); // 8 bytes
-  Vec2 skew_ = Vec2::Zero();       // 8 bytes
-
-  // 8. 浮点属性
-  float rotation_ = 0.0f; // 4 bytes
-  float opacity_ = 1.0f;  // 4 bytes
-
-  // 10. 颜色属性
-  Color3B color_ = Color3B(255, 255, 255); // 3 bytes
-
-  // 11. 整数属性
-  int zOrder_ = 0; // 4 bytes
-  int tag_ = -1;   // 4 bytes
-
-  // 12. 布尔属性
-  bool flipX_ = false; // 1 byte
-  bool flipY_ = false; // 1 byte
-
-  // 11. 场景指针
-  Scene *scene_ = nullptr; // 8 bytes
-
-  // 9. 布尔标志（打包在一起）
-  mutable bool transformDirty_ = true;      // 1 byte
-  mutable bool worldTransformDirty_ = true; // 1 byte
-  bool childrenOrderDirty_ = false;         // 1 byte
-  bool visible_ = true;                     // 1 byte
-  bool running_ = false;                    // 1 byte
-};
-
-} // namespace extra2d
diff --git a/include/scene/scene.h b/include/scene/scene.h
deleted file mode 100644
index cae5261..0000000
--- a/include/scene/scene.h
+++ /dev/null
@@ -1,84 +0,0 @@
-#pragma once
-
-#include <core/color.h>
-#include <renderer/camera.h>
-#include <scene/node.h>
-#include <vector>
-
-namespace extra2d {
-
-// 前向声明
-struct RenderCommand;
-
-// ============================================================================
-// 场景类 - 节点容器，管理整个场景图
-// ============================================================================
-class Scene : public Node {
-public:
-  Scene();
-  ~Scene() override = default;
-
-  // ------------------------------------------------------------------------
-  // 场景属性
-  // ------------------------------------------------------------------------
-  void setBackgroundColor(const Color &color) { backgroundColor_ = color; }
-  Color getBackgroundColor() const { return backgroundColor_; }
-
-  // ------------------------------------------------------------------------
-  // 摄像机
-  // ------------------------------------------------------------------------
-  void setCamera(IntrusivePtr<Camera> camera);
-  IntrusivePtr<Camera> getCamera() const { return camera_; }
-
-  Camera *getActiveCamera() const {
-    return camera_ ? camera_.get() : defaultCamera_.get();
-  }
-
-  // ------------------------------------------------------------------------
-  // 视口和尺寸
-  // ------------------------------------------------------------------------
-  void setViewportSize(float width, float height);
-  void setViewportSize(const Size &size);
-  Size getViewportSize() const { return viewportSize_; }
-
-  float width() const { return viewportSize_.width; }
-  float height() const { return viewportSize_.height; }
-
-  // ------------------------------------------------------------------------
-  // 场景状态
-  // ------------------------------------------------------------------------
-  bool isPaused() const { return paused_; }
-  void pause() { paused_ = true; }
-  void resume() { paused_ = false; }
-
-  // ------------------------------------------------------------------------
-  // 渲染和更新
-  // ------------------------------------------------------------------------
-  void renderScene(Renderer &renderer);
-  virtual void renderContent(Renderer &renderer);
-  void updateScene(float dt);
-  void collectRenderCommands(std::vector<RenderCommand> &commands,
-                             int parentZOrder = 0) override;
-
-  // ------------------------------------------------------------------------
-  // 静态创建方法
-  // ------------------------------------------------------------------------
-  static IntrusivePtr<Scene> create();
-
-protected:
-  void onEnter() override;
-  void onExit() override;
-
-  friend class SceneManager;
-
-private:
-  Color backgroundColor_ = Colors::Black;
-  Size viewportSize_ = Size::Zero();
-
-  IntrusivePtr<Camera> camera_;
-  IntrusivePtr<Camera> defaultCamera_;
-
-  bool paused_ = false;
-};
-
-} // namespace extra2d
diff --git a/include/scene/scene_manager.h b/include/scene/scene_manager.h
deleted file mode 100644
index e66f0c6..0000000
--- a/include/scene/scene_manager.h
+++ /dev/null
@@ -1,105 +0,0 @@
-#pragma once
-
-#include <core/types.h>
-#include <functional>
-#include <scene/scene.h>
-#include <stack>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-
-namespace extra2d {
-
-// 前向声明
-struct RenderCommand;
-
-// ============================================================================
-// 场景管理器 - 管理场景的生命周期和切换
-// ============================================================================
-class SceneManager {
-public:
-  // ------------------------------------------------------------------------
-  // 单例访问
-  // ------------------------------------------------------------------------
-  static SceneManager &getInstance();
-
-  // ------------------------------------------------------------------------
-  // 场景栈操作
-  // ------------------------------------------------------------------------
-
-  // 运行第一个场景
-  void runWithScene(IntrusivePtr<Scene> scene);
-
-  // 替换当前场景
-  void replaceScene(IntrusivePtr<Scene> scene);
-
-  // 压入新场景（当前场景暂停）
-  void pushScene(IntrusivePtr<Scene> scene);
-
-  // 弹出当前场景（恢复上一个场景）
-  void popScene();
-
-  // 弹出到根场景
-  void popToRootScene();
-
-  // 弹出到指定场景
-  void popToScene(const std::string &name);
-
-  // ------------------------------------------------------------------------
-  // 获取场景
-  // ------------------------------------------------------------------------
-  IntrusivePtr<Scene> getCurrentScene() const;
-  IntrusivePtr<Scene> getPreviousScene() const;
-  IntrusivePtr<Scene> getRootScene() const;
-
-  // 通过名称获取场景
-  IntrusivePtr<Scene> getSceneByName(const std::string &name) const;
-
-  // ------------------------------------------------------------------------
-  // 查询
-  // ------------------------------------------------------------------------
-  size_t getSceneCount() const { return sceneStack_.size(); }
-  bool isEmpty() const { return sceneStack_.empty(); }
-  bool hasScene(const std::string &name) const;
-
-  // ------------------------------------------------------------------------
-  // 更新和渲染
-  // ------------------------------------------------------------------------
-  void update(float dt);
-  void render(Renderer &renderer);
-  void collectRenderCommands(std::vector<RenderCommand> &commands);
-
-  // ------------------------------------------------------------------------
-  // 清理
-  // ------------------------------------------------------------------------
-  void end();
-  void purgeCachedScenes();
-
-public:
-  SceneManager() = default;
-  ~SceneManager() = default;
-  SceneManager(const SceneManager &) = delete;
-  SceneManager &operator=(const SceneManager &) = delete;
-
-  // 场景切换（供 Application 使用）
-  void enterScene(IntrusivePtr<Scene> scene);
-
-private:
-  void doSceneSwitch();
-  void dispatchPointerEvents(Scene &scene);
-
-  std::stack<IntrusivePtr<Scene>> sceneStack_;
-  std::unordered_map<std::string, IntrusivePtr<Scene>> namedScenes_;
-
-  // Next scene to switch to (queued during transition)
-  IntrusivePtr<Scene> nextScene_;
-  bool sendCleanupToScene_ = false;
-
-  Node *hoverTarget_ = nullptr;
-  Node *captureTarget_ = nullptr;
-  Vec2 lastPointerWorld_ = Vec2::Zero();
-  bool hasLastPointerWorld_ = false;
-};
-
-} // namespace extra2d
diff --git a/include/scene/shape.h b/include/scene/shape.h
deleted file mode 100644
index 3740e67..0000000
--- a/include/scene/shape.h
+++ /dev/null
@@ -1,104 +0,0 @@
-#pragma once
-
-#include <core/color.h>
-#include <core/vec2.h>
-#include <scene/node.h>
-#include <vector>
-
-namespace extra2d {
-
-// ============================================================================
-// 形状类型
-// ============================================================================
-enum class ShapeType { Point, Line, Rect, Circle, Triangle, Polygon };
-
-// ============================================================================
-// 形状节点 - 用于绘制几何形状
-// ============================================================================
-class ShapeNode : public Node {
-public:
-  ShapeNode();
-  ~ShapeNode() override = default;
-
-  // ------------------------------------------------------------------------
-  // 静态创建方法
-  // ------------------------------------------------------------------------
-  static IntrusivePtr<ShapeNode> create();
-
-  // 点
-  static IntrusivePtr<ShapeNode> createPoint(const Vec2 &pos, const Color &color);
-
-  // 线
-  static IntrusivePtr<ShapeNode> createLine(const Vec2 &start, const Vec2 &end,
-                                   const Color &color, float width = 1.0f);
-
-  // 矩形
-  static IntrusivePtr<ShapeNode> createRect(const Rect &rect, const Color &color,
-                                   float width = 1.0f);
-  static IntrusivePtr<ShapeNode> createFilledRect(const Rect &rect, const Color &color);
-
-  // 圆形
-  static IntrusivePtr<ShapeNode> createCircle(const Vec2 &center, float radius,
-                                     const Color &color, int segments = 32,
-                                     float width = 1.0f);
-  static IntrusivePtr<ShapeNode> createFilledCircle(const Vec2 &center, float radius,
-                                           const Color &color,
-                                           int segments = 32);
-
-  // 三角形
-  static IntrusivePtr<ShapeNode> createTriangle(const Vec2 &p1, const Vec2 &p2,
-                                       const Vec2 &p3, const Color &color,
-                                       float width = 1.0f);
-  static IntrusivePtr<ShapeNode> createFilledTriangle(const Vec2 &p1, const Vec2 &p2,
-                                             const Vec2 &p3,
-                                             const Color &color);
-
-  // 多边形
-  static IntrusivePtr<ShapeNode> createPolygon(const std::vector<Vec2> &points,
-                                      const Color &color, float width = 1.0f);
-  static IntrusivePtr<ShapeNode> createFilledPolygon(const std::vector<Vec2> &points,
-                                            const Color &color);
-
-  // ------------------------------------------------------------------------
-  // 属性设置
-  // ------------------------------------------------------------------------
-  void setShapeType(ShapeType type) { shapeType_ = type; }
-  ShapeType getShapeType() const { return shapeType_; }
-
-  void setColor(const Color &color) { color_ = color; }
-  Color getColor() const { return color_; }
-
-  void setFilled(bool filled) { filled_ = filled; }
-  bool isFilled() const { return filled_; }
-
-  void setLineWidth(float width) { lineWidth_ = width; }
-  float getLineWidth() const { return lineWidth_; }
-
-  void setSegments(int segments) { segments_ = segments; }
-  int getSegments() const { return segments_; }
-
-  // ------------------------------------------------------------------------
-  // 点设置
-  // ------------------------------------------------------------------------
-  void setPoints(const std::vector<Vec2> &points);
-  const std::vector<Vec2> &getPoints() const { return points_; }
-  void addPoint(const Vec2 &point);
-  void clearPoints();
-
-  Rect boundingBox() const override;
-
-protected:
-  void onDraw(Renderer &renderer) override;
-  void generateRenderCommand(std::vector<RenderCommand> &commands,
-                             int zOrder) override;
-
-private:
-  ShapeType shapeType_ = ShapeType::Rect;
-  Color color_ = Colors::White;
-  bool filled_ = false;
-  float lineWidth_ = 1.0f;
-  int segments_ = 32;
-  std::vector<Vec2> points_;
-};
-
-} // namespace extra2d
diff --git a/include/scene/sprite.h b/include/scene/sprite.h
deleted file mode 100644
index 3b38ade..0000000
--- a/include/scene/sprite.h
+++ /dev/null
@@ -1,55 +0,0 @@
-#pragma once
-
-#include <graphics/texture.h>
-#include <scene/node.h>
-
-namespace extra2d {
-
-// ============================================================================
-// 精灵节点
-// ============================================================================
-class Sprite : public Node {
-public:
-  Sprite();
-  explicit Sprite(IntrusivePtr<Texture> texture);
-  ~Sprite() override = default;
-
-  // 纹理
-  void setTexture(IntrusivePtr<Texture> texture);
-  IntrusivePtr<Texture> getTexture() const { return texture_; }
-
-  // 纹理矩形 (用于图集)
-  void setTextureRect(const Rect &rect);
-  Rect getTextureRect() const { return textureRect_; }
-
-  // 颜色混合
-  void setColor(const Color &color);
-  Color getColor() const { return color_; }
-
-  // 翻转
-  void setFlipX(bool flip);
-  void setFlipY(bool flip);
-  bool flipX() const { return flipX_; }
-  bool flipY() const { return flipY_; }
-
-  // 静态创建方法
-  static IntrusivePtr<Sprite> create();
-  static IntrusivePtr<Sprite> create(IntrusivePtr<Texture> texture);
-  static IntrusivePtr<Sprite> create(IntrusivePtr<Texture> texture, const Rect &rect);
-
-  Rect boundingBox() const override;
-
-protected:
-  void onDraw(Renderer &renderer) override;
-  void generateRenderCommand(std::vector<RenderCommand> &commands,
-                             int zOrder) override;
-
-private:
-  IntrusivePtr<Texture> texture_;
-  Rect textureRect_;
-  Color color_ = Colors::White;
-  bool flipX_ = false;
-  bool flipY_ = false;
-};
-
-} // namespace extra2d
diff --git a/src/app/application.cpp b/src/app/application.cpp
index 4b6d1ca..000bdc5 100644
--- a/src/app/application.cpp
+++ b/src/app/application.cpp
@@ -2,17 +2,11 @@
 #include <audio/audio_engine.h>
 #include <event/event_dispatcher.h>
 #include <event/event_queue.h>
-#include <graphics/vram_manager.h>
 #include <platform/input.h>
 #include <platform/window.h>
-#include <renderer/camera.h>
-#include <renderer/renderer.h>
-#include <resource/resource_manager.h>
-#include <scene/scene_manager.h>
 #include <utils/logger.h>
 #include <utils/timer.h>
 
-
 #include <chrono>
 #include <thread>
 
@@ -22,7 +16,9 @@
 
 namespace extra2d {
 
-// 获取当前时间（秒）
+/**
+ * @brief 获取当前时间（秒）
+ */
 static double getTimeSeconds() {
 #ifdef __SWITCH__
   struct timespec ts;
@@ -30,7 +26,6 @@ static double getTimeSeconds() {
   return static_cast<double>(ts.tv_sec) +
          static_cast<double>(ts.tv_nsec) / 1000000000.0;
 #else
-  // PC 平台使用 chrono
   using namespace std::chrono;
   auto now = steady_clock::now();
   auto duration = now.time_since_epoch();
@@ -53,7 +48,6 @@ bool Application::init(const AppConfig &config) {
 
   config_ = config;
 
-  // 确定平台类型
   PlatformType platform = config_.platform;
   if (platform == PlatformType::Auto) {
 #ifdef __SWITCH__
@@ -65,9 +59,6 @@ bool Application::init(const AppConfig &config) {
 
   if (platform == PlatformType::Switch) {
 #ifdef __SWITCH__
-    // ========================================
-    // 1. 初始化 RomFS 文件系统（Switch 平台）
-    // ========================================
     Result rc;
     rc = romfsInit();
     if (R_SUCCEEDED(rc)) {
@@ -77,9 +68,6 @@ bool Application::init(const AppConfig &config) {
                    rc);
     }
 
-    // ========================================
-    // 2. 初始化 nxlink 调试输出（Switch 平台）
-    // ========================================
     rc = socketInitializeDefault();
     if (R_FAILED(rc)) {
       E2D_LOG_WARN(
@@ -88,9 +76,6 @@ bool Application::init(const AppConfig &config) {
 #endif
   }
 
-  // ========================================
-  // 3. 创建窗口（包含 SDL_Init + GLES 3.2 上下文创建）
-  // ========================================
   window_ = unique<Window>();
   WindowConfig winConfig;
   winConfig.title = config.title;
@@ -98,12 +83,11 @@ bool Application::init(const AppConfig &config) {
   winConfig.height = config.height;
   if (platform == PlatformType::Switch) {
     winConfig.fullscreen = true;
-    winConfig.fullscreenDesktop = false; // Switch 使用固定分辨率全屏
+    winConfig.fullscreenDesktop = false;
     winConfig.resizable = false;
     winConfig.enableCursors = false;
     winConfig.enableDpiScale = false;
   } else {
-    // PC 平台默认窗口模式
     winConfig.fullscreen = config.fullscreen;
     winConfig.resizable = config.resizable;
     winConfig.enableCursors = config.enableCursors;
@@ -117,43 +101,10 @@ bool Application::init(const AppConfig &config) {
     return false;
   }
 
-  // ========================================
-  // 4. 初始化渲染器
-  // ========================================
-  renderer_ = Renderer::create(config.Renderer);
-  if (!renderer_ || !renderer_->init(window_.get())) {
-    E2D_LOG_ERROR("Failed to initialize renderer");
-    window_->destroy();
-    return false;
-  }
-
-  // ========================================
-  // 5. 初始化其他子系统
-  // ========================================
-  sceneManager_ = unique<SceneManager>();
-  resourceManager_ = unique<ResourceManager>();
   timerManager_ = unique<TimerManager>();
   eventQueue_ = unique<EventQueue>();
   eventDispatcher_ = unique<EventDispatcher>();
-  camera_ = unique<Camera>(0, static_cast<float>(window_->width()),
-                           static_cast<float>(window_->height()), 0);
 
-  // 窗口大小回调
-  window_->setResizeCallback([this](int width, int height) {
-    if (camera_) {
-      camera_->setViewport(0, static_cast<float>(width),
-                           static_cast<float>(height), 0);
-    }
-    if (sceneManager_) {
-      auto currentScene = sceneManager_->getCurrentScene();
-      if (currentScene) {
-        currentScene->setViewportSize(static_cast<float>(width),
-                                      static_cast<float>(height));
-      }
-    }
-  });
-
-  // 初始化音频引擎
   AudioEngine::getInstance().initialize();
 
   initialized_ = true;
@@ -169,50 +120,17 @@ void Application::shutdown() {
 
   E2D_LOG_INFO("Shutting down application...");
 
-  // 打印 VRAM 统计
-  VRAMManager::getInstance().printStats();
-
-  // 先结束所有场景，确保 onExit() 被正确调用
-  if (sceneManager_) {
-    sceneManager_->end();
-  }
-
-  // ========================================
-  // 1. 先清理所有持有 GPU 资源的子系统
-  // 必须在渲染器关闭前释放纹理等资源
-  // ========================================
-  sceneManager_.reset();    // 场景持有纹理引用
-  resourceManager_.reset(); // 纹理缓存持有 GPU 纹理
-  camera_.reset();          // 相机可能持有渲染目标
-
-  // ========================================
-  // 2. 关闭音频（不依赖 GPU）
-  // ========================================
   AudioEngine::getInstance().shutdown();
 
-  // ========================================
-  // 3. 清理其他子系统
-  // ========================================
   timerManager_.reset();
   eventQueue_.reset();
   eventDispatcher_.reset();
 
-  // ========================================
-  // 4. 最后关闭渲染器和窗口
-  // 必须在所有 GPU 资源释放后才能关闭 OpenGL 上下文
-  // ========================================
-  if (renderer_) {
-    renderer_->shutdown();
-    renderer_.reset();
-  }
-
-  // 销毁窗口（包含 SDL_Quit，会销毁 OpenGL 上下文）
   if (window_) {
     window_->destroy();
     window_.reset();
   }
 
-  // Switch 平台清理
   PlatformType platform = config_.platform;
   if (platform == PlatformType::Auto) {
 #ifdef __SWITCH__
@@ -243,12 +161,10 @@ void Application::run() {
   lastFrameTime_ = getTimeSeconds();
 
 #ifdef __SWITCH__
-  // SDL2 on Switch 内部已处理 appletMainLoop
   while (running_ && !window_->shouldClose()) {
     mainLoop();
   }
 #else
-  // PC 平台主循环
   while (running_ && !window_->shouldClose()) {
     mainLoop();
   }
@@ -276,14 +192,12 @@ void Application::resume() {
 }
 
 void Application::mainLoop() {
-  // 计算 delta time
   double currentTime = getTimeSeconds();
   deltaTime_ = static_cast<float>(currentTime - lastFrameTime_);
   lastFrameTime_ = currentTime;
 
   totalTime_ += deltaTime_;
 
-  // 计算 FPS
   frameCount_++;
   fpsTimer_ += deltaTime_;
   if (fpsTimer_ >= 1.0f) {
@@ -292,21 +206,17 @@ void Application::mainLoop() {
     fpsTimer_ -= 1.0f;
   }
 
-  // 处理窗口事件（SDL_PollEvent + 输入更新）
   window_->pollEvents();
 
-  // 处理事件队列
   if (eventDispatcher_ && eventQueue_) {
     eventDispatcher_->processQueue(*eventQueue_);
   }
 
-  // 更新
   if (!paused_) {
     update();
   }
 
-  // 渲染
-  render();
+  window_->swapBuffers();
 
   if (!config_.vsync && config_.fpsLimit > 0) {
     double frameEndTime = getTimeSeconds();
@@ -323,51 +233,16 @@ void Application::update() {
   if (timerManager_) {
     timerManager_->update(deltaTime_);
   }
-
-  if (sceneManager_) {
-    sceneManager_->update(deltaTime_);
-  }
-}
-
-void Application::render() {
-  if (!renderer_) {
-    E2D_LOG_ERROR("Render failed: renderer is null");
-    return;
-  }
-
-  renderer_->setViewport(0, 0, window_->width(), window_->height());
-
-  if (sceneManager_) {
-    sceneManager_->render(*renderer_);
-  } else {
-    E2D_LOG_WARN("Render: sceneManager is null");
-  }
-
-  window_->swapBuffers();
 }
 
 Input &Application::input() { return *window_->getInput(); }
 
 AudioEngine &Application::audio() { return AudioEngine::getInstance(); }
 
-SceneManager &Application::scenes() { return *sceneManager_; }
-
-ResourceManager &Application::resources() { return *resourceManager_; }
-
 TimerManager &Application::timers() { return *timerManager_; }
 
 EventQueue &Application::eventQueue() { return *eventQueue_; }
 
 EventDispatcher &Application::eventDispatcher() { return *eventDispatcher_; }
 
-Camera &Application::camera() { return *camera_; }
-
-void Application::enterScene(IntrusivePtr<Scene> scene) {
-  if (sceneManager_ && scene) {
-    scene->setViewportSize(static_cast<float>(window_->width()),
-                           static_cast<float>(window_->height()));
-    sceneManager_->enterScene(scene);
-  }
-}
-
 } // namespace extra2d
diff --git a/src/graphics/alpha_mask.cpp b/src/graphics/alpha_mask.cpp
deleted file mode 100644
index 2a5efe0..0000000
--- a/src/graphics/alpha_mask.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#include <graphics/alpha_mask.h>
-
-namespace extra2d {
-
-AlphaMask::AlphaMask(int width, int height)
-    : width_(width), height_(height), data_(width * height, 255) {}
-
-AlphaMask AlphaMask::createFromPixels(const uint8_t *pixels, int width,
-                                      int height, int channels) {
-  AlphaMask mask(width, height);
-
-  if (!pixels || width <= 0 || height <= 0) {
-    return mask;
-  }
-
-  // 根据通道数提取Alpha值
-  for (int y = 0; y < height; ++y) {
-    for (int x = 0; x < width; ++x) {
-      int pixelIndex = (y * width + x) * channels;
-      uint8_t alpha = 255;
-
-      if (channels == 4) {
-        // RGBA格式，Alpha在第四个通道
-        alpha = pixels[pixelIndex + 3];
-      } else if (channels == 1) {
-        // 灰度图，直接作为Alpha
-        alpha = pixels[pixelIndex];
-      } else if (channels == 3) {
-        // RGB格式，没有Alpha通道，视为不透明
-        alpha = 255;
-      }
-
-      mask.data_[y * width + x] = alpha;
-    }
-  }
-
-  return mask;
-}
-
-uint8_t AlphaMask::getAlpha(int x, int y) const {
-  if (!isValid(x, y)) {
-    return 0;
-  }
-  return data_[y * width_ + x];
-}
-
-bool AlphaMask::isOpaque(int x, int y, uint8_t threshold) const {
-  return getAlpha(x, y) >= threshold;
-}
-
-bool AlphaMask::isValid(int x, int y) const {
-  return x >= 0 && x < width_ && y >= 0 && y < height_;
-}
-
-} // namespace extra2d
diff --git a/src/graphics/gpu_context.cpp b/src/graphics/gpu_context.cpp
deleted file mode 100644
index 9aaf161..0000000
--- a/src/graphics/gpu_context.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include <graphics/gpu_context.h>
-
-namespace extra2d {
-
-GPUContext& GPUContext::getInstance() {
-    static GPUContext instance;
-    return instance;
-}
-
-void GPUContext::markValid() {
-    valid_.store(true, std::memory_order_release);
-}
-
-void GPUContext::markInvalid() {
-    valid_.store(false, std::memory_order_release);
-}
-
-bool GPUContext::isValid() const {
-    return valid_.load(std::memory_order_acquire);
-}
-
-} // namespace extra2d
diff --git a/src/graphics/opengl/gl_font_atlas.cpp b/src/graphics/opengl/gl_font_atlas.cpp
deleted file mode 100644
index 19ac639..0000000
--- a/src/graphics/opengl/gl_font_atlas.cpp
+++ /dev/null
@@ -1,330 +0,0 @@
-#include <graphics/opengl/gl_font_atlas.h>
-#include <utils/logger.h>
-#include <string>
-#include <fstream>
-#define STB_TRUETYPE_IMPLEMENTATION
-#include <stb/stb_truetype.h>
-#define STB_RECT_PACK_IMPLEMENTATION
-#include <stb/stb_rect_pack.h>
-#include <algorithm>
-
-namespace extra2d {
-
-// ============================================================================
-// UTF-8 到 UTF-32 转换（简化版）
-// ============================================================================
-static std::u32string utf8ToUtf32(const std::string& utf8) {
-    std::u32string result;
-    result.reserve(utf8.size());
-
-    const char* ptr = utf8.c_str();
-    const char* end = ptr + utf8.size();
-
-    while (ptr < end) {
-        char32_t ch = 0;
-        unsigned char byte = static_cast<unsigned char>(*ptr);
-
-        if ((byte & 0x80) == 0) {
-            // 1-byte sequence
-            ch = byte;
-            ptr += 1;
-        } else if ((byte & 0xE0) == 0xC0) {
-            // 2-byte sequence
-            ch = (byte & 0x1F) << 6;
-            ch |= (static_cast<unsigned char>(ptr[1]) & 0x3F);
-            ptr += 2;
-        } else if ((byte & 0xF0) == 0xE0) {
-            // 3-byte sequence
-            ch = (byte & 0x0F) << 12;
-            ch |= (static_cast<unsigned char>(ptr[1]) & 0x3F) << 6;
-            ch |= (static_cast<unsigned char>(ptr[2]) & 0x3F);
-            ptr += 3;
-        } else if ((byte & 0xF8) == 0xF0) {
-            // 4-byte sequence
-            ch = (byte & 0x07) << 18;
-            ch |= (static_cast<unsigned char>(ptr[1]) & 0x3F) << 12;
-            ch |= (static_cast<unsigned char>(ptr[2]) & 0x3F) << 6;
-            ch |= (static_cast<unsigned char>(ptr[3]) & 0x3F);
-            ptr += 4;
-        } else {
-            // Invalid UTF-8, skip
-            ptr += 1;
-            continue;
-        }
-
-        result.push_back(ch);
-    }
-
-    return result;
-}
-
-// ============================================================================
-// 构造函数 - 初始化字体图集
-// ============================================================================
-GLFontAtlas::GLFontAtlas(const std::string &filepath, int fontSize, bool useSDF)
-    : fontSize_(fontSize), useSDF_(useSDF), currentY_(0), scale_(0.0f),
-      ascent_(0.0f), descent_(0.0f), lineGap_(0.0f) {
-
-  // 加载字体文件
-  std::ifstream file(filepath, std::ios::binary | std::ios::ate);
-  if (!file.is_open()) {
-    E2D_LOG_ERROR("Failed to load font: {}", filepath);
-    return;
-  }
-
-  std::streamsize size = file.tellg();
-  file.seekg(0, std::ios::beg);
-  fontData_.resize(size);
-  if (!file.read(reinterpret_cast<char *>(fontData_.data()), size)) {
-    E2D_LOG_ERROR("Failed to read font file: {}", filepath);
-    return;
-  }
-
-  // 初始化 stb_truetype
-  if (!stbtt_InitFont(&fontInfo_, fontData_.data(),
-                      stbtt_GetFontOffsetForIndex(fontData_.data(), 0))) {
-    E2D_LOG_ERROR("Failed to init font: {}", filepath);
-    return;
-  }
-
-  scale_ = stbtt_ScaleForPixelHeight(&fontInfo_, static_cast<float>(fontSize_));
-
-  int ascent, descent, lineGap;
-  stbtt_GetFontVMetrics(&fontInfo_, &ascent, &descent, &lineGap);
-  ascent_ = static_cast<float>(ascent) * scale_;
-  descent_ = static_cast<float>(descent) * scale_;
-  lineGap_ = static_cast<float>(lineGap) * scale_;
-
-  createAtlas();
-}
-
-// ============================================================================
-// 析构函数
-// ============================================================================
-GLFontAtlas::~GLFontAtlas() = default;
-
-// ============================================================================
-// 获取字形 - 如果字形不存在则缓存它
-// ============================================================================
-const Glyph *GLFontAtlas::getGlyph(char32_t codepoint) const {
-  auto it = glyphs_.find(codepoint);
-  if (it == glyphs_.end()) {
-    cacheGlyph(codepoint);
-    it = glyphs_.find(codepoint);
-  }
-  return (it != glyphs_.end()) ? &it->second : nullptr;
-}
-
-// ============================================================================
-// 测量文本尺寸
-// ============================================================================
-Vec2 GLFontAtlas::measureText(const std::string &text) {
-  float width = 0.0f;
-  float height = getAscent() - getDescent();
-  float currentWidth = 0.0f;
-
-  for (char32_t codepoint : utf8ToUtf32(text)) {
-    if (codepoint == '\n') {
-      width = std::max(width, currentWidth);
-      currentWidth = 0.0f;
-      height += getLineHeight();
-      continue;
-    }
-
-    const Glyph *glyph = getGlyph(codepoint);
-    if (glyph) {
-      currentWidth += glyph->advance;
-    }
-  }
-
-  width = std::max(width, currentWidth);
-  return Vec2(width, height);
-}
-
-// ============================================================================
-// 创建图集纹理 - 初始化空白纹理和矩形打包上下文
-// ============================================================================
-void GLFontAtlas::createAtlas() {
-  // 统一使用 4 通道格式
-  int channels = 4;
-  std::vector<uint8_t> emptyData(ATLAS_WIDTH * ATLAS_HEIGHT * channels, 0);
-  texture_ = std::make_unique<GLTexture>(ATLAS_WIDTH, ATLAS_HEIGHT,
-                                         emptyData.data(), channels);
-  texture_->setFilter(true);
-
-  // 初始化矩形打包上下文
-  packNodes_.resize(ATLAS_WIDTH);
-  stbrp_init_target(&packContext_, ATLAS_WIDTH, ATLAS_HEIGHT, packNodes_.data(),
-                    ATLAS_WIDTH);
-  
-  // 预分配字形缓冲区
-  // 假设最大字形尺寸为 fontSize * fontSize * 4 (RGBA)
-  size_t maxGlyphSize = static_cast<size_t>(fontSize_ * fontSize_ * 4 * 4);
-  glyphBitmapCache_.reserve(maxGlyphSize);
-  glyphRgbaCache_.reserve(maxGlyphSize);
-}
-
-// ============================================================================
-// 缓存字形 - 渲染字形到图集并存储信息
-// 使用 stb_rect_pack 进行矩形打包
-// ============================================================================
-void GLFontAtlas::cacheGlyph(char32_t codepoint) const {
-  int advance = 0;
-  stbtt_GetCodepointHMetrics(&fontInfo_, static_cast<int>(codepoint), &advance,
-                             nullptr);
-  float advancePx = advance * scale_;
-
-  if (useSDF_) {
-    constexpr int SDF_PADDING = 8;
-    constexpr unsigned char ONEDGE_VALUE = 128;
-    constexpr float PIXEL_DIST_SCALE = 64.0f;
-
-    int w = 0, h = 0, xoff = 0, yoff = 0;
-    unsigned char *sdf = stbtt_GetCodepointSDF(
-        &fontInfo_, scale_, static_cast<int>(codepoint), SDF_PADDING,
-        ONEDGE_VALUE, PIXEL_DIST_SCALE, &w, &h, &xoff, &yoff);
-    if (!sdf || w <= 0 || h <= 0) {
-      if (sdf)
-        stbtt_FreeSDF(sdf, nullptr);
-      Glyph glyph{};
-      glyph.advance = advancePx;
-      glyphs_[codepoint] = glyph;
-      return;
-    }
-
-    stbrp_rect rect;
-    rect.id = static_cast<int>(codepoint);
-    rect.w = w + PADDING * 2;
-    rect.h = h + PADDING * 2;
-
-    stbrp_pack_rects(&packContext_, &rect, 1);
-    if (!rect.was_packed) {
-      E2D_LOG_WARN("Font atlas is full, cannot cache codepoint: {}",
-                   static_cast<int>(codepoint));
-      stbtt_FreeSDF(sdf, nullptr);
-      return;
-    }
-
-    int atlasX = rect.x + PADDING;
-    int atlasY = rect.y + PADDING;
-
-    Glyph glyph;
-    glyph.width = static_cast<float>(w);
-    glyph.height = static_cast<float>(h);
-    glyph.bearingX = static_cast<float>(xoff);
-    glyph.bearingY = static_cast<float>(yoff);
-    glyph.advance = advancePx;
-
-    // stb_rect_pack 使用左上角为原点，OpenGL纹理使用左下角为原点
-    // 需要翻转V坐标
-    float v0 = static_cast<float>(atlasY) / ATLAS_HEIGHT;
-    float v1 = static_cast<float>(atlasY + h) / ATLAS_HEIGHT;
-    glyph.u0 = static_cast<float>(atlasX) / ATLAS_WIDTH;
-    glyph.v0 = 1.0f - v1; // 翻转V坐标
-    glyph.u1 = static_cast<float>(atlasX + w) / ATLAS_WIDTH;
-    glyph.v1 = 1.0f - v0; // 翻转V坐标
-
-    glyphs_[codepoint] = glyph;
-
-    // 将 SDF 单通道数据转换为 RGBA 格式（统一格式）
-    size_t pixelCount = static_cast<size_t>(w) * static_cast<size_t>(h);
-    glyphRgbaCache_.resize(pixelCount * 4);
-    for (size_t i = 0; i < pixelCount; ++i) {
-      uint8_t alpha = sdf[i];
-      glyphRgbaCache_[i * 4 + 0] = 255;   // R
-      glyphRgbaCache_[i * 4 + 1] = 255;   // G
-      glyphRgbaCache_[i * 4 + 2] = 255;   // B
-      glyphRgbaCache_[i * 4 + 3] = alpha; // A - SDF 值存储在 Alpha 通道
-    }
-
-    // 直接设置像素对齐为 4，无需查询当前状态
-    glBindTexture(GL_TEXTURE_2D, texture_->getTextureID());
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
-    // OpenGL纹理坐标原点在左下角，需要将Y坐标翻转
-    glTexSubImage2D(GL_TEXTURE_2D, 0, atlasX, ATLAS_HEIGHT - atlasY - h, w, h,
-                    GL_RGBA, GL_UNSIGNED_BYTE, glyphRgbaCache_.data());
-
-    stbtt_FreeSDF(sdf, nullptr);
-    return;
-  }
-
-  int x0 = 0, y0 = 0, x1 = 0, y1 = 0;
-  stbtt_GetCodepointBitmapBox(&fontInfo_, static_cast<int>(codepoint), scale_,
-                              scale_, &x0, &y0, &x1, &y1);
-  int w = x1 - x0;
-  int h = y1 - y0;
-  int xoff = x0;
-  int yoff = y0;
-
-  if (w <= 0 || h <= 0) {
-    Glyph glyph{};
-    glyph.advance = advancePx;
-    glyphs_[codepoint] = glyph;
-    return;
-  }
-
-  // 使用预分配缓冲区
-  size_t pixelCount = static_cast<size_t>(w) * static_cast<size_t>(h);
-  glyphBitmapCache_.resize(pixelCount);
-  stbtt_MakeCodepointBitmap(&fontInfo_, glyphBitmapCache_.data(), w, h, w, scale_, scale_,
-                            static_cast<int>(codepoint));
-
-  // 使用 stb_rect_pack 打包矩形
-  stbrp_rect rect;
-  rect.id = static_cast<int>(codepoint);
-  rect.w = w + PADDING * 2;
-  rect.h = h + PADDING * 2;
-
-  stbrp_pack_rects(&packContext_, &rect, 1);
-
-  if (!rect.was_packed) {
-    // 图集已满，无法缓存更多字形
-    E2D_LOG_WARN("Font atlas is full, cannot cache codepoint: {}",
-                 static_cast<int>(codepoint));
-    return;
-  }
-
-  int atlasX = rect.x + PADDING;
-  int atlasY = rect.y + PADDING;
-
-  // 创建字形信息
-  Glyph glyph;
-  glyph.width = static_cast<float>(w);
-  glyph.height = static_cast<float>(h);
-  glyph.bearingX = static_cast<float>(xoff);
-  glyph.bearingY = static_cast<float>(yoff);
-  glyph.advance = advancePx;
-
-  // 计算纹理坐标（相对于图集）
-  // stb_rect_pack 使用左上角为原点，OpenGL纹理使用左下角为原点
-  // 需要翻转V坐标
-  float v0 = static_cast<float>(atlasY) / ATLAS_HEIGHT;
-  float v1 = static_cast<float>(atlasY + h) / ATLAS_HEIGHT;
-  glyph.u0 = static_cast<float>(atlasX) / ATLAS_WIDTH;
-  glyph.v0 = 1.0f - v1; // 翻转V坐标
-  glyph.u1 = static_cast<float>(atlasX + w) / ATLAS_WIDTH;
-  glyph.v1 = 1.0f - v0; // 翻转V坐标
-
-  // 存储字形
-  glyphs_[codepoint] = glyph;
-
-  // 将单通道字形数据转换为 RGBA 格式（白色字形，Alpha 通道存储灰度）
-  glyphRgbaCache_.resize(pixelCount * 4);
-  for (size_t i = 0; i < pixelCount; ++i) {
-    uint8_t alpha = glyphBitmapCache_[i];
-    glyphRgbaCache_[i * 4 + 0] = 255;   // R
-    glyphRgbaCache_[i * 4 + 1] = 255;   // G
-    glyphRgbaCache_[i * 4 + 2] = 255;   // B
-    glyphRgbaCache_[i * 4 + 3] = alpha; // A
-  }
-
-  // 更新纹理 - 将字形数据上传到图集的指定位置
-  // 直接设置像素对齐为 4，无需查询当前状态
-  glBindTexture(GL_TEXTURE_2D, texture_->getTextureID());
-  glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
-  // OpenGL纹理坐标原点在左下角，需要将Y坐标翻转
-  glTexSubImage2D(GL_TEXTURE_2D, 0, atlasX, ATLAS_HEIGHT - atlasY - h, w, h,
-                  GL_RGBA, GL_UNSIGNED_BYTE, glyphRgbaCache_.data());
-}
-
-} // namespace extra2d
diff --git a/src/graphics/opengl/gl_renderer.cpp b/src/graphics/opengl/gl_renderer.cpp
deleted file mode 100644
index 04004fb..0000000
--- a/src/graphics/opengl/gl_renderer.cpp
+++ /dev/null
@@ -1,674 +0,0 @@
-#include <SDL.h>
-#include <algorithm>
-#include <cmath>
-#include <cstring>
-#include <string>
-#include <graphics/gpu_context.h>
-#include <graphics/opengl/gl_font_atlas.h>
-#include <graphics/opengl/gl_renderer.h>
-#include <graphics/opengl/gl_texture.h>
-#include <graphics/vram_manager.h>
-#include <platform/window.h>
-#include <utils/logger.h>
-#include <vector>
-
-namespace extra2d {
-
-// ============================================================================
-// UTF-8 到 UTF-32 转换（简化版）
-// ============================================================================
-static std::u32string utf8ToUtf32(const std::string& utf8) {
-    std::u32string result;
-    result.reserve(utf8.size());
-
-    const char* ptr = utf8.c_str();
-    const char* end = ptr + utf8.size();
-
-    while (ptr < end) {
-        char32_t ch = 0;
-        unsigned char byte = static_cast<unsigned char>(*ptr);
-
-        if ((byte & 0x80) == 0) {
-            // 1-byte sequence
-            ch = byte;
-            ptr += 1;
-        } else if ((byte & 0xE0) == 0xC0) {
-            // 2-byte sequence
-            ch = (byte & 0x1F) << 6;
-            ch |= (static_cast<unsigned char>(ptr[1]) & 0x3F);
-            ptr += 2;
-        } else if ((byte & 0xF0) == 0xE0) {
-            // 3-byte sequence
-            ch = (byte & 0x0F) << 12;
-            ch |= (static_cast<unsigned char>(ptr[1]) & 0x3F) << 6;
-            ch |= (static_cast<unsigned char>(ptr[2]) & 0x3F);
-            ptr += 3;
-        } else if ((byte & 0xF8) == 0xF0) {
-            // 4-byte sequence
-            ch = (byte & 0x07) << 18;
-            ch |= (static_cast<unsigned char>(ptr[1]) & 0x3F) << 12;
-            ch |= (static_cast<unsigned char>(ptr[2]) & 0x3F) << 6;
-            ch |= (static_cast<unsigned char>(ptr[3]) & 0x3F);
-            ptr += 4;
-        } else {
-            // Invalid UTF-8, skip
-            ptr += 1;
-            continue;
-        }
-
-        result.push_back(ch);
-    }
-
-    return result;
-}
-
-// 形状渲染着色器 - 支持顶点颜色批处理 (GLES 3.2)
-static const char *SHAPE_VERTEX_SHADER = R"(
-#version 300 es
-precision highp float;
-layout(location = 0) in vec2 aPosition;
-layout(location = 1) in vec4 aColor;
-uniform mat4 uViewProjection;
-out vec4 vColor;
-void main() {
-    gl_Position = uViewProjection * vec4(aPosition, 0.0, 1.0);
-    vColor = aColor;
-}
-)";
-
-static const char *SHAPE_FRAGMENT_SHADER = R"(
-#version 300 es
-precision highp float;
-in vec4 vColor;
-out vec4 fragColor;
-void main() {
-    fragColor = vColor;
-}
-)";
-
-// VBO 初始大小（用于 VRAM 跟踪）
-static constexpr size_t SHAPE_VBO_SIZE = 1024 * sizeof(float);
-
-// ============================================================================
-// BlendMode 查找表 - 编译期构建，运行时 O(1) 查找
-// ============================================================================
-struct BlendState {
-  bool enable;
-  GLenum srcFactor;
-  GLenum dstFactor;
-};
-
-static constexpr BlendState BLEND_STATES[] = {
-    {false, 0, 0},                                // BlendMode::None
-    {true, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA}, // BlendMode::Alpha
-    {true, GL_SRC_ALPHA, GL_ONE},                 // BlendMode::Additive
-    {true, GL_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA}  // BlendMode::Multiply
-};
-
-static constexpr size_t BLEND_STATE_COUNT =
-    sizeof(BLEND_STATES) / sizeof(BLEND_STATES[0]);
-
-GLRenderer::GLRenderer()
-    : window_(nullptr), shapeVao_(0), shapeVbo_(0), lineVao_(0), lineVbo_(0),
-      vsync_(true), shapeVertexCount_(0), currentShapeMode_(GL_TRIANGLES),
-      lineVertexCount_(0), currentLineWidth_(1.0f) {
-  resetStats();
-  for (auto &v : shapeVertexCache_) {
-    v = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
-  }
-  for (auto &v : lineVertexCache_) {
-    v = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
-  }
-}
-
-GLRenderer::~GLRenderer() { shutdown(); }
-
-bool GLRenderer::init(Window *window) {
-  window_ = window;
-
-  // Switch: GL 上下文已通过 SDL2 + EGL 初始化，无需 glewInit()
-
-  // 初始化精灵批渲染器
-  if (!spriteBatch_.init()) {
-    E2D_LOG_ERROR("Failed to initialize sprite batch");
-    return false;
-  }
-
-  // 初始化形状渲染
-  initShapeRendering();
-
-  // 设置 OpenGL 状态
-  glEnable(GL_BLEND);
-  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-
-  // 标记 GPU 上下文为有效
-  GPUContext::getInstance().markValid();
-
-  E2D_LOG_INFO("OpenGL Renderer initialized");
-  E2D_LOG_INFO("OpenGL Version: {}",
-               reinterpret_cast<const char *>(glGetString(GL_VERSION)));
-
-  return true;
-}
-
-void GLRenderer::shutdown() {
-  // 标记 GPU 上下文为无效
-  // 这会在销毁 OpenGL 上下文之前通知所有 GPU 资源
-  GPUContext::getInstance().markInvalid();
-
-  spriteBatch_.shutdown();
-
-  if (lineVbo_ != 0) {
-    glDeleteBuffers(1, &lineVbo_);
-    VRAMManager::getInstance().freeBuffer(MAX_LINE_VERTICES *
-                                          sizeof(ShapeVertex));
-    lineVbo_ = 0;
-  }
-  if (lineVao_ != 0) {
-    glDeleteVertexArrays(1, &lineVao_);
-    lineVao_ = 0;
-  }
-  if (shapeVbo_ != 0) {
-    glDeleteBuffers(1, &shapeVbo_);
-    VRAMManager::getInstance().freeBuffer(MAX_SHAPE_VERTICES *
-                                          sizeof(ShapeVertex));
-    shapeVbo_ = 0;
-  }
-  if (shapeVao_ != 0) {
-    glDeleteVertexArrays(1, &shapeVao_);
-    shapeVao_ = 0;
-  }
-}
-
-void GLRenderer::beginFrame(const Color &clearColor) {
-  glClearColor(clearColor.r, clearColor.g, clearColor.b, clearColor.a);
-  glClear(GL_COLOR_BUFFER_BIT);
-  resetStats();
-}
-
-void GLRenderer::endFrame() {
-  // 刷新所有待处理的形状批次
-  flushShapeBatch();
-  // 刷新所有待处理的线条批次
-  flushLineBatch();
-}
-
-void GLRenderer::setViewport(int x, int y, int width, int height) {
-  glViewport(x, y, width, height);
-}
-
-void GLRenderer::setVSync(bool enabled) {
-  vsync_ = enabled;
-  // 使用 SDL2 设置交换间隔
-  SDL_GL_SetSwapInterval(enabled ? 1 : 0);
-}
-
-void GLRenderer::setBlendMode(BlendMode mode) {
-  // 状态缓存检查，避免冗余 GL 调用
-  if (cachedBlendMode_ == mode) {
-    return;
-  }
-  cachedBlendMode_ = mode;
-
-  // 使用查找表替代 switch
-  size_t index = static_cast<size_t>(mode);
-  if (index >= BLEND_STATE_COUNT) {
-    index = 0;
-  }
-
-  const BlendState &state = BLEND_STATES[index];
-  if (state.enable) {
-    if (!blendEnabled_) {
-      glEnable(GL_BLEND);
-      blendEnabled_ = true;
-    }
-    glBlendFunc(state.srcFactor, state.dstFactor);
-  } else {
-    if (blendEnabled_) {
-      glDisable(GL_BLEND);
-      blendEnabled_ = false;
-    }
-  }
-}
-
-void GLRenderer::setViewProjection(const glm::mat4 &matrix) {
-  viewProjection_ = matrix;
-}
-
-void GLRenderer::pushTransform(const glm::mat4 &transform) {
-  if (transformStack_.empty()) {
-    transformStack_.push_back(transform);
-  } else {
-    transformStack_.push_back(transformStack_.back() * transform);
-  }
-}
-
-void GLRenderer::popTransform() {
-  if (!transformStack_.empty()) {
-    transformStack_.pop_back();
-  }
-}
-
-glm::mat4 GLRenderer::getCurrentTransform() const {
-  if (transformStack_.empty()) {
-    return glm::mat4(1.0f);
-  }
-  return transformStack_.back();
-}
-
-IntrusivePtr<Texture> GLRenderer::createTexture(int width, int height,
-                                       const uint8_t *pixels, int channels) {
-  return makeRef<GLTexture>(width, height, pixels, channels);
-}
-
-IntrusivePtr<Texture> GLRenderer::loadTexture(const std::string &filepath) {
-  return makeRef<GLTexture>(filepath);
-}
-
-void GLRenderer::beginSpriteBatch() { spriteBatch_.begin(viewProjection_); }
-
-void GLRenderer::drawSprite(const Texture &texture, const Rect &destRect,
-                            const Rect &srcRect, const Color &tint,
-                            float rotation, const Vec2 &anchor) {
-  GLSpriteBatch::SpriteData data;
-  data.position = glm::vec2(destRect.origin.x, destRect.origin.y);
-  data.size = glm::vec2(destRect.size.width, destRect.size.height);
-
-  Texture *tex = const_cast<Texture *>(&texture);
-  float texW = static_cast<float>(tex->width());
-  float texH = static_cast<float>(tex->height());
-
-  // 纹理坐标计算
-  float u1 = srcRect.origin.x / texW;
-  float u2 = (srcRect.origin.x + srcRect.size.width) / texW;
-  float v1 = srcRect.origin.y / texH;
-  float v2 = (srcRect.origin.y + srcRect.size.height) / texH;
-
-  data.texCoordMin = glm::vec2(glm::min(u1, u2), glm::min(v1, v2));
-  data.texCoordMax = glm::vec2(glm::max(u1, u2), glm::max(v1, v2));
-
-  data.color = glm::vec4(tint.r, tint.g, tint.b, tint.a);
-  data.rotation = rotation * 3.14159f / 180.0f;
-  data.anchor = glm::vec2(anchor.x, anchor.y);
-  data.isSDF = false;
-
-  spriteBatch_.draw(texture, data);
-}
-
-void GLRenderer::drawSprite(const Texture &texture, const Vec2 &position,
-                            const Color &tint) {
-  Rect destRect(position.x, position.y, static_cast<float>(texture.width()),
-                static_cast<float>(texture.height()));
-  Rect srcRect(0, 0, static_cast<float>(texture.width()),
-               static_cast<float>(texture.height()));
-  drawSprite(texture, destRect, srcRect, tint, 0.0f, Vec2(0, 0));
-}
-
-void GLRenderer::endSpriteBatch() {
-  spriteBatch_.end();
-  stats_.drawCalls += spriteBatch_.getDrawCallCount();
-}
-
-void GLRenderer::drawLine(const Vec2 &start, const Vec2 &end,
-                          const Color &color, float width) {
-  // 如果线宽改变，需要先刷新线条批次
-  if (width != currentLineWidth_) {
-    flushLineBatch();
-    currentLineWidth_ = width;
-  }
-
-  // 添加两个顶点到线条缓冲区
-  addLineVertex(start.x, start.y, color);
-  addLineVertex(end.x, end.y, color);
-}
-
-void GLRenderer::drawRect(const Rect &rect, const Color &color, float width) {
-  // 如果线宽改变，需要先刷新线条批次
-  if (width != currentLineWidth_) {
-    flushLineBatch();
-    currentLineWidth_ = width;
-  }
-
-  float x1 = rect.origin.x;
-  float y1 = rect.origin.y;
-  float x2 = rect.origin.x + rect.size.width;
-  float y2 = rect.origin.y + rect.size.height;
-
-  // 4条线段 = 8个顶点
-  // 上边
-  addLineVertex(x1, y1, color);
-  addLineVertex(x2, y1, color);
-  // 右边
-  addLineVertex(x2, y1, color);
-  addLineVertex(x2, y2, color);
-  // 下边
-  addLineVertex(x2, y2, color);
-  addLineVertex(x1, y2, color);
-  // 左边
-  addLineVertex(x1, y2, color);
-  addLineVertex(x1, y1, color);
-}
-
-void GLRenderer::fillRect(const Rect &rect, const Color &color) {
-  // 提交当前批次（如果模式不同）
-  submitShapeBatch(GL_TRIANGLES);
-
-  // 添加两个三角形组成矩形（6个顶点）
-  float x1 = rect.origin.x;
-  float y1 = rect.origin.y;
-  float x2 = rect.origin.x + rect.size.width;
-  float y2 = rect.origin.y + rect.size.height;
-
-  // 三角形1: (x1,y1), (x2,y1), (x2,y2)
-  addShapeVertex(x1, y1, color);
-  addShapeVertex(x2, y1, color);
-  addShapeVertex(x2, y2, color);
-
-  // 三角形2: (x1,y1), (x2,y2), (x1,y2)
-  addShapeVertex(x1, y1, color);
-  addShapeVertex(x2, y2, color);
-  addShapeVertex(x1, y2, color);
-}
-
-void GLRenderer::drawCircle(const Vec2 &center, float radius,
-                            const Color &color, int segments, float width) {
-  // 限制段数不超过缓存大小
-  if (segments > static_cast<int>(MAX_CIRCLE_SEGMENTS)) {
-    segments = static_cast<int>(MAX_CIRCLE_SEGMENTS);
-  }
-
-  // 如果线宽改变，需要先刷新线条批次
-  if (width != currentLineWidth_) {
-    flushLineBatch();
-    currentLineWidth_ = width;
-  }
-
-  // 使用线条批处理绘制圆形
-  for (int i = 0; i < segments; ++i) {
-    float angle1 =
-        2.0f * 3.14159f * static_cast<float>(i) / static_cast<float>(segments);
-    float angle2 = 2.0f * 3.14159f * static_cast<float>(i + 1) /
-                   static_cast<float>(segments);
-
-    addLineVertex(center.x + radius * cosf(angle1),
-                  center.y + radius * sinf(angle1), color);
-    addLineVertex(center.x + radius * cosf(angle2),
-                  center.y + radius * sinf(angle2), color);
-  }
-}
-
-void GLRenderer::fillCircle(const Vec2 &center, float radius,
-                            const Color &color, int segments) {
-  // 限制段数不超过缓存大小
-  if (segments > static_cast<int>(MAX_CIRCLE_SEGMENTS)) {
-    segments = static_cast<int>(MAX_CIRCLE_SEGMENTS);
-  }
-
-  // 提交当前批次（如果模式不同）
-  submitShapeBatch(GL_TRIANGLES);
-
-  // 使用三角形扇形填充圆
-  // 中心点 + 边缘点
-  for (int i = 0; i < segments; ++i) {
-    float angle1 =
-        2.0f * 3.14159f * static_cast<float>(i) / static_cast<float>(segments);
-    float angle2 = 2.0f * 3.14159f * static_cast<float>(i + 1) /
-                   static_cast<float>(segments);
-
-    // 每个三角形：中心 -> 边缘点1 -> 边缘点2
-    addShapeVertex(center.x, center.y, color);
-    addShapeVertex(center.x + radius * cosf(angle1),
-                   center.y + radius * sinf(angle1), color);
-    addShapeVertex(center.x + radius * cosf(angle2),
-                   center.y + radius * sinf(angle2), color);
-  }
-}
-
-void GLRenderer::drawTriangle(const Vec2 &p1, const Vec2 &p2, const Vec2 &p3,
-                              const Color &color, float width) {
-  drawLine(p1, p2, color, width);
-  drawLine(p2, p3, color, width);
-  drawLine(p3, p1, color, width);
-}
-
-void GLRenderer::fillTriangle(const Vec2 &p1, const Vec2 &p2, const Vec2 &p3,
-                              const Color &color) {
-  submitShapeBatch(GL_TRIANGLES);
-
-  addShapeVertex(p1.x, p1.y, color);
-  addShapeVertex(p2.x, p2.y, color);
-  addShapeVertex(p3.x, p3.y, color);
-}
-
-void GLRenderer::drawPolygon(const std::vector<Vec2> &points,
-                             const Color &color, float width) {
-  if (points.size() < 2)
-    return;
-
-  // 如果线宽改变，需要先刷新线条批次
-  if (width != currentLineWidth_) {
-    flushLineBatch();
-    currentLineWidth_ = width;
-  }
-
-  // 绘制所有边
-  for (size_t i = 0; i < points.size(); ++i) {
-    const Vec2 &p1 = points[i];
-    const Vec2 &p2 = points[(i + 1) % points.size()];
-    addLineVertex(p1.x, p1.y, color);
-    addLineVertex(p2.x, p2.y, color);
-  }
-}
-
-void GLRenderer::fillPolygon(const std::vector<Vec2> &points,
-                             const Color &color) {
-  if (points.size() < 3)
-    return;
-
-  submitShapeBatch(GL_TRIANGLES);
-
-  // 使用三角形扇形填充
-  // 从第一个点开始，每两个相邻点组成一个三角形
-  for (size_t i = 1; i < points.size() - 1; ++i) {
-    addShapeVertex(points[0].x, points[0].y, color);
-    addShapeVertex(points[i].x, points[i].y, color);
-    addShapeVertex(points[i + 1].x, points[i + 1].y, color);
-  }
-}
-
-IntrusivePtr<FontAtlas> GLRenderer::createFontAtlas(const std::string &filepath,
-                                           int fontSize, bool useSDF) {
-  return makeRef<GLFontAtlas>(filepath, fontSize, useSDF);
-}
-
-void GLRenderer::drawText(const FontAtlas &font, const std::string &text,
-                          const Vec2 &position, const Color &color) {
-  drawText(font, text, position.x, position.y, color);
-}
-
-void GLRenderer::drawText(const FontAtlas &font, const std::string &text,
-                          float x, float y, const Color &color) {
-  float cursorX = x;
-  float cursorY = y;
-  float baselineY = cursorY + font.getAscent();
-
-  // 收集所有字符数据用于批处理
-  std::vector<GLSpriteBatch::SpriteData> sprites;
-  sprites.reserve(text.size()); // 预分配空间
-
-  for (char32_t codepoint : utf8ToUtf32(text)) {
-    if (codepoint == '\n') {
-      cursorX = x;
-      cursorY += font.getLineHeight();
-      baselineY = cursorY + font.getAscent();
-      continue;
-    }
-
-    const Glyph *glyph = font.getGlyph(codepoint);
-    if (glyph) {
-      float penX = cursorX;
-      cursorX += glyph->advance;
-
-      if (glyph->width <= 0.0f || glyph->height <= 0.0f) {
-        continue;
-      }
-
-      float xPos = penX + glyph->bearingX;
-      float yPos = baselineY + glyph->bearingY;
-
-      GLSpriteBatch::SpriteData data;
-      data.position = glm::vec2(xPos, yPos);
-      data.size = glm::vec2(glyph->width, glyph->height);
-      data.texCoordMin = glm::vec2(glyph->u0, glyph->v0);
-      data.texCoordMax = glm::vec2(glyph->u1, glyph->v1);
-      data.color = glm::vec4(color.r, color.g, color.b, color.a);
-      data.rotation = 0.0f;
-      data.anchor = glm::vec2(0.0f, 0.0f);
-      data.isSDF = font.isSDF();
-
-      sprites.push_back(data);
-    }
-  }
-
-  // 使用批处理绘制所有字符
-  if (!sprites.empty()) {
-    spriteBatch_.drawBatch(*font.getTexture(), sprites);
-  }
-}
-
-void GLRenderer::resetStats() { stats_ = Stats{}; }
-
-void GLRenderer::initShapeRendering() {
-  // 编译形状着色器
-  shapeShader_.compileFromSource(SHAPE_VERTEX_SHADER, SHAPE_FRAGMENT_SHADER);
-
-  // 创建形状 VAO 和 VBO
-  glGenVertexArrays(1, &shapeVao_);
-  glGenBuffers(1, &shapeVbo_);
-
-  glBindVertexArray(shapeVao_);
-  glBindBuffer(GL_ARRAY_BUFFER, shapeVbo_);
-  glBufferData(GL_ARRAY_BUFFER, MAX_SHAPE_VERTICES * sizeof(ShapeVertex),
-               nullptr, GL_DYNAMIC_DRAW);
-
-  // 位置属性 (location = 0)
-  glEnableVertexAttribArray(0);
-  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(ShapeVertex),
-                        reinterpret_cast<void *>(offsetof(ShapeVertex, x)));
-
-  // 颜色属性 (location = 1)
-  glEnableVertexAttribArray(1);
-  glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(ShapeVertex),
-                        reinterpret_cast<void *>(offsetof(ShapeVertex, r)));
-
-  glBindVertexArray(0);
-
-  // 创建线条专用 VAO 和 VBO
-  glGenVertexArrays(1, &lineVao_);
-  glGenBuffers(1, &lineVbo_);
-
-  glBindVertexArray(lineVao_);
-  glBindBuffer(GL_ARRAY_BUFFER, lineVbo_);
-  glBufferData(GL_ARRAY_BUFFER, MAX_LINE_VERTICES * sizeof(ShapeVertex),
-               nullptr, GL_DYNAMIC_DRAW);
-
-  // 位置属性 (location = 0)
-  glEnableVertexAttribArray(0);
-  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(ShapeVertex),
-                        reinterpret_cast<void *>(offsetof(ShapeVertex, x)));
-
-  // 颜色属性 (location = 1)
-  glEnableVertexAttribArray(1);
-  glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(ShapeVertex),
-                        reinterpret_cast<void *>(offsetof(ShapeVertex, r)));
-
-  glBindVertexArray(0);
-
-  // VRAM 跟踪
-  VRAMManager::getInstance().allocBuffer(MAX_SHAPE_VERTICES *
-                                         sizeof(ShapeVertex));
-  VRAMManager::getInstance().allocBuffer(MAX_LINE_VERTICES *
-                                         sizeof(ShapeVertex));
-}
-
-void GLRenderer::addShapeVertex(float x, float y, const Color &color) {
-  if (shapeVertexCount_ >= MAX_SHAPE_VERTICES) {
-    flushShapeBatch();
-  }
-  ShapeVertex &v = shapeVertexCache_[shapeVertexCount_++];
-  v.x = x;
-  v.y = y;
-  v.r = color.r;
-  v.g = color.g;
-  v.b = color.b;
-  v.a = color.a;
-}
-
-void GLRenderer::addLineVertex(float x, float y, const Color &color) {
-  if (lineVertexCount_ >= MAX_LINE_VERTICES) {
-    flushLineBatch();
-  }
-  ShapeVertex &v = lineVertexCache_[lineVertexCount_++];
-  v.x = x;
-  v.y = y;
-  v.r = color.r;
-  v.g = color.g;
-  v.b = color.b;
-  v.a = color.a;
-}
-
-void GLRenderer::submitShapeBatch(GLenum mode) {
-  if (shapeVertexCount_ == 0)
-    return;
-
-  // 如果模式改变，先刷新
-  if (currentShapeMode_ != mode && shapeVertexCount_ > 0) {
-    flushShapeBatch();
-  }
-  currentShapeMode_ = mode;
-}
-
-void GLRenderer::flushShapeBatch() {
-  if (shapeVertexCount_ == 0)
-    return;
-
-  shapeShader_.bind();
-  shapeShader_.setMat4("uViewProjection", viewProjection_);
-
-  glBindBuffer(GL_ARRAY_BUFFER, shapeVbo_);
-  glBufferSubData(GL_ARRAY_BUFFER, 0, shapeVertexCount_ * sizeof(ShapeVertex),
-                  shapeVertexCache_.data());
-
-  glBindVertexArray(shapeVao_);
-  glDrawArrays(currentShapeMode_, 0, static_cast<GLsizei>(shapeVertexCount_));
-
-  stats_.drawCalls++;
-  stats_.triangleCount += static_cast<uint32_t>(shapeVertexCount_ / 3);
-
-  shapeVertexCount_ = 0;
-}
-
-void GLRenderer::flushLineBatch() {
-  if (lineVertexCount_ == 0)
-    return;
-
-  // 先刷新形状批次
-  flushShapeBatch();
-
-  glLineWidth(currentLineWidth_);
-  shapeShader_.bind();
-  shapeShader_.setMat4("uViewProjection", viewProjection_);
-
-  glBindBuffer(GL_ARRAY_BUFFER, lineVbo_);
-  glBufferSubData(GL_ARRAY_BUFFER, 0, lineVertexCount_ * sizeof(ShapeVertex),
-                  lineVertexCache_.data());
-
-  glBindVertexArray(lineVao_);
-  glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(lineVertexCount_));
-
-  stats_.drawCalls++;
-
-  lineVertexCount_ = 0;
-}
-
-} // namespace extra2d
diff --git a/src/graphics/opengl/gl_shader.cpp b/src/graphics/opengl/gl_shader.cpp
deleted file mode 100644
index 9ab1944..0000000
--- a/src/graphics/opengl/gl_shader.cpp
+++ /dev/null
@@ -1,129 +0,0 @@
-#include <graphics/opengl/gl_shader.h>
-#include <utils/logger.h>
-#include <fstream>
-#include <sstream>
-
-namespace extra2d {
-
-GLShader::GLShader() : programID_(0) {}
-
-GLShader::~GLShader() {
-  if (programID_ != 0) {
-    glDeleteProgram(programID_);
-  }
-}
-
-bool GLShader::compileFromSource(const char *vertexSource,
-                                 const char *fragmentSource) {
-  GLuint vertexShader = compileShader(GL_VERTEX_SHADER, vertexSource);
-  if (vertexShader == 0)
-    return false;
-
-  GLuint fragmentShader = compileShader(GL_FRAGMENT_SHADER, fragmentSource);
-  if (fragmentShader == 0) {
-    glDeleteShader(vertexShader);
-    return false;
-  }
-
-  programID_ = glCreateProgram();
-  glAttachShader(programID_, vertexShader);
-  glAttachShader(programID_, fragmentShader);
-  glLinkProgram(programID_);
-
-  GLint success;
-  glGetProgramiv(programID_, GL_LINK_STATUS, &success);
-  if (!success) {
-    char infoLog[512];
-    glGetProgramInfoLog(programID_, 512, nullptr, infoLog);
-    E2D_LOG_ERROR("Shader program linking failed: {}", infoLog);
-    glDeleteProgram(programID_);
-    programID_ = 0;
-  }
-
-  glDeleteShader(vertexShader);
-  glDeleteShader(fragmentShader);
-
-  return success == GL_TRUE;
-}
-
-bool GLShader::compileFromFile(const std::string &vertexPath,
-                               const std::string &fragmentPath) {
-  std::ifstream vShaderFile(vertexPath);
-  std::ifstream fShaderFile(fragmentPath);
-
-  if (!vShaderFile.is_open() || !fShaderFile.is_open()) {
-    E2D_LOG_ERROR("Failed to open shader files: {}, {}", vertexPath,
-                  fragmentPath);
-    return false;
-  }
-
-  std::stringstream vShaderStream, fShaderStream;
-  vShaderStream << vShaderFile.rdbuf();
-  fShaderStream << fShaderFile.rdbuf();
-
-  return compileFromSource(vShaderStream.str().c_str(),
-                           fShaderStream.str().c_str());
-}
-
-void GLShader::bind() const { glUseProgram(programID_); }
-
-void GLShader::unbind() const { glUseProgram(0); }
-
-void GLShader::setBool(const std::string &name, bool value) {
-  glUniform1i(getUniformLocation(name), value ? 1 : 0);
-}
-
-void GLShader::setInt(const std::string &name, int value) {
-  glUniform1i(getUniformLocation(name), value);
-}
-
-void GLShader::setFloat(const std::string &name, float value) {
-  glUniform1f(getUniformLocation(name), value);
-}
-
-void GLShader::setVec2(const std::string &name, const glm::vec2 &value) {
-  glUniform2fv(getUniformLocation(name), 1, &value[0]);
-}
-
-void GLShader::setVec3(const std::string &name, const glm::vec3 &value) {
-  glUniform3fv(getUniformLocation(name), 1, &value[0]);
-}
-
-void GLShader::setVec4(const std::string &name, const glm::vec4 &value) {
-  glUniform4fv(getUniformLocation(name), 1, &value[0]);
-}
-
-void GLShader::setMat4(const std::string &name, const glm::mat4 &value) {
-  glUniformMatrix4fv(getUniformLocation(name), 1, GL_FALSE, &value[0][0]);
-}
-
-GLuint GLShader::compileShader(GLenum type, const char *source) {
-  GLuint shader = glCreateShader(type);
-  glShaderSource(shader, 1, &source, nullptr);
-  glCompileShader(shader);
-
-  GLint success;
-  glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
-  if (!success) {
-    char infoLog[512];
-    glGetShaderInfoLog(shader, 512, nullptr, infoLog);
-    E2D_LOG_ERROR("Shader compilation failed: {}", infoLog);
-    glDeleteShader(shader);
-    return 0;
-  }
-
-  return shader;
-}
-
-GLint GLShader::getUniformLocation(const std::string &name) {
-  auto it = uniformCache_.find(name);
-  if (it != uniformCache_.end()) {
-    return it->second;
-  }
-
-  GLint location = glGetUniformLocation(programID_, name.c_str());
-  uniformCache_[name] = location;
-  return location;
-}
-
-} // namespace extra2d
diff --git a/src/graphics/opengl/gl_sprite_batch.cpp b/src/graphics/opengl/gl_sprite_batch.cpp
deleted file mode 100644
index b56dedd..0000000
--- a/src/graphics/opengl/gl_sprite_batch.cpp
+++ /dev/null
@@ -1,363 +0,0 @@
-#include <cstring>
-#include <graphics/opengl/gl_sprite_batch.h>
-#include <utils/logger.h>
-#include <glm/gtc/matrix_transform.hpp>
-
-namespace extra2d {
-
-// ============================================================================
-// 三角函数查表 - 避免每帧重复计算 sin/cos
-// ============================================================================
-class TrigLookup {
-public:
-  static constexpr size_t TABLE_SIZE = 360 * 4;  // 0.25度精度
-  static constexpr float INDEX_SCALE = 4.0f;      // 每度4个采样点
-  static constexpr float RAD_TO_INDEX = INDEX_SCALE * 180.0f / 3.14159265359f;
-  
-  static float sinRad(float radians) {
-    return table_.sinTable[normalizeIndexRad(radians)];
-  }
-  
-  static float cosRad(float radians) {
-    return table_.cosTable[normalizeIndexRad(radians)];
-  }
-  
-private:
-  struct Tables {
-    std::array<float, TABLE_SIZE> sinTable;
-    std::array<float, TABLE_SIZE> cosTable;
-    
-    Tables() {
-      for (size_t i = 0; i < TABLE_SIZE; ++i) {
-        float angle = static_cast<float>(i) / INDEX_SCALE * 3.14159265359f / 180.0f;
-        sinTable[i] = std::sin(angle);
-        cosTable[i] = std::cos(angle);
-      }
-    }
-  };
-  
-  static size_t normalizeIndexRad(float radians) {
-    int idx = static_cast<int>(radians * RAD_TO_INDEX) % static_cast<int>(TABLE_SIZE);
-    if (idx < 0) {
-      idx += static_cast<int>(TABLE_SIZE);
-    }
-    return static_cast<size_t>(idx);
-  }
-  
-  static const Tables table_;
-};
-
-const TrigLookup::Tables TrigLookup::table_;
-
-// 静态索引生成函数
-static const std::array<GLuint, GLSpriteBatch::MAX_INDICES>& getIndices() {
-  static std::array<GLuint, GLSpriteBatch::MAX_INDICES> indices = []() {
-    std::array<GLuint, GLSpriteBatch::MAX_INDICES> arr{};
-    for (size_t i = 0; i < GLSpriteBatch::MAX_SPRITES; ++i) {
-      GLuint base = static_cast<GLuint>(i * GLSpriteBatch::VERTICES_PER_SPRITE);
-      arr[i * GLSpriteBatch::INDICES_PER_SPRITE + 0] = base + 0;
-      arr[i * GLSpriteBatch::INDICES_PER_SPRITE + 1] = base + 1;
-      arr[i * GLSpriteBatch::INDICES_PER_SPRITE + 2] = base + 2;
-      arr[i * GLSpriteBatch::INDICES_PER_SPRITE + 3] = base + 0;
-      arr[i * GLSpriteBatch::INDICES_PER_SPRITE + 4] = base + 2;
-      arr[i * GLSpriteBatch::INDICES_PER_SPRITE + 5] = base + 3;
-    }
-    return arr;
-  }();
-  return indices;
-}
-
-// 顶点着色器 (GLES 3.2)
-static const char *SPRITE_VERTEX_SHADER = R"(
-#version 300 es
-precision highp float;
-layout(location = 0) in vec2 aPosition;
-layout(location = 1) in vec2 aTexCoord;
-layout(location = 2) in vec4 aColor;
-
-uniform mat4 uViewProjection;
-
-out vec2 vTexCoord;
-out vec4 vColor;
-
-void main() {
-    gl_Position = uViewProjection * vec4(aPosition, 0.0, 1.0);
-    vTexCoord = aTexCoord;
-    vColor = aColor;
-}
-)";
-
-// 片段着色器 (GLES 3.2)
-// SDF 常量硬编码：ONEDGE_VALUE=128/255=0.502, PIXEL_DIST_SCALE=255/64=3.98
-// SDF 值存储在 Alpha 通道
-static const char *SPRITE_FRAGMENT_SHADER = R"(
-#version 300 es
-precision highp float;
-in vec2 vTexCoord;
-in vec4 vColor;
-
-uniform sampler2D uTexture;
-uniform int uUseSDF;
-
-out vec4 fragColor;
-
-void main() {
-    if (uUseSDF == 1) {
-        float dist = texture(uTexture, vTexCoord).a;
-        float sd = (dist - 0.502) * 3.98;
-        float w = fwidth(sd);
-        float alpha = smoothstep(-w, w, sd);
-        fragColor = vec4(vColor.rgb, vColor.a * alpha);
-    } else {
-        fragColor = texture(uTexture, vTexCoord) * vColor;
-    }
-}
-)";
-
-GLSpriteBatch::GLSpriteBatch()
-    : vao_(0), vbo_(0), ibo_(0), vertexCount_(0), currentTexture_(nullptr),
-      currentIsSDF_(false), drawCallCount_(0), spriteCount_(0), batchCount_(0) {
-}
-
-GLSpriteBatch::~GLSpriteBatch() { shutdown(); }
-
-bool GLSpriteBatch::init() {
-  // 创建并编译着色器
-  if (!shader_.compileFromSource(SPRITE_VERTEX_SHADER,
-                                 SPRITE_FRAGMENT_SHADER)) {
-    E2D_LOG_ERROR("Failed to compile sprite batch shader");
-    return false;
-  }
-
-  // 生成 VAO、VBO、IBO
-  glGenVertexArrays(1, &vao_);
-  glGenBuffers(1, &vbo_);
-  glGenBuffers(1, &ibo_);
-
-  glBindVertexArray(vao_);
-
-  // 设置 VBO - 使用动态绘制模式
-  glBindBuffer(GL_ARRAY_BUFFER, vbo_);
-  glBufferData(GL_ARRAY_BUFFER, MAX_VERTICES * sizeof(Vertex), nullptr,
-               GL_DYNAMIC_DRAW);
-
-  // 设置顶点属性
-  glEnableVertexAttribArray(0);
-  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
-                        (void *)offsetof(Vertex, position));
-
-  glEnableVertexAttribArray(1);
-  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
-                        (void *)offsetof(Vertex, texCoord));
-
-  glEnableVertexAttribArray(2);
-  glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex),
-                        (void *)offsetof(Vertex, color));
-
-  // 使用编译期生成的静态索引缓冲区
-  const auto& indices = getIndices();
-  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo_);
-  glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(GLuint),
-               indices.data(), GL_STATIC_DRAW);
-
-  glBindVertexArray(0);
-
-  E2D_LOG_INFO("GLSpriteBatch initialized with capacity for {} sprites",
-               MAX_SPRITES);
-  return true;
-}
-
-void GLSpriteBatch::shutdown() {
-  if (vao_ != 0) {
-    glDeleteVertexArrays(1, &vao_);
-    vao_ = 0;
-  }
-  if (vbo_ != 0) {
-    glDeleteBuffers(1, &vbo_);
-    vbo_ = 0;
-  }
-  if (ibo_ != 0) {
-    glDeleteBuffers(1, &ibo_);
-    ibo_ = 0;
-  }
-}
-
-void GLSpriteBatch::begin(const glm::mat4 &viewProjection) {
-  viewProjection_ = viewProjection;
-  vertexCount_ = 0;
-  currentTexture_ = nullptr;
-  currentIsSDF_ = false;
-  drawCallCount_ = 0;
-  spriteCount_ = 0;
-  batchCount_ = 0;
-}
-
-bool GLSpriteBatch::needsFlush(const Texture &texture, bool isSDF) const {
-  if (currentTexture_ == nullptr) {
-    return false;
-  }
-
-  // 检查是否需要刷新：纹理改变、SDF 状态改变或缓冲区已满
-  return (currentTexture_ != &texture) || (currentIsSDF_ != isSDF) ||
-         (vertexCount_ + VERTICES_PER_SPRITE > MAX_VERTICES);
-}
-
-void GLSpriteBatch::addVertices(const SpriteData &data) {
-  // 计算锚点偏移
-  float anchorOffsetX = data.size.x * data.anchor.x;
-  float anchorOffsetY = data.size.y * data.anchor.y;
-
-  // 使用三角函数查表替代 cosf/sinf
-  float cosR = TrigLookup::cosRad(data.rotation);
-  float sinR = TrigLookup::sinRad(data.rotation);
-
-  glm::vec4 color(data.color.r, data.color.g, data.color.b, data.color.a);
-
-  // 直接计算变换后的位置
-  float rx0 = -anchorOffsetX;
-  float ry0 = -anchorOffsetY;
-  float rx1 = data.size.x - anchorOffsetX;
-  float ry1 = data.size.y - anchorOffsetY;
-  
-  // 预计算旋转后的偏移
-  float cosRx0 = rx0 * cosR, sinRx0 = rx0 * sinR;
-  float cosRx1 = rx1 * cosR, sinRx1 = rx1 * sinR;
-  float cosRy0 = ry0 * cosR, sinRy0 = ry0 * sinR;
-  float cosRy1 = ry1 * cosR, sinRy1 = ry1 * sinR;
-  
-  // v0: (0, 0) -> (rx0, ry0)
-  vertexBuffer_[vertexCount_++] = {
-    glm::vec2(data.position.x + cosRx0 - sinRy0, data.position.y + sinRx0 + cosRy0),
-    glm::vec2(data.texCoordMin.x, data.texCoordMin.y),
-    color
-  };
-  
-  // v1: (size.x, 0) -> (rx1, ry0)
-  vertexBuffer_[vertexCount_++] = {
-    glm::vec2(data.position.x + cosRx1 - sinRy0, data.position.y + sinRx1 + cosRy0),
-    glm::vec2(data.texCoordMax.x, data.texCoordMin.y),
-    color
-  };
-  
-  // v2: (size.x, size.y) -> (rx1, ry1)
-  vertexBuffer_[vertexCount_++] = {
-    glm::vec2(data.position.x + cosRx1 - sinRy1, data.position.y + sinRx1 + cosRy1),
-    glm::vec2(data.texCoordMax.x, data.texCoordMax.y),
-    color
-  };
-  
-  // v3: (0, size.y) -> (rx0, ry1)
-  vertexBuffer_[vertexCount_++] = {
-    glm::vec2(data.position.x + cosRx0 - sinRy1, data.position.y + sinRx0 + cosRy1),
-    glm::vec2(data.texCoordMin.x, data.texCoordMax.y),
-    color
-  };
-}
-
-void GLSpriteBatch::draw(const Texture &texture, const SpriteData &data) {
-  // 如果需要刷新，先提交当前批次
-  if (needsFlush(texture, data.isSDF)) {
-    flush();
-  }
-
-  currentTexture_ = &texture;
-  currentIsSDF_ = data.isSDF;
-
-  addVertices(data);
-  spriteCount_++;
-}
-
-void GLSpriteBatch::drawBatch(const Texture &texture,
-                              const std::vector<SpriteData> &sprites) {
-  if (sprites.empty()) {
-    return;
-  }
-
-  // 如果当前有未提交的批次且纹理不同，先刷新
-  if (currentTexture_ != nullptr && currentTexture_ != &texture) {
-    flush();
-  }
-
-  currentTexture_ = &texture;
-  currentIsSDF_ = sprites[0].isSDF; // 假设批量中的精灵 SDF 状态一致
-
-  // 分批处理，避免超过缓冲区大小
-  size_t index = 0;
-  while (index < sprites.size()) {
-    size_t remainingSpace = (MAX_VERTICES - vertexCount_) / VERTICES_PER_SPRITE;
-    size_t batchSize = std::min(sprites.size() - index, remainingSpace);
-
-    for (size_t i = 0; i < batchSize; ++i) {
-      addVertices(sprites[index + i]);
-      spriteCount_++;
-    }
-
-    index += batchSize;
-
-    // 如果还有更多精灵，刷新当前批次
-    if (index < sprites.size()) {
-      flush();
-    }
-  }
-
-  batchCount_++;
-}
-
-void GLSpriteBatch::drawImmediate(const Texture &texture,
-                                  const SpriteData &data) {
-  // 立即绘制，不缓存 - 用于需要立即显示的情况
-  flush(); // 先提交当前批次
-
-  currentTexture_ = &texture;
-  currentIsSDF_ = data.isSDF;
-  addVertices(data);
-  spriteCount_++;
-
-  flush(); // 立即提交
-}
-
-void GLSpriteBatch::end() {
-  if (vertexCount_ > 0) {
-    flush();
-  }
-}
-
-void GLSpriteBatch::flush() {
-  if (vertexCount_ == 0 || currentTexture_ == nullptr) {
-    return;
-  }
-
-  // 绑定纹理
-  GLuint texID = static_cast<GLuint>(
-      reinterpret_cast<uintptr_t>(currentTexture_->getNativeHandle()));
-  glActiveTexture(GL_TEXTURE0);
-  glBindTexture(GL_TEXTURE_2D, texID);
-
-  // 使用着色器
-  shader_.bind();
-  shader_.setMat4("uViewProjection", viewProjection_);
-  shader_.setInt("uTexture", 0);
-  shader_.setInt("uUseSDF", currentIsSDF_ ? 1 : 0);
-  // SDF 常量已硬编码到着色器中
-
-  // 更新 VBO 数据 - 只更新实际使用的部分
-  glBindBuffer(GL_ARRAY_BUFFER, vbo_);
-  glBufferSubData(GL_ARRAY_BUFFER, 0, vertexCount_ * sizeof(Vertex),
-                  vertexBuffer_.data());
-
-  // 绘制
-  glBindVertexArray(vao_);
-  GLsizei indexCount = static_cast<GLsizei>(
-      (vertexCount_ / VERTICES_PER_SPRITE) * INDICES_PER_SPRITE);
-  glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, nullptr);
-
-  drawCallCount_++;
-  batchCount_++;
-
-  // 重置状态
-  vertexCount_ = 0;
-  currentTexture_ = nullptr;
-  currentIsSDF_ = false;
-}
-
-} // namespace extra2d
diff --git a/src/graphics/opengl/gl_texture.cpp b/src/graphics/opengl/gl_texture.cpp
deleted file mode 100644
index 45be138..0000000
--- a/src/graphics/opengl/gl_texture.cpp
+++ /dev/null
@@ -1,463 +0,0 @@
-#include <graphics/gpu_context.h>
-#include <graphics/opengl/gl_texture.h>
-#include <graphics/vram_manager.h>
-
-#define STB_IMAGE_IMPLEMENTATION
-#include <cstring>
-#include <fstream>
-#include <stb/stb_image.h>
-#include <utils/logger.h>
-
-
-namespace extra2d {
-
-// ============================================================================
-// KTX 文件头结构
-// ============================================================================
-#pragma pack(push, 1)
-struct KTXHeader {
-  uint8_t identifier[12];
-  uint32_t endianness;
-  uint32_t glType;
-  uint32_t glTypeSize;
-  uint32_t glFormat;
-  uint32_t glInternalFormat;
-  uint32_t glBaseInternalFormat;
-  uint32_t pixelWidth;
-  uint32_t pixelHeight;
-  uint32_t pixelDepth;
-  uint32_t numberOfArrayElements;
-  uint32_t numberOfFaces;
-  uint32_t numberOfMipmapLevels;
-  uint32_t bytesOfKeyValueData;
-};
-#pragma pack(pop)
-
-// KTX 文件标识符
-static const uint8_t KTX_IDENTIFIER[12] = {0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31,
-                                           0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A};
-
-// ============================================================================
-// DDS 文件头结构
-// ============================================================================
-#pragma pack(push, 1)
-struct DDSPixelFormat {
-  uint32_t size;
-  uint32_t flags;
-  uint32_t fourCC;
-  uint32_t rgbBitCount;
-  uint32_t rBitMask;
-  uint32_t gBitMask;
-  uint32_t bBitMask;
-  uint32_t aBitMask;
-};
-
-struct DDSHeader {
-  uint32_t magic;
-  uint32_t size;
-  uint32_t flags;
-  uint32_t height;
-  uint32_t width;
-  uint32_t pitchOrLinearSize;
-  uint32_t depth;
-  uint32_t mipMapCount;
-  uint32_t reserved1[11];
-  DDSPixelFormat pixelFormat;
-  uint32_t caps;
-  uint32_t caps2;
-  uint32_t caps3;
-  uint32_t caps4;
-  uint32_t reserved2;
-};
-
-struct DDSHeaderDXT10 {
-  uint32_t dxgiFormat;
-  uint32_t resourceDimension;
-  uint32_t miscFlag;
-  uint32_t arraySize;
-  uint32_t miscFlags2;
-};
-#pragma pack(pop)
-
-static constexpr uint32_t DDS_MAGIC = 0x20534444; // "DDS "
-static constexpr uint32_t DDPF_FOURCC = 0x04;
-
-static uint32_t makeFourCC(char a, char b, char c, char d) {
-  return static_cast<uint32_t>(a) | (static_cast<uint32_t>(b) << 8) |
-         (static_cast<uint32_t>(c) << 16) | (static_cast<uint32_t>(d) << 24);
-}
-
-// ============================================================================
-// GLTexture 实现
-// ============================================================================
-
-GLTexture::GLTexture(int width, int height, const uint8_t *pixels, int channels)
-    : textureID_(0), width_(width), height_(height), channels_(channels),
-      format_(PixelFormat::RGBA8), dataSize_(0) {
-  // 保存像素数据用于生成遮罩
-  if (pixels) {
-    pixelData_.resize(width * height * channels);
-    std::memcpy(pixelData_.data(), pixels, pixelData_.size());
-  }
-  createTexture(pixels);
-}
-
-GLTexture::GLTexture(const std::string &filepath)
-    : textureID_(0), width_(0), height_(0), channels_(0),
-      format_(PixelFormat::RGBA8), dataSize_(0) {
-  // 检查是否为压缩纹理格式
-  std::string ext = filepath.substr(filepath.find_last_of('.') + 1);
-  if (ext == "ktx" || ext == "KTX") {
-    loadCompressed(filepath);
-    return;
-  }
-  if (ext == "dds" || ext == "DDS") {
-    loadCompressed(filepath);
-    return;
-  }
-
-  // 不翻转图片，保持原始方向
-  stbi_set_flip_vertically_on_load(false);
-  uint8_t *data = stbi_load(filepath.c_str(), &width_, &height_, &channels_, 0);
-  if (data) {
-    // 保存像素数据用于生成遮罩
-    pixelData_.resize(width_ * height_ * channels_);
-    std::memcpy(pixelData_.data(), data, pixelData_.size());
-
-    createTexture(data);
-    stbi_image_free(data);
-  } else {
-    E2D_LOG_ERROR("Failed to load texture: {}", filepath);
-  }
-}
-
-GLTexture::~GLTexture() {
-  if (textureID_ != 0) {
-    // 检查 GPU 上下文是否仍然有效
-    // 如果 OpenGL 上下文已销毁，则跳过 glDeleteTextures 调用
-    if (GPUContext::getInstance().isValid()) {
-      glDeleteTextures(1, &textureID_);
-    }
-    // VRAM 跟踪: 释放纹理显存（无论上下文是否有效都需要更新统计）
-    if (dataSize_ > 0) {
-      VRAMManager::getInstance().freeTexture(dataSize_);
-    }
-  }
-}
-
-void GLTexture::setFilter(bool linear) {
-  bind();
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
-                  linear ? GL_LINEAR : GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
-                  linear ? GL_LINEAR : GL_NEAREST);
-}
-
-void GLTexture::setWrap(bool repeat) {
-  bind();
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
-                  repeat ? GL_REPEAT : GL_CLAMP_TO_EDGE);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
-                  repeat ? GL_REPEAT : GL_CLAMP_TO_EDGE);
-}
-
-void GLTexture::bind(unsigned int slot) const {
-  glActiveTexture(GL_TEXTURE0 + slot);
-  glBindTexture(GL_TEXTURE_2D, textureID_);
-}
-
-void GLTexture::unbind() const { glBindTexture(GL_TEXTURE_2D, 0); }
-
-void GLTexture::createTexture(const uint8_t *pixels) {
-  GLenum format = GL_RGBA;
-  GLenum internalFormat = GL_RGBA8;
-  int unpackAlignment = 4;
-  if (channels_ == 1) {
-    format = GL_RED;
-    internalFormat = GL_R8;
-    unpackAlignment = 1;
-    format_ = PixelFormat::R8;
-  } else if (channels_ == 3) {
-    format = GL_RGB;
-    internalFormat = GL_RGB8;
-    unpackAlignment = 1;
-    format_ = PixelFormat::RGB8;
-  } else if (channels_ == 4) {
-    format = GL_RGBA;
-    internalFormat = GL_RGBA8;
-    unpackAlignment = 4;
-    format_ = PixelFormat::RGBA8;
-  }
-
-  glGenTextures(1, &textureID_);
-  bind();
-
-  GLint prevUnpackAlignment = 4;
-  glGetIntegerv(GL_UNPACK_ALIGNMENT, &prevUnpackAlignment);
-  glPixelStorei(GL_UNPACK_ALIGNMENT, unpackAlignment);
-
-  glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, width_, height_, 0, format,
-               GL_UNSIGNED_BYTE, pixels);
-  glPixelStorei(GL_UNPACK_ALIGNMENT, prevUnpackAlignment);
-
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-  // 使用 NEAREST 过滤器，更适合像素艺术风格的精灵
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-
-  glGenerateMipmap(GL_TEXTURE_2D);
-
-  // VRAM 跟踪
-  dataSize_ = static_cast<size_t>(width_ * height_ * channels_);
-  VRAMManager::getInstance().allocTexture(dataSize_);
-}
-
-// ============================================================================
-// 压缩纹理加载
-// ============================================================================
-
-bool GLTexture::loadCompressed(const std::string &filepath) {
-  std::string ext = filepath.substr(filepath.find_last_of('.') + 1);
-  if (ext == "ktx" || ext == "KTX") {
-    return loadKTX(filepath);
-  }
-  if (ext == "dds" || ext == "DDS") {
-    return loadDDS(filepath);
-  }
-  E2D_LOG_ERROR("Unsupported compressed texture format: {}", filepath);
-  return false;
-}
-
-bool GLTexture::loadKTX(const std::string &filepath) {
-  std::ifstream file(filepath, std::ios::binary);
-  if (!file.is_open()) {
-    E2D_LOG_ERROR("Failed to open KTX file: {}", filepath);
-    return false;
-  }
-
-  KTXHeader header;
-  file.read(reinterpret_cast<char *>(&header), sizeof(header));
-  if (!file) {
-    E2D_LOG_ERROR("Failed to read KTX header: {}", filepath);
-    return false;
-  }
-
-  // 验证标识符
-  if (std::memcmp(header.identifier, KTX_IDENTIFIER, 12) != 0) {
-    E2D_LOG_ERROR("Invalid KTX identifier: {}", filepath);
-    return false;
-  }
-
-  width_ = static_cast<int>(header.pixelWidth);
-  height_ = static_cast<int>(header.pixelHeight);
-  channels_ = 4; // 压缩纹理通常解压为 RGBA
-
-  // 确定压缩格式
-  GLenum glInternalFormat = header.glInternalFormat;
-  switch (glInternalFormat) {
-  case GL_COMPRESSED_RGB8_ETC2:
-    format_ = PixelFormat::ETC2_RGB8;
-    channels_ = 3;
-    break;
-  case GL_COMPRESSED_RGBA8_ETC2_EAC:
-    format_ = PixelFormat::ETC2_RGBA8;
-    break;
-  case GL_COMPRESSED_RGBA_ASTC_4x4:
-    format_ = PixelFormat::ASTC_4x4;
-    break;
-  case GL_COMPRESSED_RGBA_ASTC_6x6:
-    format_ = PixelFormat::ASTC_6x6;
-    break;
-  case GL_COMPRESSED_RGBA_ASTC_8x8:
-    format_ = PixelFormat::ASTC_8x8;
-    break;
-  default:
-    E2D_LOG_ERROR("Unsupported KTX internal format: {:#06x}", glInternalFormat);
-    return false;
-  }
-
-  // 跳过 key-value 数据
-  file.seekg(header.bytesOfKeyValueData, std::ios::cur);
-
-  // 读取第一个 mipmap level
-  uint32_t imageSize = 0;
-  file.read(reinterpret_cast<char *>(&imageSize), sizeof(imageSize));
-  if (!file || imageSize == 0) {
-    E2D_LOG_ERROR("Failed to read KTX image size: {}", filepath);
-    return false;
-  }
-
-  std::vector<uint8_t> compressedData(imageSize);
-  file.read(reinterpret_cast<char *>(compressedData.data()), imageSize);
-  if (!file) {
-    E2D_LOG_ERROR("Failed to read KTX image data: {}", filepath);
-    return false;
-  }
-
-  // 创建 GL 纹理
-  glGenTextures(1, &textureID_);
-  bind();
-
-  glCompressedTexImage2D(GL_TEXTURE_2D, 0, glInternalFormat, width_, height_, 0,
-                         static_cast<GLsizei>(imageSize),
-                         compressedData.data());
-
-  GLenum err = glGetError();
-  if (err != GL_NO_ERROR) {
-    E2D_LOG_ERROR("glCompressedTexImage2D failed for KTX: {:#06x}", err);
-    glDeleteTextures(1, &textureID_);
-    textureID_ = 0;
-    return false;
-  }
-
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-
-  // VRAM 跟踪
-  dataSize_ = imageSize;
-  VRAMManager::getInstance().allocTexture(dataSize_);
-
-  E2D_LOG_INFO("Loaded compressed KTX texture: {} ({}x{}, format={:#06x})",
-               filepath, width_, height_, glInternalFormat);
-  return true;
-}
-
-bool GLTexture::loadDDS(const std::string &filepath) {
-  std::ifstream file(filepath, std::ios::binary);
-  if (!file.is_open()) {
-    E2D_LOG_ERROR("Failed to open DDS file: {}", filepath);
-    return false;
-  }
-
-  DDSHeader header;
-  file.read(reinterpret_cast<char *>(&header), sizeof(header));
-  if (!file) {
-    E2D_LOG_ERROR("Failed to read DDS header: {}", filepath);
-    return false;
-  }
-
-  if (header.magic != DDS_MAGIC) {
-    E2D_LOG_ERROR("Invalid DDS magic: {}", filepath);
-    return false;
-  }
-
-  width_ = static_cast<int>(header.width);
-  height_ = static_cast<int>(header.height);
-  channels_ = 4;
-
-  GLenum glInternalFormat = 0;
-
-  // 检查 DX10 扩展头
-  if ((header.pixelFormat.flags & DDPF_FOURCC) &&
-      header.pixelFormat.fourCC == makeFourCC('D', 'X', '1', '0')) {
-    DDSHeaderDXT10 dx10Header;
-    file.read(reinterpret_cast<char *>(&dx10Header), sizeof(dx10Header));
-    if (!file) {
-      E2D_LOG_ERROR("Failed to read DDS DX10 header: {}", filepath);
-      return false;
-    }
-
-    // DXGI_FORMAT 映射到 GL 格式
-    switch (dx10Header.dxgiFormat) {
-    case 147: // DXGI_FORMAT_ETC2_RGB8
-      glInternalFormat = GL_COMPRESSED_RGB8_ETC2;
-      format_ = PixelFormat::ETC2_RGB8;
-      channels_ = 3;
-      break;
-    case 148: // DXGI_FORMAT_ETC2_RGBA8
-      glInternalFormat = GL_COMPRESSED_RGBA8_ETC2_EAC;
-      format_ = PixelFormat::ETC2_RGBA8;
-      break;
-    default:
-      E2D_LOG_ERROR("Unsupported DDS DX10 format: {}", dx10Header.dxgiFormat);
-      return false;
-    }
-  } else {
-    E2D_LOG_ERROR("DDS file does not use DX10 extension, unsupported: {}",
-                  filepath);
-    return false;
-  }
-
-  // 计算压缩数据大小
-  size_t blockSize = (glInternalFormat == GL_COMPRESSED_RGB8_ETC2) ? 8 : 16;
-  size_t blocksWide = (width_ + 3) / 4;
-  size_t blocksHigh = (height_ + 3) / 4;
-  size_t imageSize = blocksWide * blocksHigh * blockSize;
-
-  std::vector<uint8_t> compressedData(imageSize);
-  file.read(reinterpret_cast<char *>(compressedData.data()), imageSize);
-  if (!file) {
-    E2D_LOG_ERROR("Failed to read DDS image data: {}", filepath);
-    return false;
-  }
-
-  // 创建 GL 纹理
-  glGenTextures(1, &textureID_);
-  bind();
-
-  glCompressedTexImage2D(GL_TEXTURE_2D, 0, glInternalFormat, width_, height_, 0,
-                         static_cast<GLsizei>(imageSize),
-                         compressedData.data());
-
-  GLenum err = glGetError();
-  if (err != GL_NO_ERROR) {
-    E2D_LOG_ERROR("glCompressedTexImage2D failed for DDS: {:#06x}", err);
-    glDeleteTextures(1, &textureID_);
-    textureID_ = 0;
-    return false;
-  }
-
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-
-  // VRAM 跟踪
-  dataSize_ = imageSize;
-  VRAMManager::getInstance().allocTexture(dataSize_);
-
-  E2D_LOG_INFO("Loaded compressed DDS texture: {} ({}x{})", filepath, width_,
-               height_);
-  return true;
-}
-
-void GLTexture::generateAlphaMask() {
-  if (pixelData_.empty() || width_ <= 0 || height_ <= 0) {
-    E2D_LOG_WARN("Cannot generate alpha mask: no pixel data available");
-    return;
-  }
-
-  alphaMask_ = std::make_unique<AlphaMask>(AlphaMask::createFromPixels(
-      pixelData_.data(), width_, height_, channels_));
-
-  E2D_LOG_DEBUG("Generated alpha mask for texture: {}x{}", width_, height_);
-}
-
-PixelFormat GLTexture::getFormat() const { return format_; }
-
-IntrusivePtr<Texture> GLTexture::create(int width, int height, PixelFormat format) {
-  int channels = 4;
-  switch (format) {
-  case PixelFormat::R8:
-    channels = 1;
-    break;
-  case PixelFormat::RG8:
-    channels = 2;
-    break;
-  case PixelFormat::RGB8:
-    channels = 3;
-    break;
-  case PixelFormat::RGBA8:
-    channels = 4;
-    break;
-  default:
-    channels = 4;
-    break;
-  }
-  return makeRef<GLTexture>(width, height, nullptr, channels);
-}
-
-} // namespace extra2d
diff --git a/src/graphics/vram_manager.cpp b/src/graphics/vram_manager.cpp
deleted file mode 100644
index ccedf76..0000000
--- a/src/graphics/vram_manager.cpp
+++ /dev/null
@@ -1,113 +0,0 @@
-#include <algorithm>
-#include <graphics/vram_manager.h>
-#include <utils/logger.h>
-
-namespace extra2d {
-
-// Switch 推荐 VRAM 预算 ~400MB
-static constexpr size_t DEFAULT_VRAM_BUDGET = 400 * 1024 * 1024;
-
-VRAMManager::VRAMManager()
-    : textureVRAM_(0), bufferVRAM_(0), vramBudget_(DEFAULT_VRAM_BUDGET),
-      textureAllocCount_(0), textureFreeCount_(0), bufferAllocCount_(0),
-      bufferFreeCount_(0), peakTextureVRAM_(0), peakBufferVRAM_(0) {}
-
-VRAMManager &VRAMManager::getInstance() {
-  static VRAMManager instance;
-  return instance;
-}
-
-void VRAMManager::allocTexture(size_t size) {
-  std::lock_guard<std::mutex> lock(mutex_);
-  textureVRAM_ += size;
-  textureAllocCount_++;
-  peakTextureVRAM_ = std::max(peakTextureVRAM_, textureVRAM_);
-
-  if (isOverBudget()) {
-    E2D_LOG_WARN("VRAM over budget! Used: {} MB / Budget: {} MB",
-                 getUsedVRAM() / (1024 * 1024), vramBudget_ / (1024 * 1024));
-  }
-}
-
-void VRAMManager::freeTexture(size_t size) {
-  std::lock_guard<std::mutex> lock(mutex_);
-  if (size <= textureVRAM_) {
-    textureVRAM_ -= size;
-  } else {
-    textureVRAM_ = 0;
-  }
-  textureFreeCount_++;
-}
-
-void VRAMManager::allocBuffer(size_t size) {
-  std::lock_guard<std::mutex> lock(mutex_);
-  bufferVRAM_ += size;
-  bufferAllocCount_++;
-  peakBufferVRAM_ = std::max(peakBufferVRAM_, bufferVRAM_);
-
-  if (isOverBudget()) {
-    E2D_LOG_WARN("VRAM over budget! Used: {} MB / Budget: {} MB",
-                 getUsedVRAM() / (1024 * 1024), vramBudget_ / (1024 * 1024));
-  }
-}
-
-void VRAMManager::freeBuffer(size_t size) {
-  std::lock_guard<std::mutex> lock(mutex_);
-  if (size <= bufferVRAM_) {
-    bufferVRAM_ -= size;
-  } else {
-    bufferVRAM_ = 0;
-  }
-  bufferFreeCount_++;
-}
-
-size_t VRAMManager::getUsedVRAM() const { return textureVRAM_ + bufferVRAM_; }
-
-size_t VRAMManager::getTextureVRAM() const { return textureVRAM_; }
-
-size_t VRAMManager::getBufferVRAM() const { return bufferVRAM_; }
-
-size_t VRAMManager::getAvailableVRAM() const {
-  size_t used = getUsedVRAM();
-  return (used < vramBudget_) ? (vramBudget_ - used) : 0;
-}
-
-void VRAMManager::setVRAMBudget(size_t budget) {
-  std::lock_guard<std::mutex> lock(mutex_);
-  vramBudget_ = budget;
-  E2D_LOG_INFO("VRAM budget set to {} MB", budget / (1024 * 1024));
-}
-
-size_t VRAMManager::getVRAMBudget() const { return vramBudget_; }
-
-bool VRAMManager::isOverBudget() const { return getUsedVRAM() > vramBudget_; }
-
-void VRAMManager::printStats() const {
-  std::lock_guard<std::mutex> lock(mutex_);
-  E2D_LOG_INFO("=== VRAM Stats ===");
-  E2D_LOG_INFO("  Texture VRAM: {} MB (peak: {} MB)",
-               textureVRAM_ / (1024 * 1024), peakTextureVRAM_ / (1024 * 1024));
-  E2D_LOG_INFO("  Buffer VRAM:  {} MB (peak: {} MB)",
-               bufferVRAM_ / (1024 * 1024), peakBufferVRAM_ / (1024 * 1024));
-  E2D_LOG_INFO("  Total Used:   {} MB / {} MB budget",
-               (textureVRAM_ + bufferVRAM_) / (1024 * 1024),
-               vramBudget_ / (1024 * 1024));
-  E2D_LOG_INFO("  Texture allocs/frees: {} / {}", textureAllocCount_,
-               textureFreeCount_);
-  E2D_LOG_INFO("  Buffer allocs/frees:  {} / {}", bufferAllocCount_,
-               bufferFreeCount_);
-}
-
-void VRAMManager::reset() {
-  std::lock_guard<std::mutex> lock(mutex_);
-  textureVRAM_ = 0;
-  bufferVRAM_ = 0;
-  textureAllocCount_ = 0;
-  textureFreeCount_ = 0;
-  bufferAllocCount_ = 0;
-  bufferFreeCount_ = 0;
-  peakTextureVRAM_ = 0;
-  peakBufferVRAM_ = 0;
-}
-
-} // namespace extra2d
diff --git a/src/renderer/camera.cpp b/src/renderer/camera.cpp
deleted file mode 100644
index 3b17c11..0000000
--- a/src/renderer/camera.cpp
+++ /dev/null
@@ -1,158 +0,0 @@
-#include <algorithm>
-#include <renderer/camera.h>
-#include <glm/gtc/matrix_transform.hpp>
-
-namespace extra2d {
-
-Camera::Camera() : left_(-1.0f), right_(1.0f), bottom_(-1.0f), top_(1.0f) {}
-
-Camera::Camera(float left, float right, float bottom, float top)
-    : left_(left), right_(right), bottom_(bottom), top_(top) {}
-
-Camera::Camera(const Size &viewport)
-    : left_(0.0f), right_(viewport.width), bottom_(viewport.height),
-      top_(0.0f) {}
-
-void Camera::setPosition(const Vec2 &position) {
-  position_ = position;
-  viewDirty_ = true;
-}
-
-void Camera::setPosition(float x, float y) {
-  position_.x = x;
-  position_.y = y;
-  viewDirty_ = true;
-}
-
-void Camera::setRotation(float degrees) {
-  rotation_ = degrees;
-  viewDirty_ = true;
-}
-
-void Camera::setZoom(float zoom) {
-  zoom_ = zoom;
-  viewDirty_ = true;
-  projDirty_ = true;
-}
-
-void Camera::setViewport(float left, float right, float bottom, float top) {
-  left_ = left;
-  right_ = right;
-  bottom_ = bottom;
-  top_ = top;
-  projDirty_ = true;
-}
-
-void Camera::setViewport(const Rect &rect) {
-  left_ = rect.left();
-  right_ = rect.right();
-  bottom_ = rect.bottom();
-  top_ = rect.top();
-  projDirty_ = true;
-}
-
-Rect Camera::getViewport() const {
-  return Rect(left_, top_, right_ - left_, bottom_ - top_);
-}
-
-glm::mat4 Camera::getViewMatrix() const {
-  if (viewDirty_) {
-    viewMatrix_ = glm::mat4(1.0f);
-    // 对于2D相机，我们只需要平移（注意Y轴方向）
-    viewMatrix_ = glm::translate(viewMatrix_,
-                                 glm::vec3(-position_.x, -position_.y, 0.0f));
-    viewDirty_ = false;
-  }
-  return viewMatrix_;
-}
-
-glm::mat4 Camera::getProjectionMatrix() const {
-  if (projDirty_) {
-    // 对于2D游戏，Y轴向下增长（屏幕坐标系）
-    // OpenGL默认Y轴向上，所以需要反转Y轴
-    // glm::ortho(left, right, bottom, top)
-    // 为了Y轴向下：传入 (bottom=height, top=0)，这样Y轴翻转
-    projMatrix_ = glm::ortho(
-        left_, right_, // X轴：从左到右
-        bottom_, top_, // Y轴：从下到上（传入bottom>top，实现Y轴向下增长）
-        -1.0f, 1.0f);
-    projDirty_ = false;
-  }
-  return projMatrix_;
-}
-
-glm::mat4 Camera::getViewProjectionMatrix() const {
-  // 对于2D相机，我们主要依赖投影矩阵
-  // 视口变换已经处理了坐标系转换
-  return getProjectionMatrix();
-}
-
-Vec2 Camera::screenToWorld(const Vec2 &screenPos) const {
-  // 屏幕坐标直接映射到世界坐标（在2D中通常相同）
-  return screenPos;
-}
-
-Vec2 Camera::worldToScreen(const Vec2 &worldPos) const {
-  // 世界坐标直接映射到屏幕坐标（在2D中通常相同）
-  return worldPos;
-}
-
-Vec2 Camera::screenToWorld(float x, float y) const {
-  return screenToWorld(Vec2(x, y));
-}
-
-Vec2 Camera::worldToScreen(float x, float y) const {
-  return worldToScreen(Vec2(x, y));
-}
-
-void Camera::move(const Vec2 &offset) {
-  position_ += offset;
-  viewDirty_ = true;
-}
-
-void Camera::move(float x, float y) {
-  position_.x += x;
-  position_.y += y;
-  viewDirty_ = true;
-}
-
-void Camera::setBounds(const Rect &bounds) {
-  bounds_ = bounds;
-  hasBounds_ = true;
-}
-
-void Camera::clearBounds() { hasBounds_ = false; }
-
-void Camera::clampToBounds() {
-  if (!hasBounds_)
-    return;
-
-  float viewportWidth = (right_ - left_) / zoom_;
-  float viewportHeight = (bottom_ - top_) / zoom_;
-
-  float minX = bounds_.left() + viewportWidth * 0.5f;
-  float maxX = bounds_.right() - viewportWidth * 0.5f;
-  float minY = bounds_.top() + viewportHeight * 0.5f;
-  float maxY = bounds_.bottom() - viewportHeight * 0.5f;
-
-  if (minX > maxX) {
-    position_.x = bounds_.center().x;
-  } else {
-    position_.x = std::clamp(position_.x, minX, maxX);
-  }
-
-  if (minY > maxY) {
-    position_.y = bounds_.center().y;
-  } else {
-    position_.y = std::clamp(position_.y, minY, maxY);
-  }
-
-  viewDirty_ = true;
-}
-
-void Camera::lookAt(const Vec2 &target) {
-  position_ = target;
-  viewDirty_ = true;
-}
-
-} // namespace extra2d
diff --git a/src/renderer/render_backend.cpp b/src/renderer/render_backend.cpp
deleted file mode 100644
index bb9b578..0000000
--- a/src/renderer/render_backend.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <graphics/opengl/gl_renderer.h>
-#include <renderer/renderer.h>
-
-namespace extra2d {
-
-UniquePtr<Renderer> Renderer::create(BackendType type) {
-  switch (type) {
-  case BackendType::OpenGL:
-    return unique<GLRenderer>();
-  default:
-    return nullptr;
-  }
-}
-
-} // namespace extra2d
diff --git a/src/renderer/render_command.cpp b/src/renderer/render_command.cpp
deleted file mode 100644
index 7aadd09..0000000
--- a/src/renderer/render_command.cpp
+++ /dev/null
@@ -1,169 +0,0 @@
-#include <renderer/render_command.h>
-#include <algorithm>
-
-namespace extra2d {
-
-// ============================================================================
-// RenderCommand 便捷构造函数
-// ============================================================================
-
-RenderCommand RenderCommand::makeSprite(const Texture* tex, const Rect& dest, 
-                                         const Rect& src, const Color& tint,
-                                         float rot, const Vec2& anc,
-                                         uint32_t lyr) {
-  RenderCommand cmd;
-  cmd.type = RenderCommandType::Sprite;
-  cmd.layer = lyr;
-  cmd.transform = glm::mat4(1.0f);
-  
-  SpriteCommandData data;
-  data.texture = tex;
-  data.destRect = dest;
-  data.srcRect = src;
-  data.tint = tint;
-  data.rotation = rot;
-  data.anchor = anc;
-  // 生成排序键：纹理指针的高位 + 层级的低位
-  data.sortKey = (reinterpret_cast<uintptr_t>(tex) >> 4) & 0xFFFFFFF0;
-  data.sortKey |= (lyr & 0xF);
-  
-  cmd.data = data;
-  return cmd;
-}
-
-RenderCommand RenderCommand::makeLine(const Vec2& s, const Vec2& e, const Color& c, 
-                                       float w, uint32_t lyr) {
-  RenderCommand cmd;
-  cmd.type = RenderCommandType::Line;
-  cmd.layer = lyr;
-  cmd.transform = glm::mat4(1.0f);
-  
-  LineCommandData data;
-  data.start = s;
-  data.end = e;
-  data.color = c;
-  data.width = w;
-  
-  cmd.data = data;
-  return cmd;
-}
-
-RenderCommand RenderCommand::makeRect(const Rect& r, const Color& c, 
-                                       float w, bool fill, uint32_t lyr) {
-  RenderCommand cmd;
-  cmd.type = fill ? RenderCommandType::FilledRect : RenderCommandType::Rect;
-  cmd.layer = lyr;
-  cmd.transform = glm::mat4(1.0f);
-  
-  RectCommandData data;
-  data.rect = r;
-  data.color = c;
-  data.width = w;
-  data.filled = fill;
-  
-  cmd.data = data;
-  return cmd;
-}
-
-// ============================================================================
-// RenderCommandBuffer 实现
-// ============================================================================
-
-RenderCommandBuffer::RenderCommandBuffer() : nextOrder_(0) {
-  commands_.reserve(INITIAL_CAPACITY);
-}
-
-RenderCommandBuffer::~RenderCommandBuffer() = default;
-
-void RenderCommandBuffer::addCommand(const RenderCommand& cmd) {
-  if (commands_.size() >= MAX_CAPACITY) {
-    // 缓冲区已满，可能需要立即刷新
-    return;
-  }
-  
-  RenderCommand copy = cmd;
-  copy.order = nextOrder_++;
-  commands_.push_back(std::move(copy));
-}
-
-void RenderCommandBuffer::addCommand(RenderCommand&& cmd) {
-  if (commands_.size() >= MAX_CAPACITY) {
-    return;
-  }
-  
-  cmd.order = nextOrder_++;
-  commands_.push_back(std::move(cmd));
-}
-
-RenderCommand& RenderCommandBuffer::emplaceCommand() {
-  if (commands_.size() >= MAX_CAPACITY) {
-    // 如果已满，返回一个虚拟命令（不应该发生）
-    static RenderCommand dummy;
-    return dummy;
-  }
-  
-  commands_.emplace_back();
-  commands_.back().order = nextOrder_++;
-  return commands_.back();
-}
-
-void RenderCommandBuffer::sortCommands() {
-  // 按以下优先级排序：
-  // 1. 层级 (layer) - 低层级先渲染
-  // 2. 命令类型 - 精灵类命令优先批处理
-  // 3. 纹理/材质 - 相同纹理的精灵连续渲染
-  // 4. 提交顺序 - 保证稳定性
-  
-  std::sort(commands_.begin(), commands_.end(), compareCommands);
-}
-
-void RenderCommandBuffer::clear() {
-  commands_.clear();
-  nextOrder_ = 0;
-}
-
-void RenderCommandBuffer::reserve(size_t capacity) {
-  if (capacity <= MAX_CAPACITY) {
-    commands_.reserve(capacity);
-  }
-}
-
-bool RenderCommandBuffer::compareCommands(const RenderCommand& a, const RenderCommand& b) {
-  // 首先按层级排序
-  if (a.layer != b.layer) {
-    return a.layer < b.layer;
-  }
-  
-  // 然后按类型排序（精灵类命令放在一起以便批处理）
-  if (a.type != b.type) {
-    // 精灵和文本命令优先（需要纹理）
-    bool aIsSprite = (a.type == RenderCommandType::Sprite || 
-                      a.type == RenderCommandType::Text);
-    bool bIsSprite = (b.type == RenderCommandType::Sprite || 
-                      b.type == RenderCommandType::Text);
-    
-    if (aIsSprite != bIsSprite) {
-      return aIsSprite > bIsSprite; // 精灵类命令在前
-    }
-    
-    return static_cast<uint8_t>(a.type) < static_cast<uint8_t>(b.type);
-  }
-  
-  // 对于精灵命令，按纹理排序
-  if (a.type == RenderCommandType::Sprite && b.type == RenderCommandType::Sprite) {
-    const auto& dataA = std::get<SpriteCommandData>(a.data);
-    const auto& dataB = std::get<SpriteCommandData>(b.data);
-    if (dataA.texture != dataB.texture) {
-      return dataA.texture < dataB.texture;
-    }
-    // 相同纹理时按 sortKey 排序
-    if (dataA.sortKey != dataB.sortKey) {
-      return dataA.sortKey < dataB.sortKey;
-    }
-  }
-  
-  // 最后按提交顺序排序（保证稳定性）
-  return a.order < b.order;
-}
-
-} // namespace extra2d
diff --git a/src/renderer/render_target.cpp b/src/renderer/render_target.cpp
deleted file mode 100644
index 6bb6624..0000000
--- a/src/renderer/render_target.cpp
+++ /dev/null
@@ -1,586 +0,0 @@
-#include <glad/glad.h>
-#include <graphics/opengl/gl_texture.h>
-#include <renderer/render_target.h>
-#include <utils/logger.h>
-
-#define STB_IMAGE_WRITE_IMPLEMENTATION
-#include <stb/stb_image_write.h>
-
-namespace extra2d {
-
-// ============================================================================
-// RenderTarget实现
-// ============================================================================
-
-RenderTarget::RenderTarget() = default;
-
-RenderTarget::~RenderTarget() { destroy(); }
-
-RenderTarget::RenderTarget(RenderTarget &&other) noexcept
-    : fbo_(other.fbo_), rbo_(other.rbo_),
-      colorTexture_(std::move(other.colorTexture_)),
-      depthTexture_(std::move(other.depthTexture_)), width_(other.width_),
-      height_(other.height_), colorFormat_(other.colorFormat_),
-      hasDepth_(other.hasDepth_), hasStencil_(other.hasStencil_),
-      samples_(other.samples_) {
-  other.fbo_ = 0;
-  other.rbo_ = 0;
-  other.width_ = 0;
-  other.height_ = 0;
-}
-
-RenderTarget &RenderTarget::operator=(RenderTarget &&other) noexcept {
-  if (this != &other) {
-    destroy();
-
-    fbo_ = other.fbo_;
-    rbo_ = other.rbo_;
-    colorTexture_ = std::move(other.colorTexture_);
-    depthTexture_ = std::move(other.depthTexture_);
-    width_ = other.width_;
-    height_ = other.height_;
-    colorFormat_ = other.colorFormat_;
-    hasDepth_ = other.hasDepth_;
-    hasStencil_ = other.hasStencil_;
-    samples_ = other.samples_;
-
-    other.fbo_ = 0;
-    other.rbo_ = 0;
-    other.width_ = 0;
-    other.height_ = 0;
-  }
-  return *this;
-}
-
-bool RenderTarget::create(const RenderTargetConfig &config) {
-  destroy();
-
-  width_ = config.width;
-  height_ = config.height;
-  colorFormat_ = config.colorFormat;
-  hasDepth_ = config.hasDepth;
-  hasStencil_ = config.hasStencil;
-  samples_ = config.samples;
-
-  if (!createFBO()) {
-    E2D_ERROR("创建渲染目标失败: {}x{}", width_, height_);
-    return false;
-  }
-
-  E2D_INFO("创建渲染目标: {}x{} (深度:{}, 模板:{}, 采样:{})", width_, height_,
-           hasDepth_, hasStencil_, samples_);
-
-  return true;
-}
-
-bool RenderTarget::createFromTexture(IntrusivePtr<Texture> texture, bool hasDepth) {
-  if (!texture || !texture->isValid()) {
-    E2D_ERROR("无效的颜色纹理");
-    return false;
-  }
-
-  destroy();
-
-  width_ = texture->width();
-  height_ = texture->height();
-  colorFormat_ = texture->getFormat();
-  hasDepth_ = hasDepth;
-  hasStencil_ = false;
-  samples_ = 1;
-
-  colorTexture_ = texture;
-
-  // 创建FBO
-  glGenFramebuffers(1, &fbo_);
-  glBindFramebuffer(GL_FRAMEBUFFER, fbo_);
-
-  // 附加颜色纹理
-  GLuint texId = static_cast<GLuint>(
-      reinterpret_cast<uintptr_t>(texture->getNativeHandle()));
-  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
-                         texId, 0);
-
-  // 创建深度缓冲（如果需要）
-  if (hasDepth_) {
-    glGenRenderbuffers(1, &rbo_);
-    glBindRenderbuffer(GL_RENDERBUFFER, rbo_);
-    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, width_,
-                          height_);
-    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
-                              GL_RENDERBUFFER, rbo_);
-    glBindRenderbuffer(GL_RENDERBUFFER, 0);
-  }
-
-  // 检查完整性
-  GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
-  glBindFramebuffer(GL_FRAMEBUFFER, 0);
-
-  if (status != GL_FRAMEBUFFER_COMPLETE) {
-    E2D_ERROR("FBO不完整: {:#x}", status);
-    destroy();
-    return false;
-  }
-
-  E2D_INFO("从纹理创建渲染目标: {}x{}", width_, height_);
-  return true;
-}
-
-void RenderTarget::destroy() {
-  deleteFBO();
-
-  colorTexture_.reset();
-  depthTexture_.reset();
-
-  width_ = 0;
-  height_ = 0;
-}
-
-void RenderTarget::bind() {
-  if (!isValid()) {
-    return;
-  }
-
-  glBindFramebuffer(GL_FRAMEBUFFER, fbo_);
-  glViewport(0, 0, width_, height_);
-}
-
-void RenderTarget::unbind() { bindDefault(); }
-
-void RenderTarget::clear(const Color &color) {
-  if (!isValid()) {
-    return;
-  }
-
-  bind();
-
-  GLbitfield mask = GL_COLOR_BUFFER_BIT;
-  if (hasDepth_) {
-    mask |= GL_DEPTH_BUFFER_BIT;
-    glClearDepthf(1.0f); // GLES 使用 glClearDepthf
-  }
-  if (hasStencil_) {
-    mask |= GL_STENCIL_BUFFER_BIT;
-    glClearStencil(0);
-  }
-
-  glClearColor(color.r, color.g, color.b, color.a);
-  glClear(mask);
-}
-
-void RenderTarget::setViewport(int x, int y, int width, int height) {
-  if (!isValid()) {
-    return;
-  }
-
-  bind();
-  glViewport(x, y, width, height);
-}
-
-void RenderTarget::getFullViewport(int &x, int &y, int &width,
-                                   int &height) const {
-  x = 0;
-  y = 0;
-  width = width_;
-  height = height_;
-}
-
-bool RenderTarget::resize(int width, int height) {
-  if (!isValid()) {
-    return false;
-  }
-
-  RenderTargetConfig config;
-  config.width = width;
-  config.height = height;
-  config.colorFormat = colorFormat_;
-  config.hasDepth = hasDepth_;
-  config.hasStencil = hasStencil_;
-  config.samples = samples_;
-
-  return create(config);
-}
-
-void RenderTarget::copyTo(RenderTarget &target) {
-  if (!isValid() || !target.isValid()) {
-    return;
-  }
-
-  // 使用glBlitFramebuffer复制
-  glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo_);
-  glBindFramebuffer(GL_DRAW_FRAMEBUFFER, target.fbo_);
-
-  GLbitfield mask = GL_COLOR_BUFFER_BIT;
-  if (hasDepth_ && target.hasDepth_) {
-    mask |= GL_DEPTH_BUFFER_BIT;
-  }
-
-  glBlitFramebuffer(0, 0, width_, height_, 0, 0, target.width_, target.height_,
-                    mask, GL_LINEAR);
-
-  glBindFramebuffer(GL_FRAMEBUFFER, 0);
-}
-
-void RenderTarget::blitTo(RenderTarget &target, bool color, bool depth) {
-  if (!isValid() || !target.isValid()) {
-    return;
-  }
-
-  // 使用glBlitFramebuffer复制
-  glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo_);
-  glBindFramebuffer(GL_DRAW_FRAMEBUFFER, target.getFBO());
-
-  GLbitfield mask = 0;
-  if (color) {
-    mask |= GL_COLOR_BUFFER_BIT;
-  }
-  if (depth && hasDepth_ && target.hasDepth_) {
-    mask |= GL_DEPTH_BUFFER_BIT;
-  }
-
-  if (mask != 0) {
-    glBlitFramebuffer(0, 0, width_, height_, 0, 0, target.width(),
-                      target.height(), mask, GL_LINEAR);
-  }
-
-  glBindFramebuffer(GL_FRAMEBUFFER, 0);
-}
-
-void RenderTarget::copyToScreen(int screenWidth, int screenHeight) {
-  if (!isValid()) {
-    return;
-  }
-
-  glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo_);
-  glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
-
-  glBlitFramebuffer(0, 0, width_, height_, 0, 0, screenWidth, screenHeight,
-                    GL_COLOR_BUFFER_BIT, GL_LINEAR);
-
-  glBindFramebuffer(GL_FRAMEBUFFER, 0);
-}
-
-bool RenderTarget::saveToFile(const std::string &filepath) {
-  if (!isValid() || !colorTexture_) {
-    return false;
-  }
-
-  // 读取像素数据
-  std::vector<uint8_t> pixels(width_ * height_ * 4);
-
-  bind();
-  glReadPixels(0, 0, width_, height_, GL_RGBA, GL_UNSIGNED_BYTE, pixels.data());
-  unbind();
-
-  // 翻转Y轴（OpenGL坐标系原点在左下角，PNG需要左上角原点）
-  std::vector<uint8_t> flipped(width_ * height_ * 4);
-  for (int y = 0; y < height_; ++y) {
-    for (int x = 0; x < width_; ++x) {
-      int srcIdx = ((height_ - 1 - y) * width_ + x) * 4;
-      int dstIdx = (y * width_ + x) * 4;
-      for (int c = 0; c < 4; ++c) {
-        flipped[dstIdx + c] = pixels[srcIdx + c];
-      }
-    }
-  }
-
-  // 使用stb_image_write保存为PNG
-  int result = stbi_write_png(filepath.c_str(), width_, height_, 4,
-                              flipped.data(), width_ * 4);
-
-  if (result == 0) {
-    E2D_ERROR("保存渲染目标到PNG失败: {}", filepath);
-    return false;
-  }
-
-  E2D_INFO("保存渲染目标到: {}", filepath);
-  return true;
-}
-
-IntrusivePtr<RenderTarget>
-RenderTarget::createFromConfig(const RenderTargetConfig &config) {
-  auto rt = makeRef<RenderTarget>();
-  if (rt->create(config)) {
-    return rt;
-  }
-  return nullptr;
-}
-
-GLuint RenderTarget::getCurrentFBO() {
-  GLint fbo = 0;
-  glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fbo);
-  return static_cast<GLuint>(fbo);
-}
-
-void RenderTarget::bindDefault() { glBindFramebuffer(GL_FRAMEBUFFER, 0); }
-
-// ============================================================================
-// 内部方法
-// ============================================================================
-
-bool RenderTarget::createFBO() {
-  // 创建颜色纹理
-  colorTexture_ = GLTexture::create(width_, height_, colorFormat_);
-  if (!colorTexture_ || !colorTexture_->isValid()) {
-    E2D_ERROR("创建颜色纹理失败");
-    return false;
-  }
-
-  // 创建FBO
-  glGenFramebuffers(1, &fbo_);
-  glBindFramebuffer(GL_FRAMEBUFFER, fbo_);
-
-  // 附加颜色纹理
-  GLuint colorTexId =
-      static_cast<GLTexture *>(colorTexture_.get())->getTextureID();
-  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
-                         colorTexId, 0);
-
-  // 创建深度/模板缓冲
-  if (hasDepth_ || hasStencil_) {
-    glGenRenderbuffers(1, &rbo_);
-    glBindRenderbuffer(GL_RENDERBUFFER, rbo_);
-
-    if (hasDepth_ && hasStencil_) {
-      glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, width_,
-                            height_);
-      glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
-                                GL_RENDERBUFFER, rbo_);
-      glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
-                                GL_RENDERBUFFER, rbo_);
-    } else if (hasDepth_) {
-      glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, width_,
-                            height_);
-      glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
-                                GL_RENDERBUFFER, rbo_);
-    }
-
-    glBindRenderbuffer(GL_RENDERBUFFER, 0);
-  }
-
-  // 检查完整性
-  GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
-  glBindFramebuffer(GL_FRAMEBUFFER, 0);
-
-  if (status != GL_FRAMEBUFFER_COMPLETE) {
-    E2D_ERROR("FBO创建失败，状态: {:#x}", status);
-    deleteFBO();
-    return false;
-  }
-
-  return true;
-}
-
-void RenderTarget::deleteFBO() {
-  if (rbo_ != 0) {
-    glDeleteRenderbuffers(1, &rbo_);
-    rbo_ = 0;
-  }
-
-  if (fbo_ != 0) {
-    glDeleteFramebuffers(1, &fbo_);
-    fbo_ = 0;
-  }
-}
-
-// ============================================================================
-// MultisampleRenderTarget实现
-// ============================================================================
-
-bool MultisampleRenderTarget::create(int width, int height, int samples) {
-  // 先销毁现有的
-  destroy();
-
-  width_ = width;
-  height_ = height;
-  samples_ = samples;
-  hasDepth_ = true;
-  hasStencil_ = false;
-  colorFormat_ = PixelFormat::RGBA8;
-
-  // 创建FBO
-  glGenFramebuffers(1, &fbo_);
-  glBindFramebuffer(GL_FRAMEBUFFER, fbo_);
-
-  // 创建多重采样颜色渲染缓冲
-  glGenRenderbuffers(1, &colorRBO_);
-  glBindRenderbuffer(GL_RENDERBUFFER, colorRBO_);
-  glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples, GL_RGBA8, width,
-                                   height);
-  glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
-                            GL_RENDERBUFFER, colorRBO_);
-  glBindRenderbuffer(GL_RENDERBUFFER, 0);
-
-  // 创建多重采样深度渲染缓冲
-  glGenRenderbuffers(1, &rbo_);
-  glBindRenderbuffer(GL_RENDERBUFFER, rbo_);
-  glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples,
-                                   GL_DEPTH_COMPONENT24, width, height);
-  glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
-                            GL_RENDERBUFFER, rbo_);
-  glBindRenderbuffer(GL_RENDERBUFFER, 0);
-
-  // 检查完整性
-  GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
-  glBindFramebuffer(GL_FRAMEBUFFER, 0);
-
-  if (status != GL_FRAMEBUFFER_COMPLETE) {
-    E2D_ERROR("多重采样FBO创建失败，状态: {:#x}", status);
-    destroy();
-    return false;
-  }
-
-  E2D_INFO("创建多重采样渲染目标: {}x{} (采样数: {})", width, height, samples);
-  return true;
-}
-
-void MultisampleRenderTarget::destroy() {
-  // 删除颜色渲染缓冲
-  if (colorRBO_ != 0) {
-    glDeleteRenderbuffers(1, &colorRBO_);
-    colorRBO_ = 0;
-  }
-
-  // 调用基类destroy
-  RenderTarget::destroy();
-}
-
-void MultisampleRenderTarget::resolveTo(RenderTarget &target) {
-  if (!isValid() || !target.isValid()) {
-    return;
-  }
-
-  // 使用glBlitFramebuffer解析多重采样
-  glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo_);
-  glBindFramebuffer(GL_DRAW_FRAMEBUFFER, target.getFBO());
-
-  glBlitFramebuffer(0, 0, width_, height_, 0, 0, target.width(),
-                    target.height(), GL_COLOR_BUFFER_BIT, GL_LINEAR);
-
-  glBindFramebuffer(GL_FRAMEBUFFER, 0);
-}
-
-// ============================================================================
-// RenderTargetStack实现
-// ============================================================================
-
-RenderTargetStack &RenderTargetStack::getInstance() {
-  static RenderTargetStack instance;
-  return instance;
-}
-
-void RenderTargetStack::push(RenderTarget *target) {
-  std::lock_guard<std::mutex> lock(mutex_);
-
-  if (target) {
-    stack_.push_back(target);
-    target->bind();
-  }
-}
-
-void RenderTargetStack::pop() {
-  std::lock_guard<std::mutex> lock(mutex_);
-
-  if (!stack_.empty()) {
-    stack_.pop_back();
-  }
-
-  // 绑定新的当前渲染目标
-  if (!stack_.empty()) {
-    stack_.back()->bind();
-  } else {
-    RenderTarget::bindDefault();
-  }
-}
-
-RenderTarget *RenderTargetStack::getCurrent() const {
-  std::lock_guard<std::mutex> lock(mutex_);
-
-  if (stack_.empty()) {
-    return nullptr;
-  }
-  return stack_.back();
-}
-
-size_t RenderTargetStack::size() const {
-  std::lock_guard<std::mutex> lock(mutex_);
-  return stack_.size();
-}
-
-void RenderTargetStack::clear() {
-  std::lock_guard<std::mutex> lock(mutex_);
-  stack_.clear();
-  RenderTarget::bindDefault();
-}
-
-// ============================================================================
-// RenderTargetManager实现
-// ============================================================================
-
-RenderTargetManager &RenderTargetManager::getInstance() {
-  static RenderTargetManager instance;
-  return instance;
-}
-
-bool RenderTargetManager::init(int width, int height) {
-  if (initialized_) {
-    return true;
-  }
-
-  // 创建默认渲染目标
-  RenderTargetConfig config;
-  config.width = width;
-  config.height = height;
-  config.hasDepth = true;
-  config.hasStencil = false;
-
-  defaultRenderTarget_ = RenderTarget::createFromConfig(config);
-  if (!defaultRenderTarget_) {
-    E2D_ERROR("创建默认渲染目标失败");
-    return false;
-  }
-
-  initialized_ = true;
-  E2D_INFO("渲染目标管理器初始化完成: {}x{}", width, height);
-  return true;
-}
-
-void RenderTargetManager::shutdown() {
-  if (!initialized_) {
-    return;
-  }
-
-  renderTargets_.clear();
-  defaultRenderTarget_.reset();
-  initialized_ = false;
-
-  E2D_INFO("渲染目标管理器已关闭");
-}
-
-IntrusivePtr<RenderTarget>
-RenderTargetManager::createRenderTarget(const RenderTargetConfig &config) {
-  if (!initialized_) {
-    E2D_ERROR("渲染目标管理器未初始化");
-    return nullptr;
-  }
-
-  auto rt = RenderTarget::createFromConfig(config);
-  if (rt) {
-    renderTargets_.push_back(rt);
-  }
-  return rt;
-}
-
-void RenderTargetManager::resize(int width, int height) {
-  if (!initialized_) {
-    return;
-  }
-
-  // 调整默认渲染目标大小
-  if (defaultRenderTarget_) {
-    defaultRenderTarget_->resize(width, height);
-  }
-
-  E2D_INFO("渲染目标管理器调整大小: {}x{}", width, height);
-}
-
-} // namespace extra2d
diff --git a/src/resource/resource_manager.cpp b/src/resource/resource_manager.cpp
deleted file mode 100644
index 5a782fb..0000000
--- a/src/resource/resource_manager.cpp
+++ /dev/null
@@ -1,1065 +0,0 @@
-#include <algorithm>
-#include <audio/audio_engine.h>
-#include <cstring>
-#include <graphics/opengl/gl_font_atlas.h>
-#include <graphics/opengl/gl_texture.h>
-#include <resource/resource_manager.h>
-#include <sys/stat.h>
-#include <utils/logger.h>
-
-// Windows 平台需要包含的头文件
-#ifdef _WIN32
-#include <windows.h>
-#endif
-
-namespace extra2d {
-
-// 辅助函数：检查文件是否存在
-static bool fileExists(const std::string &path) {
-  struct stat st;
-  return stat(path.c_str(), &st) == 0;
-}
-
-// 辅助函数：检查是否是 romfs 路径
-static bool isRomfsPath(const std::string &path) {
-  return path.find("romfs:/") == 0 || path.find("romfs:") == 0;
-}
-
-// 辅助函数：获取可执行文件所在目录（Windows 平台）
-#ifdef _WIN32
-static std::string getExecutableDirectory() {
-  char buffer[MAX_PATH];
-  DWORD len = GetModuleFileNameA(NULL, buffer, MAX_PATH);
-  if (len > 0 && len < MAX_PATH) {
-    std::string exePath(buffer, len);
-    size_t lastSlash = exePath.find_last_of("\\/");
-    if (lastSlash != std::string::npos) {
-      return exePath.substr(0, lastSlash);
-    }
-  }
-  return "";
-}
-#endif
-
-// 解析资源路径（优先尝试 romfs:/ 前缀，然后
-// sdmc:/，最后尝试相对于可执行文件的路径）
-static std::string resolveResourcePath(const std::string &filepath) {
-  // 如果已经是 romfs 或 sdmc 路径，直接返回
-  if (isRomfsPath(filepath) || filepath.find("sdmc:/") == 0) {
-    return filepath;
-  }
-
-  // 优先尝试 romfs:/ 前缀的路径（Switch 平台）
-  std::string romfsPath = "romfs:/" + filepath;
-  if (fileExists(romfsPath)) {
-    return romfsPath;
-  }
-
-  // 尝试 sdmc:/ 前缀的路径（Switch SD卡）
-  std::string sdmcPath = "sdmc:/" + filepath;
-  if (fileExists(sdmcPath)) {
-    return sdmcPath;
-  }
-
-  // 如果都不存在，尝试原路径
-  if (fileExists(filepath)) {
-    return filepath;
-  }
-
-  // Windows 平台：尝试相对于可执行文件的路径
-#ifdef _WIN32
-  std::string exeDir = getExecutableDirectory();
-  if (!exeDir.empty()) {
-    std::string exeRelativePath = exeDir + "/" + filepath;
-    if (fileExists(exeRelativePath)) {
-      return exeRelativePath;
-    }
-  }
-#endif
-
-  return "";
-}
-
-ResourceManager::ResourceManager() = default;
-
-ResourceManager::~ResourceManager() { shutdownAsyncLoader(); }
-
-ResourceManager &ResourceManager::getInstance() {
-  static ResourceManager instance;
-  return instance;
-}
-
-// ============================================================================
-// 异步加载系统
-// ============================================================================
-
-void ResourceManager::initAsyncLoader() {
-  if (asyncRunning_) {
-    return;
-  }
-
-  asyncRunning_ = true;
-  asyncThread_ =
-      std::make_unique<std::thread>(&ResourceManager::asyncLoadLoop, this);
-  E2D_LOG_INFO("ResourceManager: async loader initialized");
-}
-
-void ResourceManager::shutdownAsyncLoader() {
-  if (!asyncRunning_) {
-    return;
-  }
-
-  asyncRunning_ = false;
-  asyncCondition_.notify_all();
-
-  if (asyncThread_ && asyncThread_->joinable()) {
-    asyncThread_->join();
-  }
-
-  E2D_LOG_INFO("ResourceManager: async loader shutdown");
-}
-
-void ResourceManager::waitForAsyncLoads() {
-  while (pendingAsyncLoads_ > 0) {
-    std::this_thread::yield();
-  }
-}
-
-bool ResourceManager::hasPendingAsyncLoads() const {
-  return pendingAsyncLoads_ > 0;
-}
-
-void ResourceManager::asyncLoadLoop() {
-  while (asyncRunning_) {
-    AsyncLoadTask task;
-
-    {
-      std::unique_lock<std::mutex> lock(asyncQueueMutex_);
-      asyncCondition_.wait(
-          lock, [this] { return !asyncTaskQueue_.empty() || !asyncRunning_; });
-
-      if (!asyncRunning_) {
-        break;
-      }
-
-      if (asyncTaskQueue_.empty()) {
-        continue;
-      }
-
-      task = std::move(asyncTaskQueue_.front());
-      asyncTaskQueue_.pop();
-    }
-
-    // 执行加载
-    auto texture = loadTextureInternal(task.filepath, task.format);
-
-    // 回调
-    if (task.callback) {
-      task.callback(texture);
-    }
-
-    // 设置 promise
-    task.promise.set_value(texture);
-
-    pendingAsyncLoads_--;
-  }
-}
-
-// ============================================================================
-// 纹理资源 - 同步加载
-// ============================================================================
-
-IntrusivePtr<Texture> ResourceManager::loadTexture(const std::string &filepath) {
-  return loadTexture(filepath, false, TextureFormat::Auto);
-}
-
-IntrusivePtr<Texture> ResourceManager::loadTexture(const std::string &filepath,
-                                          bool async) {
-  return loadTexture(filepath, async, TextureFormat::Auto);
-}
-
-IntrusivePtr<Texture> ResourceManager::loadTexture(const std::string &filepath,
-                                          bool async, TextureFormat format) {
-  if (async) {
-    // 异步加载：返回空指针，实际纹理通过回调获取
-    loadTextureAsync(filepath, format, nullptr);
-    return nullptr;
-  }
-
-  return loadTextureInternal(filepath, format);
-}
-
-void ResourceManager::loadTextureAsync(const std::string &filepath,
-                                       TextureLoadCallback callback) {
-  loadTextureAsync(filepath, TextureFormat::Auto, callback);
-}
-
-void ResourceManager::loadTextureAsync(const std::string &filepath,
-                                       TextureFormat format,
-                                       TextureLoadCallback callback) {
-  // 确保异步加载系统已启动
-  if (!asyncRunning_) {
-    initAsyncLoader();
-  }
-
-  // 检查缓存
-  {
-    std::lock_guard<std::mutex> lock(textureMutex_);
-    auto it = textureCache_.find(filepath);
-    if (it != textureCache_.end()) {
-      // 缓存命中，更新LRU并立即回调
-      touchTexture(filepath);
-      textureHitCount_++;
-      it->second.accessCount++;
-      if (callback) {
-        callback(it->second.texture);
-      }
-      return;
-    }
-  }
-
-  // 添加到异步任务队列
-  AsyncLoadTask task;
-  task.filepath = filepath;
-  task.format = format;
-  task.callback = callback;
-
-  {
-    std::lock_guard<std::mutex> lock(asyncQueueMutex_);
-    asyncTaskQueue_.push(std::move(task));
-  }
-
-  pendingAsyncLoads_++;
-  asyncCondition_.notify_one();
-
-  E2D_LOG_DEBUG("ResourceManager: queued async texture load: {}", filepath);
-}
-
-IntrusivePtr<Texture> ResourceManager::loadTextureInternal(const std::string &filepath,
-                                                  TextureFormat format) {
-  std::lock_guard<std::mutex> lock(textureMutex_);
-
-  // 检查缓存
-  auto it = textureCache_.find(filepath);
-  if (it != textureCache_.end()) {
-    // 缓存命中
-    touchTexture(filepath);
-    textureHitCount_++;
-    it->second.accessCount++;
-    E2D_LOG_TRACE("ResourceManager: texture cache hit: {}", filepath);
-    return it->second.texture;
-  }
-
-  // 缓存未命中
-  textureMissCount_++;
-
-  // 解析资源路径（优先尝试 romfs:/ 前缀）
-  std::string fullPath = resolveResourcePath(filepath);
-  if (fullPath.empty()) {
-    E2D_LOG_ERROR("ResourceManager: texture file not found: {}", filepath);
-    return nullptr;
-  }
-
-  // 创建新纹理
-  try {
-    auto texture = makeRef<GLTexture>(fullPath);
-    if (!texture->isValid()) {
-      E2D_LOG_ERROR("ResourceManager: failed to load texture: {}", filepath);
-      return nullptr;
-    }
-
-    // 如果需要压缩，处理纹理格式
-    if (format != TextureFormat::Auto && format != TextureFormat::RGBA8) {
-      // 注意：实际压缩需要在纹理创建时处理
-      // 这里仅记录日志，实际实现需要在 GLTexture 中支持
-      E2D_LOG_DEBUG("ResourceManager: texture format {} requested for {}",
-                    static_cast<int>(format), filepath);
-    }
-
-    // 检查是否需要清理缓存
-    evictTexturesIfNeeded();
-
-    // 计算纹理大小
-    size_t textureSize = calculateTextureSize(
-        texture->width(), texture->height(), texture->getFormat());
-
-    // 分配LRU节点
-    uint32_t lruIndex = allocateLRUNode(filepath);
-
-    // 创建缓存项
-    TextureCacheEntry entry;
-    entry.texture = texture;
-    entry.size = textureSize;
-    entry.lastAccessTime = 0.0f;
-    entry.accessCount = 1;
-
-    // 添加到缓存
-    textureCache_[filepath] = entry;
-    totalTextureSize_ += textureSize;
-
-    // 添加到LRU链表头部
-    moveToFront(lruIndex);
-
-    E2D_LOG_DEBUG("ResourceManager: loaded texture: {} ({} KB)", filepath,
-                  textureSize / 1024);
-    return texture;
-  } catch (...) {
-    E2D_LOG_ERROR("ResourceManager: exception loading texture: {}", filepath);
-    return nullptr;
-  }
-}
-
-TextureFormat ResourceManager::selectBestFormat(TextureFormat requested) const {
-  if (requested != TextureFormat::Auto) {
-    return requested;
-  }
-
-  // 自动选择最佳格式
-  // 检查支持的扩展
-  // 这里简化处理，实际应该查询 OpenGL 扩展
-
-  // 桌面平台优先 DXT
-  // 移动平台优先 ETC2 或 ASTC
-
-  // 默认返回 RGBA8
-  return TextureFormat::RGBA8;
-}
-
-std::vector<uint8_t> ResourceManager::compressTexture(const uint8_t *data,
-                                                      int width, int height,
-                                                      int channels,
-                                                      TextureFormat format) {
-  // 纹理压缩实现
-  // 这里需要根据格式使用相应的压缩库
-  // 如：squish (DXT), etcpack (ETC2), astc-encoder (ASTC)
-
-  // 目前返回原始数据
-  std::vector<uint8_t> result(data, data + width * height * channels);
-  return result;
-}
-
-IntrusivePtr<Texture>
-ResourceManager::loadTextureWithAlphaMask(const std::string &filepath) {
-  // 先加载纹理
-  auto texture = loadTexture(filepath);
-  if (!texture) {
-    return nullptr;
-  }
-
-  // 生成Alpha遮罩
-  generateAlphaMask(filepath);
-
-  return texture;
-}
-
-const AlphaMask *
-ResourceManager::getAlphaMask(const std::string &textureKey) const {
-  std::lock_guard<std::mutex> lock(textureMutex_);
-
-  auto it = textureCache_.find(textureKey);
-  if (it != textureCache_.end()) {
-    GLTexture *glTexture = static_cast<GLTexture *>(it->second.texture.get());
-    return glTexture->getAlphaMask();
-  }
-  return nullptr;
-}
-
-bool ResourceManager::generateAlphaMask(const std::string &textureKey) {
-  std::lock_guard<std::mutex> lock(textureMutex_);
-
-  auto it = textureCache_.find(textureKey);
-  if (it != textureCache_.end()) {
-    GLTexture *glTexture = static_cast<GLTexture *>(it->second.texture.get());
-    if (!glTexture->hasAlphaMask()) {
-      glTexture->generateAlphaMask();
-    }
-    return glTexture->hasAlphaMask();
-  }
-  return false;
-}
-
-bool ResourceManager::hasAlphaMask(const std::string &textureKey) const {
-  std::lock_guard<std::mutex> lock(textureMutex_);
-
-  auto it = textureCache_.find(textureKey);
-  if (it != textureCache_.end()) {
-    GLTexture *glTexture = static_cast<GLTexture *>(it->second.texture.get());
-    return glTexture->hasAlphaMask();
-  }
-  return false;
-}
-
-IntrusivePtr<Texture> ResourceManager::getTexture(const std::string &key) const {
-  std::lock_guard<std::mutex> lock(textureMutex_);
-
-  auto it = textureCache_.find(key);
-  if (it != textureCache_.end()) {
-    const_cast<ResourceManager *>(this)->touchTexture(key);
-    const_cast<ResourceManager *>(this)->textureHitCount_++;
-    const_cast<uint32_t &>(it->second.accessCount)++;
-    return it->second.texture;
-  }
-  return nullptr;
-}
-
-bool ResourceManager::hasTexture(const std::string &key) const {
-  std::lock_guard<std::mutex> lock(textureMutex_);
-  return textureCache_.find(key) != textureCache_.end();
-}
-
-void ResourceManager::unloadTexture(const std::string &key) {
-  std::lock_guard<std::mutex> lock(textureMutex_);
-
-  auto it = textureCache_.find(key);
-  if (it != textureCache_.end()) {
-    // 从LRU链表中移除
-    auto nodeIt = std::find_if(
-        lruNodes_.begin(), lruNodes_.end(),
-        [&key](const LRUNode &node) { return node.valid && node.key == key; });
-    if (nodeIt != lruNodes_.end()) {
-      removeFromList(static_cast<uint32_t>(nodeIt - lruNodes_.begin()) + 1);
-      freeLRUNode(static_cast<uint32_t>(nodeIt - lruNodes_.begin()) + 1);
-    }
-
-    // 更新总大小
-    totalTextureSize_ -= it->second.size;
-
-    // 从缓存移除
-    textureCache_.erase(it);
-    E2D_LOG_DEBUG("ResourceManager: unloaded texture: {}", key);
-  }
-}
-
-// ============================================================================
-// 字体图集资源
-// ============================================================================
-
-std::string ResourceManager::makeFontKey(const std::string &filepath,
-                                         int fontSize, bool useSDF) const {
-  return filepath + "#" + std::to_string(fontSize) + (useSDF ? "#sdf" : "");
-}
-
-IntrusivePtr<FontAtlas> ResourceManager::loadFont(const std::string &filepath,
-                                         int fontSize, bool useSDF) {
-  std::lock_guard<std::mutex> lock(fontMutex_);
-
-  std::string key = makeFontKey(filepath, fontSize, useSDF);
-
-  // 检查缓存
-  auto it = fontCache_.find(key);
-  if (it != fontCache_.end()) {
-    E2D_LOG_TRACE("ResourceManager: font cache hit: {}", key);
-    return it->second;
-  }
-
-  // 解析资源路径（优先尝试 romfs:/ 前缀）
-  std::string fullPath = resolveResourcePath(filepath);
-  if (fullPath.empty()) {
-    E2D_LOG_ERROR("ResourceManager: font file not found: {}", filepath);
-    return nullptr;
-  }
-
-  // 创建新字体图集
-  try {
-    auto font = makeRef<GLFontAtlas>(fullPath, fontSize, useSDF);
-    if (!font->getTexture() || !font->getTexture()->isValid()) {
-      E2D_LOG_ERROR("ResourceManager: failed to load font: {}", filepath);
-      return nullptr;
-    }
-
-    // 存入缓存
-    fontCache_[key] = font;
-    E2D_LOG_DEBUG("ResourceManager: loaded font: {} (size={}, sdf={})",
-                  filepath, fontSize, useSDF);
-    return font;
-  } catch (...) {
-    E2D_LOG_ERROR("ResourceManager: exception loading font: {}", filepath);
-    return nullptr;
-  }
-}
-
-IntrusivePtr<FontAtlas> ResourceManager::getFont(const std::string &key) const {
-  std::lock_guard<std::mutex> lock(fontMutex_);
-
-  auto it = fontCache_.find(key);
-  if (it != fontCache_.end()) {
-    return it->second;
-  }
-  return nullptr;
-}
-
-bool ResourceManager::hasFont(const std::string &key) const {
-  std::lock_guard<std::mutex> lock(fontMutex_);
-  return fontCache_.find(key) != fontCache_.end();
-}
-
-void ResourceManager::unloadFont(const std::string &key) {
-  std::lock_guard<std::mutex> lock(fontMutex_);
-  fontCache_.erase(key);
-  E2D_LOG_DEBUG("ResourceManager: unloaded font: {}", key);
-}
-
-// ============================================================================
-// 音效资源
-// ============================================================================
-
-IntrusivePtr<Sound> ResourceManager::loadSound(const std::string &filepath) {
-  return loadSound(filepath, filepath);
-}
-
-IntrusivePtr<Sound> ResourceManager::loadSound(const std::string &name,
-                                      const std::string &filepath) {
-  std::lock_guard<std::mutex> lock(soundMutex_);
-
-  // 检查缓存
-  auto it = soundCache_.find(name);
-  if (it != soundCache_.end()) {
-    E2D_LOG_TRACE("ResourceManager: sound cache hit: {}", name);
-    return it->second;
-  }
-
-  // 解析资源路径（优先尝试 romfs:/ 前缀）
-  std::string fullPath = resolveResourcePath(filepath);
-  if (fullPath.empty()) {
-    E2D_LOG_ERROR("ResourceManager: sound file not found: {}", filepath);
-    return nullptr;
-  }
-
-  // 使用 AudioEngine 加载音效
-  auto sound = AudioEngine::getInstance().loadSound(name, fullPath);
-  if (!sound) {
-    E2D_LOG_ERROR("ResourceManager: failed to load sound: {}", filepath);
-    return nullptr;
-  }
-
-  // 存入缓存
-  soundCache_[name] = sound;
-  E2D_LOG_DEBUG("ResourceManager: loaded sound: {}", filepath);
-  return sound;
-}
-
-IntrusivePtr<Sound> ResourceManager::getSound(const std::string &key) const {
-  std::lock_guard<std::mutex> lock(soundMutex_);
-
-  auto it = soundCache_.find(key);
-  if (it != soundCache_.end()) {
-    return it->second;
-  }
-  return nullptr;
-}
-
-bool ResourceManager::hasSound(const std::string &key) const {
-  std::lock_guard<std::mutex> lock(soundMutex_);
-  return soundCache_.find(key) != soundCache_.end();
-}
-
-void ResourceManager::unloadSound(const std::string &key) {
-  std::lock_guard<std::mutex> lock(soundMutex_);
-
-  // 从 AudioEngine 也卸载
-  AudioEngine::getInstance().unloadSound(key);
-  soundCache_.erase(key);
-  E2D_LOG_DEBUG("ResourceManager: unloaded sound: {}", key);
-}
-
-// ============================================================================
-// 缓存清理
-// ============================================================================
-
-void ResourceManager::purgeUnused() {
-  // 纹理缓存使用LRU策略，不需要清理失效引用
-  // 字体和音效缓存使用 IntrusivePtr 强引用，不需要清理失效引用
-  // 当外部没有引用时，缓存会自动释放
-}
-
-void ResourceManager::clearTextureCache() {
-  std::lock_guard<std::mutex> lock(textureMutex_);
-  size_t count = textureCache_.size();
-  textureCache_.clear();
-  lruNodes_.clear();
-  lruHead_ = 0;
-  lruTail_ = 0;
-  freeList_ = 0;
-  totalTextureSize_ = 0;
-  E2D_LOG_INFO("ResourceManager: cleared {} textures from cache", count);
-}
-
-void ResourceManager::clearFontCache() {
-  std::lock_guard<std::mutex> lock(fontMutex_);
-  size_t count = fontCache_.size();
-  fontCache_.clear();
-  E2D_LOG_INFO("ResourceManager: cleared {} fonts from cache", count);
-}
-
-void ResourceManager::clearSoundCache() {
-  std::lock_guard<std::mutex> lock(soundMutex_);
-  size_t count = soundCache_.size();
-
-  // 同时清理 AudioEngine 中的缓存
-  for (const auto &pair : soundCache_) {
-    AudioEngine::getInstance().unloadSound(pair.first);
-  }
-  soundCache_.clear();
-  E2D_LOG_INFO("ResourceManager: cleared {} sounds from cache", count);
-}
-
-void ResourceManager::clearAllCaches() {
-  clearTextureCache();
-  clearFontCache();
-  clearSoundCache();
-  E2D_LOG_INFO("ResourceManager: all caches cleared");
-}
-
-size_t ResourceManager::getTextureCacheSize() const {
-  std::lock_guard<std::mutex> lock(textureMutex_);
-  return textureCache_.size();
-}
-
-// ============================================================================
-// LRU 缓存管理
-// ============================================================================
-
-void ResourceManager::setTextureCache(size_t maxCacheSize,
-                                      size_t maxTextureCount,
-                                      float unloadInterval) {
-  std::lock_guard<std::mutex> lock(textureMutex_);
-  maxCacheSize_ = maxCacheSize;
-  maxTextureCount_ = maxTextureCount;
-  unloadInterval_ = unloadInterval;
-}
-
-size_t ResourceManager::getTextureCacheMemoryUsage() const {
-  std::lock_guard<std::mutex> lock(textureMutex_);
-  return totalTextureSize_;
-}
-
-float ResourceManager::getTextureCacheHitRate() const {
-  std::lock_guard<std::mutex> lock(textureMutex_);
-  uint64_t total = textureHitCount_ + textureMissCount_;
-  if (total == 0) {
-    return 0.0f;
-  }
-  return static_cast<float>(textureHitCount_) / static_cast<float>(total);
-}
-
-void ResourceManager::printTextureCacheStats() const {
-  std::lock_guard<std::mutex> lock(textureMutex_);
-  E2D_LOG_INFO("纹理缓存统计:");
-  E2D_LOG_INFO("  缓存纹理数: {}/{}", textureCache_.size(), maxTextureCount_);
-  E2D_LOG_INFO("  缓存大小: {} / {} MB", totalTextureSize_ / (1024 * 1024),
-               maxCacheSize_ / (1024 * 1024));
-  E2D_LOG_INFO("  缓存命中: {}", textureHitCount_);
-  E2D_LOG_INFO("  缓存未命中: {}", textureMissCount_);
-  E2D_LOG_INFO("  命中率: {:.1f}%", getTextureCacheHitRate() * 100.0f);
-}
-
-void ResourceManager::update(float dt) {
-  std::lock_guard<std::mutex> lock(textureMutex_);
-
-  // 自动清理
-  autoUnloadTimer_ += dt;
-  if (autoUnloadTimer_ >= unloadInterval_) {
-    autoUnloadTimer_ = 0.0f;
-
-    // 如果缓存超过80%，清理到50%
-    if (totalTextureSize_ > maxCacheSize_ * 0.8f) {
-      size_t targetSize = static_cast<size_t>(maxCacheSize_ * 0.5f);
-      while (totalTextureSize_ > targetSize && lruTail_ != 0) {
-        std::string key = evictLRU();
-        if (key.empty())
-          break;
-
-        auto it = textureCache_.find(key);
-        if (it != textureCache_.end()) {
-          totalTextureSize_ -= it->second.size;
-          textureCache_.erase(it);
-          E2D_LOG_DEBUG("ResourceManager: auto-evicted texture: {}", key);
-        }
-      }
-      E2D_LOG_INFO("ResourceManager: texture cache trimmed to {} MB",
-                   totalTextureSize_ / (1024 * 1024));
-    }
-  }
-}
-
-// ============================================================================
-// LRU 缓存内部方法
-// ============================================================================
-
-uint32_t ResourceManager::allocateLRUNode(const std::string &key) {
-  uint32_t index;
-  if (freeList_ != 0) {
-    // 复用空闲节点
-    index = freeList_;
-    freeList_ = lruNodes_[index - 1].next;
-  } else {
-    // 分配新节点
-    lruNodes_.emplace_back();
-    index = static_cast<uint32_t>(lruNodes_.size());
-  }
-
-  LRUNode &node = lruNodes_[index - 1];
-  node.key = key;
-  node.prev = 0;
-  node.next = 0;
-  node.valid = true;
-  return index;
-}
-
-void ResourceManager::freeLRUNode(uint32_t index) {
-  if (index == 0 || index > lruNodes_.size())
-    return;
-
-  LRUNode &node = lruNodes_[index - 1];
-  node.valid = false;
-  node.key.clear();
-  node.prev = 0;
-  node.next = freeList_;
-  freeList_ = index;
-}
-
-void ResourceManager::moveToFront(uint32_t index) {
-  if (index == 0 || index > lruNodes_.size() || index == lruHead_)
-    return;
-
-  removeFromList(index);
-
-  LRUNode &node = lruNodes_[index - 1];
-  node.prev = 0;
-  node.next = lruHead_;
-
-  if (lruHead_ != 0) {
-    lruNodes_[lruHead_ - 1].prev = index;
-  }
-  lruHead_ = index;
-
-  if (lruTail_ == 0) {
-    lruTail_ = index;
-  }
-}
-
-void ResourceManager::removeFromList(uint32_t index) {
-  if (index == 0 || index > lruNodes_.size())
-    return;
-
-  LRUNode &node = lruNodes_[index - 1];
-
-  if (node.prev != 0) {
-    lruNodes_[node.prev - 1].next = node.next;
-  } else {
-    lruHead_ = node.next;
-  }
-
-  if (node.next != 0) {
-    lruNodes_[node.next - 1].prev = node.prev;
-  } else {
-    lruTail_ = node.prev;
-  }
-}
-
-std::string ResourceManager::evictLRU() {
-  if (lruTail_ == 0)
-    return "";
-
-  uint32_t index = lruTail_;
-  std::string key = lruNodes_[index - 1].key;
-
-  removeFromList(index);
-  freeLRUNode(index);
-
-  return key;
-}
-
-void ResourceManager::touchTexture(const std::string &key) {
-  // 查找对应的LRU节点
-  auto nodeIt = std::find_if(
-      lruNodes_.begin(), lruNodes_.end(),
-      [&key](const LRUNode &node) { return node.valid && node.key == key; });
-  if (nodeIt != lruNodes_.end()) {
-    uint32_t index = static_cast<uint32_t>(nodeIt - lruNodes_.begin()) + 1;
-    moveToFront(index);
-  }
-
-  // 更新时间戳
-  auto it = textureCache_.find(key);
-  if (it != textureCache_.end()) {
-    it->second.lastAccessTime = 0.0f;
-  }
-}
-
-void ResourceManager::evictTexturesIfNeeded() {
-  while ((totalTextureSize_ >= maxCacheSize_ ||
-          textureCache_.size() >= maxTextureCount_) &&
-         lruTail_ != 0) {
-    std::string key = evictLRU();
-    if (key.empty())
-      break;
-
-    auto it = textureCache_.find(key);
-    if (it != textureCache_.end()) {
-      totalTextureSize_ -= it->second.size;
-      textureCache_.erase(it);
-      E2D_LOG_DEBUG("ResourceManager: evicted texture: {}", key);
-    }
-  }
-}
-
-size_t ResourceManager::calculateTextureSize(int width, int height,
-                                             PixelFormat format) const {
-  int bytesPerPixel = 4;
-  switch (format) {
-  case PixelFormat::R8:
-    bytesPerPixel = 1;
-    break;
-  case PixelFormat::RG8:
-    bytesPerPixel = 2;
-    break;
-  case PixelFormat::RGB8:
-    bytesPerPixel = 3;
-    break;
-  case PixelFormat::RGBA8:
-    bytesPerPixel = 4;
-    break;
-  default:
-    bytesPerPixel = 4;
-    break;
-  }
-  return static_cast<size_t>(width * height * bytesPerPixel);
-}
-
-size_t ResourceManager::getFontCacheSize() const {
-  std::lock_guard<std::mutex> lock(fontMutex_);
-  return fontCache_.size();
-}
-
-size_t ResourceManager::getSoundCacheSize() const {
-  std::lock_guard<std::mutex> lock(soundMutex_);
-  return soundCache_.size();
-}
-
-// ============================================================================
-// 文本文件资源
-// ============================================================================
-
-std::string ResourceManager::loadTextFile(const std::string &filepath) {
-  return loadTextFile(filepath, "UTF-8");
-}
-
-std::string ResourceManager::loadTextFile(const std::string &filepath,
-                                          const std::string &encoding) {
-  (void)encoding; // 目前只支持 UTF-8
-
-  std::lock_guard<std::mutex> lock(textFileMutex_);
-
-  // 检查缓存
-  auto it = textFileCache_.find(filepath);
-  if (it != textFileCache_.end()) {
-    E2D_LOG_TRACE("ResourceManager: text file cache hit: {}", filepath);
-    return it->second;
-  }
-
-  // 解析资源路径
-  std::string resolvedPath = resolveResourcePath(filepath);
-  if (resolvedPath.empty()) {
-    E2D_LOG_ERROR("ResourceManager: text file not found: {}", filepath);
-    return "";
-  }
-
-  // 打开文件
-  FILE *file = nullptr;
-#ifdef _WIN32
-  errno_t err = fopen_s(&file, resolvedPath.c_str(), "rb");
-  if (err != 0 || !file) {
-    E2D_LOG_ERROR("ResourceManager: failed to open text file: {}",
-                  resolvedPath);
-    return "";
-  }
-#else
-  file = fopen(resolvedPath.c_str(), "rb");
-  if (!file) {
-    E2D_LOG_ERROR("ResourceManager: failed to open text file: {}",
-                  resolvedPath);
-    return "";
-  }
-#endif
-
-  // 获取文件大小
-  fseek(file, 0, SEEK_END);
-  long fileSize = ftell(file);
-  fseek(file, 0, SEEK_SET);
-
-  if (fileSize <= 0) {
-    fclose(file);
-    E2D_LOG_WARN("ResourceManager: text file is empty: {}", resolvedPath);
-    return "";
-  }
-
-  // 读取文件内容
-  std::string content;
-  content.resize(fileSize);
-  size_t readSize = fread(&content[0], 1, fileSize, file);
-  fclose(file);
-
-  if (readSize != static_cast<size_t>(fileSize)) {
-    E2D_LOG_ERROR("ResourceManager: failed to read text file: {}",
-                  resolvedPath);
-    return "";
-  }
-
-  // 缓存内容
-  textFileCache_[filepath] = content;
-  E2D_LOG_DEBUG("ResourceManager: loaded text file: {} ({} bytes)", filepath,
-                content.size());
-
-  return content;
-}
-
-std::string ResourceManager::getTextFile(const std::string &key) const {
-  std::lock_guard<std::mutex> lock(textFileMutex_);
-  auto it = textFileCache_.find(key);
-  if (it != textFileCache_.end()) {
-    return it->second;
-  }
-  return "";
-}
-
-bool ResourceManager::hasTextFile(const std::string &key) const {
-  std::lock_guard<std::mutex> lock(textFileMutex_);
-  return textFileCache_.find(key) != textFileCache_.end();
-}
-
-void ResourceManager::unloadTextFile(const std::string &key) {
-  std::lock_guard<std::mutex> lock(textFileMutex_);
-  auto it = textFileCache_.find(key);
-  if (it != textFileCache_.end()) {
-    textFileCache_.erase(it);
-    E2D_LOG_DEBUG("ResourceManager: unloaded text file: {}", key);
-  }
-}
-
-void ResourceManager::clearTextFileCache() {
-  std::lock_guard<std::mutex> lock(textFileMutex_);
-  size_t count = textFileCache_.size();
-  textFileCache_.clear();
-  E2D_LOG_INFO("ResourceManager: cleared {} text files from cache", count);
-}
-
-size_t ResourceManager::getTextFileCacheSize() const {
-  std::lock_guard<std::mutex> lock(textFileMutex_);
-  return textFileCache_.size();
-}
-
-// ============================================================================
-// JSON 文件资源
-// ============================================================================
-
-std::string ResourceManager::loadJsonFile(const std::string &filepath) {
-  std::lock_guard<std::mutex> lock(jsonFileMutex_);
-
-  // 检查缓存
-  auto it = jsonFileCache_.find(filepath);
-  if (it != jsonFileCache_.end()) {
-    E2D_LOG_TRACE("ResourceManager: JSON file cache hit: {}", filepath);
-    return it->second;
-  }
-
-  // 解析资源路径
-  std::string resolvedPath = resolveResourcePath(filepath);
-  if (resolvedPath.empty()) {
-    E2D_LOG_ERROR("ResourceManager: JSON file not found: {}", filepath);
-    return "";
-  }
-
-  // 打开文件
-  FILE *file = nullptr;
-#ifdef _WIN32
-  errno_t err = fopen_s(&file, resolvedPath.c_str(), "rb");
-  if (err != 0 || !file) {
-    E2D_LOG_ERROR("ResourceManager: failed to open JSON file: {}",
-                  resolvedPath);
-    return "";
-  }
-#else
-  file = fopen(resolvedPath.c_str(), "rb");
-  if (!file) {
-    E2D_LOG_ERROR("ResourceManager: failed to open JSON file: {}",
-                  resolvedPath);
-    return "";
-  }
-#endif
-
-  // 获取文件大小
-  fseek(file, 0, SEEK_END);
-  long fileSize = ftell(file);
-  fseek(file, 0, SEEK_SET);
-
-  if (fileSize <= 0) {
-    fclose(file);
-    E2D_LOG_WARN("ResourceManager: JSON file is empty: {}", resolvedPath);
-    return "";
-  }
-
-  // 读取文件内容
-  std::string content;
-  content.resize(fileSize);
-  size_t readSize = fread(&content[0], 1, fileSize, file);
-  fclose(file);
-
-  if (readSize != static_cast<size_t>(fileSize)) {
-    E2D_LOG_ERROR("ResourceManager: failed to read JSON file: {}",
-                  resolvedPath);
-    return "";
-  }
-
-  // 简单验证 JSON 格式（检查是否以 { 或 [ 开头）
-  size_t firstValid = content.find_first_not_of(" \t\n\r");
-  if (firstValid == std::string::npos ||
-      (content[firstValid] != '{' && content[firstValid] != '[')) {
-    E2D_LOG_WARN("ResourceManager: file may not be valid JSON: {}", filepath);
-    // 不阻止加载，只是警告
-  }
-
-  // 缓存内容
-  jsonFileCache_[filepath] = content;
-  E2D_LOG_DEBUG("ResourceManager: loaded JSON file: {} ({} bytes)", filepath,
-                content.size());
-
-  return content;
-}
-
-std::string ResourceManager::getJsonFile(const std::string &key) const {
-  std::lock_guard<std::mutex> lock(jsonFileMutex_);
-  auto it = jsonFileCache_.find(key);
-  if (it != jsonFileCache_.end()) {
-    return it->second;
-  }
-  return "";
-}
-
-bool ResourceManager::hasJsonFile(const std::string &key) const {
-  std::lock_guard<std::mutex> lock(jsonFileMutex_);
-  return jsonFileCache_.find(key) != jsonFileCache_.end();
-}
-
-void ResourceManager::unloadJsonFile(const std::string &key) {
-  std::lock_guard<std::mutex> lock(jsonFileMutex_);
-  auto it = jsonFileCache_.find(key);
-  if (it != jsonFileCache_.end()) {
-    jsonFileCache_.erase(it);
-    E2D_LOG_DEBUG("ResourceManager: unloaded JSON file: {}", key);
-  }
-}
-
-void ResourceManager::clearJsonFileCache() {
-  std::lock_guard<std::mutex> lock(jsonFileMutex_);
-  size_t count = jsonFileCache_.size();
-  jsonFileCache_.clear();
-  E2D_LOG_INFO("ResourceManager: cleared {} JSON files from cache", count);
-}
-
-size_t ResourceManager::getJsonFileCacheSize() const {
-  std::lock_guard<std::mutex> lock(jsonFileMutex_);
-  return jsonFileCache_.size();
-}
-
-} // namespace extra2d
diff --git a/src/scene/node.cpp b/src/scene/node.cpp
deleted file mode 100644
index 0d94531..0000000
--- a/src/scene/node.cpp
+++ /dev/null
@@ -1,422 +0,0 @@
-#include <algorithm>
-#include <cmath>
-#include <renderer/render_command.h>
-#include <scene/node.h>
-#include <scene/scene.h>
-#include <utils/logger.h>
-
-namespace extra2d {
-
-Node::Node() = default;
-
-Node::~Node() { removeAllChildren(); }
-
-void Node::addChild(IntrusivePtr<Node> child) {
-  if (!child || child.get() == this) {
-    return;
-  }
-
-  child->removeFromParent();
-  child->parent_ = this;
-  children_.push_back(child);
-  childrenOrderDirty_ = true;
-
-  // 更新索引
-  if (!child->name().empty()) {
-    nameIndex_[child->name()] = child.get();
-  }
-  if (child->tag() != -1) {
-    tagIndex_[child->tag()] = child.get();
-  }
-
-  if (running_) {
-    child->onEnter();
-    if (scene_) {
-      child->onAttachToScene(scene_);
-    }
-  }
-}
-
-void Node::addChildren(std::vector<IntrusivePtr<Node>> &&children) {
-  // 预留空间，避免多次扩容
-  size_t newSize = children_.size() + children.size();
-  if (newSize > children_.capacity()) {
-    children_.reserve(newSize);
-  }
-
-  for (auto &child : children) {
-    if (!child || child.get() == this) {
-      continue;
-    }
-
-    child->removeFromParent();
-    child->parent_ = this;
-    children_.push_back(child);
-
-    // 更新索引
-    if (!child->name().empty()) {
-      nameIndex_[child->name()] = child.get();
-    }
-    if (child->tag() != -1) {
-      tagIndex_[child->tag()] = child.get();
-    }
-
-    if (running_) {
-      child->onEnter();
-      if (scene_) {
-        child->onAttachToScene(scene_);
-      }
-    }
-  }
-
-  if (!children.empty()) {
-    childrenOrderDirty_ = true;
-  }
-}
-
-void Node::removeChild(IntrusivePtr<Node> child) {
-  if (!child)
-    return;
-
-  auto it = std::find(children_.begin(), children_.end(), child);
-  if (it != children_.end()) {
-    // 始终从空间索引中移除（无论 running_ 状态）
-    // 这确保节点被正确清理
-    (*it)->onDetachFromScene();
-
-    if (running_) {
-      (*it)->onExit();
-    }
-    // 从索引中移除
-    if (!(*it)->name().empty()) {
-      nameIndex_.erase((*it)->name());
-    }
-    if ((*it)->tag() != -1) {
-      tagIndex_.erase((*it)->tag());
-    }
-    (*it)->parent_ = nullptr;
-    children_.erase(it);
-  }
-}
-
-void Node::removeChildByName(const std::string &name) {
-  auto child = childByName(name);
-  if (child) {
-    removeChild(child);
-  }
-}
-
-void Node::removeFromParent() {
-  auto p = parent_;
-  if (p) {
-    p->removeChild(IntrusivePtr<Node>(this));
-  }
-}
-
-void Node::removeAllChildren() {
-  for (auto &child : children_) {
-    if (running_) {
-      child->onDetachFromScene();
-      child->onExit();
-    }
-    child->parent_ = nullptr;
-  }
-  children_.clear();
-  nameIndex_.clear();
-  tagIndex_.clear();
-}
-
-IntrusivePtr<Node> Node::childByName(const std::string &name) const {
-  // 使用哈希索引，O(1) 查找
-  auto it = nameIndex_.find(name);
-  if (it != nameIndex_.end()) {
-    return IntrusivePtr<Node>(it->second);
-  }
-  return nullptr;
-}
-
-IntrusivePtr<Node> Node::childByTag(int tag) const {
-  // 使用哈希索引，O(1) 查找
-  auto it = tagIndex_.find(tag);
-  if (it != tagIndex_.end()) {
-    return IntrusivePtr<Node>(it->second);
-  }
-  return nullptr;
-}
-
-void Node::setPosition(const Vec2 &pos) {
-  position_ = pos;
-  markTransformDirty();
-}
-
-void Node::setPosition(float x, float y) { setPosition(Vec2(x, y)); }
-
-void Node::setRotation(float degrees) {
-  rotation_ = degrees;
-  markTransformDirty();
-}
-
-void Node::setScale(const Vec2 &scale) {
-  scale_ = scale;
-  markTransformDirty();
-}
-
-void Node::setScale(float scale) { setScale(Vec2(scale, scale)); }
-
-void Node::setScale(float x, float y) { setScale(Vec2(x, y)); }
-
-void Node::setAnchor(const Vec2 &anchor) {
-  anchor_ = anchor;
-  markTransformDirty();
-}
-
-void Node::setAnchor(float x, float y) { setAnchor(Vec2(x, y)); }
-
-void Node::setSkew(const Vec2 &skew) {
-  skew_ = skew;
-  markTransformDirty();
-}
-
-void Node::setSkew(float x, float y) { setSkew(Vec2(x, y)); }
-
-void Node::setOpacity(float opacity) {
-  opacity_ = std::clamp(opacity, 0.0f, 1.0f);
-}
-
-void Node::setVisible(bool visible) { visible_ = visible; }
-
-void Node::setColor(const Color3B &color) { color_ = color; }
-
-void Node::setFlipX(bool flipX) { flipX_ = flipX; }
-
-void Node::setFlipY(bool flipY) { flipY_ = flipY; }
-
-void Node::setZOrder(int zOrder) {
-  if (zOrder_ != zOrder) {
-    zOrder_ = zOrder;
-    childrenOrderDirty_ = true;
-  }
-}
-
-Vec2 Node::convertToWorldSpace(const Vec2 &localPos) const {
-  glm::vec4 worldPos =
-      getWorldTransform() * glm::vec4(localPos.x, localPos.y, 0.0f, 1.0f);
-  return Vec2(worldPos.x, worldPos.y);
-}
-
-Vec2 Node::convertToNodeSpace(const Vec2 &worldPos) const {
-  glm::mat4 invWorld = glm::inverse(getWorldTransform());
-  glm::vec4 localPos = invWorld * glm::vec4(worldPos.x, worldPos.y, 0.0f, 1.0f);
-  return Vec2(localPos.x, localPos.y);
-}
-
-glm::mat4 Node::getLocalTransform() const {
-  if (transformDirty_) {
-    localTransform_ = glm::mat4(1.0f);
-
-    // T - R - S order
-    localTransform_ = glm::translate(localTransform_,
-                                     glm::vec3(position_.x, position_.y, 0.0f));
-
-    if (rotation_ != 0.0f) {
-      localTransform_ = glm::rotate(localTransform_, rotation_ * DEG_TO_RAD,
-                                    glm::vec3(0.0f, 0.0f, 1.0f));
-    }
-
-    if (skew_.x != 0.0f || skew_.y != 0.0f) {
-      glm::mat4 skewMatrix(1.0f);
-      skewMatrix[1][0] = std::tan(skew_.x * DEG_TO_RAD);
-      skewMatrix[0][1] = std::tan(skew_.y * DEG_TO_RAD);
-      localTransform_ *= skewMatrix;
-    }
-
-    localTransform_ =
-        glm::scale(localTransform_, glm::vec3(scale_.x, scale_.y, 1.0f));
-
-    // 注意：锚点偏移在渲染时处理，不在本地变换中处理
-    // 这样可以避免锚点偏移被父节点的缩放影响
-
-    transformDirty_ = false;
-  }
-  return localTransform_;
-}
-
-glm::mat4 Node::getWorldTransform() const {
-  if (worldTransformDirty_) {
-    // 使用线程局部存储的固定数组，避免每帧内存分配
-    // 限制最大深度为 256 层，足以覆盖绝大多数场景
-    thread_local std::array<const Node *, 256> nodeChainCache;
-    thread_local size_t chainCount = 0;
-
-    chainCount = 0;
-    const Node *current = this;
-    while (current && chainCount < nodeChainCache.size()) {
-      nodeChainCache[chainCount++] = current;
-      current = current->parent_;
-    }
-
-    // 从根节点开始计算
-    glm::mat4 transform = glm::mat4(1.0f);
-    for (size_t i = chainCount; i > 0; --i) {
-      transform = transform * nodeChainCache[i - 1]->getLocalTransform();
-    }
-    worldTransform_ = transform;
-    worldTransformDirty_ = false;
-  }
-  return worldTransform_;
-}
-
-void Node::markTransformDirty() {
-  // 避免重复标记，提高性能
-  if (!transformDirty_ || !worldTransformDirty_) {
-    transformDirty_ = true;
-    worldTransformDirty_ = true;
-
-    // 递归标记所有子节点
-    for (auto &child : children_) {
-      child->markTransformDirty();
-    }
-  }
-}
-
-void Node::batchUpdateTransforms() {
-  // 如果本地变换脏了，先计算本地变换
-  if (transformDirty_) {
-    (void)getLocalTransform(); // 这会计算并缓存本地变换
-  }
-
-  // 如果世界变换脏了，需要重新计算
-  if (worldTransformDirty_) {
-    auto parent = parent_;
-    if (parent) {
-      // 使用父节点的世界变换（确保父节点已经更新）
-      worldTransform_ = parent->getWorldTransform() * localTransform_;
-    } else {
-      // 根节点
-      worldTransform_ = localTransform_;
-    }
-    worldTransformDirty_ = false;
-  }
-
-  // 递归更新子节点
-  for (auto &child : children_) {
-    child->batchUpdateTransforms();
-  }
-}
-
-void Node::onEnter() {
-  running_ = true;
-  for (auto &child : children_) {
-    child->onEnter();
-  }
-}
-
-void Node::onExit() {
-  running_ = false;
-  for (auto &child : children_) {
-    child->onExit();
-  }
-}
-
-void Node::onUpdate(float dt) {
-  onUpdateNode(dt);
-
-  // Update children
-  for (auto &child : children_) {
-    child->onUpdate(dt);
-  }
-}
-
-void Node::onRender(Renderer &renderer) {
-  if (!visible_)
-    return;
-
-  onDraw(renderer);
-
-  for (auto &child : children_) {
-    child->onRender(renderer);
-  }
-}
-
-void Node::onAttachToScene(Scene *scene) {
-  scene_ = scene;
-
-  for (auto &child : children_) {
-    child->onAttachToScene(scene);
-  }
-}
-
-void Node::onDetachFromScene() {
-  scene_ = nullptr;
-  for (auto &child : children_) {
-    child->onDetachFromScene();
-  }
-}
-
-Rect Node::boundingBox() const {
-  // 默认返回一个以位置为中心的点矩形
-  return Rect(position_.x, position_.y, 0, 0);
-}
-
-void Node::update(float dt) { onUpdate(dt); }
-
-void Node::render(Renderer &renderer) {
-  if (childrenOrderDirty_) {
-    sortChildren();
-  }
-  onRender(renderer);
-}
-
-void Node::sortChildren() {
-  // 使用插入排序优化小范围更新场景
-  // 插入排序在大部分已有序的情况下性能接近O(n)
-  size_t n = children_.size();
-  if (n <= 1) {
-    childrenOrderDirty_ = false;
-    return;
-  }
-
-  // 小数组使用插入排序，大数组使用std::sort
-  if (n < 32) {
-    // 插入排序
-    for (size_t i = 1; i < n; ++i) {
-      auto key = children_[i];
-      int keyZOrder = key->zOrder();
-      int j = static_cast<int>(i) - 1;
-
-      while (j >= 0 && children_[j]->zOrder() > keyZOrder) {
-        children_[j + 1] = children_[j];
-        --j;
-      }
-      children_[j + 1] = key;
-    }
-  } else {
-    // 大数组使用标准排序
-    std::sort(children_.begin(), children_.end(),
-              [](const IntrusivePtr<Node> &a, const IntrusivePtr<Node> &b) {
-                return a->zOrder() < b->zOrder();
-              });
-  }
-
-  childrenOrderDirty_ = false;
-}
-
-void Node::collectRenderCommands(std::vector<RenderCommand> &commands,
-                                 int parentZOrder) {
-  if (!visible_)
-    return;
-
-  // 计算累积 Z 序
-  int accumulatedZOrder = parentZOrder + zOrder_;
-
-  // 生成当前节点的渲染命令
-  generateRenderCommand(commands, accumulatedZOrder);
-
-  // 递归收集子节点的渲染命令
-  // 注意：这里假设子节点已经按 Z 序排序
-  for (auto &child : children_) {
-    child->collectRenderCommands(commands, accumulatedZOrder);
-  }
-}
-
-} // namespace extra2d
diff --git a/src/scene/scene.cpp b/src/scene/scene.cpp
deleted file mode 100644
index 4948ea2..0000000
--- a/src/scene/scene.cpp
+++ /dev/null
@@ -1,73 +0,0 @@
-#include <renderer/render_command.h>
-#include <renderer/renderer.h>
-#include <scene/scene.h>
-#include <utils/logger.h>
-
-namespace extra2d {
-
-Scene::Scene() { defaultCamera_ = makeRef<Camera>(); }
-
-void Scene::setCamera(IntrusivePtr<Camera> camera) { camera_ = camera; }
-
-void Scene::setViewportSize(float width, float height) {
-  viewportSize_ = Size(width, height);
-  if (defaultCamera_) {
-    defaultCamera_->setViewport(0, width, height, 0);
-  } else if (camera_) {
-    camera_->setViewport(0, width, height, 0);
-  }
-}
-
-void Scene::setViewportSize(const Size &size) {
-  setViewportSize(size.width, size.height);
-}
-
-void Scene::renderScene(Renderer &renderer) {
-  if (!visible())
-    return;
-
-  // Begin frame with background color
-  renderer.beginFrame(backgroundColor_);
-  renderContent(renderer);
-  renderer.endFrame();
-}
-
-void Scene::renderContent(Renderer &renderer) {
-  if (!visible())
-    return;
-
-  // 在渲染前批量更新所有节点的世界变换
-  batchUpdateTransforms();
-
-  Camera *activeCam = getActiveCamera();
-  if (activeCam) {
-    renderer.setViewProjection(activeCam->getViewProjectionMatrix());
-  }
-
-  renderer.beginSpriteBatch();
-  render(renderer);
-  renderer.endSpriteBatch();
-}
-
-void Scene::updateScene(float dt) {
-  if (!paused_) {
-    update(dt);
-  }
-}
-
-void Scene::onEnter() { Node::onEnter(); }
-
-void Scene::onExit() { Node::onExit(); }
-
-void Scene::collectRenderCommands(std::vector<RenderCommand> &commands,
-                                  int parentZOrder) {
-  if (!visible())
-    return;
-
-  // 从场景的子节点开始收集渲染命令
-  Node::collectRenderCommands(commands, parentZOrder);
-}
-
-IntrusivePtr<Scene> Scene::create() { return makeRef<Scene>(); }
-
-} // namespace extra2d
diff --git a/src/scene/scene_manager.cpp b/src/scene/scene_manager.cpp
deleted file mode 100644
index 9a469d0..0000000
--- a/src/scene/scene_manager.cpp
+++ /dev/null
@@ -1,364 +0,0 @@
-#include <algorithm>
-#include <app/application.h>
-#include <renderer/render_command.h>
-#include <renderer/renderer.h>
-#include <platform/input.h>
-#include <scene/scene_manager.h>
-#include <utils/logger.h>
-
-
-namespace extra2d {
-
-namespace {
-
-Node *hitTestTopmost(const IntrusivePtr<Node> &node, const Vec2 &worldPos) {
-  if (!node || !node->visible()) {
-    return nullptr;
-  }
-
-  std::vector<IntrusivePtr<Node>> children = node->children();
-  std::stable_sort(children.begin(), children.end(),
-                   [](const IntrusivePtr<Node> &a, const IntrusivePtr<Node> &b) {
-                     return a->zOrder() < b->zOrder();
-                   });
-
-  for (auto it = children.rbegin(); it != children.rend(); ++it) {
-    if (Node *hit = hitTestTopmost(*it, worldPos)) {
-      return hit;
-    }
-  }
-
-  if (node->getEventDispatcher().getTotalListenerCount() == 0) {
-    return nullptr;
-  }
-
-  Rect bounds = node->boundingBox();
-  if (!bounds.empty() && bounds.containsPoint(worldPos)) {
-    return node.get();
-  }
-
-  return nullptr;
-}
-
-void dispatchToNode(Node *node, Event &event) {
-  if (!node) {
-    return;
-  }
-  node->getEventDispatcher().dispatch(event);
-}
-
-} // namespace
-
-SceneManager &SceneManager::getInstance() {
-  static SceneManager instance;
-  return instance;
-}
-
-void SceneManager::runWithScene(IntrusivePtr<Scene> scene) {
-  if (!scene) {
-    return;
-  }
-
-  if (!sceneStack_.empty()) {
-    E2D_LOG_WARN("SceneManager: runWithScene should only be called once");
-    return;
-  }
-
-  scene->onEnter();
-  scene->onAttachToScene(scene.get());
-  sceneStack_.push(scene);
-}
-
-void SceneManager::replaceScene(IntrusivePtr<Scene> scene) {
-  if (!scene) {
-    return;
-  }
-
-  if (sceneStack_.empty()) {
-    runWithScene(scene);
-    return;
-  }
-
-  // Pop current scene
-  auto oldScene = sceneStack_.top();
-  oldScene->onExit();
-  oldScene->onDetachFromScene();
-  sceneStack_.pop();
-
-  // Push new scene
-  scene->onEnter();
-  scene->onAttachToScene(scene.get());
-  sceneStack_.push(scene);
-}
-
-void SceneManager::enterScene(IntrusivePtr<Scene> scene) {
-  if (!scene) {
-    return;
-  }
-
-  if (sceneStack_.empty()) {
-    runWithScene(scene);
-  } else {
-    replaceScene(scene);
-  }
-}
-
-void SceneManager::pushScene(IntrusivePtr<Scene> scene) {
-  if (!scene) {
-    return;
-  }
-
-  // Pause current scene
-  if (!sceneStack_.empty()) {
-    sceneStack_.top()->pause();
-  }
-
-  // Push new scene
-  scene->onEnter();
-  scene->onAttachToScene(scene.get());
-  sceneStack_.push(scene);
-}
-
-void SceneManager::popScene() {
-  if (sceneStack_.size() <= 1) {
-    return;
-  }
-
-  auto current = sceneStack_.top();
-  current->onExit();
-  current->onDetachFromScene();
-  sceneStack_.pop();
-
-  // Resume previous scene
-  if (!sceneStack_.empty()) {
-    sceneStack_.top()->resume();
-  }
-}
-
-void SceneManager::popToRootScene() {
-  if (sceneStack_.size() <= 1) {
-    return;
-  }
-
-  // Exit all scenes except root
-  while (sceneStack_.size() > 1) {
-    auto scene = sceneStack_.top();
-    scene->onExit();
-    scene->onDetachFromScene();
-    sceneStack_.pop();
-  }
-
-  // Resume root
-  sceneStack_.top()->resume();
-}
-
-void SceneManager::popToScene(const std::string &name) {
-  // Find target scene in stack
-  std::stack<IntrusivePtr<Scene>> tempStack;
-  IntrusivePtr<Scene> target = nullptr;
-
-  while (!sceneStack_.empty()) {
-    auto scene = sceneStack_.top();
-    if (scene->name() == name) {
-      target = scene;
-      break;
-    }
-    scene->onExit();
-    scene->onDetachFromScene();
-    sceneStack_.pop();
-  }
-
-  if (target) {
-    target->resume();
-  }
-}
-
-IntrusivePtr<Scene> SceneManager::getCurrentScene() const {
-  if (sceneStack_.empty()) {
-    return nullptr;
-  }
-  return sceneStack_.top();
-}
-
-IntrusivePtr<Scene> SceneManager::getPreviousScene() const {
-  if (sceneStack_.size() < 2) {
-    return nullptr;
-  }
-
-  // Copy stack to access second top
-  auto tempStack = sceneStack_;
-  tempStack.pop();
-  return tempStack.top();
-}
-
-IntrusivePtr<Scene> SceneManager::getRootScene() const {
-  if (sceneStack_.empty()) {
-    return nullptr;
-  }
-
-  // Copy stack to access bottom
-  auto tempStack = sceneStack_;
-  IntrusivePtr<Scene> root;
-  while (!tempStack.empty()) {
-    root = tempStack.top();
-    tempStack.pop();
-  }
-  return root;
-}
-
-IntrusivePtr<Scene> SceneManager::getSceneByName(const std::string &name) const {
-  auto it = namedScenes_.find(name);
-  if (it != namedScenes_.end()) {
-    return it->second;
-  }
-
-  // Search in stack
-  auto tempStack = sceneStack_;
-  while (!tempStack.empty()) {
-    auto scene = tempStack.top();
-    if (scene->name() == name) {
-      return scene;
-    }
-    tempStack.pop();
-  }
-
-  return nullptr;
-}
-
-bool SceneManager::hasScene(const std::string &name) const {
-  return getSceneByName(name) != nullptr;
-}
-
-void SceneManager::update(float dt) {
-  if (!sceneStack_.empty()) {
-    auto &scene = *sceneStack_.top();
-    scene.updateScene(dt);
-    dispatchPointerEvents(scene);
-  }
-}
-
-void SceneManager::render(Renderer &renderer) {
-  Color clearColor = Colors::Black;
-  if (!sceneStack_.empty()) {
-    clearColor = sceneStack_.top()->getBackgroundColor();
-  }
-
-  E2D_LOG_TRACE("SceneManager::render - beginFrame with color({}, {}, {})",
-                clearColor.r, clearColor.g, clearColor.b);
-  renderer.beginFrame(clearColor);
-
-  if (!sceneStack_.empty()) {
-    E2D_LOG_TRACE("SceneManager::render - rendering scene content");
-    sceneStack_.top()->renderContent(renderer);
-  } else {
-    E2D_LOG_WARN("SceneManager::render - no scene to render");
-  }
-
-  renderer.endFrame();
-  E2D_LOG_TRACE("SceneManager::render - endFrame");
-}
-
-void SceneManager::collectRenderCommands(std::vector<RenderCommand> &commands) {
-  if (!sceneStack_.empty()) {
-    sceneStack_.top()->collectRenderCommands(commands, 0);
-  }
-}
-
-void SceneManager::end() {
-  while (!sceneStack_.empty()) {
-    auto scene = sceneStack_.top();
-    scene->onExit();
-    scene->onDetachFromScene();
-    sceneStack_.pop();
-  }
-  namedScenes_.clear();
-}
-
-void SceneManager::purgeCachedScenes() { namedScenes_.clear(); }
-
-void SceneManager::dispatchPointerEvents(Scene &scene) {
-  auto &input = Application::instance().input();
-  Vec2 screenPos = input.getMousePosition();
-
-  Vec2 worldPos = screenPos;
-  if (auto *camera = scene.getActiveCamera()) {
-    worldPos = camera->screenToWorld(screenPos);
-  }
-
-  IntrusivePtr<Node> root = IntrusivePtr<Node>(&scene);
-  Node *newHover = hitTestTopmost(root, worldPos);
-
-  if (newHover != hoverTarget_) {
-    if (hoverTarget_) {
-      Event evt;
-      evt.type = EventType::UIHoverExit;
-      evt.data = CustomEvent{0, hoverTarget_};
-      dispatchToNode(hoverTarget_, evt);
-    }
-    hoverTarget_ = newHover;
-    if (hoverTarget_) {
-      Event evt;
-      evt.type = EventType::UIHoverEnter;
-      evt.data = CustomEvent{0, hoverTarget_};
-      dispatchToNode(hoverTarget_, evt);
-    }
-  }
-
-  if (!hasLastPointerWorld_) {
-    lastPointerWorld_ = worldPos;
-    hasLastPointerWorld_ = true;
-  }
-
-  Vec2 delta = worldPos - lastPointerWorld_;
-  if (hoverTarget_ && (delta.x != 0.0f || delta.y != 0.0f)) {
-    Event evt = Event::createMouseMove(worldPos, delta);
-    dispatchToNode(hoverTarget_, evt);
-  }
-
-  float scrollDelta = input.getMouseScrollDelta();
-  if (hoverTarget_ && scrollDelta != 0.0f) {
-    Event evt = Event::createMouseScroll(Vec2(0.0f, scrollDelta), worldPos);
-    dispatchToNode(hoverTarget_, evt);
-  }
-
-  if (input.isMousePressed(MouseButton::Left)) {
-    captureTarget_ = hoverTarget_;
-    if (captureTarget_) {
-      Event evt = Event::createMouseButtonPress(
-          static_cast<int>(MouseButton::Left), 0, worldPos);
-      dispatchToNode(captureTarget_, evt);
-
-      Event pressed;
-      pressed.type = EventType::UIPressed;
-      pressed.data = CustomEvent{0, captureTarget_};
-      dispatchToNode(captureTarget_, pressed);
-    }
-  }
-
-  if (input.isMouseReleased(MouseButton::Left)) {
-    Node *target = captureTarget_ ? captureTarget_ : hoverTarget_;
-    if (target) {
-      Event evt = Event::createMouseButtonRelease(
-          static_cast<int>(MouseButton::Left), 0, worldPos);
-      dispatchToNode(target, evt);
-
-      Event released;
-      released.type = EventType::UIReleased;
-      released.data = CustomEvent{0, target};
-      dispatchToNode(target, released);
-    }
-
-    if (captureTarget_ && captureTarget_ == hoverTarget_) {
-      Event clicked;
-      clicked.type = EventType::UIClicked;
-      clicked.data = CustomEvent{0, captureTarget_};
-      dispatchToNode(captureTarget_, clicked);
-    }
-
-    captureTarget_ = nullptr;
-  }
-
-  lastPointerWorld_ = worldPos;
-}
-
-} // namespace extra2d
diff --git a/src/scene/shape_node.cpp b/src/scene/shape_node.cpp
deleted file mode 100644
index 8a8929e..0000000
--- a/src/scene/shape_node.cpp
+++ /dev/null
@@ -1,340 +0,0 @@
-#include <algorithm>
-#include <cmath>
-#include <limits>
-#include <renderer/render_command.h>
-#include <renderer/renderer.h>
-#include <scene/shape.h>
-
-namespace extra2d {
-
-ShapeNode::ShapeNode() = default;
-
-IntrusivePtr<ShapeNode> ShapeNode::create() { return makeRef<ShapeNode>(); }
-
-IntrusivePtr<ShapeNode> ShapeNode::createPoint(const Vec2 &pos, const Color &color) {
-  auto node = makeRef<ShapeNode>();
-  node->shapeType_ = ShapeType::Point;
-  node->color_ = color;
-  node->points_ = {pos};
-  return node;
-}
-
-IntrusivePtr<ShapeNode> ShapeNode::createLine(const Vec2 &start, const Vec2 &end,
-                                     const Color &color, float width) {
-  auto node = makeRef<ShapeNode>();
-  node->shapeType_ = ShapeType::Line;
-  node->color_ = color;
-  node->lineWidth_ = width;
-  node->points_ = {start, end};
-  return node;
-}
-
-IntrusivePtr<ShapeNode> ShapeNode::createRect(const Rect &rect, const Color &color,
-                                     float width) {
-  auto node = makeRef<ShapeNode>();
-  node->shapeType_ = ShapeType::Rect;
-  node->color_ = color;
-  node->lineWidth_ = width;
-  node->filled_ = false;
-  node->points_ = {
-      Vec2(rect.left(), rect.top()), Vec2(rect.right(), rect.top()),
-      Vec2(rect.right(), rect.bottom()), Vec2(rect.left(), rect.bottom())};
-  return node;
-}
-
-IntrusivePtr<ShapeNode> ShapeNode::createFilledRect(const Rect &rect,
-                                           const Color &color) {
-  auto node = createRect(rect, color, 0);
-  node->filled_ = true;
-  return node;
-}
-
-IntrusivePtr<ShapeNode> ShapeNode::createCircle(const Vec2 &center, float radius,
-                                       const Color &color, int segments,
-                                       float width) {
-  auto node = makeRef<ShapeNode>();
-  node->shapeType_ = ShapeType::Circle;
-  node->color_ = color;
-  node->lineWidth_ = width;
-  node->segments_ = segments;
-  node->filled_ = false;
-  node->points_ = {center};
-  // Store radius in a point for simplicity
-  node->addPoint(Vec2(radius, 0));
-  return node;
-}
-
-IntrusivePtr<ShapeNode> ShapeNode::createFilledCircle(const Vec2 &center, float radius,
-                                             const Color &color, int segments) {
-  auto node = createCircle(center, radius, color, segments, 0);
-  node->filled_ = true;
-  return node;
-}
-
-IntrusivePtr<ShapeNode> ShapeNode::createTriangle(const Vec2 &p1, const Vec2 &p2,
-                                       const Vec2 &p3, const Color &color,
-                                       float width) {
-  auto node = makeRef<ShapeNode>();
-  node->shapeType_ = ShapeType::Triangle;
-  node->color_ = color;
-  node->lineWidth_ = width;
-  node->filled_ = false;
-  node->points_ = {p1, p2, p3};
-  return node;
-}
-
-IntrusivePtr<ShapeNode> ShapeNode::createFilledTriangle(const Vec2 &p1, const Vec2 &p2,
-                                             const Vec2 &p3,
-                                             const Color &color) {
-  auto node = createTriangle(p1, p2, p3, color, 0);
-  node->filled_ = true;
-  return node;
-}
-
-IntrusivePtr<ShapeNode> ShapeNode::createPolygon(const std::vector<Vec2> &points,
-                                      const Color &color, float width) {
-  auto node = makeRef<ShapeNode>();
-  node->shapeType_ = ShapeType::Polygon;
-  node->color_ = color;
-  node->lineWidth_ = width;
-  node->filled_ = false;
-  node->points_ = points;
-  return node;
-}
-
-IntrusivePtr<ShapeNode> ShapeNode::createFilledPolygon(const std::vector<Vec2> &points,
-                                            const Color &color) {
-  auto node = createPolygon(points, color, 0);
-  node->filled_ = true;
-  return node;
-}
-
-void ShapeNode::setPoints(const std::vector<Vec2> &points) { points_ = points; }
-
-void ShapeNode::addPoint(const Vec2 &point) { points_.push_back(point); }
-
-void ShapeNode::clearPoints() { points_.clear(); }
-
-Rect ShapeNode::boundingBox() const {
-  if (points_.empty()) {
-    return Rect();
-  }
-
-  Vec2 offset = pos();
-
-  if (shapeType_ == ShapeType::Circle && points_.size() >= 2) {
-    float radius = std::abs(points_[1].x);
-    Vec2 center = points_[0] + offset;
-    return Rect(center.x - radius, center.y - radius, radius * 2.0f,
-                radius * 2.0f);
-  }
-
-  float minX = std::numeric_limits<float>::infinity();
-  float minY = std::numeric_limits<float>::infinity();
-  float maxX = -std::numeric_limits<float>::infinity();
-  float maxY = -std::numeric_limits<float>::infinity();
-
-  for (const auto &p : points_) {
-    Vec2 world = p + offset;
-    minX = std::min(minX, world.x);
-    minY = std::min(minY, world.y);
-    maxX = std::max(maxX, world.x);
-    maxY = std::max(maxY, world.y);
-  }
-
-  float inflate = 0.0f;
-  if (!filled_ &&
-      (shapeType_ == ShapeType::Line || shapeType_ == ShapeType::Rect ||
-       shapeType_ == ShapeType::Triangle || shapeType_ == ShapeType::Polygon ||
-       shapeType_ == ShapeType::Point)) {
-    inflate = std::max(0.0f, lineWidth_ * 0.5f);
-  }
-  if (shapeType_ == ShapeType::Point) {
-    inflate = std::max(inflate, lineWidth_ * 0.5f);
-  }
-
-  return Rect(minX - inflate, minY - inflate, (maxX - minX) + inflate * 2.0f,
-              (maxY - minY) + inflate * 2.0f);
-}
-
-void ShapeNode::onDraw(Renderer &renderer) {
-  if (points_.empty()) {
-    return;
-  }
-
-  Vec2 offset = pos();
-
-  switch (shapeType_) {
-  case ShapeType::Point:
-    if (!points_.empty()) {
-      renderer.fillCircle(points_[0] + offset, lineWidth_ * 0.5f, color_, 8);
-    }
-    break;
-
-  case ShapeType::Line:
-    if (points_.size() >= 2) {
-      renderer.drawLine(points_[0] + offset, points_[1] + offset, color_,
-                        lineWidth_);
-    }
-    break;
-
-  case ShapeType::Rect:
-    if (points_.size() >= 4) {
-      if (filled_) {
-        Rect rect(points_[0].x, points_[0].y, points_[2].x - points_[0].x,
-                  points_[2].y - points_[0].y);
-        renderer.fillRect(Rect(rect.origin + offset, rect.size), color_);
-      } else {
-        for (size_t i = 0; i < points_.size(); ++i) {
-          Vec2 start = points_[i] + offset;
-          Vec2 end = points_[(i + 1) % points_.size()] + offset;
-          renderer.drawLine(start, end, color_, lineWidth_);
-        }
-      }
-    }
-    break;
-
-  case ShapeType::Circle:
-    if (points_.size() >= 2) {
-      float radius = points_[1].x;
-      if (filled_) {
-        renderer.fillCircle(points_[0] + offset, radius, color_, segments_);
-      } else {
-        renderer.drawCircle(points_[0] + offset, radius, color_, segments_,
-                            lineWidth_);
-      }
-    }
-    break;
-
-  case ShapeType::Triangle:
-    if (points_.size() >= 3) {
-      Vec2 p1 = points_[0] + offset;
-      Vec2 p2 = points_[1] + offset;
-      Vec2 p3 = points_[2] + offset;
-      if (filled_) {
-        renderer.fillTriangle(p1, p2, p3, color_);
-      } else {
-        renderer.drawLine(p1, p2, color_, lineWidth_);
-        renderer.drawLine(p2, p3, color_, lineWidth_);
-        renderer.drawLine(p3, p1, color_, lineWidth_);
-      }
-    }
-    break;
-
-  case ShapeType::Polygon:
-    if (!points_.empty()) {
-      std::vector<Vec2> transformedPoints;
-      transformedPoints.reserve(points_.size());
-      for (const auto &p : points_) {
-        transformedPoints.push_back(p + offset);
-      }
-
-      if (filled_) {
-        renderer.fillPolygon(transformedPoints, color_);
-      } else {
-        renderer.drawPolygon(transformedPoints, color_, lineWidth_);
-      }
-    }
-    break;
-  }
-}
-
-void ShapeNode::generateRenderCommand(std::vector<RenderCommand> &commands,
-                                      int zOrder) {
-  if (points_.empty()) {
-    return;
-  }
-
-  Vec2 offset = pos();
-  RenderCommand cmd;
-  cmd.layer = zOrder;
-
-  switch (shapeType_) {
-  case ShapeType::Point:
-    if (!points_.empty()) {
-      cmd.type = RenderCommandType::FilledCircle;
-      cmd.data = CircleCommandData{
-          points_[0] + offset, lineWidth_ * 0.5f, color_, 8, 0.0f, true};
-    }
-    break;
-
-  case ShapeType::Line:
-    if (points_.size() >= 2) {
-      cmd.type = RenderCommandType::Line;
-      cmd.data = LineCommandData{points_[0] + offset, points_[1] + offset,
-                                 color_, lineWidth_};
-    }
-    break;
-
-  case ShapeType::Rect:
-    if (points_.size() >= 4) {
-      if (filled_) {
-        cmd.type = RenderCommandType::FilledRect;
-        Rect rect(points_[0].x, points_[0].y, points_[2].x - points_[0].x,
-                  points_[2].y - points_[0].y);
-        cmd.data = RectCommandData{Rect(rect.origin + offset, rect.size),
-                                   color_, 0.0f, true};
-      } else {
-        cmd.type = RenderCommandType::Rect;
-        Rect rect(points_[0].x, points_[0].y, points_[2].x - points_[0].x,
-                  points_[2].y - points_[0].y);
-        cmd.data = RectCommandData{Rect(rect.origin + offset, rect.size),
-                                   color_, lineWidth_, false};
-      }
-    }
-    break;
-
-  case ShapeType::Circle:
-    if (points_.size() >= 2) {
-      float radius = points_[1].x;
-      if (filled_) {
-        cmd.type = RenderCommandType::FilledCircle;
-        cmd.data = CircleCommandData{points_[0] + offset, radius, color_,
-                                     segments_,           0.0f,   true};
-      } else {
-        cmd.type = RenderCommandType::Circle;
-        cmd.data = CircleCommandData{points_[0] + offset, radius,     color_,
-                                     segments_,           lineWidth_, false};
-      }
-    }
-    break;
-
-  case ShapeType::Triangle:
-    if (points_.size() >= 3) {
-      Vec2 p1 = points_[0] + offset;
-      Vec2 p2 = points_[1] + offset;
-      Vec2 p3 = points_[2] + offset;
-      if (filled_) {
-        cmd.type = RenderCommandType::FilledTriangle;
-        cmd.data = TriangleCommandData{p1, p2, p3, color_, 0.0f, true};
-      } else {
-        cmd.type = RenderCommandType::Triangle;
-        cmd.data = TriangleCommandData{p1, p2, p3, color_, lineWidth_, false};
-      }
-    }
-    break;
-
-  case ShapeType::Polygon:
-    if (!points_.empty()) {
-      std::vector<Vec2> transformedPoints;
-      transformedPoints.reserve(points_.size());
-      for (const auto &p : points_) {
-        transformedPoints.push_back(p + offset);
-      }
-
-      if (filled_) {
-        cmd.type = RenderCommandType::FilledPolygon;
-        cmd.data = PolygonCommandData{transformedPoints, color_, 0.0f, true};
-      } else {
-        cmd.type = RenderCommandType::Polygon;
-        cmd.data =
-            PolygonCommandData{transformedPoints, color_, lineWidth_, false};
-      }
-    }
-    break;
-  }
-
-  commands.push_back(std::move(cmd));
-}
-
-} // namespace extra2d
diff --git a/src/scene/sprite.cpp b/src/scene/sprite.cpp
deleted file mode 100644
index fa2372e..0000000
--- a/src/scene/sprite.cpp
+++ /dev/null
@@ -1,163 +0,0 @@
-#include <algorithm>
-#include <cmath>
-#include <graphics/texture.h>
-#include <renderer/render_command.h>
-#include <renderer/renderer.h>
-#include <scene/sprite.h>
-
-namespace extra2d {
-
-Sprite::Sprite() = default;
-
-Sprite::Sprite(IntrusivePtr<Texture> texture) { setTexture(texture); }
-
-void Sprite::setTexture(IntrusivePtr<Texture> texture) {
-  texture_ = texture;
-  if (texture_) {
-    textureRect_ = Rect(0, 0, static_cast<float>(texture_->width()),
-                        static_cast<float>(texture_->height()));
-  }
-}
-
-void Sprite::setTextureRect(const Rect &rect) { textureRect_ = rect; }
-
-void Sprite::setColor(const Color &color) { color_ = color; }
-
-void Sprite::setFlipX(bool flip) { flipX_ = flip; }
-
-void Sprite::setFlipY(bool flip) { flipY_ = flip; }
-
-IntrusivePtr<Sprite> Sprite::create() { return makeRef<Sprite>(); }
-
-IntrusivePtr<Sprite> Sprite::create(IntrusivePtr<Texture> texture) {
-  return makeRef<Sprite>(texture);
-}
-
-IntrusivePtr<Sprite> Sprite::create(IntrusivePtr<Texture> texture, const Rect &rect) {
-  auto sprite = makeRef<Sprite>(texture);
-  sprite->setTextureRect(rect);
-  return sprite;
-}
-
-Rect Sprite::boundingBox() const {
-  if (!texture_ || !texture_->isValid()) {
-    return Rect();
-  }
-
-  float width = textureRect_.width();
-  float height = textureRect_.height();
-
-  auto position = pos();
-  auto anchorPt = anchor();
-  auto scaleVal = scale();
-
-  float w = width * scaleVal.x;
-  float h = height * scaleVal.y;
-  float x0 = position.x - width * anchorPt.x * scaleVal.x;
-  float y0 = position.y - height * anchorPt.y * scaleVal.y;
-  float x1 = x0 + w;
-  float y1 = y0 + h;
-
-  float l = std::min(x0, x1);
-  float t = std::min(y0, y1);
-  return Rect(l, t, std::abs(w), std::abs(h));
-}
-
-void Sprite::onDraw(Renderer &renderer) {
-  if (!texture_ || !texture_->isValid()) {
-    return;
-  }
-
-  // Calculate destination rectangle based on texture rect
-  float width = textureRect_.width();
-  float height = textureRect_.height();
-
-  // 使用世界变换来获取最终的位置
-  auto worldTransform = getWorldTransform();
-
-  // 从世界变换矩阵中提取位置（第四列）
-  float worldX = worldTransform[3][0];
-  float worldY = worldTransform[3][1];
-
-  // 从世界变换矩阵中提取缩放
-  float worldScaleX =
-      glm::length(glm::vec2(worldTransform[0][0], worldTransform[0][1]));
-  float worldScaleY =
-      glm::length(glm::vec2(worldTransform[1][0], worldTransform[1][1]));
-
-  auto anchorPt = anchor();
-
-  // 锚点由 Renderer 在绘制时处理，这里只传递位置和尺寸
-  Rect destRect(worldX, worldY, width * worldScaleX, height * worldScaleY);
-
-  // Adjust source rect for flipping
-  Rect srcRect = textureRect_;
-  if (flipX_) {
-    srcRect.origin.x = srcRect.right();
-    srcRect.size.width = -srcRect.size.width;
-  }
-  if (flipY_) {
-    srcRect.origin.y = srcRect.bottom();
-    srcRect.size.height = -srcRect.size.height;
-  }
-
-  // 从世界变换矩阵中提取旋转角度
-  float worldRotation = std::atan2(worldTransform[0][1], worldTransform[0][0]);
-
-  renderer.drawSprite(*texture_, destRect, srcRect, color_, worldRotation,
-                      anchorPt);
-}
-
-void Sprite::generateRenderCommand(std::vector<RenderCommand> &commands,
-                                   int zOrder) {
-  if (!texture_ || !texture_->isValid()) {
-    return;
-  }
-
-  // 计算目标矩形（与 onDraw 一致，使用世界变换）
-  float width = textureRect_.width();
-  float height = textureRect_.height();
-
-  // 使用世界变换来获取最终的位置
-  auto worldTransform = getWorldTransform();
-
-  // 从世界变换矩阵中提取位置（第四列）
-  float worldX = worldTransform[3][0];
-  float worldY = worldTransform[3][1];
-
-  // 从世界变换矩阵中提取缩放
-  float worldScaleX =
-      glm::length(glm::vec2(worldTransform[0][0], worldTransform[0][1]));
-  float worldScaleY =
-      glm::length(glm::vec2(worldTransform[1][0], worldTransform[1][1]));
-
-  auto anchorPt = anchor();
-
-  // 锚点由 Renderer 在绘制时处理，这里只传递位置和尺寸
-  Rect destRect(worldX, worldY, width * worldScaleX, height * worldScaleY);
-
-  // 调整源矩形（翻转）
-  Rect srcRect = textureRect_;
-  if (flipX_) {
-    srcRect.origin.x = srcRect.right();
-    srcRect.size.width = -srcRect.size.width;
-  }
-  if (flipY_) {
-    srcRect.origin.y = srcRect.bottom();
-    srcRect.size.height = -srcRect.size.height;
-  }
-
-  // 从世界变换矩阵中提取旋转角度
-  float worldRotation = std::atan2(worldTransform[0][1], worldTransform[0][0]);
-
-  // 创建渲染命令
-  RenderCommand cmd;
-  cmd.type = RenderCommandType::Sprite;
-  cmd.layer = zOrder;
-  cmd.data = SpriteCommandData{texture_.get(), destRect, srcRect, color_,
-                               worldRotation,  anchorPt, 0};
-
-  commands.push_back(std::move(cmd));
-}
-
-} // namespace extra2d