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

GLSL Shader 开发工作流:从 ShaderMaterial 到 NodeMaterial

· 0 分钟阅读
GLSL Shader 开发工作流:从 ShaderMaterial 到 NodeMaterial 的三条路线与那张升级税单 Shader Workflows: ShaderMaterial, onBeforeCompile & TSL — Three.js 3D 渲染技术专题

GLSL Shader 开发工作流:从 ShaderMaterial 到 NodeMaterial 的三条路线与那张升级税单 Shader Workflows: ShaderMaterial, onBeforeCompile & TSL

为什么 Shader 工作流是材质系统的第一块基石

先说个真事。去年冬天,一个做网页赛车的朋友凌晨两点给我发消息:玻璃全黑了,控制台一个红字都没有。他把 Three.js 从 r150 升到 r165,场景里那几块用社区库做的挡风玻璃,从透明变成了纯黑塑料。代码一行没改,构建一次没报错,跑起来就是黑。

我们查到三点。原因朴素得可笑:那个社区库是靠“字符串替换”往内置材质里塞代码的,而 Three.js 在新版本里把那个代码块改了个名字。替换找不到目标,于是什么也没发生——也没有任何人告诉你什么也没发生。

这就是我想聊 Shader 工作流的原因。你可以把材质系统理解成你和 GPU 签的一份合同:你想要什么颜色、什么高光、什么透明,全都得写成 GPU 看得懂的指令。而“你怎么写这份合同”,决定了三件事——你能改多深、改一次要花多少、以及三个月后框架升个版本,你还剩多少头发。

今天 Three.js 里能走的路,其实只有三条,且它们不是“新旧替代”关系,而是三种完全不同的成本结构:

  • 自己写(ShaderMaterial):从轮子开始造车。自由最大,账也最贵。
  • 打补丁(onBeforeCompile):官方的后门,往已经造好的车里塞私货。最实用,最脆。
  • 搭积木(NodeMaterial / TSL):用 JS 表达式拼一张节点图,编译时再翻译成 GLSL 或 WGSL。面向未来,但今天就得吃迁移的苦。

选路线本质上是在选“你愿意把痛放在哪一天”。放在今天,还是放在升级的那一天。这篇文章就是把三条路的账单摊开给你看,包括我自己翻过的车。

第一层:ShaderMaterial——自由最大,账也最贵

先讲最原始的那条。ShaderMaterial 做的事情特别朴素:你交给它两段文本,一段跑在顶点上,一段跑在像素上,它转手交给 GPU 编译。就这么简单,也就这么粗暴。

你要理解它的处境,得先知道一件事情:Three.js 的内置材质(标准材质、物理材质那一套)并不是硬编码的,它本身就是由几十个可复用的代码块拼起来的——法线算一块、光照循环算一块、阴影采样算一块、雾算一块、色调映射算一块。这些块按固定顺序拼成最终的着色器。

而 ShaderMaterial 的默认行为是:一块都不给你。你写什么就是什么。场景里的灯照不到你,阴影收不到你,雾对你无效,输出的颜色还得你自己做色彩空间转换。很多新人第一次用 ShaderMaterial,做出一个亮得刺眼、跟场景格格不入的物件,还以为是“我审美有问题”——不是,是你没接上那套管线。

当然你可以主动去“借”:把内置的那些代码块引用进来,把对应的变量声明补上。这条路走得通,而且很多人就这么干。但它有个隐性代价:你借的那些块,名字和内容都是框架内部的事,随时可能变。等于你把手伸进了别人家的抽屉。

玩家实际体验到什么

这一点特别值得说。手写 ShaderMaterial 的项目,画面往往有一种很统一的“作者味”——因为整套视觉都是同一个人、用同一套逻辑算出来的。你能在 HexGL 那种作品里立刻感觉到这种统一感。

但翻车也翻在这里。手写材质最典型的症状是:每样东西单看都挺好看,放在一起就不像一个世界的。因为光照不共享。A 物体按自己的一套算法被照亮,B 物体按另一套,两者之间的高光方向、衰减曲线、色调映射全对不上。玩家的眼睛非常敏感,他说不出哪里不对,但他会觉得“这东西是贴上去的”。

所以我的判断很明确:ShaderMaterial 是给“本来就不需要被场景光照”的东西用的。天空、全屏特效、粒子、描边、水面(如果你自己算反射)、UI 空间的东西——这些用它爽得飞起。一旦你要做的是“被场景里的灯照亮的实体”,它就是地狱,你迟早要把光照、阴影、雾一套套重写一遍,而重写完你会发现,你写的东西跟内置材质对不上。

可落地的量级参考

你要做的效果大致工作量要不要接光照建议
描边、扫描线、全屏滤镜半天到一天不需要放心用 ShaderMaterial
天空、云、体积雾一到三天不需要用它,别犹豫
粒子、拖尾一天不需要用它
自发光光带、能量护盾一到两天不需要用它
要被灯照亮的自定义实体三到五天起必须先想想能不能用第二层的办法

一条粗糙的经验线:一个手写着色器文件超过 200 行、而且它还需要响应场景光照的时候,你的维护成本就开始失控了。因为每加一个功能,你都得确认它没有和已有的光照逻辑打架。

案例:HexGL,那个手写一切的年代

2012 年前后,一个叫 Thibaut Despoulain 的开发者用 Three.js 做了个浏览器赛车 HexGL——反重力赛道、发光管道、飞船拖尾、全屏泛光。你得放到当年的语境里看这件事:那时候 Three.js 的内置材质还停留在很朴素的水平,没有 PBR,没有后期管线,连物理材质都谈不上。想要发光轨道?自己算。想要泛光?自己写一遍降采样加模糊再叠加。

他几乎把整个画面的每一个像素都握在自己手里。收益是什么?极致可控。他可以为当年一台普通笔记本的显卡量身定做着色器,每一行都是为“这台机器能跑六十帧”写的,没有一行是通用性带来的浪费。HexGL 在 2012 年跑得比很多原生 3D 项目还顺,靠的就是这份克制。

代价呢?这套东西几乎不可复用。Three.js 换一个版本,他手写的雾和色彩空间逻辑就得跟着调;后来的 PBR、级联阴影、实例化渲染,他一样都白拿不到,因为他的材质压根不在这套体系里。所以 HexGL 成了一个传奇 demo,然后就停在那儿了。

这个案例给我们的教训不是“别手写”,而是:手写让你和框架解耦,同时也让你和框架的所有进步解耦。十年后 Three.js 帮你把光照、阴影、色彩管理全都搞定了,而你的代码库还停在 2012 年。

第二层:onBeforeCompile——官方后门,最好用也最脆

如果你只是想在标准材质上加点东西,重写一整套光照是纯亏。这时候就得走第二条路:往内置材质里注入。

机制说穿了很简单:内置材质在真正送去编译之前,Three.js 会把拼好的着色器源码文本交到你手上,让你改,改完它接着编译。你拿到的是“已经装好的整车”,你只能拧螺丝——但车是免费的:PBR、环境光照、阴影、雾、实例化、骨骼、顶点变形、色彩空间管理,全套白拿。

这就是它的核心价值,而且大多数人理解错了这个价值。他们以为注入是为了“省代码”。不全是。注入真正买来的是“视觉一致性”——你做出来的东西和场景里其他物体共享同一套光照、同一套阴影、同一套色调映射,玩家的眼睛立刻把它归到“同一个世界”里。这是手写材质花十倍力气也换不来的。

你得知道“往哪儿插”

内置着色器是按顺序拼的,注入点选错,代码跑了但效果被后面的块覆盖掉——这是新手最常见的困惑:明明注入成功了,画面没变化。

想干的事该插在哪个阶段典型效果稳定度
改顶点位置顶点阶段,位置计算之前风吹草动、物体膨胀、波浪高,最安全
改屏幕位置顶点阶段,投影之后顶点抖动、低精度吸附中,注意阴影要同步
改基础色片元阶段,漫反射色计算处程序化纹理、渐变、贴花中高,注意色彩空间
改最终颜色片元阶段,光照累加之后边缘光、色差、噪点低,这里改过名
改输出前片元阶段,最末尾抖动、屏幕级滤镜中,会被色调映射影响

看到“这里改过名”那行了吗?那是我凌晨三点那次事故的根源。Three.js 在 r15x 前后重构了片元着色器的收尾部分,把原来那个负责最终输出的代码块拆了、改名了。所有靠字符串匹配往那儿插代码的库,集体失效,而且不报错。

三个必须知道的坑

第一个:程序缓存键。Three.js 会把编译好的着色器程序缓存起来复用,缓存键来自材质的一堆参数。问题在于,你注入的那段代码不在缓存键里。于是你改了自己的注入代码,跑起来发现没生效——因为它复用了上次编译的程序。你必须自己提供一个额外的缓存标识,把注入内容的特征算进去。不写这个,你会遇到“我明明改了但没变”或者更诡异的“两个不同物件的材质串味了”。

第二个:静默失败。字符串替换找不到目标,什么都不会发生。不报错、不警告、不中断。这是所有 shader 注入 bug 里最恶毒的一种,因为你的调试方向会完全跑偏——你会去查光照参数、查材质属性、查渲染顺序,查一整天,就是不查那句没生效的替换。

第三个:变体爆炸。每一份不同的注入代码,都会产生一个独立的着色器程序。二十种材质、五种注入变体,就是一百次编译。GPU 编译着色器是毫秒到上百毫秒级别的事,这些开销会在物体第一次出现在视野里的时候集中爆发——玩家看到的就是一个卡顿。

注入变体数桌面端首次编译累积移动端首次编译累积玩家感知
1 到 5 个基本无感轻微顿一下可接受
10 到 30 个半秒级一到两秒明显掉帧
50 个以上一到两秒三秒以上甚至掉帧到个位数事故级

案例:drei 的 MeshTransmissionMaterial,注入路线的极致样本

要说把注入这条路走到黑的作品,React Three Fiber 生态里的 MeshTransmissionMaterial 是最好的样本。它不是游戏,但它是 Three.js 世界里被用得最多、也被骂得最多的几个材质之一。

先说它要解决的痛点。物理材质自带的透射,本质上是一种简化的“透光”,做出来的玻璃偏塑料感:你看不到玻璃后面真实的场景,看不到厚度带来的体积感,也做不出磨砂玻璃的散射。可屏幕空间里压根没有“后面”——摄像机看不到玻璃背后的东西,因为它被玻璃挡着。

它的解法很聪明,也很粗暴:每一帧把整个场景先渲染到一张离屏纹理上,然后改造材质,让玻璃在片元阶段从这张纹理里采样,采样坐标按屏幕空间位置加上一个折射偏移算出来。为了让粗糙玻璃看起来是模糊的,它做多次采样再平均——采样数设成六次、十六次,开销就是线性地往上翻。为了做出彩虹边,红绿蓝三个通道用不同的折射率偏移各采一次。为了做出“厚玻璃”的体积感,它还会额外渲染一遍背面。你把这些加起来算一下:一块玻璃,可能就是好几次全场景渲染加上几十次纹理采样。

设计意图非常清楚:把写 shader 这件事彻底藏起来,让用户一行标签就拿到电影级玻璃。这个意图完成得漂亮,所以它被大量项目用来做产品展示页、做 hero 物体。

代价也清楚得可怕。每帧额外的整场景渲染,是移动端的死刑。社区里长期有“用了它帧率腰斩”的抱怨,官方文档自己也写得很直白:只给场景里的主角用,别拿它铺一整面墙的玻璃。这句提醒写得像玩笑,其实是血泪。

更应该被记住的是它的脆弱性。它依赖注入点,依赖那些代码块的名字和顺序。Three.js 只要调整了透射相关的部分,它就得跟着发版。这不是作者水平的问题,这是“字符串注入”这条路线的固有属性——onBeforeCompile 不是扩展点,它是官方承认的后门。后门能用,但你不能指望门框的尺寸永远不变。

第三层:NodeMaterial 与 TSL——一次编写,两个后端

第三条路是官方自己押注的未来:节点化材质。

它做的事情,本质上是用 JS 表达式搭一张图。这张图里有节点:这个值来自顶点的局部坐标,那个值来自世界空间法线,两者相乘,再跟一张纹理混合,最后接到“输出颜色”这个插槽上。整张图在编译期被翻译成真正的着色器代码——WebGL2 后端出 GLSL,WebGPU 后端出 WGSL。

一份逻辑,两个后端。这句话是整个设计哲学的浓缩,也是它存在的唯一理由。

为什么非要做这件事

你站在引擎维护者的角度想一下就明白了。WebGPU 是趋势,但你不能明天就把所有 WebGL 用户扔了。那意味着同一个效果得维护两套着色器代码。这不是两倍工作量的问题——两套代码会各自演化,半年后它们的行为就不一样了,然后你开始修“这个效果在 WebGPU 下偏亮”这种鬼问题。维护成本是指数级的。

节点图是唯一现实的中间层。除了跨后端,它还顺手解决三件字符串时代解决不了的事:

可组合。字符串拼接的组合方式是复制粘贴。你写了个边缘光,A 材质用了一份,B 材质又抄了一份,后来要调整强度曲线,你得改两处。节点图里边缘光是一个函数,接上插头就能用,改一处全生效。

可序列化。节点图是数据结构,能存成 JSON,能进可视化编辑器,能被工具读、被工具改。字符串不能——字符串只是一堆文本,工具没法理解它。Three.js 官方的节点编辑器之所以做得出来,前提就是这个。

可优化。编译器能看到整张图,能做常量折叠、能砍掉没人用的分支。字符串替换做不到,因为编译器不知道你这些字符串之间的语义关系。

但代价同样真实

说句实话,TSL 今天的体验还谈不上舒服,四条:

  • API 没稳定。r16x 那段时间,节点名和写法改了好几轮。跟着教程敲的人经常一觉醒来满屏报错,而报错信息还特别不友好。
  • 调试体验差。报错指向的是生成出来的着色器,不是你写的 JS。你得反过来推:我那个节点在这一大坨生成的代码里对应哪一句?这活儿干起来像在读汇编。
  • 生态真空。你搜不到答案。不是因为问题太难,是因为没人写过。
  • 逃生舱不优雅。要在节点图里插原生代码,得专门包一层特殊节点。包下去的那一刻,你就等于承认“这里我放弃了跨后端”。

所以我的态度是:TSL 在降低入门门槛的同时,抬高了精通门槛。你能很快拖出一个能跑的东西,但当它跑得不对的时候,你比写文本着色器时更难搞清楚为什么。

案例:官方那批 TSL 重写示例,和它背后的行业共识

Three.js 官方在近两年的 WebGPU 示例里,用 TSL 把一批经典效果重写了:射线步进的体积效果、海洋、星系粒子。这些示例最有价值的一点不是画面,是它们真的能在 WebGL2 和 WebGPU 两个后端上跑同一份代码。这在字符串时代想都别想——你手写一份 GLSL,WebGPU 那边就得再来一份 WGSL。

官方自己在做这件事,意义不小。它等于官方自己试了一次水:这条路可行,而且维护成本从“两套”降到“一套”。对引擎作者来说,这笔账算得非常清楚。

但你在项目里抄这些示例的时候要小心两件事。一是它们的可读性对新手不友好,节点图的表达方式对没写过函数式的人有点绕。二是它们随版本变化很频繁,你今天抄进项目,半年后升级一次可能就跑不起来了。我在一个项目里就这么干过——从一个示例里扒了半套体积光,跑得挺好,结果升了个版本,整段效果直接静默消失,控制台依然干干净净。

这里插一个跨引擎的对照,能帮你看清这件事的分量:Babylon.js 早在 2019 年就上了 NodeMaterial,还配了可视化编辑器。Unity 有 Shader Graph,Unreal 有材质编辑器。所以“节点化材质”根本不是 Three.js 的发明,它是整个实时渲染行业的共识。Three.js 只是后发追赶,而且追的时候还得兼顾 Web 平台特有的后端碎片化。

知道这一点,你对 TSL 的期待就会变得现实一些:它不是在炫技,它是在补一门别人六年前就补上的课。

第四层:跨后端兼容与迁移——怎么选、怎么不翻车

前三层讲的是“有什么”。这一层讲“怎么用”,因为现实情况是:绝大多数项目今天仍然必须以 WebGL2 为保底,同时又要为 WebGPU 留好路。这不是技术洁癖,这是浏览器兼容的现实。

先明确一个容易踩的认知坑:传统的 ShaderMaterial 和 onBeforeCompile,在 WebGPU 后端下是二等公民。WebGPU 那一套渲染器走的是节点材质体系,你对内置着色器做字符串注入的那套手法,在那边不一定有对应物。所以“我的项目里全是手写 GLSL,等 WebGPU 普及了自然就切过去了”这个想法是错的——到时候你面对的是重写,不是切换。

我的建议是三层兼容策略,从内到外:

第一层,材质层做一层抽象。团队内部统一一个“材质工厂”,业务代码只说“我要一个带边缘光的标准材质”,具体是走注入还是走节点,由工厂决定。这层抽象很薄,但它让你换路线时只改一处,而不是翻遍全项目。

第二层,列一张降级表。哪些效果在低端设备上直接关掉。这张表必须提前写,不能等玩家投诉。玻璃折射加低端机,等于自动播放幻灯片。

第三层,版本锁定加升级窗口。Three.js 没有严格的语义化版本,一次小版本号跳跃就可能炸掉你的注入。把升级当成项目级事件来处理:锁版本、建分支、专门排期验证材质,别让它混在日常提交里。

至于从注入迁移到节点,别搞大爆炸。新功能走新路,旧功能不动。你会在半年内发现新代码的比例越来越高,某一天旧的那部分自然就该退休了。

这里有个判断标准特别值钱:该不该上 TSL,不看“它稳不稳”,看“你的项目还要活多久”。如果这是个两周做完的营销页,别碰。如果这个项目还要活两年,那今天写的新材质就该考虑用节点了——因为两年后,你总得迁移一次,早迁比晚迁便宜。

参数化设计工具:三张表定路线

下面三张表是我自己在项目里实际用的,你可以直接抄走当评审材料。

表一:路线选型决策表

你的真实需求推荐路线一次性成本长期成本风险
改个颜色、加个渐变、加个边缘光注入小补丁半天低,但每次升级要验中
改光照模型、加自定义 BRDF注入 或 独立材质2 到 3 天中高中高
完全不受光的效果(天空、全屏、粒子)ShaderMaterial1 到 2 天低低
要完整吃光照、阴影、雾的实体注入3 到 5 天中中高
要同时跑 WebGL2 和 WebGPU节点材质1 到 2 周学习期中高,API 还在动
要做材质编辑器、要能存盘节点材质2 到 4 周高,但一次投入长期吃高

表二:性能预算建议区间

这些数字不是标准,是我在几个项目里踩出来的经验带,仅供你定初始值:

指标桌面建议移动建议为什么是这个量级
单材质注入代码行数150 行以内60 行以内超过就说明它该独立成一个材质了
同时存在的材质变体数30 以内10 以内每个变体一次编译,一次卡顿
单个程序首次编译耗时50 毫秒内120 毫秒内超过这个值必须预热
单材质的纹理采样器数8 个以内4 个以内移动端纹理单元有限
每帧 uniform 更新次数200 次以内80 次以内批量更新,别一个个赋值
额外的离屏渲染趟数1 趟以内0 趟折射玻璃的头号杀手
注入代码里能省的分支全平铺全平铺,不留动态分支分支预测在移动 GPU 上很贵

表三:升级风险自查清单

检查项危险信号处理
你用了几种注入点超过 3 种集中到一个文件,写清每处插槽语义
你的替换有没有失败保护没有替换后校验结果,找不到就走降级
你有没有写缓存标识没有必须写,按注入内容的特征算
你的项目锁版本了吗用的是浮动版本锁死,升级单独排期
升级验证覆盖到材质了吗只跑了主流程每个自定义材质都摆在场景里过一遍

一句话总结这张清单:把所有“依赖框架内部细节”的代码集中到一个抽屉里。升级那天,你只需要把抽屉整个拉出来检查一遍,而不是在十万行里翻找哪一行偷偷摸进了别人家。

双路径对照:你今天是哪种处境

路径 A:初级用户,今天就得把效果做出来

别急着学 TSL。这条路的目标是用最少的投入拿到能上线的东西。

  • 先分拣。把你要做的效果分成两类:不受光的(天空、全屏、粒子、描边)走 ShaderMaterial,受光的(实体、道具、角色)走注入。分对这一步,你就省了一半麻烦。
  • 注入只做小补丁。边缘光、渐变、程序化纹理、色差,这四类占了你八成需求,而且每类都能在几十行内搞定。
  • 三件保命的事。写缓存标识;替换之后校验一下是否成功,失败就走降级方案;把所有注入点集中在一个文件里,每处加注释写明“我假设这里有什么”。
  • 卡顿靠预热绕。加载界面的时候,把用到的材质在一个离屏的一像素小目标上先渲染一帧,把编译提前吃掉。这招很土,但它是所有优化里性价比最高的一个——玩家在加载界面等两秒,和在关卡里卡一下,体感完全不是一个量级。
  • 不追新。看到 TS L 的文章收藏就好,别动手。你现在的项目不值得为它承担 API 变动的风险。

路径 B:进阶用户,项目要活两年以上

这条路的核心不是技术选型,是给自己留后路。

  • 现在就开始写节点材质的新代码,但只写新的。别动存量。存量代码是资产,不是债,硬改只会两头空。
  • 建一层材质工厂。哪怕只有五六个材质,也要过这一层。它是你未来换路线的唯一缓冲。
  • 建降级表。把每个效果标注“低端设备的处理方式”。你会发现有些效果在低端机上的替代方案,其实比原版更好看——因为简单的东西往往更干净。
  • 把升级当项目。排期、建分支、写材质回归清单。别信“这个版本应该没影响”,我每次这么想的时候都会被打脸。
  • 接受“两套并存”这个现实。过渡期就是会两套并存,想一步到位的人最后通常一个都没做完。

我的态度:如果这个项目只活三个月,别碰节点材质;如果它能活两年,你今天写的第一行新材质代码就该是节点材质。判断依据从来不是“这技术稳不稳”,是“你有没有时间为未来付首付”。

争议与常见坑:那些不报错但会要命的事

坑一:把 onBeforeCompile 当稳定扩展点。它是官方 API,文档里写着,但官方从来不承诺它拿到的着色器源码长什么样。你注入的其实不是“扩展点”,是“框架内部实现的一段文本”。这两者的区别是:前者有契约,后者只有此刻。

坑二:忘记缓存标识。你改了注入代码,跑起来没变化。你会去查光照、查材质、查渲染顺序,最后发现是程序缓存复用了旧版本。这个坑最坑的地方在于它表现得很“合理”——有时候生效有时候不生效,取决于你先渲染了哪个物体。

坑三:在循环里改材质然后标记需要重编译。很多人做参数联动的时候这么干:每一帧改一点墨色,就重编译一次。每一次重编译都是一个全新的着色器程序,内存一路涨,帧率一路掉,最后在手机上直接崩。着色器该做的是把变化量做成 uniform,一遍编译,千遍变化。

坑四:以为着色器越复杂画面越好。说句得罪人的话:绝大多数项目的画面提升,来自三个参数的调整——法线贴图强度、粗糙度曲线、边缘光。这三样调对了,比你在片元里塞五百行噪声有用得多。我见过太多人沉迷写复杂的着色器,最后画面还不如内置材质调得好。

坑五:把 TSL 当成“现在就能全量迁移”的方案。不能。它的 API 还在动,生态还在真空期。今天能做的是“新代码用新路”,不是“推倒重来”。

还有一个争议我得摆出来:到底要不要 fork 一份 Three.js 回来自己改?有些团队被版本变更折腾怕了,就想锁死甚至 fork。我的看法是,除非你有专职的图形工程师,否则别。fork 之后你会失去整个生态——社区的坑别人的修复,你一样都吃不到。更好的做法是把依赖收窄:只在极少数地方碰内部细节,其余全部走公开接口。

FAQ

Q1:我只会 GLSL,现在要不要花两周学 TSL?

看你的项目生命周期。三个月内的项目,不学,用你会的把东西做出来。两年以上的项目,学,但别指望两周能精通——两周只能到“能拖出一个能跑的东西”,真正难的是它出错的时候你怎么查。我的建议是先只看官方的节点示例,找一个你真需要的效果重写一遍,其他的先放着。

Q2:注入的代码明明替换成功了,为什么画面没变化?

三个排查顺序。第一,看插槽位置——你是不是在光照累加之前改了颜色,然后被后面的光照块整个覆盖掉了?第二,看缓存标识——是不是复用了旧的程序?第三,看你改的值是不是被后面的色调映射和色彩空间转换吃掉了。这三条覆盖了我遇到的九成情况。

Q3:同一个材质,用在两个物体上表现不一样,是什么鬼?

九成是缓存标识没写对,两个物体共用了某个编译结果。剩下一成是顶点属性缺失——比如你的材质依赖切线,但其中一个模型的网格压根没导出切线数据,那一边就会算出乱七八糟的结果。

Q4:着色器编译导致的卡顿怎么解?

预热。在加载阶段把用到的每种材质变体都在一个最小的离屏目标上渲染一帧,逼它把程序编译出来。这么做要占一点加载时间,但把卡顿从“关卡中间突然顿一下”挪到“加载条多走半秒”,这个交换永远划算。顺带说一句,材质变体数是这条路的根,变体少一半,预热开销也少一半。

Q5:我们团队要不要直接跳到 WebGPU?

这不取决于你,取决于你的用户用什么浏览器和什么设备。现实的做法是双后端并行,用节点材质当中间层,然后等数据说话。你可以在后台悄悄采集一下用户端的 WebGPU 可用率,等这个数字让你安心了再切默认后端。别凭感觉,凭数据。

最后留个问题给你:如果你的项目明天要加一个“会发光的半透明护盾”,你会走哪条路?如果你第一反应是“写个着色器”,那说明你还停留在 2012 年;如果你第一反应是“先看看内置材质能不能注入”,那你在 2020 年;如果你第一反应是“这个项目还要活多久”,恭喜,你终于开始算账了。

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