粒子系统设计模式:GPUComputationRenderer 与 Points 的边界 Where CPU Particles End and GPU Compute Begins
CPU 粒子池三万个左右的性能瓶颈 · ping-pong FBO 到底在交换什么 · 官方 gpgpu_birds 深度拆解 · WebGPU Compute 的真实收益与回退代价 · 一张参数表跑通两条路
为什么粒子是 Web 3D 项目最先撞墙的那块天花板
大多数系统你都可以采用「先把画面做出来,性能以后再说」的思路。粒子不行。
粒子是唯一一个只要多按一下按钮、成本就翻十倍的系统。你做过这个流程:先给篝火做 30 个火星,挺好看;策划说加个被击中的爆点,你加到 800;美术说 BOSS 死亡要有一片灰烬慢慢飘散,你加到 3 万;然后帧率从 60 掉到 22。而掉帧发生的位置,恰恰是玩家最应该觉得爽的那 0.3 秒。粒子的性能峰值永远和玩家的情绪峰值重合,这是它比其他系统更难处理的根本原因。
我更愿意把粒子理解成「信息放大器」:打击感靠它、方向感靠它、材质感靠它、状态提示也靠它(中毒是绿雾、加速是拖尾、护盾破碎是碎片)。它是玩家能读懂「刚才发生了什么」的最短路径。所以它值得单独做一次架构选型,而不是随手 new 一堆 Sprite 了事。
说个我自己的翻车现场:我第一版爆炸特效用了 8000 个 THREE.Sprite,每个 Sprite 一次 draw call,在 iPhone 8 上跑起来像翻页动画。当时我还以为是自己的数学算错了,查了两天才发现,卡的并不是计算,而是提交。粒子这个系统最容易骗人的地方就在这里——你以为是粒子太多,其实是提交太碎。
这篇想讲清三件事:CPU 粒子到底在哪一步开始撑不住,限制来自哪种开销,而不只是数量多;ping-pong FBO 那套东西到底在交换什么;WebGPU 来了以后,哪些限制真的消失了,哪些仍然存在。这三件事讲清楚,你就不会再在「要不要上 GPGPU」这个问题上反复纠结。
第一层:粒子贵在哪——三种成本,别混着算
想要在粒子这件事上做出正确决策,第一步是把「性能」这个词拆开。粒子系统的开销由三种完全不同的成本构成,它们的触发条件不同,优化手段也完全不一样,混在一起谈只会得出「粒子多了就卡」这种废话。
第一种是状态更新成本。每个粒子每帧都要算一次:速度加上重力、位置加上速度、寿命减一。这些计算在 JS 主线程上跑,占用的是你和 AI、物理、UI、网络请求共享的一份时间预算。1 万个粒子跑一遍简单的积分,桌面浏览器大概 0.5 到 1.5 毫秒,中端手机上 3 到 5 毫秒。听起来不多,但你要记得,主线程每帧只有 16.6 毫秒,而且这 16.6 毫秒里你还得干别的。
第二种是数据上传成本。算完的新位置要送到 GPU,每帧都要传。1 万个粒子,属性如果是位置三个数、颜色三个数、大小一个数、透明度一个数,一共八个浮点数,每个 4 字节,就是 320KB 一帧。60 帧下来接近 19MB/s。单看带宽不算吓人,问题在于上传这个动作是在主线程排队执行的,而且驱动层偶尔会做同步,所以它带来的影响不是平均帧时间变长,而是帧时间曲线上出现一排小尖峰。玩家对尖峰比对平均值敏感得多。
第三种是填充率成本,也就是 overdraw。这个最容易被忽略。一百个 200×200 像素的半透明粒子叠在一起,就是 400 万像素的填充量,差不多等于把整个屏幕重画两遍。移动端 GPU 大多是分块渲染架构(Tile-Based Rendering,把屏幕切成小块逐块渲染,靠减少显存带宽来省电),这种架构最怕的就是同一块像素被反复涂抹,功耗和发热会直接飙上去。这部分内容[13] 移动端那篇讲得更细,这里只需要记住一句:粒子在移动端,往往先受限于发热,图形算力还没到极限。
| 成本类型 | 什么时候爆发 | 玩家能感知到什么 | 优先砍哪个 |
|---|---|---|---|
| 状态更新(主线程) | 每帧遍历全部粒子,粒子数上万后明显 | 爆发瞬间「卡一下」,1% low 崩盘 | 粒子池上限、降低某些粒子的更新频率 |
| 数据上传(CPU 到 GPU) | 每帧重传整套顶点属性 | 帧时间曲线上周期性小尖峰,手感发涩 | 属性打包、减少属性数量、降低更新频率 |
| 填充率(overdraw) | 大尺寸半透明粒子大量重叠 | 移动端掉帧、手机发烫、电量暴跌 | 缩小粒子尺寸、减数量、换加法混合 |
这里插一句关键的玩家体验判断:粒子的问题从来不在平均帧率。平均 55 帧、但每次爆炸掉到 22 帧,玩家的描述会是「这游戏手感很差」;平均 45 帧、但稳定不掉,玩家反而觉得「还凑合」。人对「输入延迟」的容忍度,远低于对「画面不够顺滑」的容忍度。而粒子恰恰总在最需要即时反馈的时刻给主线程增加负担。
所以我一直有个观点,可能有点反直觉:粒子系统里最贵的从来都是同步,粒子本身还在其次。你每多造一条从 GPU 走回 CPU 的数据链路、每多一次「等算完再决定下一步」,成本就往上跳一个数量级。后面讲 GPU 路线的所有限制,本质都是这一条的延伸。
第二层:CPU 路线的真实天花板,不是五千,是一次 GC
先把结论摆出来:CPU 粒子完全够用,而且在九成 Web 3D 项目里它才是正确答案。你觉得它不行,多半是因为写法有问题。
CPU 路线的正解是「粒子池 + 预分配 + 属性打包」,四件事:
- 池子固定。开工时一次性申请好 4096 个粒子能占的所有数组空间,运行期间永不扩容。粒子死了不是删掉,是打上「空闲」标记等着被复用。
- 活粒子紧凑排列。每帧把还活着的粒子往前挪,记录活跃数量,绘制时只画前 N 个(BufferGeometry 的绘制范围就是干这个的)。这样 GPU 端完全不用管「哪些粒子死了」,它只负责画前 N 个点。
- 属性打包。把大小和透明度塞进同一个浮点数里,用「整数部分存大小、小数部分存透明度」这种土办法,一下就省掉一整个属性,上传量少三分之一。这招看起来很土,但在带宽紧张的时候真救命。
- 循环里绝不创建对象。这条是纪律问题。我见过一个项目在粒子更新循环里每帧 new 4000 个 Vector3,结果垃圾回收每三秒来一次 20 毫秒的停顿,玩家管这叫「每隔三秒抽一下」。这种 bug 最难查,因为性能分析器上看不到它,你只能感觉到它。
所以 CPU 路线的真实天花板是怎么来的?真正卡住你的,是主线程已经没时间了,GPU 本身其实还画得动。你还要跑角色动画、寻路、UI 刷新、网络同步,粒子只能分到 1 到 2 毫秒。这就是为什么同一个引擎,做一个纯粒子 Demo 能跑十万,做进游戏里两万就喘。
给个量级参考,别当标准,当量级感用:
| 平台 | 简单积分 + 加法混合 | 再开深度排序 | 再加逐粒子碰撞 | 备注 |
|---|---|---|---|---|
| 桌面 Chrome | 2 万到 3 万 | 8000 左右 | 3000 左右 | 60 帧、主线程还有余量 |
| 中端安卓 | 3000 到 6000 | 1000 上下 | 500 上下 | 先卡在发热,图形算力还没到上限 |
| iPhone 12 级 | 6000 到 1 万 | 2000 左右 | 800 左右 | 像素比高,填充率先到达上限 |
注意第三列。深度排序是 CPU 路线的隐藏杀手:半透明粒子和场景里的其他半透明物体必须按距离从远到近画,否则就是硬边和穿帮。1 万个粒子排一次序,几毫秒就没了,而且每帧都要重排。绝大多数项目直接放弃这条,改用加法混合(Additive Blending),因为加法满足交换律,先画后画结果一样,天然不需要顺序。
代价是什么呢?所有粒子都会「发光」。火花、魔法、能量束,加法混合是完美的;但烟、灰尘、落叶、水雾,这些需要「遮挡」感的粒子,加法混合做不出来,它们会像一堆亮片贴在屏幕上。这就是一个纯粹的取舍:你要正确的遮挡关系,就得付排序的钱;你要便宜,就得接受你的粒子都会发光。
案例拆解:HexGL。这是 2013 到 2014 年间用 Three.js 写的浏览器赛车游戏,技术不算新,但架构决策至今能学。它的粒子有三类:车尾焰、撞击火花、漂移烟尘。共同特征是寿命极短(0.2 到 1 秒)、数量极低(同屏同时活着的一般在几十到两百之间)、随机性极强。
它完全没有用 GPGPU,而且我认为这个决定是对的。一次撞墙只发射二十来个火花,寿命 0.3 秒,你把它送上 GPU,光是建立数据通道和调试的成本就超过收益。留在 CPU 上的好处是决定性的:粒子的初速度可以直接取车辆的当前速度向量和碰撞法线,撞击火花会精确地沿着你撞墙的方向炸开,漂移烟尘会拖在轮胎实际经过的路径上。玩家感知到的不是「有粒子」,而是「火星朝着我撞的方向飞」和「烟跟着我的走线留在后面」。这种「粒子携带物理因果」的事,CPU 上做是免费的,GPU 上做要额外搭一条数据通道。
代价同样清楚:HexGL 做不了一整条赛道飘满萤火虫,也做不了雨幕这种持续的大面积环境粒子,因为数量一上去主线程就顶不住。它把预算全押在了「和玩家动作强相关的那几百个粒子」上。
我很喜欢这个案例,因为它说明了一件事:粒子的第一价值是「因果可见」,第二价值才是「数量」。很多团队在第一步就搞反了。
第三层:ping-pong FBO——把六万个粒子塞进一张图片
现在讲 GPU 路线。这套东西的原理其实非常朴素,只是被术语包裹得吓人。
核心思想一句话:把粒子的状态写进一张纹理的像素里。
一张 256×256 的纹理有 65536 个像素,那就让它装 65536 个粒子。第 N 号粒子住在第 N 个像素上(按行铺开,第 N 除以 256 取整是行,取余是列)。位置存在这个像素的红绿蓝三个通道里,速度存在另一张纹理的同样位置,年龄或者剩余寿命塞进 alpha 通道。
然后每帧做两件事:
第一件,算。把「上一帧的状态纹理」当输入,跑一个覆盖整张纹理的片段着色器。每个像素读自己的上一帧状态,加上这一帧的物理(重力、阻力、噪声力场、寿命递减),算出新状态,写到另一张纹理上。
第二件,换。两张纹理调换角色。刚才的输出,下一帧变成输入。
这就是 ping-pong(乒乓)这个名字的由来,球在两张靶子之间来回打。为什么不能就地读写同一张?因为 GPU 不保证你读到的像素没被别的像素抢先改掉,一片混乱。双缓冲是唯一安全的写法,没有捷径。
再看渲染。顶点着色器里,每个顶点知道自己属于第几号粒子,于是跑到纹理的对应格子采样一次,拿到位置、大小、透明度,把点放到该在的地方。渲染这一步几乎免费——位置不是从 CPU 传上来的,是它自己「查」出来的。
收益非常实在:每帧顶点上传量从几 MB 变成零,只传几个标量(当前时间、帧间隔、几个力场参数);主线程彻底解放;桌面端十万级粒子可以稳住。这套思路在 Three.js 里被封装成了 GPUComputationRenderer,干了十年的活,稳定可靠。
但代价这一层,教程里基本不讲,我一条一条摆出来,因为这决定了你该不该上它:
- 没有回读。你想知道某个粒子现在在哪,得把整张纹理读回内存,那个操作会打断 GPU 流水线,慢到几十毫秒。也就是说,GPU 粒子是「发出去就不管了」,你不能根据粒子的位置做任何游戏逻辑判断。
- 不能和 CPU 端的碰撞体互动。除非你把碰撞信息提前烘焙成纹理——高度图、深度图、有符号距离场。火焰要绕着一堵墙飘,你得把那堵墙提前变成一张数据图给它查。
- 调试像盲飞。粒子突然看不见了,你只能猜:是速度算错了?是年龄到上限被裁掉了?是位置写到了相机背后?所以必须额外做一件事——把状态纹理直接渲染到屏幕角落的小窗里,人眼看着数据调物理,这是 GPGPU 调试的必备手段,不是可选项。
- 时间是常驻状态,必须处处小心。经典 bug:用户切到别的标签页,二十分钟后切回来,帧间隔算出二十秒,一帧之内所有粒子飞出银河系。必须给帧间隔设上限(一般 0.1 秒封顶),暂停、重开、时间缩放同理。
案例拆解:Three.js 官方的 gpgpu_birds 示例。严格说它是个示例不是游戏,但在这个专题里,它的教学价值超过大多数游戏——很多人就是拿它改出了自己的作品。它的做法是:状态存在两张 256×256 纹理里(不同版本数字略有差异,量级一致),鸟群的三种群集行为(互相分开、朝邻居的平均方向对齐、朝邻居的中心靠拢)全部在片段着色器里算。
最值得说的一招是「邻居怎么找」。真实的 3D 空间里找邻居是很贵的(要么全比一遍,要么建哈希网格)。它偷了个懒:因为粒子在纹理上的排布是规整网格,第 N 号粒子的邻居,在纹理上就在它旁边几格。于是「空间邻居查询」被偷换成了「纹理邻域采样」——采样几次就完事,快到不可思议。
收益也很直观:65536 只鸟,每只都要看邻居,这套逻辑放 CPU 上是平方级的开销,必死无疑;放 GPU 上每个像素各算各的,天然并行,稳。
代价藏在细节里:邻居关系只在纹理网格内有效,当鸟飞到网格边缘(跨行、跨列),邻居就和它在三维空间里的真实邻居对不上了,于是鸟群会出现一点「贴边」的怪异行为。你想换成真实空间的邻居查询,这套偷懒就失效了。
这个案例真正教给你的东西,不是「怎么写群集」,而是:GPGPU 粒子的能力边界不在算力,在数据布局。你的粒子状态能不能被塞进一张规整的网格,决定了你能不能白嫖这份算力。塞不进去(比如粒子要经常增删、要排序、要和真实空间结构对齐),你就得换方案。
跨类对照:Minecraft 的方块破坏粒子。八个到十六个方块碎屑,纯 CPU,飞到地上消失。它证明的恰好是设计层面的事:粒子数量和「手感」几乎是两个无关变量。真正相关的是三件事——延迟(必须和挖掘动作同一帧出现)、方向(朝被击打的反方向飞)、形状(拿被破坏方块的贴图当粒子贴图,一瞬间就把「你打碎的就是那块石头」这件事说清楚了)。你完全可以在三万个 GPU 粒子里找不到手感,也可以在八个 CPU 粒子里找到。
第四层:WebGPU 把「借来的算力」变成真算力
前面讲的 GPGPU 方案,本质是一件很委屈的事:你把纹理当内存,把片段着色器当计算内核,还得画一个全屏三角形来「骗」GPU 说你是在渲染。整套东西都在伪装。
WebGPU 把伪装拆了。计算通道是真的计算通道,随之而来的是几个结构性的变化:
第一,状态可以放在结构化缓冲里,不再是必须排成方块的像素。这件事听起来很平淡,其实是最大的一次解放。粒子状态是什么?就是一个数组。在 WebGPU 里它就可以直接是一个数组,不必为了「凑成 256×256 的方格子」而浪费位置,也不必为了纹理的布局约束去扭曲你的数据结构。
第二,死粒子可以真正被回收。WebGL 那套里,死掉的粒子只能丢到屏幕外或者透明度归零,它仍然占着一个格子,仍然每帧被算一遍。你想「把活着的粒子紧凑排到前面」,在 GPU 上做不到(那需要前缀和)。WebGPU 里可以用前缀和加原子操作,在 GPU 上把活粒子列表压紧,死的位置立刻腾出来给新粒子。这一条直接解决了「粒子池必须开满、但平均只用了两成」的浪费。
第三,排序变得可行。想要烟和灰尘有正确的遮挡关系,就得排序。GPU 侧的基数排序在前面的时代基本是「理论上能做,实际上别想」,在 WebGPU 里是可以正经做的。这意味着加法混合不再是奢侈品之外的唯一选择——你可以同时要便宜和要正确的遮挡。
就现状而言,Three.js 这一侧的工具链是 WebGPURenderer 加 TSL(Three.js 自己的着色器语言),计算通道的能力在推进,但生态还在早期。关于迁移路径和双后端并行的细节,[01] 那篇讲得更完整,这里只说粒子相关的部分。
| 维度 | WebGL + ping-pong FBO | WebGPU Compute |
|---|---|---|
| 状态存放 | 浮点纹理的像素,必须排成规整网格 | 结构化缓冲,数组就是数组 |
| 计算怎么触发 | 画一个全屏三角形,伪装成渲染 | 真正的计算通道 |
| 粒子数上限 | 受纹理边长限制(256 见方约 6.5 万;512 见方约 26 万,但桌面显卡才扛得住) | 受显存和填充率限制,百万级可谈 |
| 死粒子 | 丢到屏幕外,照样吃算力 | 压缩活粒子列表,位置立即可复用 |
| 深度排序 | 基本别想 | GPU 侧排序可行 |
| 与 CPU 交互 | 回读极慢,等于没有 | 回读仍慢,但可以映射缓冲异步取 |
| 调试体验 | 把状态纹理画到角落,土但有效 | 工具链仍有缺口,靠人肉 |
| 浏览器覆盖 | 全覆盖 | 桌面 Chrome、Edge 稳;Safari 与安卓在推进 |
| Three.js 成熟度 | GPUComputationRenderer 用了十年 | WebGPURenderer 加 TSL,演进中 |
说句实话:2025 年这个时间点,绝大多数 Web 3D 项目不该为了粒子去上 WebGPU。如果你的粒子只有三五千个,CPU 池香得很,改起来还快。但如果你的核心玩法本身就是粒子——一个沙尘暴生存、一场星云穿越、一个用粒子做主要叙事的作品——那 WebGPU 的收益是决定性的,因为它把「粒子数」从美术约束变成了美术自由。这个判断标准很简单:粒子在你项目里是调味料还是主菜。
回退策略必须提前想好,不能等上线才发现。我的建议是两条路径共用一套参数表(发射率、寿命、力场强度这些),只是执行端不同;用能力探测决定走哪条;降级不只是「数量减半」,更要紧的是「功能降级」——计算端碰撞关掉、排序关掉、噪声力场换成简单的正弦扰动。这样同一个特效在两台设备上味道接近,只是精细度不同,而不是一个能看一个不能看。
参数化设计工具:一张表跑通两条路
下面这张表是我自己项目里在用的口径,两条路线(CPU 池和 GG 粒子)共用同一套参数语义,只是执行端不同。区间是经验值,不是圣旨,但你要是完全没有头绪,从这里起步不会错得离谱。
| 参数 | 建议区间 | 管什么 | 调错的典型症状 |
|---|---|---|---|
| 粒子池容量 | CPU 2048 到 8192;GPU 16384 到 262144 | 上限,不是实际用量 | 开太大导致初始化卡顿、显存吃紧 |
| 持续发射率(每秒) | 20 到 200 | 环境类粒子的密度 | 太高 → 糊成一片,看不出单个粒子 |
| 爆发发射量(一次性) | 200 到 2000 | 爆炸、撞击的冲击感 | 太少 → 没有存在感;太多 → 只剩一团白 |
| 寿命 | 打击反馈 0.15 到 0.4 秒;环境 1 到 3 秒;灰烬 4 到 10 秒 | 节奏感 | 打击粒子活过 0.5 秒 → 拖泥带水,手感变黏 |
| 初速度 | 源对象速度的 0.3 到 1.5 倍 | 粒子是否「继承」动作 | 不继承 → 粒子和角色脱节,像贴上去的 |
| 散布锥角 | 打击 15° 到 60°;爆炸接近 180° | 方向性 | 全 180° → 所有特效长得一样 |
| 重力倍数 | 真实重力的 0.2 到 1 倍 | 「重量感」 | 满重力 → 粒子掉太快,显得廉价;0 重力 → 飘得像纸片 |
| 阻力(每秒衰减) | 0.5 到 3.0 | 粒子减速的软硬 | 没阻力 → 粒子匀速飞出屏,很假 |
| 噪声力场强度 | 0 到 0.5 | 紊乱感、烟气感 | 太强 → 像抽搐 |
| 尺寸 | 世界单位 0.02 到 0.5;或像素 8 到 64 | 体积感 | 移动端尺寸偏大 → 填充率先崩 |
| 大小曲线 | 出生 0.5 → 寿命两成处到 1.0 → 死亡归 0 | 膨胀收缩的呼吸感 | 全程恒定 → 最典型的「廉价粒子」 |
| 透明度曲线 | 先快后慢衰减,别线性 | 消散的柔和度 | 线性 → 尾巴硬,像被刀切掉 |
| 混合模式 | 加法(火花、魔法)/正常加排序(烟、尘)/相乘(暗雾) | 遮挡与发光 | 全加法 → 整个世界泛白 |
| 每帧更新预算 | 桌面不超过 1.5 毫秒;移动不超过 3 毫秒 | 给主线程设红线 | 没设红线 → 一加特效就掉帧 |
| 移动端降级阈值 | 帧时间超过 20 毫秒持续 1 秒,粒子减半并关闭排序 | 兜底 | 没兜底 → 低端机直接没法玩 |
再给一张决策表,这张表比上面那张有用得多:
| 你的需求 | 推荐方案 | 为什么 |
|---|---|---|
| 少于 2000 个,且要和角色、地形精确碰撞 | CPU 池 + Points | 逻辑就在 CPU 上,粒子能携带物理信息 |
| 2000 到 3 万,纯装饰、无交互 | CPU 池 + 属性打包 + 加法混合 | 省事、好调、够用,别为了炫技上 GPU |
| 3 万以上,纯装饰,运动有规律(群集、流场、银河) | GPUComputationRenderer | 正好是它的甜区,数据布局天然规整 |
| 需要 GPU 侧排序、压缩、动态粒子数 | WebGPU Compute(带 WebGL 回退) | 这三件事在 WebGL 里基本做不到 |
| 粒子要影响游戏逻辑(火焰点燃物体、毒雾扣血) | 逻辑在 CPU,GPU 只做视觉复制 | 永远不要指望 GPU 粒子回传结果 |
最后那条值得单独说一句,因为它是我踩过最深的坑之一。「双份粒子」是个非常实用的模式:逻辑上你只有 20 个火源,各自带一个半径和一个伤害值,全部由 CPU 管理;视觉上你放 3000 个火星,纯 GPU,谁也不知道谁是谁。玩家看到的是漫天火星,程序看到的是 20 个圆。两侧各司其职,谁也不用迁就谁。你一旦试图让 GPU 粒子「知道自己烧到了什么」,整套架构就会开始崩。
双路径对照:你现在该选哪条
初级用户速览(照这个抄,基本不会翻车)
- 粒子少于 2000、且要跟角色或地形较真:CPU 池加 Points,别多想。
- 2000 到 3 万、纯装饰:CPU 池,池子固定、活粒子紧凑排前、大小和透明度打包进一个属性、加法混合。这套能覆盖你八成需求。
- 3 万以上、运动模式规整:上 GPUComputationRenderer,但先把「不能回读、不能和 CPU 碰撞、调试靠小窗」这三条写进需求文档。
- 要排序、要动态粒子数:WebGPU Compute,同时准备 WebGL 回退,两条路共用一套参数表。
- 粒子要参与游戏逻辑:逻辑在 CPU,GPU 只负责好看。双份粒子,各过各的。
进阶深入(架构分层与工程细节)
我习惯把粒子拆成四层,四层之间只通过参数通信,不互相知道对方怎么实现的:发射器层(决定什么时候、在哪儿、发多少,跑在 CPU,和游戏逻辑同源)、模拟层(算物理,CPU 池或者计算通道)、渲染层(怎么画,点还是实例化面片)、参数层(一张表,热更新)。
这样拆的好处是:你把模拟层从 CPU 换成 GPU 的时候,发射器层一行不用改,美术调的曲线也一行不用改。要是你一开始就把这三件事搅在一起写,那第二次做特效的时候,你会想辞职。
三个具体的工程细节,值得现在就做:
其一,调试视图。把状态纹理或者粒子池的关键数值渲染到屏幕角落,一条曲线一个色块。GPGPU 看不见摸不着,没有这个视图你调参数就是在抽卡。别嫌土,土的东西往往最能救火。
其二,参数热更新。粒子的手感九成靠实时微调,做不了热更新你就得反复改文件、刷新页面、重新触发那个特效。一套好的粒子调试面板能省下你一半的工时。这件事和 [16] 编辑器工作流那篇讲的是同一个道理:工具链的投入回报,是在第九十九次调参的时候还回来的。
其三,性能探针。不要只看平均帧率。至少记录每帧的 1% low 和最长帧,并且把「粒子爆发」这个事件和帧时间曲线叠在一起看。你会很直观地看到,是哪一次爆点让帧率掉下去的。这个映射关系一旦建立,你调特效就会有明确的目标。
再说一句态度:做粒子和调游戏数值很像,都要「知道自己要什么感觉」。你要的是被击中的瞬间冲击,那就把寿命压到 0.2 秒、初速度拉高、散射角收窄,让人一眼看出「这是从我这一击来的」。你要的是环境氛围,那就把发射率放低、寿命拉长、加一点噪声力场,让它慢慢飘。很多人的粒子看起来廉价,并不在于技术不够,而在于没想清楚这一堆点到底要表达什么。
争议与常见坑:那些我亲自踩过的
坑一:「粒子越多越爽」是个幻觉。真正决定爽感的是三件事——同一帧出现、方向对、有大小曲线。你去看任何一个让你觉得「打得真爽」的爆炸,数一下粒子,我赌不超过两百个。剩下的观感全是余韵和光照给的。堆数量只会得到一坨发光的雾。
坑二:每帧回读做碰撞。我干过:把粒子位置纹理读回内存,判断有没有落在水里。结果帧率从 60 掉到 24。GPU 回读是个同步操作,它会等你把活干完,几十毫秒就没了。而且你算出来的那个碰撞,玩家根本看不见。正确做法是把碰撞信息提前烘焙成纹理送进去,或者干脆不做。
坑三:忘了给帧间隔设上限。这个 bug 每个做粒子的团队都会遇到至少一次。切标签页、断点调试、系统休眠唤醒——只要有一帧的间隔是好几秒,所有粒子就会在这一帧内飞出去,回来一看屏幕空空如也。上限设在 0.1 秒,一行就能修,但你不知道就永远查不出来。
坑四:移动端的点尺寸有上限。点精灵(Point)的大小在着色器里最终是以像素为单位输出的,不同 GPU 对这个数值的上限规定不一样,超了就直接被裁掉或者缩回去。有些设备上你的粒子会莫名其妙变得很小、很糊,或者干脆消失。别把尺寸调到几百像素,那是在刀尖上跳舞。用实例化的面片(InstancedMesh,见 [03])反而更可控。
坑五:只调数量,不调曲线。粒子的「味道」有八成在大小曲线和透明度曲线上。全程恒定大小的粒子,无论多少个,看起来都像散落的贴纸;出生小、中间鼓、死亡缩回零的粒子,两百个就能做出呼吸感。
坑六:加法混合加泛光,直接过曝。加法混合的粒子在屏幕上叠加,再过一层后处理泛光(见 [04]),中间那个区域会白成一片,什么都看不见。要么降低单粒子亮度,要么给泛光设阈值,要么在爆炸瞬间压一下曝光。这个在 HDR 管线里尤其明显。
坑七:render target 泄漏。GPU 粒子的每张状态纹理都是显存里的真实资源。切换场景、重开一局、热更新的时候你如果不主动释放,它们会一直在那儿待着。这种泄漏在性能分析器上看不出来,只表现为「玩久了就开始卡,重开浏览器就好了」。释放资源的纪律,[13] 那篇讲得很细,这里只提醒一句:粒子系统经常是泄漏的重灾区。
坑八:低估排序成本。很多人做烟,第一版没排序,看着还行;第二版加了排序,帧率直接掉一截,然后就把排序关了。关掉之后半透明穿帮。这不是排序的错,是你的粒子太多、排序太贵。方案是先降数量、再谈排序。
FAQ
Q1:GPUComputationRenderer 能做粒子和地形的碰撞吗?
能,但只是「特定形状的碰撞」。你把地形的高度图或者一张俯视深度图提前烘成纹理送进去,每个粒子在计算的时候采样一次自己的高度,和地形比一比,低了就推回去。这套能做出雨水打在屋顶上溅开、落叶贴着地面滚。但它做不了任意刚体碰撞、做不了粒子互相碰撞、做不了「粒子撞到一个正在移动的物体」。想要这些,老老实实回 CPU,或者等你的项目规模配得上 WebGPU。
Q2:我的粒子在手机上变小、变糊、或者干脆消失,为什么?
三个常见原因叠在一起。一是像素比:手机屏幕的物理像素密度远高于桌面,你按 CSS 像素算出来的点大小,到了实际渲染里会显得很不一样,得把像素比算进去。二是点尺寸上限,前面讲过,不同 GPU 对这个值的规定不一样。三是尺寸随距离衰减(size attenuation)打开之后,远处的粒子本来就该变小,但它在小屏上会小到看不见。我的建议是:移动端给点尺寸设一个下限,别让它在任何情况下小于两三个像素。
Q3:粒子池开 65536,但平均只用了 5000,浪费吗?
WebGL 那套里,浪费的是算力:死粒子仍然占格子、仍然每帧被算一遍。但它不会「占着显存还很贵」,一张 256 见方的浮点纹理对现代显卡来说不算什么。真正的代价是每帧要算满 65536 次,这个是有成本的。缓解办法是给粒子一个「不活跃」状态,在计算的时候直接跳过(把位置丢到很远的地方,或者让年龄停在终点不做更新),虽然省不全,但能省一部分。要彻底解决,就得靠 WebGPU 的前缀和把那堆死粒子压掉——这也是我认为 WebGPU 对粒子最实在的一个改进。
Q4:WebGPU 现在能上生产吗?回退怎么写?
桌面 Chrome 和 Edge 已经可以了,Safari 和安卓在推进,但还没到「闭着眼睛上」的程度。回退的正确写法不是「检测不支持就报错」,而是两套实现共用一套参数:参数层完全一样,模拟层和渲染层各写一份。然后在特性探测那里分叉,桌面走计算通道,其余走 GPUComputationRenderer,再往下还有一层纯 CPU 的兜底。关键是「降级要降得优雅」——功能可以少(碰撞关掉、排序关掉),味道不能变(寿命、颜色、曲线保持一致)。这件事最好在项目第一周就设计好,而不是上线前两周。
Q5:CPU 粒子到底能撑多少?给我个数。
我给不了准确的数,因为差异太大,但我可以给一个判断方法:在你的目标设备上,把粒子数从 1000 开始往上翻倍——2000、4000、8000、16000,每次都看帧时间曲线上「最长帧」那个值。什么时候最长帧开始超过 25 毫秒、而且随粒子数线性上涨,那就是你的天花板。经验值大概在桌面 2 万、中端手机 5000 上下,但你的项目如果同时还跑着复杂的 AI 和物理,这个数还得往下砍。别信任何人的具体数字,包括我的。
Q6:为什么我的粒子看起来「很廉价」?
技术上的原因基本就这几条,按重要性排:没有大小曲线(全程一样大)、没有透明度曲线(线性衰减,尾巴很硬)、随机性不足(所有粒子一模一样,看起来是一批复制品)、没有速度继承(粒子和角色的动作脱节)、数量分布太平(该密的稀、该稀的密)。这五条里,前两条改完你的画面立刻就不一样了。真正的原因往往在于「你没有想清楚这一堆点要表达什么」,而不在技术上。
最后留个观察给你,可能有点反直觉:做粒子做得越久,我越觉得它的核心是节奏,而不是技术。一个 0.2 秒寿命、二十个粒子、朝着摄像机飞来的爆炸,比一个三秒寿命、三万粒子、均匀扩散的星云,更让人记得住。技术决定你能做多大,节奏决定它好不好玩。
所以下次你看到一个让你「哇」的特效,别急着数它用了多少粒子——先试试它消失得有多快。你会发现真正的秘密,往往藏在那零点几秒里。