// 第 19 章：完整的风格化水面。每个特性一个关键字，正文按案例逐个打开。
// 依赖：URP Asset 开启 Depth Texture 与 Opaque Texture；水面放在 Water 层（平面反射相机不渲染它）。
Shader "Cookbook/Ch19/Water"
{
    Properties
    {
        [Header(Depth Color)]
        _ShallowColor ("Shallow Color (A=alpha)", Color) = (0.35,0.85,0.8,0.35)
        _DeepColor ("Deep / Scatter Color (A=alpha)", Color) = (0.03,0.22,0.35,0.95)
        _DepthMax ("Depth For Deep Color (m)", Float) = 2
        _Absorption ("Absorption per meter (RGB)", Vector) = (0.9,0.32,0.22,0)
        _EdgeFade ("Shore Edge Fade (m)", Float) = 0.08

        [Header(Refraction)]
        [Toggle(_REFRACTION)] _Refraction ("Refraction", Float) = 1
        _RefractionStrength ("Refraction Strength", Range(0,0.2)) = 0.05
        [Toggle] _RefractLeakFix ("Fix Foreground Leak", Float) = 1

        [Header(Normals)]
        [Toggle(_NORMALS)] _Normals ("Dual Normals", Float) = 1
        [NoScaleOffset][Normal] _NormalMap ("Normal Map", 2D) = "bump" {}
        _NormalTiling ("Tiling A/B (per meter)", Vector) = (0.18,0.31,0,0)
        _FlowA ("Flow A (xy dir*speed, z strength)", Vector) = (0.03,0.02,0.6,0)
        _FlowB ("Flow B (xy dir*speed, z strength)", Vector) = (-0.025,0.035,0.45,0)

        [Header(Reflection)]
        [Toggle(_REFLECTION)] _Reflection ("Reflection", Float) = 1
        [Toggle(_PLANAR_REFLECTION)] _PlanarReflection ("Use Planar Reflection Texture", Float) = 0
        _ReflectionStrength ("Reflection Strength", Range(0,1)) = 1
        [Toggle] _UseFresnel ("Use Fresnel", Float) = 1
        _Roughness ("Reflection Roughness", Range(0,1)) = 0.05
        _PlanarDistortion ("Planar Reflection Distortion", Range(0,0.2)) = 0.04

        [Header(Specular)]
        [Toggle(_SPECULAR)] _Specular ("Sun Specular", Float) = 1
        _SpecPower ("Spec Power", Range(16,2048)) = 600
        _SpecIntensity ("Spec Intensity", Range(0,4)) = 1

        [Header(Foam)]
        [Toggle(_FOAM)] _Foam ("Shore Foam", Float) = 1
        [NoScaleOffset] _FoamNoise ("Foam Noise", 2D) = "gray" {}
        _FoamColor ("Foam Color", Color) = (0.95,0.98,1,1)
        _FoamDistance ("Foam Distance (m)", Float) = 0.6
        _FoamTiling ("Foam Tiling (per meter)", Float) = 0.35
        _FoamSoftness ("Foam Softness", Range(0.001,0.3)) = 0.03

        [Header(Caustics)]
        [Toggle(_CAUSTICS)] _Caustics ("Caustics", Float) = 1
        _CausticScale ("Caustic Scale (cells per meter)", Float) = 1.6
        _CausticIntensity ("Caustic Intensity", Range(0,4)) = 1.2
        _CausticDepthFade ("Caustic Depth Fade (m)", Float) = 1.5
        _CausticSplit ("Caustic RGB Split", Range(0,0.1)) = 0.025

        [Header(Gerstner Waves)]
        [Toggle(_GERSTNER)] _Gerstner ("Gerstner Waves", Float) = 0
        _WaveA ("Wave A (dir, steepness, wavelength)", Vector) = (1,0.3,0.18,7)
        _WaveB ("Wave B", Vector) = (0.4,1,0.15,4.3)
        _WaveC ("Wave C", Vector) = (-0.7,0.6,0.12,2.6)

        [Header(Time and Debug)]
        [Toggle] _AutoPlay ("Auto Play (_Time)", Float) = 0
        _Phase ("Phase (seconds)", Float) = 0
        [Enum(Off,0,VerticalDepth,1,ViewPath,2,Normal,3,Foam,4,Caustics,5,Fresnel,6)] _DebugView ("Debug View", Float) = 0
    }

    SubShader
    {
        Tags { "RenderType"="Transparent" "Queue"="Transparent-100" "RenderPipeline"="UniversalPipeline" }

        Pass
        {
            Name "Water"
            Tags { "LightMode"="UniversalForward" }
            Blend SrcAlpha OneMinusSrcAlpha
            ZWrite Off
            Cull Back

            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma shader_feature_local _REFRACTION
            #pragma shader_feature_local _NORMALS
            #pragma shader_feature_local_fragment _REFLECTION
            #pragma shader_feature_local_fragment _PLANAR_REFLECTION
            #pragma shader_feature_local_fragment _SPECULAR
            #pragma shader_feature_local_fragment _FOAM
            #pragma shader_feature_local_fragment _CAUSTICS
            #pragma shader_feature_local_vertex _GERSTNER
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE _MAIN_LIGHT_SHADOWS_SCREEN
            #pragma multi_compile_fragment _ _SHADOWS_SOFT _SHADOWS_SOFT_LOW _SHADOWS_SOFT_MEDIUM _SHADOWS_SOFT_HIGH
            #pragma multi_compile _ _FORWARD_PLUS
            #pragma multi_compile_fog

            #include "Assets/Cookbook/Ch19/WaterCore.hlsl"

            struct Attributes
            {
                float4 positionOS : POSITION;
                float3 normalOS   : NORMAL;
                float4 tangentOS  : TANGENT;
            };

            struct Varyings
            {
                float4 positionCS  : SV_POSITION;
                float3 positionWS  : TEXCOORD0;
                half3  normalWS    : TEXCOORD1;
                half3  tangentWS   : TEXCOORD2;
                half3  bitangentWS : TEXCOORD3;
                half   fogFactor   : TEXCOORD4;
            };

            Varyings vert(Attributes v)
            {
                Varyings o;
                float3 positionWS = TransformObjectToWorld(v.positionOS.xyz);
                // 平静水面：切线 +X、副切线 +Z、法线 +Y
                float3 tangent = float3(1, 0, 0);
                float3 binormal = float3(0, 0, 1);
            #if defined(_GERSTNER)
                float t = WaterTime();
                float3 p = positionWS;
                positionWS += GerstnerWave(_WaveA, p, t, tangent, binormal);
                positionWS += GerstnerWave(_WaveB, p, t, tangent, binormal);
                positionWS += GerstnerWave(_WaveC, p, t, tangent, binormal);
            #endif
                o.positionWS = positionWS;
                o.positionCS = TransformWorldToHClip(positionWS);
                o.tangentWS = normalize(tangent);
                o.bitangentWS = normalize(binormal);
                o.normalWS = normalize(cross(binormal, tangent));
                o.fogFactor = ComputeFogFactor(o.positionCS.z);
                return o;
            }

            half4 frag(Varyings i) : SV_Target
            {
                float t = WaterTime();
                float2 screenUV = GetNormalizedScreenSpaceUV(i.positionCS);
                half3 viewWS = GetWorldSpaceNormalizeViewDir(i.positionWS);
                float surfaceEye = LinearEyeDepth(i.positionWS, UNITY_MATRIX_V);
                Light mainLight = GetMainLight(TransformWorldToShadowCoord(i.positionWS));

                // ---- 法线 ----
                half3 normalTS = half3(0, 0, 1);
            #if defined(_NORMALS)
                normalTS = DualNormalTS(i.positionWS.xz, t);
            #endif
                half3x3 tbn = half3x3(i.tangentWS, i.bitangentWS, i.normalWS);
                half3 normalWS = normalize(mul(normalTS, tbn));

                // ---- 深度 ----
                WaterDepth wd = SampleWaterDepth(screenUV, i.positionWS);
                // 水体自身被照亮的颜色（散射色）：主光 + 环境光
                half3 waterLight = mainLight.color * saturate(mainLight.direction.y) * mainLight.shadowAttenuation + SampleSH(half3(0, 1, 0));
                half3 color;
                half alpha;

            #if defined(_REFRACTION)
                // ---- 折射 + 吸收（不透明合成：自己把“水下画面”算出来，alpha = 1）----
                float2 uvR = RefractUV(screenUV, normalTS, surfaceEye, wd.vertical);
                WaterDepth wdR = SampleWaterDepth(uvR, i.positionWS);
                half3 sceneColor = SampleSceneColor(uvR);
                #if defined(_CAUSTICS)
                sceneColor += Caustics(wdR.sceneWS, wdR.vertical, SceneUpFacing(wd.sceneWS), mainLight, t);
                #endif
                color = UnderwaterColor(sceneColor, wdR.path, _DeepColor.rgb * waterLight);
                // 岸线处和未扰动的画面过渡，避免水面边缘出现一条硬线
                color = lerp(SampleSceneColor(screenUV), color, saturate(wd.vertical / _EdgeFade));
                alpha = 1;
            #else
                // ---- 最简单的版本：按竖直水深在浅色和深色之间插值，靠 alpha 混合透出水底 ----
                half d01 = saturate(wd.vertical / _DepthMax);
                color = lerp(_ShallowColor.rgb, _DeepColor.rgb, d01) * waterLight;
                alpha = lerp(_ShallowColor.a, _DeepColor.a, d01) * saturate(wd.vertical / _EdgeFade);
            #endif

                // ---- 反射 ----
                half fresnel = _UseFresnel > 0.5 ? WaterFresnel(normalWS, viewWS) : 1.0h;
            #if defined(_REFLECTION)
                #if defined(_PLANAR_REFLECTION)
                    half3 reflection = SAMPLE_TEXTURE2D(_PlanarReflectionTex, sampler_PlanarReflectionTex,
                                                        screenUV + normalTS.xy * _PlanarDistortion).rgb;
                #else
                    half3 reflectDir = reflect(-viewWS, normalWS);
                    // Forward+ 下只有带屏幕 UV 的 5 参数版本（反射探针按屏幕分块查找），4 参数版本被 #if 掉了
                    half3 reflection = GlossyEnvironmentReflection(reflectDir, i.positionWS, _Roughness, 1.0h, screenUV);
                #endif
                half kr = fresnel * _ReflectionStrength;
                color = lerp(color, reflection, kr);
                alpha = lerp(alpha, 1.0h, kr);
            #endif

                // ---- 高光 ----
            #if defined(_SPECULAR)
                color += SunSpecular(mainLight, normalWS, viewWS);
            #endif

                // ---- 泡沫 ----
                half foam = 0;
            #if defined(_FOAM)
                foam = ShoreFoam(i.positionWS.xz, wd.vertical, normalTS, t);
                color = lerp(color, _FoamColor.rgb * waterLight, foam);
                alpha = max(alpha, foam);
            #endif

                // ---- 调试视图：把中间量直接画出来 ----
                if (_DebugView > 0.5)
                {
                    half3 dbg = 0;
                    if (_DebugView < 1.5)      dbg = saturate(wd.vertical / _DepthMax);
                    else if (_DebugView < 2.5) dbg = saturate(wd.path / _DepthMax);
                    else if (_DebugView < 3.5) dbg = half3(normalTS.xy * 1.5h + 0.5h, 0.5h);   // 放大切线空间 xy，看清纹理
                    else if (_DebugView < 4.5) dbg = foam;
                    else if (_DebugView < 5.5) dbg = CausticPattern(wd.sceneWS.xz * _CausticScale, t) * 0.5;
                    else                       dbg = fresnel;
                    return half4(dbg, 1);
                }

                color = MixFog(color, i.fogFactor);
                return half4(color, alpha);
            }
            ENDHLSL
        }
    }
}

// 水下深度：用水面这个像素的屏幕 UV 取场景深度，重建出水底的世界坐标
struct WaterDepth
{
    float3 sceneWS;     // 水底（或水中物体）表面的世界坐标
    float  vertical;    // 竖直水深 = 水面 y - 水底 y（与视角无关）
    float  path;        // 视线在水里走过的距离（与视角有关，斜看时更长）
    float  sceneEye;    // 场景的观察空间深度
};

WaterDepth SampleWaterDepth(float2 uv, float3 surfaceWS)
{
    WaterDepth o;
    float raw = SampleSceneDepth(uv);
    o.sceneWS = ComputeWorldSpacePosition(uv, raw, UNITY_MATRIX_I_VP);
    o.vertical = surfaceWS.y - o.sceneWS.y;
    o.path = distance(o.sceneWS, surfaceWS);
    o.sceneEye = LinearEyeDepth(raw, _ZBufferParams);
    return o;
}

WaterDepth wd = SampleWaterDepth(screenUV, i.positionWS);
half3 waterLight = mainLight.color * saturate(mainLight.direction.y) * mainLight.shadowAttenuation
                 + SampleSH(half3(0, 1, 0));
// ……
half d01 = saturate(wd.vertical / _DepthMax);
color = lerp(_ShallowColor.rgb, _DeepColor.rgb, d01) * waterLight;
alpha = lerp(_ShallowColor.a, _DeepColor.a, d01) * saturate(wd.vertical / _EdgeFade);

// 折射：按法线扰动屏幕 UV；如果扰动后取到的是“水面之上的东西”（深度比水面还近），说明发生了前景泄漏，退回原 UV
float2 RefractUV(float2 screenUV, half3 normalTS, float surfaceEye, float verticalDepth)
{
    // 越浅扰动越小：岸边几厘米深的水不该把岸上的东西扭得很厉害
    float2 offset = normalTS.xy * _RefractionStrength * saturate(verticalDepth * 2.0);
    // 远处的水在屏幕上更小，同样的偏移量会显得更夸张，除以深度做个近似的透视补偿
    offset /= max(1.0, surfaceEye * 0.25);
    float2 uv = screenUV + offset;
    if (_RefractLeakFix > 0.5)
    {
        float eye = LinearEyeDepth(SampleSceneDepth(uv), _ZBufferParams);
        if (eye < surfaceEye) uv = screenUV;
    }
    return uv;
}

// Beer-Lambert：光在水里每走 1 米，各通道按 exp(-σ) 衰减。红光衰减最快，所以深水偏蓝绿。
// 被吸收掉的部分用“散射色”补上（水体本身被照亮的颜色）
half3 UnderwaterColor(half3 sceneColor, float pathLength, half3 scatterColor)
{
    half3 transmittance = exp(-_Absorption.rgb * pathLength);
    return sceneColor * transmittance + scatterColor * (1.0h - transmittance);
}

// 双层法线：同一张 water_normal 以不同尺度、不同方向流动，两层叠加打破重复感
half3 DualNormalTS(float2 xz, float t)
{
    float2 uvA = xz * _NormalTiling.x + _FlowA.xy * t;
    float2 uvB = xz * _NormalTiling.y + _FlowB.xy * t;
    half3 nA = UnpackNormalScale(SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, uvA), _FlowA.z);
    half3 nB = UnpackNormalScale(SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, uvB), _FlowB.z);
    // Whiteout 混合：xy 相加、z 相乘，比简单平均保留更多细节（第 7 章有对比）
    return normalize(half3(nA.xy + nB.xy, nA.z * nB.z));
}

public static Texture2D Create(int size = 256, float strength = 3.5f)
{
    if (s_Cached != null) return s_Cached;
    var h = new float[size, size];
    // 整数波矢 (kx, ky)：在一个贴图周期里正好走完整数个波长，左右/上下边界自然衔接。
    // 方向大致集中在“风向”附近，看起来才像被风吹出来的水纹
    int[,] k = { { 3, 1 }, { 2, 3 }, { 4, -1 }, { 5, 2 }, { 3, 5 }, { 6, -3 }, { 7, 4 }, { -2, 6 },
                 { 9, 2 }, { 8, 7 }, { 11, -4 }, { 5, 10 }, { 13, 3 }, { -7, 11 } };
    var rnd = new System.Random(19);
    var phase = new float[k.GetLength(0)];
    for (int i = 0; i < phase.Length; i++) phase[i] = (float)rnd.NextDouble() * Mathf.PI * 2;

    for (int y = 0; y < size; y++)
        for (int x = 0; x < size; x++)
        {
            float u = (float)x / size, v = (float)y / size, sum = 0;
            // 域扭曲：用周期噪声扰动相位，打破正弦叠加的“格子布”感（噪声是周期的，所以仍然无缝）
            float warp = PeriodicNoise(u, v, 4, 7) * 2.2f + PeriodicNoise(u, v, 8, 8) * 1.1f;
            for (int i = 0; i < phase.Length; i++)
            {
                float kx = k[i, 0], ky = k[i, 1];
                float amp = 1f / Mathf.Sqrt(kx * kx + ky * ky);
                sum += amp * Mathf.Sin(2 * Mathf.PI * (kx * u + ky * v) + phase[i] + warp);
            }
            // 再叠几层周期性值噪声（fBm）
            sum += 0.3f * PeriodicNoise(u, v, 8, 1) + 0.15f * PeriodicNoise(u, v, 16, 2) + 0.08f * PeriodicNoise(u, v, 32, 3);
            h[x, y] = sum;
        }

    var px = new Color[size * size];
    for (int y = 0; y < size; y++)
        for (int x = 0; x < size; x++)
        {
            // 中心差分，坐标按周期回绕
            float dx = (h[(x + 1) % size, y] - h[(x - 1 + size) % size, y]) * 0.5f * strength;
            float dy = (h[x, (y + 1) % size] - h[x, (y - 1 + size) % size]) * 0.5f * strength;
            var n = new Vector3(-dx, -dy, 1).normalized;
            // R=x、G=y、B=z、A=1。URP 的 UnpackNormalScale 在桌面平台走 UnpackNormalmapRGorAG：
            // 先 a *= r 再取 (a, g)，A=1 时得到的正好是 (r, g)，所以这种未压缩的 RGBA 也能正确解码
            px[y * size + x] = new Color(n.x * 0.5f + 0.5f, n.y * 0.5f + 0.5f, n.z * 0.5f + 0.5f, 1);
        }

    s_Cached = new Texture2D(size, size, TextureFormat.RGBA32, true, true)
    {
        name = "WaterNormal_Tileable", wrapMode = TextureWrapMode.Repeat,
        filterMode = FilterMode.Trilinear, anisoLevel = 4, hideFlags = HideFlags.DontSave
    };
    s_Cached.SetPixels(px);
    s_Cached.Apply(true);
    return s_Cached;
}

// Schlick 菲涅尔。水的折射率约 1.33，F0 = ((1.33-1)/(1.33+1))² ≈ 0.02：正看几乎全透，掠射角几乎全反
half WaterFresnel(half3 normalWS, half3 viewWS)
{
    half NdotV = saturate(dot(normalWS, viewWS));
    return 0.02h + 0.98h * pow(1.0h - NdotV, 5.0h);
}

// 摘自 URP 14 ShaderLibrary/GlobalIllumination.hlsl（节选）
half3 GlossyEnvironmentReflection(half3 reflectVector, float3 positionWS, half perceptualRoughness,
                                  half occlusion, float2 normalizedScreenSpaceUV) { ... }

#if !USE_FORWARD_PLUS
half3 GlossyEnvironmentReflection(half3 reflectVector, float3 positionWS, half perceptualRoughness, half occlusion)
{ ... }
#endif

// 太阳高光：Blinn-Phong，指数很高（水面很光滑），乘上阴影，让高光不会出现在柱子的影子里
half3 SunSpecular(Light light, half3 normalWS, half3 viewWS)
{
    half3 h = SafeNormalize(light.direction + viewWS);
    half spec = pow(saturate(dot(normalWS, h)), _SpecPower);
    // 能量归一化的近似系数 (n+8)/(8π)，让指数变大时高光变小但更亮（第 5 章）
    spec *= (_SpecPower + 8.0h) / (8.0h * PI);
    return light.color * spec * _SpecIntensity * light.shadowAttenuation;
}

// 岸边泡沫 = 贴岸的一条实心带 + 一圈圈向岸边推进的细线，都用噪声打散
half ShoreFoam(float2 xz, float verticalDepth, half3 normalTS, float t)
{
    half shore = saturate(verticalDepth / _FoamDistance);          // 0 在岸线，1 在泡沫带外沿
    float2 uv = xz * _FoamTiling + normalTS.xy * 0.1 + float2(t * 0.02, t * 0.015);
    half n = SAMPLE_TEXTURE2D(_FoamNoise, sampler_FoamNoise, uv).r;

    // ① 实心带：阈值被噪声上下扰动，边缘呈不规则的锯齿
    half core = 1.0h - smoothstep(0.25h - _FoamSoftness, 0.25h + _FoamSoftness, shore + (n - 0.5h) * 0.35h);
    // ② 推进线：shore 是“离岸距离”，减去时间就得到一圈圈朝岸边移动的等深线
    half ripple = frac(shore * 2.5h - t * 0.3h + n * 0.6h);
    half lines = smoothstep(0.8h, 0.9h, ripple) * step(0.45h, n) * (1.0h - shore);
    return saturate(core + lines);
}

// 程序化焦散：Voronoi 的 F2-F1 在细胞边界处接近 0，取反后就是一张亮线网，很像焦散的光网
float2 VoronoiF1F2(float2 p, float t)
{
    float2 cell = floor(p), f = frac(p);
    float F1 = 8.0, F2 = 8.0;
    [unroll] for (int j = -1; j <= 1; j++)
    [unroll] for (int i = -1; i <= 1; i++)
    {
        float2 g = float2(i, j);
        float2 o = Hash22(cell + g);
        o = 0.5 + 0.45 * sin(t + 6.2831 * o);      // 特征点绕各自中心转圈，图案就“活”了
        float2 r = g + o - f;
        float d = dot(r, r);
        if (d < F1) { F2 = F1; F1 = d; }
        else if (d < F2) { F2 = d; }
    }
    return sqrt(float2(F1, F2));
}

half CausticPattern(float2 p, float t)
{
    float2 v1 = VoronoiF1F2(p, t);
    float2 v2 = VoronoiF1F2(p * 1.43 + 7.1, t * 1.21);
    half c1 = 1.0h - smoothstep(0.0h, 0.18h, v1.y - v1.x);
    half c2 = 1.0h - smoothstep(0.0h, 0.18h, v2.y - v2.x);
    // 两层叠加：交叉处更亮，形成焦散特有的“亮节点”
    return c1 * c1 + c2 * c2 + 2.0h * c1 * c2;
}

// 把焦散投到水下表面：沿主光方向把水底点“投影回”水面，在那里查图案，图案就会随太阳方向偏移
half3 Caustics(float3 sceneWS, float verticalDepth, half upFacing, Light light, float t)
{
    float3 L = light.direction;
    float2 p = sceneWS.xz + L.xz / max(L.y, 0.2) * verticalDepth;
    p *= _CausticScale;
    // RGB 三个通道错开一点点采样，模拟不同波长折射角不同产生的色散
    float2 split = float2(_CausticSplit, _CausticSplit * 0.5);
    half3 c = half3(CausticPattern(p + split, t), CausticPattern(p, t), CausticPattern(p - split, t));
    // 刚入水时焦散还没聚焦，太深又被吸收：用两个衰减把它限制在“中间深度”
    half fade = saturate(verticalDepth * 4.0) * exp(-verticalDepth / _CausticDepthFade);
    // 只有朝上的面才接到焦散（upFacing 由调用方用屏幕导数求出，见 SceneUpFacing）
    fade *= upFacing;
    // 阴影要在水底那一点上查：柱子的影子里不该有焦散
    half shadow = MainLightRealtimeShadow(TransformWorldToShadowCoord(sceneWS));
    return c * fade * _CausticIntensity * light.color * shadow;
}