vec4 FragAO()
{
    vec2 uv = texcoord;
    float depth = SampleDeviceDepth(uv);
    if (IsSkyDepth(depth)) return vec4(1.0);

    vec3 positionWS = ReconstructPositionWS(uv, depth);
    vec3 normalWS = normalize(SampleSceneNormals(uv));   // URP 14 的法线纹理是世界空间
    float centerEye = LinearEyeDepthWS(positionWS);

    // 每像素一个随机旋转角，把规则的采样图案打散成高频噪声，后面再模糊掉
    float noise = InterleavedGradientNoise(gl_FragCoord.xy, 0);
    vec3 randomDir = vec3(cos(noise * TWO_PI), sin(noise * TWO_PI), 0.37);
    vec3 tangentWS = normalize(cross(normalWS, randomDir));
    vec3 bitangentWS = cross(normalWS, tangentWS);

    int count = int(_SampleCount);
    float occlusion = 0.0;
    for (int i = 0; i < count; i++)
    {
        // 余弦分布的半球方向（黄金角螺旋），长度向中心聚集：近处样本更重要
        float u = (float(i) + 0.5) / float(count);
        float phi = float(i) * 2.39996323;
        float cosTheta = sqrt(1.0 - u), sinTheta = sqrt(u);
        vec3 dirTS = vec3(cos(phi) * sinTheta, sin(phi) * sinTheta, cosTheta);
        float lenScale = mix(0.1, 1.0, fract(u * 7.31 + noise) * fract(u * 7.31 + noise));
        vec3 offsetWS = (tangentWS * dirTS.x + bitangentWS * dirTS.y + normalWS * dirTS.z) * (lenScale * _Radius);
        vec3 sampleWS = positionWS + offsetWS;

        // 投影回屏幕，读那里的场景深度
        vec2 sampleUV = ComputeNormalizedDeviceCoordinates(sampleWS, UNITY_MATRIX_VP);
        float sampleEye = LinearEyeDepthWS(sampleWS);
        float sceneEye = EyeDepthAt(sampleUV);

        // 场景表面在样本点前面 → 样本点被埋住 → 记一次遮挡
        float occluded = sceneEye < sampleEye - _Bias ? 1.0 : 0.0;
        // 范围检查：深度差远大于半径的（背景前的前景边缘）不算，避免黑边光晕
        float rangeCheck = smoothstep(0.0, 1.0, _Radius / max(abs(centerEye - sceneEye), 1e-4));
        occlusion += occluded * rangeCheck;
    }
    float visibility = saturate(1.0 - occlusion / float(count) * _Intensity);
    return vec4(visibility, visibility, visibility, 1.0);
}

// 双边模糊：高斯权重 × 深度相似度权重，跨越深度断层的样本被压低，AO 不会渗到背景上
vec4 BilateralBlur(vec2 uv, vec2 dir)
{
    const float w[4] = float[4](0.324, 0.232, 0.0855, 0.0205);
    float centerEye = EyeDepthAt(uv);
    float sum = texture(_BlitTexture, uv).r * w[0];
    float wsum = w[0];
    for (int i = 1; i < 4; i++)
    {
        for (int s = -1; s <= 1; s += 2)
        {
            vec2 suv = uv + dir * float(i * s);
            float d = EyeDepthAt(suv);
            float wd = w[i] * exp(-abs(d - centerEye) / max(centerEye * 0.02, 1e-3));
            sum += textureLod(_BlitTexture, suv, 0.0).r * wd;
            wsum += wd;
        }
    }
    float v = sum / wsum;
    return vec4(v, v, v, 1.0);
}

// 进光照：必须在不透明物体之前，且要等深度/法线预通道画完（+1 与 URP 自带 SSAO 一致）
const event = s.mode === Mode.IntoLighting ? RenderPassEvent.AfterRenderingPrePasses + 1 : RenderPassEvent.AfterRenderingOpaques;

// 案例 28.4：简化版 SSAO 的 Renderer Feature（对应 Ch28/SimpleSSAOFeature.cs）。
//   IntoLighting        —— 像 URP 自带 SSAO 一样，在不透明物体之前算好 AO，作为 _ScreenSpaceOcclusionTexture 交给光照；
//   MultiplyAfterOpaque —— 不透明物体画完后直接把 AO 乘到颜色上；
//   ShowAO              —— 只显示 AO（调试）。
import { featureMaterial, RenderPassEvent } from '../engine/features.js';
import { renderDepthNormals } from './Cookbook.Ch28.ScreenSpaceUtil.js';

const Mode = { IntoLighting: 0, MultiplyAfterOpaque: 1, ShowAO: 2 };

export default class SimpleSSAOFeature {
  constructor(engine, data, scene) {
    this.engine = engine;
    this.scene = scene;
    this.settings = { material: null, mode: Mode.IntoLighting, blur: true, halfResolution: false, directLightingStrength: 0.25, ...((data && data.settings) || {}) };
  }

  async init() { this.material = featureMaterial(this.scene, this.settings.material); }

  addPasses(frame, enqueue) {
    const s = this.settings, mat = this.material;
    if (!mat) return;
    // 进光照：必须在不透明物体之前，且要等深度/法线预通道画完（+1 与 URP 自带 SSAO 一致）
    const event = s.mode === Mode.IntoLighting ? RenderPassEvent.AfterRenderingPrePasses + 1 : RenderPassEvent.AfterRenderingOpaques;
    // ConfigureInput(Depth | Normal)：前向路径下 URP 会执行 DepthNormals 预通道
    enqueue(RenderPassEvent.AfterRenderingPrePasses, (fr) => renderDepthNormals(fr), 'DepthNormalPrepass');
    enqueue(event, (fr) => {
      const W = s.halfResolution ? Math.floor(fr.width / 2) : fr.width, H = s.halfResolution ? Math.floor(fr.height / 2) : fr.height;
      const ao = fr.getTemporaryRT('_SimpleSSAO', W, H, { color: 'RGBA8' });
      const aoTemp = fr.getTemporaryRT('_SimpleSSAOTemp', W, H, { color: 'RGBA8' });
      mat.setVector('_SSAOTexelSize', [1 / W, 1 / H, W, H]);
      // 1) AO：没有输入纹理，直接画全屏三角形
      fr.blit(null, ao, mat, 0);
      // 2) 可分离双边模糊：AO → Temp（横）→ AO（竖）
      if (s.blur) {
        fr.blit(ao.texture, aoTemp, mat, 1);
        fr.blit(aoTemp.texture, ao, mat, 2);
      }
      if (s.mode === Mode.IntoLighting) {
        // 3a) 按 URP 的约定把结果交给光照：纹理 + 参数（w = 直接光受 AO 影响的比例）
        fr.setGlobal('_ScreenSpaceOcclusionTexture', ao.texture);
        fr.setGlobal('_AmbientOcclusionParam', [1, 0, 0, s.directLightingStrength]);
      } else {
        // 3b) 直接乘到相机颜色上（或只显示 AO）
        fr.setGlobal('_SSAOResult', ao.texture);
        const copy = fr.getTemporaryRT('_SimpleSSAOColor', fr.width, fr.height, { filter: 'Point' });
        fr.blit(fr.cameraColorTexture(), copy);
        fr.blit(copy.texture, 'camera', mat, s.mode === Mode.ShowAO ? 4 : 3);
      }
      fr.bindCamera();
    }, 'SimpleSSAO');
  }
}