rgbaDepth -= rgbaDepth.gbaa * bitMask;  // ✓ gbaa 是 vec4，与 vec4 的 bitMask 匹配
// rgbaDepth.gba 是 vec3，乘 vec4 会编译失败

if (uDebugMode == 1) {
  gl_FragColor = vec4(vec3(visibility), 1.0);        // 阴影 mask
} else if (uDebugMode == 2) {
  float z = unpack(texture2D(uShadowMap, shadowCoord.xy));
  gl_FragColor = vec4(vec3(z), 1.0);                 // shadow map 深度
} else if (uDebugMode == 3) {
  gl_FragColor = vec4(vec3(shadowCoord.z), 1.0);     // 当前片元光空间深度
} else if (uDebugMode == 4) {
  gl_FragColor = vec4(shadowCoord.xy, 0.0, 1.0);     // UV 分布
} else {
  gl_FragColor = vec4(phongColor * visibility, 1.0); // 正常渲染
}

varying highp vec4 vPositionFromLight;

void main(void) {
  vFragPos = (uModelMatrix * vec4(aVertexPosition, 1.0)).xyz;
  vNormal = (uModelMatrix * vec4(aNormalPosition, 0.0)).xyz;
  gl_Position = uProjectionMatrix * uViewMatrix * uModelMatrix * vec4(aVertexPosition, 1.0);
  vTextureCoord = aTextureCoord;
  vPositionFromLight = uLightMVP * vec4(aVertexPosition, 1.0);
}

uniform sampler2D uShadowMap;
uniform float uBias;
uniform int uDebugMode;
varying vec4 vPositionFromLight;

float unpack(vec4 rgbaDepth) {
  const vec4 bitShift = vec4(1.0, 1.0/256.0, 1.0/(256.0*256.0), 1.0/(256.0*256.0*256.0));
  return dot(rgbaDepth, bitShift);
}

float useShadowMap(sampler2D shadowMap, vec4 shadowCoord){
  float z = unpack(texture2D(shadowMap, shadowCoord.xy));
  return step(shadowCoord.z - uBias, z);
}

void main(void) {
  float visibility;
  vec3 shadowCoord = vPositionFromLight.xyz / vPositionFromLight.w * 0.5 + 0.5;
  visibility = useShadowMap(uShadowMap, vec4(shadowCoord, 1.0));
  vec3 phongColor = blinnPhong();
  // ... debugMode 分支 ...
  gl_FragColor = vec4(phongColor * visibility, 1.0);
}

// 世界坐标 → NDC → [0,1] 屏幕坐标
vec2 GetScreenCoordinate(vec3 posWorld) {
  return Project(vWorldToScreen * vec4(posWorld, 1.0)).xy * 0.5 + 0.5;
}

// 世界坐标 → 视空间深度（与 GBuffer 存的 vDepth 同约定）
float GetDepth(vec3 posWorld) {
  return (vWorldToScreen * vec4(posWorld, 1.0)).w;
}

float InitRand(vec2 uv) { ... }   // 用 gl_FragCoord 生成种子
float Rand1(inout float p) { ... } // 伪随机 [0,1)，顺序产生
vec2  Rand2(inout float p) { ... } // 两个随机数

// 均匀采样：pdf = 1/(2π)
vec3 SampleHemisphereUniform(inout float s, out float pdf) { ... }

// 余弦加权采样：pdf = cosθ / π
vec3 SampleHemisphereCos(inout float s, out float pdf) {
  vec2 uv = Rand2(s);
  float z = sqrt(1.0 - uv.x);          // z = cosθ
  float phi = uv.y * TWO_PI;
  float sinTheta = sqrt(uv.x);
  return vec3(sinTheta * cos(phi), sinTheta * sin(phi), z);
  pdf = z * INV_PI;                     // cosθ / π
}

void LocalBasis(vec3 n, out vec3 b1, out vec3 b2) { ... }

mat3 TBN = mat3(b1, b2, normal);   // GLSL 按列构造
vec3 dir = TBN * dirLocal;         // = dirLocal.x*b1 + dirLocal.y*b2 + dirLocal.z*normal

//vec3 dir = dirLocal.x * b1 + dirLocal.y * b2 + dirLocal.z * normal;

// Lambert BSDF：fr = ρ / π（与 wi、wo 无关）
vec3 EvalDiffuse(vec3 wi, vec3 wo, vec2 uv) {
  vec3 albedo = GetGBufferDiffuse(uv);   // 内部 pow(diffuse, 2.2) 解码回线性
  return albedo / M_PI;
}

// 方向光入射辐射度 × 阴影可见性
vec3 EvalDirectionalLight(vec2 uv) {
  float v = GetGBufferuShadow(uv);       // 第 2 次着色已算好阴影
  return uLightRadiance * v;
}

bool RayMarch(vec3 ori, vec3 dir, out vec3 hitPos) {
  const float step = 0.05;
  float t = 0.01;                       // 起始偏移，避免与自身表面相交
  for (int i = 0; i < 200; ++i) {
    vec3 p = ori + dir * t;
    vec2 uv = GetScreenCoordinate(p);
    if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0)
      return false;                     // 走出屏幕，无交
    float sceneDepth = GetGBufferDepth(uv);  // 该像素表面深度
    float rayDepth = GetDepth(p);            // 光线上该点深度
    float diff = rayDepth - sceneDepth;
    if (diff > 0.0 && diff < 0.5) {          // 光线已越过表面
      hitPos = p;
      return true;
    }
    t += step;
  }
  return false;
}

result += Li * (albedo / M_PI) * dirLocal.z / pdf;  // = Li·fr·cosθ / pdf
...
return result / float(SAMPLE_NUM);                   // = (1/N) Σ

vec3 OneBounceIndirectLight(vec3 pos, vec3 normal, vec3 albedo, inout float s) {
  vec3 b1, b2;
  LocalBasis(normal, b1, b2);
  vec3 result = vec3(0.0);

  for (int i = 0; i < SAMPLE_NUM; ++i) {
    float pdf;
    vec3 dirLocal = SampleHemisphereCos(s, pdf);
    mat3 TBN = mat3(b1, b2, normal);
    vec3 dir = TBN * dirLocal;                 // 局部 → 世界

    vec3 hitPos;
    if (RayMarch(pos, dir, hitPos)) {
      vec2 hitUV = GetScreenCoordinate(hitPos);
      vec3 hitNormal = normalize(GetGBufferNormalWorld(hitUV));

      // 命中点 q 朝 -dir 出射的直接光
      float NoL = max(dot(hitNormal, normalize(uLightDir)), 0.0);
      vec3 Li = EvalDiffuse(dir, -dir, hitUV) * EvalDirectionalLight(hitUV) * NoL;

      result += Li * (albedo / M_PI) * dirLocal.z / pdf;
    }
  }
  return result / float(SAMPLE_NUM);
}

vec3 TwoBounceIndirectLight(vec3 pos, vec3 normal, vec3 albedo, inout float s) {
  // 结构与 OneBounce 相同，唯一区别是命中点 q 的入射光：
  //   Li = Ld(直接光) + L_indirect(q 处的一次反射)
  ...
  vec3 Ld = EvalDiffuse(dir, -dir, hitUV) * EvalDirectionalLight(hitUV) * NoL;
  vec3 L_indirect = OneBounceIndirectLight(hitPos, hitNormal, hitAlbedo, s);
  vec3 Li = Ld + L_indirect;
  result += Li * (albedo / M_PI) * dirLocal.z / pdf;
  ...
}

void main() {
  float s = InitRand(gl_FragCoord.xy);

  vec3 pos = vPosWorld.xyz / vPosWorld.w;   // 当前片元世界坐标
  vec2 uv = GetScreenCoordinate(pos);
  vec3 normal = normalize(GetGBufferNormalWorld(uv));
  vec3 albedo = GetGBufferDiffuse(uv);

  // 直接光
  vec3 LD = normalize(uLightDir);
  float cosTerm = max(dot(normal, LD), 0.0);
  vec3 direct = EvalDiffuse(LD, LD, uv) * EvalDirectionalLight(uv) * cosTerm;

  // 间接光（两次反射）
  vec3 indirect = TwoBounceIndirectLight(pos, normal, albedo, s);

  vec3 color = direct + indirect;
  gl_FragColor = vec4(pow(color, vec3(1.0 / 2.2)), 1.0);  // 最后才 gamma
}