Three.js 3D 渲染技术专题全层级20 / 21 已发布

粒子系统设计模式:GPUComputationRenderer 与 Points 的边界

· 0 分钟阅读
粒子系统设计模式:GPUComputationRenderer 与 Points 的边界 Where CPU Particles End and GPU Compute Begins — Three.js 3D 渲染技术专题

粒子系统设计模式:GPUComputationRenderer 与 Points 的边界 Where CPU Particles End and GPU Compute Begins

为什么粒子是 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 能跑十万,做进游戏里两万就喘。

给个量级参考,别当标准,当量级感用:

平台简单积分 + 加法混合再开深度排序再加逐粒子碰撞备注
桌面 Chrome2 万到 3 万8000 左右3000 左右60 帧、主线程还有余量
中端安卓3000 到 60001000 上下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 FBOWebGPU 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 秒寿命、二十个粒子、朝着摄像机飞来的爆炸,比一个三秒寿命、三万粒子、均匀扩散的星云,更让人记得住。技术决定你能做多大,节奏决定它好不好玩。

所以下次你看到一个让你「哇」的特效,别急着数它用了多少粒子——先试试它消失得有多快。你会发现真正的秘密,往往藏在那零点几秒里。

文章标签
Three.jsReact Three FiberR3FWebGLWebGPUdreiThrelteTresJSThree.js 性能优化GLSL ShaderPBR 材质Three.js 阴影
更多专题全部专题
觉得有价值?点赞或收藏支持内容持续产出。
← 返回专题:Three.js 3D 渲染技术专题