libbgi: блочные AND/OR/XOR акселератора (блит строками и колонками)
Акселератор умеет не только копировать блок, но и совмещать его с приёмником: опкод `and/or/xor (hl)` между триггерами чтения и записи переводит внутренний автомат из «буфер := память» в «буфер <op>= память». Операция ортогональна направлению (гориз. LD L,L / верт. LD A,A), значит одинаково работает и для row-major картинок, и для column-major спрайтов персонажей с бесплатным флипом. Полный набор, по образцу существующего копирующего: - ядра bgi256/_bgi_blit_rows_op_raw.c и _bgi_blit_cols_op_raw.c; - строками: gfx_blit_op / gfx_blit_part_op (через _gfx_blit_full_op); - колонками: gfx_blit_cols_op / gfx_blit_cols_part_wx_op (skip/rows/ skipw/maxw и flip — как у копирующего близнеца); - putimage(XOR/OR/AND_PUT) переведён на accel, попиксельным остался только NOT_PUT — закрыт пункт 2d-1 docs/TODO.md. Одна функция на три операции: опкод патчится SMC, как размер блока и страйд, — ветвления в цикле нет. Колоночный путь дороже строкового на один OUT Port_Y: вертикальный op-burst шагает Port_Y, и перед записью его надо вернуть на верх колонки (STOP обязателен — иначе fetch операнда OUT перезапустит burst, memory/accel_operand_fetch_retrigger). Две оговорки (в шапках модулей): - операция ЧИТАЕТ ОЗУ-копию экрана, а не видео-ОЗУ, поэтому при банках 0x54/0x5C совмещается с чистым фоном, а не с нарисованным поверх; - аппаратная прозрачность #FF совместима с AND (нейтраль) и OR (#FF|bg = #FF, запись подавляется), но НЕ с XOR: там источник обязан хранить прозрачный пиксель как 0x00. Проверка: tests/accop (новый) — 8/8 PASS в MAME, побайтно, источник с разными значениями по строкам И колонкам + рамка вокруг; tests/bgi_img получил две байтовые самопроверки (COPY==источник, XOR дважды == фон), обе PASS. make size-check: роста нет (эталон принят заново — kbdpoll +63 Б приехал из прошлой сессии, воспроизводится и без этих правок). Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
@@ -87,6 +87,15 @@ void _bgi_blit_rows_raw(const uint8_t *src, uint8_t *dst,
|
||||
uint8_t w, uint8_t h,
|
||||
int sstride, uint8_t y0);
|
||||
|
||||
/* То же с ЛОГИЧЕСКОЙ ОПЕРАЦИЕЙ (приёмник = приёмник <op> источник): между
|
||||
* чтением источника и записью вставлен третий burst — чтение приёмника в
|
||||
* режиме операции. Всё горизонтально, поэтому три burst'а идут одной
|
||||
* цепочкой без сброса Port_Y. op — ОПКОД `and/or/xor (hl)` (GFX_OP_* из
|
||||
* <gfx.h>), патчится SMC. bgi256/_bgi_blit_rows_op_raw.c. */
|
||||
void _bgi_blit_rows_op_raw(const uint8_t *src, uint8_t *dst,
|
||||
uint8_t w, uint8_t h,
|
||||
int sstride, uint8_t y0, uint8_t op);
|
||||
|
||||
/* КОЛОНОЧНАЯ специализация (column-major src -> экран): каждая колонка —
|
||||
* вертикальный accel-burst (LD A,A, Port_Y авто-шаг); dst +1/колонку, src
|
||||
* +sstride/колонку. Даёт бесплатный горизонтальный флип (sstride<0 + src
|
||||
@@ -96,6 +105,15 @@ void _bgi_blit_cols_raw(const uint8_t *src, uint8_t *dst,
|
||||
uint8_t w, uint8_t h,
|
||||
int sstride, uint8_t y0);
|
||||
|
||||
/* То же с ЛОГИЧЕСКОЙ ОПЕРАЦИЕЙ (приёмник = приёмник <op> источник): между
|
||||
* чтением источника и записью вставлен третий burst — чтение приёмника в
|
||||
* режиме операции. op — ОПКОД `and/or/xor (hl)` (GFX_OP_* из <gfx.h>),
|
||||
* патчится SMC. bgi256/_bgi_blit_cols_op_raw.c (там же — прозрачность и
|
||||
* почему op-burst читает ОЗУ-копию). */
|
||||
void _bgi_blit_cols_op_raw(const uint8_t *src, uint8_t *dst,
|
||||
uint8_t w, uint8_t h,
|
||||
int sstride, uint8_t y0, uint8_t op);
|
||||
|
||||
/* Специализация для heal: src == dst == адрес экрана, оба страйда 0
|
||||
* (строку выбирает Port_Y) — адресной арифметики в цикле нет, строка
|
||||
* 77Т + burst'ы. y0 — стартовый Port_Y; w,h: 0 = 256. Без скобки и
|
||||
@@ -148,6 +166,13 @@ void _gfx_blit_full(int x, int y, const void *img,
|
||||
int sx, int sy, int w, int h);
|
||||
void _gfx_heal_full(int x, int y, int w, int h);
|
||||
|
||||
/* То же с ЛОГИЧЕСКОЙ ОПЕРАЦИЕЙ (приёмник = приёмник <op> источник) —
|
||||
* близнец _gfx_blit_full поверх _bgi_blit_rows_op_raw. op — опкод
|
||||
* GFX_OP_* из <gfx.h>. common/_gfx_blit_full_op.c (там же — прозрачность
|
||||
* и почему op-burst читает ОЗУ-копию). */
|
||||
void _gfx_blit_full_op(int x, int y, const void *img,
|
||||
int sx, int sy, int w, int h, uint8_t op);
|
||||
|
||||
/* Лин-ядра для СПРАЙТОВ (кадр ≤ 64×64, sprite.h): как *_full, но без
|
||||
* split'а >256 и с 8-битными w/h (движок/putsprite — горячий путь;
|
||||
* программа только со спрайтами не тянет общие *_full со split'ом).
|
||||
|
||||
@@ -0,0 +1,135 @@
|
||||
/*
|
||||
* _bgi_blit_cols_op_raw — accel-блит КОЛОНКАМИ с ЛОГИЧЕСКОЙ ОПЕРАЦИЕЙ:
|
||||
* приёмник = приёмник <op> источник, где <op> = AND / OR / XOR. Клон
|
||||
* _bgi_blit_cols_raw (тот же column-major источник, тот же бесплатный
|
||||
* горизонтальный флип), но между чтением источника и записью вставлен
|
||||
* ТРЕТИЙ burst — чтение приёмника в режиме операции.
|
||||
*
|
||||
* КАК ЭТО РАБОТАЕТ (docs/new/06-accel.md §6.2, подтверждено драйвером MAME
|
||||
* src/mame/sinclair/sprinter.cpp — accel_control_r/update_accel_buffer).
|
||||
* Опкоды `AND (HL)` #A6, `OR (HL)` #B6, `XOR (HL)` #AE НЕ являются
|
||||
* отдельным режимом акселератора: их M1-выборка переводит внутренний
|
||||
* автомат из «буфер := память» в «буфер <op>= память», а сам burst
|
||||
* запускается операндным чтением (HL) — в ТЕКУЩЕМ режиме направления
|
||||
* (гориз. LD L,L / верт. LD A,A). То есть операция ОРТОГОНАЛЬНА
|
||||
* направлению: для column-major спрайтов работает так же, как копия.
|
||||
* Следующее армирование (LD L,L / LD A,A / LD B,B) возвращает автомат в
|
||||
* «буфер := память».
|
||||
*
|
||||
* ОДНА функция на три операции: опкод операции патчится SMC при входе
|
||||
* (байт op), ровно как размер блока и страйд. op — это и есть опкод
|
||||
* (GFX_OP_AND/OR/XOR в <gfx.h>); проверку значения делает вызывающий.
|
||||
*
|
||||
* ПОСЛЕДОВАТЕЛЬНОСТЬ НА КОЛОНКУ (три burst'а вместо двух):
|
||||
* OUT Port_Y = y0 ; accel разоружён — операнд OUT безопасен
|
||||
* LD L,L / LD A,(DE) ; гориз. чтение: h смежных байт src -> буфер
|
||||
* LD A,A / <op> (HL) ; верт. чтение: буфер <op>= видео-колонка
|
||||
* LD B,B ; СТОП — разоружить перед вторым OUT
|
||||
* OUT Port_Y = y0 ; вернуть Y: верт. burst сдвинул его на +h
|
||||
* LD A,A / LD (HL),A ; верт. запись: буфер -> видео-колонка
|
||||
* LD B,B
|
||||
* Второй OUT обязателен: вертикальный burst ШАГАЕТ Port_Y (§6.1), и после
|
||||
* op-чтения он стоит на y0+h. СТОП перед OUT обязателен по квирку
|
||||
* memory/accel_operand_fetch_retrigger (fetch операнда под армированным
|
||||
* accel перезапускает burst). Буфер и размер блока переживают LD B,B
|
||||
* (§6.3) — это и позволяет разнести чтение и запись.
|
||||
*
|
||||
* ЧТО ЧИТАЕТ op-burst: страницы #50..#5F на ЧТЕНИЕ всегда отдают ОЗУ-копию
|
||||
* экрана, а не видео-ОЗУ (memory/sprinter_vram_transparency). Значит при
|
||||
* банке 0x54/0x5C (бит 2 — «не писать в ОЗУ-копию») операция считает
|
||||
* ЧИСТЫЙ ФОН, а не то, что уже нарисовано поверх него. Нужна операция с
|
||||
* реально видимым содержимым — вызывающий обязан рисовать банком 0x50
|
||||
* (GFX_BANK_NORMAL), тогда копия и видео-ОЗУ совпадают.
|
||||
*
|
||||
* ПРОЗРАЧНОСТЬ. Аппаратная прозрачность (банки 0x58/0x5C — не писать байт
|
||||
* #FF) действует на РЕЗУЛЬТАТ, а не на источник, поэтому даром достаётся
|
||||
* только двум операциям:
|
||||
* AND — #FF нейтрален сам по себе (#FF & bg = bg);
|
||||
* OR — #FF | bg = #FF, и запись такого байта подавляется банком 0x58/0x5C;
|
||||
* XOR — НЕ работает: #FF ^ bg = ~bg, инверсия фона на прозрачных пикселях.
|
||||
* Для XOR источник обязан иметь прозрачный индекс 0x00 (нейтральный к XOR
|
||||
* и к OR) и рисоваться банком без подавления. Подробно — шапка
|
||||
* common/gfx_blit_cols_part_wx_op.c.
|
||||
*
|
||||
* ВХОД (__sdcccall(1)): src→HL, dst→DE; стек: w 4(ix), h 5(ix),
|
||||
* sstride 6/7(ix), y0 8(ix), op 9(ix). Смысл w/h/sstride/y0 — как у
|
||||
* _bgi_blit_cols_raw. Callee-pop 6 Б.
|
||||
*
|
||||
* Raw: без клиппинга (вызывающий); W3 замаплен (_bgi_begin/end снаружи);
|
||||
* банк выставлен вызывающим. src ВНЕ W3. ОДИН DI на весь блит (втрое
|
||||
* больше трафика, чем у копии — для больших спрайтов резать вызывающему).
|
||||
* Клоббер: AF/BC/DE/HL; IX сохраняется.
|
||||
*/
|
||||
|
||||
#include "../_bgi.h"
|
||||
|
||||
void _bgi_blit_cols_op_raw(const uint8_t *src, uint8_t *dst,
|
||||
uint8_t w, uint8_t h,
|
||||
int sstride, uint8_t y0, uint8_t op) __naked
|
||||
{
|
||||
(void)src; (void)dst; (void)w; (void)h; (void)sstride; (void)y0; (void)op;
|
||||
__asm
|
||||
push ix
|
||||
ld ix, #0
|
||||
add ix, sp
|
||||
;; SMC: размер accel-блока <- h (высота колонки)
|
||||
ld a, 5 (ix)
|
||||
ld (bo_len_imm), a
|
||||
;; SMC: src-страйд между колонками (8-бит adc-цепочка, ± на вызов)
|
||||
ld a, 6 (ix)
|
||||
ld (bo_slo_imm), a
|
||||
ld a, 7 (ix)
|
||||
ld (bo_shi_imm), a
|
||||
;; SMC: опкод операции — and/or/xor (hl) (#A6/#B6/#AE)
|
||||
ld a, 9 (ix)
|
||||
ld (bo_op_imm), a
|
||||
ld b, 4 (ix) ; B = число колонок (0 => 256: djnz)
|
||||
ld c, 8 (ix) ; C = y0 (Port_Y, константа)
|
||||
;; Операция существует только в форме <op> (HL) — приёмник обязан
|
||||
;; жить в HL; источник переезжает в DE (читается LD A,(DE)).
|
||||
ex de, hl ; HL = dst (видео), DE = src (ОЗУ)
|
||||
di ; один DI на весь блит
|
||||
ld d, d ; 0x52 — режим размера блока (no-op для D)
|
||||
ld a, #0
|
||||
bo_len_imm = . - 1
|
||||
ld b, b ; 0x40 — стоп (B=счётчик не тронут)
|
||||
bo_col:
|
||||
ld a, c
|
||||
out (#0x89), a ; Port_Y = y0 (верх колонки)
|
||||
;; 1) ЧТЕНИЕ ИСТОЧНИКА — ГОРИЗОНТАЛЬНОЙ копией (LD L,L): колонка
|
||||
;; спрайта лежит в ОЗУ СМЕЖНО, шагает адрес, не Port_Y.
|
||||
ld l, l ; 0x6D — гориз. режим
|
||||
ld a, (de) ; read-burst: h байт src -> буфер accel
|
||||
;; 2) ОПЕРАЦИЯ с приёмником — ВЕРТИКАЛЬНЫМ чтением (LD A,A):
|
||||
;; буфер <op>= видео-колонка; Port_Y уезжает на y0+h.
|
||||
ld a, a ; 0x7F — верт. режим
|
||||
xor a, (hl) ; SMC: and/or/xor (hl) — op-burst
|
||||
bo_op_imm = . - 1
|
||||
ld b, b ; 0x40 — стоп (разоружить перед OUT)
|
||||
;; 3) ЗАПИСЬ — снова с верха колонки.
|
||||
ld a, c
|
||||
out (#0x89), a ; Port_Y = y0 (accel разоружён)
|
||||
ld a, a ; 0x7F — верт. режим
|
||||
ld (hl), a ; write-burst: буфер -> видео-колонка
|
||||
ld b, b ; 0x40 — стоп
|
||||
;; src += sstride (следующая колонка источника)
|
||||
ld a, e
|
||||
add a, #0
|
||||
bo_slo_imm = . - 1
|
||||
ld e, a
|
||||
ld a, d
|
||||
adc a, #0
|
||||
bo_shi_imm = . - 1
|
||||
ld d, a
|
||||
inc hl ; dst += 1 (следующий x)
|
||||
djnz bo_col
|
||||
ei ; закрыть DI-окно
|
||||
pop ix
|
||||
;; callee-pop 6 байт (w,h,sstride:2,y0,op)
|
||||
pop hl ; ret-адрес
|
||||
pop af
|
||||
pop af
|
||||
pop af
|
||||
jp (hl)
|
||||
__endasm;
|
||||
}
|
||||
@@ -0,0 +1,118 @@
|
||||
/*
|
||||
* _bgi_blit_rows_op_raw — accel-блит СТРОКАМИ с ЛОГИЧЕСКОЙ ОПЕРАЦИЕЙ:
|
||||
* приёмник = приёмник <op> источник, где <op> = AND / OR / XOR. Клон
|
||||
* _bgi_blit_rows_raw (dst фиксирован, строку выбирает Port_Y; src шагает
|
||||
* на sstride), но между чтением источника и записью вставлен ТРЕТИЙ
|
||||
* burst — чтение приёмника в режиме операции.
|
||||
*
|
||||
* КАК ЭТО РАБОТАЕТ (docs/new/06-accel.md §6.2 + пример «XOR блока данных»
|
||||
* §6.3; сверено с драйвером MAME src/mame/sinclair/sprinter.cpp,
|
||||
* accel_control_r/update_accel_buffer). Опкоды `AND (HL)` #A6,
|
||||
* `OR (HL)` #B6, `XOR (HL)` #AE — не режим направления, а переключатель
|
||||
* внутреннего автомата с «буфер := память» на «буфер <op>= память»; сам
|
||||
* burst запускает операндное чтение (HL) в ТЕКУЩЕМ режиме направления.
|
||||
* Следующее армирование (LD L,L / LD A,A / LD B,B) возвращает автомат к
|
||||
* присваиванию.
|
||||
*
|
||||
* ЗДЕСЬ ВСЁ ГОРИЗОНТАЛЬНО — и источник (строка спрайта в ОЗУ), и приёмник
|
||||
* (строка экрана), поэтому три burst'а идут ОДНОЙ цепочкой, ровно как в
|
||||
* примере документации, без промежуточных STOP/OUT:
|
||||
* LD L,L ; гориз. режим
|
||||
* LD A,(DE) ; read-burst : w байт src -> буфер accel
|
||||
* <op> (HL) ; op-burst : буфер <op>= строка экрана
|
||||
* LD (HL),A ; write-burst: буфер -> строка экрана
|
||||
* LD B,B ; стоп
|
||||
* Port_Y в горизонтальном режиме не шагает (шагает внутренний адрес,
|
||||
* который каждый burst берёт заново из регистра) — сбрасывать между
|
||||
* burst'ами нечего. Это дешевле колоночного близнеца
|
||||
* (_bgi_blit_cols_op_raw), где приёмник вертикальный и Port_Y после
|
||||
* op-burst'а приходится возвращать.
|
||||
*
|
||||
* ОДНА функция на три операции: опкод патчится SMC при входе (байт op),
|
||||
* ровно как размер блока и страйд. op — это и есть опкод (GFX_OP_AND/
|
||||
* OR/XOR в <gfx.h>); проверку значения делает вызывающий.
|
||||
*
|
||||
* ЧТО ЧИТАЕТ op-burst: страницы #50..#5F на ЧТЕНИЕ всегда отдают ОЗУ-копию
|
||||
* экрана, а не видео-ОЗУ (memory/sprinter_vram_transparency). При банке
|
||||
* 0x54/0x5C (бит 2 — «не писать в ОЗУ-копию») операция считает ЧИСТЫЙ ФОН,
|
||||
* а не то, что нарисовано поверх; нужна операция с видимой картинкой —
|
||||
* рисовать банком 0x50 (GFX_BANK_NORMAL).
|
||||
*
|
||||
* ПРОЗРАЧНОСТЬ: аппаратная (банк 0x58/0x5C — не писать #FF) смотрит на
|
||||
* РЕЗУЛЬТАТ, поэтому даром достаётся AND (#FF нейтрален) и OR (#FF | bg =
|
||||
* #FF, запись подавляется), но НЕ XOR (#FF ^ bg = ~bg). Источник для XOR
|
||||
* обязан хранить прозрачный пиксель как 0x00. Подробно — шапка
|
||||
* common/_gfx_blit_full_op.c.
|
||||
*
|
||||
* ВХОД (__sdcccall(1)): src→HL, dst→DE (фикс); стек: w 4(ix), h 5(ix),
|
||||
* sstride 6/7(ix), y0 8(ix), op 9(ix). Смысл w/h/sstride/y0 — как у
|
||||
* _bgi_blit_rows_raw. Callee-pop 6 Б.
|
||||
*
|
||||
* Raw: без клиппинга (вызывающий); W3 замаплен (_bgi_begin/end снаружи);
|
||||
* банк выставлен вызывающим. src ВНЕ W3. ОДИН DI на весь блит (втрое
|
||||
* больше трафика, чем у копии — большие блиты режет вызывающий).
|
||||
* Клоббер: AF/BC/DE/HL; IX сохраняется.
|
||||
*/
|
||||
|
||||
#include "../_bgi.h"
|
||||
|
||||
void _bgi_blit_rows_op_raw(const uint8_t *src, uint8_t *dst,
|
||||
uint8_t w, uint8_t h,
|
||||
int sstride, uint8_t y0, uint8_t op) __naked
|
||||
{
|
||||
(void)src; (void)dst; (void)w; (void)h; (void)sstride; (void)y0; (void)op;
|
||||
__asm
|
||||
push ix
|
||||
ld ix, #0
|
||||
add ix, sp
|
||||
;; SMC: размер блока <- w (immediate у ld a,#n — требование FSM)
|
||||
ld a, 4 (ix)
|
||||
ld (bro_len_imm), a
|
||||
;; SMC: src-страйд — константа на вызов (8-битная adc-цепочка)
|
||||
ld a, 6 (ix)
|
||||
ld (bro_slo_imm), a
|
||||
ld a, 7 (ix)
|
||||
ld (bro_shi_imm), a
|
||||
;; SMC: опкод операции — and/or/xor (hl) (#A6/#B6/#AE)
|
||||
ld a, 9 (ix)
|
||||
ld (bro_op_imm), a
|
||||
ld b, 5 (ix) ; B = счётчик строк (0 => 256: djnz)
|
||||
ld c, 8 (ix) ; C = y
|
||||
;; Операция существует только в форме <op> (HL) — приёмник обязан
|
||||
;; жить в HL; источник переезжает в DE (читается LD A,(DE)).
|
||||
ex de, hl ; HL = dst (экран, фикс), DE = src (ОЗУ)
|
||||
di ; один DI на весь блит
|
||||
ld d, d ; 0x52 — режим размера блока (no-op для D)
|
||||
ld a, #0
|
||||
bro_len_imm = . - 1
|
||||
ld b, b ; 0x40 — стоп (B=счётчик не тронут)
|
||||
bro_row:
|
||||
ld a, c
|
||||
out (#0x89), a ; Port_Y = y
|
||||
inc c
|
||||
ld l, l ; 0x6D — армировать гориз. копию строки
|
||||
ld a, (de) ; read-burst : src -> буфер акселератора
|
||||
xor a, (hl) ; SMC: op-burst — буфер <op>= строка экрана
|
||||
bro_op_imm = . - 1
|
||||
ld (hl), a ; write-burst: буфер -> строка экрана
|
||||
ld b, b ; 0x40 — стоп
|
||||
;; src += sstride (dst НЕ двигается — строку выбирает Port_Y)
|
||||
ld a, e
|
||||
add a, #0
|
||||
bro_slo_imm = . - 1
|
||||
ld e, a
|
||||
ld a, d
|
||||
adc a, #0
|
||||
bro_shi_imm = . - 1
|
||||
ld d, a
|
||||
djnz bro_row
|
||||
ei ; закрыть DI-окно блита
|
||||
pop ix
|
||||
;; callee-pop 6 байт (w,h,sstride:2,y0,op)
|
||||
pop hl ; ret-адрес
|
||||
pop af
|
||||
pop af
|
||||
pop af
|
||||
jp (hl)
|
||||
__endasm;
|
||||
}
|
||||
@@ -0,0 +1,79 @@
|
||||
/*
|
||||
* _gfx_blit_full_op — bracket-free ядро блита под-прямоугольника картинки
|
||||
* getimage-формата ЛОГИЧЕСКОЙ ОПЕРАЦИЕЙ (приёмник = приёмник <op>
|
||||
* источник). Полный близнец _gfx_blit_full: тот же клип по экрану, та же
|
||||
* нарезка на полосы ≤256 байт, БЕЗ _bgi_begin/_bgi_end и БЕЗ смены банка
|
||||
* (вызывающий обязан замапить W3 и выставить банк). Разница одна — вызов
|
||||
* op-ядра _bgi_blit_rows_op_raw вместо копирующего.
|
||||
*
|
||||
* ПОЧЕМУ ОТДЕЛЬНОЕ ТЕЛО, а не флаг в _gfx_blit_full. Копирующий путь —
|
||||
* горячий (спрайтовый движок гоняет его в batch-цикле); ветка «а не
|
||||
* операция ли?» тянула бы op-ядро в любую программу с блитом (~+170 Б
|
||||
* _CODE при нулевой пользе). Клип-математика дублируется сознательно —
|
||||
* правки вносить в ОБА файла (близнец: common/_gfx_blit_full.c).
|
||||
*
|
||||
* ---- ПРОЗРАЧНОСТЬ (главное отличие от копии) ----------------------
|
||||
* Аппаратная прозрачность (банк 0x58/0x5C: байт #FF не пишется) смотрит на
|
||||
* РЕЗУЛЬТАТ операции, а не на источник, поэтому достаётся даром не всем:
|
||||
* GFX_OP_AND — прозрачный #FF нейтрален сам по себе (#FF & bg = bg),
|
||||
* банк не важен;
|
||||
* GFX_OP_OR — #FF | bg = #FF, и запись такого байта подавляется банком
|
||||
* 0x58/0x5C: обычный атлас годится КАК ЕСТЬ. Оговорка:
|
||||
* подавится и «настоящий» результат, случайно равный #FF;
|
||||
* GFX_OP_XOR — с прозрачностью #FF НЕ РАБОТАЕТ: #FF ^ bg = ~bg, то есть
|
||||
* инверсия фона по всему прямоугольнику картинки. Источник
|
||||
* для XOR обязан хранить прозрачный пиксель как 0x00 —
|
||||
* нейтральный элемент и для XOR, и для OR (так же, как в
|
||||
* DOS-оригиналах, где прозрачный индекс = 0).
|
||||
* Замаскировать #FF внутри операции нельзя в принципе: побитовые AND/OR/XOR
|
||||
* не умеют «выбрать по условию», а #FF — нейтраль только для AND.
|
||||
*
|
||||
* ---- ЧТО ЧИТАЕТ ОПЕРАЦИЯ ------------------------------------------
|
||||
* Чтение страниц #50..#5F всегда отдаёт ОЗУ-копию экрана
|
||||
* (memory/sprinter_vram_transparency), поэтому при банке 0x54/0x5C («не
|
||||
* писать в копию») операция совмещается с ЧИСТЫМ ФОНОМ, а не с тем, что
|
||||
* уже нарисовано поверх. Нужен результат поверх нарисованного — рисовать
|
||||
* банком GFX_BANK_NORMAL (0x50), где копия и видео-ОЗУ совпадают; платой
|
||||
* будет потеря дарового heal из копии.
|
||||
*
|
||||
* Цена: три accel-burst'а на строку вместо двух (+50% времени accel);
|
||||
* подготовка/клип — как у копии.
|
||||
*/
|
||||
#include "../_bgi.h"
|
||||
|
||||
void _gfx_blit_full_op(int x, int y, const void *img,
|
||||
int sx, int sy, int w, int h, uint8_t op)
|
||||
{
|
||||
const uint8_t *p = (const uint8_t *)img;
|
||||
const uint8_t *src;
|
||||
uint16_t dst;
|
||||
int img_w;
|
||||
|
||||
/* img_w — ПОЛНАЯ ширина картинки/ленты из заголовка getimage
|
||||
* (p[0]=lo, p[1]=hi) = шаг между строками источника (sstride). */
|
||||
img_w = p[0] | (p[1] << 8);
|
||||
|
||||
/* Клип по экрану — только если хоть один край вылезает. */
|
||||
if (x < 0 || y < 0 || x + w > _bgi_maxx + 1 || y + h > _bgi_maxy + 1) {
|
||||
if (x < 0) { sx -= x; w += x; x = 0; }
|
||||
if (y < 0) { sy -= y; h += y; y = 0; }
|
||||
if (x + w > _bgi_maxx + 1) w = _bgi_maxx + 1 - x;
|
||||
if (y + h > _bgi_maxy + 1) h = _bgi_maxy + 1 - y;
|
||||
if (w <= 0 || h <= 0) return;
|
||||
}
|
||||
|
||||
src = p + 4 + sx;
|
||||
if (sy)
|
||||
src += (uint16_t)sy * (uint16_t)img_w;
|
||||
|
||||
dst = _gfx_addr_base + x;
|
||||
while (w > 256) {
|
||||
_bgi_blit_rows_op_raw(src, (uint8_t *)dst, 0 /* =256 */, (uint8_t)h,
|
||||
img_w, (uint8_t)y, op);
|
||||
src += 256;
|
||||
dst += 256;
|
||||
w -= 256;
|
||||
}
|
||||
_bgi_blit_rows_op_raw(src, (uint8_t *)dst, (uint8_t)w, (uint8_t)h,
|
||||
img_w, (uint8_t)y, op);
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
/*
|
||||
* gfx_blit_cols_op — блит спрайта column-major ЛОГИЧЕСКОЙ ОПЕРАЦИЕЙ, без
|
||||
* клип-параметров: приёмник = приёмник <op> источник (op = GFX_OP_AND /
|
||||
* GFX_OP_OR / GFX_OP_XOR). Относится к gfx_blit_cols_part_wx_op так же,
|
||||
* как gfx_blit_cols к gfx_blit_cols_part_wx — тонкая обёртка.
|
||||
*
|
||||
* Прозрачность, выбор банка и цена операции — в шапке
|
||||
* gfx_blit_cols_part_wx_op.c (коротко: XOR требует источника с прозрачным
|
||||
* 0x00, OR работает с обычным #FF-атласом через банк 0x58/0x5C).
|
||||
*/
|
||||
#include <stdint.h>
|
||||
#include "../_bgi.h"
|
||||
|
||||
void gfx_blit_cols_op(int x, int y, const void *img, uint8_t flip, uint8_t op)
|
||||
{
|
||||
gfx_blit_cols_part_wx_op(x, y, img, flip, 0, 0, 0, 0, op);
|
||||
}
|
||||
@@ -0,0 +1,95 @@
|
||||
/*
|
||||
* gfx_blit_cols_part_wx_op — блит спрайта column-major ЛОГИЧЕСКОЙ ОПЕРАЦИЕЙ:
|
||||
* приёмник = приёмник <op> источник (op = GFX_OP_AND / GFX_OP_OR /
|
||||
* GFX_OP_XOR). Полный близнец gfx_blit_cols_part_wx: те же клип-параметры
|
||||
* (skip/rows сверху, skipw/maxw по колонкам), тот же бесплатный флип; вся
|
||||
* разница — вызов op-ядра вместо копирующего.
|
||||
*
|
||||
* ПОЧЕМУ ОТДЕЛЬНОЕ ТЕЛО, а не флаг в gfx_blit_cols_part_wx. Копирующий
|
||||
* путь — самый горячий в движке персонажей (PoP зовёт его на каждого Char
|
||||
* каждый кадр); ветка «а не операция ли?» в его хвосте тянула бы op-ядро в
|
||||
* ЛЮБУЮ программу, использующую блит колонками (~+180 Б _CODE при нулевой
|
||||
* пользе). Клип-математика здесь дублируется сознательно — правки клипа
|
||||
* вносить в ОБА файла (близнец: common/gfx_blit_cols_part_wx.c).
|
||||
*
|
||||
* ПРОЗРАЧНОСТЬ — ГЛАВНОЕ ОТЛИЧИЕ ОТ КОПИИ. Аппаратная прозрачность (банк
|
||||
* 0x58/0x5C: байт #FF не пишется) смотрит на РЕЗУЛЬТАТ операции, а не на
|
||||
* источник. Отсюда:
|
||||
* GFX_OP_AND — прозрачный #FF нейтрален сам по себе (#FF & bg = bg);
|
||||
* банк любой.
|
||||
* GFX_OP_OR — #FF | bg = #FF, запись подавляется банком 0x58/0x5C;
|
||||
* работает с нашими обычными атласами КАК ЕСТЬ. Оговорка:
|
||||
* подавится и «настоящий» результат, случайно равный #FF.
|
||||
* GFX_OP_XOR — с прозрачностью #FF НЕ РАБОТАЕТ: #FF ^ bg = ~bg, то есть
|
||||
* инверсия фона по всему прямоугольнику спрайта. Источник
|
||||
* для XOR обязан хранить прозрачный пиксель как 0x00 —
|
||||
* нейтральный элемент и для XOR, и для OR (так же, как в
|
||||
* оригинале DOS-игр, где прозрачный индекс = 0).
|
||||
*
|
||||
* ЧТО ЧИТАЕТ ОПЕРАЦИЯ. Чтение страниц #50..#5F всегда отдаёт ОЗУ-копию
|
||||
* экрана (memory/sprinter_vram_transparency), поэтому при банке 0x54/0x5C
|
||||
* (не писать в копию) операция считает ЧИСТЫЙ ФОН, а не то, что уже
|
||||
* нарисовано поверх. Нужен результат поверх нарисованного — рисовать
|
||||
* банком GFX_BANK_NORMAL (0x50), у которого копия и видео-ОЗУ совпадают;
|
||||
* платой будет потеря дарового heal из копии.
|
||||
*
|
||||
* Цена: три accel-burst'а на колонку вместо двух (+50% времени accel);
|
||||
* подготовка/клип — как у копии.
|
||||
*/
|
||||
#include <stdint.h>
|
||||
#include "../_bgi.h"
|
||||
|
||||
void gfx_blit_cols_part_wx_op(int x, int y, const void *img, uint8_t flip,
|
||||
int skip, int rows, uint8_t skipw, uint8_t maxw,
|
||||
uint8_t op)
|
||||
{
|
||||
const uint8_t *p = (const uint8_t *)img;
|
||||
int full_w = p[0] | (p[1] << 8);
|
||||
int full_h = p[2] | (p[3] << 8);
|
||||
const uint8_t *px = p + 4;
|
||||
int w = full_w, h;
|
||||
int sstride = flip ? -full_h : full_h; /* шаг между колонками в ОЗУ */
|
||||
int sy; /* пропуск строк сверху колонки */
|
||||
int cx = 0; /* пропуск колонок слева */
|
||||
const uint8_t *src;
|
||||
uint8_t *dst;
|
||||
|
||||
if (full_w <= 0 || full_h <= 0)
|
||||
return;
|
||||
if (skipw) { /* обрезка СЛЕВА */
|
||||
if ((int)skipw >= w) return; /* срезано целиком */
|
||||
cx = (int)skipw;
|
||||
x += (int)skipw;
|
||||
w -= (int)skipw;
|
||||
}
|
||||
if (maxw && (int)maxw < w)
|
||||
w = (int)maxw; /* обрезка справа */
|
||||
if (skip < 0) skip = 0;
|
||||
if (skip >= full_h)
|
||||
return; /* обрезано целиком */
|
||||
sy = skip;
|
||||
h = full_h - skip;
|
||||
if (rows > 0 && rows < h)
|
||||
h = rows;
|
||||
|
||||
/* Клип по экрану — только если хоть один край вылезает. */
|
||||
if (x < 0 || y < 0 || x + w > _bgi_maxx + 1 || y + h > _bgi_maxy + 1) {
|
||||
if (x < 0) { cx -= x; w += x; x = 0; }
|
||||
if (y < 0) { sy -= y; h += y; y = 0; }
|
||||
if (x + w > _bgi_maxx + 1) w = _bgi_maxx + 1 - x;
|
||||
if (y + h > _bgi_maxy + 1) h = _bgi_maxy + 1 - y;
|
||||
if (w <= 0 || h <= 0) return;
|
||||
}
|
||||
|
||||
/* Первая ВИДИМАЯ колонка (с учётом флипа) + первая видимая строка. */
|
||||
src = flip ? (px + (uint16_t)(full_w - 1) * (uint16_t)full_h) : px;
|
||||
if (cx)
|
||||
src += cx * sstride;
|
||||
src += sy;
|
||||
|
||||
_bgi_begin();
|
||||
dst = (uint8_t *)(_gfx_addr_base + (uint16_t)x);
|
||||
_bgi_blit_cols_op_raw(src, dst, (uint8_t)w, (uint8_t)h, sstride,
|
||||
(uint8_t)y, op);
|
||||
_bgi_end();
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
/*
|
||||
* gfx_blit_op — блит ЦЕЛОЙ картинки getimage-формата ЛОГИЧЕСКОЙ ОПЕРАЦИЕЙ
|
||||
* (приёмник = приёмник <op> источник). Близнец gfx_blit: читает w,h из
|
||||
* заголовка и делегирует ядру gfx_blit_part_op (клип/полосы/accel — там).
|
||||
*/
|
||||
#include "../_bgi.h"
|
||||
|
||||
void gfx_blit_op(int x, int y, const void *img, uint8_t op)
|
||||
{
|
||||
const uint8_t *p = (const uint8_t *)img;
|
||||
|
||||
gfx_blit_part_op(x, y, img, 0, 0,
|
||||
p[0] | (p[1] << 8), p[2] | (p[3] << 8), op);
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
/*
|
||||
* gfx_blit_part_op — блит под-прямоугольника картинки getimage-формата
|
||||
* ЛОГИЧЕСКОЙ ОПЕРАЦИЕЙ (приёмник = приёмник <op> источник; op —
|
||||
* GFX_OP_AND / GFX_OP_OR / GFX_OP_XOR из <gfx.h>). Близнец gfx_blit_part:
|
||||
* своя W3-скобка вокруг bracket-free ядра _gfx_blit_full_op, текущий банк
|
||||
* (gfx_set_bank), клип по экрану.
|
||||
*
|
||||
* Прозрачность (XOR требует источника с прозрачным 0x00, AND/OR работают
|
||||
* с обычным #FF-атласом) и то, что операция читает ОЗУ-копию экрана, —
|
||||
* в шапке common/_gfx_blit_full_op.c.
|
||||
*/
|
||||
|
||||
#include "../_bgi.h"
|
||||
|
||||
void gfx_blit_part_op(int x, int y, const void *img,
|
||||
int sx, int sy, int w, int h, uint8_t op)
|
||||
{
|
||||
_bgi_begin();
|
||||
_gfx_blit_full_op(x, y, img, sx, sy, w, h, op);
|
||||
_bgi_end();
|
||||
}
|
||||
+25
-20
@@ -8,11 +8,17 @@
|
||||
* с учётом текущего банка (gfx_set_bank: 0x58 даёт аппаратную
|
||||
* прозрачность 0xFF, 0x54/0x5C — временный вывод).
|
||||
*
|
||||
* XOR/OR/AND — комбинируем с экраном по-пиксельно (raw-чтение +
|
||||
* raw-плот в одной W3-скобке); NOT — пишем ~src. Ускорение этих op
|
||||
* блочными режимами акселератора — «следующая версия» (см.
|
||||
* docs/sprite-api-design.md §9). Клиппинга на этом пути НЕТ
|
||||
* (per-pixel bounds-check остаётся только в safe-версии).
|
||||
* XOR/OR/AND_PUT — тоже через акселератор (gfx_blit_part_op, 2026-08-11;
|
||||
* закрыт пункт 2d-1 docs/TODO.md): акселератор умеет блочные AND/OR/XOR
|
||||
* между своим буфером и памятью приёмника, попиксельного цикла CPU больше
|
||||
* нет. Клиппинг у них теперь ТОТ ЖЕ, что у COPY_PUT (раньше на этом пути
|
||||
* клипа не было вовсе). Оговорки — в шапке common/_gfx_blit_full_op.c:
|
||||
* операция читает ОЗУ-копию экрана (при банках 0x54/0x5C это чистый фон),
|
||||
* а прозрачность #FF совместима с AND/OR, но не с XOR.
|
||||
*
|
||||
* NOT_PUT — по-прежнему по-пиксельно (пишем ~src): это не операция с
|
||||
* приёмником, а инверсия источника, у акселератора такого режима нет.
|
||||
* Клиппинга на этом пути НЕТ (per-pixel bounds-check только в safe).
|
||||
*
|
||||
* Буфер bitmap обязан лежать вне W3 (< 0xC000) — на время операции W3
|
||||
* замаплен на видеобанк.
|
||||
@@ -23,31 +29,30 @@ void putimage(int left, int top, const void *bitmap, int op)
|
||||
{
|
||||
const uint8_t *p = (const uint8_t *)bitmap;
|
||||
int w, h, x, y;
|
||||
uint8_t src, dst;
|
||||
uint8_t gop;
|
||||
|
||||
w = p[0] | (p[1] << 8);
|
||||
h = p[2] | (p[3] << 8);
|
||||
if (w <= 0 || h <= 0) return;
|
||||
|
||||
if (op == COPY_PUT) {
|
||||
switch (op) {
|
||||
case COPY_PUT:
|
||||
gfx_blit_part(left, top, bitmap, 0, 0, w, h);
|
||||
return;
|
||||
case XOR_PUT: gop = GFX_OP_XOR; break;
|
||||
case OR_PUT: gop = GFX_OP_OR; break;
|
||||
case AND_PUT: gop = GFX_OP_AND; break;
|
||||
default: gop = 0; break; /* NOT_PUT — попиксельно ниже */
|
||||
}
|
||||
if (gop) {
|
||||
gfx_blit_part_op(left, top, bitmap, 0, 0, w, h, gop);
|
||||
return;
|
||||
}
|
||||
|
||||
p += 4;
|
||||
_bgi_begin();
|
||||
for (y = 0; y < h; y++) {
|
||||
for (x = 0; x < w; x++) {
|
||||
src = *p++;
|
||||
switch (op) {
|
||||
case XOR_PUT: dst = (uint8_t)_bgi_read_raw(left + x, top + y) ^ src; break;
|
||||
case OR_PUT: dst = (uint8_t)_bgi_read_raw(left + x, top + y) | src; break;
|
||||
case AND_PUT: dst = (uint8_t)_bgi_read_raw(left + x, top + y) & src; break;
|
||||
case NOT_PUT:
|
||||
default: dst = (uint8_t)~src; break;
|
||||
}
|
||||
_bgi_plot_raw(left + x, top + y, dst);
|
||||
}
|
||||
}
|
||||
for (y = 0; y < h; y++)
|
||||
for (x = 0; x < w; x++)
|
||||
_bgi_plot_raw(left + x, top + y, (uint8_t)~(*p++));
|
||||
_bgi_end();
|
||||
}
|
||||
|
||||
@@ -156,6 +156,41 @@ void gfx_blit_cols_part_w(int x, int y, const void *img, uint8_t flip,
|
||||
void gfx_blit_cols_part_wx(int x, int y, const void *img, uint8_t flip,
|
||||
int skip, int rows, uint8_t skipw, uint8_t maxw);
|
||||
|
||||
/* ---- Блит колонками с ЛОГИЧЕСКОЙ ОПЕРАЦИЕЙ ------------------------ *
|
||||
* Акселератор умеет не только копировать блок, но и совмещать его с тем,
|
||||
* что уже лежит в приёмнике: приёмник = приёмник <op> источник. Значения
|
||||
* GFX_OP_* — это ОПКОДЫ Z80 `and/or/xor (hl)`: именно ими переключается
|
||||
* автомат акселератора, и именно они патчатся SMC в ядре (одна функция на
|
||||
* все три операции, ветвления в цикле нет). Иных значений не бывает.
|
||||
*
|
||||
* ПРОЗРАЧНОСТЬ. Аппаратная прозрачность (банк с битом 3 — не писать #FF)
|
||||
* смотрит на РЕЗУЛЬТАТ, а не на источник:
|
||||
* GFX_OP_AND — #FF нейтрален сам по себе, обычный атлас годится;
|
||||
* GFX_OP_OR — #FF | bg = #FF, подавляется банком 0x58/0x5C — обычный
|
||||
* атлас годится;
|
||||
* GFX_OP_XOR — с прозрачным #FF даёт инверсию фона по всему футпринту;
|
||||
* источник ОБЯЗАН хранить прозрачный пиксель как 0x00.
|
||||
* Операция читает приёмник из ОЗУ-копии экрана: при банках 0x54/0x5C это
|
||||
* ЧИСТЫЙ ФОН (нарисованного поверх не видно), при 0x50 — реальная картинка.
|
||||
* Подробности — шапка common/gfx_blit_cols_part_wx_op.c. */
|
||||
#define GFX_OP_AND 0xA6 /* опкод `and (hl)` */
|
||||
#define GFX_OP_XOR 0xAE /* опкод `xor (hl)` */
|
||||
#define GFX_OP_OR 0xB6 /* опкод `or (hl)` */
|
||||
|
||||
/* --- строками (row-major, как gfx_blit/gfx_blit_part) --- */
|
||||
void gfx_blit_op(int x, int y, const void *img, uint8_t op);
|
||||
void gfx_blit_part_op(int x, int y, const void *img,
|
||||
int sx, int sy, int w, int h, uint8_t op);
|
||||
|
||||
/* --- колонками (column-major, как gfx_blit_cols; flip бесплатный) --- */
|
||||
void gfx_blit_cols_op(int x, int y, const void *img, uint8_t flip, uint8_t op);
|
||||
|
||||
/* Полный вариант: те же клип-параметры, что у gfx_blit_cols_part_wx
|
||||
* (skip/rows — обрезка сверху, skipw/maxw — окно по колонкам). */
|
||||
void gfx_blit_cols_part_wx_op(int x, int y, const void *img, uint8_t flip,
|
||||
int skip, int rows, uint8_t skipw, uint8_t maxw,
|
||||
uint8_t op);
|
||||
|
||||
/* То же БЕЗ клипа по экрану — пара к gfx_blit_cols_part так же, как
|
||||
* gfx_blit_part_noclip к gfx_blit_part. Вызывающий гарантирует: спрайт
|
||||
* целиком на экране, ширина/высота кадра и y <= 255, skip < высоты.
|
||||
|
||||
Reference in New Issue
Block a user