Слои отрисовки и порядок глубины: Z-order и сортировка по Y в 2D

Коротко

В 2D-игре видно то, что нарисовано позже, поэтому глубину задаёт порядок рисования. Ключ сортировки складывается из трёх частей: слой (земля, мир, передний план, интерфейс), внутри мирового слоя — Y точки опоры объекта, при равенстве — постоянный id. Высота прыжка хранится отдельно и на порядок не влияет, а сортировка почти готового списка каждый кадр стоит около n сравнений.

Содержание

  1. Почему порядок рисования и есть глубина
  2. Слои: грубый порядок от земли до интерфейса
  3. Сортировка по Y: какая точка объекта считается
  4. Ничьи и мигание: третий признак ключа
  5. Компаратор, который не сортирует
  6. Прыжок и высота над землёй
  7. Сколько стоит сортировать каждый кадр
  8. Код на JavaScript и проверка в Node.js
  9. Обвязка для браузера
  10. Практический сценарий: герой проходит мимо дерева
  11. Когда вам это не подойдёт

Почему порядок рисования и есть глубина

В обычном 2D-рисовании на canvas нет буфера глубины: каждая новая фигура ложится поверх уже нарисованного, и выше оказывается тот, кого нарисовали последним. Так работает режим наложения source-over, который у CanvasRenderingContext2D стоит по умолчанию. Значит, «кто перед кем» в 2D-игре решается одним вопросом — в каком порядке обходить список объектов при рисовании.

Этот подход называют алгоритмом художника: сначала дальнее, потом ближнее, как художник пишет горы, затем луг, затем деревья. Его описали Мартин Ньюэлл, Ричард Ньюэлл и Том Санча в 1972 году для трёхмерной графики, но в 2D он работает почти без оговорок: плоские спрайты не пересекают друг друга, а только перекрывают.

Запомнить достаточно одного правила: объект, который должен закрывать другой, рисуется после него. Числовое значение «глубины» само по себе не важно — важно, что список отсортирован так, чтобы это правило выполнялось.

Слои: грубый порядок от земли до интерфейса

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

СлойНомерЧто в нёмСортировка внутри
Земля0тени, лужи, следы, тайлы поланет, порядок добавления
Мир1герой, враги, деревья, бочки, сундукипо Y точки опоры
Передний план2кроны над дорогой, арки, туманнет
Интерфейс3счёт, здоровье, подсказкинет

Тень героя — частая ошибка новичка: если положить её в мировой слой, тень соседнего дерева может лечь поверх ног персонажа. Всё плоское, что лежит на земле, — в слой 0. Подробно о слоях уровня, фоне и параллаксе — в статьях про тайловые сетки и про камеру; здесь важно другое: что делать внутри мирового слоя, где объекты перекрывают друг друга по мере движения.

Сортировка по Y: какая точка объекта считается

Внутри мирового слоя объекты сортируют по Y точки опоры — нижней точки, которой объект касается земли: ноги героя, основание ствола, дно бочки. Чем ниже на экране опора, тем ближе объект к зрителю и тем позже его рисуют. Это работает и для вида сверху под углом, и для RPG с видом «три четверти».

Типичная ошибка — сортировать по координате, которая уже есть у спрайта: по верхнему краю (так удобно рисовать через drawImage) или по центру. Наш пример: дерево 64 × 96 px с основанием в y = 210, герой 32 × 48 px стоит чуть выше, ногами в y = 200, то есть за деревом.

Ключ сортировкиДеревоГеройПорядокКто виден в точке (300, 180)
Верх спрайта114152дерево → геройгерой (ошибка)
Центр спрайта162176дерево → геройгерой (ошибка)
Точка опоры210200герой → дереводерево (верно)

Высокий объект всегда «выигрывает» по верху и центру, потому что его картинка начинается выше. Поэтому координату объекта удобно с самого начала хранить как точку опоры, а прямоугольник спрайта вычислять от неё: top = y − h. Тогда сортировать можно прямо по y, без пересчётов.

Ничьи и мигание: третий признак ключа

Если у двух объектов одинаковый Y, порядок между ними должен решать постоянный признак, например id, иначе они начнут меняться местами. Сортировка в JavaScript стабильна со стандарта ECMAScript 2019: равные элементы сохраняют свой порядок. Но это порядок в массиве, а он меняется, когда объект удаляют и добавляют снова — например, при возврате из пула.

В нашем прогоне две бочки стоят на одной линии y = 250 и перекрываются на 20 px. Раз в 15 кадров первый объект списка уходит в конец — как при повторном спавне. С ключом «только Y» за 120 кадров верхняя бочка сменилась 8 раз — игрок видит мигание. С ключом «Y, затем id» — ни разу.

Ключ целиком:

сначала layer по возрастанию
затем  y опоры по возрастанию (только в мировом слое)
затем  id по возрастанию (id выдаётся при создании и не меняется)

Компаратор, который не сортирует

Функция сравнения для sort обязана возвращать отрицательное число, ноль или положительное, и одинаково для пары (a, b) и (b, a) с обратным знаком. Сокращение вида (a, b) => a.y > b.y ? 1 : 0 выглядит рабочим, но нарушает это правило: для a < b оно говорит «равны». По документации MDN, V8 (Chrome, Node.js) и JavaScriptCore (Safari) такой массив не сортируют вовсе, а SpiderMonkey (Firefox) сортирует — то есть игра выглядит по-разному в разных браузерах.

Наш прогон в Node.js это подтверждает: [3, 1, 4, 1, 5, 9] с компаратором «1 или 0» остался [3, 1, 4, 1, 5, 9], а с a − b стал [1, 1, 3, 4, 5, 9]. Для чисел безопасна разность a.y − b.y, для составного ключа — цепочка «если признаки различаются, вернуть разность, иначе перейти к следующему», как в compareDepth ниже. Ещё одно требование MDN — компаратор не должен ничего менять: не двигайте в нём объекты и не пересчитывайте позиции.

Прыжок и высота над землёй

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

Пример: бочка 40 × 40 px стоит опорой в y = 210, герой ногами в y = 220 — перед ней — и прыгает на высоту z = 40. Нижний край его картинки теперь 180, выше бочки. Если сортировать по нижнему краю картинки, в точке (300, 175) окажется бочка — герой «нырнул» за неё посреди прыжка. При сортировке по опоре там виден герой. Тень героя при этом остаётся в слое земли под точкой опоры и показывает игроку, где он приземлится.

нижний край картинки = y − z
верх картинки        = y − z − h
ключ сортировки      = y   (z не участвует)

Сколько стоит сортировать каждый кадр

Сортировать весь мировой слой каждый кадр обычно дёшево, потому что между кадрами порядок почти не меняется. С версии V8 7.0 и Chrome 70 Array.prototype.sort работает по алгоритму Timsort (о переходе команда V8 написала 28 сентября 2018 года): он ищет уже упорядоченные участки, и полностью отсортированный массив проходит за линейное время.

Наш подсчёт вызовов компаратора на 1000 объектах в Node.js 24:

Входной списокСравнений
Случайный порядок8655
Уже отсортирован (прошлый кадр, никто не двигался)999
50 объектов сдвинулись на ±2 px2317

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

Код на JavaScript и проверка в Node.js

Модуль ниже не рисует сам, а решает две задачи: вычисляет прямоугольник спрайта от точки опоры и сравнивает объекты по ключу «слой → Y → id». Для проверки в Node.js в нём есть программный «холст» topAt: он перебирает список в порядке рисования и возвращает имя последнего объекта, накрывшего точку, — так же, как это сделал бы canvas.

// depth.mjs — порядок отрисовки 2D: слои, сортировка по Y, стабильный ключ
export const LAYER = { GROUND: 0, WORLD: 1, OVER: 2, UI: 3 };   // снизу вверх

// Объект: x — центр, y — точка опоры на земле (ноги, основание ствола),
// z — высота над землёй (прыжок), w и h — размер спрайта в px
export function spriteRect(o) {
  const bottom = o.y - (o.z ?? 0);                     // рисуем выше опоры на высоту прыжка
  return { left: o.x - o.w / 2, top: bottom - o.h, right: o.x + o.w / 2, bottom };
}

// Составной ключ: слой → Y опоры (только в мире) → id. Возвращает −1, 0 или 1
export function compareDepth(a, b) {
  if (a.layer !== b.layer) return a.layer - b.layer;
  if (a.layer === LAYER.WORLD && a.y !== b.y) return a.y - b.y;
  return a.id - b.id;                                  // ничья решается одинаково в каждом кадре
}

// Программный «холст»: рисуем прямоугольники по порядку, позже нарисованный — сверху
export function topAt(list, px, py) {
  let top = null;
  for (const o of list) {
    const r = spriteRect(o);
    if (px >= r.left && px < r.right && py >= r.top && py < r.bottom) top = o.name;
  }
  return top;
}

// ---- проверка в Node.js ----
const tree = { id: 1, name: 'дерево', layer: LAYER.WORLD, x: 300, y: 210, w: 64, h: 96 };
const hero = { id: 2, name: 'герой', layer: LAYER.WORLD, x: 300, y: 200, w: 32, h: 48 };
const byKey = key => (a, b) => key(a) - key(b);
const top = o => spriteRect(o).top, center = o => (spriteRect(o).top + spriteRect(o).bottom) / 2;

// 1. Алгоритм художника: что нарисовано позже, то и сверху
console.log('1) рисуем дерево, потом героя → в точке (300, 180):', topAt([tree, hero], 300, 180),
  '| наоборот →', topAt([hero, tree], 300, 180));

// 2. Герой стоит за деревом (опора 200 < 210): какой ключ сортировки даёт верную картинку
for (const [name, cmp] of [['верх спрайта', byKey(top)], ['центр спрайта', byKey(center)], ['точка опоры', compareDepth]]) {
  const list = [tree, hero].sort(cmp);
  console.log(`2) ключ «${name}»: порядок ${list.map(o => o.name).join(' → ')}, в (300, 180) видно: ${topAt(list, 300, 180)}`);
}

// 3. Ничья по Y: две бочки на одной линии, массив меняет порядок при возврате объекта из пула
const barrelA = { id: 10, name: 'бочка A', layer: LAYER.WORLD, x: 100, y: 250, w: 40, h: 40 };
const barrelB = { id: 11, name: 'бочка B', layer: LAYER.WORLD, x: 120, y: 250, w: 40, h: 40 };
for (const [name, cmp] of [['только Y', byKey(o => o.y)], ['Y, затем id', compareDepth]]) {
  let objects = [barrelA, barrelB], last = null, flips = 0;
  for (let frame = 0; frame < 120; frame++) {
    if (frame % 15 === 14) objects = [...objects.slice(1), objects[0]];  // первый ушёл в конец списка
    const seen = topAt([...objects].sort(cmp), 110, 240);
    if (last && seen !== last) flips++;
    last = seen;
  }
  console.log(`3) ключ «${name}»: за 120 кадров смен верхней бочки — ${flips}`);
}

// 4. Компаратор, который возвращает только 1 и 0, в V8 не сортирует
const ys = [3, 1, 4, 1, 5, 9];
console.log('4) (a > b ? 1 : 0):', JSON.stringify([...ys].sort((a, b) => (a > b ? 1 : 0))),
  '| a − b:', JSON.stringify([...ys].sort((a, b) => a - b)));

// 5. Прыжок: сортируем по опоре на земле, а не по нижнему краю картинки
const barrel = { id: 3, name: 'бочка', layer: LAYER.WORLD, x: 300, y: 210, w: 40, h: 40 };
const jumper = { id: 4, name: 'герой', layer: LAYER.WORLD, x: 300, y: 220, z: 40, w: 32, h: 48 };
const byDrawnBottom = byKey(o => spriteRect(o).bottom);
console.log('5) герой в прыжке перед бочкой, в (300, 175) по опоре:', topAt([barrel, jumper].sort(compareDepth), 300, 175),
  '| по нижнему краю картинки:', topAt([barrel, jumper].sort(byDrawnBottom), 300, 175));

// 6. Цена сортировки каждый кадр: 1000 объектов, считаем вызовы компаратора
function seeded(seed) { let s = seed >>> 0; return () => (s = (s * 1664525 + 1013904223) >>> 0) / 2 ** 32; }
const rand = seeded(53);
const world = Array.from({ length: 1000 }, (_, i) => ({ id: i, layer: LAYER.WORLD, y: Math.floor(rand() * 2000) }));
const count = arr => { let n = 0; arr.sort((a, b) => (n++, compareDepth(a, b))); return n; };
const randomCalls = count([...world]);
const sorted = [...world].sort(compareDepth);
const sortedCalls = count([...sorted]);
const moved = sorted.map(o => ({ ...o }));
for (let i = 0; i < 50; i++) moved[Math.floor(rand() * 1000)].y += Math.floor(rand() * 5) - 2;  // 50 сдвинулись на ±2 px
const nearlyCalls = count(moved);
console.log(`6) 1000 объектов: случайный порядок — ${randomCalls} сравнений, уже отсортированы — ${sortedCalls}, после кадра с 50 сдвигами — ${nearlyCalls}`);

// 7. Сценарий: герой идёт вниз мимо дерева, опора с 190 до 228 px, шаг 2 px; смотрим точку на груди героя
let switches = 0, prev = null, switchY = null;
for (let y = 190; y <= 228; y += 2) {
  const h = { ...hero, y };
  const seen = topAt([tree, h].sort(compareDepth), 300, y - 20);
  if (prev && seen !== prev) { switches++; switchY = y; }
  prev = seen;
}
console.log(`7) проход мимо дерева: смен «кто сверху» — ${switches}, герой впереди с опоры y = ${switchY} px (у дерева 210)`);

Вывод прогона (проверено в Node.js 24.22.1, 11.11.2026):

1) рисуем дерево, потом героя → в точке (300, 180): герой | наоборот → дерево
2) ключ «верх спрайта»: порядок дерево → герой, в (300, 180) видно: герой
2) ключ «центр спрайта»: порядок дерево → герой, в (300, 180) видно: герой
2) ключ «точка опоры»: порядок герой → дерево, в (300, 180) видно: дерево
3) ключ «только Y»: за 120 кадров смен верхней бочки — 8
3) ключ «Y, затем id»: за 120 кадров смен верхней бочки — 0
4) (a > b ? 1 : 0): [3,1,4,1,5,9] | a − b: [1,1,3,4,5,9]
5) герой в прыжке перед бочкой, в (300, 175) по опоре: герой | по нижнему краю картинки: бочка
6) 1000 объектов: случайный порядок — 8655 сравнений, уже отсортированы — 999, после кадра с 50 сдвигами — 2317
7) проход мимо дерева: смен «кто сверху» — 1, герой впереди с опоры y = 210 px (у дерева 210)

Что показывают семь сценариев:

  • 1. Алгоритм художника. В точке, где дерево и герой перекрываются, виден тот, кого нарисовали вторым.
  • 2. Точка опоры. Ключи «верх спрайта» и «центр спрайта» ставят героя, который стоит за деревом, перед ним; ключ по опоре даёт верную картинку.
  • 3. Ничьи. Без id верхняя из двух бочек на одной линии сменилась 8 раз за 120 кадров — каждый раз, когда список менял порядок; с id — 0 раз.
  • 4. Компаратор. «1 или 0» в V8 оставил массив без изменений.
  • 5. Прыжок. По опоре герой в прыжке остаётся перед бочкой, по нижнему краю картинки — прячется за неё.
  • 6. Цена. 999 сравнений на готовом списке, 2317 после одного кадра движения, 8655 на случайном.
  • 7. Проход мимо дерева. Порядок меняется ровно один раз — при опоре героя y = 210, равной опоре дерева. При ничьей решает id: у героя он больше, поэтому герой уже впереди.

Обвязка для браузера

В браузере тот же ключ используется так: объекты лежат в одном массиве, массив сортируется на месте раз в кадр, затем обходится по порядку. Блок проверки в конце depth.mjs для браузера удалите или вынесите в отдельный файл.

// main.js — обвязка для браузера: один список, сортировка раз в кадр, рисование по порядку
import { LAYER, spriteRect, compareDepth } from './depth.mjs';

const canvas = document.querySelector('canvas');
const ctx = canvas.getContext('2d');
canvas.width = 640; canvas.height = 360;

let nextId = 1;
const make = (o) => ({ id: nextId++, z: 0, ...o });        // id выдаётся один раз и не меняется
const objects = [
  make({ name: 'тень', layer: LAYER.GROUND, x: 300, y: 214, w: 56, h: 8, color: '#0004' }),
  make({ name: 'дерево', layer: LAYER.WORLD, x: 300, y: 210, w: 64, h: 96, color: '#2a6' }),
  make({ name: 'бочка', layer: LAYER.WORLD, x: 400, y: 260, w: 40, h: 40, color: '#a62' }),
  make({ name: 'счёт', layer: LAYER.UI, x: 60, y: 30, w: 100, h: 20, color: '#fff' }),
];
const hero = make({ name: 'герой', layer: LAYER.WORLD, x: 200, y: 240, w: 32, h: 48, color: '#36c' });
objects.push(hero);

const held = new Set();
addEventListener('keydown', e => held.add(e.code));
addEventListener('keyup', e => held.delete(e.code));

let last = performance.now();
function frame(now) {
  const dt = Math.min(now - last, 250) / 1000; last = now;
  const speed = 120;                                       // px/с
  hero.x += ((held.has('ArrowRight') ? 1 : 0) - (held.has('ArrowLeft') ? 1 : 0)) * speed * dt;
  hero.y += ((held.has('ArrowDown') ? 1 : 0) - (held.has('ArrowUp') ? 1 : 0)) * speed * dt;

  objects.sort(compareDepth);                              // почти отсортированный список — дёшево
  ctx.fillStyle = '#7b5'; ctx.fillRect(0, 0, canvas.width, canvas.height);
  for (const o of objects) {
    const r = spriteRect(o);
    ctx.fillStyle = o.color;
    ctx.fillRect(r.left, r.top, r.right - r.left, r.bottom - r.top);
  }
  requestAnimationFrame(frame);
}
requestAnimationFrame(frame);

Подключите main.js как модуль к странице с одним элементом canvas и откройте её через локальный сервер. Стрелками ведите синий прямоугольник-героя вокруг зелёного дерева: выше основания ствола он уходит за дерево, ниже — выходит вперёд, тень остаётся под всем, а счёт — поверх всего. Синтаксис обвязки проверен командой node --check. Три детали:

  • id выдаётся один раз. Функция make присваивает номер при создании; если объект возвращается из пула, номер не меняется.
  • Сортировка на месте. objects.sort(compareDepth) каждый кадр получает массив, упорядоченный в прошлом кадре, — это вариант «почти отсортирован» из таблицы выше.
  • Дробные координаты. Герой движется со скоростью 120 px/с, и y дробный; разность a.y − b.y с ним работает, а округлять для сортировки не нужно.

Практический сценарий: герой проходит мимо дерева

Задача: в деревне с видом сверху герой должен проходить за деревом и перед ним без скачков картинки. Входные условия — дерево 64 × 96 px с основанием ствола в y = 210, герой 32 × 48 px идёт сверху вниз, опора меняется с 190 до 228 px с шагом 2 px. Шаги:

  1. Опора. Задать у дерева и героя y точки опоры, а не верхнего угла картинки; прямоугольник спрайта считать через spriteRect.
  2. Слой. Дерево и героя положить в мировой слой, тень героя — в слой земли.
  3. Ключ. Сортировать по compareDepth: слой → Y → id.
  4. Проверка. На каждом шаге смотреть, кто виден в точке на груди героя (y − 20), и считать, сколько раз ответ сменился.

Проверяемый итог — сценарий 7: ровно одна смена, при y = 210. Если смен больше одной, где-то порядок зависит от положения в массиве; если смена происходит не на уровне основания ствола, опора задана не той точкой. Тот же тест удобно держать для каждого нового высокого объекта: столба, дома, статуи.

Когда вам это не подойдёт

Сортировка «слой → Y → id» решает большинство сцен, но не все:

  • Изометрия и объекты на нескольких клетках. В изометрической сетке ключом обычно служит сумма координат клетки, а длинные объекты вроде стены через три клетки одной точкой опоры не описываются: их режут на части по клеткам или сортируют по отношению «кто кого закрывает». Это тот случай, где алгоритм художника из 1972 года требует разрезать фигуры.
  • Платформер с видом сбоку. Там глубина почти не меняется: игрок не уходит «вглубь», и хватает слоёв из таблицы выше без сортировки по Y.
  • Многоэтажные уровни. Мост над дорогой, балкон, второй этаж: объект наверху может иметь меньший Y, чем объект под ним, но должен быть поверх. Нужен ещё один признак ключа — уровень высоты, — или отдельный слой для верхнего яруса.
  • Тысячи объектов с разными текстурами в WebGL. Сортировка по Y рвёт пакеты по атласам. Там чаще используют буфер глубины и записывают Y в координату глубины, но полупрозрачные спрайты всё равно приходится сортировать.

Мы разрабатываем J2DRU — браузерный 2D игровой движок, где логика собирается из событий, условий и действий, а проект можно углублять на TypeScript. Движок в разработке и публично пока не открыт, заявку можно оставить на странице раннего доступа (подача заявки не гарантирует приглашение).

Источники (проверено: ноябрь 2026, 11.11.2026): MDN — CanvasRenderingContext2D: globalCompositeOperation (source-over по умолчанию — новая фигура рисуется поверх уже нарисованного); Wikipedia — Painter's algorithm (сортировка от дальнего к ближнему; Ньюэлл, Ньюэлл и Санча, 1972; разрезание при циклическом перекрытии); MDN — Array.prototype.sort() (требования к компаратору; стабильность с ECMAScript 2019; компаратор «1 или 0» в V8, JavaScriptCore и SpiderMonkey); V8 — Getting things sorted in V8 (28.09.2018; Timsort и стабильная сортировка с V8 7.0 / Chrome 70; отсортированный массив — за линейное время). Размеры объектов, координаты, число слоёв, скорость героя и подсчёт сравнений — наши значения и наш прогон в Node.js 24.

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

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

Почему персонаж оказывается перед деревом, хотя стоит за ним?

Скорее всего, объекты сортируются по верхнему краю или центру спрайта. У дерева высотой 96 px верх выше, чем у героя высотой 48 px, и дерево рисуется первым. Сортируйте по точке опоры — по нижней точке, которой объект касается земли: ноги героя, основание ствола.

Почему два объекта на одной линии мигают, меняясь местами?

При одинаковом Y порядок решает их положение в массиве, а оно меняется при удалении и повторном добавлении объектов. Добавьте в ключ сортировки третий признак — постоянный id объекта. В нашем прогоне без id верхняя бочка сменилась 8 раз за 120 кадров, с id — ни разу.

Не слишком ли дорого сортировать все объекты каждый кадр?

Обычно нет. Array.prototype.sort в V8 с версии 7.0 работает по алгоритму Timsort, который уже отсортированный список проходит за линейное время. В нашем прогоне 1000 объектов потребовали 999 сравнений (n − 1) на готовом списке, 2317 после кадра, где 50 объектов сдвинулись на ±2 px, и 8655 на случайном порядке.

Как сортировать персонажа, который прыгает?

Храните высоту прыжка z отдельно от Y опоры: рисуйте спрайт на z пикселей выше, а сортируйте по Y на земле. Если сортировать по нижнему краю картинки, герой в прыжке перед бочкой «уйдёт» за неё.