前端手写像素风 vs 游戏侧特效工具:同一审美,两套工程答案
前端手写像素风 vs 游戏侧特效工具:同一审美,两套工程答案
像素风特效有一个尴尬的处境:审美标准是统一的(高对比轮廓、色阶分明、白热核心、抖动过渡),但实现它的工程路径却被平台硬生生劈成了两条。
一条在浏览器里:没有粒子发射器,没有编辑器时间轴,只有 Canvas 2D、一个 ImageData 和一堆 CSS 属性,开发者要靠代码一像素一像素地把火焰"算"出来。另一条在游戏引擎里:GPUParticles2D、ShaderMaterial、翻页动画、可视化调参面板,美术和程序各有各的入口。
社区里这两条路的声量都很真实。前端侧,一篇讲 CSS 渐变锯齿问题的文章能拿到 1.5 万阅读、76 个赞;讲用 CSS Houdini 的 paintWorklet 画像素边框的实践有十几条评论在讨论可行性;而"一张 12MB 的照片拖垮页面"的 ImageSource / PixelMap / ImagePacker 工程链路也有 1.1 万阅读——说明大家都在同一个坑里:浏览器很擅长排版和合成,但从不擅长"以 1 像素为原子"地作画。游戏侧则相反,Godot 社区的经验贴反复强调 GPUParticles2D、着色器、纹理 2 的幂次、预乘 Alpha、最近邻过滤这些"引擎味道"很重的话题。
pixelfx 这个仓库有意思的地方在于,它同时给出了这两套答案:232 个纯代码的像素特效(src/fx/ 下 232 个效果文件,加上 20 个 _lib.js 和索引文件,共 252 个 JS 文件、约 3.97 万行;内核实心只有 src/core/ 下 11 个文件、1564 行),以及一套把同一份代码导出成引擎友好资源的工具链。
同一个"冰霜新星",在浏览器里是一段 update(dt) + draw(p),在 Godot 里是一张 2592×2304 的图集加一份 JSON。这篇文章就沿着这条分岔路,把两边的实现手段、限制边界和真正可复用的统一方案讲清楚。
先看一个具体效果:同一份美术意图,两种交付物
以 ice/frost-nova 为例。它的元数据写在文件顶部,这是一份契约,而不是注释:
// src/fx/ice/frost-nova.js
export const meta = {
name: "Frost nova",
tags: ["ice", "nova", "aoe", "frost", "magic", "one-shot"],
size: [288, 192],
origin: [144, 150],
duration: 3.4,
loop: false,
fps: 30,
bg: "ground",
actor: 2,
options: { palette: ["#151a3d", "#212f6b", ...], reach: 104, seed: 4 },
};
短短十几行里已经把三件事钉死了:
size/origin决定画布与锚点。锚点是"施法者脚下",不是画布中心,这样特效才能跟着角色移动。duration: 3.4+fps: 30决定帧数:3.4×30 = 102,一次性特效再多渲染一帧收尾,共 103 帧。actor: 2表示这是一个"会包裹角色"的效果——240×38 的标准替身小人(src/core/actor.js)会被冻住、被描边、被遮罩。
引擎侧拿到的就是这 103 帧:
"size": { "w": 2592, "h": 2304 },
"frameTags": [{ "name": "frost-nova", "from": 0, "to": 102, "direction": "forward" }],
"pixelfx": { "id": "ice/frost-nova", "fps": 30, "loop": false, "frames": 103,
"frameSize": [288, 192], "pivot": [144, 150], "columns": 9 }
9 列 × 288 = 2592,12 行 × 192 = 2304,pivot 就是 origin 原样搬过去。这份 JSON 是 Aseprite 风格的(frames[] 里带 frame 矩形、duration),因此 Phaser 的 atlas loader、Godot 与 Unity 的 Aseprite 导入器都能直接读,而 meta.pixelfx 这段私有字段承载了引擎侧真正需要的三件事:帧率、是否循环、轴心在哪。
浏览器侧:能做什么,以及被什么卡住
手段比想象中多,但都不是为像素画的
前端做像素风,可选的路子大致四类,社区里都有人踩过:
| 手段 | 谁在用它 | 真正的坑 |
|---|---|---|
CSS 渐变 / 多层 box-shadow |
像素风 UI 组件库 | 渐变必然产生子像素过渡,放大后是锯齿与涂抹感,需要额外的抗锯齿或"硬分阶"处理 |
SVG / CSS paintWorklet |
像素边框(Houdini) | 灵活度和动态性极好,但绘制逻辑跑在 worklet 独立作用域里,需要单独构建产物;且只能画"静态几何" |
| 位图序列帧 | 传统做法 | 体积与解码成本;一张大图会直接吃掉主线程与内存 |
| Canvas 2D 逐像素 | pixelfx 这类代码驱动方案 |
一切都要自己写:采样、抖动、光照、混合 |
paintWorklet 那条路的社区反馈很有代表性:作者用它做了像素风按钮边框,能通过 CSS 变量实时改边框宽度、圆角、阴影位置,评价是"动态可控、性能好、可组合"。但它解决的是形状与描边,解决不了"一团火焰每帧怎么变、光怎么衰减、火星怎么弹跳"。后者需要的是仿真,不是绘制。
反过来,位图路线在前端也未必便宜。讲 PixelMap 工程化的那篇文章开篇就点出问题从"从相册选一张图、轻量处理、预览、导出"开始——听上去简单,实际整条解码/编码链路都要精打细算。对像素特效来说更糟的是:序列帧一旦要换色(蓝色火焰、粉色治疗光),要么重画,要么在运行时做调色板映射。
pixelfx 的选择是第四条路,而且把约束压到了极致:没有一张图片。docs/AUTHORING.md 开头那句是硬规定——"It has no images and no dependencies beyond src/core"。
关键实现:两个 32 位缓冲区
整个库的地基在 src/core/fx.js 的 createFrame:
export function createFrame(w, h, ox = 0, oy = 0) {
return { w, h, ox, oy, color: new Uint32Array(w * h), light: new Uint32Array(w * h) };
}
两个 Uint32Array:color 存不透明像素,light 存加色光。它们的内存布局刻意做成和 ImageData 一致(src/core/color.js 注释:"Colors are 32-bit integers laid out like ImageData bytes (R, G, B, A in memory)"),所以整块 buffer 可以近乎零拷贝地喂给 Canvas。
这里有个容易被忽略的工程决策:像素画不做颜色插值。color.js 里 at() 的注释写得很直白——"pixel art picks a color, it doesn't fade between two":沿色阶取整档,而不是在两个色之间混合。只有光(light)和半透明体积(烟雾、水汽)才允许平滑过渡。
半透明怎么处理?src/core/painter.js 用 4×4 有序抖动(Bayer 矩阵),而不是 alpha 混合:
const BAYER = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5].map((v) => (v + 0.5) / 16);
// ...
put(sx, sy, c, a = 1) {
a *= this.fade;
if (a < 1 && a <= BAYER[((sy & 3) << 2) | (sx & 3)]) return; // 低于阈值就不画
...
}
这就是"像素风淡出"和"CSS opacity 淡出"的根本差别:前者是离散地丢掉像素,后者是连续地降低不透明度。前者缩小看有颗粒感,后者缩小看是雾。
合成的三行核心逻辑
composite() 是浏览器侧最后一步,也是整个"看起来像游戏"的秘诀:
if (l) {
const lr = (l & 255) * lightK, lg = ((l >>> 8) & 255) * lightK, lb = ((l >>> 16) & 255) * lightK;
if (a < 255) {
const pa = a / 255, pr = r * pa + lr, pg = g * pa + lg, pb = b * pa + lb;
const na = Math.min(1, Math.max(pa, Math.max(lr, lg, lb) / 255));
if (na > 0) { r = Math.min(255, pr / na); ... a = na * 255; }
} else {
r = Math.min(255, r + lr); ...
}
}
注释里的那句是关键:"over transparency, light becomes color with alpha (its brightest channel), which reads as additive over dark backgrounds"。光在透明背景上会被"烘焙"成带 alpha 的颜色——这正是同一份代码导出成 sprite sheet 之后,引擎在暗色场景里还能读出"发光感"的原因。这是一个为了跨端妥协、但妥协得非常准确的公式。
浏览器真正的限制,不在渲染,在调度
把特效跑在浏览器里,性能杀手通常不是"算不出来",而是三个地方:
-
主线程逐像素。每个效果每帧都要遍历自己的画布范围,
frost-nova是 288×192≈5.5 万像素,nuke是 400×320=12.8 万像素。仓库自带的tools/check.mjs会对每帧耗时打警告,我实测了三个效果:fire/torch、ice/frost-nova通过,explosions/nuke报slow: 5.3 ms a frame。注意docs/AUTHORING.md里写的质量底线是 2 ms 一帧,脚本的告警阈值却是 4 ms——文档比脚本更严,这是有意留的余量。 -
缩放与设备像素比。像素画最怕"非整数缩放"。
gallery/app.js里的处理相当克制:
// shrinking pixel art nearest-neighbour drops whole 1 px lines; smooth it only when it has to shrink
const shown = this.canvas.getBoundingClientRect().width * devicePixelRatio;
this.canvas.style.imageRendering = shown && shown < this.W ? "auto" : "";
只有当显示宽度小于原始像素宽度(必须缩小时)才关闭 pixelated,否则一律最近邻。这条规则值得所有像素风网页抄走。
- 页面里同时有几个 canvas。画廊的做法是
IntersectionObserver+ 离屏暂停:只有滚进视野的 tile 才创建Player,滚出去就不再tick。另外还尊重prefers-reduced-motion——开启减弱动效时不是停播,而是seek(duration * 0.4)定格在一帧最有信息量的画面上。
游戏侧工具链:优势区间在"规模"和"管线",不在审美
Godot 社区的实践总结得很清楚:GPUParticles2D 负责"大量、同类、可并行"的粒子;ShaderMaterial 负责"整体形变、流光、扭曲";而像素风特效的关键是用预绘的精灵表当粒子纹理,再配合调色板映射保证风格统一。
这恰好和 pixelfx 的导出物严丝合缝。tools/render.mjs 的 --sheet 会写出透明 PNG 网格 + JSON:
node tools/render.mjs ice/frost-nova --sheet
# -> records/ice/frost-nova/frost-nova.png (2592x2304, 103 帧)
# -> records/ice/frost-nova/frost-nova.json (Aseprite 风格帧表 + meta.pixelfx)
整库导出则是 node tools/sheets.mjs,按 sheets/<category>/<name>.png + .json 铺开,并生成一份 sheets/index.json 索引(含 id / fps / frames / frameSize / pivot / columns)。这份索引对引擎侧特别重要——它让"加载哪个图、按几帧播、轴心在哪"变成数据,而不是散落在美术的记忆里。
游戏侧真正的优势区间可以列成一张对比表:
| 维度 | 浏览器手写(Canvas 2D) | 引擎工具链(Godot / Unity 等) |
|---|---|---|
| 粒子规模 | 数百到数千,主线程逐像素 | 万级,GPU 并行 |
| 混合与光照 | 自己实现加色、抖动、alpha | 内置混合模式、2D 光照、后处理 |
| 深度排序 | 靠 draw(frame, "back" / "front") 两遍 |
原生 z-index / 图层 |
| 参数调试 | 改代码 + 重渲染 | 编辑器实时拖参数 |
| 逐实例变色 | 传 palette 选项即可 |
需要材质实例或调色板贴图 |
| 跟随移动目标 | 天然支持(每帧算位置) | 需要脚本驱动或粒子跟随 |
反过来,浏览器侧赢在"运行时可变":createFx(mod, { palette, seed, flip, angle, light }) 里,任何一个色阶都能在运行时替换。src/core/color.js 里预置了 27 组色阶(fire / ice / holy / poison / neon / cyber / matrix / candy……),雪可以用粉色,治疗光可以发蓝,一行选项就够:
node tools/render.mjs fire/torch --gif --opts '{"palette": ["#102","#215","#43a","#8cf","#cff","#fff"]}'
这份能力在引擎侧反而是弱项:同一张图集想做"冰火双形态",要么多渲一套,要么加一层材质与查找表。
两套答案共用的底座:确定性 + 可校验
真正让"同一份美术意图能落到两个平台"的,不是渲染技术,而是时间与随机数的纪律。
一切随机都必须有种子
src/core/math.js 里 Rng 是 mulberry32,rand(...) 是对整数做哈希的确定性伪随机:
export function hash(...ns) {
let h = 0x9e3779b9;
for (const n of ns) { h = Math.imul(h ^ (n | 0), 0x85ebca6b); h ^= h >>> 13; h = Math.imul(h, 0xc2b2ae35); h ^= h >>> 16; }
return h >>> 0;
}
export const rand = (...ns) => hash(...ns) / 4294967296;
tools/check.mjs 会直接扫源码,命中 Math.random 就判失败:
if (/Math\.random/.test(src)) errs.push("uses Math.random: use rng/rand/burst/cycle so frames repeat");
我实际跑了一遍校验工具,结果很干净:
ok fire/torch
ok ice/frost-nova
warn explosions/nuke
slow: 5.3 ms a frame
3 effects: 3 pass, 0 fail, 1 with warnings
两种效果,两种时间模型
这是整个设计里最值得学的部分。docs/AUTHORING.md 把效果分为两类:
- 纯函数型(Pure):导出
draw(p, t, o),第 t 秒的画面只由 t 决定。适合循环效果(火焰、传送门、瀑布)。因为没有任何跨帧状态,t = 0与t = duration天然对齐,不存在接缝。 - 仿真型(Simulated):导出
create(o)返回{ update(dt), draw(p), drawBack?(p) }。适合一次性效果(爆炸、命中、碎裂),要火星弹跳、碎块翻滚、烟雾翻卷。
仿真型 + 可变帧率 = 物理结果不一致,这是跨端最大的坑。解决方案在 createFx 里:
update(dt) {
t += dt;
if (!impl.update) return;
// simulations step at 120 Hz or finer whatever the caller's frame rate, so they look the same everywhere
const n = Math.max(1, Math.ceil(dt * 120 - 1e-9));
for (let i = 0; i < n; i++) impl.update(dt / n, opts);
}
不管调用方是 30 fps 的离屏渲染、60 fps 的浏览器,还是 144 fps 的显示器,粒子物理都以 120 Hz 为最小步长推进。src/core/sim.js 里 GRAVITY = 950(px/s²),单位是"美术像素",这样重力、初速、阻尼都能写成可读的数字,而不是某台机器上的魔数。
校验工具把"审美"变成了可自动化的门槛
tools/check.mjs 检查的不是"好不好看",而是那些眼睛容易漏、上线才炸的问题:
| 检查项 | 判据 | 为什么重要 |
|---|---|---|
| 画布溢出 | 在 size 外围留 24px 边距后统计越界像素 |
光晕被画布边缘切断,进游戏就是一个方框 |
| 一次性效果是否收干净 | t = duration 时画布上必须为空 |
否则残影会永久挂在场景里 |
| 循环接缝 | 末帧→首帧的像素变化量 ≤ 常规步进 2 倍 | 否则循环时有"跳帧"感 |
| 短色板容错 | 传入 4 阶色板时不能出现 undefined 颜色 |
强制用 fit(o.palette, n) 重采样 |
| 确定性 | 同一 t 画两次必须完全一致 |
否则帧 40 每次都不一样,无法导出图集 |
| 每帧耗时 | 中位数 > 4 ms 告警 | 移动端与低端机的余量 |
fit() 的重采样逻辑在 color.js:
export function fit(r, n) {
r = r.map(hex);
if (r.length === n) return r;
return Array.from({ length: n }, (_, i) => r[Math.round((i * (r.length - 1)) / Math.max(1, n - 1))]);
}
效果代码里通篇写 C[5]、C[6] 这样的按序号取档,长度由 fit 拉到固定阶数,于是调用方传 4 阶还是 9 阶都不会画崩。这个约定让"任意调色板"从口号变成了静态可验证的性质。
跨端统一风格的现实做法
把上面的机制串起来,一条可落地的路线是这样的。
1. 一份源,两条出口
同一份特效代码,按场景选出口:
| 场景 | 出口 | 命令 |
|---|---|---|
| Canvas / Phaser / PixiJS / Kaplay / three.js | 直接 import 代码 | npm i github:patch-gg/pixelfx |
| Godot / Unity / GameMaker / Defold / LÖVE / Bevy | 导出图集 + JSON | node tools/render.mjs <id> --sheet |
| 整库交付给美术 | 批量导出 | node tools/sheets.mjs |
浏览器里接入的完整循环只有十行:
import { createFrame, clearFrame, createFx, composite } from "pixelfx";
import * as frostNova from "pixelfx/fx/ice/frost-nova";
const frame = createFrame(320, 180);
const img = new ImageData(320, 180);
const fx = createFx(frostNova, { x: 160, y: 140 });
function tick(dt) {
fx.update(dt);
clearFrame(frame);
fx.draw(frame, "back"); // 角色身后那一半
drawCharacters();
fx.draw(frame, "front"); // 角色身前那一半
composite(frame, img.data, backgroundColor);
ctx.putImageData(img, 0, 0);
}
draw(frame, "back") / "front" 这个两遍绘制接口是为了解决像素特效里最容易被忽略的问题:地面圆环的前半圈应该在角色前面,后半圈应该在角色后面。frost-nova 里的 ring() 就是靠 Math.sin(g) < 0 === back 把一圈光环拆到两个图层。
2. 三处必须对齐的"像素级约定"
跨端要看起来是"同一款游戏",不是"同一套素材",需要三件事对齐:
- 采样方式:图集导入必须最近邻、无压缩、无 mipmap。前端侧对应
image-rendering: pixelated,而且只在缩小时才允许退回平滑。 - 整数缩放:图集里每帧是 288×192,屏幕上就必须是 288×k 或 192×k;k 非整数时,1px 的轮廓会变成 2px 或消失。
- 轴心:
meta.pixelfx.pivot(如[144, 150])是"角色脚下"的位置,不是画布中心。引擎侧把它设成 pivot 后,特效才能跟着单位走。这是把代码侧的局部坐标(docs/AUTHORING.md:"(0, 0) is the anchor: the feet of the character, the point of impact")翻译成引擎概念的唯一桥梁。
3. 该导出还是该移植
skills/pixelfx/SKILL.md 的第 4 节给了一个很实用的判据:如果图集不够用——效果需要跟随移动目标、或者需要每实例运行时改色——就应该移植而不是导出。移植时要保留三样东西:双缓冲结构、4×4 Bayer 抖动阈值、色阶索引。然后"把 JS 原版和你的移植版并排渲染,对比是否一致"。
这句话反过来说明了一件事:这两套工程答案的差异,几乎全部集中在"谁负责播放"上。美术逻辑一旦被写成 t 的函数或固定步长的仿真,它就是可以搬运的;反之,如果特效依赖引擎的私有粒子参数组合,它就永远只能活在那一款引擎里。
顺手一提:AI 生成的像素特效,靠的不是提示词
这个仓库还有一半价值在 skills/pixelfx/SKILL.md——一个 Claude Code 技能,方法论来自 Hugo Duprez 的那篇 "How to make (good) pixel art effects with Claude",核心是三个词:code is clay, trust your eyes, feed your references(代码是泥,相信眼睛,喂参考)。
它的工作流是硬性的四拍循环,而不是一次生成:
node tools/new.mjs arcane/my-spell # 生成可运行骨架
node tools/render.mjs arcane/my-spell # 渲染到 records/arcane/my-spell/contact.png,然后"看"
node tools/check.mjs arcane/my-spell # 溢出、接缝、未播种随机、慢帧
tools/new.mjs 的模板本身就带着两种时间模型的教学:--loop 版本用 cycle(t, duration, 12, seed, ...) 保证首尾相接,非循环版本用 burst + fly + seg 保证 t = duration 时画布为空。而 SKILL.md 里那张"看到什么 / 怎么改"的表格才是真正的工程知识,比如:
| 你看到的 | 该改什么 |
|---|---|
| 1x 缩放下糊成一团 | 减少颜色数、明确剪影、只留一个视觉焦点 |
| 飘、没有打击感 | 快进慢出(ease.outQuart)、1~2 帧纯白 hero frame、总时长缩短 |
| 烟雾出现棋盘格抖动 | 改用 SMOKE / VAPOUR / DUST 粒子或 p.disc,真半透明 |
| 循环有接缝 | cycle、loopNoise(phase)、整格 tileNoise 滚动 |
"烟雾不能是抖动棋盘"这条尤其值得记:它是像素风最容易被误用的一点。抖动适合做硬边淡出(像素消失),不适合做半透明体积(烟雾、水汽)。所以 src/core/particles.js 里 fly() 这类闭式解粒子存在,而 src/core/painter.js 另外提供 blend() / disc() 走真 alpha 混合——两条路并存,按语义选。
结语:不是二选一,而是分工
把两套答案放在一起看,边界其实很清楚:
- 审美层是共享的:色阶分档、白热核心、抖动淡出、环形透视、相位编排(蓄力→爆发→扩散→停留→崩解)。这部分与平台无关,
docs/AUTHORING.md里那 10 条"the bar"就是它的规格说明书。 - 播放层是不共享的:浏览器给的是"每帧一次 JS 调用 + 一块 ImageData",引擎给的是"GPU 粒子 + 材质 + 图层"。所以
pixelfx把"播放"抽象成update(dt)/draw(frame, layer),把"交付"抽象成两种格式(代码或图集)。 - 验证层必须是共享的:确定性、固定步长、收干净、无接缝、色板可换、每帧预算。这六条如果不写死在工具里,任何一套管线都会在项目后期崩掉。
所以"前端手写"和"游戏侧工具"并不是两个竞争方案。真正的问题从来不是"用哪个",而是你的特效有没有被写成一份可以搬运的东西。232 个效果、252 个文件、1564 行内核,这个仓库给出的答案不算最优雅:逐像素、主线程、没有 GPU 加速;但它足够诚实:每一帧都可以重放,每一个颜色都可以替换,每一份产出都能落到两个平台,而且还有脚本替你把关。
在像素风这种"1 像素就是 1 单位"的领域里,能被验证的确定性,比能被调参的灵活性更值钱。