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

libbgi: bgi256 fill-примитивы на register-ABI + typedef color_t

Browse Source 
- удалён глобальный скретч акселератора (_gfx_acc256.c); fill-сегменты
  (_gfx_hfill256/_gfx_vfill256) принимают аргументы в регистрах HL/C/B/E,
  вызываются только из asm raw-примитивов
- новый _gfx_rectfill256: заливка прямоугольника через Horizontal_Size
- raw-примитивы (plot/read/hspan/vspan/clear) переписаны под новый ABI
- graphics.h: typedef color_t (uint8_t) для всех public color-функций
- sprinter-cc: флаг --safe (линковка *_safe.lib при наличии)
- CLAUDE.md/mame_interactive: авто-прогон тестов в MAME
- gfx_demo: демонстрация rectfill

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Alexander Petrov
2026-07-10 14:32:21 +03:00
parent 52636a5d6e
commit 029607971f
31 changed files with 618 additions and 283 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libbgi/bgi256/_bgi_clear_raw.c
+33 -13
View File
@@ -1,21 +1,41 @@
/*
* _bgi_clear_raw — залить всё поле 320×256 цветом color, mode 0x81.
* Построчный hfill: 256 строк × 2 burst'а (256 + 64 байта) = 512.
* W3-naive: вызывающий обрамляет begin/end.
* 320 вертикальных Fill-burst'ов (по колонке 256 строк), Port_Y=0.
* Register-only asm, без глобального скретча. W3-naive: вызывающий
* обрамляет _bgi_begin/_bgi_end. color → A (__sdcccall(1)).
*/
#include "../_bgi.h"
void _bgi_clear_raw(uint8_t color)
void _bgi_clear_raw(uint8_t color) __naked
{
_gfx_acc_color = color;
for (int y = 0; y < GFX_HEIGHT; y++) {
_gfx_acc_y = (uint8_t)y;
_gfx_acc_addr = _gfx_addr_base; /* burst 256 байт */
_gfx_acc_len = 0;
_gfx_hfill256_chunk();
_gfx_acc_addr = (uint16_t)(_gfx_addr_base + 256); /* burst 64 байта */
_gfx_acc_len = 64;
_gfx_hfill256_chunk();
}
__asm
ld c, a ; color -> c
xor a, a
out (#0x89), a ; Port_Y = 0
ld hl, (__gfx_addr_base) ; HL = база draw-страницы (0xC000/0xC140)
ld de, #0x0000
_clear_cyc0:
ld a, e ; if DE >= 320 - return
sub a, #0x40
ld a, d
sbc a, #0x01
ret NC
;; --- ПОСЛЕДОВАТЕЛЬНОСТЬ АКСЕЛЕРАТОРА ---
di
ld d, d ; 0x52 — режим размера блока
ld a, #0 ; 0x3E 0 — размер (256 точек по высоте)
ld e, e ; 0x5B — вертикальный Fill
ld a, c ; 0x79 — A = цвет (НЕ ещё один ld a,#n)
ld (hl), a ; выстрел; заливает _gfx_acc_len байт
ld b, b ; 0x40 — выключить
ei
inc hl
inc de
jr _clear_cyc0
__endasm;
}
libbgi/bgi256/_bgi_hspan_raw.c
+59 -21
View File
@@ -1,28 +1,66 @@
/*
* _bgi_hspan_raw — горизонтальная линия len пикселей от (x,y),
* mode 0x81, через Fill-burst'ы акселератора (до 256 байт за выстрел).
* W3-naive: вызывающий обрамляет begin/end.
* _bgi_hspan_raw — горизонтальная линия len пикселей от (x,y), mode 0x81,
* через Fill-burst'ы акселератора (до 256 байт за выстрел). W3-naive:
* вызывающий обрамляет _bgi_begin/_bgi_end.
*
* __sdcccall(1): x→HL, y→DE(E=y), len→стек(4/5(ix)), color→стек(6(ix)).
* Значения передаются в _gfx_hfill256_segment через регистры (HL=addr,
* C=color, B=len, E=y) — без глобального скретча. len>256 (макс. ширина
* 320) → два burst'а: хвост (len-256) на addr+256, затем 256 на addr;
* усечение len до байта даёт (len-256) для 257..320 (256 -> 0 = «256»).
*/
#include "../_bgi.h"
void _bgi_hspan_raw(int x, int y, int len, uint8_t color)
void _bgi_hspan_raw(int x, int y, int len, uint8_t color) __naked
{
if ((unsigned)y >= GFX_HEIGHT) return;
if (x < 0) { len += x; x = 0; }
if (x >= GFX_WIDTH) return;
if (x + len > GFX_WIDTH) len = GFX_WIDTH - x;
if (len <= 0) return;
_gfx_acc_color = color;
_gfx_acc_y = (uint8_t)y;
_gfx_acc_addr = (uint16_t)(_gfx_addr_base + (unsigned)x);
while (len > 0) {
int chunk = len > 256 ? 256 : len;
_gfx_acc_len = (chunk == 256) ? 0 : (uint8_t)chunk;
_gfx_hfill256_chunk();
len -= chunk;
_gfx_acc_addr += chunk;
}
__asm
.globl __gfx_addr_base
.globl __gfx_hfill256_segment
push ix
ld ix, #0
add ix, sp
#ifndef GFX_NOCHECK
ld a, d
or a, a
jr NZ, hs_ret ; (unsigned)y >= 256
ld a, l
sub a, #0x40
ld a, h
sbc a, #0x01
jr NC, hs_ret ; (unsigned)x >= 320
#endif
ld c, l
ld b, h ; BC = x
ld hl, (__gfx_addr_base)
add hl, bc ; HL = base + x
ld a, 6 (ix)
ld c, a ; C = color
ld a, 5 (ix)
or a, a
jr Z, hs_single ; len < 256
ld a, 4 (ix)
or a, a
jr Z, hs_single ; len == 256 (B=0)
;; 257..320: два burst-a
push hl ; base addr
inc h ; addr + 256
ld a, 4 (ix)
ld b, a ; B = len-256 (низкий байт)
call __gfx_hfill256_segment
pop hl ; base addr
ld b, #0 ; 256
call __gfx_hfill256_segment
jr hs_ret
hs_single:
ld a, 4 (ix)
ld b, a ; B = len (0 если ==256)
call __gfx_hfill256_segment
hs_ret:
pop ix
pop hl
pop af
inc sp
jp (hl)
__endasm;
}
libbgi/bgi256/_bgi_plot_raw.c
+36 -19
View File
@@ -1,30 +1,47 @@
/*
* _bgi_plot_raw — пиксель (x,y) цветом color, mode 0x81.
* _bgi_plot_raw — пиксель (x,y) цветом color, mode 0x81 (register-only asm).
*
* "Raw" = W3-naive: вызывающий уже сделал _gfx_w3_video_begin (W3 на
* видеобанке, DI). Адресация: CPU _gfx_addr_base + x, Port_Y (0x89) = y.
* "Raw" = W3-naive: вызывающий уже сделал _bgi_begin (W3 на видеобанке, DI).
* Адресация: CPU _gfx_addr_base + x, Port_Y (0x89) = y.
*
* Скретч отдельный от _gfx_acc_* — чтобы putpixel внутри цикла
* Брезенхэма не топтал внешнее состояние акселератора.
* __sdcccall(1): x→HL, y→DE (E=low), color→стек (1 байт над ret-адресом).
* Всё считается в регистрах — ни статик-скретча, ни round-trip через _DATA
* (самый горячий примитив: Брезенхэм в line/circle/fillpoly/draw_scaled).
*/
#include "../_bgi.h"
static uint8_t _gfx_pp_y;
static uint16_t _gfx_pp_addr;
static uint8_t _gfx_pp_color;
void _bgi_plot_raw(int x, int y, uint8_t color)
void _bgi_plot_raw(int x, int y, uint8_t color) __naked
{
if ((unsigned)x >= GFX_WIDTH || (unsigned)y >= GFX_HEIGHT) return;
_gfx_pp_y = (uint8_t)y;
_gfx_pp_addr = (uint16_t)(_gfx_addr_base + (unsigned)x);
_gfx_pp_color = color;
__asm
ld a, (__gfx_pp_y)
out (#0x89), a
ld hl, (__gfx_pp_addr)
ld a, (__gfx_pp_color)
ld (hl), a
.globl __gfx_addr_base
#ifndef GFX_NOCHECK
ld a, l
sub a, #0x40
ld a, h
sbc a, #0x01
jr NC, pp_done ; (unsigned)x >= 320
ld a, d
or a, a
jr NZ, pp_done ; (unsigned)y >= 256
#endif
ld a, e
out (#0x89), a ; Port_Y = y
ld bc, (__gfx_addr_base)
add hl, bc ; HL = base + x
ld c, l
ld b, h ; BC = dest
ld hl, #2
add hl, sp
ld a, (hl) ; A = color (со стека, SP+2)
ld h, b
ld l, c ; HL = dest
ld (hl), a ; выстрел
#ifndef GFX_NOCHECK
pp_done:
#endif
pop hl ; ret-адрес
inc sp ; callee-pop байта color
jp (hl)
__endasm;
}
libbgi/bgi256/_bgi_read_raw.c
+31 -17
View File
@@ -1,27 +1,41 @@
/*
* _bgi_read_raw — прочитать пиксель (x,y) БЕЗ своей W3-скобки
* (вызывающий уже сделал _gfx_w3_video_begin). Для блиттинга image:
* getimage/putimage читают тысячи пикселей в одной скобке.
* _bgi_read_raw — прочитать пиксель (x,y), mode 0x81 (register-only asm).
*
* "Raw" = W3-naive: вызывающий уже сделал _bgi_begin (W3 на видеобанке, DI).
* Для блиттинга: getimage/putimage читают тысячи пикселей в одной скобке.
* За пределами экрана возвращает 0.
*
* __sdcccall(1): x→HL, y→DE (E=low); возврат uint8_t в A. Всё в регистрах,
* без статик-скретча (единый стиль с _bgi_plot_raw).
*/
#include "../_bgi.h"
static uint8_t _gfx_gpr_y;
static uint16_t _gfx_gpr_addr;
static uint8_t _gfx_gpr_color;
uint8_t _bgi_read_raw(int x, int y)
uint8_t _bgi_read_raw(int x, int y) __naked
{
if ((unsigned)x >= GFX_WIDTH || (unsigned)y >= GFX_HEIGHT) return 0;
_gfx_gpr_y = (uint8_t)y;
_gfx_gpr_addr = (uint16_t)(_gfx_addr_base + (unsigned)x);
(void)x; (void)y;
__asm
ld a, (__gfx_gpr_y)
out (#0x89), a
ld hl, (__gfx_gpr_addr)
ld a, (hl)
ld (__gfx_gpr_color), a
.globl __gfx_addr_base
#ifndef GFX_NOCHECK
ld a, l
sub a, #0x40
ld a, h
sbc a, #0x01
jr NC, rr_zero ; (unsigned)x >= 320
ld a, d
or a, a
jr NZ, rr_zero ; (unsigned)y >= 256
#endif
ld a, e
out (#0x89), a ; Port_Y = y
ld bc, (__gfx_addr_base)
add hl, bc ; HL = base + x
ld a, (hl) ; A = пиксель (возврат)
ret
#ifndef GFX_NOCHECK
rr_zero:
xor a, a
ret
#endif
__endasm;
return _gfx_gpr_color;
}
libbgi/bgi256/_bgi_vspan_raw.c
+76 -41
View File
@@ -1,50 +1,85 @@
/*
* _bgi_vspan_raw — вертикальная линия len пикселей от (x,y),
* mode 0x81. Вертикальный Fill акселератора сам инкрементирует Port_Y,
* так что вся колонка (высота 256) — один burst. W3-naive.
* _bgi_vspan_raw — вертикальная линия len пикселей от (x,y), mode 0x81,
* через Vertical Fill акселератора (один burst = колонка до 256 строк).
* W3-naive: вызывающий обрамляет _bgi_begin/_bgi_end.
*
* __sdcccall(1): x→HL, y→DE(E=y), len→стек(4/5(ix)), color→стек(6(ix)).
* В _gfx_vfill256_segment передаём HL=addr, C=color, B=len, E=y (без
* глобального скретча). x держим в BC на время клипа (clip портит HL/DE),
* адрес считаем в конце. len усекается до байта: 256 -> 0 = «256».
*/
#include "../_bgi.h"
/* Вертикальный Fill: _gfx_acc_len пикселей в колонке _gfx_acc_addr,
* верхняя строка _gfx_acc_y. Про SMC и правила FSM акселератора —
* см. _gfx_hfill256.c. */
static void vfill_chunk(void) __naked
void _bgi_vspan_raw(int x, int y, int len, uint8_t color) __naked
{
__asm
ld a, (__gfx_acc_len)
ld (_vfill256_len_imm), a
ld a, (__gfx_acc_y)
out (#0x89), a ; стартовый Y
ld a, (__gfx_acc_color)
ld c, a
ld hl, (__gfx_acc_addr)
ld d, d ; 0x52 — режим размера блока
ld a, #0 ; immediate-длина (патчится)
_vfill256_len_imm = . - 1
ld e, e ; 0x5B — вертикальный Fill
ld a, c ; A = цвет
ld (hl), a ; выстрел
ld b, b ; 0x40 — выключить
ret
.globl __gfx_addr_base
.globl __gfx_vfill256_segment
push ix
ld ix, #0
add ix, sp
#ifndef GFX_NOCHECK
ld a, l
sub a, #0x40
ld a, h
sbc a, #0x01
jr NC, vs_ret ; (unsigned)x >= 320
#endif
ld c, l
ld b, h ; BC = x (пережить клип)
#ifndef GFX_NOCHECK
bit 7, d
jr Z, vs_ypos
;; y < 0: len += y ; y = 0
ld l, 4 (ix)
ld h, 5 (ix)
add hl, de ; len + y (y отрицателен)
ld 4 (ix), l
ld 5 (ix), h
ld de, #0
vs_ypos:
ld a, d
or a, a
jr NZ, vs_ret ; y >= 256
;; y + len > 256 ? -> len = 256 - y
ld l, 4 (ix)
ld h, 5 (ix)
add hl, de ; y + len (D=0)
ld a, h
or a, a
jr Z, vs_lenchk ; < 256
dec a
jr NZ, vs_clamp ; high >= 2
ld a, l
or a, a
jr Z, vs_lenchk ; == 256
vs_clamp:
xor a, a
sub a, e ; 0 - y (низкий байт)
ld 4 (ix), a
ld a, #1
sbc a, #0 ; 1 - borrow => 256 - y
ld 5 (ix), a
vs_lenchk:
ld a, 4 (ix)
or a, 5 (ix)
jr Z, vs_ret ; len == 0
bit 7, 5 (ix)
jr NZ, vs_ret ; len < 0
#endif
ld hl, (__gfx_addr_base)
add hl, bc ; HL = base + x
ld a, 6 (ix)
ld c, a ; C = color
ld a, 4 (ix)
ld b, a ; B = len (256 -> 0)
call __gfx_vfill256_segment
vs_ret:
pop ix
pop hl
pop af
inc sp
jp (hl)
__endasm;
}
void _bgi_vspan_raw(int x, int y, int len, uint8_t color)
{
if ((unsigned)x >= GFX_WIDTH) return;
if (y < 0) { len += y; y = 0; }
if (y >= GFX_HEIGHT) return;
if (y + len > GFX_HEIGHT) len = GFX_HEIGHT - y;
if (len <= 0) return;
/* GFX_HEIGHT = 256, полная колонка — один accel-burst. */
_gfx_acc_color = color;
_gfx_acc_y = (uint8_t)y;
_gfx_acc_addr = (uint16_t)(_gfx_addr_base + (unsigned)x);
_gfx_acc_len = (len == 256) ? 0 : (uint8_t)len;
vfill_chunk();
}
libbgi/bgi256/_gfx_acc256.c
-12
View File
@@ -1,12 +0,0 @@
/*
* _gfx_acc256 — скретч акселератора для 256-цветных raw-примитивов
* (модуль только с данными). Общий для hline/vline/clear; однопоточно —
* GFX работает с выключенными прерываниями между W3-begin/end.
*/
#include "../_bgi.h"
uint8_t _gfx_acc_color;
uint8_t _gfx_acc_y;
uint8_t _gfx_acc_len; /* 0 = 256 — конвенция акселератора */
uint16_t _gfx_acc_addr;
libbgi/bgi256/_gfx_hfill256.c
+28 -30
View File
@@ -1,45 +1,43 @@
/*
* _gfx_hfill256_chunk — горизонтальный Fill-burst акселератора:
* _gfx_acc_len байт цвета _gfx_acc_color с адреса _gfx_acc_addr на
* строке _gfx_acc_y. Pre: W3 замаплен на видеобанк, DI активен.
* _gfx_hfill256_segment — горизонтальный Fill-burst акселератора (register-ABI).
*
* Опкоды акселератора (docs/converted/accel_r.txt):
* ВХОД (регистры; вызывается ТОЛЬКО из asm — raw-примитивами):
* HL = CPU-адрес начала строки (base + x)
* C = цвет
* B = длина (0 = 256 — конвенция акселератора)
* E = y (строка для Port_Y)
* Клоббер: A, F. Сохраняет BC/DE/HL/IX/IY — все опкоды акселератора это
* `ld r,r`, т.е. no-op'ы по регистрам, поэтому color(C)/len(B)/y(E) переживают
* accel-последовательность (это и есть смысл register-ABI — без скретча в _DATA).
* Pre: W3 замаплен на видеобанк (вызывающий сделал _bgi_begin).
*
* Опкоды (docs/converted/accel_r.txt):
* LD D,D (0x52) режим «задать размер блока»; СЛЕДУЮЩИЙ байт — длина,
* ОБЯЗАН быть immediate-операндом LD A,n (0x3E)
* ОБЯЗАН быть immediate-операндом LD A,n (0x3E) → SMC-патч.
* LD C,C (0x49) горизонтальный Fill (LD (HL),A заливает n байт)
* LD B,B (0x40) выключить акселератор
*
* Байт длины патчится SMC — HOME после загрузки DSS это RAM, патчить
* собственный .EXE безопасно. Вставлять другой `ld a,#n` между LD C,C
* и стреляющим LD (HL),A нельзя — FSM акселератора перечитает immediate
* как новый размер блока.
* Другой `ld a,#n` между LD C,C и стреляющим LD (HL),A вставлять нельзя —
* FSM акселератора перечитает immediate как новый размер блока.
*/
#include "../_bgi.h"
void _gfx_hfill256_chunk(void) __naked
void _gfx_hfill256_segment(void) __naked
{
__asm
;; Пропатчить immediate LD A,#n байтом длины.
ld a, (__gfx_acc_len)
ld (_hfill256_len_imm), a
ld a, (__gfx_acc_y)
out (#0x89), a ; Port_Y = y
;; Цвет в C и адрес в HL готовим ДО взведения акселератора.
ld a, (__gfx_acc_color)
ld c, a
ld hl, (__gfx_acc_addr)
;; --- ПОСЛЕДОВАТЕЛЬНОСТЬ АКСЕЛЕРАТОРА ---
ld d, d ; 0x52 — режим размера блока
ld a, #0 ; 0x3E nn — размер (nn патчится выше)
ld a, b
ld (_hfill256_len_imm), a ; SMC: размер блока <- B
ld a, e
out (#0x89), a ; Port_Y <- E (y)
di
ld d, d ; 0x52 — режим размера блока
ld a, #0
_hfill256_len_imm = . - 1
ld c, c ; 0x49 — горизонтальный Fill
ld a, c ; 0x79 — A = цвет (НЕ ещё один ld a,#n)
ld (hl), a ; выстрел; заливает _gfx_acc_len байт
ld b, b ; 0x40 — выключить
ld c, c ; 0x49 — горизонтальный Fill (C=color, no-op)
ld a, c ; 0x79 — A = цвет
ld (hl), a ; выстрел; заливает len байт
ld b, b ; 0x40 — выключить (B=len, no-op)
ei
ret
__endasm;
}
libbgi/bgi256/_gfx_rectfill256.c
+91
View File
@@ -0,0 +1,91 @@
/*
* _gfx_rectfill256 — заливка прямоугольника (x,y,w,h) цветом color, mode 0x81.
*
* Выбор ориентации burst'а: если w>h и w<=256 — гоним h горизонтальных
* Fill'ов шириной w (y++ на каждой строке); иначе w вертикальных Fill'ов
* высотой h (addr++ на каждой колонке). Инварианты (color=C, len=B) и
* бегущий addr=HL/y=E живут в регистрах через весь цикл — _gfx_*_segment
* их сохраняет; счётчик другой размерности крутится в его стек-слоте.
*
* __sdcccall(1): x→HL, y→DE(E=y); w→4/5(ix), h→6/7(ix), color→8(ix).
* Pre: W3 замаплен, DI активен вокруг выстрелов внутри segment'ов.
* Вызывающий управляет _bgi_begin/_bgi_end. w,h предполагаются >= 0.
*/
#include "../_bgi.h"
void _gfx_rectfill256(int x, int y, int w, int h, uint8_t color) __naked
{
__asm
.globl __gfx_addr_base
.globl __gfx_hfill256_segment
.globl __gfx_vfill256_segment
push ix
ld ix, #0
add ix, sp
ld bc, (__gfx_addr_base)
add hl, bc ; HL = base + x (бегущий addr)
ld a, 8 (ix)
ld c, a ; C = color
;; --- ветка: w>h && w<=256 ? (unsigned, w/h >= 0) ---
ld a, 4 (ix)
sub a, 6 (ix)
ld b, a ; (w-h) низкий
ld a, 5 (ix)
sbc a, 7 (ix) ; CF=1 если w<h
jr C, rf_vbranch
or a, b
jr Z, rf_vbranch ; w==h -> не (w>h)
ld a, 5 (ix) ; w high
cp a, #2
jr NC, rf_vbranch ; w >= 512
dec a
jr NZ, rf_hbranch ; high==0 -> w<256
ld a, 4 (ix)
or a, a
jr NZ, rf_vbranch ; high==1,low!=0 -> w>256
rf_hbranch:
ld a, 4 (ix)
ld b, a ; B = len = w (256 -> 0)
rf_hloop:
ld a, 6 (ix)
or a, 7 (ix)
jr Z, rf_done ; h == 0
call __gfx_hfill256_segment
inc e ; y++
ld a, 6 (ix)
sub a, #1
ld 6 (ix), a
ld a, 7 (ix)
sbc a, #0
ld 7 (ix), a
jr rf_hloop
rf_vbranch:
ld a, 6 (ix)
ld b, a ; B = len = h (256 -> 0)
rf_vloop:
ld a, 4 (ix)
or a, 5 (ix)
jr Z, rf_done ; w == 0
call __gfx_vfill256_segment
inc hl ; addr++
ld a, 4 (ix)
sub a, #1
ld 4 (ix), a
ld a, 5 (ix)
sbc a, #0
ld 5 (ix), a
jr rf_vloop
rf_done:
pop ix
pop hl
pop af
pop af
inc sp
jp (hl)
__endasm;
}
libbgi/bgi256/_gfx_vfill256.c
+36
View File
@@ -0,0 +1,36 @@
/*
* _gfx_vfill256_segment — вертикальный Fill-burst акселератора (register-ABI).
*
* ВХОД (регистры; вызывается ТОЛЬКО из asm — raw-примитивами):
* HL = CPU-адрес колонки (base + x)
* C = цвет
* B = длина (0 = 256 — конвенция акселератора)
* E = y (стартовая строка для Port_Y)
* Клоббер: A, F. Сохраняет BC/DE/HL/IX/IY (все accel-опкоды — no-op'ы по
* регистрам; см. _gfx_hfill256.c). Pre: W3 замаплен (вызывающий сделал _bgi_begin).
*
* Опкоды: LD D,D (0x52) размер блока (SMC-immediate), LD E,E (0x5B)
* вертикальный Fill, LD B,B (0x40) выключить.
*/
#include "../_bgi.h"
void _gfx_vfill256_segment(void) __naked
{
__asm
ld a, b
ld (_vfill256_len_imm), a ; SMC: размер блока <- B
ld a, e
out (#0x89), a ; Port_Y <- E (y)
di
ld d, d ; 0x52 — режим размера блока
ld a, #0
_vfill256_len_imm = . - 1
ld e, e ; 0x5B — вертикальный Fill (E=y, no-op)
ld a, c ; 0x79 — A = цвет
ld (hl), a ; выстрел; заливает len байт
ld b, b ; 0x40 — выключить (B=len, no-op)
ei
ret
__endasm;
}
libbgi/bgi256/getpixel.c
+24 -18
View File
@@ -9,25 +9,31 @@ static uint8_t _gp_y;
static uint16_t _gp_addr;
static uint8_t _gp_color;
unsigned getpixel(int x, int y)
color_t getpixel(int x, int y)
{
#ifndef GFX_NOCHECK
if ((unsigned)x >= GFX_WIDTH || (unsigned)y >= GFX_HEIGHT) return 0;
_gp_y = (uint8_t)y;
_gp_addr = (uint16_t)(_gfx_addr_base + (unsigned)x);
__asm
di
in a, (#0xE2)
ld (__gfx_saved_w3), a
ld a, (__gfx_bank)
out (#0xE2), a
ld a, (_gp_y)
out (#0x89), a
ld hl, (_gp_addr)
ld a, (hl)
ld (_gp_color), a
ld a, (__gfx_saved_w3)
out (#0xE2), a
ei
__endasm;
#endif
_bgi_begin();
register uint8_t _gp_color = _bgi_read_raw(x, y);
_bgi_end();
return _gp_color;
// _gp_y = (uint8_t)y;
// _gp_addr = (uint16_t)(_gfx_addr_base + (unsigned)x);
// __asm
// di
// in a, (#0xE2)
// ld (__gfx_saved_w3), a
// ld a, (__gfx_bank)
// out (#0xE2), a
// ld a, (_gp_y)
// out (#0x89), a
// ld hl, (_gp_addr)
// ld a, (hl)
// ld (_gp_color), a
// ld a, (__gfx_saved_w3)
// out (#0xE2), a
// ei
// __endasm;
// return _gp_color;
}
libbgi/bgi256/putpixel.c
+25 -19
View File
@@ -15,25 +15,31 @@ static uint8_t _pp_y;
static uint16_t _pp_addr;
static uint8_t _pp_color;
void putpixel(int x, int y, int color)
void putpixel(int x, int y, color_t color)
{
#ifndef GFX_NOCHECK
if ((unsigned)x >= GFX_WIDTH || (unsigned)y >= GFX_HEIGHT) return;
_pp_y = (uint8_t)y;
_pp_addr = (uint16_t)(_gfx_addr_base + (unsigned)x);
_pp_color = (uint8_t)color;
__asm
di
in a, (#0xE2)
ld (__gfx_saved_w3), a
ld a, (__gfx_bank)
out (#0xE2), a
ld a, (_pp_y)
out (#0x89), a
ld hl, (_pp_addr)
ld a, (_pp_color)
ld (hl), a
ld a, (__gfx_saved_w3)
out (#0xE2), a
ei
__endasm;
#endif
_bgi_begin();
_bgi_plot_raw(x, y, color);
_bgi_end();
return;
// _pp_y = (uint8_t)y;
// _pp_addr = (uint16_t)(_gfx_addr_base + (unsigned)x);
// _pp_color = (uint8_t)color;
// __asm
// di
// in a, (#0xE2)
// ld (__gfx_saved_w3), a
// ld a, (__gfx_bank)
// out (#0xE2), a
// ld a, (_pp_y)
// out (#0x89), a
// ld hl, (_pp_addr)
// ld a, (_pp_color)
// ld (hl), a
// ld a, (__gfx_saved_w3)
// out (#0xE2), a
// ei
// __endasm;
}