前言

  继之前的水焦散渲染模拟后又过了有一年多了,期间顺利毕业且放弃高薪追寻WLB入职了一家游戏外企。在工位摸鱼时偶然刷到一篇大规模FLIP流体模拟在桌面端消费级显卡上跑出了不错的DamBreak效果,技痒难耐决定重拾之前搁置已久的移动端流体飞溅调研,没想到最终还是取得了不错的效果(不然也就不会有这篇博文了)。

  场景相关是我最近看奥德赛导致的,个人还挺喜欢这种神话史诗,当然现实一些的考量也有:移动端的粒子无法达到桌面端那种量级,在精度和量级的权衡下个人选择了漂流瓶这种取巧方案。最终是在高端机(Redmi K90pm)上64K粒子稳定FPS100+,中低端机(Redmi K50)上32K粒子稳定FPS80+,算是还不错的性能了(后续加了个PBD标签皮筋导致性能略有下降,但…还挺好玩的)。

img

模拟

  在Games201中胡渊鸣提及水的模拟可以概括为拉格朗日视角的粒子法和欧拉视角的网格法,但两种都有自身局限,如粒子法(SPH,PBF)难以保证稳定性和不可压缩性,网格法(LBM)不好表现飞溅效果。所以最终实现肯定是混合方案,多方比较后个人选择了MLS-MPM,表现不错,性能也稳定。MLS-MPM本身能做的东西很多,沙子、雪等…但移动端上目前还不大能奢望这种多态互动,所以就先演示飞溅吧。

  MLS-MPM最初由胡渊鸣在SIGGRAPH 2018提出,本质上是对传统 MPM 的一次加速改造。它沿用了B样条权重,但借MLS近似把权重梯度直接写成权重乘节点偏移,省掉了单独计算权重梯度的开销,让应力和APIC的仿射项可以合成一个矩阵一次散射出去。在代码中,模拟可以分为初始化的缓存边界和运行时的清空网格,粒子转网格,更新网格,网格转粒子。

初始化

  做这种规模的模拟,自然是逃不开GPU的Compute Shader。在Unity中由C#创建Buffer、传参数、下发任务,粒子的更新过程留在GPU,渲染也继续读同一份Buffer,这样不用每帧把几万粒子搬回CPU。

  初始化的第一件事是撒点,但由于瓶子的形状不规则所以需要先从瓶子的mesh中把形状提取出来,以供初始化和后续查表算SDF。这里我是将其压成一条旋转体轮廓线,以二维点概括瓶身内壁的轮廓,之后在圆中估算下水量对应面积就可以开始均匀撒点。对于粒子,MLS-MPM只需要记录位置、速度、密度比以及记录周围速度变化的仿射矩阵(概念源自APIC)。

1
2
3
4
5
6
struct Particle
{
float4 position; // 网格坐标
float4 velocity; // 网格速度与密度比
float4 affineX, affineY, affineZ; // 仿射矩阵
};

  不过实际存的时候是拆成五段连续的数组(SoA),这带来了不错的性能提升。

1
2
3
4
5
6
7
RWStructuredBuffer<float4> _Particles;

particle.position = _Particles[id];
particle.velocity = _Particles[id + _ParticleCount];
particle.affineX = _Particles[id + 2 * _ParticleCount];
particle.affineY = _Particles[id + 3 * _ParticleCount];
particle.affineZ = _Particles[id + 4 * _ParticleCount];

粒子转网格

  每个子步先清空网格,然后就是P2G的第一步算权重:每个粒子把自己的质量和动量分给周围3×3×3个节点,各轴用二次B样条算权重,三轴相乘即为节点权重。

1
2
3
4
5
6
void Weights(float3 position, out int3 origin, out float3 w[3])
{
origin = (int3)floor(position - .5);
float3 f = position - origin;
w[0] = .5 * (1.5 - f) * (1.5 - f); w[1] = .75 - (f - 1) * (f - 1); w[2] = .5 * (f - .5) * (f - .5);
}

  之后则是算应力和散射:水这里用的是弱可压缩:密度比超过1就给个立方压力往外推,低于1不管,免得负压把粒子吸成一坨。再加点黏性,和仿射矩阵合成一个矩阵q,乘上节点偏移就是要分出去的动量。密度比直接用上一次G2P顺手收集的,能省则省了属于是。

1
2
3
4
5
6
float ratio = p.velocity.w, pressure = BulkModulus() * max(ratio * ratio * ratio - 1, 0);
float3x3 c = float3x3(p.affineX.xyz, p.affineY.xyz, p.affineZ.xyz), stress = Viscosity * (c + transpose(c));
stress[0][0] -= pressure; stress[1][1] -= pressure; stress[2][2] -= pressure;
float3x3 q = c - (4 * Dt / (ratio * _RestDensity)) * stress;
...
float3 momentum = weight * (p.velocity.xyz + mul(q, cell - p.position.xyz));

  最后就是P2G最大的麻烦:几万个粒子同时往同一批节点里加东西,只能上原子操作,而移动端又没有浮点原子加。最后个人是把值放大成定点数,两个有符号16位塞进一个int,这样每个节点只需两次InterlockedAdd。其中缩放系数(质量512,动量32)是在不溢出和精度之间凑出来的,虽然trick但也是尝试诸多方法后唯一work的优化(说来怎么有种莫名的心酸)。

1
2
3
// 第一个int:质量、X动量    第二个int:Y动量、Z动量
void Accumulate(uint address, float low, float high) { InterlockedAdd(_Accumulation[address], asint(asuint((int)round(low)) + (asuint((int)round(high)) << 16))); }
int2 Unpack(int v) { int low = (v << 16) >> 16; return int2(low, (v - low) >> 16); }

网格转粒子

  网格更新比较简单,拆出质量和动量,相除得到速度,加上重力,再处理瓶壁和船即可。

1
2
3
4
5
6
int2 a = Unpack(_Accumulation[id * 2]), b = Unpack(_Accumulation[id * 2 + 1]);
float mass = a.x / MassScale;
if (mass <= 0) return;
float3 velocity = float3(a.y, b.x, b.y) / MomentumScale / mass + Gravity * Dt;
...
if (wall.w > -(Clearance() + .65)) velocity -= max(dot(velocity, wall.xyz), 0) * wall.xyz;

  然后G2P再用同一套二次B样条权重把27个节点的速度收回来,顺带重建仿射矩阵和密度比,最后积分位置即可。

1
2
3
4
5
float3 v = weight * node.xyz, offset = origin + int3(x, y, z) - p.position.xyz;
density += weight * node.w; velocity += v;
cx += 4 * v.x * offset; cy += 4 * v.y * offset; cz += 4 * v.z * offset;
...
float3 position = p.position.xyz + Dt * velocity;

  这里的4其实是二次B样条下的4/Δx²,网格坐标里Δx=1就只剩4。它和前面MLS省掉权重梯度是同一件事:速度梯度直接由权重乘节点偏移拼出来,下一步P2G再原样用回去,这样粒子就能带着局部的旋转和剪切走,而不是每轮都被网格磨平。同时顺手收集的密度比写进velocity.w,用以下一个子步P2G算压力。

  至于边界,网格那边只去掉朝壁里的速度,管的是”别往里走”;但积分完的粒子还是可能越界,所以G2P再按瓶子轮廓投影回去,并留一点间距。碰过墙的粒子仿射矩阵清零,不然贴壁那层会有奇怪的旋转。

渲染

  模拟完得到的是一堆点,想让它像一整块水还得重建表面。Marching Cubes在手机上太费了,所以最终走的是经典的屏幕空间流体:只管相机看得到的部分。大致步骤可以概括为:粒子深度 + 厚度 → 双边平滑 → 重建法线 → 计算光照->白沫合成 → 飞沫

屏幕空间

  每个粒子画一个两三角形的面片,片元里切成圆,再按球面算出真实深度。这里要写两份深度:一份线性的给后面平滑和重建用,一份投影后的给深度测试用,两者不能混用。

1
2
3
4
5
float r2 = dot(i.disk, i.disk);
clip(1 - r2);
float3 surface = i.centerVS + float3(i.disk, sqrt(1 - r2)) * _FluidRadius;
clip(SceneEyeDepth(i.positionCS.xy * _FluidBufferSize.zw) + surface.z); // 被场景挡住就不要了
o.depth = -surface.z; o.deviceDepth = DeviceDepth(surface);

  厚度Pass则是用加法混合,累加视线穿过每个球的弦长,后续用来算吸收光照。然后是双边滤波,普通模糊会把水和后面的背景糊在一起,所以权重里除了屏幕距离还要看深度差,差太多的直接跳过。横纵各四轮,尺度逐轮缩小,目的是磨掉单个粒子的轮廓。

1
2
3
4
float difference = (data.x - center.x) / DepthRange;
if (data.x <= 0 || abs(difference) > 2) continue;
float weight = exp(-.125 * tap * tap - 2 * difference * difference);
sum += data * weight; weights += weight;

  有了平滑后的深度,逆投影回视空间,相邻像素差分叉乘得到法线。着色就是实时中常见的那套近似:厚度指数衰减背景色当吸收,法线偏移UV采场景颜色(Opaque Texture)当折射,Cubemap加菲涅耳当反射。

1
2
3
4
float3 transmittance = exp(-_Absorption.rgb * thickness);
float3 transmitted = SampleSceneColor(refracted) * transmittance + _WaterColor.rgb * (1 - transmittance);
float fresnel = .02 + .98 * pow(1 - saturate(dot(normalVS, viewVS)), 5);
float3 water = lerp(transmitted, environment, fresnel) + highlight * .4;

白沫与飞溅

  水面有了,但拖船搅动再猛也总觉得差了些什么。所以又单独开了个8K的白水粒子池,它不参与MPM,只读已有的网格速度和质量,分成贴水面跟着漂的白沫和飞出去的飞沫。

1
struct Whitewater { float4 position, velocity, normalType; }; // position.w寿命,normalType.w 0飞沫 1白沫

  生成时每个空位随机挑一个水粒子,先判断它是不是在水面:用周围网格质量的梯度当法线,再排除瓶壁和船底挤出来的假界面。然后拿速度、仿射矩阵里的应变和涡量估一个活跃度,换成按时间步算的概率,这样即使帧率变了生成量也不会跟着变。

1
2
3
4
float strain = sqrt(dot(s.affineX.xyz, s.affineX.xyz) + dot(s.affineY.xyz, s.affineY.xyz) + dot(s.affineZ.xyz, s.affineZ.xyz));
float3 curl = float3(s.affineZ.y - s.affineY.z, s.affineX.z - s.affineZ.x, s.affineY.x - s.affineX.y);
float activity = saturate((speed - FoamSpeed) / FoamSpeed) * saturate((strain + .5 * length(curl) - Deformation) / 12) * lerp(.45, 1, saturate(outgoing / 2));
if (Random(seed + 17) < 1 - exp(-Emission * activity * TickDt)) ...

  往外冲得快的算飞沫,只受重力和阻力;其余的算白沫,吸附在水面上跟着网格速度漂,钻进水里或者寿命到了就消失。同时白沫没有一个个画白圈,而是先沿水面铺成拉长的椭圆,累加成一张密度图,再叠一层Voronoi气泡纹理,最后在水面合成时按密度盖上去。这样连成一片才像泡沫,不然就会是一堆白边的粒子。飞沫则在水面合成之后单独画,按屏幕速度拉长一点,用场景深度和水面深度做软交界。

杂项

船水耦合

  船推水这边是以船上挂着的胶囊碰撞体为形状来源,每帧把胶囊的端点、半径和前、后、左、右、中五个探针位置一次性同步给流体。网格更新时不允许水相对船体往里走,G2P时把钻进胶囊的粒子推出去。由于船会倾斜,所以船体速度里还要补上角速度的部分:

1
2
float3 hull = _BoatVelocity + cross(_BoatAngularVelocity, position - (_BoatA.xyz + _BoatB) * .5);
velocity -= min(dot(velocity - hull, normal), 0) * normal;

  水带船这边也没必要把粒子读回CPU,网格里已经有现成的速度和质量。在船的前、后、左、右、中各放一个探针,在附近的网格柱里从上往下找质量由空气变成水的位置当水面高度,再取水面下几格的速度当水流。毕竟船底那圈节点的速度已经被船自己约束过了,采了就成了船跟着自己走,所以要跳过。

1
2
3
4
5
6
7
8
for (int y = GridOffset.y + GridSize.y - 2; y > GridOffset.y; y--) // 自上而下找水面
{
float mass = _Grid[CellIndex(cell)].w, above = _Grid[CellIndex(cell + int3(0, 1, 0))].w;
if (mass <= threshold || above > threshold) continue;
heightSum += (y + saturate((mass - threshold) / (mass - above))) * weight;
... // 再取水面下几格非船体节点的速度当水流
break;
}

  探针结果每0.1秒异步读回一次,中心点决定吃水高度,前后、左右的高度差叉乘出水面法线决定船的俯仰和侧倾,水流速度则带着船漂。严格来说这不是浮力积分,只是便宜的随波逐流,但对一艘小帆船够用了。

皮筋模拟

  瓶口挂的标签是简单的PBD:16段绳子加上标签下沿两个角,一共19个点,标签用三条边约束成一个小刚性三角。每步先加重力和风力(Perlin噪声拼出来的阵风,标签面还额外算一份风压),然后处理迭代距离约束、间隔点的弯曲约束和把标签转至朝向相机的扭转约束,最后处理桌面、瓶身、瓶口和软木塞的碰撞,用位置差回算速度。

1
2
3
4
5
void Distance(int a, int b, float rest, float softness)
{
Vector3 d = p[b] - p[a], c = d * ((1 - rest / d.magnitude) / ((w[a] + w[b]) * (1 + softness * 8)));
p[a] += c * w[a]; p[b] -= c * w[b];
}

  绳子网格每帧沿着节点用平行传输(沿着绳子走,每圈只做最小旋转,避免扭成麻花)扫一圈八边形管子,抓的时候找屏幕上最近的节点拉过去,松手保留速度,甩起来还挺有弹性,虽然又吃了点性能但真挺好玩的。

后记

  最后还是加上亿点点细节,一个能拖船推水、能甩标签的漂流瓶就算完工了。也算是圆了多年前的梦,证明了移动端跑3D流体模拟的可行性,虽然离进入游戏场景,为玩家们所体验还是有一定距离。

  当然这套也有很多偷懒的地方:边界只支持沿X轴的旋转体瓶子,船是运动学跟随而不是真浮力,拖得太快也没做连续碰撞,透明光路也只是近似。但作为一个Demo来说已经足够好玩了,完结撒花。