// 立即模式绘制一个彩色三角形
glBegin(GL_TRIANGLES);           // 告诉 GPU："接下来我要画三角形"
    glColor3f(1.0f, 0.0f, 0.0f); // 设置当前颜色为红色（RGB 各 0~1）
    glVertex3f(-0.5f, -0.5f, 0.0f); // 发送第一个顶点坐标（左下角）
    glColor3f(0.0f, 1.0f, 0.0f); // 切换颜色为绿色
    glVertex3f( 0.5f, -0.5f, 0.0f); // 发送第二个顶点（右下角）
    glColor3f(0.0f, 0.0f, 1.0f); // 切换颜色为蓝色
    glVertex3f( 0.0f,  0.5f, 0.0f); // 发送第三个顶点（顶部）
glEnd();                          // 告诉 GPU："三角形数据发完了，可以画了"

// MC 1.12 Tessellator 的典型用法
Tessellator tessellator = Tessellator.getInstance(); // 获取全局唯一的绘制器实例
BufferBuilder buffer = tessellator.getBuffer();       // 取出内部的数据构建器

// begin() 告诉构建器：我要画四边形(GL_QUADS)，每个顶点带位置+纹理坐标
buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX);

// 添加四个顶点构成一个矩形面
// pos(x,y,z) 设置 3D 坐标，tex(u,v) 设置纹理采样坐标（0~1 范围）
buffer.pos(x,     y,     z).tex(u0, v0).endVertex(); // 左下角
buffer.pos(x,     y + h, z).tex(u0, v1).endVertex(); // 左上角
buffer.pos(x + w, y + h, z).tex(u1, v1).endVertex(); // 右上角
buffer.pos(x + w, y,     z).tex(u1, v0).endVertex(); // 右下角

tessellator.draw(); // 把攒好的数据一次性上传 GPU 并绘制——每帧都要重新来一遍

// GameRenderer.render() 简化版
public void render(float partialTick) {
    // 检查窗口尺寸变化
    if (window.isResized()) {
        mainTarget.resize(window.getWidth(), window.getHeight());
    }

    // 清除主帧缓冲
    mainTarget.clear();
    mainTarget.bindWrite(true);

    // 更新全局 uniform
    RenderSystem.setShaderGameTime(gameTime);
    RenderSystem.setShaderScreenSize(width, height);

    // 渲染光照贴图（供方块和实体采样）
    lightTexture.turnOnLightLayer();
    lightTexture.updateLightmap(partialTick);

    // 渲染 3D 世界
    renderLevel(partialTick);

    // 实体描边（光标指向时的高亮轮廓）
    doEntityOutline();

    // 后处理链（着色器效果）
    if (postEffect != null) {
        postEffect.process(partialTick);
    }

    // 清除深度缓冲（GUI 需要独立深度空间）
    mainTarget.bindWrite(true);
    RenderSystem.clear(GL_DEPTH_BUFFER_BIT);

    // 渲染 GUI（血条 物品栏 聊天 调试信息）
    guiRenderer.render(partialTick);

    // 帧结束
    mainTarget.unbindWrite();
    window.swapBuffers();
}

// LevelRenderer.renderLevel() 渲染顺序
public void renderLevel(PoseStack poseStack, float partialTick, Camera camera) {
    // 天空盒（最远背景）
    renderSky(poseStack);

    // 地形 solid（不透明方块 深度测试开启 不需要排序）
    renderChunkLayer(RenderType.solid(), poseStack, camera);

    // 地形 cutout（镂空方块 alpha 测试丢弃透明像素）
    renderChunkLayer(RenderType.cutout(), poseStack, camera);

    // 实体（玩家 怪物 掉落物）
    renderEntities(poseStack, camera, partialTick);

    // 方块实体（箱子 告示牌 信标）
    renderBlockEntities(poseStack, camera, partialTick);

    // 粒子
    particleEngine.render(poseStack, camera, partialTick);

    // 天气效果（雨 雪）
    renderWeather(poseStack, camera);

    // 地形 translucent（半透明方块 从远到近排序 最后绘制）
    renderChunkLayer(RenderType.translucent(), poseStack, camera);
}

// RenderSystem 的典型使用方式
RenderSystem.enableBlend();
RenderSystem.setShader(GameRenderer::getPositionTexShader);
RenderSystem.setShaderTexture(0, myTexture);

// 1. 检查：当前是否在渲染线程
if (RenderSystem.isOnRenderThread()) {
    RenderSystem.enableBlend(); // 安全，直接执行
}

// 2. 断言：不在渲染线程就崩溃（调试用）
RenderSystem.assertOnRenderThread();

// 3. 延迟：不在渲染线程时，把操作排队到渲染线程执行
RenderSystem.recordRenderCall(() -> {
    RenderSystem.enableBlend();
    RenderSystem.setShaderColor(1.0f, 0.0f, 0.0f, 1.0f);
});

// 设置当前着色器（Supplier 延迟获取，避免初始化顺序问题）
RenderSystem.setShader(GameRenderer::getPositionTexShader);
RenderSystem.setShader(GameRenderer::getParticleShader);
RenderSystem.setShader(() -> myCustomShader); // 自定义着色器

// 设置纹理到采样器单元
RenderSystem.setShaderTexture(0, new ResourceLocation("minecraft", "textures/block/dirt.png"));
RenderSystem.setShaderTexture(0, diffuseTexture);  // 单元 0：主纹理
RenderSystem.setShaderTexture(1, overlayTexture);  // 单元 1：覆盖层
RenderSystem.setShaderTexture(2, lightmapTexture); // 单元 2：光照贴图

// 颜色调制器（乘以顶点颜色，影响最终输出）
RenderSystem.setShaderColor(1.0f, 1.0f, 1.0f, 1.0f); // 白色，无调制
RenderSystem.setShaderColor(1.0f, 0.0f, 0.0f, 1.0f); // 红色叠加
RenderSystem.setShaderColor(1.0f, 1.0f, 1.0f, 0.5f); // 半透明

// 雾效参数
RenderSystem.setShaderFogStart(10.0f);  // 雾起始距离
RenderSystem.setShaderFogEnd(100.0f);   // 雾结束距离
RenderSystem.setShaderFogColor(0.5f, 0.5f, 0.5f, 1.0f); // 灰雾
RenderSystem.setShaderFogShape(FogShape.SPHERE); // 球形雾（MC 默认）

// 开关
RenderSystem.enableBlend();   // 启用颜色混合（画半透明物体前必须开）
RenderSystem.disableBlend();  // 禁用（画不透明物体时关掉，提升性能）

// 标准透明混合公式：最终颜色 = 新颜色 × alpha + 旧颜色 × (1 - alpha)
// 这是最直觉的透明效果：alpha=0.5 时新旧各占一半
RenderSystem.defaultBlendFunc();
// 上面这一行等价于下面这个更明确的写法：
RenderSystem.blendFuncSeparate(
    GlStateManager.SourceFactor.SRC_ALPHA,         // srcRGB: 新颜色的 RGB 乘以自身 alpha
    GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA, // dstRGB: 旧颜色的 RGB 乘以 (1-alpha)
    GlStateManager.SourceFactor.ONE,               // srcAlpha: 新 alpha 直接取
    GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA  // dstAlpha: 旧 alpha 也做混合
);

// 加法混合公式：最终颜色 = 新颜色 × alpha + 旧颜色 × 1
// 旧颜色不衰减，新颜色叠上去只会让画面更亮——适合发光效果
RenderSystem.blendFunc(
    GlStateManager.SourceFactor.SRC_ALPHA, // 新颜色按 alpha 缩放
    GlStateManager.DestFactor.ONE          // 旧颜色保持不变（1=不衰减）
);

// 预乘 Alpha 公式：最终颜色 = 新颜色 × 1 + 旧颜色 × (1-alpha)
// 前提是纹理在制作时已经把 RGB 乘过 alpha 了，避免边缘出现黑线
RenderSystem.blendFunc(
    GlStateManager.SourceFactor.ONE,               // 新颜色直接取（已经预乘过了）
    GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA  // 旧颜色按 (1-alpha) 衰减
);

// 乘法混合公式：最终颜色 = 旧颜色 × 新颜色
// 效果：新颜色越暗的地方，旧颜色也变暗——适合阴影贴花
RenderSystem.blendFunc(
    GlStateManager.SourceFactor.DST_COLOR, // 新颜色的贡献 = 旧颜色值（相当于做乘法）
    GlStateManager.DestFactor.ZERO         // 旧颜色贡献 = 0（完全被替换为乘法结果）
);

// 开关
RenderSystem.enableDepthTest();   // 开启深度测试
RenderSystem.disableDepthTest();  // 关闭（GUI 不需要）

// 深度比较函数
RenderSystem.depthFunc(GL11.GL_LEQUAL);  // 小于等于通过（MC 默认）
RenderSystem.depthFunc(GL11.GL_LESS);    // 严格小于
RenderSystem.depthFunc(GL11.GL_ALWAYS);  // 总是通过（忽略深度）

// 深度写入控制
RenderSystem.depthMask(true);   // 允许写入深度缓冲
RenderSystem.depthMask(false);  // 禁止写入（半透明物体必须关）

// 阶段一：不透明物体（写入深度 + 测试深度）
RenderSystem.enableDepthTest();
RenderSystem.depthMask(true);
renderOpaqueObjects();

// 阶段二：半透明物体（测试深度但不写入）
RenderSystem.enableDepthTest();  // 仍然测试——被遮挡的部分不画
RenderSystem.depthMask(false);   // 不写入——否则后面的半透明会被挡
renderTranslucentObjects();

// 阶段三：GUI（不需要深度）
RenderSystem.disableDepthTest();
renderGUI();

// 面剔除
RenderSystem.enableCull();   // 剔除背面（普通方块 实体）
RenderSystem.disableCull();  // 双面渲染（树叶 草 粒子）

// 多边形偏移（解决 Z-fighting：两个面距离太近闪烁）
RenderSystem.enablePolygonOffset();
RenderSystem.polygonOffset(-1.0f, -1.0f); // 向相机方向偏移（贴花在方块表面）
// 渲染完后关闭
RenderSystem.disablePolygonOffset();

// 颜色写入遮罩（控制哪些通道写入帧缓冲）
RenderSystem.colorMask(true, true, true, true);   // RGBA 全写
RenderSystem.colorMask(true, true, true, false);  // 只写 RGB 不写 Alpha
RenderSystem.colorMask(false, false, false, false); // 什么都不写（只写深度/模板）

// 视口
RenderSystem.viewport(0, 0, width, height);

// 裁剪测试（只渲染指定矩形内的像素）
RenderSystem.enableScissor(x, y, width, height);
RenderSystem.disableScissor();

// 清除
RenderSystem.clearColor(0.0f, 0.0f, 0.0f, 1.0f); // 设置清除色
RenderSystem.clear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT, Minecraft.ON_OSX);

public void renderCustomEffect(PoseStack poseStack, ResourceLocation texture, float alpha) {
    // === 设置渲染状态 ===
    RenderSystem.enableBlend();                            // 开启混合
    RenderSystem.blendFunc(                                // 加法混合（发光）
        GlStateManager.SourceFactor.SRC_ALPHA,
        GlStateManager.DestFactor.ONE
    );
    RenderSystem.enableDepthTest();                        // 深度测试开
    RenderSystem.depthMask(false);                         // 不写入深度
    RenderSystem.disableCull();                            // 双面渲染

    // === 设置着色器和纹理 ===
    RenderSystem.setShader(GameRenderer::getPositionTexColorShader);
    RenderSystem.setShaderTexture(0, texture);             // 绑定纹理
    RenderSystem.setShaderColor(1.0f, 1.0f, 1.0f, alpha); // 透明度

    // === 构建顶点数据 ===
    Matrix4f matrix = poseStack.last().pose();             // 获取变换矩阵
    Tesselator tesselator = Tesselator.getInstance();
    BufferBuilder buffer = tesselator.getBuilder();

    buffer.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX_COLOR);
    buffer.vertex(matrix, -1, -1, 0).uv(0, 1).color(255, 255, 255, 255).endVertex();
    buffer.vertex(matrix,  1, -1, 0).uv(1, 1).color(255, 255, 255, 255).endVertex();
    buffer.vertex(matrix,  1,  1, 0).uv(1, 0).color(255, 255, 255, 255).endVertex();
    buffer.vertex(matrix, -1,  1, 0).uv(0, 0).color(255, 255, 255, 255).endVertex();

    // === 上传并绘制 ===
    BufferUploader.drawWithShader(tesselator.end());

    // === 恢复状态 ===
    RenderSystem.depthMask(true);                          // 恢复深度写入
    RenderSystem.enableCull();                             // 恢复面剔除
    RenderSystem.defaultBlendFunc();                       // 恢复默认混合
    RenderSystem.disableBlend();                           // 关闭混合
    RenderSystem.setShaderColor(1.0f, 1.0f, 1.0f, 1.0f);  // 恢复颜色
}

// 获取全局唯一的 Tesselator 实例
Tesselator tesselator = Tesselator.getInstance();
// 从中取出 BufferBuilder
BufferBuilder buffer = tesselator.getBuilder();

// 第一步：获取 builder
Tesselator tesselator = Tesselator.getInstance();
BufferBuilder buffer = tesselator.getBuilder();

// 第二步：begin —— 指定图元模式和顶点格式
buffer.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_COLOR_TEX_LIGHTMAP);

// 第三步：逐顶点写入属性（重复 N 次）
// 这里以一个四边形的四个顶点为例
buffer.vertex(matrix, x0, y0, z0)
      .color(255, 255, 255, 255)
      .uv(0.0f, 0.0f)
      .uv2(packedLight)
      .endVertex();

buffer.vertex(matrix, x1, y1, z1)
      .color(255, 255, 255, 255)
      .uv(1.0f, 0.0f)
      .uv2(packedLight)
      .endVertex();

buffer.vertex(matrix, x2, y2, z2)
      .color(255, 255, 255, 255)
      .uv(1.0f, 1.0f)
      .uv2(packedLight)
      .endVertex();

buffer.vertex(matrix, x3, y3, z3)
      .color(255, 255, 255, 255)
      .uv(0.0f, 1.0f)
      .uv2(packedLight)
      .endVertex();

// 第四步：结束构建，得到打包好的数据
BufferBuilder.RenderedBuffer renderedBuffer = buffer.end();

// 第五步：上传到 GPU 并绘制
BufferUploader.drawWithShader(renderedBuffer);

buffer.vertex(matrix, x, y, z)       // 位置——将 (x,y,z) 乘以变换矩阵后写入缓冲区
      .color(255, 255, 255, 255)     // RGBA 颜色，每个分量 0-255（255=最大强度）
      .uv(u, v)                      // UV0 主纹理坐标——GPU 从纹理的 (u,v) 位置取颜色
      .overlayCoords(u, v)           // UV1 覆盖层坐标（实体受伤红闪 TNT 白闪用这个）
      .uv2(packedLight)              // UV2 光照贴图坐标——决定该顶点接收多少环境光
      .normal(nx, ny, nz)            // 法线方向——垂直于表面指向外侧的单位向量
      .endVertex();                  // 标记当前顶点结束，内部写入指针前进到下一个顶点的位置

// ✓ 正确：POSITION_TEX_COLOR 的顺序是 pos → uv → color
buffer.vertex(x, y, z).uv(u, v).color(r, g, b, a).endVertex();

// ✗ 错误：color 和 uv 顺序反了
buffer.vertex(x, y, z).color(r, g, b, a).uv(u, v).endVertex();
// 不会报错！但 GPU 会把 color 的字节当 UV 解释，画面完全乱掉

public void renderTexturedQuad(PoseStack poseStack, ResourceLocation texture,
                               float x, float y, float width, float height) {
    // 绑定着色器和纹理
    RenderSystem.setShader(GameRenderer::getPositionTexShader);
    RenderSystem.setShaderTexture(0, texture);

    Matrix4f matrix = poseStack.last().pose();
    Tesselator tesselator = Tesselator.getInstance();
    BufferBuilder buffer = tesselator.getBuilder();

    // 开始构建四边形 使用 POSITION_TEX 格式
    buffer.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX);

    // 逆时针绕序：左下 → 右下 → 右上 → 左上
    buffer.vertex(matrix, x, y + height, 0).uv(0, 1).endVertex();
    buffer.vertex(matrix, x + width, y + height, 0).uv(1, 1).endVertex();
    buffer.vertex(matrix, x + width, y, 0).uv(1, 0).endVertex();
    buffer.vertex(matrix, x, y, 0).uv(0, 0).endVertex();

    // 一次上传并绘制
    BufferUploader.drawWithShader(tesselator.end());
}

public void renderDebugTriangle(PoseStack poseStack,
                                float x1, float y1,
                                float x2, float y2,
                                float x3, float y3) {
    RenderSystem.setShader(GameRenderer::getPositionColorShader);
    // 关闭纹理 启用混合以支持半透明
    RenderSystem.enableBlend();

    Matrix4f matrix = poseStack.last().pose();
    Tesselator tesselator = Tesselator.getInstance();
    BufferBuilder buffer = tesselator.getBuilder();

    buffer.begin(VertexFormat.Mode.TRIANGLES, DefaultVertexFormat.POSITION_COLOR);

    // 三个顶点分别用红 绿 蓝 GPU 会自动插值产生渐变
    buffer.vertex(matrix, x1, y1, 0).color(255, 0, 0, 128).endVertex();
    buffer.vertex(matrix, x2, y2, 0).color(0, 255, 0, 128).endVertex();
    buffer.vertex(matrix, x3, y3, 0).color(0, 0, 255, 128).endVertex();

    BufferUploader.drawWithShader(tesselator.end());
    RenderSystem.disableBlend();
}

public void renderBillboard(PoseStack poseStack, Camera camera,
                            Vec3 center, float size,
                            float u0, float v0, float u1, float v1,
                            int light) {
    RenderSystem.setShader(GameRenderer::getParticleShader);

    // 从相机获取朝向向量
    Vec3 right = new Vec3(camera.getLeftVector()).scale(-1);
    Vec3 up = new Vec3(camera.getUpVector());

    // 四个角的偏移
    float hs = size * 0.5f;
    Matrix4f matrix = poseStack.last().pose();
    Tesselator tesselator = Tesselator.getInstance();
    BufferBuilder buffer = tesselator.getBuilder();

    buffer.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.PARTICLE);

    // 左下
    float x0 = (float)(center.x - right.x * hs - up.x * hs);
    float y0 = (float)(center.y - right.y * hs - up.y * hs);
    float z0 = (float)(center.z - right.z * hs - up.z * hs);
    buffer.vertex(matrix, x0, y0, z0).uv(u0, v1).color(255, 255, 255, 255)
          .uv2(light).endVertex();

    // 右下
    float x1 = (float)(center.x + right.x * hs - up.x * hs);
    float y1f = (float)(center.y + right.y * hs - up.y * hs);
    float z1 = (float)(center.z + right.z * hs - up.z * hs);
    buffer.vertex(matrix, x1, y1f, z1).uv(u1, v1).color(255, 255, 255, 255)
          .uv2(light).endVertex();

    // 右上
    float x2 = (float)(center.x + right.x * hs + up.x * hs);
    float y2f = (float)(center.y + right.y * hs + up.y * hs);
    float z2 = (float)(center.z + right.z * hs + up.z * hs);
    buffer.vertex(matrix, x2, y2f, z2).uv(u1, v0).color(255, 255, 255, 255)
          .uv2(light).endVertex();

    // 左上
    float x3 = (float)(center.x - right.x * hs + up.x * hs);
    float y3f = (float)(center.y - right.y * hs + up.y * hs);
    float z3 = (float)(center.z - right.z * hs + up.z * hs);
    buffer.vertex(matrix, x3, y3f, z3).uv(u0, v0).color(255, 255, 255, 255)
          .uv2(light).endVertex();

    BufferUploader.drawWithShader(tesselator.end());
}

// ✗ 低效：每个物体单独 draw call
for (var obj : objects) {
    buffer.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX_COLOR);
    addVertices(buffer, obj);
    BufferUploader.drawWithShader(tesselator.end()); // 每次都上传+绘制
}
// 100 个物体 = 100 次 draw call = 100 次状态同步

// ✓ 高效：合并成一次 draw call
buffer.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX_COLOR);
for (var obj : objects) {
    addVertices(buffer, obj); // 只往 buffer 里追加顶点
}
BufferUploader.drawWithShader(tesselator.end()); // 一次上传 一次绘制
// 100 个物体 = 1 次 draw call

// 按纹理对物体分组
Map<ResourceLocation, List<RenderObject>> grouped = objects.stream()
    .collect(Collectors.groupingBy(RenderObject::getTexture));

// 每组一次 draw call
for (var entry : grouped.entrySet()) {
    RenderSystem.setShaderTexture(0, entry.getKey());

    buffer.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX_COLOR);
    for (var obj : entry.getValue()) {
        addVertices(buffer, obj);
    }
    BufferUploader.drawWithShader(tesselator.end());
}
// N 种纹理 = N 次 draw call（而不是 M 个物体 = M 次）

// ✗ 没有 RenderType：手动设置每个状态，还要手动恢复
RenderSystem.enableBlend();
RenderSystem.blendFunc(SRC_ALPHA, ONE_MINUS_SRC_ALPHA);
RenderSystem.enableDepthTest();
RenderSystem.depthMask(false);
RenderSystem.disableCull();
RenderSystem.setShader(GameRenderer::getEntityTranslucentShader);
RenderSystem.setShaderTexture(0, texture);
// 渲染...
// 还要恢复所有 7 个状态！漏一个就出 bug

// ✓ 有 RenderType：三行搞定
RenderType type = RenderType.entityTranslucent(texture);
type.setupRenderState();   // 自动设置所有状态
// 渲染...
type.clearRenderState();   // 自动恢复所有状态

RenderType renderType = RenderType.entityTranslucent(myTexture);
renderType.setupRenderState(); // 设置所有状态

Tesselator tesselator = Tesselator.getInstance();
BufferBuilder buffer = tesselator.getBuilder();
buffer.begin(renderType.mode(), renderType.format());
// 添加顶点...
BufferUploader.drawWithShader(tesselator.end());

renderType.clearRenderState(); // 恢复所有状态

public void render(PoseStack poseStack, MultiBufferSource bufferSource,
                   int packedLight, int packedOverlay) {
    // 获取指定 RenderType 的 VertexConsumer
    VertexConsumer consumer = bufferSource.getBuffer(
        RenderType.entityTranslucent(myTexture)
    );
    // 直接往里添加顶点
    Matrix4f matrix = poseStack.last().pose();
    consumer.vertex(matrix, x, y, z)
            .color(255, 255, 255, 255)
            .uv(u, v)
            .overlayCoords(packedOverlay)
            .uv2(packedLight)
            .normal(poseStack.last().normal(), 0, 1, 0)
            .endVertex();
    // MultiBufferSource 自动管理绘制时机
}

// RenderType 内部的状态组合
RenderType.CompositeState state = RenderType.CompositeState.builder()
    .setShaderState(RENDERTYPE_ENTITY_TRANSLUCENT_SHADER)  // 着色器
    .setTextureState(new TextureStateShard(texture, false, false)) // 纹理
    .setTransparencyState(TRANSLUCENT_TRANSPARENCY)        // 混合模式
    .setLightmapState(LIGHTMAP)                           // 光照贴图
    .setOverlayState(OVERLAY)                             // 覆盖层
    .setCullState(NO_CULL)                                // 不剔除
    .setWriteMaskState(COLOR_DEPTH_WRITE)                  // 写入遮罩
    .createCompositeState(true);  // true = 半透明需要排序

// 透明度
RenderStateShard.NO_TRANSPARENCY        // 不混合
RenderStateShard.TRANSLUCENT_TRANSPARENCY // 标准透明
RenderStateShard.ADDITIVE_TRANSPARENCY   // 加法（发光）
RenderStateShard.GLINT_TRANSPARENCY      // 附魔光泽

// 深度
RenderStateShard.NO_DEPTH_TEST    // 无深度测试
RenderStateShard.LEQUAL_DEPTH_TEST // ≤ 通过（默认）

// 面剔除
RenderStateShard.CULL     // 剔除背面
RenderStateShard.NO_CULL  // 双面

// 写入
RenderStateShard.COLOR_WRITE       // 只写颜色
RenderStateShard.DEPTH_WRITE       // 只写深度
RenderStateShard.COLOR_DEPTH_WRITE // 都写

public static final RenderType MY_GLOW = RenderType.create(
    "my_mod:glow",                              // 唯一名称（调试用）
    DefaultVertexFormat.POSITION_TEX_COLOR,      // 顶点格式
    VertexFormat.Mode.QUADS,                     // 图元模式
    256,                                        // 缓冲区大小
    false,                                      // affectsCrumbling（参与方块破坏？）
    true,                                       // sortOnUpload（半透明排序？）
    RenderType.CompositeState.builder()
        .setShaderState(POSITION_TEX_COLOR_SHADER)
        .setTextureState(new TextureStateShard(
            new ResourceLocation("my_mod", "textures/glow.png"), false, false))
        .setTransparencyState(ADDITIVE_TRANSPARENCY)  // 加法混合
        .setCullState(NO_CULL)                        // 双面
        .setDepthTestState(LEQUAL_DEPTH_TEST)
        .setWriteMaskState(COLOR_WRITE)               // 不写深度
        .createCompositeState(false)
);

// Util.memoize 缓存——同一个纹理只创建一次 RenderType 实例
private static final Function<ResourceLocation, RenderType> CUSTOM_ENTITY =
    Util.memoize(texture -> RenderType.create(
        "my_mod:custom_entity",
        DefaultVertexFormat.NEW_ENTITY,
        VertexFormat.Mode.QUADS,
        256, true, true,
        RenderType.CompositeState.builder()
            .setShaderState(RENDERTYPE_ENTITY_TRANSLUCENT_SHADER)
            .setTextureState(new TextureStateShard(texture, false, false))
            .setTransparencyState(TRANSLUCENT_TRANSPARENCY)
            .setLightmapState(LIGHTMAP)
            .setOverlayState(OVERLAY)
            .setCullState(NO_CULL)
            .createCompositeState(true)
    ));

public static RenderType customEntity(ResourceLocation texture) {
    return CUSTOM_ENTITY.apply(texture);
}

// 参数：宽度 高度 是否带深度缓冲 macOS兼容标志
RenderTarget target = new RenderTarget(width, height, true, Minecraft.ON_OSX);

RenderTarget mainTarget = Minecraft.getInstance().getMainRenderTarget();

// 绑定为写入目标（参数控制是否同时设置 viewport）
target.bindWrite(true);
// 参数 false 时只绑定 FBO 不改 viewport，适合部分区域渲染
target.bindWrite(false);

// 解绑写入（恢复到默认帧缓冲）
target.unbindWrite();

// 绑定为读取源（把颜色纹理绑到纹理单元）
target.bindRead();
target.unbindRead();

// 设置清除颜色（RGBA 范围 0-1）
target.setClearColor(0.0f, 0.0f, 0.0f, 0.0f);
// 执行清除（颜色缓冲 + 深度缓冲一起清）
target.clear(Minecraft.ON_OSX);

// 窗口 resize 时调用，重新分配纹理
target.resize(newWidth, newHeight, Minecraft.ON_OSX);

// 获取颜色纹理的 GL ID（用于在着色器里采样）
int colorTex = target.getColorTextureId();
// 获取深度纹理的 GL ID
int depthTex = target.getDepthTextureId();

// 把内容 blit 到屏幕主缓冲
target.blitToScreen(screenWidth, screenHeight);
// 从另一个 RenderTarget 复制深度缓冲
target.copyDepthFrom(sourceTarget);

public void renderToTarget(RenderTarget target) {
    // 保存当前绑定的帧缓冲
    RenderTarget previous = Minecraft.getInstance().getMainRenderTarget();

    // 绑定离屏目标
    target.setClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    target.clear(Minecraft.ON_OSX);
    target.bindWrite(true);

    // 在这里执行渲染操作
    // 所有 draw call 都会写入 target 而非屏幕
    renderSomeContent();

    // 恢复到之前的帧缓冲
    target.unbindWrite();
    previous.bindWrite(true);
}

public void renderFullscreenQuad(RenderTarget source) {
    // 绑定源纹理
    source.bindRead();

    // 设置着色器
    RenderSystem.setShader(GameRenderer::getPositionTexShader);

    // 构建覆盖整个屏幕的四边形
    BufferBuilder builder = Tesselator.getInstance().begin(
        VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX);
    builder.addVertex(-1.0f, -1.0f, 0.0f).setUv(0.0f, 0.0f);
    builder.addVertex( 1.0f, -1.0f, 0.0f).setUv(1.0f, 0.0f);
    builder.addVertex( 1.0f,  1.0f, 0.0f).setUv(1.0f, 1.0f);
    builder.addVertex(-1.0f,  1.0f, 0.0f).setUv(0.0f, 1.0f);
    BufferUploader.drawWithShader(builder.buildOrThrow());

    source.unbindRead();
}

// blur.fsh — 单方向高斯模糊
#version 150

uniform sampler2D DiffuseSampler;  // 输入纹理
uniform vec2 BlurDir;              // 模糊方向 (1,0) 或 (0,1)
uniform vec2 InSize;               // 纹理尺寸

in vec2 texCoord;
out vec4 fragColor;

void main() {
    vec2 texelSize = 1.0 / InSize;
    // 5-tap 高斯权重
    float weights[5] = float[](0.227, 0.194, 0.122, 0.054, 0.016);

    vec3 result = texture(DiffuseSampler, texCoord).rgb * weights[0];

    for (int i = 1; i < 5; i++) {
        vec2 offset = BlurDir * texelSize * float(i);
        result += texture(DiffuseSampler, texCoord + offset).rgb * weights[i];
        result += texture(DiffuseSampler, texCoord - offset).rgb * weights[i];
    }

    fragColor = vec4(result, 1.0);
}

public class PingPongBuffer {
    private final RenderTarget bufferA;
    private final RenderTarget bufferB;
    private boolean writeToA = true;

    public PingPongBuffer(int width, int height) {
        this.bufferA = new RenderTarget(width, height, false, Minecraft.ON_OSX);
        this.bufferB = new RenderTarget(width, height, false, Minecraft.ON_OSX);
    }

    // 获取当前要写入的目标
    public RenderTarget getWriteTarget() {
        return writeToA ? bufferA : bufferB;
    }

    // 获取当前要读取的源（上一个 Pass 的输出）
    public RenderTarget getReadTarget() {
        return writeToA ? bufferB : bufferA;
    }

    // 一个 Pass 结束后翻转
    public void swap() {
        writeToA = !writeToA;
    }

    // 调整尺寸
    public void resize(int width, int height) {
        bufferA.resize(width, height, Minecraft.ON_OSX);
        bufferB.resize(width, height, Minecraft.ON_OSX);
    }

    // 获取最终结果（最后写入的那个）
    public RenderTarget getResult() {
        // swap 后 writeToA 已翻转，所以结果在"读取目标"里
        return getReadTarget();
    }
}

PingPongBuffer pingPong = new PingPongBuffer(width, height);

// 初始内容写入
pingPong.getWriteTarget().bindWrite(true);
renderInitialContent();
pingPong.swap();

// 多次后处理
for (PostEffect effect : effects) {
    RenderTarget src = pingPong.getReadTarget();
    RenderTarget dst = pingPong.getWriteTarget();

    dst.clear(Minecraft.ON_OSX);
    dst.bindWrite(true);
    effect.apply(src);  // 从 src 采样，写入 dst
    dst.unbindWrite();

    pingPong.swap();
}

// 最终结果
RenderTarget finalResult = pingPong.getResult();
finalResult.blitToScreen(screenWidth, screenHeight);

RenderSystem.bindTexture(target.getColorTextureId());
GlStateManager._texParameter(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
GlStateManager._texParameter(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);

#moj_import <fog.glsl>       // 从 shaders/include/ 目录引入
#moj_import "my_utils.glsl"  // 从当前文件同目录引入

#version 150

#moj_import <fog.glsl>

// 顶点属性输入
in vec3 Position;   // 粒子顶点世界坐标
in vec2 UV0;        // 纹理坐标
in vec4 Color;      // 顶点颜色（粒子染色）
in ivec2 UV2;       // 光照贴图坐标（整数，需除以 16 归一化）

// 采样器
uniform sampler2D Sampler2;  // 光照贴图（lightmap）

// 变换矩阵
uniform mat4 ModelViewMat;   // 模型视图矩阵
uniform mat4 ProjMat;        // 投影矩阵

// 雾效参数
uniform int FogShape;        // 雾的形状：0 球形 1 圆柱形

// 传递给片段着色器的插值变量
out float vertexDistance;    // 顶点到相机的距离，用于雾效计算
out vec2 texCoord0;          // 纹理坐标透传
out vec4 vertexColor;        // 最终顶点颜色（粒子色 * 光照）

void main() {
    // 标准 MVP 变换：把 3D 世界坐标变成屏幕上的 2D 坐标
    // Position 是世界坐标 → 乘 ModelViewMat 得到相机视角下的坐标 → 乘 ProjMat 压成屏幕坐标
    // vec4(Position, 1.0) 中的 1.0 是齐次坐标的 w 分量，用于透视除法（近大远小）
    gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

    // 计算该顶点到相机的距离，fog_distance 是 fog.glsl 里的工具函数
    // 这个距离值会传给片段着色器，用来决定雾效浓度（越远越浓）
    vertexDistance = fog_distance(ModelViewMat, Position, FogShape);

    // 纹理坐标直接透传
    texCoord0 = UV0;

    // 顶点颜色 = 粒子自身颜色 × 光照贴图采样值
    // UV2 / 16 将整数坐标映射到 16×16 光照贴图的纹素位置
    vertexColor = Color * texelFetch(Sampler2, UV2 / 16, 0);
}

#version 150

#moj_import <fog.glsl>

// 从顶点着色器接收的插值变量
in float vertexDistance;
in vec2 texCoord0;
in vec4 vertexColor;

// 采样器
uniform sampler2D Sampler0;  // 粒子纹理图集

// Uniform
uniform vec4 ColorModulator; // 全局颜色调制（用于淡入淡出等效果）
uniform vec4 FogColor;       // 雾的颜色
uniform float FogStart;      // 雾起始距离
uniform float FogEnd;        // 雾结束距离

// 输出
out vec4 fragColor;

void main() {
    // 采样粒子纹理
    vec4 color = texture(Sampler0, texCoord0) * vertexColor * ColorModulator;

    // alpha 测试：完全透明的像素直接丢弃
    if (color.a < 0.01) {
        discard;
    }

    // 应用线性雾效混合
    fragColor = linear_fog(color, vertexDistance, FogStart, FogEnd, FogColor);
}

// 获取 Uniform 句柄
Uniform uniform = shader.getUniform("ColorModulator");

// 设置值（多种重载）
uniform.set(1.0f, 1.0f, 1.0f, 0.5f);  // vec4
uniform.set(matrix);                     // mat4
uniform.set(0.8f);                       // float

// 上传到 GPU（在 draw call 前调用）
uniform.upload();

// 地形渲染的通用片段（被多个管线复用）
private static final SnippetKey TERRAIN_SNIPPET = RenderPipeline.builder()
    .withVertexShader("core/rendertype_solid")
    .withFragmentShader("core/rendertype_solid")
    .withSampler("Sampler0")       // 方块纹理图集
    .withSampler("Sampler2")       // 光照贴图
    .withUniform("ModelViewMat")
    .withUniform("ProjMat")
    .withUniform("ChunkOffset")    // 区块偏移量，用于相对坐标渲染
    .withUniform("ColorModulator")
    .withUniform("FogStart")
    .withUniform("FogEnd")
    .withUniform("FogColor")
    .withUniform("FogShape")
    .withVertexFormat(DefaultVertexFormat.BLOCK)
    .buildSnippet();

// 实体渲染的管线配置
private static final SnippetKey ENTITY_SNIPPET = RenderPipeline.builder()
    .withVertexShader("core/rendertype_entity_solid")
    .withFragmentShader("core/rendertype_entity_solid")
    .withSampler("Sampler0")       // 实体纹理
    .withSampler("Sampler1")       // 覆盖层纹理（受伤闪红 死亡变白）
    .withSampler("Sampler2")       // 光照贴图
    .withUniform("ModelViewMat")
    .withUniform("ProjMat")
    .withUniform("ColorModulator")
    .withUniform("Light0_Direction")
    .withUniform("Light1_Direction")
    .withVertexFormat(DefaultVertexFormat.NEW_ENTITY)
    .buildSnippet();