想象一座巨大的露天泳池，水面上挤满了正在戏水的人。你作为一名管理员，并不真的认识每一个人，但你手里有两张关键地图：一张标出每个人都正在往哪个方向游（速度），另一张标出哪些地方人挤人、哪些地方空荡荡（压力）。只要同时掌握这两张图，你就能预判下一秒钟人群会如何流动：人太多的地方会被挤开，空出来的地方会被旁边的人补上。计算机模拟流体，做的就是同样一件事——只不过它要同时管理几万个“游泳者”，并且每秒钟更新几十次。Navier-Stokes 方程就是这群人的规则手册，稳定流体算法是救生员的广播修正，网格法像在池底铺瓷砖，而 GPU 则像一大群同时开工的救生员。这篇内容，就是带你把这座“数字泳池”从规则看到落地。

岗位关联

理解流体模拟的求解框架与控制策略，能帮你驾驭从游戏实时特效到影视级数字资产的生产管线，也是高性能渲染系统设计中绕不开的算法素养。

目录
  1. 可视化演示
  2. 1 流体方程直觉：速度场与压力场
  3. 2 稳定流体算法：救生员的广播修正
  4. 3 网格法与粒子法：池底瓷砖与个人手环
  5. 4 GPU并行加速：全员救生员同时开动
  6. 5 影视游戏应用：拍电影与打游戏的取舍
  7. 6 工程调优实践：把泳池管得又快又稳
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

展示系统处理流水线、实时性能指标曲线及多方案对比分析，包含数据流转、吞吐延迟监控与方案评估。

本节配有交互动效（进入视口后自动加载，约 3KB）。

系统可视化 处理流程：输入→处理→模型→输出 性能监控：实时指标 P=L×T

1 流体方程直觉：速度场与压力场

泳池管理员最关心的不是某一个游泳者的名字，而是“这一块水面的人正在往哪走”和“这一块水面挤不挤”。前者叫速度场，后者叫压力场。只要知道整个泳池每个位置的速度变化，管理员就可以预判下一瞬间人群的流动。Navier-Stokes 方程做的正是这件事：它把水看成连续体，不求每一个水分子的轨迹，而是求每一个空间点上的速度如何随时间改变。

在三维空间中，速度场记作 \(\mathbf u(x,y,z,t)\)，压力场记作 \(p\)。水不可压缩，意味着任意一个小立方体里，流进来的水量必须等于流出去的水量，这就是“连续性条件”。把牛顿第二定律和不可压缩条件组合起来，就得到流体模拟最核心的偏微分方程：

如果把泳池人群比作流体，那么 Navier-Stokes 方程就是管理员手里的“人群动力学手册”。有了它，管理员不需要认识每一个人，只需要看到速度和拥挤程度的变化趋势，就能推演出整个泳池下一秒的样貌。

∂u∂t+(u⋅∇)u=−1ρ∇p+ν∇2u+f,∇⋅u=0\displaystyle \frac{\partial \mathbf u}{\partial t} + (\mathbf u \cdot \nabla)\mathbf u = -\frac{1}{\rho}\nabla p + \nu \nabla^2 \mathbf u + \mathbf f,\qquad \nabla \cdot \mathbf u = 0
这个方程从左到右依次是：速度变化率、平流、压力、黏性扩散、外力，以及不可压缩约束。它把“泳池人群运动”切成五个可计算的部分。
  1. 速度变化率描述每个点上水的速度随时间的变化快慢。
    ∂u∂t\displaystyle \frac{\partial \mathbf u}{\partial t}
  2. 平流项水会带着自身的动量流向下游，相当于游泳者顺着人流被推着走。
    (u⋅∇)u\displaystyle (\mathbf u \cdot \nabla)\mathbf u
  3. 压力梯度项人多的地方压力高，水流会从高压区被推向低压区。
    −1ρ∇p\displaystyle -\frac{1}{\rho}\nabla p
  4. 黏性扩散项蜂蜜比水粘，这项让相邻区域的速度趋向一致，抹掉尖锐差异。
    ν∇2u\displaystyle \nu \nabla^2 \mathbf u
  5. 外力项重力、风扇、搅拌器这些外部推力都会写进这里。
    f\displaystyle \mathbf f
  6. 连续性条件水不可压缩，任意小盒子的净流入量必须为零。
    ∇⋅u=0\displaystyle \nabla \cdot \mathbf u = 0

2 稳定流体算法：救生员的广播修正

直接求解上节那个偏微分方程非常容易爆炸：时间步长稍大，速度就会发散，模拟画面立刻变得像沸腾的泥浆。于是斯坦福大学的 Jos Stam 提出“稳定流体”方法，好比救生员不再逐个追逐游泳者，而是在每个时间片开始前，让所有人先按旧位置移动，再用广播统一修正。这样无论时间步取多大，画面都不会数值爆炸。

稳定流体算法的核心思想是“算子分裂”：把复杂的方程拆成平流、扩散、外力、投影四个独立步骤，每个步骤单独处理。其中最巧妙的是半拉格朗日平流：为了知道一个格子下一秒的速度，我们沿着速度方向反向回溯，找到这个水团上一时刻来自哪里，再把那里的值取过来。这就像管理员预测“小张下一格会到哪”，反过来先问“小张这一格的水是从哪格漂来的”。

救生员的这套“先回溯、再广播”策略，让每一个网格单元都只读取旧数据，不读取正在被更新的邻居数据，因此天然稳定。这也解释了为什么 Stam 方法至今仍是游戏引擎里实时流体最常用的地基。

un+1(x)=un(x−un(x)Δt)\displaystyle \mathbf u^{n+1}(\mathbf x) = \mathbf u^{n}(\mathbf x - \mathbf u^{n}(\mathbf x)\Delta t)
u∗=un+1−Δtρ∇p,∇⋅u∗=0\displaystyle \mathbf u^* = \mathbf u^{n+1} - \frac{\Delta t}{\rho}\nabla p,\qquad \nabla \cdot \mathbf u^* = 0
前一个公式是平流的反向回溯取样，后一个公式是投影法：先加上外力得到一个中间速度，再减去压力梯度让它满足不可压缩条件。
  1. 回溯坐标从当前位置反向走一个时间步，找到上游位置。
    x−un(x)Δt\displaystyle \mathbf x - \mathbf u^{n}(\mathbf x)\Delta t
  2. 取样赋值把回溯点上的旧速度取回来，作为新速度。
    un(x−un(x)Δt)\displaystyle \mathbf u^{n}(\mathbf x - \mathbf u^{n}(\mathbf x)\Delta t)
  3. 预测速度先暂不考虑压力，直接加入外力得到中间速度 \(\mathbf u^*\)。
    un+1−Δtρ∇p\displaystyle \mathbf u^{n+1} - \frac{\Delta t}{\rho}\nabla p
  4. 投影约束求解压力后修正速度，使最终速度场满足无散度条件。
    ∇⋅u∗=0\displaystyle \nabla \cdot \mathbf u^* = 0

3 网格法与粒子法：池底瓷砖与个人手环

泳池管理有两种极端方案：一是在池底铺满瓷砖，管理员只统计每块瓷砖上有多少人，这叫欧拉网格法；二是让每个人都戴一枚定位手环，管理员直接追踪每一个人的轨迹，这叫拉格朗日粒子法，其中代表作是 SPH。网格法擅长描述整体水流、处理大规模水体，但细节容易丢失；粒子法擅长水花飞溅、泡沫破碎，但粒子数量一大就非常消耗内存。

在工程实现中，网格法常用 MAC 交错网格：速度存放在格子的边上，压力存放在格子中心，避免压力和速度“你推我挤”产生棋盘格错误。SPH 则把连续水体离散成一组粒子，每个粒子的密度由周围邻居粒子的质量加权累加得到：

所以网格法像“看瓷砖里的平均人流”，SPH 像“逐个追踪手环”。现代影视特效很少只用一种：FLIP 和 APIC 等混合方法把粒子装在网格上计算压力，再把计算结果写回粒子，既保留水花细节，又借用网格法的高效压力求解。

ρi=∑jmjW(xi−xj,h)\displaystyle \rho_i = \sum_{j} m_j W(\mathbf x_i - \mathbf x_j, h)
其中 \(W\) 是光滑核函数，\(h\) 是影响半径。粒子越密集，\(\rho_i\) 越大，压力也就越高，自然会把粒子推开。
  1. 粒子质量每个邻居粒子的质量 \(m_j\) 都会贡献给当前粒子的密度。
    mj\displaystyle m_j
  2. 核函数加权距离越近的邻居贡献越大，用核函数 \(W\) 控制影响程度。
    W(xi−xj,h)\displaystyle W(\mathbf x_i - \mathbf x_j, h)
  3. 邻居求和把所有在影响半径内的粒子贡献累加起来。
    ∑j\displaystyle \sum_{j}

4 GPU并行加速：全员救生员同时开动

如果只有一个救生员巡视整个泳池，遇到 1024×1024 的网格就会累到崩溃。GPU 的思路是：每个格子配一个“小救生员”，大家同时读旧状态、同时写新状态。速度场可以存进纹理，每个像素保存一个速度向量，求解压力时让每个像素执行同样的 Jacobi 迭代。这就是游戏实时烟雾能跑起来的原因。

压力计算中最常见的是拉普拉斯算子，它需要读取当前格子上下左右四个邻居的压力。用有限差分可以写成：

当“小救生员”们同时开工，泳池管理就变得非常快。为了实现这一点，现代渲染引擎通常用 Compute Shader 保存速度纹理、执行平流和压力迭代，再交给渲染管线做体绘制。GPU 的并行规模和流体的网格结构天然匹配，因此流体模拟成了图形学里最能吃透硬件性能的算法之一。

∇2pi,j≈pi+1,j+pi−1,j+pi,j+1+pi,j−1−4pi,jΔx2\displaystyle \nabla^2 p_{i,j} \approx \frac{p_{i+1,j} + p_{i-1,j} + p_{i,j+1} + p_{i,j-1} - 4p_{i,j}}{\Delta x^2}
每个格子只看自己的四个邻居，彼此之间没有依赖冲突，因此特别适合 GPU 并行。性能瓶颈往往不在计算量，而在显存带宽和纹理读写次数。
  1. 四邻求和把上下左右四个格子的压力值相加。
    pi+1,j+pi−1,j+pi,j+1+pi,j−1\displaystyle p_{i+1,j} + p_{i-1,j} + p_{i,j+1} + p_{i,j-1}
  2. 中心差分减去当前格子压力值的四倍，得到局部弯曲程度。
    −4pi,j\displaystyle - 4p_{i,j}
  3. 网格间距平方除以 \(\Delta x^2\) 把离散差分还原成二阶导数的量纲。
    Δx2\displaystyle \Delta x^2

5 影视游戏应用：拍电影与打游戏的取舍

同样是泳池，游戏玩家要求每一帧 60 毫秒内算完，电影特效则允许一台渲染农场算一个晚上。于是游戏侧偏向 Stam 稳定流体配合低分辨率网格，追求“看起来合理”；影视侧偏向高分辨率 FLIP/SPH，追求“每一滴水花都符合物理”。这也决定了它们在体积渲染合成时的不同策略。

烟雾、云、火焰这类半透明介质，渲染时通常沿视线方向做体积积分。光线穿过烟气时，能量被吸收系数 \(\sigma_t\) 不断衰减，最终屏幕上看到的是所有深度贡献的累加：

在游戏中，这个公式会被简化成一层层半透明切片或粒子云；在电影中，则用真正的射线步进计算。无论是“快餐式”的实时烟雾，还是“米其林式”的影视水花，物理模拟和体积渲染始终是一对搭档，一个负责提供流体形状，一个负责让它看起来有重量感。

T(a,b)=exp⁡(−∫abσt(s) ds)\displaystyle T(a,b) = \exp\left(-\int_a^b \sigma_t(s)\,ds\right)
\(T(a,b)\) 表示光线从位置 \(a\) 走到 \(b\) 后还剩多少能量。气体越浓、路径越长，透过的光越少，看起来就越厚重。
  1. 吸收系数\(\sigma_t(s)\) 表示路径上每个点的烟雾浓度。
    σt(s)\displaystyle \sigma_t(s)
  2. 路径积分把从 \(a\) 到 \(b\) 的整条视线上的浓度累加起来。
    ∫ab\displaystyle \int_a^b
  3. 指数衰减透光率随累积浓度指数下降，浓度越大衰减越快。
    exp⁡(−∫abσt(s) ds)\displaystyle \exp\left(-\int_a^b \sigma_t(s)\,ds\right)

6 工程调优实践：把泳池管得又快又稳

真正把流体模拟放进项目时，最常卡住人的不是方程推导，而是调参。泳池太小，细节不够；瓷砖太多，内存不够。更关键的是时间步长不能乱选。网格越细，水流每帧跨越的格子数越少，时间步就必须跟着缩小，否则一个格子直接跳过另一个格子，物理就失真了，这就是著名的 CFL 条件：

除了 CFL 条件，工程实现还要处理边界条件：墙壁是“无滑移”还是“自由滑移”，进出口是“固定压力”还是“固定速度”。另外，半拉格朗日平流虽然稳定，但会带来数值耗散，旋涡容易越算越糊，这时候需要补充涡量约束或更高阶插值。泳池管理没有万能方案，所有调优都在“速度、细节、内存”三者之间找平衡。

Δt≤CΔx∣u∣max⁡\displaystyle \Delta t \le C \frac{\Delta x}{|\mathbf u|_{\max}}
\(\Delta x\) 是网格间距，\(|\mathbf u|_{\max}\) 是全场最大速度，\(C\) 是安全常数，通常取 0.5 到 1。速度越快、网格越细，时间步就要越小。
  1. 空间步长网格间距 \(\Delta x\) 越小，信息传递距离越短。
    Δx\displaystyle \Delta x
  2. 最大速度\(|\mathbf u|_{\max}\) 是当前流场中最快的水流速度。
    ∣u∣max⁡\displaystyle |\mathbf u|_{\max}
  3. 安全系数常数 \(C\) 给时间步留出余量，防止水一步跨过多个格子。
    C\displaystyle C

AI 应用场景

场景 1：游戏引擎实时烟雾特效

阶段：实时渲染与程序化内容生成

解决的问题：传统方案用美术手工序列帧做烟雾，无法应对风向变化和角色交互；Stam 稳定流体算法配合 GPU 纹理迭代，让烟雾能实时对玩家行为做出反应。

具体案例：一款开放世界 RPG 的篝火旁，玩家投掷火球会扰动烟气。策划把烟雾速度场写入 RenderTexture，每帧做平流、扩散和投影，再用体积光照叠加。玩家视角变化时烟雾方向自然跟随。

场景 2：影视级水花与飞溅特效

阶段：离线仿真与资产制作

解决的问题：真人电影里船只撞击浪花、角色落入水中，靠手 K 关键帧无法保证水花飞溅的物理真实感；使用 SPH/FLIP 混合方法，用粒子追踪飞溅水珠，用网格求解整体水面流动。

具体案例：一部灾难片中，洪水冲过街道。特效团队先用高分辨率 FLIP 模拟主水体，再叠加数百万 SPH 粒子生成水雾和泡沫，最后用体积渲染合成。虽然单帧渲染几十小时，但镜头真实度远超手工特效。

场景 3：虚拟演播室的实时水面交互

阶段：交互式实时仿真与视觉集成

解决的问题：新闻演播室、虚拟偶像直播需要主持人与水面实时交互，传统录制视频无法响应实时动作。低分辨率网格配合 GPU 并行求解，可以在几十毫秒内更新水面高度场。

具体案例：虚拟偶像直播中，主播挥手时面前的数字水面泛起涟漪。系统把挥手骨骼位置转成外力注入速度场，每帧求解浅水方程，再通过法线贴图让水面出现波光。

Python 演示

python79 行
import numpy as np  class FluidSim:    def __init__(self, size=64, visc=0.0001, dt=0.1):        self.size = size        self.visc = visc        self.dt = dt        self.u = np.zeros((size, size))        self.v = np.zeros((size, size))        self.density = np.zeros((size, size))        self.pressure = np.zeros((size, size))     def advect(self, field, u, v):        size = self.size        dt = self.dt        x, y = np.meshgrid(np.arange(size), np.arange(size), indexing='ij')        px = np.clip(x - dt * u * size, 0.5, size - 1.5)        py = np.clip(y - dt * v * size, 0.5, size - 1.5)        i0 = np.floor(px).astype(int)        j0 = np.floor(py).astype(int)        i1 = i0 + 1        j1 = j0 + 1        sx = px - i0        tx = 1.0 - sx        sy = py - j0        ty = 1.0 - sy        out = (tx * (ty * field[i0, j0] + sy * field[i0, j1]) +               sx * (ty * field[i1, j0] + sy * field[i1, j1]))        return out     def diffuse(self, field, field0):        a = self.dt * self.visc * self.size * self.size        x = field0.copy()        for _ in range(4):            x = (field0 + a * (np.roll(x, 1, 0) + np.roll(x, -1, 0) +                               np.roll(x, 1, 1) + np.roll(x, -1, 1))) / (1 + 4 * a)        return x     def project(self):        size = self.size        h = 1.0 / size        div = np.zeros((size, size))        div[1:-1, 1:-1] = -0.5 * h * (            self.u[2:, 1:-1] - self.u[:-2, 1:-1] +            self.v[1:-1, 2:] - self.v[1:-1, :-2])        self.pressure.fill(0.0)        for _ in range(20):            self.pressure[1:-1, 1:-1] = (                div[1:-1, 1:-1] +                self.pressure[2:, 1:-1] + self.pressure[:-2, 1:-1] +                self.pressure[1:-1, 2:] + self.pressure[1:-1, :-2]) * 0.25        self.u[1:-1, 1:-1] -= 0.5 * (            self.pressure[2:, 1:-1] - self.pressure[:-2, 1:-1]) / h        self.v[1:-1, 1:-1] -= 0.5 * (            self.pressure[1:-1, 2:] - self.pressure[1:-1, :-2]) / h     def step(self):        u_adv = self.advect(self.u, self.u, self.v)        v_adv = self.advect(self.v, self.u, self.v)        self.u = self.diffuse(self.u, u_adv)        self.v = self.diffuse(self.v, v_adv)        self.project()        self.density = self.advect(self.density, self.u, self.v)        self.density *= 0.995  def main():    sim = FluidSim(size=64)    for _ in range(300):        sim.u[30:34, 20] = 0.2        sim.v[30:34, 20] = -0.2        sim.density[30:34, 20] = 1.0        sim.step()    print("density sum =", sim.density.sum())  if __name__ == "__main__":    main()
目的：用 NumPy 实现一个最简二维 Stam 稳定流体求解器，包含半拉格朗日平流、隐式扩散和投影法，持续注入外力后输出最终染料总量。
  1. px = np.clip(x - dt * u * size, 0.5, size - 1.5)沿速度反向回溯采样点，并夹取到合法网格范围内。
  2. i0 = np.floor(px).astype(int)取回溯位置所在格子的左下角坐标。
  3. tx = 1.0 - sx计算水平方向双线性插值的权重。
  4. out = (tx * (ty * field[i0, j0] + sy * field[i0, j1]) + sx * (ty * field[i1, j0] + sy * field[i1, j1]))用四个邻居值做双线性插值，完成平流取样。
  5. a = self.dt * self.visc * self.size * self.size把黏性系数、时间步和网格尺度合并成扩散强度。
  6. x = (field0 + a * (np.roll(x, 1, 0) + ...)) / (1 + 4 * a)隐式扩散迭代，保证大时间步也不发散。
  7. div[1:-1, 1:-1] = -0.5 * h * (...)用中心差分计算速度场的散度，作为压力方程的右端项。
  8. self.pressure[1:-1, 1:-1] = (...) * 0.25Jacobi 迭代求解压力泊松方程。
  9. self.density *= 0.995每帧让染料轻微衰减，模拟真实世界的能量损耗。

常见误区

误区我只要往场景里撒几万个粒子，给它们随机轨道，看起来就像水花了。粒子越多越逼真，不需要什么方程。

正解粒子的运动必须由速度场和压力场驱动，否则只是无物理意义的“彩色沙子”。Navier-Stokes 方程解决的是粒子之间的相互作用，粒子只是把速度场可视化出来的载体。没有方程，再多粒子也表现不出水流汇聚、旋涡、阻挡反弹的真实感。

为何常见：因为渲染出来的水花和泡泡确实由粒子呈现，初学者容易把“展示层”当成“计算层”。

误区GPU 很厉害，把网格分辨率从 128 提到 1024，画面一定更精细，直接堆分辨率就行。

正解网格变细后，空间步长 \(\Delta x\) 变小，根据 CFL 条件，时间步长必须同步缩小，否则一帧内水流会跨过多个格子，数值误差迅速放大。分辨率翻倍，内存和计算量通常上涨好几倍，必须同时调整时间步、压力迭代次数和显存策略。

为何常见：人们容易用“图像分辨率”的经验理解物理网格，忽略时间步与空间步的耦合关系。

误区要么选网格做水面，要么选 SPH 做水花，项目里只能选一种方法。

正解影视和游戏中大量使用 FLIP、APIC 等混合方法：网格负责高效求解压力，粒子负责承载细节与飞溅，两者之间互相映射。选型不是非此即彼，而是根据画面需求决定哪一层用网格、哪一层用粒子。

为何常见：教材为了清晰常把两类方法分开介绍，初学者容易把它们当成对立框架。

误区Stam 方法无条件稳定，画面不会炸，那我放心把时间步调大，细节也不会丢。

正解无条件稳定只保证“不炸”，不保证“不失真”。半拉格朗日平流的回溯插值本质上是一种平滑操作，会不断抹掉小尺度旋涡，导致烟雾越算越糊。工程中需要加涡量约束或高阶插值来补偿耗散。

为何常见：“稳定”这个词容易让人误以为等于“准确”，实际上稳定性和保真度是两个维度。

面试题

Q1. 稳定流体方法（Stam）最重要的承诺是？

单选题 · easy

  • A.无论时间步多大都不会数值失稳← 正确答案
  • B.永远不需要求解压力场
  • C.只需粒子不需要网格
  • D.能自动生成参数化模型

答案：A。Stam 方法通过半拉格朗日回溯取样和隐式扩散，避免显式格式对时间步的苛刻限制，因此能做到无条件稳定。但它仍然需要求解压力场，也仍然需要网格或类似的空间结构。

Q2. 不可压缩流体的连续性条件写作？

单选题 · easy

  • A.∇ × u = 0
  • B.∇ · u = 0← 正确答案
  • C.∇²p = 0
  • D.∂u/∂t = 0

答案：B。不可压缩意味着任意区域净流入为零，数学上写成速度场的散度为零，即 ∇·u=0。旋度为零对应无旋流动，和不可压缩不是一回事。

Q3. 半拉格朗日平流在回溯旧位置后，还需要做什么？

单选题 · mid

  • A.对旧场做双线性插值← 正确答案
  • B.把旧场整体清零
  • C.对压力做隐式求解
  • D.对速度做傅里叶变换

答案：A。回溯点通常不会精确落在网格中心，需要用周围四个网格值做双线性插值，才能得到平滑的平流结果。这不是压力求解，也不是频谱方法。

Q4. SPH 粒子法中，每个粒子的密度主要通过什么得到？

单选题 · mid

  • A.对邻居粒子的质量加权累加← 正确答案
  • B.对全局压力场取平均
  • C.对渲染纹理进行采样
  • D.对网格单元做差分

答案：A。SPH 把连续场离散到粒子上，每个粒子的密度由影响半径内邻居粒子的质量乘以核函数后累加得到。压力场是之后由密度计算出来的，不是直接取全局平均。

Q5. CFL 稳定条件对实时流体模拟的启示是？

单选题 · hard

  • A.网格越细，时间步长应越小← 正确答案
  • B.网格越细，时间步长应越大
  • C.时间步长只取决于压力迭代次数
  • D.时间步长与网格尺寸无关

答案：A。CFL 条件要求一个时间步内流体移动距离不超过一个网格，所以空间步变小后时间步必须跟着变小，否则数值解会失真甚至发散。压力迭代次数并不直接决定时间步上限。

Q6. 影视特效中兼顾水花细节与整体流场的常见做法是？

单选题 · mid

  • A.使用 FLIP/APIC 等混合方法← 正确答案
  • B.只使用欧拉网格法
  • C.只使用刚体物理引擎
  • D.只使用光线追踪渲染

答案：A。FLIP 和 APIC 用网格计算压力、用粒子追踪水花，兼顾效率与细节。纯网格难以表现飞溅，纯粒子计算压力又太慢，刚体和光追都不是流体求解的核心手段。

Q7. 下列哪些属于 Stam 稳定流体算法的主要步骤？

多选题 · mid

  • A.对速度场做平流← 正确答案
  • B.对黏性做隐式扩散← 正确答案
  • C.用投影法修正压力← 正确答案
  • D.对粒子做邻域搜索

答案：ABC。Stam 的算子分裂流程是外力、平流、扩散、投影。投影法负责让速度场满足不可压缩条件。邻域搜索是 SPH 粒子法的步骤，不属于 Stam 网格算法的标准流程。

Q8. GPU 上并行求解压力 Poisson 方程通常依赖什么？

多选题 · hard

  • A.像素/计算着色器按格点并行← 正确答案
  • B.Jacobi 或 CG 迭代求解← 正确答案
  • C.粒子邻域链表加速
  • D.显式 Euler 时间推进

答案：AB。压力方程每个格点只依赖邻居，可以用着色器并行执行 Jacobi 或 CG 迭代。粒子邻域链表是 SPH 的数据结构，显式 Euler 不适合作为压力方程的稳定求解器。

Q9. 实时烟雾渲染常用的简化手段包括？

多选题 · mid

  • A.体密度沿射线积分合成← 正确答案
  • B.半透明粒子云近似← 正确答案
  • C.深度排序粒子混合← 正确答案
  • D.全局光照路径追踪

答案：ABC。实时烟雾常用射线步进累积密度、粒子云近似和深度排序混合。全局光照路径追踪虽然效果真实，但成本过高，通常只在离线电影渲染中使用。

Q10. 数值耗散给流体模拟带来的主要问题是？

单选题 · hard

  • A.旋涡和细节被抹平← 正确答案
  • B.计算时间指数增长
  • C.内存占用直接翻倍
  • D.渲染出现明显色差

答案：A。半拉格朗日平流中的插值会把速度差异平均化，相当于不断给流体“降温”，让小尺度旋涡消失、细节变糊。数值耗散影响的是物理细节，而不是计算时间、内存或颜色。