libbgi: спрайты — кэш адреса кадра, DDA+asm тик, Y-сортировка со слоями
Оптимизации 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:
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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);
|
||||
+366
-75
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
+26
-14
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
|
||||
Reference in New Issue
Block a user