diff --git a/src/renderer/renderer_module.cpp b/src/renderer/renderer_module.cpp
index a7d6e53..174409f 100644
--- a/src/renderer/renderer_module.cpp
+++ b/src/renderer/renderer_module.cpp
@@ -1,3 +1,4 @@
+#include "glad/glad.h"
 #include <algorithm>
 #include <event/events.h>
 #include <glm/gtc/type_ptr.hpp>
@@ -142,9 +143,6 @@ void RendererModule::onWindowShow() {
   setViewport(0, 0, static_cast<int32>(windowWidth),
               static_cast<int32>(windowHeight));
 
-  // 禁用深度测试和背面剔除（2D渲染不需要）
-  // glDisable(GL_DEPTH_TEST);
-  // glDisable(GL_CULL_FACE);
   glEnable(GL_BLEND);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
diff --git a/src/renderer/shader.cpp b/src/renderer/shader.cpp
index 3c659d1..ddbb070 100644
--- a/src/renderer/shader.cpp
+++ b/src/renderer/shader.cpp
@@ -1,236 +1,226 @@
-#include <renderer/shader.h>
-#include <utils/logger.h>
-#include <glad/glad.h>
 #include <fstream>
+#include <glad/glad.h>
+#include <renderer/shader.h>
 #include <sstream>
+#include <utils/logger.h>
 
 namespace extra2d {
 
 Shader::Shader() = default;
 
 Shader::~Shader() {
-    if (program_ != 0) {
-        glDeleteProgram(program_);
-        program_ = 0;
-    }
+  if (program_ != 0) {
+    glDeleteProgram(program_);
+    program_ = 0;
+  }
 }
 
-bool Shader::loadFromFile(const std::string& vsPath, const std::string& fsPath) {
-    // 读取顶点着色器
-    std::ifstream vsFile(vsPath);
-    if (!vsFile.is_open()) {
-        E2D_LOG_ERROR("Failed to open vertex shader: {}", vsPath);
-        return false;
-    }
-    std::stringstream vsStream;
-    vsStream << vsFile.rdbuf();
-    std::string vsSource = vsStream.str();
-    
-    // 读取片段着色器
-    std::ifstream fsFile(fsPath);
-    if (!fsFile.is_open()) {
-        E2D_LOG_ERROR("Failed to open fragment shader: {}", fsPath);
-        return false;
-    }
-    std::stringstream fsStream;
-    fsStream << fsFile.rdbuf();
-    std::string fsSource = fsStream.str();
-    
-    return loadFromSource(vsSource, fsSource);
+bool Shader::loadFromFile(const std::string &vsPath,
+                          const std::string &fsPath) {
+  // 读取顶点着色器
+  std::ifstream vsFile(vsPath);
+  if (!vsFile.is_open()) {
+    E2D_LOG_ERROR("Failed to open vertex shader: {}", vsPath);
+    return false;
+  }
+  std::stringstream vsStream;
+  vsStream << vsFile.rdbuf();
+  std::string vsSource = vsStream.str();
+
+  // 读取片段着色器
+  std::ifstream fsFile(fsPath);
+  if (!fsFile.is_open()) {
+    E2D_LOG_ERROR("Failed to open fragment shader: {}", fsPath);
+    return false;
+  }
+  std::stringstream fsStream;
+  fsStream << fsFile.rdbuf();
+  std::string fsSource = fsStream.str();
+
+  return loadFromSource(vsSource, fsSource);
 }
 
-bool Shader::loadFromSource(const std::string& vsSource, const std::string& fsSource) {
-    // 删除旧程序
-    if (program_ != 0) {
-        glDeleteProgram(program_);
-        program_ = 0;
-    }
-    
-    uniformCache_.clear();
-    
-    // 处理源码（添加版本声明）
-    std::string processedVS = addVersionIfNeeded(vsSource, GL_VERTEX_SHADER);
-    std::string processedFS = addVersionIfNeeded(fsSource, GL_FRAGMENT_SHADER);
-    
-    E2D_LOG_INFO("Compiling vertex shader...");
-    // 编译顶点着色器
-    GLuint vs = compileShader(GL_VERTEX_SHADER, processedVS);
-    if (vs == 0) {
-        E2D_LOG_ERROR("Vertex shader compilation failed");
-        return false;
-    }
-    
-    E2D_LOG_INFO("Compiling fragment shader...");
-    // 编译片段着色器
-    GLuint fs = compileShader(GL_FRAGMENT_SHADER, processedFS);
-    if (fs == 0) {
-        E2D_LOG_ERROR("Fragment shader compilation failed");
-        glDeleteShader(vs);
-        return false;
-    }
-    
-    E2D_LOG_INFO("Linking shader program...");
-    // 链接程序
-    if (!linkProgram(vs, fs)) {
-        E2D_LOG_ERROR("Shader program linking failed");
-        glDeleteShader(vs);
-        glDeleteShader(fs);
-        return false;
-    }
-    
-    // 清理着色器对象
+bool Shader::loadFromSource(const std::string &vsSource,
+                            const std::string &fsSource) {
+  // 删除旧程序
+  if (program_ != 0) {
+    glDeleteProgram(program_);
+    program_ = 0;
+  }
+
+  uniformCache_.clear();
+
+  // 处理源码（添加版本声明）
+  std::string processedVS = addVersionIfNeeded(vsSource, GL_VERTEX_SHADER);
+  std::string processedFS = addVersionIfNeeded(fsSource, GL_FRAGMENT_SHADER);
+
+  E2D_LOG_INFO("Compiling vertex shader...");
+  // 编译顶点着色器
+  GLuint vs = compileShader(GL_VERTEX_SHADER, processedVS);
+  if (vs == 0) {
+    E2D_LOG_ERROR("Vertex shader compilation failed");
+    return false;
+  }
+
+  E2D_LOG_INFO("Compiling fragment shader...");
+  // 编译片段着色器
+  GLuint fs = compileShader(GL_FRAGMENT_SHADER, processedFS);
+  if (fs == 0) {
+    E2D_LOG_ERROR("Fragment shader compilation failed");
+    glDeleteShader(vs);
+    return false;
+  }
+
+  E2D_LOG_INFO("Linking shader program...");
+  // 链接程序
+  if (!linkProgram(vs, fs)) {
+    E2D_LOG_ERROR("Shader program linking failed");
     glDeleteShader(vs);
     glDeleteShader(fs);
-    
-    E2D_LOG_INFO("Shader program created successfully, program ID: {}", program_);
-    return true;
+    return false;
+  }
+
+  // 清理着色器对象
+  glDeleteShader(vs);
+  glDeleteShader(fs);
+
+  E2D_LOG_INFO("Shader program created successfully, program ID: {}", program_);
+  return true;
 }
 
 void Shader::bind() const {
-    if (program_ != 0) {
-        glUseProgram(program_);
-    }
+  if (program_ != 0) {
+    glUseProgram(program_);
+  }
 }
 
-void Shader::unbind() const {
-    glUseProgram(0);
+void Shader::unbind() const { glUseProgram(0); }
+
+void Shader::setUniformBlock(const std::string &name, uint32_t binding) {
+  if (program_ == 0)
+    return;
+
+  GLuint index = glGetUniformBlockIndex(program_, name.c_str());
+  if (index != GL_INVALID_INDEX) {
+    glUniformBlockBinding(program_, index, binding);
+  }
 }
 
-void Shader::setUniformBlock(const std::string& name, uint32_t binding) {
-    if (program_ == 0) return;
-    
-    GLuint index = glGetUniformBlockIndex(program_, name.c_str());
-    if (index != GL_INVALID_INDEX) {
-        glUniformBlockBinding(program_, index, binding);
-    }
+void Shader::setInt(const std::string &name, int value) {
+  GLint location = getUniformLocation(name);
+  if (location != -1) {
+    glUniform1i(location, value);
+  }
 }
 
-void Shader::setInt(const std::string& name, int value) {
-    GLint location = getUniformLocation(name);
-    if (location != -1) {
-        glUniform1i(location, value);
-    }
+void Shader::setFloat(const std::string &name, float value) {
+  GLint location = getUniformLocation(name);
+  if (location != -1) {
+    glUniform1f(location, value);
+  }
 }
 
-void Shader::setFloat(const std::string& name, float value) {
-    GLint location = getUniformLocation(name);
-    if (location != -1) {
-        glUniform1f(location, value);
-    }
+void Shader::setVec2(const std::string &name, float x, float y) {
+  GLint location = getUniformLocation(name);
+  if (location != -1) {
+    glUniform2f(location, x, y);
+  }
 }
 
-void Shader::setVec2(const std::string& name, float x, float y) {
-    GLint location = getUniformLocation(name);
-    if (location != -1) {
-        glUniform2f(location, x, y);
-    }
+void Shader::setVec4(const std::string &name, float x, float y, float z,
+                     float w) {
+  GLint location = getUniformLocation(name);
+  if (location != -1) {
+    glUniform4f(location, x, y, z, w);
+  }
 }
 
-void Shader::setVec4(const std::string& name, float x, float y, float z, float w) {
-    GLint location = getUniformLocation(name);
-    if (location != -1) {
-        glUniform4f(location, x, y, z, w);
-    }
+void Shader::setMat4(const std::string &name, const float *value) {
+  GLint location = getUniformLocation(name);
+  if (location != -1) {
+    glUniformMatrix4fv(location, 1, GL_FALSE, value);
+  }
 }
 
-void Shader::setMat4(const std::string& name, const float* value) {
-    GLint location = getUniformLocation(name);
-    if (location != -1) {
-        glUniformMatrix4fv(location, 1, GL_FALSE, value);
-        // 调试：输出设置成功的uniform
-        static int logCount = 0;
-        if (logCount < 3) {
-            E2D_LOG_INFO("Set uniform '{}' at location {}", name, location);
-            logCount++;
-        }
-    } else {
-        // 调试：输出未找到的uniform
-        static bool loggedOnce = false;
-        if (!loggedOnce) {
-            E2D_LOG_WARN("Uniform '{}' not found in shader", name);
-            loggedOnce = true;
-        }
-    }
-}
+GLuint Shader::compileShader(GLenum type, const std::string &source) {
+  GLuint shader = glCreateShader(type);
 
-GLuint Shader::compileShader(GLenum type, const std::string& source) {
-    GLuint shader = glCreateShader(type);
-    
-    const char* src = source.c_str();
-    glShaderSource(shader, 1, &src, nullptr);
-    glCompileShader(shader);
-    
-    // 检查编译状态
-    GLint success;
-    glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
-    if (!success) {
-        char infoLog[512];
-        glGetShaderInfoLog(shader, 512, nullptr, infoLog);
-        
-        const char* typeStr = (type == GL_VERTEX_SHADER) ? "vertex" : "fragment";
-        E2D_LOG_ERROR("{} shader compilation failed: {}", typeStr, infoLog);
-        
-        glDeleteShader(shader);
-        return 0;
-    }
-    
-    return shader;
+  const char *src = source.c_str();
+  glShaderSource(shader, 1, &src, nullptr);
+  glCompileShader(shader);
+
+  // 检查编译状态
+  GLint success;
+  glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
+  if (!success) {
+    char infoLog[512];
+    glGetShaderInfoLog(shader, 512, nullptr, infoLog);
+
+    const char *typeStr = (type == GL_VERTEX_SHADER) ? "vertex" : "fragment";
+    E2D_LOG_ERROR("{} shader compilation failed: {}", typeStr, infoLog);
+
+    glDeleteShader(shader);
+    return 0;
+  }
+
+  return shader;
 }
 
 bool Shader::linkProgram(GLuint vertexShader, GLuint fragmentShader) {
-    program_ = glCreateProgram();
-    glAttachShader(program_, vertexShader);
-    glAttachShader(program_, fragmentShader);
-    glLinkProgram(program_);
-    
-    // 检查链接状态
-    GLint success;
-    glGetProgramiv(program_, GL_LINK_STATUS, &success);
-    if (!success) {
-        char infoLog[512];
-        glGetProgramInfoLog(program_, 512, nullptr, infoLog);
-        E2D_LOG_ERROR("Shader program linking failed: {}", infoLog);
-        
-        glDeleteProgram(program_);
-        program_ = 0;
-        return false;
-    }
-    
-    return true;
+  program_ = glCreateProgram();
+  glAttachShader(program_, vertexShader);
+  glAttachShader(program_, fragmentShader);
+  glLinkProgram(program_);
+
+  // 检查链接状态
+  GLint success;
+  glGetProgramiv(program_, GL_LINK_STATUS, &success);
+  if (!success) {
+    char infoLog[512];
+    glGetProgramInfoLog(program_, 512, nullptr, infoLog);
+    E2D_LOG_ERROR("Shader program linking failed: {}", infoLog);
+
+    glDeleteProgram(program_);
+    program_ = 0;
+    return false;
+  }
+
+  return true;
 }
 
-GLint Shader::getUniformLocation(const std::string& name) {
-    if (program_ == 0) return -1;
-    
-    // 检查缓存
-    auto it = uniformCache_.find(name);
-    if (it != uniformCache_.end()) {
-        return it->second;
-    }
-    
-    // 查询 uniform 位置
-    GLint location = glGetUniformLocation(program_, name.c_str());
-    uniformCache_[name] = location;
-    
-    return location;
+GLint Shader::getUniformLocation(const std::string &name) {
+  if (program_ == 0)
+    return -1;
+
+  // 检查缓存
+  auto it = uniformCache_.find(name);
+  if (it != uniformCache_.end()) {
+    return it->second;
+  }
+
+  // 查询 uniform 位置
+  GLint location = glGetUniformLocation(program_, name.c_str());
+  uniformCache_[name] = location;
+
+  return location;
 }
 
-std::string Shader::addVersionIfNeeded(const std::string& source, GLenum type) {
-    // 如果已经包含版本声明，直接返回
-    if (source.find("#version") != std::string::npos) {
-        return source;
-    }
-    
-    // 添加 OpenGL ES 3.2 版本声明
-    std::string result = "#version 320 es\n";
-    
-    // 片段着色器需要添加精度声明
-    if (type == GL_FRAGMENT_SHADER) {
-        result += "precision mediump float;\n";
-    }
-    
-    result += source;
-    return result;
+std::string Shader::addVersionIfNeeded(const std::string &source, GLenum type) {
+  // 如果已经包含版本声明，直接返回
+  if (source.find("#version") != std::string::npos) {
+    return source;
+  }
+
+  // 添加 OpenGL ES 3.2 版本声明
+  std::string result = "#version 320 es\n";
+
+  // 片段着色器需要添加精度声明
+  if (type == GL_FRAGMENT_SHADER) {
+    result += "precision mediump float;\n";
+  }
+
+  result += source;
+  return result;
 }
 
 } // namespace extra2d
diff --git a/src/scene/director.cpp b/src/scene/director.cpp
index 8ab5213..4dbdab5 100644
--- a/src/scene/director.cpp
+++ b/src/scene/director.cpp
@@ -1,154 +1,140 @@
-#include <scene/director.h>
-#include <scene/components/camera_component.h>
 #include <event/events.h>
+#include <scene/components/camera_component.h>
+#include <scene/director.h>
 #include <utils/logger.h>
 
 namespace extra2d {
 
-Director::Director() {
-}
+Director::Director() {}
 
-Director::~Director() {
-    shutdown();
-}
+Director::~Director() { shutdown(); }
 
-bool Director::init() {
-    return true;
-}
+bool Director::init() { return true; }
 
 void Director::shutdown() {
-    // 结束当前场景
-    if (runningScene_) {
-        runningScene_->onExit();
-        runningScene_.reset();
-    }
+  // 结束当前场景
+  if (runningScene_) {
+    runningScene_->onExit();
+    runningScene_.reset();
+  }
 
-    // 清空场景栈
-    while (!sceneStack_.empty()) {
-        sceneStack_.pop();
-    }
+  // 清空场景栈
+  while (!sceneStack_.empty()) {
+    sceneStack_.pop();
+  }
 
-    running_ = false;
+  running_ = false;
 }
 
 void Director::runScene(Ptr<Scene> scene) {
-    if (!scene) return;
+  if (!scene)
+    return;
 
-    // 结束当前场景
-    if (runningScene_) {
-        runningScene_->onExit();
-    }
+  // 结束当前场景
+  if (runningScene_) {
+    runningScene_->onExit();
+  }
 
-    // 清空场景栈
-    while (!sceneStack_.empty()) {
-        sceneStack_.pop();
-    }
+  // 清空场景栈
+  while (!sceneStack_.empty()) {
+    sceneStack_.pop();
+  }
 
-    // 运行新场景
-    runningScene_ = scene;
-    runningScene_->onEnter();
-    running_ = true;
-    needEnd_ = false;
+  // 运行新场景
+  runningScene_ = scene;
+  runningScene_->onEnter();
+  running_ = true;
+  needEnd_ = false;
 }
 
 void Director::replaceScene(Ptr<Scene> scene) {
-    if (!scene) return;
+  if (!scene)
+    return;
 
-    // 结束当前场景
-    if (runningScene_) {
-        runningScene_->onExit();
-    }
+  // 结束当前场景
+  if (runningScene_) {
+    runningScene_->onExit();
+  }
 
-    // 替换场景
-    runningScene_ = scene;
-    runningScene_->onEnter();
+  // 替换场景
+  runningScene_ = scene;
+  runningScene_->onEnter();
 }
 
 void Director::pushScene(Ptr<Scene> scene) {
-    if (!scene) return;
+  if (!scene)
+    return;
 
-    // 暂停当前场景
-    if (runningScene_) {
-        // 可以在这里添加暂停逻辑
-        sceneStack_.push(runningScene_);
-    }
+  // 暂停当前场景
+  if (runningScene_) {
+    // 可以在这里添加暂停逻辑
+    sceneStack_.push(runningScene_);
+  }
 
-    // 运行新场景
-    runningScene_ = scene;
-    runningScene_->onEnter();
+  // 运行新场景
+  runningScene_ = scene;
+  runningScene_->onEnter();
 }
 
 void Director::popScene() {
-    if (sceneStack_.empty()) {
-        // 没有场景可以弹出，结束运行
-        end();
-        return;
-    }
+  if (sceneStack_.empty()) {
+    // 没有场景可以弹出，结束运行
+    end();
+    return;
+  }
 
-    // 结束当前场景
-    if (runningScene_) {
-        runningScene_->onExit();
-    }
+  // 结束当前场景
+  if (runningScene_) {
+    runningScene_->onExit();
+  }
 
-    // 弹出栈顶场景
-    runningScene_ = sceneStack_.top();
-    sceneStack_.pop();
+  // 弹出栈顶场景
+  runningScene_ = sceneStack_.top();
+  sceneStack_.pop();
 
-    // 恢复场景
-    // 可以在这里添加恢复逻辑
+  // 恢复场景
+  // 可以在这里添加恢复逻辑
 }
 
 void Director::end() {
-    needEnd_ = true;
-    running_ = false;
+  needEnd_ = true;
+  running_ = false;
 
-    if (runningScene_) {
-        runningScene_->onExit();
-        runningScene_.reset();
-    }
+  if (runningScene_) {
+    runningScene_->onExit();
+    runningScene_.reset();
+  }
 }
 
-Scene* Director::getRunningScene() const {
-    return runningScene_.get();
-}
+Scene *Director::getRunningScene() const { return runningScene_.get(); }
 
-CameraComponent* Director::getMainCamera() const {
-    if (runningScene_) {
-        return runningScene_->getMainCamera();
-    }
-    return nullptr;
+CameraComponent *Director::getMainCamera() const {
+  if (runningScene_) {
+    return runningScene_->getMainCamera();
+  }
+  return nullptr;
 }
 
 void Director::update(float dt) {
-    if (!running_ || !runningScene_) return;
+  if (!running_ || !runningScene_)
+    return;
 
-    runningScene_->update(dt);
+  runningScene_->update(dt);
 }
 
 void Director::render() {
-    if (!running_ || !runningScene_) return;
+  if (!running_ || !runningScene_)
+    return;
 
-    // 从场景获取相机并上传矩阵
-    CameraComponent* camera = runningScene_->getMainCamera();
-    if (camera) {
-        Mat4 viewProj = camera->getViewProjectionMatrix();
-        
-        // 调试输出：打印视图投影矩阵
-        static bool logged = false;
-        if (!logged) {
-            const float* m = glm::value_ptr(viewProj);
-            E2D_LOG_INFO("ViewProjection Matrix:");
-            E2D_LOG_INFO("  {:.4f} {:.4f} {:.4f} {:.4f}", m[0], m[4], m[8], m[12]);
-            E2D_LOG_INFO("  {:.4f} {:.4f} {:.4f} {:.4f}", m[1], m[5], m[9], m[13]);
-            E2D_LOG_INFO("  {:.4f} {:.4f} {:.4f} {:.4f}", m[2], m[6], m[10], m[14]);
-            E2D_LOG_INFO("  {:.4f} {:.4f} {:.4f} {:.4f}", m[3], m[7], m[11], m[15]);
-            logged = true;
-        }
-        
-        events::OnRenderSetCamera::emit(viewProj);
-    }
+  // 从场景获取相机并上传矩阵
+  CameraComponent *camera = runningScene_->getMainCamera();
+  if (camera) {
+    Mat4 viewProj = camera->getViewProjectionMatrix();
 
-    runningScene_->render();
+    events::OnRenderSetCamera::emit(viewProj);
+  }
+
+  runningScene_->render();
 }
 
 } // namespace extra2d