snark13/Sprinter-SDCC
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

libbgi: спрайты — кэш адреса кадра, DDA+asm тик, Y-сортировка со слоями

Browse Source 
Оптимизации A+B (профиль rpgwalk-15: активная часть кадра 410К → 307К
тактов из 430080; лимит спрайтов 16×16 на стабильные 48.8 fps: 14 → ~21):

- (B) sprite_t.src/stride — готовый адрес кадра: считают только
  sprite_frame (теперь функция, одно умножение на СМЕНУ кадра) и тикер
  (±an_step БАЙТ инкрементально); блит-ядра принимают src+stride,
  img/sx/sy из сигнатуры ушли.  Блит 177К → 146К на кадр.
- (A) тик 100К → 37.7К: tween переформулирован Брезенхэм → беззнаковый
  DDA (mv_rem/mv_acc, «приехали» = rem==0 — без знаковых 16-бит
  сравнений), tick_move и tick_anim — ручной asm (SDCC спиллит такие
  функции в IX-фрейм ~100 обращений; C-реструктуризации не помогали —
  проверено кодогеном).  Биты an_flags переименованы по категориям
  (_SPR_STRIP_HORZ, _SPR_PP_BACK).

Y-сортировка (gfx_sprite_ysort, идеи пользователя — 8-бит ключ,
персистентность):

- painter's algorithm по ключу {layer:8, clamp_y:8}; поле
  sprite_t.layer (в КОНЦЕ структуры — asm-офсеты не сдвигает): слои
  сцены в одном массиве/одном sprite_update;
- ПЕРСИСТЕНТНАЯ asm-таблица {key16, ptr16}: resort порядка прошлого
  кадра (почти линейно), rebuild при смене arr/count; массив
  приложения не трогается; ~28К/15 спрайтов (с нуля было 44К);
- компоненты YSORT_Y/YSORT_LAYER отключаемы независимо масками ключа
  (без ветвлений в сортировщике); ВНИМАНИЕ: mode=1 значит Y-only,
  полный порядок = YSORT_Y|YSORT_LAYER;
- funcptr-DCE: выключено = код и таблица не линкуются (rpgwalk −190 Б);
- ПРАВИЛО в sprite.h: два sprite_update на страницу запрещены (heal
  второй группы стирает спрайты первой — ОЗУ-копия чистая).

Попутные фиксы:

- libbgi/Makefile: .rel зависят от заголовков (HDRS) — stale .rel со
  старой раскладкой sprite_t молча ломал рантайм;
- rpgprof: --memory small (перерос tiny: BSS вылезал за W2 → мгновенный
  «Unexpected application termination»; mkexe это пока не ловит);
- tests/spranim: проверки переведены на кэш src, добавлены T6 (reframe
  после тикера) и T7 (Y-сортировка: порядок, слои, персистентный
  resort, LAYER-only) — 7/7 PASS в MAME.

Доки: §9д — новый бюджет (19.5К/спрайт), §9е — ПЛАН FPS-делителя
(frame pacing, gfx_set_fps_div); TODO — дизайн цепочки irq-обработчиков.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
Alexander Petrov
2026-07-14 17:19:24 +03:00
parent 0eec977630
commit b9ddce8d34
24 changed files with 1339 additions and 304 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libbgi/Makefile
+10 -4
View File
@@ -28,6 +28,12 @@ BUILD := $(CURDIR)/build
COMMON_C := $(wildcard $(CURDIR)/common/*.c)
BGI256_C := $(wildcard $(CURDIR)/bgi256/*.c)
# Заголовки либы: любой .rel зависит от всех — правка _bgi.h/sprite.h/…
# пересобирает модули (иначе stale .rel со СТАРОЙ раскладкой sprite_t
# молча ломает рантайм — кусало 2026-07-14: sprite_moveto писал флаги
# по старому офсету, T4/T5 spranim FAIL).
HDRS := $(wildcard $(CURDIR)/*.h $(CURDIR)/include/*.h)
COMMON_FAST_RELS := $(patsubst $(CURDIR)/common/%.c,$(BUILD)/fast/common/%.rel,$(COMMON_C))
BGI256_FAST_RELS := $(patsubst $(CURDIR)/bgi256/%.c,$(BUILD)/fast/bgi256/%.rel,$(BGI256_C))
COMMON_SAFE_RELS := $(patsubst $(CURDIR)/common/%.c,$(BUILD)/safe/common/%.rel,$(COMMON_C))
@@ -45,21 +51,21 @@ safe: $(LIB_SAFE)
# --- Fast version: -DGFX_NOCHECK (guard'и выключены) ---
$(BUILD)/fast/common/%.rel: $(CURDIR)/common/%.c
$(BUILD)/fast/common/%.rel: $(CURDIR)/common/%.c $(HDRS)
@mkdir -p $(dir $@)
$(SDCC) -mz80 --no-std-crt0 --std-c99 --opt-code-size -DGFX_NOCHECK --max-allocs-per-node 100000 $(INC) -c -o $@ $<
$(BUILD)/fast/bgi256/%.rel: $(CURDIR)/bgi256/%.c
$(BUILD)/fast/bgi256/%.rel: $(CURDIR)/bgi256/%.c $(HDRS)
@mkdir -p $(dir $@)
$(SDCC) -mz80 --no-std-crt0 --std-c99 --opt-code-size -DGFX_NOCHECK --max-allocs-per-node 100000 $(INC) -c -o $@ $<
# --- Safe version: guard'и включены (по умолчанию) ---
$(BUILD)/safe/common/%.rel: $(CURDIR)/common/%.c
$(BUILD)/safe/common/%.rel: $(CURDIR)/common/%.c $(HDRS)
@mkdir -p $(dir $@)
$(SDCC) -mz80 --no-std-crt0 --std-c99 --opt-code-size $(INC) -c -o $@ $<
$(BUILD)/safe/bgi256/%.rel: $(CURDIR)/bgi256/%.c
$(BUILD)/safe/bgi256/%.rel: $(CURDIR)/bgi256/%.c $(HDRS)
@mkdir -p $(dir $@)
$(SDCC) -mz80 --no-std-crt0 --std-c99 --opt-code-size $(INC) -c -o $@ $<
libbgi/_bgi.h
+27 -6
View File
@@ -117,16 +117,19 @@ void _gfx_heal_full(int x, int y, int w, int h);
/* Лин-ядра для СПРАЙТОВ (кадр ≤ 64×64, sprite.h): как *_full, но без
* split'а >256 и с 8-битными w/h (движок/putsprite — горячий путь;
* программа только со спрайтами не тянет общие *_full со split'ом).
* common/_gfx_blit_sprite.c, _gfx_heal_sprite.c. */
void _gfx_blit_sprite(int x, int y, const void *img,
int sx, int sy, uint8_t w, uint8_t h);
* Сигнатура БЕЗ img/sx/sy (2026-07-14): src — ГОТОВЫЙ адрес пикселей
* кадра, stride — шаг строки источника; считает их вызывающий один раз
* (кэш в sprite_t / putsprite из заголовка) — ни чтения заголовка, ни
* умножения в ядре. common/_gfx_blit_sprite.c, _gfx_heal_sprite.c. */
void _gfx_blit_sprite(int x, int y, const uint8_t *src,
uint16_t stride, uint8_t w, uint8_t h);
void _gfx_heal_sprite(int x, int y, uint8_t w, uint8_t h);
/* NOCLIP-ядра: клип-кода нет вообще (полный выигрыш от codegen, не только
* скип проверок). Зовутся при gfx_sprite_clip(0) — приложение
* гарантирует пределы. common/_gfx_blit_sprite_noclip.c, _gfx_heal_… */
void _gfx_blit_sprite_noclip(int x, int y, const void *img,
int sx, int sy, uint8_t w, uint8_t h);
void _gfx_blit_sprite_noclip(int x, int y, const uint8_t *src,
uint16_t stride, uint8_t w, uint8_t h);
void _gfx_heal_sprite_noclip(int x, int y, uint8_t w, uint8_t h);
/* Диспетчеризация clip/noclip через УКАЗАТЕЛИ (не ветка в горячем цикле):
@@ -136,12 +139,30 @@ void _gfx_heal_sprite_noclip(int x, int y, uint8_t w, uint8_t h);
* см. docs/sprite-api-design.md). Дефолт (clip-ядра) — статическая
* инициализация; указатели в РАЗДЕЛЬНЫХ data-модулях (_gfx_blit_fn.c,
* _gfx_heal_fn.c): putsprite-only программа не тянет heal-ядро. */
typedef void (*_gfx_blit_fp)(int, int, const void *, int, int,
typedef void (*_gfx_blit_fp)(int, int, const uint8_t *, uint16_t,
uint8_t, uint8_t);
typedef void (*_gfx_heal_fp)(int, int, uint8_t, uint8_t);
extern _gfx_blit_fp _gfx_blit_fn;
extern _gfx_heal_fp _gfx_heal_fn;
/* ---- Y-сортировка блит-прохода (sprite.h: gfx_sprite_ysort) ------- *
* _spr_ysort ведёт ПЕРСИСТЕНТНУЮ таблицу 4-байтных записей
* {key16 = layer:8|clamp_y:8, ptr16} (вставки, стабильно; таблица и
* состояние сцены — приватные данные его модуля) и ВОЗВРАЩАЕТ её
* адрес. Указатель спрайта — в записи по смещению +2. Лимит спрайтов
* на кадр — _GFX_YSORT_MAX; больше — sprite_update рисует БЕЗ
* сортировки (фолбэк).
* Подключение — указателем _spr_ysort_fn (NULL = выкл, дефолт; ставит
* gfx_sprite_ysort, обнуляя _spr_ysort_last — форс rebuild) —
* программа без вызова сеттера не линкует ни код сортировщика, ни
* таблицу (funcptr-DCE, как _spr_tick_fn).
* common/_spr_ysort.c, _spr_ysort_fn.c, gfx_sprite_ysort.c. */
#define _GFX_YSORT_MAX 32u
uint8_t *_spr_ysort(void *arr, uint16_t count);
extern uint8_t *(*_spr_ysort_fn)(void *arr, uint16_t count);
extern void *_spr_ysort_last; /* arr прошлого кадра (сеттер сбрасывает) */
extern uint8_t _spr_ysort_kmask[2]; /* маски ключа: [0] y, [1] layer (0/FF) */
/* ---- Атласы в страницах W0 (sprite.h, §9в дизайна) ---------------- *
* _gfx_w0_dss — страница ядра DSS (снимается при первом map/load);
* _gfx_w0_cur — какая спрайт-страница должна стоять в W0 (читает
libbgi/common/_gfx_blit_sprite.c
+17 -49
View File
@@ -6,66 +6,34 @@
* и смены банка — вызывающий (sprite_update/putsprite) держит скобку и
* банк 0x5C. Проверок размера НЕТ (контракт ≤64 — в доке, не в коде).
*
* src — ГОТОВЫЙ адрес первого пикселя кадра, stride — шаг строки
* источника (полная ширина img/ленты); считает вызывающий один раз
* (кэш sprite_t.src/stride; putsprite — из заголовка). Заголовок
* getimage и (sx,sy) ядру больше не передаются (2026-07-14) — весь
* пересчёт адреса кадра ушёл в редкие точки его смены (sprite_frame,
* тикер анимации инкрементально).
*
* Клип по ЭКРАНУ остаётся (это функциональность — спрайты штатно уходят
* за края): fast-path «целиком на экране» = 4 сравнения.
*
* ФОРМАТ getimage и параметры атласа
* ----------------------------------
* img указывает на getimage-буфер: 4-байтовый заголовок + пиксели.
* Заголовок = uint16 width, uint16 height (little-endian):
* p[0]=width lo, p[1]=width hi, p[2]=height lo, p[3]=height hi.
* Дальше (p+4) — пиксели ПОСТРОЧНО, по width байт на строку.
*
* int img_w = p[0] | (p[1] << 8);
* — это ПОЛНАЯ ширина картинки/ленты-атласа (склейка двух байтов
* заголовка в 16-бит). Используется как ШАГ между строками источника
* (sstride): чтобы спуститься на строку ниже в буфере, надо прибавить к
* адресу целую ширину картинки. Для одиночного спрайта img_w == ширине
* кадра; для ЛЕНТЫ-АТЛАСА (много кадров в ряд) img_w — ширина всей ленты
* (> ширины кадра w), поэтому img_w остаётся int (лента может быть шире
* 64, хотя КАДР ≤ 64).
*
* (sx, sy) — смещение КАДРА (под-прямоугольника) ВНУТРИ картинки:
* левый-верхний угол вырезаемого кадра в пикселях. Для целого спрайта
* sx = sy = 0. Для кадра N горизонтальной ленты: sx = N*FRAME_W, sy = 0
* (вертикальные атласы — sy). Отсюда адрес первого пикселя кадра:
* src = p + 4 (пропустить заголовок)
* + sx (сместиться на sx пикселей вправо в первой строке)
* + sy*img_w (спуститься на sy строк — цикл сложений ниже, без
* умножения: обычно sy == 0).
* за края): fast-path «целиком на экране» = 4 сравнения; при выходе
* корректируются края И src (левый — src += -x; верхний — src +=
* (-y)*stride, одно 16-бит умножение ТОЛЬКО на реально клипнутом
* кадре — редкость рядом с кадровым циклом).
*/
#include "../_bgi.h"
void _gfx_blit_sprite(int x, int y, const void *img,
int sx, int sy, uint8_t w, uint8_t h)
void _gfx_blit_sprite(int x, int y, const uint8_t *src,
uint16_t stride, uint8_t w, uint8_t h)
{
const uint8_t *p = (const uint8_t *)img;
const uint8_t *src;
uint16_t dst;
int img_w = p[0] | (p[1] << 8); /* ширина картинки/ленты = sstride */
int cw = w, ch = h; /* рабочие w,h кадра (для клипа) */
if (x < 0 || y < 0 || x + cw > _bgi_maxx + 1 || y + ch > _bgi_maxy + 1) {
if (x < 0) { sx -= x; cw += x; x = 0; }
if (y < 0) { sy -= y; ch += y; y = 0; }
if (x < 0) { src += -x; cw += x; x = 0; }
if (y < 0) { src += (uint16_t)(-y) * stride; ch += y; y = 0; }
if (x + cw > _bgi_maxx + 1) cw = _bgi_maxx + 1 - x;
if (y + ch > _bgi_maxy + 1) ch = _bgi_maxy + 1 - y;
if (cw <= 0 || ch <= 0) return;
}
/* Адрес первого пикселя кадра: заголовок(4) + sx вправо + sy строк
* вниз. sy*img_w умножением (__mulint, O(1) ~300Т): вертикальные
* ленты атласов сделали sy != 0 нормой — цикл сложений был O(sy),
* до ~64К тактов на блит кадра 11 (профиль rpgwalk 2026-07-13).
* if (sy): горизонтальные ленты/одиночные спрайты не платят и за
* умножение. */
src = p + 4 + sx;
if (sy)
src += (uint16_t)sy * (uint16_t)img_w;
dst = _gfx_addr_base + x;
_bgi_blit_rows_raw(src, (uint8_t *)dst, (uint8_t)cw, (uint8_t)ch,
img_w, (uint8_t)y);
_bgi_blit_rows_raw(src, (uint8_t *)(_gfx_addr_base + x),
(uint8_t)cw, (uint8_t)ch, (int)stride, (uint8_t)y);
}
libbgi/common/_gfx_blit_sprite_noclip.c
+11 -18
View File
@@ -11,27 +11,20 @@
* заворачивается наверх, x за 320 — в соседнюю строку/страницу; см.
* tests/spriteclip). Вызывать только когда спрайт заведомо в пределах.
*
* Формат img/img_w/sx/sy — как в _gfx_blit_sprite (getimage-заголовок +
* лента-атлас). БЕЗ _bgi_begin/_bgi_end и смены банка (держит вызывающий).
* src — ГОТОВЫЙ адрес первого пикселя кадра, stride — шаг строки
* источника (полная ширина img); считает вызывающий один раз (кэш
* sprite_t.src/stride ведут sprite_frame и тикер; putsprite — из
* заголовка). До 2026-07-14 здесь были img+sx/sy с пересчётом адреса
* на КАЖДЫЙ блит (цикл O(sy), потом __mulint) — профиль rpgwalk снёс
* весь пересчёт в редкие точки смены кадра.
*
* БЕЗ _bgi_begin/_bgi_end и смены банка (держит вызывающий).
*/
#include "../_bgi.h"
void _gfx_blit_sprite_noclip(int x, int y, const void *img,
int sx, int sy, uint8_t w, uint8_t h)
void _gfx_blit_sprite_noclip(int x, int y, const uint8_t *src,
uint16_t stride, uint8_t w, uint8_t h)
{
const uint8_t *p = (const uint8_t *)img;
const uint8_t *src;
int img_w = p[0] | (p[1] << 8); /* ширина картинки/ленты = sstride */
/* sy*img_w умножением (__mulint, O(1) ~300Т): вертикальные ленты
* атласов сделали sy != 0 нормой — старый цикл сложений был O(sy),
* до ~64К тактов на блит кадра 11 (профиль rpgwalk 2026-07-13).
* if (sy): горизонтальные ленты/одиночные спрайты (sy == 0) не
* платят и за умножение. */
src = p + 4 + sx;
if (sy)
src += (uint16_t)sy * (uint16_t)img_w;
_bgi_blit_rows_raw(src, (uint8_t *)(_gfx_addr_base + x),
w, h, img_w, (uint8_t)y);
w, h, (int)stride, (uint8_t)y);
}
libbgi/common/_spr_ysort.c
+221
View File
@@ -0,0 +1,221 @@
/*
* _spr_ysort — ПЕРСИСТЕНТНАЯ таблица порядка отрисовки спрайтов для
* блит-прохода sprite_update (gfx_sprite_ysort): 4-байтные записи
* {key16, ptr16}, отсортированные вставками по возрастанию ключа.
* Возвращает адрес таблицы.
*
* КЛЮЧ = {layer, y}: старший байт — слой спрайта (слой 1 всегда поверх
* слоя 0 — ходячие/летающие/курсор), младший — clamp(y, 0, 255)
* (идея пользователя: экран 256 строк — вся видимая зона сортируется
* точно, за краями порядок неважен, перекрытие невидимо). Компоненты
* отключаемы независимо (YSORT_Y/YSORT_LAYER): маски _spr_ysort_kmask
* затирают выключенный байт ключа — без ветвлений в горячем цикле.
*
* ПЕРСИСТЕНТНОСТЬ (идея пользователя): таблица живёт МЕЖДУ кадрами.
* Каждый вызов — «resort»: для каждой записи ключ пересчитывается по
* её спрайту и запись вставляется в отсортированный префикс. Спрайты
* двигаются на пиксели за кадр → порядок прошлого кадра почти актуален
* → вставки вырождаются в одно сравнение с соседом (почти линейно).
* Смена сцены (arr/count != прошлых, см. _spr_ysort_last/_lastn) —
* rebuild: заполнить ptr-поля из массива и прогнать тот же resort
* (первый кадр — полная сортировка, разово дороже). МАССИВ ПРИЛОЖЕНИЯ
* НЕ ТРОГАЕТСЯ — сортируются только внутренние записи-указатели.
*
* Стабильность: равные ключи сохраняют порядок ПРОШЛОГО КАДРА (спрайты
* на одной высоте не мерцают взаимным порядком, пока реально не
* разойдутся).
*
* C-эквивалент:
* if (arr != last || count != lastn) { // новая сцена
* for (i = 0; i < count; i++) tab[i].ptr = &arr[i];
* last = arr; lastn = count;
* }
* for (i = 0; i < count; i++) { // resort
* p = tab[i].ptr;
* key = (p->layer << 8) | clamp8(p->y);
* for (pos = i; pos && tab[pos-1].key > key; pos--)
* tab[pos] = tab[pos-1];
* tab[pos] = {key, p};
* }
* return tab;
*
* Офсеты: y = +8/9, layer = +56 в sprite_t, sizeof(sprite_t) = 57 —
* сверять пробником при правке структуры (рецепт в шапке tick_move).
* Вход __sdcccall(1): arr → HL, count → DE (используется E; count
* ограничен _GFX_YSORT_MAX вызывающим); ВОЗВРАТ — адрес таблицы (DE).
* IX callee-saved.
*/
#include "../_bgi.h"
/* Данные модуля (без вызова gfx_sprite_ysort не линкуются вместе с
* кодом). _spr_ysort_last обнуляет сеттер при включении — форсирует
* rebuild. НЕ инициализировать (crt0 зануляет). */
uint8_t _gfx_ysort_tab[4u * _GFX_YSORT_MAX];
void *_spr_ysort_last; /* arr прошлого кадра */
uint8_t _spr_ysort_lastn; /* count прошлого кадра */
uint8_t _spr_ysort_kmask[2]; /* маски ключа (сеттер): *
* [0] & y, [1] & layer */
uint8_t *_spr_ysort(void *arr, uint16_t count) __naked
{
(void)arr; (void)count;
__asm
push ix
ld a, e
or a, a
jr NZ, ys_have_sprites
;; count == 0: вернуть таблицу как есть (сцену не запоминаем)
ld de, #__gfx_ysort_tab
pop ix
ret
ys_have_sprites:
;; ---- та же сцена, что кадр назад? (arr и count совпадают) ----
ld a, (__spr_ysort_lastn)
cp a, e
jr NZ, ys_rebuild
ld bc, (__spr_ysort_last)
ld a, c
cp a, l
jr NZ, ys_rebuild
ld a, b
cp a, h
jr Z, ys_resort_entry ; сцена та же — только resort
ys_rebuild:
;; ---- новая сцена: запомнить и заполнить ptr-поля записей ----
ld (__spr_ysort_last), hl
ld a, e
ld (__spr_ysort_lastn), a
ld b, a ; B = count
ld de, #__gfx_ysort_tab + 2 ; DE = &tab[0].ptr
ys_fill:
ld a, l
ld (de), a
inc de
ld a, h
ld (de), a
inc de
inc de
inc de ; DE = &tab[i+1].ptr
ld a, l ; cur += sizeof(sprite_t) = 57
add a, #57
ld l, a
jr NC, ys_fill_nc
inc h
ys_fill_nc:
djnz ys_fill
ys_resort_entry:
;; ---- resort: обновить ключи и пересортировать вставками ----
ld a, (__spr_ysort_lastn)
ld b, a ; B = счётчик записей
ld hl, #__gfx_ysort_tab ; HL = R (текущая запись)
ys_next_rec:
push bc ; [счётчик]
push hl ; [R]
;; BC = P (спрайт записи)
inc hl
inc hl
ld c, (hl)
inc hl
ld b, (hl)
;; ---- ключ: E = clamp8(P->y), D = P->layer ----
ld hl, #8
add hl, bc ; HL = &P->y
ld e, (hl)
inc hl
ld a, (hl) ; y hi
or a, a
jr Z, ys_key_y_done ; y в 0..255 — точный ключ
ld e, #0
bit 7, a
jr NZ, ys_key_y_done ; y < 0 → 0
ld e, #255 ; y > 255 → 255
ys_key_y_done:
ld hl, #56
add hl, bc ; HL = &P->layer
ld d, (hl) ; key = layer:8 | y:8 (DE)
;; маски компонентов (YSORT_Y/YSORT_LAYER): выключенный — в 0
ld a, (__spr_ysort_kmask + 0)
and a, e
ld e, a
ld a, (__spr_ysort_kmask + 1)
and a, d
ld d, a
;; стек к скану: [счётчик][R][P], HL = pos = R
pop hl ; R
push hl
push bc ; P
ys_scan:
;; pos == tab? → место в голове
ld a, l
cp a, #<(__gfx_ysort_tab)
jr NZ, ys_cmp_prev
ld a, h
cp a, #>(__gfx_ysort_tab)
jr Z, ys_place
ys_cmp_prev:
;; key < prev.key (prev = pos-4)? — сдвиг prev вправо и шаг
;; влево; key >= prev.key (включая равные — стабильность) —
;; место найдено.
push hl
ld a, l
sub a, #4
ld l, a
jr NC, ys_prev_nc
dec h
ys_prev_nc: ; HL = prev
ld a, e
sub a, (hl) ; key.lo - prev.lo
inc hl
ld a, d
sbc a, (hl) ; CF = key < prev.key (16-бит)
pop hl ; HL = pos
jr NC, ys_place
;; сдвиг: копировать prev → pos (4 байта), pos = prev
push de ; key
ld d, h
ld e, l ; DE = pos (dst)
ld a, l
sub a, #4
ld l, a
jr NC, ys_shift_nc
dec h
ys_shift_nc: ; HL = prev (src)
push hl ; prev — станет новым pos
ld bc, #4
ldir ; prev → pos, 4 байта
pop hl ; pos = prev
pop de ; key
jr ys_scan
ys_place:
;; записать {key, P} в pos (HL)
ld (hl), e
inc hl
ld (hl), d
inc hl
pop bc ; P
ld (hl), c
inc hl
ld (hl), b
;; продвинуть R и счётчик
pop hl ; R
ld a, l
add a, #4
ld l, a
jr NC, ys_adv_nc
inc h
ys_adv_nc:
pop bc ; счётчик
dec b
jp NZ, ys_next_rec
ld de, #__gfx_ysort_tab ; вернуть адрес таблицы (ptr в DE)
pop ix
ret
__endasm;
}
libbgi/common/_spr_ysort_fn.c
+9
View File
@@ -0,0 +1,9 @@
/*
* _spr_ysort_fn — указатель подключения Y-сортировки к sprite_update
* (DCE-паттерн как у _spr_tick_fn): NULL (дефолт, _BSS) — сортировки
* нет и её код НЕ линкуется; gfx_sprite_ysort(1) ставит _spr_ysort.
* Заодно указатель — это и флаг включения (отдельного нет).
*/
#include "../_bgi.h"
uint8_t *(*_spr_ysort_fn)(void *arr, uint16_t count);
libbgi/common/_sprite_tick.c
+366 -75
View File
@@ -2,93 +2,384 @@
* _sprite_tick — тикер авто-анимаций (§9г): вызывается из sprite_update
* (раз на КАДР, до heal/блит-проходов — dirty должен взводиться раньше).
* Кадровая анимация и tween-перемещение НЕЗАВИСИМЫ (идут одновременно);
* тикаются и у скрытых спрайтов («время идёт», ветка дороже).
* тикаются и у скрытых спрайтов («время идёт»).
*
* Кадровая: смена кадра = ±an_step к оси ленты (sy; при _SPR_ANIM_HORZ
* — sx) — БЕЗ умножения; wrap цикла — прыжок оси в an_lo (посчитан
* sprite_anim'ом один раз). Маятник разворачивается НА границе (…2,3,
* 2,1,0,1…, без удвоения крайних). ANIM_ONCE замирает на last:
* SPR_ANIM_ON снимается, SPR_ANIM_DONE взводится.
* ГОРЯЧИЙ ПУТЬ (профиль rpgwalk 2026-07-13: тик ел 7.3К тактов/спрайт —
* №2 после блита; переписан 2026-07-14):
* - один ранний выход на спрайт без активных анимаций;
* - декремент таймеров — в цикле, до call'а: недозревший таймер не
* платит за вызов хелпера;
* - сама смена кадра/порция перемещения — в static-хелперах
* tick_anim/tick_move: читаемость + SDCC работает с ЛОКАЛЬНЫМИ
* копиями полей в регистрах вместо IX-обращений (~19Т каждое)
* на каждый чих;
* - кадровая анимация двигает КЭШ АДРЕСА кадра (s->src ± an_step
* байт; wrap — прыжок на готовый an_src0) — ни выбора оси, ни
* пиксельных смещений: всё посчитано sprite_anim'ом один раз.
*
* Перемещение: раз в mv_speed кадров — порция ≤mv_step итераций
* классического Брезенхэма (err-аккумулятор: большая ось шагает каждую
* итерацию, меньшая подтягивается — нелинейные 2/3/2/3 сами собой,
* деления нет). Цель достигнута — SPR_MOVE_ON→off, SPR_MOVE_DONE.
* Кадровая: маятник разворачивается НА границе (…2,3,2,1,0,1… — без
* удвоения крайних); ANIM_ONCE замирает на last: SPR_ANIM_ON снимается,
* SPR_ANIM_DONE взводится. sx/sy НЕ обновляются (см. sprite.h: их
* абсолютно переустановит следующий sprite_frame/sprite_anim).
*
* Перемещение: раз в mv_speed кадров — порция ≤mv_step шагов главной
* оси беззнакового DDA (минорная подтягивается аккумулятором —
* нелинейные 2/3/2/3 сами собой, деления нет; знаковых 16-бит
* сравнений Брезенхэма нет — на Z80 они были главной статьёй расхода).
* Цель достигнута (mv_rem == 0) — SPR_MOVE_ON→off, SPR_MOVE_DONE.
*/
#include "../_bgi.h"
#include <sprite.h>
/* Одна смена кадра кадровой анимации (таймер уже дозрел).
*
* РУЧНОЙ ASM (2026-07-14): та же болезнь SDCC, что у tick_move —
* C-версия спиллилась в IX-фрейм (~120 обращений, ~4-5К тактов на
* вызов); asm ~1К. При медленных анимациях (speed ≥ 5) вклад мал,
* но при speed 1-2 tick_anim зовётся на каждый кадр для каждого
* спрайта и становился главной статьёй тика.
*
* C-эквивалент (семантика 1:1, тест tests/spranim T1/T2/T3/T6):
*
* s->an_timer = s->an_speed;
* if (!(fl & PP_BACK)) { // вперёд
* if (fr < last) { fr++; src += step; }
* else if (fl & ONCE) { ON→off, DONE→on; return; } // не грязнить
* else if (fl & PP) { BACK→on; // разворот на границе:
* if (fr > first) { fr--; src -= step; } else нет-шага; }
* else ..LOOP.. { fr = first; src = an_src0; }
* } else { // маятник, обратно
* if (fr > first) { fr--; src -= step; }
* else { BACK→off; // разворот на first
* if (fr < last) { fr++; src += step; } else нет-шага; }
* }
* если шаг был: an_frame = fr; s->src = src; flags |= DIRTY;
*
* Офсеты полей sprite_t (см. пробник в шапке tick_move):
* src=2 flags=16 an_flags=18 an_frame=19 an_first=20 an_last=21
* an_speed=22 an_timer=23 an_step=24 an_src0=26
* Биты an_flags: ON=0x01 DONE=0x02 PP_BACK=0x10 PP=0x40 ONCE=0x80.
* Вход __sdcccall(1): s → HL. IX callee-saved.
*/
static void tick_anim(sprite_t *s) __naked
{
(void)s;
__asm
push ix
push hl
pop ix ; IX = s
;; an_timer = an_speed — перезарядить темп
ld a, 22 (ix)
ld 23 (ix), a
ld b, 19 (ix) ; B = fr (текущий кадр)
ld c, 18 (ix) ; C = an_flags
bit 4, c ; _SPR_PP_BACK?
jr NZ, ta_backward
;; ---- ход вперёд (LOOP/ONCE всегда; маятник — фаза «туда») ----
ld a, b
cp a, 21 (ix) ; CF = (fr < an_last)
jr NC, ta_at_last
inc b ; шаг вперёд: fr++
call ta_src_fwd ; src += an_step
jr ta_commit ; commit
ta_at_last:
;; fr == last: конец отрезка — по режиму
bit 7, c ; _SPR_ANIM_ONCE?
jr Z, ta_not_once
;; ONCE: замереть на last, отчитаться, НЕ грязнить
ld a, c
and a, #0xFE ; ~SPR_ANIM_ON
or a, #0x02 ; SPR_ANIM_DONE
ld 18 (ix), a
jr ta_done ; выход без dirty
ta_not_once:
bit 6, c ; _SPR_ANIM_PP?
jr Z, ta_loop_wrap
;; маятник: разворот на границе — сразу шаг назад
;; (…2,3,2,… — крайний кадр не удваивается)
set 4, c ; _SPR_PP_BACK
ld 18 (ix), c
ld a, 20 (ix) ; an_first
cp a, b ; CF = (first < fr)
jr NC, ta_done ; лента из 1 кадра — шага нет
dec b
call ta_src_back ; src -= an_step
jr ta_commit
ta_loop_wrap:
;; LOOP: wrap — прыжок на заранее посчитанный first
ld b, 20 (ix) ; fr = an_first
ld l, 26 (ix)
ld h, 27 (ix) ; HL = an_src0
ld 2 (ix), l
ld 3 (ix), h ; src = an_src0
jr ta_commit_fr ; commit (src уже записан)
;; ---- маятник, фаза «обратно» ----
ta_backward:
ld a, 20 (ix) ; an_first
cp a, b ; CF = (first < fr)
jr NC, ta_turn_fwd
dec b ; шаг назад
call ta_src_back ; src -= an_step
jr ta_commit
ta_turn_fwd:
;; на first: разворот — сразу шаг вперёд
res 4, c ; снять _SPR_PP_BACK
ld 18 (ix), c
ld a, b
cp a, 21 (ix) ; CF = (fr < an_last)
jr NC, ta_done ; лента из 1 кадра — шага нет
inc b
call ta_src_fwd ; src += an_step
;; ---- commit: кадр сменился ----
ta_commit: ; (src записан хелпером)
ta_commit_fr:
ld 19 (ix), b ; an_frame = fr
ld a, 16 (ix)
or a, #0x0C ; flags |= _SPR_DIRTY
ld 16 (ix), a
ta_done:
pop ix
ret
;; ---- хелперы: s->src ± an_step; клоббер A,DE,HL ----
ta_src_fwd: ; src += an_step
ld l, 2 (ix)
ld h, 3 (ix)
ld e, 24 (ix)
ld d, 25 (ix)
add hl, de
ld 2 (ix), l
ld 3 (ix), h
ret
ta_src_back: ; src -= an_step
ld l, 2 (ix)
ld h, 3 (ix)
ld e, 24 (ix)
ld d, 25 (ix)
or a, a ; CF = 0
sbc hl, de
ld 2 (ix), l
ld 3 (ix), h
ret
__endasm;
}
/* Одна порция tween-перемещения (таймер уже дозрел): до mv_step шагов
* главной оси DDA (см. sprite_moveto: вся арифметика беззнаковая,
* «приехали» = mv_rem == 0 — сравнений координат нет вообще).
*
* РУЧНОЙ ASM (2026-07-14): SDCC на этой функции спиллил ВСЁ в IX-фрейм
* (~100 IX-обращений по ~19Т, ~6.5К тактов на вызов при порции в один
* шаг) — и никакие реструктуризации C этого не лечили. asm держит
* горячее в регистрах: ~2К тактов на вызов.
*
* C-эквивалент (семантика 1:1, тест tests/spranim):
*
* uint8_t n = s->mv_step; // порция...
* if (n > s->mv_rem) n = s->mv_rem; // ...не длиннее остатка
* s->mv_rem -= n;
* s->mv_timer = s->mv_speed;
* mins = 0; // шагов минорной оси
* for (k = n; k--; ) { // DDA-аккумулятор
* acc += dmin;
* if (acc >= dmaj) { acc -= dmaj; mins++; }
* }
* major_coord += sgnmaj*n; minor_coord += sgnmin*mins;
* s->flags |= _SPR_DIRTY;
* if (!s->mv_rem) { MOVE_ON→off; MOVE_DONE→on; }
*
* Офсеты полей sprite_t — сверены offsetof-пробником по фактическому
* кодогену SDCC 4.5 (поля пакуются подряд, выравнивания нет):
* x=6 y=8 flags=16 an_flags=18 mv_speed=28 mv_timer=29 mv_step=30
* mv_rem=35 mv_acc=37 mv_dmaj=39 mv_dmin=41 mv_ymaj=43
* mv_sgnmaj=44 mv_sgnmin=45
* ПРИ ИЗМЕНЕНИИ ПОРЯДКА ПОЛЕЙ В sprite.h — ПЕРЕСЧИТАТЬ (см. заметку
* у sprite_t). Вход __sdcccall(1): s → HL. IX callee-saved.
*/
static void tick_move(sprite_t *s) __naked
{
(void)s;
__asm
push ix
push hl
pop ix ; IX = s
;; mv_timer = mv_speed — перезарядить темп
ld a, 28 (ix)
ld 29 (ix), a
;; B = n = min(mv_step, mv_rem); HL = rem
ld b, 30 (ix)
ld l, 35 (ix)
ld h, 36 (ix)
ld a, h
or a, a
jr NZ, tm_n_ok ; rem >= 256 — заведомо >= n
ld a, l
cp a, b
jr NC, tm_n_ok ; rem >= n — порция целиком
ld b, l ; хвост маршрута короче: n = rem
tm_n_ok:
;; rem -= n (заём в старший байт вручную)
ld a, l
sub a, b
ld l, a
jr NC, tm_rem_stored
dec h
tm_rem_stored:
ld 35 (ix), l
ld 36 (ix), h
push bc ; сохранить n (в B) на время цикла
;; ---- DDA минорной оси: n прогонов аккумулятора ----
;; HL = acc, DE = dmin, C = mins (счётчик шагов минорной), B = k
ld l, 37 (ix)
ld h, 38 (ix)
ld e, 41 (ix)
ld d, 42 (ix)
ld c, #0
tm_dda_loop:
add hl, de ; acc += dmin
;; беззнаковое acc >= dmaj?
ld a, l
sub a, 39 (ix)
ld a, h
sbc a, 40 (ix)
jr C, tm_dda_next ; acc < dmaj — минорная стоит
;; acc -= dmaj; mins++
ld a, l
sub a, 39 (ix)
ld l, a
ld a, h
sbc a, 40 (ix)
ld h, a
inc c
tm_dda_next:
djnz tm_dda_loop
ld 37 (ix), l
ld 38 (ix), h
ld e, c ; E = mins
pop bc ; B = n
;; ---- применить порцию к координатам ----
;; sgn* = ±1: rlca выносит знак в CF (0xFF → CF=1)
ld a, 43 (ix) ; ymaj?
or a, a
jr NZ, tm_ymaj
;; --- главная ось X (поле +6), минорная Y (+8) ---
ld a, 44 (ix) ; sgnmaj
rlca
ld a, b ; A = n
jr NC, tm_xmaj_n_set
neg ; A = -n
tm_xmaj_n_set:
push ix
pop hl
ld bc, #6
add hl, bc ; HL = &x
call tm_add16 ; x += ±n
ld a, e
or a, a
jp Z, tm_mark_dirty ; минорная не шагала (далеко: jp)
ld a, 45 (ix) ; sgnmin
rlca
ld a, e ; A = mins
jr NC, tm_xmaj_min_set
neg
tm_xmaj_min_set:
push ix
pop hl
ld bc, #8
add hl, bc ; HL = &y
call tm_add16 ; y += ±mins
jp tm_mark_dirty
;; --- главная ось Y (+8), минорная X (+6) ---
tm_ymaj:
ld a, 44 (ix) ; sgnmaj
rlca
ld a, b
jr NC, tm_ymaj_n_set
neg
tm_ymaj_n_set:
push ix
pop hl
ld bc, #8
add hl, bc ; HL = &y
call tm_add16 ; y += ±n
ld a, e
or a, a
jr Z, tm_mark_dirty
ld a, 45 (ix) ; sgnmin
rlca
ld a, e
jr NC, tm_ymaj_min_set
neg
tm_ymaj_min_set:
push ix
pop hl
ld bc, #6
add hl, bc ; HL = &x
call tm_add16 ; x += ±mins
tm_mark_dirty:
;; flags |= _SPR_DIRTY (0x0C) — порция всегда двигает major
ld a, 16 (ix)
or a, #0x0C
ld 16 (ix), a
;; rem == 0 → приехали: MOVE_ON снять, MOVE_DONE взвести
ld a, 35 (ix)
or a, 36 (ix)
jr NZ, tm_done
ld a, 18 (ix)
and a, #0xFB ; ~SPR_MOVE_ON
or a, #0x08 ; SPR_MOVE_DONE
ld 18 (ix), a
tm_done:
pop ix
ret
;; ---- хелпер: *(int16 @HL) += sign_extend(A); клоббер A,BC ----
tm_add16:
ld c, a
add a, a ; CF = знак A
sbc a, a ; A = 0x00 / 0xFF
ld b, a ; BC = знак-расширенная дельта
ld a, (hl)
add a, c
ld (hl), a
inc hl
ld a, (hl)
adc a, b
ld (hl), a
ret
__endasm;
}
void _sprite_tick(void *arr, uint8_t count)
{
sprite_t *s = (sprite_t *)arr;
uint8_t i;
for (i = 0; i < count; i++, s++) {
/* ---- кадровая анимация ---- */
if ((s->an_flags & SPR_ANIM_ON) && --s->an_timer == 0) {
int *axis = (s->an_flags & _SPR_ANIM_HORZ) ? &s->sx : &s->sy;
uint8_t moved = 1;
uint8_t fl = s->an_flags;
s->an_timer = s->an_speed;
if (!(s->an_flags & _SPR_ANIM_BACK)) {
if (s->an_frame < s->an_last) {
s->an_frame++;
*axis += s->an_step;
} else if (s->an_flags & _SPR_ANIM_ONCE) {
s->an_flags &= (uint8_t)~SPR_ANIM_ON;
s->an_flags |= SPR_ANIM_DONE;
moved = 0;
} else if (s->an_flags & _SPR_ANIM_PP) {
s->an_flags |= _SPR_ANIM_BACK; /* разворот на границе */
if (s->an_frame > s->an_first) {
s->an_frame--;
*axis -= s->an_step;
} else
moved = 0; /* лента из 1 кадра */
} else { /* ANIM_LOOP: wrap */
s->an_frame = s->an_first;
*axis = s->an_lo;
}
} else { /* маятник, назад */
if (s->an_frame > s->an_first) {
s->an_frame--;
*axis -= s->an_step;
} else {
s->an_flags &= (uint8_t)~_SPR_ANIM_BACK;
if (s->an_frame < s->an_last) {
s->an_frame++;
*axis += s->an_step;
} else
moved = 0;
}
}
if (moved)
s->flags |= _SPR_DIRTY;
}
/* ---- tween-перемещение ---- */
if ((s->an_flags & SPR_MOVE_ON) && --s->mv_timer == 0) {
uint8_t n = s->mv_step;
int x = s->x, y = s->y;
s->mv_timer = s->mv_speed;
while (n--) {
int e2;
if (x == s->mv_tx && y == s->mv_ty)
break;
e2 = s->mv_err * 2;
if (e2 >= s->mv_dy) { s->mv_err += s->mv_dy; x += s->mv_sgnx; }
if (e2 <= s->mv_dx) { s->mv_err += s->mv_dx; y += s->mv_sgny; }
}
if (x != s->x || y != s->y) {
s->x = x;
s->y = y;
s->flags |= _SPR_DIRTY;
}
if (x == s->mv_tx && y == s->mv_ty) {
s->an_flags &= (uint8_t)~SPR_MOVE_ON;
s->an_flags |= SPR_MOVE_DONE;
}
}
/* Типичный спрайт в кадре НЕ дозрел ни до смены кадра, ни до
* шага — держим этот путь коротким: одна проверка флагов +
* декремент(ы) таймера. */
if (!(fl & (SPR_ANIM_ON | SPR_MOVE_ON)))
continue;
if ((fl & SPR_ANIM_ON) && --s->an_timer == 0)
tick_anim(s);
if ((fl & SPR_MOVE_ON) && --s->mv_timer == 0)
tick_move(s);
}
}
libbgi/common/atlas_sprite_init.c
+16 -1
View File
@@ -13,20 +13,35 @@ void atlas_sprite_init(sprite_t *s, const atlas_t *a, uint8_t idx)
{
uint8_t saved = _io_page_w3;
const uint8_t *e;
uint16_t img; /* W0-адрес шапки ленты */
sprinter_page_w3(a->page);
e = (const uint8_t *)(0xC000 + _ATL_DIR_OFF) + (uint16_t)idx * 8;
s->img = (const void *)(e[0] | (uint16_t)(e[1] << 8));
img = (uint16_t)(e[0] | (e[1] << 8));
s->img = (const void *)img;
s->w = e[2]; /* fw — размер КАДРА */
s->h = e[3]; /* fh */
/* stride = полная ширина ЛЕНТЫ из её getimage-шапки (каталог хранит
* только размер кадра; лента nx>1 шире кадра). Шапка лежит в
* странице атласа — читаем через ТЕКУЩИЙ W3-маппинг: адрес в W3 =
* 0xC000 + W0-адрес. */
{
const uint8_t *hdr = (const uint8_t *)(0xC000 + img);
s->stride = (uint16_t)(hdr[0] | (hdr[1] << 8));
}
sprinter_page_w3(saved);
/* src — W0-адрес пикселей кадра (0,0); разыменовывается блитом
* только при подключенной странице (sprite_update мапит сам). */
s->src = (const uint8_t *)img + 4;
s->x = 0; s->y = 0;
s->sx = 0; s->sy = 0;
s->flags = 0;
s->page = a->page;
s->an_flags = 0; /* авто-анимации выключены */
s->an_frame = 0;
s->layer = 0; /* нижний слой Y-сортировки */
s->drawn[0].on = 0;
s->drawn[1].on = 0;
}
libbgi/common/gfx_sprite_ysort.c
+28
View File
@@ -0,0 +1,28 @@
/*
* gfx_sprite_ysort — включить/выключить сортировку блит-прохода
* sprite_update (painter's algorithm) и выбрать компоненты порядка:
* mode = YSORT_Y | YSORT_LAYER (см. sprite.h). Дефолт 0 (выкл):
* z-order = индекс массива.
*
* Компоненты управляются МАСКАМИ ключа (_spr_ysort_kmask): выключенный
* компонент затирается в 0 при построении ключа — в сортировщике нет
* ни одного ветвления по режиму.
*
* Включение — подключением указателя _spr_ysort_fn (паттерн funcptr-DCE
* как у тикера): только этот модуль ссылается на код сортировщика —
* программа без вызова gfx_sprite_ysort() не линкует ни его, ни таблицу.
*/
#include "../_bgi.h"
#include <sprite.h> /* YSORT_* */
void gfx_sprite_ysort(uint8_t mode)
{
if (mode) {
_spr_ysort_kmask[0] = (mode & YSORT_Y) ? 0xFF : 0x00;
_spr_ysort_kmask[1] = (mode & YSORT_LAYER) ? 0xFF : 0x00;
_spr_ysort_fn = _spr_ysort;
_spr_ysort_last = 0; /* форс rebuild: пока было выключено /
* при смене режима порядок мог уехать */
} else
_spr_ysort_fn = 0;
}
libbgi/common/putsprite.c
+4 -1
View File
@@ -18,7 +18,10 @@ void putsprite(int x, int y, const void *img)
gfx_set_bank(GFX_BANK_SPRITE);
_bgi_begin();
(*_gfx_blit_fn)(x, y, img, 0, 0, p[0], p[2]);
/* Ядро принимает готовый src+stride (кэш-схема 2026-07-14): для
* целой картинки src = пиксели за заголовком, stride = её ширина. */
(*_gfx_blit_fn)(x, y, p + 4, (uint16_t)(p[0] | (p[1] << 8)),
p[0], p[2]);
_bgi_end();
gfx_set_bank(saved);
}
libbgi/common/sprite_anim.c
+26 -14
View File
@@ -3,9 +3,18 @@
* вдоль оси ленты (вертикальная; ANIM_HORIZ — вдоль X), смена раз в
* speed кадров, mode = ANIM_LOOP / ANIM_PINGPONG / ANIM_ONCE.
*
* Всё дорогое считается ЗДЕСЬ один раз (не в тике): шаг оси = размер
* кадра, осевое смещение first — циклом сложений (без __mulint).
* Ставит текущий кадр на first, сбрасывает SPR_ANIM_DONE, подключает
* Всё дорогое считается ЗДЕСЬ один раз, чтобы тикеру осталась только
* 16-бит арифметика указателя:
* an_step — шаг кадра в БАЙТАХ src: fw (гориз. лента: следующий кадр
* правее на ширину кадра) или fh*stride (верт.: ниже на
* fh строк источника);
* an_src0 — готовый адрес кадра first (для wrap ANIM_LOOP: тикер
* прыгает указателем, ничего не пересчитывая).
* Смена кадра тикером = s->src ± an_step; sx/sy тикер НЕ трогает
* (см. sprite.h про кэш src).
*
* Ставит текущий кадр на first (через sprite_frame — единственную
* точку пересчёта (sx,sy)→src), сбрасывает SPR_ANIM_DONE, подключает
* тикер (_spr_tick_fn) — до первого вызова sprite_anim/sprite_moveto
* код тикера в программу не линкуется. Требование: индексы ≤ 127,
* first ≤ last. Move-статусы (SPR_MOVE_*) не трогаются.
@@ -17,18 +26,27 @@ void sprite_anim(sprite_t *s, uint8_t first, uint8_t last,
uint8_t speed, uint8_t mode)
{
uint8_t f = s->an_flags & (SPR_MOVE_ON | SPR_MOVE_DONE);
uint8_t step = (mode & ANIM_HORIZ) ? s->w : s->h;
uint8_t step_px = (mode & ANIM_HORIZ) ? s->w : s->h;
int lo = 0;
uint8_t i;
for (i = 0; i < first; i++)
lo += step; /* first*step без умножения */
lo += step_px; /* first*step без умножения */
if (!speed)
speed = 1;
s->an_step = step;
s->an_lo = lo;
/* Ось — на кадр first (sprite_frame пересчитает кэш src + dirty). */
if (mode & ANIM_HORIZ)
sprite_frame(s, lo, s->sy);
else
sprite_frame(s, s->sx, lo);
/* Байтовый шаг кадра и адрес first-кадра — всё, что нужно тикеру. */
s->an_step = (mode & ANIM_HORIZ)
? s->w
: (uint16_t)s->h * s->stride;
s->an_src0 = s->src; /* src уже стоит на first */
s->an_first = first;
s->an_last = last;
s->an_frame = first;
@@ -37,18 +55,12 @@ void sprite_anim(sprite_t *s, uint8_t first, uint8_t last,
f |= SPR_ANIM_ON;
if (mode & ANIM_HORIZ)
f |= _SPR_ANIM_HORZ;
f |= _SPR_STRIP_HORZ;
if ((mode & 0x03u) == ANIM_PINGPONG)
f |= _SPR_ANIM_PP;
if ((mode & 0x03u) == ANIM_ONCE)
f |= _SPR_ANIM_ONCE;
s->an_flags = f;
/* Ось — на кадр first (обычный путь sprite_frame: dirty при смене). */
if (mode & ANIM_HORIZ)
sprite_frame(s, lo, s->sy);
else
sprite_frame(s, s->sx, lo);
_spr_tick_fn = _sprite_tick;
}
libbgi/common/sprite_anim_stop.c
+14 -7
View File
@@ -1,25 +1,32 @@
/*
* sprite_anim_stop — остановить кадровую анимацию. frame ≥ 0 — какой
* кадр останется на экране (индекс вдоль оси ленты, ≤127); -1 —
* замереть на текущем. Ось кадра считается циклом сложений (стоп —
* редкий вызов, __mulint не тянем). Валидна после sprite_anim
* (an_step/ось настроены им); SPR_ANIM_DONE не трогает.
* замереть на текущем.
*
* Пиксельный шаг оси берётся из размера кадра (w — горизонтальная
* лента, h — вертикальная; an_step НЕ годится — он в БАЙТАХ src),
* смещение кадра — циклом сложений (стоп — редкий вызов). Установка
* кадра — через sprite_frame (единственная точка пересчёта кэша src;
* важно и при frame == an_frame: src мог уехать тикером, а sx/sy —
* нет, sprite_frame сверяет именно src). Валидна после sprite_anim;
* SPR_ANIM_DONE не трогает.
*/
#include "../_bgi.h"
#include <sprite.h>
void sprite_anim_stop(sprite_t *s, int8_t frame)
{
s->an_flags &= (uint8_t)~(SPR_ANIM_ON | _SPR_ANIM_BACK);
s->an_flags &= (uint8_t)~(SPR_ANIM_ON | _SPR_PP_BACK);
if (frame >= 0 && (uint8_t)frame != s->an_frame) {
if (frame >= 0) {
uint8_t step_px = (s->an_flags & _SPR_STRIP_HORZ) ? s->w : s->h;
int off = 0;
uint8_t i;
for (i = 0; i < (uint8_t)frame; i++)
off += s->an_step;
off += step_px;
s->an_frame = (uint8_t)frame;
if (s->an_flags & _SPR_ANIM_HORZ)
if (s->an_flags & _SPR_STRIP_HORZ)
sprite_frame(s, off, s->sy);
else
sprite_frame(s, s->sx, off);
libbgi/common/sprite_frame.c
+34
View File
@@ -0,0 +1,34 @@
/*
* sprite_frame — сменить кадр атласа: запомнить (sx,sy) и пересчитать
* кэш src = img + 4 + sx + sy*stride (адрес первого пикселя кадра).
*
* Кэш src — то, что реально использует блит (без чтения заголовка и
* умножения на каждый кадр экрана); здесь единственное место, где
* (sx,sy) конвертируются в адрес «дорогим» путём — одно 16-бит
* умножение (__mulint; при sy < 256 он сам идёт коротким 8-итерационным
* путём). Смена кадра — редкая операция рядом с блитом.
*
* Указатель НЕ разыменовывается — для W0-атласов пересчёт безопасен
* без подключения страницы (вся арифметика на кэше stride из init).
*
* Была inline-функцией (только sx/sy+dirty) до появления кэша src
* (2026-07-14, оптимизация B: blit 11.8К → ~10К тактов/спрайт).
*/
#include "../_bgi.h"
#include <sprite.h>
void sprite_frame(sprite_t *s, int sx, int sy)
{
/* «Кадр не сменился» определяет src, НЕ (sx,sy): тикер анимации
* двигает src, оставляя sx/sy нетронутыми, поэтому старые sx/sy
* могут совпасть с запрошенными при уехавшем src. */
const uint8_t *src = (const uint8_t *)s->img + 4 + sx
+ (uint16_t)sy * s->stride;
s->sx = sx;
s->sy = sy;
if (s->src != src) {
s->src = src;
s->flags |= _SPR_DIRTY;
}
}
libbgi/common/sprite_init.c
+8 -1
View File
@@ -3,7 +3,11 @@
* getimage (uint16 w, uint16 h). Спрайт невидим (flags = 0) и нигде не
* нарисован (drawn[*].on = 0) — первый sprite_show + sprite_update его
* выведет. Для атласа после init перезадать s->w/s->h (размер кадра) и
* s->sx/s->sy. См. docs/sprite-api-design.md §9.1.
* перейти на кадр через sprite_frame. См. docs/sprite-api-design.md §9.1.
*
* Заполняет кэш блита: stride (полная ширина img = шаг строки источника)
* и src (адрес пикселей кадра (0,0) = img+4) — дальше их ведут
* sprite_frame и тикер анимации, блит берёт готовыми.
*/
#include "../_bgi.h"
#include <sprite.h>
@@ -13,6 +17,8 @@ void sprite_init(sprite_t *s, const void *img)
const uint8_t *p = (const uint8_t *)img;
s->img = img;
s->stride = (uint16_t)(p[0] | (p[1] << 8)); /* ширина img/ленты */
s->src = p + 4; /* кадр (0,0) */
s->x = 0;
s->y = 0;
s->sx = 0;
@@ -25,6 +31,7 @@ void sprite_init(sprite_t *s, const void *img)
s->page = 0; /* img в обычной памяти (не W0-атлас) */
s->an_flags = 0; /* авто-анимации выключены */
s->an_frame = 0;
s->layer = 0; /* нижний слой Y-сортировки */
s->drawn[0].on = 0;
s->drawn[1].on = 0;
}
libbgi/common/sprite_moveto.c
+37 -16
View File
@@ -1,13 +1,20 @@
/*
* sprite_moveto — запустить tween-перемещение к (tx,ty): раз в interval
* кадров тикер делает до max_step итераций Брезенхэма (большая ось —
* итерация = пиксель; меньшая подтягивается err-аккумулятором).
* Пример: (0,0)→(100,50), max_step 5, interval 4 → 20 шагов × 4 кадра
* = 80 кадров (1.6 с), Y идёт 2/3/2/3.
* кадров тикер делает до max_step шагов вдоль ГЛАВНОЙ оси (большая
* |дельта|); минорная ось подтягивается DDA-аккумулятором — нелинейные
* 2/3/2/3 сами собой, деления нет. Пример: (0,0)→(100,50), max_step 5,
* interval 4 → 20 порций × 4 кадра = 80 кадров (1.6 с).
*
* Дельты/знаки/аккумулятор считаются здесь один раз. Если цель ==
* текущая позиция — сразу SPR_MOVE_DONE (тикер не включается).
* Кадровые статусы (SPR_ANIM_*) не трогаются.
* Всё дорогое (выбор главной оси, |дельты|, знаки) считается здесь один
* раз; тикеру остаётся БЕЗЗНАКОВАЯ арифметика (см. sprite.h: acc/rem —
* на Z80 беззнаковое 16-бит сравнение в разы дешевле знаковых сравнений
* классического Брезенхэма, ради этого и переформулировано 2026-07-14).
* За mv_dmaj шагов главной оси минорная получает ровно mv_dmin шагов
* (аккумулятор со стартом dmaj/2 — симметричное округление), так что
* обе координаты приходят в цель одновременно; «приехали» = mv_rem == 0.
*
* Если цель == текущая позиция — сразу SPR_MOVE_DONE (тикер не
* включается). Кадровые статусы (SPR_ANIM_*) не трогаются.
*/
#include "../_bgi.h"
#include <sprite.h>
@@ -17,11 +24,10 @@ void sprite_moveto(sprite_t *s, int tx, int ty,
{
int dx = tx - s->x;
int dy = ty - s->y;
int8_t sgnx = 1, sgny = 1;
s->mv_sgnx = 1;
if (dx < 0) { dx = -dx; s->mv_sgnx = -1; }
s->mv_sgny = 1;
if (dy < 0) { dy = -dy; s->mv_sgny = -1; }
if (dx < 0) { dx = -dx; sgnx = -1; }
if (dy < 0) { dy = -dy; sgny = -1; }
s->an_flags &= (uint8_t)~SPR_MOVE_DONE;
if (dx == 0 && dy == 0) {
@@ -29,11 +35,26 @@ void sprite_moveto(sprite_t *s, int tx, int ty,
return;
}
s->mv_tx = tx;
s->mv_ty = ty;
s->mv_dx = dx;
s->mv_dy = -dy;
s->mv_err = dx - dy;
s->mv_tx = tx;
s->mv_ty = ty;
/* Главная ось — с большей |дельтой| (при равенстве — X, диагональ
* ровная в обе стороны). */
if ((uint16_t)dy > (uint16_t)dx) {
s->mv_ymaj = 1;
s->mv_dmaj = (uint16_t)dy;
s->mv_dmin = (uint16_t)dx;
s->mv_sgnmaj = sgny;
s->mv_sgnmin = sgnx;
} else {
s->mv_ymaj = 0;
s->mv_dmaj = (uint16_t)dx;
s->mv_dmin = (uint16_t)dy;
s->mv_sgnmaj = sgnx;
s->mv_sgnmin = sgny;
}
s->mv_rem = s->mv_dmaj; /* шагов до цели */
s->mv_acc = s->mv_dmaj >> 1; /* симметричное округление minor */
if (!max_step) max_step = 1;
if (!interval) interval = 1;
libbgi/common/sprite_update.c
+24 -6
View File
@@ -33,6 +33,7 @@ void sprite_update(sprite_t *arr, uint8_t count)
uint8_t dbit = p ? _SPR_DIRTY1 : _SPR_DIRTY0;
uint8_t saved = gfx_get_bank();
uint8_t i;
const uint8_t *rec; /* курсор сорт-таблицы (NULL = без) */
sprite_t *s;
/* Проход 0: тик авто-анимаций (§9г) — ДО heal/блита (двигает x/y и
@@ -52,18 +53,33 @@ void sprite_update(sprite_t *arr, uint8_t count)
}
_bgi_end();
/* Y-сортировка блит-прохода (gfx_sprite_ysort): asm-сортировка
* строит таблицу записей {key,ptr} по ВОЗРАСТАНИЮ y (нижние
* рисуются последними = поверх) и возвращает её адрес; rec — курсор
* по полю ptr записей (+1, шаг 3), NULL = сортировки нет.
* Подключена указателем (funcptr-DCE). Сортируем ПОСЛЕ тика (y уже
* сдвинуты). count больше таблицы — фолбэк на порядок массива. */
rec = 0;
if (_spr_ysort_fn && count <= _GFX_YSORT_MAX)
rec = (*_spr_ysort_fn)(arr, count) + 2; /* поле ptr записи */
/* Проход 2: блит ВСЕХ видимых, требующих обновления. Спрайты из
* W0-атласов (s->page): подключить страницу перед блитом — один OUT
* на СМЕНУ страницы (спрайты одного атласа подряд = один OUT);
* порядок «_gfx_w0_cur, затем OUT» закрывает гонку с ISR-стабом
* (он восстановит уже новую). heal-проходу страница не нужна
* (img не читается). */
* на СМЕНУ страницы (спрайты одного атласа подряд = один OUT; при
* Y-сортировке смен может быть больше); порядок «_gfx_w0_cur,
* затем OUT» закрывает гонку с ISR-стабом (он восстановит уже
* новую). heal-проходу страница и порядок не нужны. */
gfx_set_bank(GFX_BANK_SPRITE);
_bgi_begin();
{
uint8_t mapped = 0; /* 0 = W0 не тронута (там ядро DSS) */
for (i = 0, s = arr; i < count; i++, s++) {
for (i = 0; i < count; i++) {
if (rec) {
s = *(sprite_t * const *)rec; /* Y-порядок */
rec += 4;
} else
s = arr + i; /* z = индекс массива */
if (s->flags & (dbit | SPR_ALWAYS)) {
if (s->flags & SPR_VISIBLE) {
if (s->page != mapped && s->page) {
@@ -71,7 +87,9 @@ void sprite_update(sprite_t *arr, uint8_t count)
_io_page_w0 = s->page;
mapped = s->page;
}
(*_gfx_blit_fn)(s->x, s->y, s->img, s->sx, s->sy, s->w, s->h);
/* src/stride — готовый кэш (sprite_frame/тикер),
* ядро не считает адрес кадра вообще. */
(*_gfx_blit_fn)(s->x, s->y, s->src, s->stride, s->w, s->h);
s->drawn[p].x = s->x;
s->drawn[p].y = s->y;
s->drawn[p].on = 1;
libbgi/include/sprite.h
+105 -18
View File
@@ -55,10 +55,14 @@
#define SPR_ANIM_DONE 0x02u /* one-shot дошёл до last */
#define SPR_MOVE_ON 0x04u /* tween-перемещение идёт */
#define SPR_MOVE_DONE 0x08u /* перемещение достигло цели */
#define _SPR_ANIM_BACK 0x10u /* внутр.: маятник идёт назад */
#define _SPR_ANIM_HORZ 0x20u /* внутр.: лента горизонтальная (ось sx) */
#define _SPR_ANIM_PP 0x40u /* внутр.: режим маятника */
#define _SPR_ANIM_ONCE 0x80u /* внутр.: режим one-shot */
/* Внутренние биты an_flags (владеет движок) — три РАЗНЫЕ категории:
* режим анимации (зеркало параметра mode), свойство ЛЕНТЫ (ориентация
* данных в атласе) и runtime-состояние (меняется само в процессе). */
#define _SPR_PP_BACK 0x10u /* runtime: маятник сейчас идёт назад */
#define _SPR_STRIP_HORZ 0x20u /* лента: кадры вдоль X (двигается sx) */
#define _SPR_ANIM_PP 0x40u /* режим: маятник */
#define _SPR_ANIM_ONCE 0x80u /* режим: one-shot */
/* Режимы sprite_anim(). */
#define ANIM_LOOP 0u /* 0,1,..,last,first,.. (цикл) */
@@ -66,10 +70,24 @@
#define ANIM_ONCE 2u /* first..last, замереть на last + DONE */
#define ANIM_HORIZ 0x80u /* ИЛИ-флаг: кадры вдоль X (сетка nx>1) */
/* ВНИМАНИЕ: порядок полей ЗАШИТ в asm-ядро тикера (офсеты полей в
* common/_sprite_tick.c, tick_move) — при изменении порядка/типов
* пересчитать офсеты там (offsetof-пробником, рецепт в его шапке). */
typedef struct {
const void *img; /* getimage-формат / атлас-лента (вне W3) */
/* --- кэш адреса кадра (владеет движок; менять ТОЛЬКО через
* sprite_frame) ---
* src — ГОТОВЫЙ адрес первого пикселя ТЕКУЩЕГО кадра (img + 4 +
* sx + sy*stride). Блит берёт его как есть: ни чтения заголовка,
* ни умножения в кадровом цикле. Тикер анимации двигает src
* инкрементально (±an_step байт); sx/sy при этом НЕ обновляются —
* они «последняя позиция, установленная sprite_frame», и снова
* становятся истиной при следующем sprite_frame/sprite_anim
* (те ставят ось абсолютно, а не относительно). */
const uint8_t *src; /* адрес пикселей текущего кадра */
uint16_t stride; /* полная ширина img в байтах (шаг строки) */
int x, y; /* ЛОГИЧЕСКАЯ позиция левого-верхнего угла кадра */
int sx, sy; /* смещение кадра внутри img (атлас; 0 = целая) */
int sx, sy; /* смещение кадра, заданное sprite_frame (см. src)*/
uint8_t w, h; /* размер кадра (кэш заголовка), 1..255 */
uint8_t flags; /* SPR_* | внутренние dirty */
uint8_t page; /* 0 = img в обычной памяти; иначе физ. страница *
@@ -81,23 +99,40 @@ typedef struct {
uint8_t an_frame; /* ТЕКУЩИЙ индекс кадра (0-based по ленте) */
uint8_t an_first, an_last; /* границы анимации (индексы) */
uint8_t an_speed, an_timer; /* кадров между сменами / счётчик */
uint8_t an_step; /* шаг оси = fh (верт. лента) или fw (гориз.) */
int an_lo; /* осевое смещение кадра first (для wrap) */
uint16_t an_step; /* шаг кадра в БАЙТАХ src: fw (гориз. лента) *
* или fh*stride (верт.) — считает sprite_anim */
const uint8_t *an_src0; /* src кадра first (для wrap цикла) */
uint8_t mv_speed, mv_timer; /* кадров между шагами / счётчик */
uint8_t mv_step; /* макс. пикселей вдоль большей оси за шаг */
int mv_tx, mv_ty; /* цель */
int mv_dx, mv_dy, mv_err;/* Брезенхэм: dx, -dy, аккумулятор */
int8_t mv_sgnx, mv_sgny; /* знаки шага осей */
int mv_tx, mv_ty; /* цель (для sprite_move_stop) */
/* DDA по главной оси (беззнаковый — на Z80 16-бит беззнаковые
* сравнения в разы дешевле знаковых Брезенхэма, 2026-07-14):
* главная ось шагает каждую итерацию, минорная подтягивается
* аккумулятором; «приехали» = mv_rem == 0 (сравнений координат нет). */
uint16_t mv_rem; /* осталось шагов главной оси до цели */
uint16_t mv_acc; /* аккумулятор минорной оси (старт dmaj/2) */
uint16_t mv_dmaj, mv_dmin; /* |дельты| главной / минорной осей */
uint8_t mv_ymaj; /* 1 = главная ось Y (иначе X) */
int8_t mv_sgnmaj, mv_sgnmin;/* знаки шага главной/минорной осей */
/* --- внутреннее (владеет движок) --- */
struct {
int x, y; /* где нарисован на странице p */
uint8_t on; /* нарисован ли на странице p */
} drawn[2];
/* Слой для Y-сортировки (см. gfx_sprite_ysort): при включённой
* сортировке спрайты упорядочиваются по {layer, y} — слой старше:
* слой 1 ВСЕГДА поверх слоя 0 (ходячие/летающие/курсор...), внутри
* слоя — painter по y. 0 после sprite_init; без сортировки не
* используется (порядок = индекс массива). Поле В КОНЦЕ структуры:
* офсеты полей выше зашиты в asm тикера/сортировщика. */
uint8_t layer;
} sprite_t;
/* Инициализация: w,h из заголовка img, невидим, ничего не нарисовано.
* Для АТЛАСА (кадр — под-прямоугольник) после init выставить s->w/s->h
* в размер кадра и s->sx/s->sy — на нужный кадр (или sprite_frame). */
/* Инициализация: w,h из заголовка img, кадр (0,0), невидим, ничего не
* нарисовано. Для АТЛАСА (кадр — под-прямоугольник) после init
* выставить s->w/s->h в размер кадра и перейти на нужный кадр ТОЛЬКО
* через sprite_frame (он ведёт кэш src; голые s->sx/s->sy кэш не
* обновят). */
void sprite_init(sprite_t *s, const void *img);
/* Кадр всей сцены: на ТЕКУЩЕЙ draw-странице (gfx_get_draw_page)
@@ -105,7 +140,16 @@ void sprite_init(sprite_t *s, const void *img);
* скобка/банк на проход). Спрайты без изменений с прошлого визита этой
* страницы (и без SPR_ALWAYS) не трогаются. Для дабл-буфера звать после
* gfx_set_draw_page(hidden); для одиночной страницы/курсора — прямо на
* видимой. */
* видимой.
*
* ВСЯ СЦЕНА СТРАНИЦЫ — ОДИН ВЫЗОВ! Два sprite_update на одну страницу
* (например «сначала ходячие, потом летающие») ЛОМАЮТ перекрытия МЕЖДУ
* группами: heal второй группы берёт из ОЗУ-копии чистый ФОН (спрайты
* в копию не пишутся — банк 0x5C) и стирает нарисованных первой
* группой; двухпроходная дисциплина «heal все → блит все» покрывает
* перекрытия только ВНУТРИ одного вызова. Логические группы держать
* диапазонами индексов одного массива (z-порядок групп = порядок
* диапазонов; слоение при Y-сортировке — полем layer). */
void sprite_update(sprite_t *arr, uint8_t count);
/* Сахар канонического дабл-буфер-кадра: draw-страница = скрытая →
@@ -114,6 +158,49 @@ void sprite_update(sprite_t *arr, uint8_t count);
* sprite_flip — тогда heal учтёт его через ОЗУ-копию. */
void sprite_flip(sprite_t *arr, uint8_t count);
/* Режимы gfx_sprite_ysort (битовая маска компонентов ключа). */
#define YSORT_OFF 0u /* сортировки нет: z-order = индекс массива */
#define YSORT_Y 0x01u /* painter по y (нижние поверх верхних) */
#define YSORT_LAYER 0x02u /* слои: layer 1 поверх layer 0 */
/* Y-сортировка блит-прохода (painter's algorithm): mode — какие
* компоненты ключа участвуют в порядке отрисовки:
* YSORT_Y | YSORT_LAYER — полный порядок {layer, y}: сначала слои
* (спрайт слоя 1 ВСЕГДА поверх слоя 0 — ходячие/летающие/
* курсор...), внутри слоя — по y (нижние по экрану поверх
* верхних, «ближе к зрителю»);
* YSORT_Y — только painter по y, слои игнорируются;
* YSORT_LAYER — только слои; внутри слоя порядок стабилен
* (наследуется от прошлого кадра / порядка массива);
* YSORT_OFF (0, дефолт) — z-order = индекс массива.
* Выключенный компонент маскируется в ключе (2 AND на спрайт, ~1К на
* 15 спрайтов) — сортировщик не замедляется ветвлениями.
*
* ПЕРСИСТЕНТНОСТЬ: таблица порядка живёт МЕЖДУ кадрами — каждый кадр
* ключи обновляются и порядок пересортировывается вставками; спрайты
* двигаются на пиксели за кадр, порядок почти актуален → почти
* линейно. Цена (замер rpgwalk-15, 2026-07-14): ~28К тактов на 15
* спрайтов (~2К/спрайт, ~6% бюджета кадра; построение с нуля каждый
* кадр стоило 44К). Массив приложения при этом НЕ трогается (sp[2]
* всегда персонаж 2) — сортируются внутренние записи-указатели. При
* смене arr/count (другая сцена) таблица перестраивается сама; первый
* кадр после включения/смены — полная сортировка (разово дороже).
*
* Сортировка СТАБИЛЬНА относительно ПРОШЛОГО КАДРА: спрайты с равным
* ключом сохраняют взаимный порядок прошлого кадра (не мерцают), а не
* порядок массива. Лимит: до 32 спрайтов на вызов sprite_update;
* больше — кадр рисуется без сортировки (безопасный фолбэк).
* Выключено = 0 тактов И 0 байт: код сортировщика и таблица не
* линкуются (funcptr-DCE). heal-проход порядка не требует и остаётся
* линейным.
*
* Замечания: (1) перекрывающиеся спрайты обязаны быть dirty ОБА, чтобы
* смена их взаимного порядка отрисовалась — движущиеся грязнятся сами,
* статики помечать sprite_touch (правило то же, что и без сортировки);
* (2) сортировка перемешивает порядок W0-атласов — смен страницы W0
* может стать больше (один дешёвый OUT на смену). */
void gfx_sprite_ysort(uint8_t on);
/* --- O(1) изменения состояния (inline: без call-оверхеда в физике) --- */
/* Переместить: меняет только логическую позицию + грязнит обе страницы. */
@@ -121,10 +208,10 @@ inline void sprite_move(sprite_t *s, int x, int y) {
if (s->x != x || s->y != y) { s->x = x; s->y = y; s->flags |= _SPR_DIRTY; }
}
/* Сменить кадр атласа (под-прямоугольник img). */
inline void sprite_frame(sprite_t *s, int sx, int sy) {
if (s->sx != sx || s->sy != sy) { s->sx = sx; s->sy = sy; s->flags |= _SPR_DIRTY; }
}
/* Сменить кадр атласа (под-прямоугольник img). Не inline: пересчитывает
* кэш src (одно 16-бит умножение sy*stride) — при АКТИВНОЙ кадровой
* анимации не звать (тикер ведёт src сам). */
void sprite_frame(sprite_t *s, int sx, int sy);
/* Показать (если был скрыт — грязнит обе страницы). */
inline void sprite_show(sprite_t *s) {