《体积云与大气散射：Raymarching、Beer-Lambert 与相位函数》

// GLSL：基础体积 Raymarching 骨架
vec4 raymarchVolume(vec3 rayOrigin, vec3 rayDir, float maxDist) {
    float t = 0.0;
    vec3 scatteredLight = vec3(0.0);   // 累加散射光
    float transmittance = 1.0;         // 当前透射率

    for (int i = 0; i < MAX_STEPS; ++i) {
        vec3 pos = rayOrigin + rayDir * t;
        float density = sampleDensity(pos);          // 介质密度
        if (density > 0.001) {
            vec3 lit = integrateLightAt(pos);        // 该点的入射散射光
            float sigma_t = density * extinctionCoeff; // 消光系数
            float sampleTrans = exp(-sigma_t * stepSize);
            // 能量守恒的解析积分（而非简单相乘）
            float clampedExt = max(sigma_t, 1e-4);
            vec3 S = lit * sigma_s / clampedExt;      // 源项
            scatteredLight += transmittance * (1.0 - sampleTrans) * S;
            transmittance *= sampleTrans;
        }
        t += stepSize;
        if (transmittance < 0.01) break;              // 提前退出
    }
    return vec4(scatteredLight, transmittance);
}

// 蓝噪声抖动：打散条带
float blueNoise = texture(blueNoiseTex, gl_FragCoord.xy / 64.0).r;
float t = stepSize * blueNoise;   // 起点随机偏移

// HLSL：一步内的解析积分，能量更准确
float3 IntegrateScatteringWithinSegment(float3 sigmaS, float3 sigmaT, float stepSize) {
    // 单段透射率
    float3 transmittance = exp(-sigmaT * stepSize);
    // 单段散射积分：∫ sigmaS * exp(-sigmaT * s) ds, s in [0, stepSize]
    float3 integrated = (sigmaS / max(sigmaT, 1e-5)) * (1.0 - transmittance);
    return integrated;
}

// GLSL：Henyey-Greenstein 相位函数
float phaseHG(float cosTheta, float g) {
    float g2 = g * g;
    float denom = 1.0 + g2 - 2.0 * g * cosTheta;
    return (1.0 - g2) / (4.0 * PI * pow(max(denom, 1e-4), 1.5));
}

// 云常用双叶 HG：前向瓣 + 后向瓣叠加，模拟多重散射
float phaseCloud(float cosTheta) {
    const float gF = 0.8;    // 前向
    const float gB = -0.5;   // 后向
    return mix(phaseHG(cosTheta, gF), phaseHG(cosTheta, gB), 0.5);
}

// GLSL：瑞利相位函数
float phaseRayleigh(float cosTheta) {
    return (3.0 / (16.0 * PI)) * (1.0 + cosTheta * cosTheta);
}

Transmittance LUT 参数化：
  u_r  = 归一化高度  (r - Rg) / (Rt - Rg)      // 地表到大气顶
  u_mu = 天顶角余弦 μ = cos(θ_view)
  存储值 = exp(-∫ σ_t ds)  三通道 RGB

// GLSL：从 LUT 采样天空颜色
vec3 computeSkyColor(vec3 worldDir, vec3 sunDir, float camHeight) {
    float r = length(camPos + worldDir * 0.0) ;      // 相机高度
    float mu = dot(normalize(worldDir), normalize(camPos));
    float uR = (r - Rg) / (Rt - Rg);
    vec3 transmittance = texture(transmittanceLut, vec2(mu * 0.5 + 0.5, uR)).rgb;

    // 散射 LUT：需要 (高度, 视线天顶角, 视线-太阳夹角)
    float muS = dot(normalize(worldDir), sunDir);
    vec3 inscatter = sampleScatteringLUT(r, mu, muS);

    return inscatter * sunIntensity;
}

// GLSL：3D Worley 噪声（F1 距离）
float worley3D(vec3 p) {
    vec3 cell = floor(p);
    vec3 local = fract(p);
    float minDist = 1.0;
    for (int x = -1; x <= 1; ++x)
    for (int y = -1; y <= 1; ++y)
    for (int z = -1; z <= 1; ++z) {
        vec3 neighbor = vec3(x, y, z);
        vec3 featurePoint = neighbor + hash3(cell + neighbor);
        float d = length(featurePoint - local);
        minDist = min(minDist, d);
    }
    return minDist;
}

// GLSL：云密度函数
float cloudDensity(vec3 pos) {
    // 高度归一化：0 = 云底, 1 = 云顶
    float heightFrac = (pos.y - cloudBottom) / (cloudTop - cloudBottom);
    // 高度梯度：底部和顶部衰减
    float heightGradient = smoothstep(0.0, 0.15, heightFrac)
                         * smoothstep(1.0, 0.65, heightFrac);
    if (heightGradient <= 0.0) return 0.0;

    // 基础形状：低频 Worley + Perlin
    float baseShape = worley3D(pos * 0.05) * 0.6 + fbm(pos * 0.1) * 0.4;
    // 侵蚀：高频噪声减去，让边缘破碎
    float erosion = fbm(pos * 0.4) * 0.35;
    // 高度重映射：让底部密度更高
    float density = remap(baseShape, erosion, 1.0, 0.0, 1.0) * heightGradient;

    return clamp(density, 0.0, 1.0);
}

// GLSL：单次散射光照
vec3 lightMarch(vec3 pos, vec3 sunDir) {
    float opticalDepth = 0.0;
    for (int i = 0; i < LIGHT_STEPS; ++i) {
        vec3 p = pos + sunDir * (i + 0.5) * lightStepSize;
        opticalDepth += sampleDensity(p) * lightStepSize;
    }
    float transmittance = exp(-opticalDepth * extinctionCoeff);
    // 相位函数调制
    float phase = phaseCloud(dot(rayDir, sunDir));
    return sunColor * transmittance * phase * sunIntensity;
}

// GLSL：Beer's Powder 近似，让云边缘透光
float powder = 1.0 - exp(-density * 2.0 * stepSize);
float beer = exp(-opticalDepth);
float light = mix(beer, beer * powder, 0.5);

// C++：UE5 风格的体积云分辨率控制
struct FVolumetricCloudParams {
    float ResolutionScale = 0.5f;   // 半分辨率
    int32 MaxRaymarchSteps = 64;
    int32 LightMarchSteps = 6;
    bool  bTemporalReprojection = true;
    bool  bCheckerboard = true;     // 棋盘渲染，隔行更新
};