NEKOPARTY STUDIO

NEKOPARTY STUDIO

Godot高性能完整物理天空+体积云实现（下）

Godot高性能完整物理天空+体积云实现（下）

Godot 计算机图形

字数统计: 4k阅读时长: 16 min

 2026/06/04   Share

• 
• 
• 
• 
• 

前言

此天空实现大量参考了Godot源码主要贡献者ClayJohn在一个开源Repo里的实现，并作出了大量修改和扩展。本文会详细解析他的实现并说明我自己做了什么样的内容以及扩展。

现在的天空包含完整的基于物理的昼夜循环，以及高质量（几乎无噪音）的体积云渲染，且速度极快。

这套实现天空部分比较标准，但是体积云部分的渲染策略非常罕见，性能比起3A游戏的普遍标准是数量级级别的好（ClayJohn自己的代码就是这种实现，我基本抄了），但是也有相当的局限性（我通过一些Trick进行了改进，但是治标不治本），是一个需要取舍的工程问题。

如果你需要一个标准的3A级别的体积云实现，你可以使用GodotAssetLib里面的SunshineClouds这个插件。但是这个插件性能问题不小，且云的降噪写的质量比较差，实际视觉效果可能不理想。如果你没有这么高要求的体积云，其实可以看看我这篇（的下一篇）

上文我们分析了天空的渲染部分，现在我们来详细说明体积云的渲染过程，这部分内容比较复杂，本来想再分上下篇，但是这篇拖太久了，下面还有一部分新的关于体积云的内容，想了想还是合一块了。

云建模

ClayJohn的实现中，云建模基本是完全参考《地平线：零之曙光》的Nubis体积云方案，是一个经典解法。

实际要做的事情就是提供一个density()函数。通过这个函数能够取到空间中任意位置的云的密度。用以做光线步进或者什么别的事情。

首先，云被限制在两个同心球壳之间

const float g_radius          = 6000000.0;  // 地面
const float base_sky_b_radius = 6001500.0;  // 云层底  (1500m)
const float base_sky_t_radius = 6004000.0;  // 云层顶  (4000m)

通过这个函数去取某个坐标在云层范围里的相对高度：

float GetHeightFractionForPoint(float inPosition) {
    float h = (inPosition - sky_b_radius()) / (sky_t_radius() - sky_b_radius());
    return clamp(h, 0.0, 1.0);   // 0 = 云层底, 1 = 云层顶
}

建模过程用到了三张噪声纹理，perlworlnoise.tga作为large_scale_noise使用。它的R通道作为主轮廓，GBA是多频FBM噪声，是3D纹理。worlnoise.bmp作为small_scale_noise，是多频 Worley灶神。还有一张weather.bmp作为天气噪声，用于采样获得云类型和云覆盖度的系数，这个是2D噪声。三张图预览效果如下：

这几张有点眼熟🤣，就先不考据出处了。

实现里对云的形状进行了区分，三种云定义了三种不同的云垂直梯度。在mixGradients函数里计算它。

const vec4 STRATUS_GRADIENT       = vec4(0.02, 0.05, 0.09, 0.11);  // 层云：贴底很薄
const vec4 STRATOCUMULUS_GRADIENT = vec4(0.02, 0.2,  0.48, 0.625); // 层积云：一般的云
const vec4 CUMULUS_GRADIENT       = vec4(0.01, 0.0625, 0.78, 1.0); // 积云：鼓鼓的云

每个 vec4 是四个高度阈值 (x,y,z,w)，定义一条”梯形”曲线的四个拐点。cloudType（来自天气图 R 通道）在 0~1 之间，用三角权重在三种梯度间插值：

float stratus       = 1.0 - clamp(cloudType * 2.0, 0.0, 1.0);   // type=0 时为 1
float stratocumulus = 1.0 - abs(cloudType - 0.5) * 2.0;          // type=0.5 时为 1
float cumulus       = clamp(cloudType - 0.5, 0.0, 1.0) * 2.0;    // type=1 时为 1
return STRATUS*stratus + STRATOCUMULUS*stratocumulus + CUMULUS*cumulus;

其中，cloudType=0 代表层云，cloudType=0.5 代表层积云，cloudType=1 代表积。

之后会把梯度转换为密度乘子

float densityHeightGradient(float heightFrac, float cloudType) {
    vec4 g = mixGradients(cloudType);
    return smoothstep(g.x, g.y, heightFrac) - smoothstep(g.z, g.w, heightFrac);
}

说白了，这个步骤其实就是按高度计算出一个密度的比例值。云层两边薄中间厚的效果就是靠这个得来的。

最后将所有组件组合起来，得到density()函数。

先取高度分数

vec3 p = pip;
float height_fraction = GetHeightFractionForPoint(length(p));

施加基础风力让云慢慢平移

p.xz += params.time * 20.0 * normalize(params.wind_direction) * params.wind_speed * 0.6;

采样前文所说的large_scale_noise来获得轮廓

vec4 n = textureLod(large_scale_noise, p * 0.00008 * noise_scales.x + offset, mip - 2.0);
float fbm = n.g * 0.625 + n.b * 0.25 + n.a * 0.125;   // 用 GBA 三个频率合成 FBM

然后用梯度+Noise+WeatherMap来获得最终的云。

float g = densityHeightGradient(height_fraction, weather.r);   // 垂直窗
float base_cloud = remap(n.r, -(1.0 - fbm), 1.0, 0.0, 1.0);    // 用 fbm 扰动下界
float weather_coverage = params.cloud_coverage * weather.b;     // 全局×天气图
base_cloud = remap(base_cloud * g, 1.0 - weather_coverage, 1.0, 0.0, 1.0);
base_cloud *= weather_coverage;

之后再整点更细节的小风

p.xz -= params.time * normalize(params.wind_direction) * 40.;
p.y  -= params.time * 40;

再用小噪声做边缘侵蚀

vec3 hn = textureLod(small_scale_noise, p * 0.001 * noise_scales.y + offset, mip).rgb;
float hfbm = hn.r * 0.625 + hn.g * 0.25 + hn.b * 0.125;        // 又一个 FBM
hfbm = mix(hfbm, 1.0 - hfbm, clamp(height_fraction * 4.0, 0.0, 1.0));  // 高处反转
base_cloud = remap(base_cloud, hfbm * 0.4 * height_fraction, 1.0, 0.0, 1.0);

最后用pow进行一个塑形，让底部实一点，顶部虚一点。

return pow(clamp(base_cloud, 0.0, 1.0), (1.0 - height_fraction)*0.8 + 0.5);

这样整个密度部分就完成了。

光照计算

光照部分其实是要解体积渲染方程。沿一条视线，进入眼睛的光是沿途每一点散射进来的光、再被前面的云衰减后的累加。

$$
L = \int_0^D \underbrace{T(0 \to s)}{\text{视线透射率}}; \underbrace{\sigma_s(s)}{\text{散射}}; \underbrace{L_{\text{in}}(s)}_{\text{该点收到的光}}, ds
$$

其中视线透射率按 Beer-Lambert计算，即

$$
T(0\to s) = \exp!\big(-\int_0^s \sigma_t,dx\big)
$$

march()的全部工作就是离散算积分。

在开始循环前，需要进行一些准备工作。为了消除离散步长产生的条带问题，可以通过添加抖动来解决这个问题。

float ss = length(dir);          // 步长（dir 传进来时带长度）
dir = normalize(dir);
vec3 p = pos + dir * hash(pos * 10.0) * ss;   // 起点随机抖动一个步长内

不过需要说明的是，ClayJohn自己的实现里没有这部分，由于这个实现的特殊性，你不加这玩意也看不太出来。我自己为了一些特殊情景的观感还是加上了。

用于计算自阴影的光线步长。

float t_dist = sky_t_radius() - sky_b_radius();   // 云层厚度 2500m
float lss = t_dist / 64.0;                          // 朝光源采样的步长 ≈ 39m
vec3 ldir = normalize(params.LIGHT_DIRECTION);

注意这个和视线出发的步长不同，这个是计算朝太阳方向走被上方的云挡了多少光用的。

云是强前向散射介质，即光大多继续沿原方向走，所以背光看云边会发亮。用 Henyey-Greenstein 相位函数来处理这个事情：

float henyey_greenstein(float cos_theta, float g) {
    const float k = 0.0795774715459;   // 1/(4π)
    return k * (1.0 - g*g) / pow(1.0 + g*g - 2.0*g*cos_theta, 1.5);
}

g>0 就是前向。

这边使用双瓣HG，一个是上文所说的强前向，另一个做后向的，用于实现那种“背光轮廓光”的效果。

float dual_lobe_hg(float cos_theta, float g_forward, float g_back, float w) {
    return mix(henyey_greenstein(cos_theta, g_forward),    // 0.8 强前向：晴空高光
               henyey_greenstein(cos_theta, g_back), w);   // -0.5 后向：银边
}

纯为了好看，做了个银边效果的增强。这个效果是太阳/月亮附近那一圈的云的边缘亮度会增加。

float silver_weight = 0.5 + 0.5 * smoothstep(0.0, 1.0, -costheta);
float phase = dual_lobe_hg(costheta, 0.8, -0.5, 0.3) * mix(1.0, 1.5, silver_weight);

这两部分都是我自己往ClayJohn的实现上加的。他的实现看上取云不论什么时候都有点灰灰的，所以我做了这些增强。

之后就是从skyLUT取光的颜色。

vec3 atmosphere_sun     = getValFromSkyLUT(LIGHT_DIRECTION) * 0.1 * LIGHT_ENERGY * LIGHT_COLOR; // 太阳方向的天空色 = 直射光色
vec3 atmosphere_ambient = getValFromSkyLUT(vec3(1,1,0)) * 0.05;        // 天顶色 = 顶部环境光
atmosphere_ambient = mix(atmosphere_ambient, vec3(length(...)), 0.5);  // 往白拉一半，避免过蓝
vec3 atmosphere_ground  = getValFromSkyLUT(vec3(1,-1,0)) * 5.0 * 0.05; // 地平线下 = 底部环境光
atmosphere_ground = mix(atmosphere_ground, ground_color * ..., 0.5);   // 混入地面反照色

所以这个云实现和天空基本是强制耦合的。

下面就是主循环部分，老生常谈的沿着视线方向做RayMarch。

for (int i = 0; i < depth; i++) {
    p += dir * ss;
    vec3 weather_sample = texture(weather_noise, ...).xyz;
    float height_fraction = GetHeightFractionForPoint(length(p));

    t = density(p, weather_sample, 0.0);     // 这一点的云浓度（上一节的 density）
    float dt = exp(-params.density * t * ss); // 这一步的透射率（Beer-Lambert）

    if (t > 0.0) {            // 只在云里才算光照（省性能）
        ... 自阴影 + 多重散射 + 累加 ...
    }
}

自阴影部分即每个点也要朝着光源方向采样一定步数。

vec3 blend_ldir = mix(ldir, moon_dir, night_blend);   // 昼夜混合的光向
for (int j = 0; j < 6; j++) {
    lp += (blend_ldir + RANDOM_VECTORS[j] * float(j)) * lss;   // 锥形扩散
    lt = density(lp, lweather, float(j));
    cd += lt;     // 累积朝光源的光学深度
}

注意到有RANDOM_VECTORS[j] * j，这说明越往光源走，偏移越大。这是因为采样点呈锥形发散而非一条直线。模拟了光的散射锥，比直线采样自阴影更软。除此之外，density(lp, lweather, float(j))可以看出 mip 随 j 增大用于省性能。

除此之外，还进行了一次粗略的远处阴影采样。

lp = p + blend_ldir * 18.0 * lss;     // 朝光源跳很远（18 步）
lt = pow(density(lp, lweather, 5.0), ...);  // 高 mip
cd += lt;

在这之后，就是通过 Beer-Powder 与多重散射来计算云本身。Beer指的是 exp(-density·cd) 的做法，即光被遮挡越多越暗。Powder 即1 - exp(-density·cd·2)，是个经验补偿，模拟云朝光面边缘反而偏暗的暗边效应。

单次散射会让云的中间调很灰。真实云里光弹很多次，从内部漏出来，把灰色提亮。这里用 3 个倍频近似，是Wrenninge/Frostbite的做法。

const int MS_OCTAVES = 3;
const float MS_A = 0.5;  // 每层衰减消光
const float MS_B = 0.5;  // 每层降低相位各向异性
const float MS_C = 0.7;  // 每层降低能量

float a_n=1.0, b_n=1.0, c_n=1.0;
for (int n = 0; n < MS_OCTAVES; n++) {
    float beers_n  = exp(-density * cd * lss * 3.0 * a_n);
    float powder_n = 1.0 - exp(-density * cd * lss * 3.0 * 2.0 * a_n);
    float phase_n  = mix(phase_sun_n, phase_moon_n, night_blend);  // 各向异性随 b_n 减弱
    ms_light += c_n * 2.0 * beers_n * powder_n * primary_light * phase_n;
    a_n *= MS_A; b_n *= MS_B; c_n *= MS_C;
}

最后就是环境光和散射累加。

vec3 ambient = mix(ground_light, ambient_light, smoothstep(0.0, 1.0, height_fraction));
alpha += (1.0 - dt) * (1.0 - alpha);
vec3 radiance = (ambient + ms_light) * t;
L += T * (radiance - radiance * dt) / max(0.0000001, t);
T *= dt;

按云层厚度施加一个底部到顶部的环境光颜色。

不过March的步数不是固定的，由调用方根据视线穿过云层的实际厚度决定。

float shelldist = interval.y - interval.x;        // 视线在云层里的长度
float target_step = (sky_t_radius() - sky_b_radius()) / 64.0;  // 目标 ~40m/步
int steps = clamp(int(shelldist / target_step), 32, 192);       // 下限32 上限192
vec3 raystep = ndir * shelldist / float(steps);
col = march(start, end, raystep, steps);

接近地平线的地方多给点步数，正上方的区域就少给点步数。

这样云的渲染部分就完成了，还是个比较标准的实现。下面我们具体说一下这个实现的神奇Trick。

邪道大合集

所谓八面体贴图，其实只是球体投影的一个方式。完整的球面投影方式如图所示：

不过对于我们的实现，其实还能进一步节约。考虑到云只会生成在天空的上半球面，我们可以只取图中的上半球，然后可以发现投影图就只生下了一个菱形。我们将它旋转45度就能变成一个正方形了。

这个实现做的事情就是把云的渲染结果写入这个正方形作为贴图，然后Sky Shader去采样这个贴图，将云合成到天空上。所以说这个实现本质上和实际渲染分辨率是解耦的，性能也非常容易调整。

着色器里是这么进行编码和解码的：

vec2 vec3_to_oct(vec3 e) {
    e /= abs(e.x) + abs(e.y) + abs(e.z);          // 第1步：L1 归一化 → 投到八面体
    e.xy = e.z >= 0.0 ? e.xy : oct_wrap(e.xy);    // 下半球折叠(本实现用不到)

    vec2 n;                                         // 第3步：旋转45° + 缩放到[0,1]²
    n.y = e.y * 0.5 + 0.5;
    n.x = e.x * 0.5 + n.y;     // = 0.5 + 0.5*(e.x + e.y)
    n.y = e.x * -0.5 + n.y;    // = 0.5 + 0.5*(e.y - e.x)
    return n;
}

vec3 oct_to_vec3(vec2 e) {
    vec3 n;
    n.x = (e.x - e.y);              // 反解出 e_x
    n.y = (e.x + e.y) - 1.0;       // 反解出 e_y
    n.z = 1.0 - abs(n.x) - abs(n.y);   // 由 |x|+|y|+|z|=1 还原 z
    n.xy = n.z >= 0.0 ? n.xy : oct_wrap(n.xy);
    return normalize(n);           // 投回单位球
}

单纯这样做，似乎节约不了很多性能。于是这个做法用了一个更狠的Trick去完成这个事情：分块更新这个八面体贴图。

首先，ClayJohn给这个八面体贴图设置的默认分辨率是768 * 768，也就是说，它本身每帧全跑也就大约是一个1080P半分辨率全屏RayMarch的性能水平。但考虑到云本身不是什么太高频的信息，我们可以用更激进的方式去均分掉这个计算量。

做法如下：将768 * 768的贴图拆分成 8 * 8 的块，每块是96 * 96的分辨率，然后每帧更新一块即可。64帧能够把所有块更新一次。但很明显，如果真的这么做的话云层贴图本身会出现明显的切割痕迹。所以实际操作是三张图进行轮转。

var texture_to_update   : int = 0   # 正在后台逐块写
var texture_to_blend_from : int = 1 # 上一轮完成的（旧）
var texture_to_blend_to   : int = 2 # 最近一轮完成的（新）

每次完成一整轮更新就轮转这个贴图索引。

if frame >= frames_to_update:
    texture_to_update     = (texture_to_update + 1) % 3
    texture_to_blend_from = (texture_to_blend_from + 1) % 3
    texture_to_blend_to   = (texture_to_blend_to + 1) % 3
    _update_per_frame_data()      # 关键：参数每轮只更新一次
    sky_material.set_shader_parameter("blend_from_texture", textures[texture_to_blend_from])
    sky_material.set_shader_parameter("blend_to_texture",   textures[texture_to_blend_to])
    sky_material.set_shader_parameter("sky_blend_from_texture", sky_lut.back_texture[0])
    sky_material.set_shader_parameter("sky_blend_to_texture",   sky_lut.back_texture[1])
    frame = 0

最后，在skyShader里按时间进行两张图片的慢慢混合。

这样，实际每帧运算量直接降低到了 1/64，最后得到了这个快到爆炸的邪道体积云实现。

不过，这个实现明显的缺点就是云层移动过快的时候能明显观察到64帧内的混合痕迹，而且视角实际上看不到部分的云的计算按理说是被浪费掉了。不过也非常快了。但是这带来一个额外的好处，由于渲染本身是跟视角完全解耦的，不会因为视角移动产生任何传统实现可能有的重投影降噪导致的拖影现象。

不需要降噪😨

也许你可以注意到，这套实现不存在任何降噪或者类似降噪性质的管线，但是最后的结果也非常漂亮，没有任何噪声。这主要有两个原因

1. 由于计算量得到了巨大程度的分摊，你可以肆无忌惮的提高采样和March质量本身。默认的March步数就是32~192步，已经是个不一定低的步数了。

2. 在两帧图像之间缓慢混合，其实本身也起到了一定的降噪效果。而且它不会每帧重新渲染图像，所以本来就不会出现高频的抖动现象。

如果你没有穿过云层的要求的话，这样一个体积云就在Godot里面实现了。我想这也能作为Godot其实已经不非常缺乏图形能力的一个证明。不过我也完成了一个标准的体积云实现，这个就留着下次再讲了😋

（补充：这个是以SunshineCloudsV2插件为脚手架搭建的。这个插件因为它构式一样的优化和降噪其实基本不可用，我以这个为基础设施做了大量优化改进）

• Previous Post
  Godot高性能完整物理天空+体积云实现（上）

PV: :)

CATALOG

1. 1. 前言
2. 2. 云建模
3. 3. 光照计算
4. 4. 邪道大合集
5. 5. 不需要降噪😨

• Archive
• Tag
• Cate

Total : 13

2026

• 06/04 Godot高性能完整物理天空+体积云实现（下）
• 06/04 Godot高性能完整物理天空+体积云实现（上）
• 03/15 视频脚本：关于独立制作提升画面质感的一些思考，以及一次近期GameJam复盘
• 03/02 Godot可交互水面渲染（二）：交互，高级API
• 02/14 Godot可交互水面渲染（一）：GDShader

2025

• 12/10 2025年终总结
• 10/16 Godot自定义后处理
• 08/06 编译多语言离线版本Godot官方文档教程
• 07/17 Godot使用MMD模型的个人工作流程
• 07/06 Godot 4.5 中的Stencil
• 06/20 Godot卡通角色渲染
• 06/17 贴图反Tile算法
• 06/15 本站杂记之始

 代码工程  Godot  GameJam  Shader  计算机图形  角色Worflow序列  文档  Sphinx  Compositor  杂记  Blender  MMD  模型  杂谈



缺失模块，请参考主题文档进行安装配置：https://github.com/fi3ework/hexo-theme-archer#%E5%AE%89%E8%A3%85%E4%B8%BB%E9%A2%98

