作者注:Saltline 用代码描述几何、纹理和声音的生成规则,因此分发体积很小,但部分工作量被转移到了玩家设备的运行时计算中。
Saltline 只有约 1.4MB,是因为它的单个 HTML 文件里保存的是生成模型、纹理和声音的规则,而不是预先制作好的模型文件、贴图和音效。浏览器打开文件后,JavaScript 和 Shader 在本地实时构建出雨夜港口、集装箱和无人机。程序化生成改变了游戏资源的表达和交付方式:下载量大幅减少,同时 CPU 构建几何、GPU 计算像素的工作量相应增加。文件体积、运行内存和 GPU 负载是三笔独立的账。
下文先拆开这个 1.4MB 文件的构成,再对照传统游戏的资产生产方式,接着用集装箱、金属材质和雨水三个例子说明程序化几何、程序化纹理、Shader 和程序化音效各自如何工作,然后分析小体积背后的运行时成本,最后给出一段可运行的代码,演示如何通过 API 让大模型生成同类程序化场景。

To Know:程序化 3D 游戏术语预备
| 术语 | 解释 |
|---|---|
| 程序化几何 | 按参数和规则创建顶点与模型形状,例如用长宽高生成一个箱体 |
| 程序化纹理 | 通过数学函数(如噪声)计算出表面颜色和图案 |
| Shader | 在 GPU 上执行的小程序,决定每个顶点的位置和每个像素的颜色 |
| 噪声函数 | Perlin、Simplex 等算法,能生成自然、不规则的随机图案 |
| 实例化渲染 | 一次绘制调用画出大量相似物体,Three.js 中对应 InstancedMesh |
| WebGL | 浏览器提供的 GPU 图形接口,让网页能渲染 3D 画面 |
| Three.js | 基于 JavaScript 的 Web 3D 图形库,封装了场景、相机、材质等概念 |
| HTML | 组织网页内容和代码的文件格式,Saltline 的全部核心代码都在一个 HTML 文件中 |
| 分发体积 | 玩家需要下载的文件数据量 |
| 运行内存 | 程序执行时占用的内存,包括运行时生成的几何体和纹理 |
| GPU 负载 | 图形处理器每一帧需要完成的计算量 |
| Token | 大语言模型处理文本的基本单位,也是 API 计费单位 |
1 1.4MB 的 HTML 文件里装了什么:Saltline 单文件架构
1.1 Saltline 是一个什么样的 AI 生成 3D 游戏
2026 年 11 月 9 日,Anthropic 工程师 Felix Rieseberg 公开了一项 Claude Fable 5.2 编程实验:用一条提示词,要求模型制作一款视觉效果尽量接近 AAA 游戏的小规模第一人称射击游戏,过程中不提供人工反馈。产出就是 Saltline。
游戏设定在雨夜的集装箱港口,玩家要关闭三个信号中继站并撤离,敌人是空中巡逻无人机和地面机械猎犬。它支持第一人称移动、射击、交互和任务目标,带有雨水、灯光、环境音效和武器效果,提供画质设置。它是单人、单关卡的可玩原型,“3A”是实验目标和视觉上的类比。国内社交平台传播的“几猫·国产3A大作”是 Saltline 的中文版本或重新包装版本,名称来自传播过程。
开发者自述的数据如下,均为其本人在 X 上公布的估算,未经第三方审计:
- 开发时间约 8 小时;
- 按 API 定价估算的成本约 550 美元;
- 输入 Token 约 4.45 亿,其中大量使用了缓存;
- 输出 Token 约 270 万。
由于输入 Token 大量命中缓存,这笔账无法简单用普通输入单价乘以总量来复算,具体账单结构也没有公开。这 550 美元属于一次性生成成本,玩家在浏览器里游玩时不会再调用模型。
1.2 index.html 的构成:Three.js、生成代码与外部字体
GitHub 镜像仓库给出了精确数据:核心文件 index.html 为 1,425,707 字节,约 1.43MB(1.36MiB)。这个文件的构成可以概括为四部分:
- Three.js 运行代码:整个 3D 库被打包进 HTML,负责场景、相机、材质和 WebGL 渲染;
- 场景与资产生成代码:几何体、纹理、材质由 JavaScript 函数和 Shader 构建;
- 程序化音频代码:声音同样由代码合成,仓库中没有独立音频文件;
- 游戏逻辑:输入控制、敌人行为、任务流程。
仓库中没有独立的图片、视频和音频文件。唯一明确的外部依赖是 Google Fonts 字体。开发者在 11 月 10 日补充说明,游戏中的所有内容都是代码,纹理和模型都是函数。
1.3 浏览器打开 Saltline 后发生了什么
运行流程是一条清晰的本地流水线:浏览器读取 HTML → JavaScript 开始执行 → 初始化 Three.js 和 WebGL 渲染环境 → 代码生成场景几何、材质、纹理和声音 → GPU 每帧渲染画面 → 玩家用键盘和鼠标操作,游戏逻辑持续更新。
这条流水线中,“生成资产”这一步发生在玩家设备上。Saltline 官方体验页也提示:页面初始化可能需要较长时间,设备性能会影响启动速度;卡在等待画面时应检查 WebGL 2 和浏览器硬件加速;卡顿时可切换到 Low 画质。这些提示本身就说明了运行时计算的分量。

2 传统游戏如何制作模型、纹理和声音
2.1 传统 3D 游戏的三类核心资产
传统 3D 游戏的画面和声音主要来自预先制作好的资产文件:
- 模型文件:美术在建模软件中制作,保存为顶点、面、UV 坐标等数据;
- 纹理贴图:漫反射、法线、粗糙度、金属度等多张图片,贴在模型表面提供细节;
- 音效文件:录制或合成后导出的音频,在特定事件触发时播放。
这些资产经过制作、优化、压缩和打包后随游戏一起分发。引擎在运行时加载它们,主要工作是“读取并显示”。
2.2 传统资产为什么会占据大量空间
预制资产保存的是结果。一张高分辨率贴图要记录每一个像素的颜色值;一个精细模型要记录每一个顶点的位置;一段音效要记录每一个采样点。场景越丰富、分辨率越高,需要记录的结果数据就越多,体积随之线性增长。
程序化方式保存的是过程。一个噪声函数只需几十行代码,却能在任意分辨率下产生锈迹图案;一个参数化箱体函数可以生成任意尺寸的集装箱。这就是 1.4MB 能承载一个完整港口场景的根本原因。
| 对比维度 | 传统预制资产 | 程序化生成资产 |
|---|---|---|
| 文件中保存的内容 | 最终结果数据(顶点、像素、采样) | 生成规则(函数、参数、Shader) |
| 生产方式 | 美术在专业工具中逐个制作 | 编写代码和参数,运行时计算 |
| 分发体积 | 随资产数量和精度增长 | 主要由代码量决定,通常很小 |
| 运行时主要工作 | 加载、解码、显示 | 构建几何、计算纹理、合成声音 |
| 细节控制力 | 美术可精确控制每处细节 | 依赖算法表达能力,调参成本高 |
| 典型适用对象 | 角色、关键道具、写实场景 | 重复结构、自然表面、天气特效 |
3 AI 如何用代码生成游戏资产:四种程序化技术
程序化生成是游戏行业长期使用的技术,《我的世界》的地形、众多 Roguelike 的关卡都依赖它。Saltline 的新意在于,由 AI 模型在一次持续生成过程中同时写出了几何、纹理、Shader、音频和游戏逻辑的全部代码,减少了建模、材质、音效、编程之间的人员交接。
| 层次 | 生成对象 | 技术思路 | Saltline 中的对应例子 |
|---|---|---|---|
| 几何生成 | 模型形状 | 顶点、面、参数化几何 | 集装箱、仓库、码头结构 |
| 材质生成 | 表面属性 | 颜色、粗糙度、金属度参数 | 集装箱金属外壳 |
| 纹理生成 | 表面细节 | 噪声、分形、Voronoi | 锈迹、污渍、磨损 |
| 环境生成 | 场景布局 | 规则、随机数、空间关系 | 集装箱堆叠排布 |
| 动画生成 | 物体运动 | 数学函数、状态变化 | 无人机巡逻、雨滴下落 |
| 声音生成 | 音效 | 振荡器、滤波器、噪声 | 雨声、枪声、环境音 |
3.1 程序化几何:用参数搭出一个集装箱
集装箱本质上是一个带波纹侧板的长方体。程序化几何的做法是:用长、宽、高参数生成六面体,再沿侧面按正弦函数偏移顶点,模拟瓦楞钢板的起伏。Three.js 的 BufferGeometry 允许直接写入顶点数组,BoxGeometry 则提供了现成的参数化箱体。
港口里有成百上千个集装箱,它们共享同一份几何数据。这时用 InstancedMesh 实例化渲染,只需为每个实例保存一个变换矩阵(位置、旋转、缩放)和一个颜色,就能在一次绘制调用中画出整片集装箱堆场。
3.2 程序化纹理:用噪声函数画出锈迹
程序化纹理通过算法生成纹理数据。常用算法包括 Perlin Noise、Simplex Noise、Voronoi 和分形噪声:叠加几层不同频率的噪声,就能得到自然的锈斑分布;用 Voronoi 能做出剥落油漆的块状边界。
在 Three.js 中,这类纹理通常在初始化阶段计算一次,写入 DataTexture(直接填像素数组)或 CanvasTexture(用 Canvas 2D 绘制),然后像普通贴图一样交给材质使用。纹理生成一次后会常驻显存,运行时的额外开销主要是这份显存占用。
3.3 Shader:在 GPU 上逐像素计算金属与雨水
Shader 运行在 GPU 上,根据坐标、时间、光照等输入实时计算每个像素的颜色。它和程序化纹理的区别在于计算发生的时机:程序化纹理可以预先算好一张图;Shader 则可以每一帧现场计算,不需要生成完整图片。
雨夜港口是 Shader 的典型用武之地。湿润金属表面的反光、地面积水随时间扰动的波纹、雨丝的下落,都可以写成以时间为输入的函数,每帧重新计算。Three.js 的 ShaderMaterial 允许直接编写顶点着色器和片元着色器来实现这些效果。两种方式的权衡很直接:预生成纹理占内存、省算力;Shader 实时计算省内存、耗算力。
3.4 程序化音效:用振荡器和滤波器合成雨声
浏览器的 Web Audio API 提供振荡器、噪声缓冲和滤波器节点。白噪声经过低通滤波器就接近雨声;短促的噪声爆发加上快速衰减的音量包络就是枪声;低频振荡器调制音高可以模拟无人机的嗡鸣。Saltline 仓库中没有任何音频文件,声音全部由这类代码实时合成。

4 文件变小了,运行就更轻了吗:程序化生成的成本分析
4.1 区分分发体积、运行内存与 GPU 负载
衡量一个 3D 游戏的“重量”,至少要看三个维度:
- 分发体积:玩家下载了多少数据。Saltline 在这一项上极具优势;
- 运行内存:运行时生成的顶点缓冲、纹理、音频缓冲都会占用内存和显存,一个 1.4MB 的程序完全可以在运行时创建出数百 MB 的数据;
- 计算负载:CPU 和 GPU 每帧要完成的工作量,复杂 Shader 会直接推高这一项。
反过来,一个体积很大的游戏也可以通过压缩、分块加载和资源流式传输把运行效率做得很好。只用文件体积判断技术路线的优劣,会得出片面的结论。
4.2 程序化生成把成本转移到了哪里
| 技术方式 | 可能减少的成本 | 可能增加的成本 |
|---|---|---|
| 程序化模型 | 模型下载与存储 | CPU 几何构建时间 |
| Shader 纹理 | 图片文件与纹理传输 | GPU 每帧实时计算 |
| 程序化纹理(预生成) | 图片文件下载 | 初始化计算与显存占用 |
| 实例化渲染 | 重复绘制调用 | 场景管理与实例数据维护 |
| 动态生成场景 | 预制资产数量 | 初始化和运行时计算 |
| 程序化音效 | 音频文件存储 | 实时音频合成开销 |
Saltline 初始化较慢、需要提供 Low 画质选项,正是这张表的现实体现:下载阶段省下的工作,在启动阶段和每一帧渲染中被重新支付。
4.3 Shader、实例化渲染与动态几何的取舍
三种技术解决的问题各不相同,组合使用效果最好:
- 实例化渲染降低的是 CPU 向 GPU 发出绘制调用的次数,最适合大量重复物体,例如集装箱堆场、路灯、雨滴粒子;
- Shader把细节计算放到 GPU 上,适合随时间变化的效果(雨水、积水、灯光闪烁),代价是片元着色器越复杂,高分辨率下的 GPU 负载越重;
- 动态几何适合需要按参数变化或数量有限的结构,构建成本集中在初始化阶段,构建完成后就是普通网格。
工程上常见的优化方向是:能预先算好的就在初始化阶段算一次缓存起来,只有必须随时间变化的才放进每帧 Shader。
4.4 Saltline 路线与云游戏、AI 世界模型的区别
“AI 做游戏”在当前至少对应三种技术路线,Saltline 属于第一种。
| 对比维度 | 本地网页游戏 | 云游戏 | AI 世界模型 |
|---|---|---|---|
| 代表案例 | Saltline | GeForce NOW、Pixel Streaming | Genie 3、Muse/WHAMM、Oasis |
| AI 参与环节 | 开发阶段生成代码 | 通常不涉及 | 运行时逐帧生成画面 |
| 画面生成 | 本地 GPU 渲染 | 云端 GPU 渲染后传视频流 | 模型实时预测生成 |
| 网络要求 | 首次加载后可离线 | 持续联网 | 通常需要持续联网 |
| 成本发生时机 | 一次性开发成本,之后由玩家设备承担 | 每次游玩产生服务器成本 | 每次游玩产生推理成本 |
| 主要限制 | 浏览器与本地硬件 | 网络延迟、带宽 | 一致性、延迟、可控性 |
Saltline 把 AI 成本集中在开发阶段,生成完成后,游戏规则由代码确定,运行与模型无关。这一点决定了它可以离线运行,也决定了玩家设备性能是体验的上限。
5 程序化 3D 游戏快速上手:用 API 让大模型生成场景代码
5.1 极简示例:一次调用生成程序化场景
下面的脚本通过 OpenAI 兼容接口调用大模型,让它输出一个包含程序化集装箱、噪声锈迹和 Shader 雨水的单文件 HTML。模型名称请以平台模型列表中的实际名称为准:
import openai
client = openai.OpenAI(
api_key="YOUR_API_KEY",
base_url="https://api.apiyi.com/v1" # API易 统一接口,一个 Key 调用多家模型
)
prompt = """生成一个单文件 HTML,用 Three.js(CDN 引入)实现:
1. 用 InstancedMesh 程序化生成 200 个随机颜色的集装箱堆场;
2. 用 DataTexture + 多层噪声生成锈迹纹理,不使用任何图片文件;
3. 用 ShaderMaterial 实现随时间下落的雨丝;
4. 用 Web Audio API 合成低通滤波白噪声作为雨声。
只输出完整 HTML 代码。"""
resp = client.chat.completions.create(
model="your-model-name", # 替换为平台上的实际模型名
messages=[{"role": "user", "content": prompt}],
)
open("procedural_port.html", "w", encoding="utf-8").write(resp.choices[0].message.content)
运行后用浏览器打开 procedural_port.html 即可查看效果。Saltline 是一次 8 小时、数亿 Token 的长时间生成过程,这个示例只演示同一思路的最小闭环。
查看完整实现:程序化集装箱、噪声锈迹、Shader 雨水与合成雨声的手写参考代码
下面是一段手写的参考实现,便于对照理解模型生成的代码结构。它把第 3 章的四种技术放在同一个文件里:
<!DOCTYPE html>
<html><head><meta charset="utf-8"><style>body{margin:0;background:#000}</style></head>
<body>
<script type="module">
import * as THREE from 'https://unpkg.com/[email protected]/build/three.module.js';
const renderer = new THREE.WebGLRenderer({ antialias: true });
renderer.setSize(innerWidth, innerHeight);
document.body.appendChild(renderer.domElement);
const scene = new THREE.Scene();
scene.fog = new THREE.Fog(0x0a0f18, 20, 120);
const camera = new THREE.PerspectiveCamera(60, innerWidth / innerHeight, 0.1, 500);
camera.position.set(0, 12, 40);
camera.lookAt(0, 0, 0);
// 1. 程序化纹理:多层值噪声生成锈迹,写入 DataTexture
const size = 256, data = new Uint8Array(size * size * 4);
const rand = (x, y) => (Math.sin(x * 127.1 + y * 311.7) * 43758.5453) % 1;
function noise(x, y) {
const xi = Math.floor(x), yi = Math.floor(y), xf = x - xi, yf = y - yi;
const a = rand(xi, yi), b = rand(xi + 1, yi), c = rand(xi, yi + 1), d = rand(xi + 1, yi + 1);
const u = xf * xf * (3 - 2 * xf), v = yf * yf * (3 - 2 * yf);
return Math.abs(a + (b - a) * u + (c - a) * v + (a - b - c + d) * u * v);
}
for (let y = 0; y < size; y++) for (let x = 0; x < size; x++) {
let n = 0, amp = 0.5, f = 4 / size;
for (let o = 0; o < 4; o++) { n += noise(x * f, y * f) * amp; amp *= 0.5; f *= 2; }
const rust = Math.min(1, n * 1.4), i = (y * size + x) * 4;
data[i] = 120 + rust * 100; data[i + 1] = 110 - rust * 40; data[i + 2] = 100 - rust * 60; data[i + 3] = 255;
}
const rustTex = new THREE.DataTexture(data, size, size, THREE.RGBAFormat);
rustTex.wrapS = rustTex.wrapT = THREE.RepeatWrapping;
rustTex.needsUpdate = true;
// 2. 程序化几何 + 实例化渲染:200 个集装箱共享一份几何
const box = new THREE.BoxGeometry(6, 2.6, 2.4);
const mat = new THREE.MeshStandardMaterial({ map: rustTex, metalness: 0.6, roughness: 0.5 });
const containers = new THREE.InstancedMesh(box, mat, 200);
const m = new THREE.Matrix4(), color = new THREE.Color();
for (let i = 0; i < 200; i++) {
const col = i % 10, row = Math.floor(i / 10) % 5, layer = Math.floor(i / 50);
m.makeTranslation(col * 6.5 - 30, layer * 2.7 + 1.3, row * 3 - 7);
containers.setMatrixAt(i, m);
containers.setColorAt(i, color.setHSL(Math.random(), 0.5, 0.45));
}
containers.instanceMatrix.needsUpdate = true;
scene.add(containers);
scene.add(new THREE.HemisphereLight(0x6688aa, 0x111111, 0.6));
const lamp = new THREE.PointLight(0xffaa55, 80, 60);
lamp.position.set(0, 15, 10);
scene.add(lamp);
// 3. Shader:雨丝位置在 GPU 上随时间计算
const rainCount = 6000, pos = new Float32Array(rainCount * 3);
for (let i = 0; i < rainCount * 3; i++) pos[i] = (Math.random() - 0.5) * 80;
const rainGeo = new THREE.BufferGeometry();
rainGeo.setAttribute('position', new THREE.BufferAttribute(pos, 3));
const rainMat = new THREE.ShaderMaterial({
uniforms: { uTime: { value: 0 } },
transparent: true,
vertexShader: `uniform float uTime;
void main(){
vec3 p = position;
p.y = mod(p.y - uTime * 25.0, 40.0);
gl_Position = projectionMatrix * modelViewMatrix * vec4(p, 1.0);
gl_PointSize = 2.0;
}`,
fragmentShader: `void main(){ gl_FragColor = vec4(0.6, 0.7, 0.9, 0.5); }`
});
scene.add(new THREE.Points(rainGeo, rainMat));
// 4. 程序化音效:白噪声经低通滤波模拟雨声(点击页面后启动)
addEventListener('click', () => {
const ctx = new AudioContext();
const buf = ctx.createBuffer(1, ctx.sampleRate * 2, ctx.sampleRate);
const ch = buf.getChannelData(0);
for (let i = 0; i < ch.length; i++) ch[i] = Math.random() * 2 - 1;
const src = ctx.createBufferSource(); src.buffer = buf; src.loop = true;
const lp = ctx.createBiquadFilter(); lp.type = 'lowpass'; lp.frequency.value = 1200;
const gain = ctx.createGain(); gain.gain.value = 0.15;
src.connect(lp).connect(gain).connect(ctx.destination); src.start();
}, { once: true });
const clock = new THREE.Clock();
renderer.setAnimationLoop(() => {
rainMat.uniforms.uTime.value = clock.getElapsedTime();
renderer.render(scene, camera);
});
</script>
</body></html>
整个文件没有一张图片、一个模型文件或一段音频。锈迹纹理在初始化时计算一次(CPU 成本 + 显存),雨丝位置每帧在顶点着色器中计算(GPU 成本),集装箱通过一次绘制调用完成(降低 CPU 调用开销)。
快速上手建议:生成程序化场景代码时,不同模型在 Three.js API 准确度和 Shader 写法上差异明显。通过 API易 apiyi.com 用同一个 Key 切换多家模型、并排对比输出质量,新用户的免费测试额度足够跑完多轮对比。
5.2 生成提示词的三条实用技巧
把提示词写得像一份技术规格,比写成一句愿景效果更好:
- 指定技术点:明确要求 InstancedMesh、DataTexture、ShaderMaterial 等具体 API,模型就会按程序化路线实现,而不是假设存在外部资源;
- 声明约束:写明“不使用任何图片、模型、音频文件”和“单文件 HTML”,与 Saltline 的约束保持一致;
- 要求性能分级:让模型提供低、中、高画质切换(例如降低雨滴数量、关闭阴影),对应 Saltline 提供 Low 画质的做法。
5.3 生成成本的估算方式
以 Anthropic 官方公布的 Claude Fable 5.2 价格为参考:输入 8 美元/百万 Token,输出 40 美元/百万 Token,缓存读取 0.20 美元/百万 Token,5 分钟缓存写入 10 美元/百万 Token;上下文窗口 1M Token,最大输出 128K Token。像 5.1 节这样的单次生成,Token 用量通常只有数千到数万量级。Saltline 那种 8 小时的长时间自主迭代会反复读取已有代码,缓存命中带来的价格差异会显著影响总成本,因此长任务要优先利用提示词缓存。
成本建议:做长时间代码生成实验时,可以先在 API易 apiyi.com 上用小规模提示词测出单轮 Token 消耗,再按迭代轮数估算总预算,平台按量计费,适合先小后大地验证方案。
6 常见问题 FAQ
Q1:什么是程序化生成的 3D 游戏资产?
程序化生成资产是用代码和参数描述模型、纹理、声音的生成规则,运行时再计算出结果。文件里保存的是“怎么画”,传统资产文件保存的是“画好的结果”。Saltline 的集装箱、锈迹和雨声都属于这一类。
Q2:程序化纹理和 Shader 有什么区别?
程序化纹理通过算法生成纹理数据,可以预先算成一张图放进显存;Shader 是 GPU 上的程序,可以在每一帧渲染时直接计算像素颜色。前者多占内存、少占算力,后者相反,两者经常结合使用。
Q3:Saltline 是什么时候发布的,用了哪个模型?
2026 年 11 月 9 日由 Anthropic 工程师 Felix Rieseberg 发布,使用 Claude Fable 5.2,单次提示词、无人工反馈。约 8 小时、约 550 美元、约 4.45 亿输入 Token 和 270 万输出 Token 均为开发者自述估算。11 月 10 日他补充说明模型和纹理全部由代码生成。
Q4:程序化生成最适合哪些游戏场景?
– **大量重复结构**:集装箱堆场、建筑群、植被,配合实例化渲染效果最好;
– **自然表面**:锈迹、岩石、木纹等适合噪声表达的材质;
– **动态天气与特效**:雨水、积水波纹、灯光闪烁这类随时间变化的效果;
– **体积敏感的分发场景**:网页小游戏、互动广告、可即点即玩的原型。
需要精确艺术控制的主角、关键剧情道具,预制资产仍然更合适,商业项目通常采用混合方案。
Q5:如何通过 API 让大模型生成程序化 3D 场景代码?
1. 在 API易 apiyi.com 注册并获取 API Key 和免费测试额度;
2. 使用本文 5.1 节的脚本,将 base_url 设为 `https://api.apiyi.com/v1`;
3. 在提示词中写明 Three.js API、单文件、无外部资源等约束,生成后用浏览器打开验证。
由于接口兼容 OpenAI 格式,切换 Claude、GPT、Gemini 等模型只需修改 model 参数。
Q6:程序化生成有哪些已知限制?
– **运行时成本**:初始化计算、显存占用和复杂 Shader 的 GPU 负载都会转嫁到玩家设备,Saltline 也需要 Low 画质选项和较长初始化时间;
– **浏览器约束**:Unity 官方文档指出 Web 平台在文件系统、线程和内存上受限,移动端支持有限;
– **艺术可控性**:算法表达力有边界,写实角色和精细道具难以纯代码生成;
– **工程成熟度**:AI 能快速产出可玩原型,商业游戏所需的长期优化、测试和内容扩展仍需大量工程投入。
7 1.4MB 3D 游戏与程序化生成 Key Takeaways
- 体积来源:Saltline 约 1.4MB,保存的是生成规则,没有图片、模型和音频文件。
- 四种技术:程序化几何、程序化纹理、Shader、程序化音效各管一层,分工明确。
- 成本转移:下载体积降低,CPU 构建、显存占用和 GPU 每帧计算相应增加。
- 评估维度:同时看分发体积、初始化时间、运行内存和每帧 GPU 成本。
- AI 的角色:AI 负责写生成代码,程序化技术本身早已广泛用于游戏开发。
- 上手方式:通过 API易 apiyi.com 用一个 Key 对比多家模型生成的 Three.js 场景代码。
8 总结:游戏开发正在从制作资产走向编写资产生成规则
Saltline 展示了一种资源表达方式的变化:传统游戏交付“制作好的资产”,程序化游戏交付“生成资产的规则”。AI 代码生成让这条路线的门槛显著降低,一个模型可以在一次持续生成中同时写出几何、纹理、Shader、音频和游戏逻辑,省去了多工种之间的交接。
这条路线有清晰的适用边界。它在分发体积和部署便利性上优势突出,同时把计算压力转移到玩家设备;它擅长重复结构、自然表面和动态特效,精细的艺术资产仍依赖传统生产。传统资产生产与程序化生产会长期互补,Saltline 的价值在于证明了一个小体积程序也能构建出丰富的交互场景。
想亲手验证这条路线,可以从 5.1 节的脚本开始,推荐通过 API易 apiyi.com 调用不同模型生成程序化场景,对比它们对 Three.js 和 Shader 的掌握程度。
📚 参考资料
- Saltline 代码镜像与 README:单文件结构、字节数及开发者数据归属
- 链接:
github.com/realcodebear/saltline-fable-5.2 -
说明: 可直接查看 index.html 的程序化生成代码
-
Saltline 独立体验页面:在线试玩及初始化、画质设置说明
- 链接:
saltline.games -
说明: 中文版本位于
saltline.games/zh -
几猫中文版本 GitHub 仓库:国内传播版本的存档
- 链接:
github.com/Megasu/jimao-3a-game -
说明: 提供离线运行说明和文件大小数据
-
Claude Fable 5.2 模型规格与价格:Anthropic 官方文档
- 链接:
platform.claude.com/docs/en/models/fable-5-2/overview -
说明: 输入、输出、缓存价格及上下文规格
-
Three.js 官方文档与示例:InstancedMesh、ShaderMaterial、BufferGeometry、DataTexture
- 链接:
threejs.org/docs与threejs.org/examples -
说明: 本文代码所用 API 的权威说明
-
MDN WebGL API:浏览器 GPU 渲染接口
- 链接:
developer.mozilla.org/en-US/docs/Web/API/WebGL_API -
说明: 理解 Three.js 底层渲染机制
-
Unity WebGL 技术概览:Web 平台的线程、内存与移动端限制
- 链接:
docs.unity.cn/6000.0/Documentation/Manual/webgl-technical-overview.html - 说明: 评估浏览器游戏工程边界的参考
作者: APIYI 技术团队
技术交流: 欢迎在 API易 apiyi.com 首页联系我们,更多接入资料可访问 docs.apiyi.com 文档中心
