《水面与海洋渲染：FFT 频谱、Gerstner 波与菲涅尔》

// C++：海洋系统的分层结构
struct FOceanSettings {
    // 大尺度：FFT 频谱
    int   FFTResolution      = 256;    // 256x256 复数网格
    float PatchSize          = 1000.0f; // 每 patch 覆盖米数
    float WindSpeed          = 12.0f;   // m/s
    float WindDirection      = 45.0f;   // 度
    float Amplitude          = 1.0f;
    float Choppiness         = 1.2f;    // 尖化，制造浪尖

    // 小尺度：细节法线
    float DetailNormalScale  = 8.0f;
    float DetailNormalSpeed  = 0.5f;

    // 着色
    float WaterDepth         = 20.0f;   // 用于吸收/散射
    float FoamThreshold      = 0.6f;
};

// GLSL：单个 Gerstner 波对顶点位置与法线的贡献
struct GerstnerWave {
    vec2  direction;   // 归一化波向
    float amplitude;   // A
    float wavelength;  // λ
    float steepness;   // Q, 0..1
    float speed;
};

void gerstnerWave(GerstnerWave w, vec3 pos, float t,
                  inout vec3 displaced, inout vec3 normal) {
    float k = 2.0 * PI / w.wavelength;
    float c = sqrt(9.8 / k);                       // 相速度
    vec2  d = normalize(w.direction);
    float f = k * (dot(d, pos.xz) - c * w.speed * t);
    float a = w.steepness / k;                     // 尖化幅度

    // 水平位移（Gerstner 的核心）
    displaced.x += d.x * a * cos(f);
    displaced.z += d.y * a * cos(f);
    // 垂直位移
    displaced.y += a * sin(f);

    // 解析法线（对位置求偏导）
    float wa = k * a;
    normal.x -= d.x * wa * cos(f);
    normal.z -= d.y * wa * cos(f);
    normal.y -= w.steepness * wa * sin(f);
}

Phillips 频谱（简化）：
  P(k) = A · exp(-1/(k·L)²) / k⁴ · |k̂ · ŵ|²
  L = V²/g             // 最大波长，V 风速
  高斯随机数 × √P(k)   → 初始复振幅

// GLSL：在 compute shader 中演化频谱并准备逆 FFT
// h0(k) 与 h0(-k) 由 CPU/初始化阶段生成
vec2 htilde(vec2 k, float t, vec2 h0k, vec2 h0MinusK) {
    float omega = sqrt(9.81 * length(k));
    float cosw = cos(omega * t);
    float sinw = sin(omega * t);
    // 共轭项旋转
    vec2 a = vec2(h0k.x * cosw - h0k.y * sinw, h0k.x * sinw + h0k.y * cosw);
    vec2 b = vec2(h0MinusK.x * cosw + h0MinusK.y * sinw,
                 -h0MinusK.x * sinw + h0MinusK.y * cosw);
    return a + b;
}

// HLSL：从高度场生成位移与泡沫
float3 BuildDisplacement(float2 uv, float choppiness, out float foam) {
    float2 grad = GetHeightGradient(uv);            // ∂h/∂x, ∂h/∂z
    float3 disp = float3(-grad.x * choppiness, GetHeight(uv), -grad.y * choppiness);

    // Jacobian 折叠 → 泡沫
    float2 dDx = GetDisplacementDx(uv);
    float2 dDz = GetDisplacementDz(uv);
    float jacobian = (1.0 + dDx.x) * (1.0 + dDz.y) - dDx.y * dDz.x;
    foam = saturate(1.0 - jacobian * 4.0);          // 折叠越强泡沫越多
    return disp;
}

// C++：镜像相机矩阵
glm::mat4 BuildReflectionMatrix(const glm::vec4& plane) {
    // plane = (n.x, n.y, n.z, d)，水面 y = h
    glm::mat4 R(1.0f);
    R[0][0] = 1 - 2 * plane.x * plane.x;
    R[0][1] = -2 * plane.x * plane.y;
    // ... 其余元素按平面反射公式填充
    R[3][1] = -2 * plane.w * plane.y;
    return R;
}

// GLSL：屏幕空间折射
vec2 ScreenSpaceRefraction(vec2 screenUV, vec3 normal, float depth) {
    // 扰动强度随深度衰减，浅水折射强
    float distortion = RefractionStrength / (depth + 1.0);
    vec2 offset = normal.xz * distortion;
    return texture(sceneColor, screenUV + offset).rgb;
}

// GLSL：Schlick 菲涅尔
vec3 FresnelSchlick(float cosTheta, vec3 F0) {
    return F0 + (1.0 - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0);
}

vec3 ShadeWater(vec3 N, vec3 V, vec3 L, vec3 reflection, vec3 refraction) {
    float cosTheta = max(dot(N, V), 0.0);
    vec3 F = FresnelSchlick(cosTheta, vec3(0.02));

    // 漫反射水体色 + 高光
    vec3 diffuse = waterAlbedo * (1.0 - F);
    vec3 specular = reflection * F;
    vec3 transmitted = refraction * (1.0 - F) * waterTransmittance;

    vec3 H = normalize(L + V);
    float NdotH = max(dot(N, H), 0.0);
    vec3 sunSpec = sunColor * pow(NdotH, 512.0) * specularStrength;

    return diffuse + specular + transmitted + sunSpec;
}

// GLSL：按深度吸收，得到水体颜色
vec3 WaterAbsorption(float depth, vec3 waterColor, vec3 extinction) {
    // 视深度（视线穿过的水柱长度）
    float viewDepth = depth / max(dot(N, V), 0.1);
    return waterColor * exp(-extinction * viewDepth);
}

// GLSL：简化的水体次表面散射
vec3 WaterSSS(vec3 N, vec3 V, vec3 L, float thickness) {
    vec3 H = normalize(L + N * distortionStrength);
    float VdotH = pow(saturate(dot(V, -H)), power) * scale;
    float backLight = VdotH * saturate(dot(V, L));
    return sssColor * backLight * thickness;
}

// GLSL：岸边泡沫（基于深度差）
float ShoreFoam(float sceneDepth, float waterDepth, float threshold) {
    float depthDiff = sceneDepth - waterDepth;   // 越浅越小
    float foam = 1.0 - smoothstep(0.0, threshold, depthDiff);
    return foam * noiseFoam;                     // 叠加噪声打碎
}

// GLSL：水面软边缘，避免硬切
float SoftEdge(float sceneDepth, float waterDepth, float fadeDistance) {
    float diff = sceneDepth - waterDepth;
    return saturate(diff / fadeDistance);
}

// C++：patch 网格，中心高精度
struct FOceanPatch {
    float CenterX, CenterZ;
    float Size;          // 覆盖范围
    int   FFTRes;        // 该 patch 的 FFT 分辨率（LOD）
};
// 相机移动超过阈值时，把最远的 patch 移到前方（环形缓冲）