refactor(render):重构渲染系统架构

- 将 BufferBuilder 移至 systems.buffer 包并增强功能- 添加 BuiltBuffer 和 RenderState 内部类支持状态管理- 新增 BufferUploader 类处理缓冲区上传和状态应用
- 引入 RenderSystem 统一封装 OpenGL 调用
- Mesh2D 和 ModelRender 更新使用新的渲染系统接口- ModelGLPanel 适配新包结构并使用 RenderSystem 初始化
- 移除旧版 LightSource 构造函数- 整体提升渲染代码的模块化和可维护性

重要更新
- 重写渲染器
- 移除辉光，采用旧版着色器渲染，任何有关辉光的将在下一个版本彻底删除

src/main/java/com/chuangzhou/vivid2D/render/ModelRender.java

@@ -2,20 +2,20 @@ package com.chuangzhou.vivid2D.render;
 
 import com.chuangzhou.vivid2D.render.model.Model2D;
 import com.chuangzhou.vivid2D.render.model.ModelPart;
-import com.chuangzhou.vivid2D.render.model.buffer.BufferBuilder;
+import com.chuangzhou.vivid2D.render.systems.buffer.BufferBuilder;
+import com.chuangzhou.vivid2D.render.systems.buffer.Tesselator;
 import com.chuangzhou.vivid2D.render.model.util.LightSource;
 import com.chuangzhou.vivid2D.render.model.util.Mesh2D;
 import com.chuangzhou.vivid2D.render.model.util.PhysicsSystem;
+import com.chuangzhou.vivid2D.render.systems.RenderSystem;
+import com.chuangzhou.vivid2D.render.systems.ShaderSources;
 import org.joml.Matrix3f;
 import org.joml.Vector2f;
 import org.joml.Vector4f;
 import org.lwjgl.opengl.*;
-import org.lwjgl.system.MemoryUtil;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.nio.ByteBuffer;
-import java.nio.FloatBuffer;
 import java.util.*;
 import java.util.concurrent.atomic.AtomicInteger;
 
@@ -45,82 +45,152 @@ import static org.lwjgl.opengl.GL20.glGetUniformLocation;
  * </ul>
  *
  * @author tzdwindows
- * @version 1.0
+ * @version 1.2
  * @since 2025-10-13
  */
 public final class ModelRender {
+    /**
+     * 渲染系统日志记录器，用于记录渲染过程中的调试信息、错误和性能数据
+     */
     private static final Logger logger = LoggerFactory.getLogger(ModelRender.class);
+
+    /**
+     * 私有构造函数，防止外部实例化 - 这是一个工具类，只包含静态方法
+     */
     private ModelRender() { /* no instances */ }
 
-    // ================== 全局状态 ==================
+// ================== 全局状态 ==================
+
+    /**
+     * 渲染系统初始化状态标志，确保系统只初始化一次
+     * @see #initialize()
+     * @see #isInitialized()
+     */
     private static boolean initialized = false;
+
+    /**
+     * 视口宽度（像素），定义渲染区域的大小
+     * 默认值：800像素
+     * @see #setViewport(int, int)
+     */
     private static int viewportWidth = 800;
+
+    /**
+     * 视口高度（像素），定义渲染区域的大小
+     * 默认值：600像素
+     * @see #setViewport(int, int)
+     */
     private static int viewportHeight = 600;
+
+    /**
+     * 清除颜色（RGBA），用于在每帧开始时清空颜色缓冲区
+     * 默认值：黑色不透明 (0.0f, 0.0f, 0.0f, 1.0f)
+     * @see RenderSystem#clearColor(float, float, float, float)
+     */
     private static final Vector4f CLEAR_COLOR = new Vector4f(0.0f, 0.0f, 0.0f, 1.0f);
+
+    /**
+     * 深度测试启用标志，控制是否进行深度缓冲测试
+     * 在2D渲染中通常禁用以提高性能
+     * 默认值：false（禁用）
+     * @see RenderSystem#enableDepthTest()
+     * @see RenderSystem#disableDepthTest()
+     */
     private static final boolean enableDepthTest = false;
+
+    /**
+     * 混合功能启用标志，控制透明度和颜色混合
+     * 默认值：true（启用）
+     * @see RenderSystem#enableBlend()
+     * @see RenderSystem#disableBlend()
+     */
     private static final boolean enableBlending = true;
 
-    // 着色器与资源
-    private static final Map<String, ShaderProgram> shaderMap = new HashMap<>();
-    private static ShaderProgram defaultProgram = null;
+    private static final int SHADER_MAX_LIGHTS = 8;
 
+// ================== 着色器与资源管理 ==================
+
+    /**
+     * 着色器程序缓存映射，按名称存储已编译的着色器程序
+     * 键：着色器名称（如 "default"）
+     * 值：对应的着色器程序对象
+     * @see ShaderSources.ShaderProgram
+     */
+    private static final Map<String, ShaderSources.ShaderProgram> shaderMap = new HashMap<>();
+
+    /**
+     * 默认着色器程序，用于大多数模型的渲染
+     * 包含基础的光照、纹理和变换功能
+     * @see #compileDefaultShader()
+     */
+    private static ShaderSources.ShaderProgram defaultProgram = null;
+
+    /**
+     * 网格GPU资源缓存，管理已上传到GPU的网格数据
+     * 键：Mesh2D对象
+     * 值：对应的OpenGL资源（VAO、VBO、EBO）
+     * @see MeshGLResources
+     */
     private static final Map<Mesh2D, MeshGLResources> meshResources = new HashMap<>();
+
+    /**
+     * 纹理单元分配器，用于管理多个纹理的绑定
+     * 确保不同的纹理绑定到正确的纹理单元
+     * 默认从0开始递增分配
+     */
     private static final AtomicInteger textureUnitAllocator = new AtomicInteger(0);
 
-    // 默认白色纹理
+    /**
+     * 默认白色纹理ID，当模型没有指定纹理时使用
+     * 这是一个1x1的纯白色纹理，确保模型有基本的颜色显示
+     * @see #createDefaultTexture()
+     */
     private static int defaultTextureId = 0;
 
-    // ================== 碰撞箱渲染配置 ==================
-    // 是否在渲染时绘制碰撞箱（线框）
-    public static boolean renderColliders = false;
-    // 碰撞箱线宽
-    public static float colliderLineWidth = 2.0f;
-    // 碰撞箱颜色（默认白色）
+// ================== 碰撞箱渲染配置 ==================
+
+    /**
+     * 碰撞箱渲染开关，控制是否在场景中显示物理碰撞体的轮廓
+     * 调试时非常有用，可以直观看到碰撞边界
+     * 默认值：true（启用）
+     */
+    public static boolean renderColliders = true;
+
+    /**
+     * 碰撞箱线框宽度，控制碰撞体轮廓线的粗细
+     * 单位：像素
+     * 默认值：1.0f
+     */
+    public static float colliderLineWidth = 1.0f;
+
+    /**
+     * 碰撞箱颜色（RGBA），定义碰撞体轮廓的显示颜色
+     * 默认值：白色不透明 (1.0f, 1.0f, 1.0f, 1.0f)
+     */
     public static Vector4f colliderColor = new Vector4f(1.0f, 1.0f, 1.0f, 1.0f);
-    // 圆形碰撞体绘制细分（越高越圆）
+
+    /**
+     * 圆形碰撞体细分数量，控制圆形碰撞体的平滑度
+     * 值越高圆形越平滑，但渲染开销也越大
+     * 默认值：32（在性能和视觉效果间取得平衡）
+     */
     private static final int CIRCLE_SEGMENTS = 32;
-    // 是否在渲染时绘制碰撞箱
+
+    /**
+     * 光源位置渲染开关，控制是否在场景中显示光源的位置
+     * 用点状标记显示每个启用的光源位置
+     * 默认值：true（启用）
+     */
     public static boolean renderLightPositions = true;
 
-    // ================== 内部类：ShaderProgram ==================
-    private static class ShaderProgram {
-        final int programId;
-        final Map<String, Integer> uniformCache = new HashMap<>();
+    // ================== 内部类：ShaderSources.ShaderProgram ==================
 
-        ShaderProgram(int programId) {
-            this.programId = programId;
-        }
-
-        void use() {
-            GL20.glUseProgram(programId);
-        }
-
-        void stop() {
-            GL20.glUseProgram(0);
-        }
-
-        int getUniformLocation(String name) {
-            return uniformCache.computeIfAbsent(name, k -> {
-                int loc = glGetUniformLocation(programId, k);
-                if (loc == -1) {
-                    // debug 时可以打开
-                    logger.warn("Warning: uniform not found: {}", k);
-                }
-                return loc;
-            });
-        }
-
-        void delete() {
-            if (GL20.glIsProgram(programId)) GL20.glDeleteProgram(programId);
-        }
-    }
 
     // ================== 内部类：MeshGLResources ==================
     private static class MeshGLResources {
         int vao = 0;
         int vbo = 0;
         int ebo = 0;
-        int vertexCount = 0;
         boolean initialized = false;
 
         void dispose() {
@@ -131,179 +201,19 @@ public final class ModelRender {
         }
     }
 
-    // ================== 着色器源 ==================
-    private static final String VERTEX_SHADER_SRC =
-            """
-            #version 330 core
-            layout(location = 0) in vec2 aPosition;
-            layout(location = 1) in vec2 aTexCoord;
-            out vec2 vTexCoord;
-            out vec2 vWorldPos;
-            
-            uniform mat3 uModelMatrix;
-            uniform mat3 uViewMatrix;
-            uniform mat3 uProjectionMatrix;
-            
-            void main() {
-                vec3 p = uProjectionMatrix * uViewMatrix * uModelMatrix * vec3(aPosition, 1.0);
-                gl_Position = vec4(p.xy, 0.0, 1.0);
-                vTexCoord = aTexCoord;
-                vWorldPos = (uModelMatrix * vec3(aPosition, 1.0)).xy;
-            }
-            """;
-
-    private static final String FRAGMENT_SHADER_SRC =
-            """
-            #version 330 core
-            in vec2 vTexCoord;
-            in vec2 vWorldPos;
-            out vec4 FragColor;
-           
-            uniform sampler2D uTexture;
-            uniform vec4 uColor;
-            uniform float uOpacity;
-            uniform int uBlendMode;
-            uniform int uDebugMode;
-           
-            #define MAX_LIGHTS 8
-            uniform vec2 uLightsPos[MAX_LIGHTS];
-            uniform vec3 uLightsColor[MAX_LIGHTS];
-            uniform float uLightsIntensity[MAX_LIGHTS];
-            uniform int uLightsIsAmbient[MAX_LIGHTS];
-            uniform int uLightCount;
-           
-            // 辉光相关
-            uniform int uLightsIsGlow[MAX_LIGHTS];
-            uniform vec2 uLightsGlowDir[MAX_LIGHTS];
-            uniform float uLightsGlowIntensity[MAX_LIGHTS];
-            uniform float uLightsGlowRadius[MAX_LIGHTS];
-            uniform float uLightsGlowAmount[MAX_LIGHTS];
-           
-            // 常用衰减系数（可在 shader 内微调）
-            const float ATT_CONST = 1.0;
-            const float ATT_LINEAR = 0.09;
-            const float ATT_QUAD = 0.032;
-           
-            // 简单 Reinhard tone mapping，避免过曝
-            vec3 toneMap(vec3 color) {
-                return color / (color + vec3(1.0));
-            }
-           
-            void main() {
-                // 先采样纹理
-                vec4 tex = texture(uTexture, vTexCoord);
-                float alpha = tex.a * uOpacity;
-                if (alpha <= 0.001) discard;
-           
-                // 基础颜色（纹理 * 部件颜色）
-                vec3 baseColor = tex.rgb * uColor.rgb;
-           
-                // 如果没有光源，仅返回基础颜色（节约性能）
-                if (uLightCount == 0) {
-                    vec3 outCol = clamp(baseColor, 0.0, 1.0);
-                    if (uBlendMode == 1) outCol = tex.rgb + uColor.rgb;
-                    else if (uBlendMode == 2) outCol = tex.rgb * uColor.rgb;
-                    else if (uBlendMode == 3) outCol = 1.0 - (1.0 - tex.rgb) * (1.0 - uColor.rgb);
-                    FragColor = vec4(outCol, alpha);
-                    return;
-                }
-           
-                // 环境光基线
-                vec3 ambientBase = vec3(0.06);
-                vec3 lighting = vec3(0.0);
-                vec3 glowAccum = vec3(0.0);
-                vec3 specularAccum = vec3(0.0);
-           
-                // 累积显式标记为环境光的光源
-                for (int i = 0; i < uLightCount; ++i) {
-                    if (uLightsIsAmbient[i] == 1) {
-                        lighting += uLightsColor[i] * uLightsIntensity[i];
-                    }
-                }
-                lighting += ambientBase;
-           
-                // 对每个非环境光源计算物理式衰减 + 漫反射 + 简单高光 + 辉光（若启用）
-                for (int i = 0; i < uLightCount; ++i) {
-                    if (uLightsIsAmbient[i] == 1) continue;
-           
-                    vec2 toLight2 = uLightsPos[i] - vWorldPos;
-                    float dist = length(toLight2);
-                    // 物理风格衰减
-                    float attenuation = ATT_CONST / (ATT_CONST + ATT_LINEAR * dist + ATT_QUAD * dist * dist);
-                    float radiance = uLightsIntensity[i] * attenuation;
-           
-                    // 漫反射（在二维中基于距离模拟衰减的明暗）
-                    // 使用更平滑的距离曲线：max(0, 1 - (dist / (radiusApprox)))
-                    float radiusApprox = max(1.0, 1000.0 * attenuation); // 通过衰减估算影响半径
-                    float diffuseFactor = clamp(1.0 - (dist / (radiusApprox + 0.0001)), 0.0, 1.0);
-                    vec3 diff = uLightsColor[i] * radiance * diffuseFactor;
-                    lighting += diff;
-           
-                    // 简单高光（在 2D 中模拟亮点）
-                    vec3 viewDir = vec3(0.0, 0.0, 1.0);
-                    vec3 lightDir3 = normalize(vec3(toLight2, 0.0));
-                    vec3 normal = vec3(0.0, 0.0, 1.0);
-                    vec3 reflectDir = reflect(-lightDir3, normal);
-                    float specFactor = pow(max(dot(viewDir, reflectDir), 0.0), 32.0);
-                    float specIntensity = 0.25;
-                    specularAccum += uLightsColor[i] * radiance * specFactor * specIntensity;
-           
-                    // 若启用了辉光（glow），使用高斯风格衰减，并支持方向性辉光
-                    if (uLightsIsGlow[i] == 1) {
-                        float glowRadius = max(0.0001, uLightsGlowRadius[i]);
-                        float gdist = dist;
-                        // 高斯分布：exp(-(d^2) / (2 * sigma^2))
-                        float sigma = glowRadius * 0.5; // sigma = radius * 0.5（经验值）
-                        float gauss = exp(- (gdist * gdist) / (2.0 * sigma * sigma));
-           
-                        // 方向性因子：如果给出方向，使用方向与片元向量点积来增强朝向一侧的辉光
-                        float dirFactor = 1.0;
-                        vec2 glowDir = uLightsGlowDir[i];
-                        if (length(glowDir) > 0.0001) {
-                            vec2 ndir = normalize(glowDir);
-                            vec2 toFrag = normalize(vWorldPos - uLightsPos[i]);
-                            dirFactor = max(dot(ndir, toFrag), 0.0); // 只在方向半球贡献
-                        }
-                        float gIntensity = uLightsGlowIntensity[i];
-                        float gAmount = uLightsGlowAmount[i];
-                        vec3 glow = uLightsColor[i] * gauss * gIntensity * gAmount * dirFactor;
-                        glowAccum += glow;
-                    }
-                }
-           
-                // 合并直接光照与高光后进行简单的色调映射（避免过曝）
-                vec3 totalLighting = lighting + specularAccum;
-                // 防止数值过大，进行 Reinhard tone mapping
-                vec3 litMapped = toneMap(totalLighting);
-                vec3 finalColor = baseColor * litMapped;
-           
-                // 将辉光作为屏幕加色（加法混合），然后再做一次 tone map 以稳定输出
-                finalColor += glowAccum;
-                finalColor = toneMap(finalColor);
-           
-                // 支持简单的 blend 模式（保留已有行为）
-                if (uBlendMode == 1) finalColor = tex.rgb + uColor.rgb;
-                else if (uBlendMode == 2) finalColor = tex.rgb * uColor.rgb;
-                else if (uBlendMode == 3) finalColor = 1.0 - (1.0 - tex.rgb) * (1.0 - uColor.rgb);
-           
-                finalColor = clamp(finalColor, 0.0, 1.0);
-                FragColor = vec4(finalColor, alpha);
-            }
-            """;
-
     // ================== 初始化 / 清理 ==================
     public static synchronized void initialize() {
         if (initialized) return;
 
         logger.info("Initializing ModelRender...");
 
-        // 需要在外部创建 OpenGL 上下文并调用 GL.createCapabilities()
-        logGLInfo();
+        // 初始化渲染系统
+        RenderSystem.beginInitialization();
+        RenderSystem.initRenderThread();
 
-        // 初始 GL 状态
+        logGLInfo();
         setupGLState();
 
-        // 创建默认 shader
         try {
             compileDefaultShader();
         } catch (RuntimeException ex) {
@@ -311,24 +221,24 @@ public final class ModelRender {
             throw ex;
         }
 
-        // 创建默认纹理
         createDefaultTexture();
-
-        // 初始化视口
-        GL11.glViewport(0, 0, viewportWidth, viewportHeight);
+        RenderSystem.viewport(0, 0, viewportWidth, viewportHeight);
+        RenderSystem.finishInitialization();
 
         initialized = true;
         logger.info("ModelRender initialized successfully");
     }
 
     private static void logGLInfo() {
-        logger.info("OpenGL Vendor: {}", GL11.glGetString(GL11.GL_VENDOR));
-        logger.info("OpenGL Renderer: {}", GL11.glGetString(GL11.GL_RENDERER));
-        logger.info("OpenGL Version: {}", GL11.glGetString(GL11.GL_VERSION));
-        logger.info("GLSL Version: {}", GL20.glGetString(GL20.GL_SHADING_LANGUAGE_VERSION));
+        logger.info("OpenGL Vendor: {}", RenderSystem.getVendor());
+        logger.info("OpenGL Renderer: {}", RenderSystem.getRenderer());
+        logger.info("OpenGL Version: {}", RenderSystem.getOpenGLVersion());
+        logger.info("GLSL Version: {}", RenderSystem.getGLSLVersion());
+        RenderSystem.logDetailedGLInfo();
     }
 
-    private static void uploadLightsToShader(ShaderProgram sp, Model2D model) {
+
+    private static void uploadLightsToShader(ShaderSources.ShaderProgram sp, Model2D model) {
         List<com.chuangzhou.vivid2D.render.model.util.LightSource> lights = model.getLights();
         int idx = 0;
 
@@ -372,33 +282,34 @@ public final class ModelRender {
         }
     }
 
+
     private static void setupGLState() {
-        GL11.glClearColor(CLEAR_COLOR.x, CLEAR_COLOR.y, CLEAR_COLOR.z, CLEAR_COLOR.w);
+        RenderSystem.clearColor(CLEAR_COLOR.x, CLEAR_COLOR.y, CLEAR_COLOR.z, CLEAR_COLOR.w);
 
         if (enableBlending) {
-            GL11.glEnable(GL11.GL_BLEND);
-            GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+            RenderSystem.enableBlend();
+            RenderSystem.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
         } else {
-            GL11.glDisable(GL11.GL_BLEND);
+            RenderSystem.disableBlend();
         }
 
         if (enableDepthTest) {
-            GL11.glEnable(GL11.GL_DEPTH_TEST);
-            GL11.glDepthFunc(GL11.GL_LEQUAL);
+            RenderSystem.enableDepthTest();
+            RenderSystem.depthFunc(GL11.GL_LEQUAL);
+            RenderSystem.depthMask(true);
+            RenderSystem.clearDepth(1.0);
         } else {
-            GL11.glDisable(GL11.GL_DEPTH_TEST);
+            RenderSystem.disableDepthTest();
         }
 
-        GL11.glDisable(GL11.GL_CULL_FACE);
-
-        checkGLError("setupGLState");
+        RenderSystem.checkGLError("setupGLState");
     }
 
     private static void compileDefaultShader() {
-        int vs = compileShader(GL20.GL_VERTEX_SHADER, VERTEX_SHADER_SRC);
-        int fs = compileShader(GL20.GL_FRAGMENT_SHADER, FRAGMENT_SHADER_SRC);
+        int vs = compileShader(GL20.GL_VERTEX_SHADER, ShaderSources.VERTEX_SHADER_SRC);
+        int fs = compileShader(GL20.GL_FRAGMENT_SHADER, ShaderSources.FRAGMENT_SHADER_SRC);
         int prog = linkProgram(vs, fs);
-        ShaderProgram sp = new ShaderProgram(prog);
+        ShaderSources.ShaderProgram sp = new ShaderSources.ShaderProgram(prog);
         shaderMap.put("default", sp);
         defaultProgram = sp;
 
@@ -413,50 +324,19 @@ public final class ModelRender {
     }
 
     private static int compileShader(int type, String src) {
-        int shader = GL20.glCreateShader(type);
-        GL20.glShaderSource(shader, src);
-        GL20.glCompileShader(shader);
-        int status = GL20.glGetShaderi(shader, GL20.GL_COMPILE_STATUS);
-        if (status == GL11.GL_FALSE) {
-            String log = GL20.glGetShaderInfoLog(shader);
-            GL20.glDeleteShader(shader);
-            throw new RuntimeException("Shader compilation failed: " + log);
-        }
-        return shader;
+        RenderSystem.assertOnRenderThread();
+        return RenderSystem.compileShader(type, src);
     }
 
     private static int linkProgram(int vs, int fs) {
-        int prog = GL20.glCreateProgram();
-        GL20.glAttachShader(prog, vs);
-        GL20.glAttachShader(prog, fs);
-        GL20.glLinkProgram(prog);
-        int status = GL20.glGetProgrami(prog, GL20.GL_LINK_STATUS);
-        if (status == GL11.GL_FALSE) {
-            String log = GL20.glGetProgramInfoLog(prog);
-            GL20.glDeleteProgram(prog);
-            throw new RuntimeException("Program link failed: " + log);
-        }
-        // shaders can be deleted after linking
-        GL20.glDetachShader(prog, vs);
-        GL20.glDetachShader(prog, fs);
-        GL20.glDeleteShader(vs);
-        GL20.glDeleteShader(fs);
-        return prog;
+        RenderSystem.assertOnRenderThread();
+        return RenderSystem.linkProgram(vs, fs);
     }
 
     private static void createDefaultTexture() {
-        // 使用 GL11.glGenTextures() 获取单个 id（更直观，避免 IntBuffer 问题）
-        defaultTextureId = GL11.glGenTextures();
-        GL11.glBindTexture(GL11.GL_TEXTURE_2D, defaultTextureId);
-        ByteBuffer white = MemoryUtil.memAlloc(4);
-        white.put((byte)255).put((byte)255).put((byte)255).put((byte)255).flip();
-        GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA8, 1, 1, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, white);
-        MemoryUtil.memFree(white);
-        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
-        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
-        GL11.glBindTexture(GL11.GL_TEXTURE_2D, 0);
-
-        checkGLError("createDefaultTexture");
+        RenderSystem.assertOnRenderThread();
+        defaultTextureId = RenderSystem.createDefaultTexture();
+        RenderSystem.checkGLError("createDefaultTexture");
     }
 
     public static synchronized void cleanup() {
@@ -469,13 +349,13 @@ public final class ModelRender {
         meshResources.clear();
 
         // shaders
-        for (ShaderProgram sp : shaderMap.values()) sp.delete();
+        for (ShaderSources.ShaderProgram sp : shaderMap.values()) sp.delete();
         shaderMap.clear();
         defaultProgram = null;
 
         // textures
         if (defaultTextureId != 0) {
-            GL11.glDeleteTextures(defaultTextureId);
+            RenderSystem.deleteTextures(defaultTextureId);
             defaultTextureId = 0;
         }
 
@@ -488,6 +368,12 @@ public final class ModelRender {
         if (!initialized) throw new IllegalStateException("ModelRender not initialized");
         if (model == null) return;
 
+        // 确保在渲染线程
+        RenderSystem.assertOnRenderThread();
+
+        // 添加前置错误检查
+        RenderSystem.checkGLError("render_start");
+
         // 物理系统更新
         PhysicsSystem physics = model.getPhysics();
         if (physics != null && physics.isEnabled()) {
@@ -496,18 +382,34 @@ public final class ModelRender {
 
         model.update(deltaTime);
 
-        GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | (enableDepthTest ? GL11.GL_DEPTH_BUFFER_BIT : 0));
+        // 检查清除操作前的状态
+        RenderSystem.checkGLError("before_clear");
+        RenderSystem.clear(GL11.GL_COLOR_BUFFER_BIT | (enableDepthTest ? GL11.GL_DEPTH_BUFFER_BIT : 0));
+        RenderSystem.checkGLError("after_clear");
+
+        // 检查着色器程序
+        if (defaultProgram == null || defaultProgram.programId == 0) {
+            logger.error("Default shader program is not initialized");
+            return;
+        }
 
         defaultProgram.use();
+        RenderSystem.checkGLError("after_use_program");
 
         // 设置投影与视图
         Matrix3f proj = buildOrthoProjection(viewportWidth, viewportHeight);
         setUniformMatrix3(defaultProgram, "uProjectionMatrix", proj);
         setUniformMatrix3(defaultProgram, "uViewMatrix", new Matrix3f().identity());
+        RenderSystem.checkGLError("after_set_matrices");
 
         // 添加光源数据上传
         uploadLightsToShader(defaultProgram, model);
+        RenderSystem.checkGLError("after_upload_lights");
+
+        // 在渲染光源位置前检查
+        RenderSystem.checkGLError("before_render_light_positions");
         renderLightPositions(model);
+        RenderSystem.checkGLError("after_render_light_positions");
 
         // 递归渲染所有根部件
         Matrix3f identity = new Matrix3f().identity();
@@ -515,36 +417,81 @@ public final class ModelRender {
             if (p.getParent() != null) continue;
             renderPartRecursive(p, identity);
         }
+        RenderSystem.checkGLError("after_render_parts");
 
         if (renderColliders && physics != null) {
             renderPhysicsColliders(physics);
+            RenderSystem.checkGLError("after_render_colliders");
         }
 
-
-
         defaultProgram.stop();
-        checkGLError("render");
+        RenderSystem.checkGLError("render_end");
     }
 
     private static void renderLightPositions(Model2D model) {
         if (!renderLightPositions) return;
-
-        GL11.glPointSize(10.0f);
-        setUniformIntInternal(defaultProgram, "uDebugMode", 1);
-
+        // 设置灯泡颜色为光源的颜色
         for (LightSource light : model.getLights()) {
             if (!light.isEnabled()) continue;
 
-            // 绘制光源位置
-            BufferBuilder bb =
-                    new BufferBuilder(1 * 4);
-            bb.begin(GL11.GL_POINTS, 1);
-            bb.vertex(light.getPosition().x, light.getPosition().y, 0.5f, 0.5f);
-            bb.end();
-        }
+            // 使用光源的颜色来绘制灯泡
+            Vector4f lightColor = new Vector4f(light.getColor().x, light.getColor().y, light.getColor().z, 1.0f);
+            setUniformVec4Internal(defaultProgram, "uColor", lightColor);
 
-        setUniformIntInternal(defaultProgram, "uDebugMode", 0);
-        GL11.glPointSize(1.0f);
+            // 绘制灯泡形状
+            drawLightBulb(light.getPosition(), light.getIntensity());
+
+            if (light.isAmbient()) {
+                drawCrossMark(light.getPosition(), light.getIntensity());
+            }
+        }
+        // 恢复原始颜色
+        setUniformVec4Internal(defaultProgram, "uColor", new Vector4f(1,1,1,1));
+    }
+
+    /**
+     * 绘制简洁的灯泡形状
+     * @param position 灯泡位置
+     * @param intensity 光源强度，用于控制灯泡大小
+     */
+    private static void drawLightBulb(Vector2f position, float intensity) {
+        Tesselator tesselator = Tesselator.getInstance();
+        BufferBuilder builder = tesselator.getBuilder();
+        float bulbSize = 3.0f + (intensity / 10.0f);
+        int segments = 16;
+        builder.begin(RenderSystem.DRAW_TRIANGLE_FAN, segments + 2);
+
+        builder.vertex(position.x, position.y, 0.5f, 0.5f);
+
+        for (int i = 0; i <= segments; i++) {
+            double angle = 2.0 * Math.PI * i / segments;
+            float x = position.x + bulbSize * (float) Math.cos(angle);
+            float y = position.y + bulbSize * (float) Math.sin(angle);
+            builder.vertex(x, y, 0.5f, 0.5f);
+        }
+        tesselator.end();
+    }
+
+    /**
+     * 绘制十字标记（用于环境光）
+     */
+    private static void drawCrossMark(Vector2f position, float size) {
+        Tesselator tesselator = Tesselator.getInstance();
+        BufferBuilder builder = tesselator.getBuilder();
+
+        float crossSize = size * 0.8f;
+
+        // 绘制水平线
+        builder.begin(RenderSystem.DRAW_LINES, 2);
+        builder.vertex(position.x - crossSize, position.y, 0.5f, 0.5f);
+        builder.vertex(position.x + crossSize, position.y, 0.5f, 0.5f);
+        tesselator.end();
+
+        // 绘制垂直线
+        builder.begin(RenderSystem.DRAW_LINES, 2);
+        builder.vertex(position.x, position.y - crossSize, 0.5f, 0.5f);
+        builder.vertex(position.x, position.y + crossSize, 0.5f, 0.5f);
+        tesselator.end();
     }
 
     /**
@@ -587,7 +534,7 @@ public final class ModelRender {
             setUniformIntInternal(defaultProgram, "uTexture", 0);
         } else {
             // 使用默认白色纹理
-            GL11.glBindTexture(GL11.GL_TEXTURE_2D, defaultTextureId);
+            RenderSystem.bindTexture(defaultTextureId);
             setUniformIntInternal(defaultProgram, "uTexture", 0);
         }
 
@@ -597,43 +544,78 @@ public final class ModelRender {
         // 调用 Mesh2D 的 draw 方法，传入当前使用的着色器程序和变换矩阵
         mesh.draw(defaultProgram.programId, matToUse);
 
-        checkGLError("renderMesh");
+        RenderSystem.checkGLError("renderMesh");
     }
 
     // ================== 渲染碰撞箱相关实现 ==================
 
     private static void renderPhysicsColliders(PhysicsSystem physics) {
-        // 设置渲染状态
-        GL11.glLineWidth(colliderLineWidth);
+        if (physics == null) {
+            logger.warn("renderPhysicsColliders: physics system is null");
+            return;
+        }
+
+        // 设置渲染状态
+        RenderSystem.checkGLError("before_set_line_width");
+        RenderSystem.lineWidth(colliderLineWidth);
+        RenderSystem.checkGLError("after_set_line_width");
+
+        RenderSystem.activeTexture(RenderSystem.GL_TEXTURE0);
+        RenderSystem.bindTexture(defaultTextureId);
+        RenderSystem.checkGLError("after_bind_texture");
 
-        // 绑定默认纹理（shader 依赖 uTexture）并设置颜色/opacity
-        GL13.glActiveTexture(GL13.GL_TEXTURE0);
-        GL11.glBindTexture(GL11.GL_TEXTURE_2D, defaultTextureId);
         setUniformIntInternal(defaultProgram, "uTexture", 0);
         setUniformVec4Internal(defaultProgram, "uColor", colliderColor);
         setUniformFloatInternal(defaultProgram, "uOpacity", 1.0f);
         setUniformIntInternal(defaultProgram, "uBlendMode", 0);
         setUniformIntInternal(defaultProgram, "uDebugMode", 0);
+        RenderSystem.checkGLError("after_set_uniforms");
 
         // 使用单位矩阵作为 model（碰撞体顶点按世界坐标提供）
         setUniformMatrix3(defaultProgram, "uModelMatrix", new Matrix3f().identity());
+        RenderSystem.checkGLError("after_set_model_matrix");
 
-        for (PhysicsSystem.PhysicsCollider collider : physics.getColliders()) {
-            if (!collider.isEnabled()) continue;
+        List<PhysicsSystem.PhysicsCollider> colliders = physics.getColliders();
+        if (colliders == null || colliders.isEmpty()) {
+            logger.debug("No colliders to render");
+            return;
+        }
+
+        int enabledColliders = 0;
+        for (PhysicsSystem.PhysicsCollider collider : colliders) {
+            if (collider == null || !collider.isEnabled()) continue;
+
+            RenderSystem.checkGLError("before_render_collider_" + enabledColliders);
 
             if (collider instanceof PhysicsSystem.CircleCollider) {
                 PhysicsSystem.CircleCollider c = (PhysicsSystem.CircleCollider) collider;
-                drawCircleColliderWire(c.getCenter(), c.getRadius());
+                if (c.getCenter() != null && c.getRadius() > 0) {
+                    drawCircleColliderWire(c.getCenter(), c.getRadius());
+                    enabledColliders++;
+                } else {
+                    logger.warn("Invalid CircleCollider: center={}, radius={}", c.getCenter(), c.getRadius());
+                }
             } else if (collider instanceof PhysicsSystem.RectangleCollider) {
                 PhysicsSystem.RectangleCollider r = (PhysicsSystem.RectangleCollider) collider;
-                drawRectangleColliderWire(r.getCenter(), r.getWidth(), r.getHeight());
+                if (r.getCenter() != null && r.getWidth() > 0 && r.getHeight() > 0) {
+                    drawRectangleColliderWire(r.getCenter(), r.getWidth(), r.getHeight());
+                    enabledColliders++;
+                } else {
+                    logger.warn("Invalid RectangleCollider: center={}, width={}, height={}",
+                            r.getCenter(), r.getWidth(), r.getHeight());
+                }
             } else {
-                // 未知类型：尝试调用 collidesWith 以获取位置（跳过）
+                logger.warn("Unknown collider type: {}", collider.getClass().getSimpleName());
             }
+
+            RenderSystem.checkGLError("after_render_collider_" + enabledColliders);
         }
 
+        logger.debug("Rendered {} enabled colliders", enabledColliders);
+
         // 恢复默认线宽
-        GL11.glLineWidth(1.0f);
+        RenderSystem.lineWidth(1.0f);
+        RenderSystem.checkGLError("after_reset_line_width");
     }
 
 
@@ -643,16 +625,18 @@ public final class ModelRender {
      */
     private static void drawCircleColliderWire(Vector2f center, float radius) {
         int segments = Math.max(8, CIRCLE_SEGMENTS);
-        BufferBuilder bb = new BufferBuilder(segments * 4);
-        bb.begin(GL11.GL_LINE_LOOP, segments);
+
+        Tesselator tesselator = Tesselator.getInstance();
+        BufferBuilder builder = tesselator.getBuilder();
+
+        builder.begin(RenderSystem.DRAW_LINE_LOOP, segments);
         for (int i = 0; i < segments; i++) {
             double ang = 2.0 * Math.PI * i / segments;
             float x = center.x + radius * (float) Math.cos(ang);
             float y = center.y + radius * (float) Math.sin(ang);
-            // 给常量 texcoord
-            bb.vertex(x, y, 0.5f, 0.5f);
+            builder.vertex(x, y, 0.5f, 0.5f);
         }
-        bb.end();
+        tesselator.end();
     }
 
     /**
@@ -661,117 +645,52 @@ public final class ModelRender {
     private static void drawRectangleColliderWire(Vector2f center, float width, float height) {
         float halfW = width / 2.0f;
         float halfH = height / 2.0f;
-        BufferBuilder bb = new BufferBuilder(4 * 4);
-        bb.begin(GL11.GL_LINE_LOOP, 4);
-        bb.vertex(center.x - halfW, center.y - halfH, 0.5f, 0.5f);
-        bb.vertex(center.x + halfW, center.y - halfH, 0.5f, 0.5f);
-        bb.vertex(center.x + halfW, center.y + halfH, 0.5f, 0.5f);
-        bb.vertex(center.x - halfW, center.y + halfH, 0.5f, 0.5f);
-        bb.end();
-    }
 
-    /**
-     * 从 float[] (x,y,u,v interleaved) 绘制 GL_LINE_LOOP
-     */
-    private static void drawLineLoopFromFloatArray(float[] interleavedXYUV, int vertexCount) {
-        // 创建 VAO/VBO
-        int vao = GL30.glGenVertexArrays();
-        int vbo = GL15.glGenBuffers();
+        Tesselator tesselator = Tesselator.getInstance();
+        BufferBuilder builder = tesselator.getBuilder();
 
-        GL30.glBindVertexArray(vao);
-        GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vbo);
-
-        // 上传数据
-        FloatBuffer fb = MemoryUtil.memAllocFloat(interleavedXYUV.length);
-        fb.put(interleavedXYUV).flip();
-        GL15.glBufferData(GL15.GL_ARRAY_BUFFER, fb, GL15.GL_DYNAMIC_DRAW);
-        MemoryUtil.memFree(fb);
-
-        // attrib 0 -> aPosition (vec2)
-        GL20.glEnableVertexAttribArray(0);
-        GL20.glVertexAttribPointer(0, 2, GL11.GL_FLOAT, false, 4 * Float.BYTES, 0);
-
-        // attrib 1 -> aTexCoord (vec2) （提供常量 texcoord）
-        GL20.glEnableVertexAttribArray(1);
-        GL20.glVertexAttribPointer(1, 2, GL11.GL_FLOAT, false, 4 * Float.BYTES, 2 * Float.BYTES);
-
-        // 绘制线环
-        GL11.glDrawArrays(GL11.GL_LINE_LOOP, 0, vertexCount);
-
-        // 清理
-        GL20.glDisableVertexAttribArray(0);
-        GL20.glDisableVertexAttribArray(1);
-        GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
-        GL30.glBindVertexArray(0);
-
-        GL15.glDeleteBuffers(vbo);
-        GL30.glDeleteVertexArrays(vao);
-
-        checkGLError("drawLineLoopFromFloatArray");
+        builder.begin(RenderSystem.DRAW_LINE_LOOP, 4);
+        builder.vertex(center.x - halfW, center.y - halfH, 0.5f, 0.5f);
+        builder.vertex(center.x + halfW, center.y - halfH, 0.5f, 0.5f);
+        builder.vertex(center.x + halfW, center.y + halfH, 0.5f, 0.5f);
+        builder.vertex(center.x - halfW, center.y + halfH, 0.5f, 0.5f);
+        tesselator.end();
     }
 
     // ================== uniform 设置辅助（内部使用，确保 program 已绑定） ==================
-    private static void setUniformIntInternal(ShaderProgram sp, String name, int value) {
+    private static void setUniformIntInternal(ShaderSources.ShaderProgram sp, String name, int value) {
         int loc = sp.getUniformLocation(name);
-        if (loc != -1) GL20.glUniform1i(loc, value);
+        if (loc != -1) RenderSystem.uniform1i(loc, value);
     }
 
-    private static void setUniformVec3Internal(ShaderProgram sp, String name, org.joml.Vector3f vec) {
+    private static void setUniformVec3Internal(ShaderSources.ShaderProgram sp, String name, org.joml.Vector3f vec) {
         int loc = sp.getUniformLocation(name);
-        if (loc != -1) {
-            GL20.glUniform3f(loc, vec.x, vec.y, vec.z);
-        }
+        if (loc != -1) RenderSystem.uniform3f(loc, vec);
     }
 
-    private static void setUniformVec2Internal(ShaderProgram sp, String name, org.joml.Vector2f vec) {
+    private static void setUniformVec2Internal(ShaderSources.ShaderProgram sp, String name, org.joml.Vector2f vec) {
         int loc = sp.getUniformLocation(name);
-        if (loc != -1) {
-            GL20.glUniform2f(loc, vec.x, vec.y);
-        }
+        if (loc != -1) RenderSystem.uniform2f(loc, vec);
     }
 
-    private static void setUniformFloatInternal(ShaderProgram sp, String name, float value) {
+    private static void setUniformFloatInternal(ShaderSources.ShaderProgram sp, String name, float value) {
         int loc = sp.getUniformLocation(name);
-        if (loc != -1) GL20.glUniform1f(loc, value);
+        if (loc != -1) RenderSystem.uniform1f(loc, value);
     }
 
-    private static void setUniformVec4Internal(ShaderProgram sp, String name, Vector4f vec) {
+    private static void setUniformVec4Internal(ShaderSources.ShaderProgram sp, String name, org.joml.Vector4f vec) {
         int loc = sp.getUniformLocation(name);
-        if (loc != -1) GL20.glUniform4f(loc, vec.x, vec.y, vec.z, vec.w);
+        if (loc != -1) RenderSystem.uniform4f(loc, vec);
     }
 
-    private static void setUniformMatrix3(ShaderProgram sp, String name, Matrix3f m) {
+    private static void setUniformMatrix3(ShaderSources.ShaderProgram sp, String name, org.joml.Matrix3f m) {
         int loc = sp.getUniformLocation(name);
         if (loc == -1) return;
-        FloatBuffer fb = MemoryUtil.memAllocFloat(9);
-        try {
-            m.get(fb);
-            GL20.glUniformMatrix3fv(loc, false, fb);
-        } finally {
-            MemoryUtil.memFree(fb);
-        }
-    }
-
-
-    // 外部可用的统一设置（会自动切换到默认程序）
-    private static void setUniformInt(String name, int value) {
-        defaultProgram.use();
-        setUniformIntInternal(defaultProgram, name, value);
-        defaultProgram.stop();
-    }
-    private static void setUniformFloat(String name, float value) {
-        defaultProgram.use();
-        setUniformFloatInternal(defaultProgram, name, value);
-        defaultProgram.stop();
-    }
-    private static void setUniformVec4(String name, Vector4f v) {
-        defaultProgram.use();
-        setUniformVec4Internal(defaultProgram, name, v);
-        defaultProgram.stop();
+        RenderSystem.uniformMatrix3(loc, m);
     }
 
     // ================== 部件属性 ==================
-    private static void setPartUniforms(ShaderProgram sp, ModelPart part) {
+    private static void setPartUniforms(ShaderSources.ShaderProgram sp, ModelPart part) {
         setUniformFloatInternal(sp, "uOpacity", part.getOpacity());
         int blend = 0;
         ModelPart.BlendMode bm = part.getBlendMode();
@@ -804,28 +723,7 @@ public final class ModelRender {
     public static void setViewport(int width, int height) {
         viewportWidth = Math.max(1, width);
         viewportHeight = Math.max(1, height);
-        GL11.glViewport(0, 0, viewportWidth, viewportHeight);
-    }
-
-    public static void setClearColor(float r, float g, float b, float a) {
-        GL11.glClearColor(r,g,b,a);
-    }
-
-    private static void checkGLError(String op) {
-        int e = GL11.glGetError();
-        if (e != GL11.GL_NO_ERROR) {
-            //logger.error("OpenGL error during {}: {}", op, getGLErrorString(e));
-        }
-    }
-
-    private static String getGLErrorString(int err) {
-        switch (err) {
-            case GL11.GL_INVALID_ENUM: return "GL_INVALID_ENUM";
-            case GL11.GL_INVALID_VALUE: return "GL_INVALID_VALUE";
-            case GL11.GL_INVALID_OPERATION: return "GL_INVALID_OPERATION";
-            case GL11.GL_OUT_OF_MEMORY: return "GL_OUT_OF_MEMORY";
-            default: return "Unknown(0x" + Integer.toHexString(err) + ")";
-        }
+        RenderSystem.viewport(0, 0, viewportWidth, viewportHeight);
     }
 
     // ================== 辅助：外部获取状态 ==================