1,4 МБ достаточно, чтобы вместить 3D-игру? Как ИИ создаёт модели и текстуры с помощью кода

1,4 МБ достаточно, чтобы вместить 3D-игру? Как ИИ создаёт модели и текстуры с помощью кода

Примечание автора: Saltline описывает правила генерации геометрии, текстур и звука кодом, поэтому размер дистрибутива получается небольшим, но часть работы перекладывается на вычисления во время выполнения на устройстве игрока.

Saltline весит всего около 1,4 МБ, потому что в его единственном HTML-файле хранятся правила генерации моделей, текстур и звука, а не заранее подготовленные файлы моделей, текстуры и звуковые эффекты. После открытия файла в браузере JavaScript и шейдеры в реальном времени собирают на месте ночной порт под дождём, контейнеры и дронов. Процедурная генерация меняет то, как игровые ресурсы описываются и доставляются: объём загрузки резко снижается, а нагрузка на CPU, который строит геометрию, и на GPU, который вычисляет пиксели, соответственно растёт. Размер файла, оперативная память и нагрузка на GPU — это три отдельные статьи расходов.

Ниже сначала разберём, из чего состоит этот файл на 1,4 МБ, затем сравним его с традиционным способом производства игровых ассетов, далее на трёх примерах — контейнеры, металлические материалы и дождь — покажем, как работают процедурная геометрия, процедурные текстуры, шейдеры и процедурный звук, после чего разберём, во что обходится маленький размер во время выполнения, и в конце приведём рабочий код, который показывает, как через API заставить большую языковую модель генерировать похожую процедурную сцену.

ai-procedural-3d-game-1-4mb-code-generated-models-textures-ru-image-0

Table of Contents

Что нужно знать: базовые термины процедурной 3D-графики в играх

Термин Объяснение
Процедурная геометрия Создание вершин и формы модели по параметрам и правилам — например, построение коробки по длине, ширине и высоте
Процедурные текстуры Вычисление цвета и рисунка поверхности с помощью математических функций (например, шума)
Шейдер Небольшая программа, выполняемая на GPU, которая определяет положение каждой вершины и цвет каждого пикселя
Функции шума Алгоритмы вроде Perlin и Simplex, генерирующие естественные нерегулярные случайные паттерны
Инстансированный рендеринг Один вызов отрисовки рисует множество похожих объектов; в Three.js это соответствует InstancedMesh
WebGL Графический интерфейс GPU, предоставляемый браузером и позволяющий веб-страницам отрисовывать 3D-сцены
Three.js JavaScript-библиотека для 3D-графики в вебе, инкапсулирующая понятия сцены, камеры, материалов и т. п.
HTML Формат файлов для организации веб-контента и кода; весь основной код Saltline находится в одном HTML-файле
Объём дистрибутива Объём данных, которые игроку нужно скачать
Память во время выполнения Память, занимаемая программой при выполнении, включая геометрию и текстуры, создаваемые во время работы
Нагрузка на GPU Объём вычислений, которые графический процессор должен выполнить за каждый кадр
Токен Базовая единица текста, которую обрабатывает большая языковая модель; также единица расчёта стоимости API

1 Что умещается в HTML-файле на 1,4 МБ: одностраничная архитектура Saltline

1.1 Что представляет собой AI-игра Saltline с 3D-графикой

9 ноября 2026 года инженер Anthropic Феликс Рисеберг опубликовал эксперимент по программированию с Claude Fable 5.2: одним промптом он попросил модель создать небольшой шутер от первого лица, визуально максимально близкий к AAA-игре, при этом без обратной связи от человека. Результат — Saltline.

Действие игры происходит в контейнерном порту дождливой ночью. Игрок должен отключить три сигнальные ретрансляционные станции и эвакуироваться; враги — патрульные дроны в воздухе и механические псы на земле. Есть перемещение от первого лица, стрельба, взаимодействие с объектами и цели миссии, дождь, освещение, эмбиент и эффекты оружия, а также настройки графики. Это однопользовательский играбельный прототип с одним уровнем; «3A» здесь — цель эксперимента и визуальная аналогия. Распространяемая в китайских соцсетях «几猫·国产3A大作» — это китайская версия или переупакованная версия Saltline; название появилось в процессе распространения.

Данные, которые разработчик указал сам, — это его оценки, опубликованные в X и не прошедшие независимую проверку:

  • время разработки — около 8 часов;
  • стоимость по оценке на основе цен API — около 550 долларов;
  • входные токены — около 445 млн, при этом значительная часть попала в кэш;
  • выходные токены — около 2,7 млн.

Поскольку входные токены в основном попадали в кэш, эти расходы нельзя просто пересчитать умножением обычной цены за входной токен на общий объём; структура счёта также не раскрыта. Эти 550 долларов — разовые затраты на генерацию: когда игрок запускает игру в браузере, модель больше не вызывается.

1.2. Устройство index.html: Three.js, генерируемый код и внешние шрифты

В зеркале на GitHub есть точные данные: основной файл index.html весит 1,425,707 байт, то есть примерно 1.43MB (1.36MiB). Его содержимое можно условно разделить на четыре части:

  1. Код Three.js: вся 3D-библиотека упакована прямо в HTML и отвечает за сцену, камеру, материалы и рендеринг через WebGL;
  2. Код генерации сцены и ресурсов: геометрия, текстуры и материалы создаются JavaScript-функциями и шейдерами;
  3. Код процедурного звука: звук тоже синтезируется кодом — отдельных аудиофайлов в репозитории нет;
  4. Игровая логика: управление вводом, поведение врагов и последовательность заданий.

В репозитории нет отдельных файлов изображений, видео и аудио. Единственная явная внешняя зависимость — шрифты Google Fonts. 10 ноября разработчик добавил пояснение: всё в игре создаётся кодом, а текстуры и модели — это функции.

1.3. Что происходит после открытия Saltline в браузере

Весь процесс выглядит как понятный локальный конвейер: браузер читает HTML → запускается JavaScript → инициализируются Three.js и среда рендеринга WebGL → код генерирует геометрию сцены, материалы, текстуры и звук → GPU отрисовывает кадры → игрок управляет клавиатурой и мышью, а игровая логика постоянно обновляется.

На этом конвейере шаг «генерация ресурсов» выполняется на устройстве игрока. Официальная страница Saltline тоже предупреждает: инициализация может занимать заметное время, а производительность устройства влияет на скорость запуска; если страница зависла на экране ожидания, стоит проверить WebGL 2 и аппаратное ускорение браузера; при подтормаживаниях можно переключиться на низкое качество (Low). Сами эти подсказки показывают, насколько велика нагрузка на вычисления во время выполнения.

ai-procedural-3d-game-1-4mb-code-generated-models-textures-ru-image-1

2 Как в традиционных играх создаются модели, текстуры и звук

2.1 Три типа ключевых ассетов традиционной 3D-игры

Картинка и звук в традиционной 3D-игре берутся в основном из заранее подготовленных файлов ассетов:

  • Файлы моделей: художник делает их в программе для моделирования, сохраняются данные о вершинах, полигонах, UV-координатах и т. д.;
  • Текстурные карты: диффузная карта, карта нормалей, карта шероховатости, карта металличности и другие изображения — они накладываются на поверхность модели и добавляют детали;
  • Звуковые файлы: аудио, записанное или синтезированное и затем экспортированное, воспроизводится при наступлении определённого события.

Все эти ассеты проходят через создание, оптимизацию, сжатие и упаковку, а потом распространяются вместе с игрой. Движок загружает их во время работы, и его основная задача — «прочитать и показать».

2.2 Почему традиционные ассеты занимают так много места

Заранее подготовленные ассеты хранят результат. Одна текстура высокого разрешения должна записать значение цвета каждого пикселя; детализированная модель — положение каждой вершины; звуковой фрагмент — каждый сэмпл. Чем богаче сцена и выше разрешение, тем больше данных-результатов нужно записать, и объём растёт линейно.

Процедурный подход хранит процесс. Одна функция шума — это несколько десятков строк кода, но она даёт узор ржавчины в любом разрешении; одна параметризованная функция контейнера создаёт контейнер любого размера. Именно поэтому 1,4 МБ могут вместить целую сцену порта.

Критерий сравнения Традиционные заранее подготовленные ассеты Процедурно генерируемые ассеты
Что хранится в файле Итоговые данные результата (вершины, пиксели, сэмплы) Правила генерации (функции, параметры, шейдеры)
Способ производства Художник создаёт каждый ассет по отдельности в специализированном инструменте Пишется код и параметры, вычисление происходит во время выполнения
Объём при дистрибуции Растёт с количеством ассетов и их точностью Определяется в основном объёмом кода, обычно небольшой
Основная работа во время выполнения Загрузка, декодирование, отображение Построение геометрии, вычисление текстур, синтез звука
Контроль над деталями Художник может точно управлять каждой деталью Зависит от выразительных возможностей алгоритма, настройка параметров дорогостояща
Типичные объекты применения Персонажи, ключевые предметы, реалистичные сцены Повторяющиеся структуры, природные поверхности, погодные эффекты

3. Как ИИ создаёт игровые ассеты кодом: четыре процедурных техники

Процедурная генерация — приём, который игровая индустрия использует уже давно: на нём держатся ландшафты «Minecraft» и уровни бесчисленных roguelike. Новизна Saltline в другом: модель ИИ в рамках одного непрерывного процесса генерации написала код сразу для геометрии, текстур, шейдеров, звука и игровой логики — и тем самым убрала лишние передачи работы между моделированием, материалами, звуком и программированием.

Уровень Объект генерации Технический подход Пример в Saltline
Генерация геометрии Форма модели Вершины, полигоны, параметрическая геометрия Контейнеры, склад, конструкции причала
Генерация материалов Свойства поверхности Параметры цвета, шероховатости, металличности Металлическая обшивка контейнера
Генерация текстур Детали поверхности Шум, фракталы, Voronoi Ржавчина, пятна, потёртости
Генерация окружения Компоновка сцены Правила, случайные числа, пространственные связи Расположение штабелей контейнеров
Генерация анимации Движение объектов Математические функции, смена состояний Патрулирование дронов, падение капель дождя
Генерация звука Звуковые эффекты Осцилляторы, фильтры, шум Шум дождя, выстрелы, эмбиент

3.1 Процедурная геометрия: собираем контейнер из параметров

Контейнер — это по сути прямоугольный параллелепипед с гофрированными боковыми стенками. Подход процедурной геометрии такой: по параметрам длины, ширины и высоты генерируем шестигранник, а затем смещаем вершины вдоль боковых граней по синусоиде, имитируя рельеф гофрированной стали. BufferGeometry в Three.js позволяет напрямую записывать массив вершин, а BoxGeometry даёт готовый параметризованный корпус.

В порту сотни и тысячи контейнеров, и все они используют одни и те же геометрические данные. В этом случае применяют инстансинг через InstancedMesh: достаточно хранить для каждого экземпляра матрицу преобразования (позиция, поворот, масштаб) и цвет — и всю площадку с контейнерами можно отрисовать за один вызов отрисовки.

3.2 Процедурные текстуры: рисуем ржавчину шумовыми функциями

Процедурные текстуры генерируют данные текстуры алгоритмически. Часто используемые алгоритмы — Perlin Noise, Simplex Noise, Voronoi и фрактальный шум: наложив несколько слоёв шума с разными частотами, получаем естественное распределение пятен ржавчины; а с помощью Voronoi можно сделать блочные границы отслаивающейся краски.

В Three.js такие текстуры обычно вычисляются один раз на этапе инициализации, записываются в DataTexture (прямое заполнение массива пикселей) или CanvasTexture (рисование через Canvas 2D), а затем передаются материалу как обычная карта. Текстура создаётся один раз и постоянно живёт в видеопамяти, так что дополнительные затраты во время работы — это в основном занятая ею видеопамять.

3.3 Shader: попиксельный расчёт металла и дождя на GPU

Shader работает на GPU и в реальном времени вычисляет цвет каждого пикселя по входным данным — координатам, времени, освещению. От процедурных текстур его отличает момент, когда происходят вычисления: процедурную текстуру можно рассчитать заранее и получить готовую картинку, а Shader считает всё на месте каждый кадр — полное изображение ему генерировать не нужно.

Ночной дождливый порт — типичная сцена для Shader. Отражения на влажном металле, рябь на лужах, которая меняется со временем, падающие струи дождя — всё это можно записать как функции от времени и пересчитывать каждый кадр. ShaderMaterial в Three.js позволяет напрямую написать вершинный и фрагментный шейдеры и реализовать эти эффекты. Компромисс между двумя подходами простой: заранее сгенерированные текстуры занимают память, но экономят вычислительные ресурсы; Shader-вычисления в реальном времени экономят память, но нагружают GPU.

3.4 Процедурный звук: синтезируем шум дождя осцилляторами и фильтрами

Web Audio API в браузере даёт осцилляторы, буферы шума и узлы-фильтры. Белый шум после фильтра низких частот уже похож на шум дождя; короткая вспышка шума с быстро затухающей огибающей громкости — это выстрел; низкочастотный осциллятор, модулирующий высоту тона, имитирует гул дрона. В репозитории Saltline нет ни одного аудиофайла — все звуки синтезируются в реальном времени таким вот кодом.

ai-procedural-3d-game-1-4mb-code-generated-models-textures-ru-image-2

4 Файл стал меньше — значит, и работает легче? Анализ затрат на процедурную генерацию

4.1 Разделяем объём дистрибутива, оперативную память и нагрузку на GPU

Чтобы оценить «вес» 3D-игры, нужно смотреть как минимум на три измерения:

  1. Объём дистрибутива: сколько данных скачивает игрок. Saltline здесь сильно выигрывает;
  2. Оперативная память: вершинные буферы, текстуры и аудиобуферы, создаваемые во время выполнения, занимают память и видеопамять — программа размером 1.4 МБ вполне может во время работы создать сотни МБ данных;
  3. Вычислительная нагрузка: объём работы, который CPU и GPU выполняют каждый кадр; сложные шейдеры напрямую увеличивают этот показатель.

И наоборот, игра с большим объёмом тоже может работать эффективно за счёт сжатия, блочной загрузки и потоковой передачи ресурсов. Судить о достоинствах технического подхода только по размеру файла — значит делать односторонние выводы.

4.2 Куда процедурная генерация переносит затраты

Технология Что может сократить затраты Что может увеличить затраты
Процедурные модели Загрузку и хранение моделей Время построения геометрии на CPU
Шейдерные текстуры Файлы изображений и передачу текстур Покадровые вычисления на GPU в реальном времени
Процедурные текстуры (предварительная генерация) Загрузку файлов изображений Вычисления при инициализации и занятость видеопамяти
Инстансинг Повторяющиеся вызовы отрисовки Управление сценой и поддержку данных экземпляров
Динамическая генерация сцен Количество заранее подготовленных ассетов Вычисления при инициализации и во время работы
Процедурное аудио Хранение аудиофайлов Затраты на синтез аудио в реальном времени

Saltline инициализируется медленнее и вынуждена предлагать настройку качества Low — это как раз реальное отражение этой таблицы: работа, сэкономленная на загрузке, снова оплачивается на этапе запуска и при отрисовке каждого кадра.

4.3 Компромиссы между шейдерами, инстансингом и динамической геометрией

Эти три технологии решают разные задачи, и вместе они работают лучше всего:

  • Инстансинг сокращает число вызовов отрисовки, которые CPU отправляет GPU, и лучше всего подходит для множества повторяющихся объектов — например, контейнерных площадок, фонарей, частиц дождя;
  • Шейдеры переносят расчёт деталей на GPU и подходят для эффектов, меняющихся со временем (дождь, лужи, мерцание света). Цена — чем сложнее фрагментный шейдер, тем выше нагрузка на GPU при высоком разрешении;
  • Динамическая геометрия подходит для структур, которые должны меняться по параметрам или имеют ограниченное количество. Затраты на построение сосредоточены на этапе инициализации, а после построения это обычный меш.

Обычное инженерное направление оптимизации: то, что можно посчитать заранее, рассчитывается один раз на этапе инициализации и кэшируется; в шейдер, работающий каждый кадр, выносится только то, что действительно должно меняться со временем.

4.4 Отличие подхода Saltline от облачного гейминга и ИИ-моделей мира

«ИИ делает игры» — сегодня это как минимум три технических подхода. Saltline относится к первому из них.

Критерий сравнения Локальные веб-игры Облачный гейминг ИИ-модели мира
Примеры Saltline GeForce NOW, Pixel Streaming Genie 3, Muse/WHAMM, Oasis
Где участвует ИИ Генерация кода на этапе разработки Обычно не участвует Покадровая генерация изображения во время выполнения
Генерация изображения Локальный рендеринг на GPU Рендеринг на GPU в облаке с последующей передачей видеопотока Генерация в реальном времени через предсказание модели
Требования к сети После первой загрузки можно играть офлайн Постоянное подключение к сети Обычно требуется постоянное подключение к сети
Когда возникают затраты Единоразовые затраты на разработку, дальше нагрузка ложится на устройство игрока Затраты на сервер при каждом запуске игры Затраты на инференс при каждом запуске игры
Основные ограничения Браузер и локальное оборудование Задержка сети, пропускная способность Согласованность, задержка, управляемость

Saltline сосредотачивает затраты на ИИ на этапе разработки: после завершения генерации правила игры определяются кодом, а работа не зависит от модели. Именно поэтому игра может работать офлайн, а производительность устройства игрока задаёт верхнюю границу качества впечатлений.

5 Быстрый старт с процедурной 3D-игрой: с помощью API заставляем большую языковую модель генерировать код сцены

5.1 Минимальный пример: генерируем процедурную сцену одним вызовом

Скрипт ниже вызывает большую языковую модель через OpenAI-совместимый интерфейс и просит её выдать один HTML-файл, содержащий процедурные контейнеры, шумовую ржавчину и дождь на шейдерах. Имя модели указывайте точно так, как оно записано в списке моделей платформы:

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # APIYI: единый интерфейс, один ключ для вызова моделей разных провайдеров
)

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 часов и сотни миллионов токенов; пример выше демонстрирует лишь минимальный замкнутый цикл той же идеи.

Посмотреть полную реализацию: рукописный справочный код с процедурными контейнерами, шумовой ржавчиной, дождём на шейдерах и синтезированным звуком дождя

Ниже — рукописная справочная реализация, по которой удобно сверять и понимать структуру кода, сгенерированного моделью. В одном файле собраны четыре технологии из главы 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. Процедурная текстура: многослойный value-noise генерирует ржавчину, результат пишем в 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. Шейдер: позиции струй дождя вычисляются на 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. Процедурный звук: белый шум через low-pass фильтр имитирует шум дождя (запускается по клику на странице)
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 и стилем написания шейдеров. Через APIYI apiyi.com можно переключаться между несколькими моделями с одним и тем же ключом и сравнивать качество вывода бок о бок — бесплатной тестовой квоты для новых пользователей достаточно, чтобы пройти несколько раундов сравнения.

5.2 Три практических приёма составления промптов

Написать промпт как техническое задание лучше, чем как одно предложение-мечту:

  • Указывайте технические точки: явно требуйте конкретные API вроде InstancedMesh, DataTexture, ShaderMaterial — тогда модель пойдёт по процедурному пути, а не будет предполагать наличие внешних ресурсов;
  • Озвучивайте ограничения: пишите «не использовать никакие изображения, файлы моделей, аудиофайлы» и «один HTML-файл», как в ограничениях Saltline;
  • Требуйте уровни качества: просите модель предусмотреть переключение низкого, среднего и высокого качества (например, уменьшение количества капель дождя, отключение теней) — так же, как в Saltline сделан пресет Low.

5.3 Как оценивать стоимость генерации

Возьмём за ориентир официальные цены Anthropic на Claude Fable 5.2: 8 долларов за миллион входных токенов, 40 долларов за миллион выходных, 0,20 доллара за миллион токенов чтения из кеша и 10 долларов за миллион токенов записи в кеш на 5 минут; контекстное окно — 1M токенов, максимальный вывод — 128K токенов. У одиночной генерации, как в разделе 5.1, расход токенов обычно измеряется тысячами или десятками тысяч. А вот у Saltline с его 8-часовой автономной итерацией код постоянно перечитывается, и разница в цене из-за попаданий в кеш заметно влияет на общую стоимость — поэтому в долгих задачах стоит в первую очередь задействовать кеширование промптов.

Совет по стоимости: когда запускаете долгий эксперимент с генерацией кода, сначала измерьте расход токенов за один раунд на небольшом промпте в APIYI apiyi.com, а потом оценивайте общий бюджет по числу итераций. Платформа считает по факту потребления, так что удобно проверять схему «сначала малое, потом большое».

6. Частые вопросы (FAQ)

Вопрос 1: Что такое процедурно генерируемые 3D-ассеты для игр?

Процедурно генерируемые ассеты — это когда правила создания моделей, текстур и звуков описываются кодом и параметрами, а результат вычисляется уже во время работы. В файле хранится «как это нарисовать», а в традиционном файле ассета — «уже нарисованный результат». Контейнеры, ржавчина и шум дождя в Saltline как раз из этой категории.

Вопрос 2: Чем процедурные текстуры отличаются от шейдеров?

Процедурная текстура — это когда данные текстуры генерируются алгоритмом, и их можно заранее просчитать в одну картинку и положить в видеопамять. Шейдер — это программа на GPU, которая вычисляет цвет пикселя прямо при рендере каждого кадра. Первый вариант больше ест память и меньше — вычисления, второй наоборот; на практике их часто комбинируют.

Вопрос 3: Когда вышла Saltline и на какой модели она сделана?

9 ноября 2026 года, автор — инженер Anthropic Феликс Рисеберг (Felix Rieseberg), использовалась Claude Fable 5.2, один промпт, без обратной связи от человека. Примерно 8 часов, около 550 долларов, порядка 445 млн входных токенов и 2,7 млн выходных — всё это оценки самого разработчика. 10 ноября он добавил уточнение, что модель и текстуры целиком сгенерированы кодом.

Вопрос 4: Для каких игровых сценариев процедурная генерация подходит лучше всего?

— **Массовые повторяющиеся структуры**: контейнерные площадки, застройка, растительность — в связке с инстансированным рендерингом дают лучший результат;
— **Природные поверхности**: ржавчина, камни, древесные волокна — материалы, которые хорошо описываются шумом;
— **Динамическая погода и эффекты**: дождь, рябь на лужах, мерцание света — всё, что меняется со временем;
— **Сценарии, чувствительные к объёму дистрибуции**: браузерные мини-игры, интерактивная реклама, прототипы с мгновенным запуском.

Для главных героев и ключевых сюжетных предметов, где нужен точный художественный контроль, готовые ассеты всё ещё уместнее. В коммерческих проектах обычно используют смешанный подход.

Вопрос 5: Как через API заставить большую языковую модель генерировать код процедурных 3D-сцен?

1. Зарегистрируйтесь на APIYI apiyi.com и получите API-ключ и бесплатный тестовый лимит;
2. Используйте скрипт из раздела 5.1 этой статьи, указав base_url `https://api.apiyi.com/v1`;
3. В промпте явно пропишите ограничения: API Three.js, один файл, без внешних ресурсов — а после генерации откройте результат в браузере и проверьте.

Интерфейс совместим с форматом OpenAI, так что для переключения между Claude, GPT, Gemini и другими моделями достаточно изменить параметр model.

Вопрос 6: Какие известные ограничения есть у процедурной генерации?

— **Затраты в рантайме**: вычисления при инициализации, расход видеопамяти и нагрузка на GPU от сложных шейдеров ложатся на устройство игрока; Saltline также требует опцию качества Low и довольно долгую инициализацию.
— **Ограничения браузера**: в официальной документации Unity указано, что веб-платформа ограничена в работе с файловой системой, потоками и памятью, а поддержка мобильных устройств ограничена.
— **Художественный контроль**: выразительность алгоритмов имеет пределы — реалистичных персонажей и детализированные предметы трудно создать только кодом.
— **Инженерная зрелость**: AI быстро создаёт играбельный прототип, но коммерческой игре всё равно нужны серьёзные инженерные усилия для долгосрочной оптимизации, тестирования и расширения контента.

7. Ключевые выводы: 3D-игра весом 1,4 МБ и процедурная генерация

  • Откуда берётся размер: Saltline весит около 1,4 МБ — в файле хранятся правила генерации, а не изображения, модели и аудиофайлы.
  • Четыре технологии: процедурная геометрия, процедурные текстуры, шейдеры и процедурные звуковые эффекты — каждая отвечает за свой слой, с чётким разделением задач.
  • Перенос затрат: размер загрузки снижается, но соответственно растут затраты на сборку на CPU, использование видеопамяти и вычисления GPU на каждый кадр.
  • Что оценивать: одновременно смотреть на размер дистрибутива, время инициализации, потребление оперативной памяти и затраты GPU на каждый кадр.
  • Роль AI: AI пишет код генерации, а сами процедурные технологии уже давно широко применяются в разработке игр.
  • Как начать: через APIYI apiyi.com с помощью одного ключа сравнить код сцен Three.js, который генерируют разные модели.

8. Итог: разработка игр движется от создания ассетов к написанию правил генерации ассетов

Saltline показывает смену самого способа выражать ресурсы: традиционная игра поставляет «готовые ассеты», а процедурная игра — «правила, по которым эти ассеты генерируются». Генерация кода с помощью ИИ заметно снижает порог входа на этот путь — одна модель может в рамках одного продолжающегося процесса генерации написать сразу геометрию, текстуры, шейдеры, звук и игровую логику, избавляя от передачи задач между разными специалистами.

У этого пути есть чёткие границы применимости. Он явно выигрывает по размеру дистрибутива и простоте развёртывания, но при этом переносит вычислительную нагрузку на устройства игроков. Он хорошо справляется с повторяющимися структурами, природными поверхностями и динамическими эффектами, однако детализированные художественные ассеты по-прежнему требуют традиционного производства. Традиционное производство ассетов и процедурное производство будут долго дополнять друг друга, а ценность Saltline в том, что он доказывает: небольшая по объёму программа тоже способна построить насыщенную интерактивную сцену.

Если хотите проверить этот путь на практике, начните со скрипта из раздела 5.1. Рекомендую вызывать разные модели через APIYI apiyi.com для генерации процедурных сцен и сравнивать, насколько хорошо они владеют Three.js и шейдерами.

📚 Справочные материалы

  1. Зеркало кода Saltline и README: структура одного файла, размер в байтах и принадлежность данных разработчику
  2. Ссылка: github.com/realcodebear/saltline-fable-5.2
  3. Описание: здесь можно напрямую посмотреть программно сгенерированный код index.html

  4. Отдельная страница для знакомства с Saltline: онлайн-демо, а также описание инициализации и настроек качества графики

  5. Ссылка: saltline.games
  6. Описание: китайская версия доступна по адресу saltline.games/zh

  7. GitHub-репозиторий китайской версии 几猫: архив версии, распространявшейся в Китае

  8. Ссылка: github.com/Megasu/jimao-3a-game
  9. Описание: содержит инструкцию по офлайн-запуску и данные о размере файлов

  10. Спецификации и цены модели Claude Fable 5.2: официальная документация Anthropic

  11. Ссылка: platform.claude.com/docs/en/models/fable-5-2/overview
  12. Описание: цены на ввод, вывод и кэширование, а также спецификации контекстного окна

  13. Официальная документация и примеры Three.js: InstancedMesh, ShaderMaterial, BufferGeometry, DataTexture

  14. Ссылка: threejs.org/docs и threejs.org/examples
  15. Описание: авторитетное описание API, используемых в коде этой статьи

  16. MDN WebGL API: интерфейс GPU-рендеринга в браузере

  17. Ссылка: developer.mozilla.org/en-US/docs/Web/API/WebGL_API
  18. Описание: помогает понять, как работает рендеринг в основе Three.js

  19. Обзор технологий Unity WebGL: потоки, память и ограничения мобильных платформ в вебе

  20. Ссылка: docs.unity.cn/6000.0/Documentation/Manual/webgl-technical-overview.html
  21. Описание: справочник для оценки инженерных границ браузерных игр

Автор: техническая команда APIYI
Обсуждение технологий: свяжитесь с нами на главной странице APIYI apiyi.com, больше материалов по интеграции — в центре документации docs.apiyi.com

Читайте также