输入：方块坐标 玩家位置 模型数据 纹理贴图
处理：坐标变换 光栅化 着色 混合
输出：一帧画面（一张 1920×1080 的像素矩阵）

你的代码 -> OpenGL API -> 显卡驱动（不同厂商各自实现） -> GPU 硬件

顶点0: 位置(-0.5, -0.5, 0.0), 颜色(1,0,0,1), 纹理坐标(0.0, 0.0)
顶点1: 位置( 0.5, -0.5, 0.0), 颜色(0,1,0,1), 纹理坐标(1.0, 0.0)
顶点2: 位置( 0.0,  0.5, 0.0), 颜色(0,0,1,1), 纹理坐标(0.5, 1.0)

#version 150

in vec3 Position;           // 顶点位置
in vec4 Color;              // 顶点颜色
in vec2 UV0;                // 纹理坐标

uniform mat4 ModelViewMat;  // 模型视图矩阵（由 CPU 每帧传入）
uniform mat4 ProjMat;       // 投影矩阵（由 CPU 每帧传入）

out vec4 vertexColor;       // 传给下一阶段
out vec2 texCoord;          // 传给下一阶段

void main() {
    // 核心：坐标变换，把模型空间的点变换到裁剪空间
    gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);
    // 直接透传
    vertexColor = Color;
    texCoord = UV0;
}

模型空间 -[Model]-> 世界空间 -[View]-> 观察空间 -[Projection]-> 裁剪空间 -[视口变换]-> 屏幕坐标

TRIANGLES: v0,v1,v2 | v3,v4,v5        （6顶点画2三角形）
STRIP:     v0,v1,v2 | v1,v2,v3        （4顶点画2三角形，复用 v1 v2）

edge(A, B, P) = (B.x - A.x) * (P.y - A.y) - (B.y - A.y) * (P.x - A.x)

P = w0 * V0 + w1 * V1 + w2 * V2
其中 w0 + w1 + w2 = 1, w0 >= 0, w1 >= 0, w2 >= 0

color_P = w0 * color_V0 + w1 * color_V1 + w2 * color_V2
uv_P    = w0 * uv_V0    + w1 * uv_V1    + w2 * uv_V2

#version 150

in vec4 vertexColor;        // 从顶点着色器传来（已被光栅化插值）
in vec2 texCoord;           // 纹理坐标（已插值）

uniform sampler2D Sampler0; // 纹理采样器

out vec4 fragColor;         // 最终颜色输出

void main() {
    // 从纹理图上取色
    vec4 texColor = texture(Sampler0, texCoord);
    // 纹理色 × 顶点色 = 最终色
    fragColor = texColor * vertexColor;
}

最终颜色 = 新颜色 × alpha + 旧颜色 × (1 - alpha)

// com.mojang.blaze3d.vertex.VertexFormatElement
public static final VertexFormatElement POSITION = register(0, 0, Type.FLOAT, false, 3);  // xyz 三个 float
public static final VertexFormatElement COLOR    = register(1, 0, Type.UBYTE, true,  4);  // rgba 四个 unsigned byte
public static final VertexFormatElement UV0      = register(2, 0, Type.FLOAT, false, 2);  // 主纹理坐标 uv
public static final VertexFormatElement UV1      = register(3, 1, Type.SHORT, false, 2);  // 覆盖层坐标（受伤变红）
public static final VertexFormatElement UV2      = register(4, 2, Type.SHORT, false, 2);  // 光照贴图坐标
public static final VertexFormatElement NORMAL   = register(5, 0, Type.BYTE,  true,  3);  // 法线方向 xyz

// 方块渲染格式：位置 + 颜色 + 纹理坐标 + 光照
public static final VertexFormat BLOCK = VertexFormat.builder()
    .add("Position", VertexFormatElement.POSITION)  // 3×float = 12 bytes
    .add("Color",    VertexFormatElement.COLOR)      // 4×ubyte = 4 bytes
    .add("UV0",      VertexFormatElement.UV0)        // 2×float = 8 bytes
    .add("UV2",      VertexFormatElement.UV2)        // 2×short = 4 bytes
    .build();                                        // 总计 28 bytes/顶点

// 实体渲染格式：比方块多了覆盖层和法线
public static final VertexFormat ENTITY = VertexFormat.builder()
    .add("Position", VertexFormatElement.POSITION)
    .add("Color",    VertexFormatElement.COLOR)
    .add("UV0",      VertexFormatElement.UV0)
    .add("UV1",      VertexFormatElement.UV1)        // 覆盖层（受伤闪红）
    .add("UV2",      VertexFormatElement.UV2)
    .add("Normal",   VertexFormatElement.NORMAL)     // 法线（光照计算）
    .padding(1)                                      // 对齐填充
    .build();

// GUI / HUD 格式：最精简
public static final VertexFormat POSITION_TEX_COLOR = VertexFormat.builder()
    .add("Position", VertexFormatElement.POSITION)
    .add("UV0",      VertexFormatElement.UV0)
    .add("Color",    VertexFormatElement.COLOR)
    .build();

CPU 端 BufferBuilder 攒顶点 -> build() 打包 MeshData -> 上传到 GpuBuffer(VBO)
GPU 端按 VertexFormat(VAO schema) 解析 -> 喂给顶点着色器

// com.mojang.blaze3d.shaders.ShaderType
public enum ShaderType {
    VERTEX("vertex", ".vsh"),    // 顶点着色器
    FRAGMENT("fragment", ".fsh"); // 片段着色器
}

// 标量——和 Java 基本类型对应
float f = 3.14;    // 单精度浮点
int   i = 42;      // 整数
bool  b = true;    // 布尔

// 向量——打包的多分量类型，GPU 一条指令处理整个向量
vec2 uv       = vec2(0.5, 0.5);          // 2 个 float（纹理坐标）
vec3 position = vec3(1.0, 2.0, 3.0);     // 3 个 float（空间坐标）
vec4 color    = vec4(1.0, 0.0, 0.0, 1.0); // 4 个 float（RGBA 颜色）

// 矩阵——用于坐标变换
mat4 transform; // 4×4 矩阵

// 采样器——纹理的句柄
sampler2D tex;  // 2D 纹理

vec4 c = vec4(1.0, 0.5, 0.0, 1.0);
c.rgb   // vec3(1.0, 0.5, 0.0) 取前三个分量
c.bgr   // vec3(0.0, 0.5, 1.0) 反转 RGB
c.rrrr  // vec4(1.0, 1.0, 1.0, 1.0) 广播
c.xy    // vec2(1.0, 0.5)

// in — 输入，从上游接收
in vec3 Position;     // 顶点着色器里：来自顶点数据
in vec4 vertexColor;  // 片段着色器里：来自顶点着色器（已插值）

// out — 输出，传给下游
out vec4 vertexColor; // 顶点着色器里：传给片段着色器
out vec4 fragColor;   // 片段着色器里：最终像素颜色

// uniform — 全局只读常量，CPU 端设置，一次 draw call 内不变
uniform mat4 ModelViewMat;  // 变换矩阵
uniform mat4 ProjMat;       // 投影矩阵
uniform float GameTime;     // 游戏时间
uniform sampler2D Sampler0; // 纹理

// ===== 顶点着色器 =====
gl_Position    // (必须设置) 变换后的顶点位置，vec4
gl_PointSize   // 点的大小，用于 GL_POINTS 模式
gl_VertexID    // 当前顶点的索引号

// ===== 片段着色器 =====
gl_FragCoord   // 当前片段的屏幕坐标，vec4 (x, y, z, 1/w)
gl_FrontFacing // 是否是正面，bool
gl_FragDepth   // 可选：手动设置片段深度（覆盖默认值）

// 各种构造方式
vec4 a = vec4(1.0);                    // (1.0, 1.0, 1.0, 1.0) 广播标量
vec4 b = vec4(vec3(1.0, 2.0, 3.0), 1.0); // 从 vec3 + float 构造
vec3 c = vec3(vec2(1.0, 2.0), 3.0);    // 从 vec2 + float 构造
vec2 d = vec4(1.0, 2.0, 3.0, 4.0).xy;  // 从 vec4 截取

// 向量运算——逐分量进行
vec3 a = vec3(1.0, 2.0, 3.0);
vec3 b = vec3(4.0, 5.0, 6.0);
vec3 c = a + b;    // (5.0, 7.0, 9.0) 逐分量加
vec3 d = a * b;    // (4.0, 10.0, 18.0) 逐分量乘（不是点积！）
vec3 e = a * 2.0;  // (2.0, 4.0, 6.0) 标量乘

// 矩阵 × 向量
mat4 M = ...;
vec4 result = M * vec4(position, 1.0);  // 矩阵乘法

// 取值
abs(x)           // 绝对值
sign(x)          // 符号 (-1.0, 0.0, 1.0)
floor(x)         // 向下取整
ceil(x)          // 向上取整
round(x)         // 四舍五入
fract(x)         // 小数部分 = x - floor(x)
mod(x, y)        // 取模 = x - y * floor(x/y)

// 限制和插值
min(x, y)        // 最小值
max(x, y)        // 最大值
clamp(x, a, b)   // 限制范围 [a, b]，等价于 max(a, min(b, x))
mix(a, b, t)     // 线性插值 = a * (1-t) + b * t
step(edge, x)    // x < edge ? 0.0 : 1.0（硬切）
smoothstep(a, b, x)  // 平滑 S 曲线插值（Hermite 插值）

// 三角函数
sin(x), cos(x), tan(x)
asin(x), acos(x), atan(x)
atan(y, x)       // 二参数版本，返回完整 [-π, π] 范围

// 指数和幂
pow(x, y)        // x 的 y 次方
exp(x)           // e^x
exp2(x)          // 2^x
log(x)           // ln(x)
log2(x)          // log₂(x)
sqrt(x)          // 平方根
inversesqrt(x)   // 1 / sqrt(x)，GPU 有专用硬件，比手动除法快

// smoothstep(edge0, edge1, x) 等价于：
float t = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);
return t * t * (3.0 - 2.0 * t);  // Hermite 插值多项式

// 长度和距离
length(v)        // 向量长度 = sqrt(dot(v, v))
distance(a, b)   // 两点距离 = length(a - b)
normalize(v)     // 归一化为单位向量 = v / length(v)

// 点积和叉积
dot(a, b)        // 点积 = a.x*b.x + a.y*b.y + a.z*b.z
                 // 几何意义：|a|*|b|*cos(θ)
                 // 用途：光照计算（法线·光线方向 = 亮度因子）
cross(a, b)      // 叉积（仅 vec3），结果垂直于 a 和 b
                 // 用途：计算面法线

// 反射和折射
reflect(I, N)    // 反射向量，I 是入射方向，N 是法线
                 // = I - 2.0 * dot(N, I) * N
refract(I, N, eta) // 折射向量，eta 是折射率比

// 面朝向
faceforward(N, I, Nref)  // 如果 dot(Nref, I) < 0 返回 N，否则返回 -N

// 基础采样
texture(sampler, uv)         // 用浮点 UV 坐标采样，会做过滤（NEAREST 或 LINEAR）
texture(sampler, uv, bias)   // 带 LOD 偏移的采样

// 精确像素采样
texelFetch(sampler, ivec2(x, y), lod)  // 用整数坐标精确取某个像素，不做过滤
                                        // MC 光照贴图用这个

// 纹理信息
textureSize(sampler, lod)    // 返回 ivec2(width, height)

// Lod 相关
textureLod(sampler, uv, lod) // 手动指定 mipmap 级别采样

// 逐分量比较（返回 bvec）
lessThan(a, b)       // a < b
greaterThan(a, b)    // a > b
equal(a, b)          // a == b

// 逐分量选择
mix(a, b, bvec)      // bvec 版本的 mix：按 bool 向量选择

// 1. 丢弃透明片段
if (texColor.a < 0.01) discard;  // 不写入任何缓冲

// 2. 颜色空间转换：线性 -> sRGB（伽马校正）
vec3 srgb = pow(linearColor, vec3(1.0 / 2.2));

// 3. 雾效（MC 标准做法）
float fogFactor = smoothstep(FogStart, FogEnd, vertexDistance);
color = mix(color, FogColor, fogFactor * FogColor.a);

// 4. 法线贴图解包（-1~1 范围）
vec3 normal = texture(normalMap, uv).xyz * 2.0 - 1.0;

// 5. 亮度计算（人眼感知加权）
float luminance = dot(color.rgb, vec3(0.2126, 0.7152, 0.0722));

// 6. 边缘发光（Fresnel 效果）
float rim = 1.0 - max(dot(normal, viewDir), 0.0);
rim = pow(rim, 3.0);
color += rimColor * rim;

#version 150

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in ivec2 UV2;

uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
uniform sampler2D Sampler2; // 光照贴图

out vec4 vertexColor;
out vec2 texCoord0;
out float vertexDistance;

void main() {
    // 坐标变换
    gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);
    // 算到相机的距离（雾效用）
    vertexDistance = length((ModelViewMat * vec4(Position, 1.0)).xyz);
    // 透传纹理坐标
    texCoord0 = UV0;
    // 查光照贴图得到亮度
    vec4 lightColor = texelFetch(Sampler2, UV2 / 16, 0);
    vertexColor = Color * lightColor;
}

#version 150

in vec4 vertexColor;
in vec2 texCoord0;
in float vertexDistance;

uniform sampler2D Sampler0; // 方块纹理
uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

out vec4 fragColor;

void main() {
    // 采样方块纹理
    vec4 texColor = texture(Sampler0, texCoord0);
    // 透明像素直接丢弃，不写入帧缓冲
    if (texColor.a < 0.01) discard;
    // 纹理色 × 顶点色(含光照) × 全局调色
    vec4 color = texColor * vertexColor * ColorModulator;
    // 应用雾效：距离越远越接近雾色
    float fogFactor = smoothstep(FogStart, FogEnd, vertexDistance);
    color = mix(color, FogColor, fogFactor * FogColor.a);
    fragColor = color;
}

shaders/
├── core/         核心着色器（方块 实体 粒子 GUI 天空）
├── include/      公共代码片段（雾效函数 光照工具）
└── post/         后处理着色器（模糊 辉光 反色）

// net.minecraft.client.renderer.RenderPipelines（简化）
// 方块地形管线
private static final RenderPipeline.Snippet TERRAIN_SNIPPET = RenderPipeline.builder(GENERIC_BLOCKS_SNIPPET)
    .withUniform("Projection", UniformType.UNIFORM_BUFFER)
    .withUniform("ChunkSection", UniformType.UNIFORM_BUFFER)
    .withVertexShader("core/terrain")      // 着色器路径直接写死
    .withFragmentShader("core/terrain")
    .buildSnippet();

// 实体管线
private static final RenderPipeline.Snippet ENTITY_SNIPPET = RenderPipeline.builder(MATRICES_FOG_LIGHT_DIR_SNIPPET)
    .withVertexShader("core/entity")
    .withFragmentShader("core/entity")
    .withSampler("Sampler0")               // 纹理采样器
    .withSampler("Sampler2")               // 光照贴图
    .withVertexFormat(DefaultVertexFormat.ENTITY, VertexFormat.Mode.QUADS)
    .withDepthStencilState(DepthStencilState.DEFAULT)
    .buildSnippet();

// net.minecraft.client.renderer.PostChainConfig
public record PostChainConfig(
    Map<Identifier, InternalTarget> internalTargets,
    List<Pass> passes
) {
    public record Pass(
        Identifier vertexShaderId,      // 顶点着色器 ID
        Identifier fragmentShaderId,    // 片段着色器 ID
        List<Input> inputs,             // 输入纹理/目标
        Identifier outputTarget,        // 输出目标
        Map<String, List<UniformValue>> uniforms
    ) { ... }
}

不合并：对每个顶点做 3 次变换 = 3 次矩阵乘法
合并后：先算 M = A × B × C，再对每个顶点乘一次 M

位置点：w = 1，受平移影响  (x, y, z, 1)
方向向量：w = 0，不受平移  (dx, dy, dz, 0)

// com.mojang.blaze3d.vertex.PoseStack.Pose
public static final class Pose {
    private final Matrix4f pose = new Matrix4f();   // 位姿矩阵（平移旋转缩放）
    private final Matrix3f normal = new Matrix3f(); // 法线矩阵（光照计算用）
    private boolean trustedNormals = true;          // 法线矩阵是否可信
}

poseStack.pushPose();                                    // 保存当前状态
poseStack.translate(x, y, z);                            // 平移
poseStack.mulPose(Axis.YP.rotationDegrees(rotation));    // 绕 Y 轴旋转
poseStack.scale(sx, sy, sz);                             // 缩放
// 渲染...
poseStack.popPose();                                     // 恢复之前的状态

ModelViewMat = View × Model

gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);
//           投影       模型视图        齐次坐标扩展

private void computeNormalMatrix() {
    this.normal.set(this.pose).invert().transpose();
    this.trustedNormals = false;
}

// com.mojang.blaze3d.textures.FilterMode
public enum FilterMode {
    NEAREST,  // 最近邻：取最近像素，效果像素化锐利
    LINEAR;   // 线性插值：取周围像素加权平均，效果平滑模糊
}

// com.mojang.blaze3d.textures.GpuTexture
public GpuTexture(int usage, String label, TextureFormat format,
                  int width, int height, int depthOrLayers, int mipLevels) {
    // mipLevels: mip 级数，0 级是原图，每级尺寸减半
}

Level 0: 16×16 (原图)
Level 1: 8×8   (每 2×2 像素平均为 1 像素)
Level 2: 4×4
Level 3: 2×2
Level 4: 1×1

// com.mojang.blaze3d.textures.AddressMode
public enum AddressMode {
    REPEAT,        // 重复平铺：UV=1.5 等效于 0.5
    CLAMP_TO_EDGE; // 钳制到边缘：超出部分取边缘颜色
}

uniform sampler2D Sampler0; // 纹理单元 0：主纹理（方块/实体贴图）
uniform sampler2D Sampler1; // 纹理单元 1：覆盖层（受伤变红效果）
uniform sampler2D Sampler2; // 纹理单元 2：光照贴图

// com.mojang.blaze3d.pipeline.RenderTarget
public abstract class RenderTarget {
    public int width;
    public int height;
    public final boolean useDepth;
    protected @Nullable GpuTexture colorTexture;     // 颜色附件（纹理）
    protected @Nullable GpuTextureView colorTextureView;
    protected @Nullable GpuTexture depthTexture;     // 深度附件（纹理）
    protected @Nullable GpuTextureView depthTextureView;
}

// MRT 片段着色器
out vec4 fragColor0;  // 颜色附件 0：最终颜色
out vec4 fragColor1;  // 颜色附件 1：法线
out vec4 fragColor2;  // 颜色附件 2：深度/材质 ID

渲染片段 A (深度 0.3):
  深度缓冲当前值 = 1.0 (初始值)
  0.3 < 1.0 → 测试通过，写入颜色，更新深度缓冲为 0.3

渲染片段 B (深度 0.5，同一像素位置):
  深度缓冲当前值 = 0.3
  0.5 > 0.3 → 测试失败，丢弃片段 B（被 A 遮挡）

渲染片段 C (深度 0.1，同一像素位置):
  深度缓冲当前值 = 0.3
  0.1 < 0.3 → 测试通过，覆盖 A，更新深度为 0.1

// com.mojang.blaze3d.pipeline.DepthStencilState
public record DepthStencilState(
    CompareOp depthTest,            // 比较函数
    boolean writeDepth,             // 是否写入深度缓冲
    float depthBiasScaleFactor,     // 深度偏移（解决 Z-fighting）
    float depthBiasConstant
) {
    public static final DepthStencilState DEFAULT =
        new DepthStencilState(CompareOp.LESS_THAN_OR_EQUAL, true);
}

最终颜色 = 源颜色 × 源因子 + 目标颜色 × 目标因子

// com.mojang.blaze3d.pipeline.BlendFunction
// 标准半透明：src × alpha + dst × (1 - alpha)
public static final BlendFunction TRANSLUCENT = new BlendFunction(
    SourceFactor.SRC_ALPHA,
    DestFactor.ONE_MINUS_SRC_ALPHA,
    SourceFactor.ONE,
    DestFactor.ONE_MINUS_SRC_ALPHA
);

// 加法混合：src × 1 + dst × 1（发光 粒子 闪电效果）
public static final BlendFunction ADDITIVE = new BlendFunction(
    SourceFactor.ONE, DestFactor.ONE
);

// 闪光效果：src × srcColor + dst × 1
public static final BlendFunction GLINT = new BlendFunction(
    SourceFactor.SRC_COLOR, DestFactor.ONE,
    SourceFactor.ZERO, DestFactor.ONE
);

// com.mojang.blaze3d.pipeline.ColorTargetState
public static final int WRITE_RED   = 1;   // 0001
public static final int WRITE_GREEN = 2;   // 0010
public static final int WRITE_BLUE  = 4;   // 0100
public static final int WRITE_ALPHA = 8;   // 1000
public static final int WRITE_ALL   = 15;  // 1111
public static final int WRITE_NONE  = 0;   // 0000

// 错误示例：状态泄漏
void renderGlass() {
    glEnable(GL_BLEND);  // 开启混合
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    // 画玻璃...
    // 忘记关闭混合！
}

void renderBlock() {
    // 此时混合仍然开启——不透明方块被错误地做了混合
    // 画方块...
}

// com.mojang.blaze3d.pipeline.RenderPipeline（简化）
public class RenderPipeline {
    private final Identifier vertexShader;       // 着色器
    private final Identifier fragmentShader;
    private final VertexFormat vertexFormat;      // 顶点格式
    private final VertexFormat.Mode vertexFormatMode;
    private final @Nullable DepthStencilState depthStencilState;  // 深度/模板配置
    private final boolean cull;                  // 是否背面剔除
    private final ColorTargetState colorTargetState;  // 混合 + 写入遮罩
    private final PolygonMode polygonMode;       // 填充/线框
}

glViewport(x, y, width, height);