Коротко
Память текстуры в видеокарте считается по пикселям, а не по файлу: ширина × высота × байт на пиксель формата хранения, и ещё около трети сверху, если включена цепочка мипмапов. В нашем прогоне PNG тайлов 2048×2048 весит 669 461 байт, а в RGBA8 занимает 16 777 216 байт; уровень с файлами на 1,33 МиБ требует 46 МиБ видеопамяти. Атлас должен помещаться в MAX_TEXTURE_SIZE устройства и не тратить место на прозрачные поля, а выгрузка уровня — это deleteTexture для текстур, на которые больше не ссылается ни один уровень, а не только очистка кэша картинок в JS.
Содержание
- Три размера одной картинки
- Модель: «Лис-почтальон», три биома и одиннадцать атласов
- Код на JavaScript и проверка в Node.js
- Что показал прогон: восемь ловушек
- MAX_TEXTURE_SIZE: спрашивать у контекста, а не угадывать
- Формат хранения: что меняет байты на пиксель
- Выгрузка: две половины и счётчик ссылок
- Практический сценарий: бюджет видеопамяти «Лиса-почтальона»
- Когда вам это не подойдёт
Три размера одной картинки
У каждой картинки в игре три разных размера — файл, декодированные пиксели и текстура в видеокарте, — и подменять один другим нельзя. Файл PNG или WebP сжат; чтобы что-то нарисовать, браузер его декодирует, а при загрузке в WebGL пиксели копируются в текстуру в том формате, который вы указали.
| Размер | Чем определяется | Когда освобождается |
|---|---|---|
| Файл (PNG, WebP) | содержимым картинки и сжатием | после декодирования игре не нужен |
| Декодированные пиксели | ширина × высота × 4 байта для RGBA (в нашей модели) | когда ссылок нет или после ImageBitmap.close() |
| Текстура в видеокарте | ширина × высота × байт на пиксель формата, плюс мипмапы | после gl.deleteTexture(), когда текстура больше не используется |
Первая строка — тема статьи о загрузке ресурсов: там вес файлов определяет, сколько ждать. Здесь — третья строка: сколько видеопамяти занимает уже загруженный уровень.
Видеопамять нельзя спросить у браузера. В рекомендациях MDN по WebGL сказано, что WebGL не даёт API для запроса объёма видеопамяти, потому что такие запросы непереносимы; приложению советуют самому оценивать, сколько оно выделило, обрабатывать событие webglcontextlost и предлагать настройки качества. Поэтому всё ниже — оценка, которую игра ведёт сама.
Модель: «Лис-почтальон», три биома и одиннадцать атласов
Наш пример — браузерный платформер «Лис-почтальон» с тремя биомами: Лес, Пещера и Ледник; у каждого свои атласы, а часть атласов общая. Игра, атласы, размеры, рисунки и все числа — наш пример.
| Атлас (наш пример) | Размер | Кому нужен |
|---|---|---|
hero — лис и письма | 1024×1024 | всем уровням |
ui — интерфейс | 1024×512 | всем уровням |
ground — тайлы земли | 2048×2048 | Лесу и Пещере |
forest-props, cave-props — декор | 2048×2048 | своему уровню |
forest-back, cave-back, ice-back — фон | 2048×1024 | своему уровню |
ice-tiles — тайлы льда | 2048×2048 | Леднику |
ice-props — 180 спрайтов декора, boss — 16 кадров 256×256 | считает упаковщик | Леднику |
Чтобы вес файлов был настоящим, код рисует каждый атлас в памяти — круги на прозрачном поле, плотные плитки или полосатый фон — и кодирует его в PNG через zlib из Node.js. Рисунок детерминированный, генератор с фиксированным зерном, поэтому файлы одного размера при каждом запуске. Маршрут игрока — Лес → Пещера → Ледник → снова Лес: возврат проверяет, что выгрузка не сломала повторный вход.
Код на JavaScript и проверка в Node.js
Код — шесть модулей: кодировщик PNG, учёт видеопамяти, упаковщик, данные игры, способы сменить уровень и проверочный файл. Запуск — Node.js 24.22.1, модули ES (.mjs); живого контекста WebGL в Node.js нет, поэтому модули не рисуют, а считают то, что выделил бы контекст.
Модуль png.mjs рисует атлас и кодирует его в настоящий PNG: сигнатура, заголовок, сжатые данные и контрольные суммы.
// png.mjs — наш пример: рисуем атлас в памяти и кодируем в PNG, чтобы вес файла был настоящим.
import { deflateSync, crc32 } from "node:zlib";
function chunk(type, data) {
const head = Buffer.alloc(8), crc = Buffer.alloc(4);
head.writeUInt32BE(data.length, 0);
head.write(type, 4, "latin1");
crc.writeUInt32BE(crc32(Buffer.concat([head.subarray(4), data])));
return Buffer.concat([head, data, crc]);
}
// RGBA 8 бит на канал; у каждой строки фильтр 1 (Sub): байт минус байт пикселя слева.
export function encodePng(w, h, rgba) {
const raw = Buffer.alloc(h * (1 + w * 4)), ihdr = Buffer.alloc(13);
for (let y = 0; y < h; y++) {
const o = y * (1 + w * 4), s = y * w * 4;
raw[o] = 1;
for (let i = 0; i < w * 4; i++) raw[o + 1 + i] = (rgba[s + i] - (i >= 4 ? rgba[s + i - 4] : 0)) & 255;
}
ihdr.writeUInt32BE(w, 0); ihdr.writeUInt32BE(h, 4); ihdr[8] = 8; ihdr[9] = 6;
const sig = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
return Buffer.concat([sig, chunk("IHDR", ihdr), chunk("IDAT", deflateSync(raw, { level: 6 })), chunk("IEND", Buffer.alloc(0))]);
}
// Рисунок детерминированный: генератор с зерном. "sprites" — круги на прозрачном поле,
// "tiles" — плотные плитки 32×32, "backdrop" — непрозрачный полосатый фон.
export function paintAtlas(w, h, style, seed) {
let st = seed;
const rnd = () => (st = (Math.imul(st, 1664525) + 1013904223) >>> 0) / 4294967296;
const px = new Uint8Array(w * h * 4), cell = style === "tiles" ? 32 : 128;
const palette = Array.from({ length: 12 }, () => [rnd(), rnd(), rnd()].map((c) => Math.floor(c * 255)));
for (let cy = 0; cy < h; cy += cell) for (let cx = 0; cx < w; cx += cell) {
const base = palette[Math.floor(rnd() * 12)], dark = base.map((c) => c >> 1), r = cell * (0.25 + rnd() * 0.2);
for (let y = cy; y < Math.min(cy + cell, h); y++) for (let x = cx; x < Math.min(cx + cell, w); x++) {
const dx = x - cx - cell / 2, dy = y - cy - cell / 2;
let c = null;
if (style === "backdrop") c = (y >> 4) % 2 ? base : dark;
else if (style === "tiles") c = x - cx < 2 || y - cy < 2 ? dark : base;
else if (dx * dx + dy * dy < r * r) c = dy > 0 ? dark : base;
if (c === null) continue;
const n = rnd() < (style === "tiles" ? 0.03 : 0.06) ? 24 : 0, i = (y * w + x) * 4;
px.set([Math.min(255, c[0] + n), Math.min(255, c[1] + n), Math.min(255, c[2] + n), 255], i);
}
}
return px;
}
Модуль gpu.mjs — байты на пиксель по формату, цепочка мипмапов, учёт живых текстур и сторона JS с кэшем картинок. Формула для ASTC взята из таблицы MDN по расширению WEBGL_compressed_texture_astc.
// gpu.mjs — наш пример: сколько байт занимает текстура в видеокарте и учёт живых текстур.
// Несжатые форматы: ширина × высота × байт на пиксель. ASTC — формула блоков из таблицы MDN.
// RGB8 считаем по 4 байта: трёхканальные форматы драйвер может эмулировать четырёхканальными.
const astc = (bw, bh) => (w, h) => Math.floor((w + bw - 1) / bw) * Math.floor((h + bh - 1) / bh) * 16;
export const FORMATS = {
RGBA8: { label: "RGBA8, 8+8+8+8 бит", bytes: (w, h) => w * h * 4 },
RGB8: { label: "RGB8, 8+8+8 бит (считаем как RGBA8)", bytes: (w, h) => w * h * 4 },
RGBA4: { label: "RGBA4, 4+4+4+4 бит", bytes: (w, h) => w * h * 2 },
ASTC4: { label: "ASTC 4×4 (сжатый, нужно расширение)", bytes: astc(4, 4) },
ASTC8: { label: "ASTC 8×8 (сжатый, нужно расширение)", bytes: astc(8, 8) },
};
// Цепочка мипмапов: каждый уровень вдвое меньше предыдущего (с округлением вниз), до 1×1.
export function mipChain(w, h) {
const levels = [[w, h]];
while (w > 1 || h > 1) {
w = Math.max(1, Math.floor(w / 2));
h = Math.max(1, Math.floor(h / 2));
levels.push([w, h]);
}
return levels;
}
export function textureBytes(format, w, h, mips = false) {
const levels = mips ? mipChain(w, h) : [[w, h]];
return levels.reduce((sum, [lw, lh]) => sum + FORMATS[format].bytes(lw, lh), 0);
}
// Учёт видеопамяти: то, что в WebGL делают texImage2D / texStorage2D и deleteTexture.
export function createGpu(maxTextureSize) {
const live = new Map();
let bytes = 0, peak = 0, uploaded = 0;
return {
maxTextureSize,
upload(name, t) {
if (t.w > maxTextureSize || t.h > maxTextureSize)
return { ok: false, why: t.w + "×" + t.h + " больше MAX_TEXTURE_SIZE " + maxTextureSize };
if (live.has(name)) return { ok: true, bytes: 0 };
const b = textureBytes(t.format, t.w, t.h, t.mips);
live.set(name, b);
bytes += b; uploaded += b; peak = Math.max(peak, bytes);
return { ok: true, bytes: b };
},
remove(name) {
if (!live.has(name)) return 0;
const b = live.get(name);
live.delete(name);
bytes -= b;
return b;
},
has: (name) => live.has(name),
get bytes() { return bytes; },
get peak() { return peak; },
get uploaded() { return uploaded; },
get count() { return live.size; },
};
}
// Сторона JS: кэш загруженных картинок. Декодированная картинка — ширина × высота × 4 байта.
export function createJs() {
const cache = new Map();
let fetched = 0;
return {
load(name, t) {
if (cache.has(name)) return;
cache.set(name, t.w * t.h * 4);
fetched += t.file;
},
drop(name) { cache.delete(name); }, // удалить из кэша и вызвать ImageBitmap.close()
get decoded() { let s = 0; for (const b of cache.values()) s += b; return s; },
get fetched() { return fetched; },
};
}
export const MiB = (b) => (b / 1048576).toFixed(2).replace(".", ",") + " МиБ";
export const num = (n) => String(n).replace(/\B(?=(\d{3})+(?!\d))/g, " ");
Модуль pack.mjs укладывает спрайты полками. Как найти прямоугольник кадра в листе, разобрано в нашей статье о спрайтовых листах и покадровой анимации; здесь упаковщик отвечает на один вопрос — сколько пикселей атласа уходит впустую.
// pack.mjs — наш пример: укладка спрайтов в атлас полками и проверка пустого места.
// Полка — ряд спрайтов одной высоты; padding — зазор между спрайтами, чтобы фильтр не цеплял соседа.
export function packShelves(sizes, maxWidth, padding) {
const items = sizes.map((s, i) => ({ ...s, i })).sort((a, b) => b.h - a.h || b.w - a.w || a.i - b.i);
let x = 0, y = 0, shelfH = 0, width = 0;
for (const s of items) {
if (x > 0 && x + s.w > maxWidth) { y += shelfH + padding; x = 0; shelfH = 0; }
s.x = x; s.y = y;
x += s.w + padding;
shelfH = Math.max(shelfH, s.h);
width = Math.max(width, s.x + s.w);
}
const used = sizes.reduce((sum, s) => sum + s.w * s.h, 0);
return { w: width, h: y + shelfH, used, fill: used / (width * (y + shelfH)) };
}
// Все кадры в один ряд — так выглядит лист, собранный вручную без упаковщика.
export function packRow(sizes, padding) {
const w = sizes.reduce((sum, s) => sum + s.w, 0) + padding * (sizes.length - 1);
return { w, h: Math.max(...sizes.map((s) => s.h)) };
}
Модуль game.mjs описывает атласы и уровни. Размеры декора Ледника и листа босса получены упаковщиком, вес каждого PNG — длина закодированного файла.
// game.mjs — наш пример: платформер «Лис-почтальон», три биома и их атласы.
import { encodePng, paintAtlas } from "./png.mjs";
import { packShelves, packRow } from "./pack.mjs";
export const LIMIT = 4096; // MAX_TEXTURE_SIZE в модели; в игре его спрашивают у контекста
// Декор ледника: 180 спрайтов, каждый художник выгрузил отдельным файлом на холсте 128×128.
// Сам рисунок меньше холста — остальное прозрачные поля.
export const ICE_PROPS = Array.from({ length: 180 }, (_, i) => ({ w: 40 + (i * 37) % 80, h: 36 + (i * 53) % 88 }));
export const ICE_CANVAS = 128;
const icePacked = packShelves(ICE_PROPS, 1024, 2);
// Босс ледника: 16 кадров 256×256 с зазором 2 пикселя.
export const BOSS_FRAMES = Array.from({ length: 16 }, () => ({ w: 256, h: 256 }));
export const bossRow = packRow(BOSS_FRAMES, 2);
const bossShelves = packShelves(BOSS_FRAMES, LIMIT, 2);
// Атласы: размер, формат в видеокарте, мипмапы и стиль рисунка для настоящего PNG.
export const ATLASES = {
hero: { w: 1024, h: 1024, style: "sprites", seed: 1 },
ui: { w: 1024, h: 512, style: "sprites", seed: 2 },
ground: { w: 2048, h: 2048, style: "tiles", seed: 3 },
"forest-props": { w: 2048, h: 2048, style: "sprites", seed: 4 },
"forest-back": { w: 2048, h: 1024, style: "backdrop", seed: 5 },
"cave-props": { w: 2048, h: 2048, style: "sprites", seed: 6 },
"cave-back": { w: 2048, h: 1024, style: "backdrop", seed: 7 },
"ice-tiles": { w: 2048, h: 2048, style: "tiles", seed: 8 },
"ice-props": { w: icePacked.w, h: icePacked.h, style: "sprites", seed: 9 },
"ice-back": { w: 2048, h: 1024, style: "backdrop", seed: 10 },
boss: { w: bossShelves.w, h: bossShelves.h, style: "sprites", seed: 11 },
};
for (const a of Object.values(ATLASES)) {
a.format = "RGBA8";
a.mips = false;
a.file = encodePng(a.w, a.h, paintAtlas(a.w, a.h, a.style, a.seed)).length;
}
// Какие атласы нужны каждому уровню. hero и ui — всем, ground — лесу и пещере.
export const LEVELS = {
forest: ["hero", "ui", "ground", "forest-props", "forest-back"],
cave: ["hero", "ui", "ground", "cave-props", "cave-back"],
glacier: ["hero", "ui", "ice-tiles", "ice-props", "ice-back", "boss"],
};
export const ROUTE = ["forest", "cave", "glacier", "forest"];
export const NAMES = { forest: "Лес", cave: "Пещера", glacier: "Ледник" };
Модуль levels.mjs — шесть способов сменить уровень. Четыре ошибочных выглядят рабочими, пока не посмотришь на счётчик видеопамяти или на список пропавших текстур.
// levels.mjs — наш пример: шесть способов сменить уровень; четыре из них ошибочны.
import { createGpu, createJs } from "./gpu.mjs";
import { ATLASES, LEVELS } from "./game.mjs";
function world(limit) {
const gpu = createGpu(limit), js = createJs();
const load = (name) => { js.load(name, ATLASES[name]); return gpu.upload(name, ATLASES[name]); };
const missing = (level) => LEVELS[level].filter((n) => !gpu.has(n));
return { gpu, js, load, missing };
}
// А. Ничего не выгружаем.
export function keepAll(limit) {
const w = world(limit);
return { ...w, enter(level) { LEVELS[level].forEach(w.load); } };
}
// Б. «Выгружаем» только сторону JS: чистим кэш и закрываем ImageBitmap, текстуры не удаляем.
export function jsOnly(limit) {
const w = world(limit);
let prev = null;
return { ...w, enter(level) {
if (prev) LEVELS[prev].forEach((n) => w.js.drop(n));
LEVELS[level].forEach(w.load);
prev = level;
} };
}
// В и Г: выгружаем список прошлого уровня целиком; разница — в порядке (order).
export function byList(limit, order) {
const w = world(limit);
let prev = null;
const unload = () => prev && LEVELS[prev].forEach((n) => { w.js.drop(n); w.gpu.remove(n); });
return { ...w, enter(level) {
if (order === "удалить, потом грузить") unload();
LEVELS[level].forEach(w.load);
if (order === "грузить, потом удалить") unload();
prev = level;
} };
}
// Д и Е: счётчик ссылок. Текстура удаляется, когда на неё не ссылается ни один уровень;
// ImageBitmap закрываем сразу после загрузки. Разница — в порядке (order).
export function refCounted(limit, order) {
const w = world(limit);
const refs = new Map();
let prev = null;
const loadOnce = (n) => { if (!w.gpu.has(n)) { w.load(n); w.js.drop(n); } };
const mark = (n) => refs.set(n, (refs.get(n) || 0) + 1);
const release = (n) => {
refs.set(n, refs.get(n) - 1);
if (refs.get(n) === 0) { refs.delete(n); w.gpu.remove(n); }
};
return { ...w, refs, enter(level) {
LEVELS[level].forEach(mark);
if (order === "сначала взять") LEVELS[level].forEach(loadOnce);
if (prev) LEVELS[prev].forEach(release);
LEVELS[level].forEach(loadOnce);
prev = level;
} };
}
Проверочный файл test.mjs печатает семь сцен. Часов и встроенной случайности в коде нет, поэтому вывод одинаков при каждом запуске.
// test.mjs — наш пример: память текстур «Лиса-почтальона», Node.js 24.
import { FORMATS, mipChain, textureBytes, createGpu, MiB, num } from "./gpu.mjs";
import { packShelves } from "./pack.mjs";
import { LIMIT, ATLASES, LEVELS, ROUTE, NAMES, ICE_PROPS, ICE_CANVAS, BOSS_FRAMES, bossRow } from "./game.mjs";
import * as managers from "./levels.mjs";
const gpuOf = (n) => textureBytes(ATLASES[n].format, ATLASES[n].w, ATLASES[n].h, ATLASES[n].mips);
const sum = (names, f) => names.reduce((s, n) => s + f(n), 0);
console.log("1. Размер файла и память видеокарты");
const g = ATLASES.ground;
console.log(" ground 2048×2048: PNG " + num(g.file) + " байт, RGBA8 без мипмапов " + num(gpuOf("ground")) +
" байт, соотношение 1 : " + Math.round(gpuOf("ground") / g.file));
const all = Object.keys(ATLASES);
console.log(" все " + all.length + " атласов: файлы " + MiB(sum(all, (n) => ATLASES[n].file)) +
", видеокарта " + MiB(sum(all, gpuOf)));
console.log("");
console.log("2. MAX_TEXTURE_SIZE в модели " + LIMIT);
for (const [w, h] of [[4096, 1024], [4097, 1024]]) {
const r = createGpu(LIMIT).upload("test", { w, h, format: "RGBA8" });
console.log(" " + w + "×" + h + ": " + (r.ok ? "загружен" : "отказ — " + r.why));
}
const rowLimit = createGpu(LIMIT).upload("boss-row", { ...bossRow, format: "RGBA8" });
const rowBig = createGpu(8192).upload("boss-row", { ...bossRow, format: "RGBA8" });
console.log(" босс в один ряд, " + BOSS_FRAMES.length + " кадров 256×256 с зазором 2: " + bossRow.w + "×" + bossRow.h +
"; лимит 4096 — " + (rowLimit.ok ? "загружен" : "отказ") + ", лимит 8192 — " + (rowBig.ok ? "загружен" : "отказ"));
console.log(" босс полками до ширины " + LIMIT + ": " + ATLASES.boss.w + "×" + ATLASES.boss.h + " — " +
(createGpu(LIMIT).upload("boss", ATLASES.boss).ok ? "загружен" : "отказ") + ", " + MiB(gpuOf("boss")));
console.log("");
console.log("3. Мипмапы");
for (const [w, h] of [[2048, 2048], [2048, 1024], [ATLASES["ice-props"].w, ATLASES["ice-props"].h]]) {
const base = textureBytes("RGBA8", w, h), full = textureBytes("RGBA8", w, h, true);
console.log(" " + w + "×" + h + ": уровней " + mipChain(w, h).length + ", без мипмапов " + num(base) + ", с мипмапами " +
num(full) + " (+" + num(full - base) + ", +" + ((full - base) / base * 100).toFixed(2).replace(".", ",") + "%)");
}
const withMips = (level) => MiB(sum(LEVELS[level], (n) => textureBytes("RGBA8", ATLASES[n].w, ATLASES[n].h, true)));
console.log(" уровень «Лес»: без мипмапов " + MiB(sum(LEVELS.forest, gpuOf)) + ", с мипмапами " + withMips("forest"));
console.log(" уровень «Ледник»: без мипмапов " + MiB(sum(LEVELS.glacier, gpuOf)) + ", с мипмапами " + withMips("glacier"));
console.log("");
console.log("4. Декор ледника: " + ICE_PROPS.length + " спрайтов");
const drawn = ICE_PROPS.reduce((s, p) => s + p.w * p.h, 0);
const separate = ICE_PROPS.length * textureBytes("RGBA8", ICE_CANVAS, ICE_CANVAS);
console.log(" нарисовано пикселей: " + num(drawn) + " (" + MiB(drawn * 4) + " в RGBA8)");
console.log(" а) " + ICE_PROPS.length + " текстур " + ICE_CANVAS + "×" + ICE_CANVAS + " с прозрачными полями: " + MiB(separate) +
", полезных пикселей " + Math.round(drawn / (ICE_PROPS.length * ICE_CANVAS * ICE_CANVAS) * 100) + "%");
console.log(" б) один атлас 4096×4096 «на вырост»: " + MiB(textureBytes("RGBA8", 4096, 4096)) +
", полезных пикселей " + Math.round(drawn / (4096 * 4096) * 100) + "%");
for (const width of [1024, 2048]) {
const p = packShelves(ICE_PROPS, width, 2);
console.log(" в) обрезка полей и полки шириной " + width + ": " + p.w + "×" + p.h + ", " + MiB(textureBytes("RGBA8", p.w, p.h)) +
", полезных пикселей " + Math.round(p.fill * 100) + "%");
}
console.log("");
console.log("5. Форматы для атласа 2048×2048");
for (const [k, f] of Object.entries(FORMATS))
console.log(" " + f.label.padEnd(40) + num(textureBytes(k, 2048, 2048)).padStart(11) + " байт");
console.log(" проверка формулы по таблице MDN: ASTC 4×4 512×512 = " + num(textureBytes("ASTC4", 512, 512)) +
", ASTC 8×8 512×512 = " + num(textureBytes("ASTC8", 512, 512)));
console.log("");
console.log("6. Смена уровней " + ROUTE.map((l) => NAMES[l]).join(" → ") + ", МиБ");
const labels = { keepAll: "А. ничего не выгружаем", jsOnly: "Б. выгружаем только JS",
"byList/удалить, потом грузить": "В. удалить всё старое, потом грузить",
"byList/грузить, потом удалить": "Г. грузить, потом удалить список старого",
"refCounted/сначала взять": "Д. счётчик ссылок: взять новое, отпустить старое",
"refCounted/отметить, отпустить, загрузить": "Е. счётчик ссылок: отметить, отпустить, загрузить недостающее" };
for (const [key, label] of Object.entries(labels)) {
const [fn, order] = key.split("/");
const m = managers[fn](LIMIT, order), vram = [], heap = [], lost = [];
for (const level of ROUTE) {
m.enter(level);
vram.push(MiB(m.gpu.bytes).replace(" МиБ", ""));
heap.push(MiB(m.js.decoded).replace(" МиБ", ""));
if (m.missing(level).length) lost.push(NAMES[level] + ": " + m.missing(level).join(", "));
}
console.log(" " + label);
console.log(" видеокарта " + vram.join(" → ") + "; в JS " + heap.join(" → ") + " МиБ");
console.log(" пик " + MiB(m.gpu.peak) + ", загружено в видеокарту " + MiB(m.gpu.uploaded) + ", скачано " + MiB(m.js.fetched));
if (lost.length) console.log(" НЕТ ТЕКСТУР — " + lost.join("; "));
}
console.log("");
console.log("7. Фильтр «файлы уровня меньше 3 МиБ»");
for (const level of Object.keys(LEVELS)) {
const files = sum(LEVELS[level], (n) => ATLASES[n].file), vram = sum(LEVELS[level], gpuOf);
console.log(" " + NAMES[level].padEnd(7) + " файлы " + MiB(files) + " — " + (files < 3 * 1048576 ? "проходит" : "не проходит") +
"; видеокарта " + MiB(vram) + ", соотношение 1 : " + Math.round(vram / files));
}
Вывод прогона (Node.js 24.22.1, node test.mjs; МиБ — 1 048 576 байт):
1. Размер файла и память видеокарты
ground 2048×2048: PNG 669 461 байт, RGBA8 без мипмапов 16 777 216 байт, соотношение 1 : 25
все 11 атласов: файлы 3,07 МиБ, видеокарта 106,47 МиБ
2. MAX_TEXTURE_SIZE в модели 4096
4096×1024: загружен
4097×1024: отказ — 4097×1024 больше MAX_TEXTURE_SIZE 4096
босс в один ряд, 16 кадров 256×256 с зазором 2: 4126×256; лимит 4096 — отказ, лимит 8192 — загружен
босс полками до ширины 4096: 3868×514 — загружен, 7,58 МиБ
3. Мипмапы
2048×2048: уровней 12, без мипмапов 16 777 216, с мипмапами 22 369 620 (+5 592 404, +33,33%)
2048×1024: уровней 12, без мипмапов 8 388 608, с мипмапами 11 184 812 (+2 796 204, +33,33%)
1023×1253: уровней 11, без мипмапов 5 127 276, с мипмапами 6 831 272 (+1 703 996, +33,23%)
уровень «Лес»: без мипмапов 46,00 МиБ, с мипмапами 61,33 МиБ
уровень «Ледник»: без мипмапов 42,47 МиБ, с мипмапами 56,62 МиБ
4. Декор ледника: 180 спрайтов
нарисовано пикселей: 1 138 454 (4,34 МиБ в RGBA8)
а) 180 текстур 128×128 с прозрачными полями: 11,25 МиБ, полезных пикселей 39%
б) один атлас 4096×4096 «на вырост»: 64,00 МиБ, полезных пикселей 7%
в) обрезка полей и полки шириной 1024: 1023×1253, 4,89 МиБ, полезных пикселей 89%
в) обрезка полей и полки шириной 2048: 2036×664, 5,16 МиБ, полезных пикселей 84%
5. Форматы для атласа 2048×2048
RGBA8, 8+8+8+8 бит 16 777 216 байт
RGB8, 8+8+8 бит (считаем как RGBA8) 16 777 216 байт
RGBA4, 4+4+4+4 бит 8 388 608 байт
ASTC 4×4 (сжатый, нужно расширение) 4 194 304 байт
ASTC 8×8 (сжатый, нужно расширение) 1 048 576 байт
проверка формулы по таблице MDN: ASTC 4×4 512×512 = 262 144, ASTC 8×8 512×512 = 65 536
6. Смена уровней Лес → Пещера → Ледник → Лес, МиБ
А. ничего не выгружаем
видеокарта 46,00 → 70,00 → 106,47 → 106,47; в JS 46,00 → 70,00 → 106,47 → 106,47 МиБ
пик 106,47 МиБ, загружено в видеокарту 106,47 МиБ, скачано 3,07 МиБ
Б. выгружаем только JS
видеокарта 46,00 → 70,00 → 106,47 → 106,47; в JS 46,00 → 46,00 → 42,47 → 46,00 МиБ
пик 106,47 МиБ, загружено в видеокарту 106,47 МиБ, скачано 5,29 МиБ
В. удалить всё старое, потом грузить
видеокарта 46,00 → 46,00 → 42,47 → 46,00; в JS 46,00 → 46,00 → 42,47 → 46,00 МиБ
пик 46,00 МиБ, загружено в видеокарту 180,47 МиБ, скачано 5,29 МиБ
Г. грузить, потом удалить список старого
видеокарта 46,00 → 24,00 → 36,47 → 40,00; в JS 46,00 → 24,00 → 36,47 → 40,00 МиБ
пик 82,47 МиБ, загружено в видеокарту 158,47 МиБ, скачано 4,53 МиБ
НЕТ ТЕКСТУР — Пещера: hero, ui, ground; Ледник: hero, ui; Лес: hero, ui
Д. счётчик ссылок: взять новое, отпустить старое
видеокарта 46,00 → 46,00 → 42,47 → 46,00; в JS 0,00 → 0,00 → 0,00 → 0,00 МиБ
пик 82,47 МиБ, загружено в видеокарту 146,47 МиБ, скачано 4,29 МиБ
Е. счётчик ссылок: отметить, отпустить, загрузить недостающее
видеокарта 46,00 → 46,00 → 42,47 → 46,00; в JS 0,00 → 0,00 → 0,00 → 0,00 МиБ
пик 46,00 МиБ, загружено в видеокарту 146,47 МиБ, скачано 4,29 МиБ
7. Фильтр «файлы уровня меньше 3 МиБ»
Лес файлы 1,33 МиБ — проходит; видеокарта 46,00 МиБ, соотношение 1 : 34
Пещера файлы 1,34 МиБ — проходит; видеокарта 46,00 МиБ, соотношение 1 : 34
Ледник файлы 1,28 МиБ — проходит; видеокарта 42,47 МиБ, соотношение 1 : 33
Что показал прогон: восемь ловушек
Прогон подтвердил восемь ловушек: три — в том, как считать память, две — в размере и укладке атласа, три — в выгрузке при смене уровня. В скобках — сцена вывода.
Ловушка 1: вес PNG принимают за память текстуры (сцена 1)
Вес PNG ничего не говорит о памяти текстуры: в видеокарте лежат пиксели, а не сжатый файл. Атлас ground 2048×2048 весит 669 461 байт, а в RGBA8 без мипмапов занимает 16 777 216 байт — соотношение 1 : 25. Все одиннадцать атласов — 3,07 МиБ файлов и 106,47 МиБ видеопамяти. В формуле текстуры нет содержимого картинки: 2048 × 2048 × 4 — это 16 МиБ и для пёстрых тайлов, и для декора, который в основном прозрачен, хотя PNG у них сжимается по-разному.
Ловушка 2: атлас на пиксель шире лимита (сцена 2)
Атлас, у которого хотя бы одна сторона больше MAX_TEXTURE_SIZE, не загрузится, и одного лишнего пикселя достаточно: в модели с лимитом 4096 атлас 4096×1024 загружается, а 4097×1024 получает отказ. Реалистичный путь к такому атласу — лист «в один ряд»: 16 кадров босса по 256 пикселей с зазором 2 дают 16 × 256 + 15 × 2 = 4126. С лимитом 8192 (пусть таков он на машине разработчика) модель его загружает, с лимитом 4096 — нет. Те же кадры полками не шире 4096 дали атлас 3868×514 на 7,58 МиБ, и он проходит при обоих лимитах.
Какой ошибкой ответит реальный контекст и что будет нарисовано вместо атласа, мы не запускали и не утверждаем: в модели это отказ до загрузки.
Ловушка 3: мипмапы «на всякий случай» (сцена 3)
Полная цепочка мипмапов добавляет к текстуре около трети памяти. Для 2048×2048 в RGBA8 цепочка из 12 уровней заняла 22 369 620 байт вместо 16 777 216 — плюс 5 592 404 байта, 33,33%. У 2048×1024 надбавка та же, 33,33%, у атласа 1023×1253 — 33,23%: уровни делятся пополам с округлением вниз. Уровень Лес вырос с 46,00 до 61,33 МиБ.
MDN называет мипмапы дешёвыми по памяти (около 33% для квадратных текстур), но для 2D-ресурсов, которые никогда не уменьшаются, советует эту надбавку не платить. Там же оговорка: некоторые драйверы могут выделить всю цепочку, даже если загружен один уровень, — для Ледника это 56,62 МиБ вместо 42,47. Поэтому в WebGL2 MDN советует создавать текстуру через texStorage2D с нужным числом уровней; для 2D-атласа это один. Фильтр текстуры — отдельный вопрос: для пиксель-арта нужен «ближайший сосед», это разобрано в статье о пиксель-арте без размытия.
Ловушка 4: атлас «на вырост» и прозрачные поля (сцена 4)
Атлас экономит видеопамять, только когда он обрезан по содержимому; атлас фиксированного размера «с запасом» дороже отдельных текстур. В 180 спрайтах декора Ледника нарисовано 1 138 454 пикселя — 4,34 МиБ в RGBA8:
| Способ (наш пример) | Видеопамять | Полезных пикселей |
|---|---|---|
| 180 текстур 128×128 с прозрачными полями | 11,25 МиБ | 39% |
| Атлас 4096×4096 «на вырост» | 64,00 МиБ | 7% |
| Обрезка полей, полки шириной 1024 → 1023×1253 | 4,89 МиБ | 89% |
| Обрезка полей, полки шириной 2048 → 2036×664 | 5,16 МиБ | 84% |
Гипотеза «атлас всегда экономит память» не подтвердилась: атлас 4096×4096 (64,00 МиБ) дороже 180 отдельных текстур (11,25 МиБ), потому что пустой пиксель RGBA8 стоит те же 4 байта. Экономию дают обрезка прозрачных полей и размер атласа по содержимому. Полки шириной 1024 оказались плотнее, чем 2048, на этом наборе; на другом может быть наоборот, ширину выбирают прогоном.
Округление сторон до степени двойки мы в модель не добавляли: по MDN ограничения для сторон не степени двойки (без мипмапов, только CLAMP_TO_EDGE) описаны для WebGL1. Выравнивание, которое может добавить драйвер, и служебные расходы на каждую текстуру мы не знаем и не считаем. Довод за атлас со стороны отрисовки — смена текстуры разрывает пакет — разобран в статье об отрисовке 2D-игры.
Ловушка 5: смена уровня без выгрузки (сцена 6, А)
Без выгрузки видеопамять растёт с каждым новым биомом и не падает при возврате: Лес — 46,00 МиБ, Пещера — 70,00, Ледник — 106,47, снова Лес — 106,47. Ошибок нет, пока у устройства хватает памяти. Пещера добавила только свои cave-props и cave-back: hero, ui и ground уже загружены — и на этих общих атласах ломаются следующие варианты.
Ловушка 6: выгрузили картинку в JS, а текстура осталась (сцена 6, Б)
Очистка кэша картинок и ImageBitmap.close() не трогают текстуру в видеокарте. Вариант Б при смене уровня удаляет из кэша и закрывает картинки прошлого уровня: в JS после Ледника 42,47 МиБ вместо 106,47. Счётчик видеопамяти — тот же, что у варианта А: 70,00, 106,47 и 106,47 МиБ. После texImage2D у текстуры своя копия пикселей: close(), по MDN, освобождает ресурсы самого ImageBitmap, а WebGLTexture удаляет deleteTexture. Вдобавок при возврате в Лес файлы скачаны заново: 5,29 МиБ за маршрут против 3,07.
Ловушка 7: выгрузили общий атлас, который нужен следующему уровню (сцена 6, В и Г)
Если выгружать список прошлого уровня целиком, общие атласы либо загружаются заново, либо пропадают — зависит от порядка.
- «Удалить всё старое, потом грузить» (В). Видеопамять правильная — 46,00, 46,00, 42,47, 46,00 МиБ, — но
hero,uiиgroundудаляются и тут же загружаются снова: за маршрут в видеокарту ушло 180,47 МиБ против 146,47 у рабочего варианта. - «Грузить, потом удалить список старого» (Г). Новый уровень пропускает уже живые общие атласы, а удаление списка прошлого уносит их. В Пещере нет
hero,uiиground, в Леднике и снова в Лесу —heroиui. Счётчик в Пещере выглядит лучше правильного — 24,00 МиБ, — потому что половины текстур просто нет.
Второй исход опаснее: падения нет, лишней памяти нет, есть уровень без героя. Его ловит только проверка «все текстуры уровня живы» — в модели функция missing.
Ловушка 8: фильтр по весу файлов пропускает тяжёлую сцену (сцена 7)
Проверка «файлы уровня меньше N мегабайт» ничего не говорит о видеопамяти. Фильтр «меньше 3 МиБ» прошли все три уровня — 1,33, 1,34 и 1,28 МиБ файлов, — а в видеокарте они занимают 46,00, 46,00 и 42,47 МиБ, соотношение 1 : 33–34. Проверка бюджета в сборке должна считать ширину × высоту × формат из манифеста атласов.
MAX_TEXTURE_SIZE: спрашивать у контекста, а не угадывать
Максимальную сторону текстуры читают у контекста один раз при старте — gl.getParameter(gl.MAX_TEXTURE_SIZE) возвращает целое число, — а атласы готовят под лимит, который есть у всех целевых устройств. В рекомендациях MDN перечислены минимумы, которые на практике поддерживают практически все системы, и для MAX_TEXTURE_SIZE это 4096; там же предупреждение, что настольная машина может поддерживать текстуры 16k, а слабые системы — нет.
- Упаковщик получает лимит параметром. В модели это
LIMIT = 4096; значение с вашего компьютера — не лимит (сцена 2: 4126×256 проходит при 8192 и не проходит при 4096). - Проверка в сборке, а не в игре. Атлас больше 4096 по любой стороне останавливает сборку, а не ждёт отказа на телефоне игрока.
- Запрос — один раз. MDN относит
get*Parameter()к вызовам, которые могут синхронно остановить поток ради обмена с процессом видеокарты, и советует избегать их в рабочем коде; значение читают при создании контекста и хранят.
Лимит ограничивает сторону, а не память: атлас 4096×4096 помещается в лимит и стоит 64 МиБ в RGBA8.
Формат хранения: что меняет байты на пиксель
Байты на пиксель задаёт формат текстуры в видеокарте, а не формат файла. Сцена 5 считает атлас 2048×2048 в пяти форматах: RGBA8 и RGB8 — по 16 777 216 байт, RGBA4 — 8 388 608, ASTC 4×4 — 4 194 304, ASTC 8×8 — 1 048 576.
- RGBA8. Таблица MDN для
texImage2Dдаёт для парыRGBA+UNSIGNED_BYTE4 байта на пиксель на входе и оговаривает, что для «безразмерных» внутренних форматов нельзя указать, сколько байт пиксель займёт внутри; в WebGL2 есть форматы с точной раскладкой,RGBA8— 8, 8, 8, 8 бит. Модель считает 4 байта и называет это оценкой. - RGB8 не экономит четверть. MDN предупреждает, что ряд форматов, особенно трёхканальных, эмулируется, и советует предпочитать RGBA8. Модель считает RGB8 как RGBA8 — по худшему случаю; реальную экономию на устройстве мы не измеряли.
- RGBA4. Вдвое дешевле RGBA8, но на канал 4 бита — 16 уровней; на плавных градиентах это может дать видимые ступени, на пиксель-арте с короткой палитрой — нет. Решают глазами на своих атласах.
- ASTC и другие сжатые форматы. Хранятся в видеопамяти блоками и распаковываются при чтении в шейдере. Размер ASTC — число блоков по ширине × по высоте × 16 байт по формуле из таблицы MDN; модель воспроизводит табличные 262 144 байта для 512×512 при блоке 4×4 и 65 536 при 8×8.
У сжатых форматов есть ограничения, и все они из MDN. WebGL не требует ни одного сжатого формата: формат включается расширением, которого может не быть; ASTC обычно доступен на графике Mali ARM, Intel и NVIDIA Tegra, для настольных систем в рекомендациях назван S3TC, единого формата нет. WebGL не сжимает текстуры сам, файл должен быть уже в нужном формате и по сети обычно тяжелее PNG, а generateMipmap для сжатых форматов не работает. Поэтому это отдельный конвейер сборки с запасным RGBA8, и браться за него стоит после обрезки полей и отказа от лишних мипмапов.
Выгрузка: две половины и счётчик ссылок
Выгрузка уровня — это освобождение стороны JS и удаление текстур в видеокарте, причём вторую половину делают не по списку уровня, а по счётчику ссылок. Варианты Д и Е в сцене 6 дают одинаковые 46,00 → 46,00 → 42,47 → 46,00 МиБ, без пропавших текстур и с 146,47 МиБ загрузок за маршрут — меньше, чем у любого варианта, который освобождает память.
Сторона JS. После загрузки пикселей в текстуру картинка в JS не нужна: в Д и Е ImageBitmap закрывается сразу, и в JS после каждой смены уровня 0,00 МиБ.
Сторона видеокарты. Текстуру удаляет gl.deleteTexture(texture); для уже удалённой, по MDN, вызов ничего не делает. Рекомендации MDN советуют удалять объекты сразу, не дожидаясь сборщика мусора, и уточняют: удаление освобождает ссылку, а сам объект освобождается, когда реализация его больше не использует. Поэтому счётчик модели — это то, что мы попросили освободить, а не измеренная память.
Счётчик ссылок. Каждый уровень держит ссылку на каждый свой атлас, текстура удаляется на нуле. hero и ui не опускаются ниже единицы, ground переживает переход Лес → Пещера и удаляется на переходе в Ледник.
Порядок решает пик. Это то, чего мы не ожидали: счётчик ссылок сам по себе пик не снижает.
Д: взять новое и загрузить → отпустить старое пик 82,47 МиБ
Е: отметить новое без загрузки → отпустить старое → загрузить пик 46,00 МиБ
В варианте Д на смене уровня старый уровень и новые атласы на мгновение живут вместе: пик за маршрут — 82,47 МиБ, хотя ни один уровень не тяжелее 46,00. В варианте Е общие атласы сначала получают лишнюю ссылку, потом всё, что дошло до нуля, удаляется, и только потом грузится недостающее: пик равен самому тяжёлому уровню. Цена — экран загрузки: в Д старый уровень можно показывать до конца загрузки, в Е — нет.
Ссылки, которые переживают объект, на стороне JS разобраны в статье об издателе и подписчике; для текстур правило то же — пока атлас нужен живому объекту, удалять его нельзя.
Практический сценарий: бюджет видеопамяти «Лиса-почтальона»
Память текстур в браузерной игре держат в рамках так: бюджет считают по размеру атласа и формату хранения, а не по весу PNG, каждый атлас укладывают в MAX_TEXTURE_SIZE с обрезкой полей, а текстуры выгружают через deleteTexture со счётчиком ссылок на общие атласы. Для «Лиса-почтальона» это семь шагов.
- Манифест текстур. Для каждого атласа — ширина, высота, формат и число уровней, как в
ATLASES; память — функциейtextureBytes, а не по весу файлов. - Бюджет и проверка в сборке. API для объёма видеопамяти нет, поэтому бюджет — решение команды под самые слабые целевые устройства. Сборка проверяет сумму по каждому уровню и пик смены уровня; у «Лиса-почтальона» самый тяжёлый уровень — 46,00 МиБ.
- Стороны не больше 4096. Лист босса — полками 3868×514 вместо ряда 4126×256. MAX_TEXTURE_SIZE читается при старте; если он меньше 4096, игра сообщает, что устройство не поддерживается.
- Без мипмапов для 2D-атласов.
texStorage2Dс одним уровнем — Ледник 42,47 МиБ, а не 56,62. - Обрезка полей и размер по содержимому. Декор Ледника — 4,89 МиБ вместо 11,25 отдельными текстурами и 64,00 атласом «на вырост».
- Выгрузка по счётчику ссылок.
ImageBitmap.close()после загрузки,deleteTextureна нуле, порядок «отметить, отпустить, загрузить», если два уровня сразу не помещаются в бюджет. - Проверка маршрутом. Лес → Пещера → Ледник → Лес: при возврате в Лес снова 46,00 МиБ, список пропавших текстур пуст, загружено за маршрут 146,47 МиБ.
Проверяемый итог: 46,00 МиБ вместо 106,47 после трёх смен уровня, пик 46,00 МиБ, ни одного атласа шире 4096 и ни одной пропавшей текстуры. Модель не знает, сколько реально выделил драйвер и что будет при потере контекста: после webglcontextlost атласы текущего уровня придётся скачать и загрузить заново по тому же манифесту, ведь картинки в JS уже закрыты. Если кадры при этом пропускаются, причину ищут по шагам из статьи о просадках FPS: память текстур отвечает на вопрос «поместится ли», а не «успеет ли».
Когда вам это не подойдёт
Учёт видеопамяти и счётчик ссылок нужны игре на WebGL с несколькими уровнями и крупными атласами; вот где они лишние или их мало:
- Игра на Canvas2D. Текстурами управляет браузер,
deleteTextureу вас нет: остаётся отпустить ссылки на картинки и закрытьImageBitmap. Формула ширина × высота × 4 годится для оценки, но вести счётчик не по чему. - Маленькая игра на один экран. Если все атласы — две текстуры 1024×1024, то есть 8 МиБ в RGBA8, учёт сложнее самой проблемы.
- Открытый мир с подгрузкой по ходу движения. Выгрузка там — постоянный поток с приоритетами по расстоянию до камеры, и счётчик ссылок — лишь одна из деталей.
- Готовый движок со своим кэшем текстур. Удалять текстуры в обход него опасно; формулы годятся для бюджета, а выгрузку делайте его средствами.
- Нужна точная цифра, а не оценка. WebGL не сообщает объём видеопамяти, а драйвер вправе хранить текстуры иначе; модель нужна для бюджета и сравнения вариантов, а не для отчёта о потреблении.
Мы разрабатываем J2DRU — браузерный 2D игровой движок, где логика собирается из событий, условий и действий, а проект можно углублять на TypeScript. Движок в разработке и публично пока не открыт, заявку можно оставить на странице раннего доступа (подача заявки не гарантирует приглашение).
Источники (проверено: ноябрь 2026, 11.11.2026): MDN — WebGL best practices (нет API для объёма видеопамяти, оценивать расход самим и обрабатывать webglcontextlost; удалять объекты сразу, объект освобождается, когда реализация его не использует; сжатые форматы, S3TC для настольных систем, единого формата нет; texStorage и драйверы, выделяющие всю цепочку мипмапов, +33% для квадратных текстур; мипмапы не нужны 2D-ресурсам, которые не уменьшаются; MAX_TEXTURE_SIZE 4096 практически у всех систем; get*Parameter() может синхронно остановить поток; эмуляция трёхканальных форматов; generateMipmap не работает для сжатых форматов); MDN — getParameter() (MAX_TEXTURE_SIZE, GLint); MDN — texImage2D() (RGBA + UNSIGNED_BYTE — 4 байта на входе, безразмерные форматы, RGBA8 и RGBA4 в WebGL2); MDN — deleteTexture(); MDN — ImageBitmap.close(); MDN — generateMipmap() (уровни вдвое меньше, до 1×1); MDN — texStorage2D() (параметр levels); MDN — Using textures in WebGL (стороны не степени двойки в WebGL1); MDN — Compressed texture formats (форматы через расширения, WebGL их не сжимает, по сети обычно хуже PNG и JPG); MDN — WEBGL_compressed_texture_astc (формула по блокам, 262 144 и 65 536 байт для 512×512; Mali ARM, Intel, NVIDIA Tegra). Игра «Лис-почтальон», атласы, рисунки, вес PNG, упаковщик, лимит 4096 в модели, варианты выгрузки и все числа прогона — наш пример и наш расчёт в Node.js 24.22.1.
Читайте также:
- Загрузка ресурсов браузерной игры: экран загрузки, честный прогресс и подгрузка уровней по требованию
- Отрисовка 2D-игры в браузере: пакетная отправка спрайтов и переход с WebGPU на WebGL2
- Как найти просадку FPS в браузерной 2D-игре: бюджет кадра, Chrome DevTools Performance, долгие задачи и сборка мусора
- Пиксель-арт в браузере без размытия: image-rendering, целочисленное масштабирование и devicePixelRatio
- Издатель и подписчик в игре: порядок доставки событий, отписка и утечки памяти