Nota do autor: o Saltline descreve em código as regras de geração de geometria, texturas e som; por isso, o tamanho de distribuição é pequeno, mas parte da carga de trabalho foi deslocada para a computação em tempo de execução no dispositivo do jogador.
O Saltline tem apenas cerca de 1.4MB porque seu único arquivo HTML guarda as regras de geração de modelos, texturas e sons, e não arquivos de modelo, texturas e efeitos sonoros já produzidos de antemão. Quando o navegador abre o arquivo, JavaScript e Shader montam localmente, em tempo real, o porto em noite de chuva, os contêineres e os drones. A geração procedural mudou a forma de expressar e entregar os recursos do jogo: o volume de download caiu bastante, enquanto o trabalho de CPU para montar geometria e de GPU para calcular pixels aumentou na mesma proporção. Tamanho de arquivo, memória de execução e carga da GPU são três contas independentes.
A seguir, primeiro vou destrinchar a composição desse arquivo de 1.4MB; depois comparar com o modo tradicional de produzir recursos em jogos; em seguida, usar três exemplos — contêineres, material metálico e chuva — para explicar como funcionam, respectivamente, a geometria procedural, a textura procedural, o Shader e os efeitos sonoros procedurais; então analisar o custo de tempo de execução por trás do tamanho pequeno; e, por fim, apresentar um trecho de código executável que mostra como usar uma API para fazer um Modelo de Linguagem Grande gerar uma cena procedural semelhante.

Para saber: preparação de terminologia de jogos 3D procedurais
| Termo | Explicação |
|---|---|
| Geometria procedural | Cria vértices e formas de modelo com base em parâmetros e regras, por exemplo, gerar um cubo a partir de comprimento, largura e altura |
| Textura procedural | Calcula cores e padrões de superfície por meio de funções matemáticas (como ruído) |
| Shader | Pequeno programa executado na GPU que determina a posição de cada vértice e a cor de cada pixel |
| Função de ruído | Algoritmos como Perlin, Simplex, capazes de gerar padrões aleatórios naturais e irregulares |
| Renderização por instância | Desenha uma grande quantidade de objetos semelhantes em uma única chamada de desenho; no Three.js, corresponde ao InstancedMesh |
| WebGL | Interface gráfica de GPU fornecida pelo navegador, que permite às páginas web renderizar imagens 3D |
| Three.js | Biblioteca de gráficos 3D para Web baseada em JavaScript, que encapsula conceitos como cena, câmera e material |
| HTML | Formato de arquivo que organiza o conteúdo e o código de uma página web; todo o código central do Saltline está em um único arquivo HTML |
| Tamanho de distribuição | Volume de dados de arquivo que o jogador precisa baixar |
| Memória em execução | Memória ocupada durante a execução do programa, incluindo geometrias e texturas geradas em tempo de execução |
| Carga da GPU | Quantidade de cálculo que o processador gráfico precisa realizar a cada quadro |
| Token | Unidade básica de processamento de texto de um Modelo de Linguagem Grande, e também unidade de cobrança da API |
1 O que há dentro de um arquivo HTML de 1,4 MB: a arquitetura de arquivo único do Saltline
1.1 Que tipo de jogo 3D gerado por IA é o Saltline
Em 9 de novembro de 2026, o engenheiro da Anthropic Felix Rieseberg divulgou um experimento de programação com o Claude Fable 5.2: usando um único comando, pediu ao modelo que criasse um jogo de tiro em primeira pessoa de pequeno porte com visual o mais próximo possível de um jogo AAA, sem fornecer qualquer feedback humano durante o processo. O resultado foi o Saltline.
O jogo se passa em um porto de contêineres numa noite chuvosa, onde o jogador precisa desativar três estações de retransmissão de sinal e depois evacuar; os inimigos são drones de patrulha aérea e cães mecânicos terrestres. Ele oferece movimentação em primeira pessoa, tiro, interação e objetivos de missão, com chuva, iluminação, áudio ambiente e efeitos de armas, além de configurações de qualidade gráfica. É um protótipo jogável single-player de um único nível, e o “3A” é a meta do experimento e uma analogia visual. A versão “几猫·国产3A大作” que circulou nas redes sociais chinesas é a versão em chinês do Saltline ou uma versão reembalada dele, sendo esse nome resultado do próprio processo de divulgação.
Os dados relatados pelo próprio desenvolvedor são os seguintes, todos estimativas publicadas por ele no X e sem auditoria de terceiros:
- Tempo de desenvolvimento de cerca de 8 horas;
- Custo estimado com base nos preços da API de cerca de 550 dólares;
- Tokens de entrada de aproximadamente 445 milhões, com grande uso de cache;
- Tokens de saída de aproximadamente 2,7 milhões.
Como os tokens de entrada acertaram muito o cache, essa conta não pode ser simplesmente recalculada multiplicando o preço unitário de entrada comum pela quantidade total, e a estrutura detalhada da fatura também não foi divulgada. Esses 550 dólares são um custo único de geração; quando o jogador joga no navegador, o modelo não é mais chamado.
1.2 Como o index.html é montado: Three.js, código gerado e fontes externas
O repositório espelho no GitHub traz dados precisos: o arquivo principal index.html tem 1.425.707 bytes, cerca de 1,43 MB (1,36 MiB). Podemos resumir a composição desse arquivo em quatro partes:
- Código de execução do Three.js: a biblioteca 3D inteira é empacotada dentro do HTML e cuida da cena, da câmera, dos materiais e da renderização WebGL;
- Código de geração de cena e assets: geometrias, texturas e materiais são construídos por funções JavaScript e Shaders;
- Código de áudio procedural: o som também é sintetizado por código, não existe nenhum arquivo de áudio separado no repositório;
- Lógica do jogo: controle de entrada, comportamento dos inimigos, fluxo das tarefas.
Não há arquivos independentes de imagem, vídeo ou áudio no repositório. A única dependência externa explícita são as fontes do Google Fonts. No dia 10 de novembro, o desenvolvedor acrescentou um esclarecimento: tudo no jogo é código, e as texturas e os modelos são funções.
1.3 O que acontece quando você abre o Saltline no navegador
O fluxo de execução é uma pipeline local bem clara: o navegador lê o HTML → o JavaScript começa a executar → inicializa o Three.js e o ambiente de renderização WebGL → o código gera geometria, materiais, texturas e som da cena → a GPU renderiza o quadro a cada frame → o jogador opera com teclado e mouse, e a lógica do jogo continua se atualizando.
Nessa pipeline, a etapa de “gerar assets” acontece no próprio dispositivo do jogador. A página oficial de demonstração do Saltline também avisa: a inicialização da página pode demorar um pouco, e o desempenho do dispositivo afeta a velocidade de início; se travar na tela de espera, vale checar o WebGL 2 e a aceleração de hardware do navegador; em caso de lentidão, é possível mudar para a qualidade Low. Esses próprios avisos já mostram o peso da computação em tempo de execução.

2 Como os jogos tradicionais criam modelos, texturas e sons
2.1 Os três tipos de ativos centrais dos jogos 3D tradicionais
O visual e o som de um jogo 3D tradicional vêm principalmente de arquivos de ativos pré-produzidos:
- Arquivos de modelo: criados pelos artistas em softwares de modelagem e salvos como dados de vértices, faces, coordenadas UV, etc.;
- Texturas: várias imagens como difusa, normal, rugosidade e metalicidade, aplicadas sobre a superfície do modelo para fornecer detalhes;
- Arquivos de efeitos sonoros: áudios gravados ou sintetizados e exportados, reproduzidos quando um evento específico é disparado.
Esses ativos passam por produção, otimização, compressão e empacotamento, e são distribuídos junto com o jogo. A engine carrega tudo em tempo de execução, e o trabalho principal é “ler e exibir”.
2.2 Por que os ativos tradicionais ocupam tanto espaço
Ativos pré-produzidos armazenam o resultado. Uma textura em alta resolução precisa registrar o valor de cor de cada pixel; um modelo detalhado precisa registrar a posição de cada vértice; um efeito sonoro precisa registrar cada ponto de amostragem. Quanto mais rica a cena e maior a resolução, mais dados de resultado precisam ser registrados, e o tamanho cresce linearmente.
A abordagem procedural armazena o processo. Uma função de ruído precisa de apenas algumas dezenas de linhas de código, mas consegue gerar um padrão de ferrugem em qualquer resolução; uma função de caixa paramétrica consegue gerar contêineres de qualquer tamanho. É essa a razão fundamental pela qual 1.4MB consegue conter uma cena portuária completa.
| Dimensão de comparação | Ativo pré-produzido tradicional | Ativo gerado proceduralmente |
|---|---|---|
| O que é armazenado no arquivo | Dados do resultado final (vértices, pixels, amostras) | Regras de geração (funções, parâmetros, shader) |
| Modo de produção | Artistas criam um por um em ferramentas profissionais | Escrever código e parâmetros, calculados em tempo de execução |
| Tamanho de distribuição | Cresce com a quantidade e a precisão dos ativos | Determinado principalmente pela quantidade de código, geralmente muito pequeno |
| Trabalho principal em tempo de execução | Carregar, decodificar, exibir | Construir geometria, calcular texturas, sintetizar sons |
| Capacidade de controle de detalhes | Artistas podem controlar cada detalhe com precisão | Depende da capacidade de expressão do algoritmo, alto custo de ajuste de parâmetros |
| Objetos de aplicação típicos | Personagens, itens-chave, cenas realistas | Estruturas repetitivas, superfícies naturais, efeitos climáticos |
3 Como a IA gera ativos de jogo com código: quatro técnicas procedurais
A geração procedural é uma técnica usada há muito tempo na indústria de jogos: o terreno de Minecraft e as fases de muitos roguelikes dependem dela. A novidade do Saltline é que um modelo de IA, em um único processo contínuo de geração, escreveu ao mesmo tempo todo o código de geometria, texturas, shaders, áudio e lógica de jogo, reduzindo a passagem de trabalho entre modelagem, materiais, efeitos sonoros e programação.
| Camada | Objeto gerado | Ideia técnica | Exemplo correspondente no Saltline |
|---|---|---|---|
| Geração de geometria | Forma do modelo | Vértices, faces, geometria paramétrica | Contêineres, armazém, estruturas do cais |
| Geração de materiais | Propriedades da superfície | Parâmetros de cor, rugosidade e metalicidade | Casca metálica do contêiner |
| Geração de texturas | Detalhes da superfície | Ruído, fractal, Voronoi | Ferrugem, manchas, desgaste |
| Geração de ambiente | Layout da cena | Regras, números aleatórios, relações espaciais | Arranjo das pilhas de contêineres |
| Geração de animação | Movimento dos objetos | Funções matemáticas, mudanças de estado | Patrulha de drones, queda de gotas de chuva |
| Geração de som | Efeitos sonoros | Osciladores, filtros, ruído | Som de chuva, tiros, som ambiente |
3.1 Geometria procedural: montando um contêiner com parâmetros
Um contêiner é, essencialmente, um paralelepípedo com painéis laterais ondulados. A abordagem da geometria procedural consiste em gerar um hexaedro a partir dos parâmetros de comprimento, largura e altura e, em seguida, deslocar os vértices ao longo das laterais seguindo uma função senoidal, simulando as ondulações do aço corrugado. O BufferGeometry do Three.js permite escrever diretamente no array de vértices, enquanto o BoxGeometry já oferece uma caixa paramétrica pronta para uso.
Em um porto há centenas ou milhares de contêineres, e todos eles compartilham os mesmos dados de geometria. Nesse caso, usamos InstancedMesh para renderização instanciada: basta guardar, para cada instância, uma matriz de transformação (posição, rotação, escala) e uma cor, e assim desenhamos todo o pátio de contêineres em uma única chamada de desenho.
3.2 Texturas procedurais: pintando ferrugem com funções de ruído
Texturas procedurais são dados de textura gerados por algoritmos. Os algoritmos mais usados incluem Perlin Noise, Simplex Noise, Voronoi e ruído fractal: sobrepondo várias camadas de ruído com frequências diferentes, obtemos uma distribuição natural de manchas de ferrugem; com Voronoi é possível criar as bordas em blocos típicas de tinta descascada.
No Three.js, esse tipo de textura normalmente é calculado uma vez na fase de inicialização, gravado em uma DataTexture (preenchendo diretamente o array de pixels) ou em uma CanvasTexture (desenhando com Canvas 2D), e depois entregue ao material como qualquer outro mapa. Uma vez gerada, a textura fica residente na memória de vídeo; o custo extra em tempo de execução é basicamente essa ocupação de VRAM.
3.3 Shader: calculando metal e chuva pixel a pixel na GPU
O Shader roda na GPU e calcula em tempo real a cor de cada pixel com base em entradas como coordenadas, tempo e iluminação. A diferença em relação às texturas procedurais está no momento em que o cálculo acontece: texturas procedurais podem ser pré-calculadas em uma imagem; já o Shader pode calcular na hora, a cada frame, sem precisar gerar uma imagem completa.
Porto em noite de chuva é o cenário típico para Shaders. O reflexo em superfícies metálicas molhadas, as ondulações da água acumulada no chão perturbadas pelo tempo e a queda dos fios de chuva podem todos ser escritos como funções que recebem o tempo como entrada e são recalculadas a cada frame. O ShaderMaterial do Three.js permite escrever diretamente vertex shaders e fragment shaders para implementar esses efeitos. O trade-off entre as duas abordagens é direto: texturas pré-geradas ocupam memória e economizam poder de computação; o cálculo em tempo real com Shader economiza memória e consome poder de computação.
3.4 Efeitos sonoros procedurais: sintetizando som de chuva com osciladores e filtros
A Web Audio API do navegador oferece osciladores, buffers de ruído e nós de filtro. Ruído branco passado por um filtro passa-baixa fica próximo do som de chuva; uma explosão curta de ruído com envelope de volume de decaimento rápido é um tiro; um oscilador de baixa frequência modulando o tom pode simular o zumbido de um drone. No repositório Saltline não há nenhum arquivo de áudio; todos os sons são sintetizados em tempo real por esse tipo de código.

4 Arquivo menor significa execução mais leve? Analisando os custos da geração procedural
4.1 Distinguir tamanho de distribuição, memória em tempo de execução e carga de GPU
Para medir o “peso” de um jogo 3D, é preciso olhar pelo menos três dimensões:
- Tamanho de distribuição: quanto dado o jogador baixa. O Saltline tem grande vantagem nesse quesito;
- Memória em tempo de execução: buffers de vértices, texturas e buffers de áudio gerados em runtime ocupam memória RAM e VRAM — um programa de apenas 1,4 MB pode perfeitamente criar centenas de MB de dados enquanto roda;
- Carga computacional: o trabalho que CPU e GPU precisam executar a cada frame. Shaders complexos elevam diretamente esse número.
Por outro lado, um jogo de grande volume também pode alcançar ótima eficiência de execução por meio de compressão, carregamento em blocos e streaming de assets. Julgar qual abordagem técnica é melhor usando apenas o tamanho do arquivo leva a conclusões parciais.
4.2 Para onde a geração procedural transfere o custo
| Técnica | Custo que pode diminuir | Custo que pode aumentar |
|---|---|---|
| Modelo procedural | Download e armazenamento do modelo | Tempo de construção de geometria na CPU |
| Texturas via shader | Arquivos de imagem e transferência de texturas | Cálculo em tempo real na GPU a cada frame |
| Texturas procedurais (pré-geradas) | Download de arquivos de imagem | Cálculo de inicialização e consumo de memória de vídeo |
| Renderização por instâncias | Chamadas de desenho repetidas | Gerenciamento de cena e manutenção dos dados de instância |
| Cena gerada dinamicamente | Quantidade de assets pré-fabricados | Cálculos de inicialização e em tempo de execução |
| Efeitos sonoros procedurais | Armazenamento de arquivos de áudio | Custo de síntese de áudio em tempo real |
O fato de Saltline demorar mais para inicializar e precisar oferecer uma opção de qualidade Low é justamente essa tabela se materializando: o trabalho economizado na fase de download é pago de novo no momento do boot e em cada frame renderizado.
4.3 O trade-off entre shader, renderização por instâncias e geometria dinâmica
As três técnicas resolvem problemas diferentes e funcionam melhor quando combinadas:
- Renderização por instâncias reduz o número de chamadas de desenho que a CPU envia à GPU, e é mais indicada para grandes volumes de objetos repetidos, como pátios de contêineres, postes de iluminação e partículas de gotas de chuva;
- Shader leva o cálculo dos detalhes para a GPU e cai bem para efeitos que mudam ao longo do tempo (chuva, poças d’água, luzes piscando), mas o preço é que quanto mais complexo o fragment shader, mais pesada fica a carga na GPU em resoluções altas;
- Geometria dinâmica serve para estruturas que precisam variar conforme parâmetros ou que têm quantidade limitada; o custo de construção se concentra na inicialização e, depois de pronta, ela é apenas uma malha comum.
A direção de otimização mais comum na engenharia é esta: o que puder ser calculado antecipadamente deve ser calculado uma vez na inicialização e guardado em cache; só o que realmente precisa mudar com o tempo vai para o shader de cada frame.
4.4 A abordagem do Saltline e as diferenças em relação aos jogos em nuvem e aos modelos de mundo com IA
“Fazer jogos com IA” hoje corresponde a pelo menos três abordagens técnicas; o Saltline se encaixa na primeira.
| Dimensão de comparação | Jogo web local | Jogos em nuvem | Modelo de mundo com IA |
|---|---|---|---|
| Casos representativos | Saltline | GeForce NOW, Pixel Streaming | Genie 3, Muse/WHAMM, Oasis |
| Onde a IA participa | Gera código na fase de desenvolvimento | Geralmente não envolve IA | Gera quadros em tempo de execução |
| Geração de imagens | Renderização local na GPU | Renderização na GPU da nuvem e transmissão em fluxo de vídeo | Geração por predição em tempo real do modelo |
| Requisitos de rede | Pode funcionar offline após o primeiro carregamento | Requer conexão contínua | Geralmente requer conexão contínua |
| Momento em que os custos ocorrem | Custo de desenvolvimento único; depois, o custo fica com o dispositivo do jogador | Cada sessão gera custo de servidor | Cada sessão gera custo de inferência |
| Principais limitações | Navegador e hardware local | Latência e largura de banda da rede | Consistência, latência e controlabilidade |
O Saltline concentra os custos de IA na fase de desenvolvimento. Depois que a geração é concluída, as regras do jogo são definidas pelo código e a execução não depende do modelo. Isso determina tanto a possibilidade de rodar offline quanto o fato de o desempenho do dispositivo do jogador ser o limite superior da experiência.
5 Início rápido em jogos 3D procedurais: usando a API para o modelo gerar código de cena
5.1 Exemplo minimalista: gerar uma cena procedural em uma única chamada
O script abaixo chama o Modelo de Linguagem Grande por meio da interface compatível com OpenAI, para que ele produza um HTML de arquivo único contendo contêineres procedurais, ferrugem com ruído e chuva em shader. O nome do modelo deve corresponder ao nome real na lista de modelos da plataforma:
import openai
client = openai.OpenAI(
api_key="YOUR_API_KEY",
base_url="https://api.apiyi.com/v1" # Interface unificada da APIYI, uma única chave para chamar vários modelos
)
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", # Substitua pelo nome real do modelo na plataforma
messages=[{"role": "user", "content": prompt}],
)
open("procedural_port.html", "w", encoding="utf-8").write(resp.choices[0].message.content)
Após executar, basta abrir o procedural_port.html no navegador para ver o resultado. O Saltline foi um processo de geração longo, de 8 horas e centenas de milhões de tokens; este exemplo demonstra apenas o menor loop fechado da mesma ideia.
Ver a implementação completa: código de referência escrito à mão com contêineres procedurais, ferrugem com ruído, chuva em shader e som de chuva sintetizado
A seguir está uma implementação de referência escrita à mão, para ajudar a comparar e entender a estrutura de código gerada pelo modelo. Ela reúne as quatro técnicas do Capítulo 3 em um único arquivo:
<!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. Textura procedural: ruído de valor em múltiplas camadas gera ferrugem, gravada em 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. Geometria procedural + renderização instanciada: 200 contêineres compartilham uma única geometria
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: posição das gotas de chuva calculada na GPU ao longo do tempo
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. Efeito sonoro procedural: ruído branco passa-baixa simula o som da chuva (iniciado após clicar na página)
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>
O arquivo inteiro não contém uma única imagem, um único arquivo de modelo nem um trecho de áudio. A textura de ferrugem é calculada uma vez na inicialização (custo de CPU + memória de vídeo), as posições das gotas de chuva são calculadas a cada frame no vertex shader (custo de GPU) e os contêineres são desenhados em uma única chamada de desenho (reduz o overhead de chamadas de CPU).
Dica para começar rápido: ao gerar código de cena procedural, os modelos apresentam diferenças evidentes na precisão da API do Three.js e no jeito de escrever shaders. Com o APIYI apiyi.com, use a mesma Key para alternar entre vários modelos e comparar a qualidade das saídas lado a lado. A cota de teste gratuita para novos usuários é suficiente para completar várias rodadas de comparação.
5.2 Três dicas práticas para gerar comandos
Escrever o comando como se fosse uma especificação técnica rende mais do que escrevê-lo como uma frase de visão:
- Especifique os pontos técnicos: exija explicitamente APIs específicas como InstancedMesh, DataTexture e ShaderMaterial, e o modelo vai implementar pela rota procedural em vez de assumir que existem recursos externos;
- Declare as restrições: escreva “não usar nenhuma imagem, arquivo de modelo ou áudio” e “HTML em arquivo único”, mantendo a consistência com as restrições do Saltline;
- Exija níveis de qualidade: peça ao modelo para oferecer alternância entre qualidade baixa, média e alta (por exemplo, reduzir a quantidade de gotas de chuva e desativar sombras), o que corresponde à abordagem do Saltline de oferecer qualidade Low.
5.3 Como estimar o custo de geração
Tomando como referência os preços oficiais divulgados pela Anthropic para o Claude Fable 5.2: US$ 8 por milhão de tokens de entrada, US$ 40 por milhão de tokens de saída, US$ 0,20 por milhão de tokens de leitura de cache, US$ 10 por milhão de tokens de escrita de cache de 5 minutos; janela de contexto de 1M tokens, saída máxima de 128K tokens. Em uma geração única como a da seção 5.1, o consumo de tokens normalmente fica na casa dos milhares a algumas dezenas de milhares. Iterações autônomas longas de 8 horas, como as do Saltline, releem o código existente repetidamente, e a diferença de preço trazida pelo acerto de cache afeta bastante o custo total — por isso, tarefas longas devem priorizar o uso de cache de comandos.
Dica de custo: ao fazer experimentos longos de geração de código, você pode primeiro medir o consumo de tokens por rodada com um comando de pequena escala no APIYI apiyi.com, e depois estimar o orçamento total pelo número de iterações. A plataforma cobra por uso, então é perfeita para validar a solução do pequeno para o grande.
6 Perguntas Frequentes (FAQ)
Q1: O que são assets 3D de jogos gerados proceduralmente?
Assets gerados proceduralmente são modelos, texturas e sons descritos por meio de código e parâmetros que definem as regras de geração, com o resultado calculado em tempo de execução. O arquivo guarda “como desenhar”, enquanto um arquivo de asset tradicional guarda “o resultado já desenhado”. Os contêineres, a ferrugem e o som da chuva em Saltline pertencem a essa categoria.
Q2: Qual é a diferença entre textura procedural e Shader?
Texturas procedurais geram os dados de textura por meio de algoritmos, que podem ser pré-calculados e enviados à memória de vídeo como uma imagem; já os Shaders são programas executados na GPU, capazes de calcular a cor de cada pixel diretamente a cada frame. O primeiro consome mais memória e menos poder de processamento, o segundo o contrário, e os dois costumam ser usados em conjunto.
Q3: Quando o Saltline foi lançado e qual modelo foi usado?
Foi lançado em 9 de novembro de 2026 pelo engenheiro da Anthropic, Felix Rieseberg, usando Claude Fable 5.2, com um único comando (prompt) e sem feedback humano. Aproximadamente 8 horas, cerca de 550 dólares, cerca de 445 milhões de tokens de entrada e 2,7 milhões de tokens de saída são estimativas relatadas pelo próprio desenvolvedor. Em 10 de novembro ele acrescentou que tanto o modelo quanto as texturas foram totalmente gerados por código.
Q4: Para quais cenários de jogo a geração procedural é mais adequada?
– **Estruturas repetitivas em grande quantidade**: pátios de contêineres, conjuntos de edifícios, vegetação, com melhores resultados quando combinados com renderização por instâncias;
– **Superfícies naturais**: materiais como ferrugem, rochas e veios de madeira, que funcionam bem com ruído;
– **Clima e efeitos dinâmicos**: efeitos que mudam com o tempo, como chuva, ondulações na água acumulada e cintilação de luzes;
– **Cenários de distribuição sensíveis ao tamanho**: minijogos web, anúncios interativos e protótipos jogáveis instantaneamente.
Para protagonistas que exigem controle artístico preciso e itens de enredo essenciais, assets pré-fabricados continuam sendo mais adequados, e projetos comerciais normalmente adotam uma abordagem híbrida.
Q5: Como fazer um Modelo de Linguagem Grande gerar código de cenas 3D procedurais via API?
1. Cadastre-se em APIYI apiyi.com e obtenha a chave API e a cota gratuita de teste;
2. Use o script da seção 5.1 deste artigo, definindo `base_url` como `https://api.apiyi.com/v1`;
3. No comando (prompt), especifique restrições como a API do Three.js, arquivo único e ausência de recursos externos; depois de gerar, abra no navegador para validar.
Como a interface é compatível com o formato OpenAI, para alternar entre modelos como Claude, GPT e Gemini basta alterar o parâmetro `model`.
Q6: Quais são as limitações conhecidas da geração procedural?
– **Custo em tempo de execução**: o cálculo de inicialização, o uso de memória de vídeo e a carga de GPU de Shaders complexos recaem sobre o dispositivo do jogador, e o próprio Saltline precisa de uma opção de qualidade Low e de um tempo de inicialização mais longo;
– **Restrições do navegador**: a documentação oficial da Unity aponta que a plataforma Web tem limitações de sistema de arquivos, threads e memória, além de suporte limitado em dispositivos móveis;
– **Controle artístico**: a expressividade dos algoritmos tem limites, e personagens realistas e itens refinados dificilmente podem ser gerados puramente por código;
– **Maturidade de engenharia**: a IA consegue produzir rapidamente protótipos jogáveis, mas a otimização de longo prazo, os testes e a expansão de conteúdo exigidos por jogos comerciais ainda demandam muito investimento de engenharia.
7 Jogo 3D de 1.4MB e geração procedural — Principais conclusões
- Origem do tamanho: Saltline tem cerca de 1.4MB; o que é armazenado são as regras de geração, sem arquivos de imagem, modelo ou áudio.
- Quatro técnicas: geometria procedural, textura procedural, Shader e som procedural, cada uma responsável por uma camada, com divisão de trabalho bem definida.
- Transferência de custo: o tamanho do download diminui, enquanto a construção na CPU, o uso de VRAM e o cálculo por frame na GPU aumentam na mesma medida.
- Dimensões de avaliação: considerar ao mesmo tempo o tamanho de distribuição, o tempo de inicialização, a memória em execução e o custo de GPU por frame.
- O papel da IA: a IA é responsável por escrever o código de geração; as técnicas procedurais em si já são amplamente usadas no desenvolvimento de jogos.
- Como começar: usar a APIYI apiyi.com com uma única Key para comparar o código de cenas Three.js gerado por vários modelos.
8 Conclusão: o desenvolvimento de jogos está passando da produção de assets para a escrita das regras de geração de assets
Saltline mostra uma mudança na forma de expressar recursos: os jogos tradicionais entregam “assets prontos”, enquanto os jogos procedurais entregam “as regras que geram os assets”. A geração de código por IA reduz bastante a barreira dessa rota; um modelo pode, em uma única geração contínua, escrever ao mesmo tempo geometria, textura, Shader, áudio e lógica de jogo, eliminando a passagem de bastão entre várias funções.
Essa rota tem limites claros de aplicação. Ela se destaca em tamanho de distribuição e conveniência de implantação, ao mesmo tempo em que transfere a pressão computacional para o dispositivo do jogador; ela é boa em estruturas repetitivas, superfícies naturais e efeitos dinâmicos, mas assets artísticos refinados ainda dependem da produção tradicional. A produção tradicional de assets e a produção procedural vão se complementar por muito tempo; o valor da Saltline está em provar que um programa de pequeno tamanho também consegue construir cenas interativas ricas.
Para verificar essa rota na prática, você pode começar pelo script da seção 5.1; recomenda-se chamar modelos diferentes via APIYI apiyi.com para gerar cenas procedurais e comparar o domínio que eles têm de Three.js e Shader.
📚 Referências
- Espelho de código e README do Saltline: estrutura de arquivo único, contagem de bytes e atribuição de dados do desenvolvedor
- Link:
github.com/realcodebear/saltline-fable-5.2 -
Descrição: é possível ver diretamente o código gerado programaticamente em index.html
-
Página independente de demonstração do Saltline: teste online e instruções de inicialização e configuração de qualidade gráfica
- Link:
saltline.games -
Descrição: a versão em chinês está em
saltline.games/zh -
Repositório GitHub da versão chinesa de Jimao: arquivo da versão distribuída na China
- Link:
github.com/Megasu/jimao-3a-game -
Descrição: oferece instruções para execução offline e dados de tamanho de arquivo
-
Especificações e preços do modelo Claude Fable 5.2: documentação oficial da Anthropic
- Link:
platform.claude.com/docs/en/models/fable-5-2/overview -
Descrição: preços de entrada, saída e cache, além das especificações da janela de contexto
-
Documentação e exemplos oficiais do Three.js: InstancedMesh, ShaderMaterial, BufferGeometry, DataTexture
- Link:
threejs.org/docsethreejs.org/examples -
Descrição: referência autoritativa para as APIs usadas no código deste artigo
-
API WebGL do MDN: interface de renderização por GPU do navegador
- Link:
developer.mozilla.org/en-US/docs/Web/API/WebGL_API -
Descrição: para entender o mecanismo de renderização subjacente do Three.js
-
Visão geral técnica do Unity WebGL: limitações de threads, memória e dispositivos móveis na plataforma Web
- Link:
docs.unity.cn/6000.0/Documentation/Manual/webgl-technical-overview.html - Descrição: referência para avaliar os limites de engenharia de jogos no navegador
Autor: Equipe técnica da APIYI
Contato técnico: Entre em contato conosco pela página inicial da APIYI apiyi.com; para mais materiais de integração, visite a central de documentação em docs.apiyi.com
