Память текстур в браузерной игре: размер атласа, форматы и выгрузка

Коротко

Память текстуры в видеокарте считается по пикселям, а не по файлу: ширина × высота × байт на пиксель формата хранения, и ещё около трети сверху, если включена цепочка мипмапов. В нашем прогоне PNG тайлов 2048×2048 весит 669 461 байт, а в RGBA8 занимает 16 777 216 байт; уровень с файлами на 1,33 МиБ требует 46 МиБ видеопамяти. Атлас должен помещаться в MAX_TEXTURE_SIZE устройства и не тратить место на прозрачные поля, а выгрузка уровня — это deleteTexture для текстур, на которые больше не ссылается ни один уровень, а не только очистка кэша картинок в JS.

Содержание

  1. Три размера одной картинки
  2. Модель: «Лис-почтальон», три биома и одиннадцать атласов
  3. Код на JavaScript и проверка в Node.js
  4. Что показал прогон: восемь ловушек
  5. MAX_TEXTURE_SIZE: спрашивать у контекста, а не угадывать
  6. Формат хранения: что меняет байты на пиксель
  7. Выгрузка: две половины и счётчик ссылок
  8. Практический сценарий: бюджет видеопамяти «Лиса-почтальона»
  9. Когда вам это не подойдёт

Три размера одной картинки

У каждой картинки в игре три разных размера — файл, декодированные пиксели и текстура в видеокарте, — и подменять один другим нельзя. Файл 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×12534,89 МиБ89%
Обрезка полей, полки шириной 2048 → 2036×6645,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, а слабые системы — нет.

  1. Упаковщик получает лимит параметром. В модели это LIMIT = 4096; значение с вашего компьютера — не лимит (сцена 2: 4126×256 проходит при 8192 и не проходит при 4096).
  2. Проверка в сборке, а не в игре. Атлас больше 4096 по любой стороне останавливает сборку, а не ждёт отказа на телефоне игрока.
  3. Запрос — один раз. 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_BYTE 4 байта на пиксель на входе и оговаривает, что для «безразмерных» внутренних форматов нельзя указать, сколько байт пиксель займёт внутри; в 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 со счётчиком ссылок на общие атласы. Для «Лиса-почтальона» это семь шагов.

  1. Манифест текстур. Для каждого атласа — ширина, высота, формат и число уровней, как в ATLASES; память — функцией textureBytes, а не по весу файлов.
  2. Бюджет и проверка в сборке. API для объёма видеопамяти нет, поэтому бюджет — решение команды под самые слабые целевые устройства. Сборка проверяет сумму по каждому уровню и пик смены уровня; у «Лиса-почтальона» самый тяжёлый уровень — 46,00 МиБ.
  3. Стороны не больше 4096. Лист босса — полками 3868×514 вместо ряда 4126×256. MAX_TEXTURE_SIZE читается при старте; если он меньше 4096, игра сообщает, что устройство не поддерживается.
  4. Без мипмапов для 2D-атласов. texStorage2D с одним уровнем — Ледник 42,47 МиБ, а не 56,62.
  5. Обрезка полей и размер по содержимому. Декор Ледника — 4,89 МиБ вместо 11,25 отдельными текстурами и 64,00 атласом «на вырост».
  6. Выгрузка по счётчику ссылок. ImageBitmap.close() после загрузки, deleteTexture на нуле, порядок «отметить, отпустить, загрузить», если два уровня сразу не помещаются в бюджет.
  7. Проверка маршрутом. Лес → Пещера → Ледник → Лес: при возврате в Лес снова 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.

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

Частые вопросы

Сколько видеопамяти занимает текстура 2048×2048?

В формате RGBA8 без мипмапов — 2048 × 2048 × 4 = 16 777 216 байт, то есть 16 МиБ, сколько бы ни весил PNG. В нашем прогоне PNG тайлов того же размера весил 669 461 байт: файл сжат, а видеокарте отдаются пиксели. С полной цепочкой мипмапов та же текстура занимает 22 369 620 байт, на 33,33% больше.

Почему атлас загружается на компьютере, но не на телефоне?

Одна из причин — сторона атласа больше MAX_TEXTURE_SIZE слабого устройства. В нашем прогоне лист босса в один ряд получился 4126×256: при лимите 8192 он загружается, при лимите 4096 — нет. Лимит спрашивают у контекста через gl.getParameter(gl.MAX_TEXTURE_SIZE) один раз при старте, а атласы упаковывают так, чтобы стороны не превышали 4096 — по MDN, такой лимит поддерживают практически все системы.

Нужны ли мипмапы в 2D-игре?

Только для текстур, которые показываются заметно уменьшенными, например на карте мира с отдалением. Мипмапы добавляют память: в нашем прогоне +33,33% для 2048×2048 и уровень «Лес» вырос с 46,00 до 61,33 МиБ. MDN советует не платить эту надбавку за 2D-ресурсы, которые не уменьшаются, и в WebGL2 создавать такие текстуры через texStorage2D с одним уровнем.

Как выгрузить текстуру из памяти видеокарты?

Вызвать gl.deleteTexture для объекта WebGLTexture, когда текстура больше не нужна ни одному уровню. Очистка кэша картинок и ImageBitmap.close() освобождают сторону JS, но не текстуру, созданную загрузкой: в нашем прогоне при такой «выгрузке» счётчик видеопамяти после трёх смен уровня показал те же 106,47 МиБ, что и без выгрузки. Общие атласы удаляют по счётчику ссылок, иначе следующий уровень останется без героя и интерфейса.