github.com/captain-amygdala.pistorm
1
0
Fork 0
mirror of https://github.com/captain-amygdala/pistorm.git synced 2026-04-16 00:20:51 +00:00
Code Issues Projects Releases Wiki Activity

New PiGFX color format handling, probably needs testing

Browse Source
This commit is contained in:
beeanyew
2021-11-06 12:25:07 +01:00
parent e0b2298415
commit 0ef7de3c69
9 changed files with 343 additions and 227 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
platforms/amiga/rtg/argbswizzle.shader
View File

@@ -14,5 +14,5 @@ void main()
{
vec4 texelColor = texture2D(texture0, fragTexCoord);
gl_FragColor = vec4(texelColor.b, texelColor.g, texelColor.r, 1.0);
gl_FragColor = vec4(texelColor.g, texelColor.b, texelColor.a, 1.0);
}

18
platforms/amiga/rtg/bgraswizzle.shader Normal file
View File

@@ -0,0 +1,18 @@
#version 100
precision mediump float;
varying vec2 fragTexCoord;
varying vec4 fragColor;
uniform sampler2D texture0;
uniform sampler2D texture1;
uniform vec4 colDiffuse;
void main()
{
vec4 texelColor = texture2D(texture0, fragTexCoord);
gl_FragColor = vec4(texelColor.b, texelColor.g, texelColor.r, 1.0);
}

258
platforms/amiga/rtg/rtg-gfx.c
View File

@@ -25,15 +25,16 @@ extern uint32_t framebuffer_addr_adj;
extern uint8_t realtime_graphics_debug;
void rtg_fillrect_solid(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint32_t color, uint16_t pitch, uint16_t format) {
uint8_t *dptr = &rtg_mem[rtg_address_adj[0] + (x << format) + (y * pitch)];
uint8_t *dptr = &rtg_mem[rtg_address_adj[0] + (x * rtg_pixel_size[format]) + (y * pitch)];
switch(format) {
case RTGFMT_8BIT: {
case RTGFMT_8BIT_CLUT: {
for (int xs = 0; xs < w; xs++) {
dptr[xs] = color & 0xFF;
}
break;
}
case RTGFMT_RBG565: {
case RTGFMT_RGB565_LE: case RTGFMT_RGB565_BE: case RTGFMT_BGR565_LE:
case RTGFMT_RGB555_LE: case RTGFMT_RGB555_BE: case RTGFMT_BGR555_LE: {
color = htobe16((color & 0xFFFF));
uint16_t *ptr = (uint16_t *)dptr;
for (int xs = 0; xs < w; xs++) {
@@ -41,7 +42,8 @@ void rtg_fillrect_solid(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint32_t
}
break;
}
case RTGFMT_RGB32: {
case RTGFMT_RGB32_ABGR: case RTGFMT_RGB32_ARGB:
case RTGFMT_RGB32_BGRA: case RTGFMT_RGB32_RGBA: {
color = htobe32(color);
uint32_t *ptr = (uint32_t *)dptr;
for (int xs = 0; xs < w; xs++) {
@@ -52,16 +54,16 @@ void rtg_fillrect_solid(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint32_t
}
for (int ys = 1; ys < h; ys++) {
dptr += pitch;
memcpy(dptr, (void *)(size_t)(dptr - pitch), (w << format));
memcpy(dptr, (void *)(size_t)(dptr - pitch), (w * rtg_pixel_size[format]));
}
}
void rtg_fillrect(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint32_t color, uint16_t pitch, uint16_t format, uint8_t mask) {
uint8_t *dptr = &rtg_mem[rtg_address_adj[0] + (x << format) + (y * pitch)];
uint8_t *dptr = &rtg_mem[rtg_address_adj[0] + (x * rtg_pixel_size[format]) + (y * pitch)];
for (int ys = 0; ys < h; ys++) {
for (int xs = 0; xs < w; xs++) {
SET_RTG_PIXEL_MASK(&dptr[xs << format], (color & 0xFF), format);
SET_RTG_PIXEL_MASK(&dptr[xs * rtg_pixel_size[format]], (color & 0xFF), format);
}
dptr += pitch;
}
@@ -69,22 +71,24 @@ void rtg_fillrect(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint32_t color
void rtg_invertrect(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint16_t pitch, uint16_t format, uint8_t mask) {
if (mask) {}
uint8_t *dptr = &rtg_mem[rtg_address_adj[0] + (x << format) + (y * pitch)];
uint8_t *dptr = &rtg_mem[rtg_address_adj[0] + (x * rtg_pixel_size[format]) + (y * pitch)];
for (int ys = 0; ys < h; ys++) {
switch(format) {
case RTGFMT_8BIT: {
case RTGFMT_8BIT_CLUT: {
for (int xs = 0; xs < w; xs++) {
dptr[xs] ^= mask;
}
break;
}
case RTGFMT_RBG565: {
case RTGFMT_RGB565_LE: case RTGFMT_RGB565_BE: case RTGFMT_BGR565_LE:
case RTGFMT_RGB555_LE: case RTGFMT_RGB555_BE: case RTGFMT_BGR555_LE: {
for (int xs = 0; xs < w; xs++) {
((uint16_t *)dptr)[xs] = ~((uint16_t *)dptr)[xs];
}
break;
}
case RTGFMT_RGB32: {
case RTGFMT_RGB32_ABGR: case RTGFMT_RGB32_ARGB:
case RTGFMT_RGB32_BGRA: case RTGFMT_RGB32_RGBA: {
for (int xs = 0; xs < w; xs++) {
((uint32_t *)dptr)[xs] = ~((uint32_t *)dptr)[xs];
}
@@ -97,8 +101,8 @@ void rtg_invertrect(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint16_t pit
void rtg_blitrect(uint16_t x, uint16_t y, uint16_t dx, uint16_t dy, uint16_t w, uint16_t h, uint16_t pitch, uint16_t format, uint8_t mask) {
if (mask) {}
uint8_t *sptr = &rtg_mem[rtg_address_adj[0] + (x << format) + (y * pitch)];
uint8_t *dptr = &rtg_mem[rtg_address_adj[0] + (dx << format) + (dy * pitch)];
uint8_t *sptr = &rtg_mem[rtg_address_adj[0] + (x * rtg_pixel_size[format]) + (y * pitch)];
uint8_t *dptr = &rtg_mem[rtg_address_adj[0] + (dx * rtg_pixel_size[format]) + (dy * pitch)];
uint32_t xdir = 1, pitchstep = pitch;
@@ -128,8 +132,8 @@ void rtg_blitrect(uint16_t x, uint16_t y, uint16_t dx, uint16_t dy, uint16_t w,
}
void rtg_blitrect_solid(uint16_t x, uint16_t y, uint16_t dx, uint16_t dy, uint16_t w, uint16_t h, uint16_t pitch, uint16_t format) {
uint8_t *sptr = &rtg_mem[rtg_address_adj[0] + (x << format) + (y * pitch)];
uint8_t *dptr = &rtg_mem[rtg_address_adj[0] + (dx << format) + (dy * pitch)];
uint8_t *sptr = &rtg_mem[rtg_address_adj[0] + (x * rtg_pixel_size[format]) + (y * pitch)];
uint8_t *dptr = &rtg_mem[rtg_address_adj[0] + (dx * rtg_pixel_size[format]) + (dy * pitch)];
uint32_t xdir = 1, pitchstep = pitch;
@@ -144,9 +148,9 @@ void rtg_blitrect_solid(uint16_t x, uint16_t y, uint16_t dx, uint16_t dy, uint16
for (int ys = 0; ys < h; ys++) {
if (xdir)
memcpy(dptr, sptr, w << format);
memcpy(dptr, sptr, w * rtg_pixel_size[format]);
else
memmove(dptr, sptr, w << format);
memmove(dptr, sptr, w * rtg_pixel_size[format]);
sptr += pitchstep;
dptr += pitchstep;
}
@@ -154,8 +158,8 @@ void rtg_blitrect_solid(uint16_t x, uint16_t y, uint16_t dx, uint16_t dy, uint16
void rtg_blitrect_nomask_complete(uint16_t sx, uint16_t sy, uint16_t dx, uint16_t dy, uint16_t w, uint16_t h, uint16_t srcpitch, uint16_t dstpitch, uint32_t src_addr, uint32_t dst_addr, uint16_t format, uint8_t minterm) {
if (minterm) {}
uint8_t *sptr = &rtg_mem[src_addr - (PIGFX_RTG_BASE + PIGFX_REG_SIZE) + (sx << format) + (sy * srcpitch)];
uint8_t *dptr = &rtg_mem[dst_addr - (PIGFX_RTG_BASE + PIGFX_REG_SIZE) + (dx << format) + (dy * dstpitch)];
uint8_t *sptr = &rtg_mem[src_addr - (PIGFX_RTG_BASE + PIGFX_REG_SIZE) + (sx * rtg_pixel_size[format]) + (sy * srcpitch)];
uint8_t *dptr = &rtg_mem[dst_addr - (PIGFX_RTG_BASE + PIGFX_REG_SIZE) + (dx * rtg_pixel_size[format]) + (dy * dstpitch)];
uint32_t xdir = 1, src_pitchstep = srcpitch, dst_pitchstep = dstpitch;
uint8_t draw_mode = minterm;
@@ -173,17 +177,24 @@ void rtg_blitrect_nomask_complete(uint16_t sx, uint16_t sy, uint16_t dx, uint16_
}
}
if (format == RTGFMT_RBG565)
mask = 0xFFFF;
if (format == RTGFMT_RGB32)
mask = 0xFFFFFFFF;
switch (format) {
case RTGFMT_RGB565_LE: case RTGFMT_RGB565_BE: case RTGFMT_BGR565_LE:
case RTGFMT_RGB555_LE: case RTGFMT_RGB555_BE: case RTGFMT_BGR555_LE:
mask = 0xFFFF;
break;
case RTGFMT_RGB32_ABGR: case RTGFMT_RGB32_ARGB:
case RTGFMT_RGB32_BGRA: case RTGFMT_RGB32_RGBA:
mask = 0xFFFFFFFF;
default:
break;
}
if (minterm == MINTERM_SRC) {
for (int ys = 0; ys < h; ys++) {
if (xdir)
memcpy(dptr, sptr, w << format);
memcpy(dptr, sptr, w * rtg_pixel_size[format]);
else
memmove(dptr, sptr, w << format);
memmove(dptr, sptr, w * rtg_pixel_size[format]);
sptr += src_pitchstep;
dptr += dst_pitchstep;
}
@@ -193,13 +204,15 @@ void rtg_blitrect_nomask_complete(uint16_t sx, uint16_t sy, uint16_t dx, uint16_
if (xdir) {
for (int xs = 0; xs < w; xs++) {
switch (format) {
case RTGFMT_8BIT:
case RTGFMT_8BIT_CLUT:
HANDLE_MINTERM_PIXEL(sptr[xs], dptr[xs], format);
break;
case RTGFMT_RBG565:
case RTGFMT_RGB565_LE: case RTGFMT_RGB565_BE: case RTGFMT_BGR565_LE:
case RTGFMT_RGB555_LE: case RTGFMT_RGB555_BE: case RTGFMT_BGR555_LE:
HANDLE_MINTERM_PIXEL(((uint16_t *)sptr)[xs], ((uint16_t *)dptr)[xs], format);
break;
case RTGFMT_RGB32:
case RTGFMT_RGB32_ABGR: case RTGFMT_RGB32_ARGB:
case RTGFMT_RGB32_BGRA: case RTGFMT_RGB32_RGBA:
HANDLE_MINTERM_PIXEL(((uint32_t *)sptr)[xs], ((uint32_t *)dptr)[xs], format);
break;
}
@@ -208,13 +221,15 @@ void rtg_blitrect_nomask_complete(uint16_t sx, uint16_t sy, uint16_t dx, uint16_
else {
for (int xs = w - 1; xs >= sx; xs--) {
switch (format) {
case RTGFMT_8BIT:
case RTGFMT_8BIT_CLUT:
HANDLE_MINTERM_PIXEL(sptr[xs], dptr[xs], format);
break;
case RTGFMT_RBG565:
case RTGFMT_RGB565_LE: case RTGFMT_RGB565_BE: case RTGFMT_BGR565_LE:
case RTGFMT_RGB555_LE: case RTGFMT_RGB555_BE: case RTGFMT_BGR555_LE:
HANDLE_MINTERM_PIXEL(((uint16_t *)sptr)[xs], ((uint16_t *)dptr)[xs], format);
break;
case RTGFMT_RGB32:
case RTGFMT_RGB32_ABGR: case RTGFMT_RGB32_ARGB:
case RTGFMT_RGB32_BGRA: case RTGFMT_RGB32_RGBA:
HANDLE_MINTERM_PIXEL(((uint32_t *)sptr)[xs], ((uint32_t *)dptr)[xs], format);
break;
}
@@ -229,7 +244,7 @@ void rtg_blitrect_nomask_complete(uint16_t sx, uint16_t sy, uint16_t dx, uint16_
extern struct emulator_config *cfg;
void rtg_blittemplate(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint32_t src_addr, uint32_t fgcol, uint32_t bgcol, uint16_t pitch, uint16_t t_pitch, uint16_t format, uint16_t offset_x, uint8_t mask, uint8_t draw_mode) {
uint8_t *dptr = &rtg_mem[rtg_address_adj[1] + (x << format) + (y * pitch)];
uint8_t *dptr = &rtg_mem[rtg_address_adj[1] + (x * rtg_pixel_size[format]) + (y * pitch)];
uint8_t *sptr = NULL;
uint8_t cur_bit = 0, base_bit = 0, cur_byte = 0;
uint8_t invert = (draw_mode & DRAWMODE_INVERSVID);
@@ -248,16 +263,22 @@ void rtg_blittemplate(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint32_t s
printf("offset_x: %d mask: %.2X draw_mode: %d\n", offset_x, mask, draw_mode);
}
uint32_t fg_color[3] = {
(fgcol & 0xFF),
htobe16((fgcol & 0xFFFF)),
htobe32(fgcol),
};
uint32_t bg_color[3] = {
(bgcol & 0xFF),
htobe16((bgcol & 0xFFFF)),
htobe32(bgcol),
};
uint32_t fg_color = htobe32(fgcol);
uint32_t bg_color = htobe32(bgcol);
switch (format) {
case RTGFMT_RGB565_LE: case RTGFMT_RGB565_BE: case RTGFMT_BGR565_LE:
case RTGFMT_RGB555_LE: case RTGFMT_RGB555_BE: case RTGFMT_BGR555_LE:
htobe16((fgcol & 0xFFFF));
htobe16((bgcol & 0xFFFF));
break;
case RTGFMT_8BIT_CLUT: case RTGFMT_4BIT_PLANAR:
fg_color = (fgcol & 0xFF);
bg_color = (bgcol & 0xFF);
break;
default:
break;
}
sptr = get_mapped_data_pointer_by_address(cfg, src_addr);
if (!sptr) {
@@ -276,22 +297,22 @@ void rtg_blittemplate(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint32_t s
for (int xs = 0; xs < w; xs++) {
TEMPLATE_LOOPX;
if (w >= 8 && cur_bit == 0x80 && xs < w - 8) {
if (mask == 0xFF || format != RTGFMT_8BIT) {
SET_RTG_PIXELS(&dptr[xs << format], fg_color[format], format);
if (mask == 0xFF || format != RTGFMT_8BIT_CLUT) {
SET_RTG_PIXELS(&dptr[xs * rtg_pixel_size[format]], fg_color, format);
}
else {
SET_RTG_PIXELS_MASK(&dptr[xs], fg_color[format], format);
SET_RTG_PIXELS_MASK(&dptr[xs], fg_color, format);
}
xs += 7;
}
else {
while (cur_bit > 0 && xs < w) {
if (cur_byte & cur_bit) {
if (mask == 0xFF || format != RTGFMT_8BIT) {
SET_RTG_PIXEL(&dptr[xs << format], fg_color[format], format);
if (mask == 0xFF || format != RTGFMT_8BIT_CLUT) {
SET_RTG_PIXEL(&dptr[xs * rtg_pixel_size[format]], fg_color, format);
}
else {
SET_RTG_PIXEL_MASK(&dptr[xs], fg_color[format], format);
SET_RTG_PIXEL_MASK(&dptr[xs], fg_color, format);
}
}
xs++;
@@ -309,22 +330,22 @@ void rtg_blittemplate(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint32_t s
for (int xs = 0; xs < w; xs++) {
TEMPLATE_LOOPX;
if (w >= 8 && cur_bit == 0x80 && xs < w - 8) {
if (mask == 0xFF || format != RTGFMT_8BIT) {
SET_RTG_PIXELS2_COND(&dptr[xs << format], fg_color[format], bg_color[format], format);
if (mask == 0xFF || format != RTGFMT_8BIT_CLUT) {
SET_RTG_PIXELS2_COND(&dptr[xs * rtg_pixel_size[format]], fg_color, bg_color, format);
}
else {
SET_RTG_PIXELS2_COND_MASK(&dptr[xs << format], fg_color[format], bg_color[format], format);
SET_RTG_PIXELS2_COND_MASK(&dptr[xs * rtg_pixel_size[format]], fg_color, bg_color, format);
}
xs += 7;
}
else {
while (cur_bit > 0 && xs < w) {
if (mask == 0xFF || format != RTGFMT_8BIT) {
SET_RTG_PIXEL(&dptr[xs << format], (cur_byte & cur_bit) ? fg_color[format] : bg_color[format], format);
if (mask == 0xFF || format != RTGFMT_8BIT_CLUT) {
SET_RTG_PIXEL(&dptr[xs * rtg_pixel_size[format]], (cur_byte & cur_bit) ? fg_color : bg_color, format);
}
else {
SET_RTG_PIXEL_MASK(&dptr[xs << format], (cur_byte & cur_bit) ? fg_color[format] : bg_color[format], format);
SET_RTG_PIXEL_MASK(&dptr[xs * rtg_pixel_size[format]], (cur_byte & cur_bit) ? fg_color : bg_color, format);
}
xs++;
cur_bit >>= 1;
@@ -341,13 +362,13 @@ void rtg_blittemplate(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint32_t s
for (int xs = 0; xs < w; xs++) {
TEMPLATE_LOOPX;
if (w >= 8 && cur_bit == 0x80 && xs < w - 8) {
INVERT_RTG_PIXELS(&dptr[xs << format], format)
INVERT_RTG_PIXELS(&dptr[xs * rtg_pixel_size[format]], format)
xs += 7;
}
else {
while (cur_bit > 0 && xs < w) {
if (cur_byte & cur_bit) {
INVERT_RTG_PIXEL(&dptr[xs << format], format)
INVERT_RTG_PIXEL(&dptr[xs * rtg_pixel_size[format]], format)
}
xs++;
cur_bit >>= 1;
@@ -365,7 +386,7 @@ void rtg_blittemplate(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint32_t s
void rtg_blitpattern(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint32_t src_addr_, uint32_t fgcol, uint32_t bgcol, uint16_t pitch, uint16_t format, uint16_t offset_x, uint16_t offset_y, uint8_t mask, uint8_t draw_mode, uint8_t loop_rows) {
if (mask) {}
uint8_t *dptr = &rtg_mem[rtg_address_adj[1] + (x << format) + (y * pitch)];
uint8_t *dptr = &rtg_mem[rtg_address_adj[1] + (x * rtg_pixel_size[format]) + (y * pitch)];
uint8_t *sptr = NULL, *sptr_base = NULL;
uint8_t cur_bit = 0, base_bit = 0, cur_byte = 0;
uint8_t invert = (draw_mode & DRAWMODE_INVERSVID);
@@ -378,17 +399,22 @@ void rtg_blitpattern(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint32_t sr
tmpl_x = (offset_x / 8) % 2;
cur_bit = base_bit = (0x80 >> (offset_x % 8));
uint32_t fg_color[3] = {
(fgcol & 0xFF),
htobe16((fgcol & 0xFFFF)),
htobe32(fgcol),
};
uint32_t bg_color[3] = {
(bgcol & 0xFF),
htobe16((bgcol & 0xFFFF)),
htobe32(bgcol),
};
uint32_t fg_color = htobe32(fgcol);
uint32_t bg_color = htobe32(bgcol);
switch (format) {
case RTGFMT_RGB565_LE: case RTGFMT_RGB565_BE: case RTGFMT_BGR565_LE:
case RTGFMT_RGB555_LE: case RTGFMT_RGB555_BE: case RTGFMT_BGR555_LE:
htobe16((fgcol & 0xFFFF));
htobe16((bgcol & 0xFFFF));
break;
case RTGFMT_8BIT_CLUT: case RTGFMT_4BIT_PLANAR:
fg_color = (fgcol & 0xFF);
bg_color = (bgcol & 0xFF);
break;
default:
break;
}
sptr = get_mapped_data_pointer_by_address(cfg, src_addr);
if (!sptr) {
@@ -410,22 +436,22 @@ void rtg_blitpattern(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint32_t sr
for (int xs = 0; xs < w; xs++) {
PATTERN_LOOPX;
if (w >= 8 && cur_bit == 0x80 && xs < w - 8) {
if (mask == 0xFF || format != RTGFMT_8BIT) {
SET_RTG_PIXELS(&dptr[xs << format], fg_color[format], format);
if (mask == 0xFF || format != RTGFMT_8BIT_CLUT) {
SET_RTG_PIXELS(&dptr[xs * rtg_pixel_size[format]], fg_color, format);
}
else {
SET_RTG_PIXELS_MASK(&dptr[xs], fg_color[format], format);
SET_RTG_PIXELS_MASK(&dptr[xs], fg_color, format);
}
xs += 7;
}
else {
while (cur_bit > 0 && xs < w) {
if (cur_byte & cur_bit) {
if (mask == 0xFF || format != RTGFMT_8BIT) {
SET_RTG_PIXEL(&dptr[xs << format], fg_color[format], format);
if (mask == 0xFF || format != RTGFMT_8BIT_CLUT) {
SET_RTG_PIXEL(&dptr[xs * rtg_pixel_size[format]], fg_color, format);
}
else {
SET_RTG_PIXEL_MASK(&dptr[xs], fg_color[format], format);
SET_RTG_PIXEL_MASK(&dptr[xs], fg_color, format);
}
}
xs++;
@@ -443,22 +469,22 @@ void rtg_blitpattern(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint32_t sr
for (int xs = 0; xs < w; xs++) {
PATTERN_LOOPX;
if (w >= 8 && cur_bit == 0x80 && xs < w - 8) {
if (mask == 0xFF || format != RTGFMT_8BIT) {
SET_RTG_PIXELS2_COND(&dptr[xs << format], fg_color[format], bg_color[format], format);
if (mask == 0xFF || format != RTGFMT_8BIT_CLUT) {
SET_RTG_PIXELS2_COND(&dptr[xs * rtg_pixel_size[format]], fg_color, bg_color, format);
}
else {
SET_RTG_PIXELS2_COND_MASK(&dptr[xs << format], fg_color[format], bg_color[format], format);
SET_RTG_PIXELS2_COND_MASK(&dptr[xs * rtg_pixel_size[format]], fg_color, bg_color, format);
}
xs += 7;
}
else {
while (cur_bit > 0 && xs < w) {
if (mask == 0xFF || format != RTGFMT_8BIT) {
SET_RTG_PIXEL(&dptr[xs << format], (cur_byte & cur_bit) ? fg_color[format] : bg_color[format], format);
if (mask == 0xFF || format != RTGFMT_8BIT_CLUT) {
SET_RTG_PIXEL(&dptr[xs * rtg_pixel_size[format]], (cur_byte & cur_bit) ? fg_color : bg_color, format);
}
else {
SET_RTG_PIXEL_MASK(&dptr[xs << format], (cur_byte & cur_bit) ? fg_color[format] : bg_color[format], format);
SET_RTG_PIXEL_MASK(&dptr[xs * rtg_pixel_size[format]], (cur_byte & cur_bit) ? fg_color : bg_color, format);
}
xs++;
cur_bit >>= 1;
@@ -475,13 +501,13 @@ void rtg_blitpattern(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint32_t sr
for (int xs = 0; xs < w; xs++) {
PATTERN_LOOPX;
if (w >= 8 && cur_bit == 0x80 && xs < w - 8) {
INVERT_RTG_PIXELS(&dptr[xs << format], format)
INVERT_RTG_PIXELS(&dptr[xs * rtg_pixel_size[format]], format)
xs += 7;
}
else {
while (cur_bit > 0 && xs < w) {
if (cur_byte & cur_bit) {
INVERT_RTG_PIXEL(&dptr[xs << format], format)
INVERT_RTG_PIXEL(&dptr[xs * rtg_pixel_size[format]], format)
}
xs++;
cur_bit >>= 1;
@@ -500,11 +526,19 @@ void rtg_drawline_solid(int16_t x1_, int16_t y1_, int16_t x2_, int16_t y2_, uint
int16_t x1 = x1_, y1 = y1_;
int16_t x2 = x1_ + x2_, y2 = y1 + y2_;
uint32_t fg_color[3] = {
(fgcol & 0xFF),
htobe16((fgcol & 0xFFFF)),
htobe32(fgcol),
};
uint32_t fg_color = htobe32(fgcol);
switch (format) {
case RTGFMT_RGB565_LE: case RTGFMT_RGB565_BE: case RTGFMT_BGR565_LE:
case RTGFMT_RGB555_LE: case RTGFMT_RGB555_BE: case RTGFMT_BGR555_LE:
htobe16((fgcol & 0xFFFF));
break;
case RTGFMT_8BIT_CLUT: case RTGFMT_4BIT_PLANAR:
fg_color = (fgcol & 0xFF);
break;
default:
break;
}
uint8_t *dptr = &rtg_mem[rtg_address_adj[0] + (y1 * pitch)];
@@ -525,7 +559,7 @@ void rtg_drawline_solid(int16_t x1_, int16_t y1_, int16_t x2_, int16_t y2_, uint
ix = dy_abs >> 1;
iy = dx_abs >> 1;
SET_RTG_PIXEL(&dptr[x << format], fg_color[format], format);
SET_RTG_PIXEL(&dptr[x * rtg_pixel_size[format]], fg_color, format);
if (dx_abs >= dy_abs) {
if (!len) len = dx_abs;
@@ -537,7 +571,7 @@ void rtg_drawline_solid(int16_t x1_, int16_t y1_, int16_t x2_, int16_t y2_, uint
}
x += x_step;
SET_RTG_PIXEL(&dptr[x << format], fg_color[format], format);
SET_RTG_PIXEL(&dptr[x * rtg_pixel_size[format]], fg_color, format);
}
}
else {
@@ -550,24 +584,24 @@ void rtg_drawline_solid(int16_t x1_, int16_t y1_, int16_t x2_, int16_t y2_, uint
}
dptr += line_step;
SET_RTG_PIXEL(&dptr[x << format], fg_color[format], format);
SET_RTG_PIXEL(&dptr[x * rtg_pixel_size[format]], fg_color, format);
}
}
}
#define DRAW_LINE_PIXEL \
if (pattern & cur_bit) { \
if (invert) { INVERT_RTG_PIXEL(&dptr[x << format], format) } \
if (invert) { INVERT_RTG_PIXEL(&dptr[x * rtg_pixel_size[format]], format) } \
else { \
if (mask == 0xFF || format != RTGFMT_8BIT) { SET_RTG_PIXEL(&dptr[x << format], fg_color[format], format); } \
else { SET_RTG_PIXEL_MASK(&dptr[x << format], fg_color[format], format); } \
if (mask == 0xFF || format != RTGFMT_8BIT_CLUT) { SET_RTG_PIXEL(&dptr[x * rtg_pixel_size[format]], fg_color, format); } \
else { SET_RTG_PIXEL_MASK(&dptr[x * rtg_pixel_size[format]], fg_color, format); } \
} \
} \
else if (draw_mode == DRAWMODE_JAM2) { \
if (invert) { INVERT_RTG_PIXEL(&dptr[x << format], format) } \
if (invert) { INVERT_RTG_PIXEL(&dptr[x * rtg_pixel_size[format]], format) } \
else { \
if (mask == 0xFF || format != RTGFMT_8BIT) { SET_RTG_PIXEL(&dptr[x << format], bg_color[format], format); } \
else { SET_RTG_PIXEL_MASK(&dptr[x << format], bg_color[format], format); } \
if (mask == 0xFF || format != RTGFMT_8BIT_CLUT) { SET_RTG_PIXEL(&dptr[x * rtg_pixel_size[format]], bg_color, format); } \
else { SET_RTG_PIXEL_MASK(&dptr[x * rtg_pixel_size[format]], bg_color, format); } \
} \
} \
if ((cur_bit >>= 1) == 0) \
@@ -582,16 +616,22 @@ void rtg_drawline (int16_t x1_, int16_t y1_, int16_t x2_, int16_t y2_, uint16_t
//uint32_t color_mask = 0xFFFF0000;
uint8_t invert = 0;
uint32_t fg_color[3] = {
(fgcol & 0xFF),
htobe16((fgcol & 0xFFFF)),
htobe32(fgcol),
};
uint32_t bg_color[3] = {
(bgcol & 0xFF),
htobe16((bgcol & 0xFFFF)),
htobe32(bgcol),
};
uint32_t fg_color = htobe32(fgcol);
uint32_t bg_color = htobe32(bgcol);
switch (format) {
case RTGFMT_RGB565_LE: case RTGFMT_RGB565_BE: case RTGFMT_BGR565_LE:
case RTGFMT_RGB555_LE: case RTGFMT_RGB555_BE: case RTGFMT_BGR555_LE:
htobe16((fgcol & 0xFFFF));
htobe16((bgcol & 0xFFFF));
break;
case RTGFMT_8BIT_CLUT: case RTGFMT_4BIT_PLANAR:
fg_color = (fgcol & 0xFF);
bg_color = (bgcol & 0xFF);
break;
default:
break;
}
uint8_t *dptr = &rtg_mem[rtg_address_adj[0] + (y1 * pitch)];
@@ -714,7 +754,7 @@ void rtg_p2c_ex(int16_t sx, int16_t sy, int16_t dx, int16_t dy, int16_t w, int16
goto skip;
}
HANDLE_MINTERM_PIXEL(u8_fg, dptr[x], RTGFMT_8BIT);
HANDLE_MINTERM_PIXEL(u8_fg, dptr[x], RTGFMT_8BIT_CLUT);
skip:;
if ((cur_bit >>= 1) == 0) {
@@ -859,10 +899,12 @@ void rtg_p2d (int16_t sx, int16_t sy, int16_t dx, int16_t dy, int16_t w, int16_t
if (mask == 0xFF && (draw_mode == MINTERM_SRC || draw_mode == MINTERM_NOTSRC)) {
switch (rtg_format) {
case RTGFMT_RBG565:
case RTGFMT_RGB565_LE: case RTGFMT_RGB565_BE: case RTGFMT_BGR565_LE:
case RTGFMT_RGB555_LE: case RTGFMT_RGB555_BE: case RTGFMT_BGR555_LE:
((uint16_t *)dptr)[x] = (fg_color >> 16);
break;
case RTGFMT_RGB32:
case RTGFMT_RGB32_ABGR: case RTGFMT_RGB32_ARGB:
case RTGFMT_RGB32_BGRA: case RTGFMT_RGB32_RGBA:
((uint32_t *)dptr)[x] = fg_color;
break;
}

61
platforms/amiga/rtg/rtg-output-raylib.c
View File

@@ -40,7 +40,7 @@ uint32_t cur_rtg_frame = 0;
static pthread_t thread_id;
static uint8_t mouse_cursor_enabled = 0, cursor_image_updated = 0;
static uint8_t clut_cursor_enabled = 0, clut_image_updated = 0;
static uint8_t clut_cursor_enabled = 0;
static uint8_t updating_screen = 0, debug_palette = 0, show_fps = 0, palette_updated = 0;
static uint8_t mouse_cursor_w = 16, mouse_cursor_h = 16;
static int16_t mouse_cursor_x = 0, mouse_cursor_y = 0;
@@ -52,7 +52,7 @@ struct rtg_shared_data {
uint16_t *width, *height;
uint16_t *format, *pitch;
uint16_t *offset_x, *offset_y;
volatile uint8_t *memory;
uint8_t *memory;
uint32_t *addr;
uint8_t *running;
};
@@ -73,17 +73,21 @@ uint32_t clut_cursor_texture_data[256 * 256];
void rtg_update_screen() {}
uint32_t rtg_to_raylib[RTGFMT_NUM] = {
PIXELFORMAT_UNCOMPRESSED_GRAYSCALE,
PIXELFORMAT_UNCOMPRESSED_R5G6B5,
PIXELFORMAT_UNCOMPRESSED_R8G8B8A8,
PIXELFORMAT_UNCOMPRESSED_R5G5B5A1,
};
uint32_t rtg_pixel_size[RTGFMT_NUM] = {
1,
2,
4,
2,
PIXELFORMAT_UNCOMPRESSED_GRAYSCALE, // 4BIT_PLANAR,
PIXELFORMAT_UNCOMPRESSED_GRAYSCALE, // 8BIT_CLUT,
PIXELFORMAT_UNCOMPRESSED_R5G6B5, // RGB565_BE,
PIXELFORMAT_UNCOMPRESSED_R5G6B5, // RGB565_LE,
PIXELFORMAT_UNCOMPRESSED_R5G6B5, // BGR565_LE,
PIXELFORMAT_UNCOMPRESSED_R8G8B8, // RGB24,
PIXELFORMAT_UNCOMPRESSED_R8G8B8, // BGR24,
PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, // RGB32_ARGB,
PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, // RGB32_ABGR,
PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, // RGB32_RGBA,
PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, // RGB32_BGRA,
PIXELFORMAT_UNCOMPRESSED_R5G5B5A1, // RGB555_BE,
PIXELFORMAT_UNCOMPRESSED_R5G5B5A1, // RGB555_LE,
PIXELFORMAT_UNCOMPRESSED_R5G5B5A1, // BGR555_LE,
PIXELFORMAT_UNCOMPRESSED_GRAYSCALE, // NONE,
};
void rtg_scale_output(uint16_t width, uint16_t height) {
@@ -201,7 +205,7 @@ void *rtgThread(void *args) {
int reinit = 0, old_filter_mode = -1, force_filter_mode = 0;
rtg_on = 1;
volatile uint32_t *indexed_buf = NULL;
uint32_t *indexed_buf = NULL;
rtg_share_data.format = &rtg_display_format;
rtg_share_data.width = &rtg_display_width;
@@ -233,7 +237,8 @@ void *rtgThread(void *args) {
Color bef = { 0, 64, 128, 255 };
Shader clut_shader = LoadShader(NULL, "platforms/amiga/rtg/clut.shader");
Shader swizzle_shader = LoadShader(NULL, "platforms/amiga/rtg/argbswizzle.shader");
Shader bgra_swizzle_shader = LoadShader(NULL, "platforms/amiga/rtg/bgraswizzle.shader");
Shader argb_swizzle_shader = LoadShader(NULL, "platforms/amiga/rtg/argbswizzle.shader");
int clut_loc = GetShaderLocation(clut_shader, "texture1");
raylib_clut.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
@@ -274,7 +279,8 @@ reinit_raylib:;
raylib_fb.format = rtg_to_raylib[format];
switch (format) {
case RTGFMT_RBG565:
case RTGFMT_RGB565_BE: \
case RTGFMT_RGB555_BE: \
raylib_fb.width = width;
indexed_buf = calloc(1, width * height * 2);
break;
@@ -304,7 +310,7 @@ reinit_raylib:;
}
/* If we are not in 16bit mode then don't use any filtering - otherwise force_filter_mode to no smoothing */
if (force_filter_mode == 0) {
if (format != RTGFMT_RBG565 && filter_mode != 0) {
if (rtg_pixel_size[format] != 2 && filter_mode != 0) {
printf("Turning Smooth filtering off - display mode not 16bit\n");
force_filter_mode = 1;
old_filter_mode = filter_mode;
@@ -312,7 +318,7 @@ reinit_raylib:;
SetTextureFilter(raylib_cursor_texture, 0);
}
} else {
if (format == RTGFMT_RBG565) {
if (rtg_pixel_size[format] == 2) {
printf("Turning Smooth filtering back on - display mode is 16bit\n");
force_filter_mode = 0;
old_filter_mode = -1;
@@ -323,20 +329,23 @@ reinit_raylib:;
updating_screen = 1;
switch (format) {
case RTGFMT_8BIT:
case RTGFMT_8BIT_CLUT:
BeginShaderMode(clut_shader);
SetShaderValueTexture(clut_shader, clut_loc, raylib_clut_texture);
break;
case RTGFMT_RGB32:
BeginShaderMode(swizzle_shader);
case RTGFMT_RGB32_BGRA:
BeginShaderMode(bgra_swizzle_shader);
break;
case RTGFMT_RGB32_ARGB:
BeginShaderMode(argb_swizzle_shader);
break;
}
DrawTexturePro(raylib_texture, srcrect, dstscale, origin, 0.0f, RAYWHITE);
switch (format) {
case RTGFMT_8BIT:
case RTGFMT_RGB32:
case RTGFMT_8BIT_CLUT:
case RTGFMT_RGB32_BGRA: case RTGFMT_RGB32_ARGB:
EndShaderMode();
break;
}
@@ -350,7 +359,7 @@ reinit_raylib:;
}
if (debug_palette) {
if (format == RTGFMT_8BIT) {
if (format == RTGFMT_8BIT_CLUT) {
Rectangle srcrect = { 0, 0, 256, 1 };
Rectangle dstrect = { 0, 0, 1024, 8 };
DrawTexturePro(raylib_clut_texture, srcrect, dstrect, origin, 0.0f, RAYWHITE);
@@ -364,7 +373,7 @@ reinit_raylib:;
EndDrawing();
rtg_output_in_vblank = 1;
cur_rtg_frame++;
if (format == RTGFMT_RBG565) {
if (format == RTGFMT_RGB565_BE || format == RTGFMT_RGB555_BE) {
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
((uint16_t *)indexed_buf)[x + (y * width)] = be16toh(((uint16_t *)data->memory)[(*data->addr / 2) + x + (y * (pitch / 2))]);
@@ -390,7 +399,7 @@ reinit_raylib:;
} else {
BeginDrawing();
ClearBackground(bef);
DrawText("RTG is currently sleeping.", 16, 16, 12, RAYWHITE);
//DrawText("RTG is currently sleeping.", 16, 16, 12, RAYWHITE);
EndDrawing();
}
if (pitch != *data->pitch || height != *data->height || width != *data->width || format != *data->format) {

43
platforms/amiga/rtg/rtg.c
View File

@@ -53,17 +53,29 @@ extern uint8_t rtg_on, rtg_enabled, rtg_output_in_vblank;
"MEM",
};*/
static const char *rtg_format_names[RTGFMT_NUM] = {
"8BPP CLUT",
"16BPP RGB (565)",
"32BPP RGB (RGBA)",
"15BPP RGB (555)",
};
#define DEBUG printf
#else
#define DEBUG(...)
#endif
static const char *rtg_format_names[RTGFMT_NUM] = {
"4BPP PLANAR",
"8BPP CLUT",
"16BPP RGB (565 BE)",
"16BPP RGB (565 LE)",
"16BPP BGR (565 LE)",
"24BPP RGB",
"24BPP BGR",
"32BPP RGB (ARGB)",
"32BPP RGB (ABGR)",
"32BPP RGB (RGBA)",
"32BPP RGB (BGRA)",
"15BPP RGB (555 BE)",
"15BPP RGB (555 LE)",
"15BPP BGR (555 LE)",
"NONE/UNKNOWN",
};
int init_rtg_data(struct emulator_config *cfg_) {
rtg_mem = calloc(1, 40 * SIZE_MEGA);
if (!rtg_mem) {
@@ -272,7 +284,7 @@ static void handle_irtg_command(uint32_t cmd) {
rtg_offset_x = M68KR(M68K_REG_D1);
rtg_offset_y = M68KR(M68K_REG_D2);
rtg_pitch = (M68KR(M68K_REG_D0) << RGBF_D7);
rtg_pitch = rtg_pixel_size[RGBF_D7];
framebuffer_addr = M68KR(M68K_REG_A1) - (PIGFX_RTG_BASE + PIGFX_REG_SIZE);
framebuffer_addr_adj = framebuffer_addr + (rtg_offset_x << RGBF_D7) + (rtg_offset_y * rtg_pitch);
@@ -525,21 +537,22 @@ static void handle_rtg_command(uint32_t cmd) {
framebuffer_addr_adj = framebuffer_addr + (rtg_offset_x << rtg_display_format) + (rtg_offset_y * rtg_pitch);
rtg_total_rows = rtg_y[1];
}
if (realtime_graphics_debug) {
//if (realtime_graphics_debug) {
printf("Set RTG mode:\n");
printf("%dx%d pixels\n", rtg_display_width, rtg_display_height);
#ifdef DEBUG_RTG
printf("Pixel format: %s\n", rtg_format_names[rtg_display_format]);
#endif
}
printf("Pixel format: %s (%d)\n", rtg_format_names[rtg_display_format], rtg_display_format);
//}
break;
case RTGCMD_SETPAN:
//printf("Command: SetPan.\n");
rtg_offset_x = rtg_x[1];
rtg_offset_y = rtg_y[1];
rtg_pitch = (rtg_x[0] << rtg_display_format);
rtg_pitch = (rtg_x[0] * rtg_pixel_size[rtg_display_format]);
framebuffer_addr = rtg_address[0] - (PIGFX_RTG_BASE + PIGFX_REG_SIZE);
framebuffer_addr_adj = framebuffer_addr + (rtg_offset_x << rtg_display_format) + (rtg_offset_y * rtg_pitch);
//printf("PAN:\nPitch: %d\n", rtg_pitch);
//printf("Pixel format: %s (%d)\n", rtg_format_names[rtg_format], rtg_format);
//printf("Display pixel format: %s (%d)\n", rtg_format_names[rtg_display_format], rtg_display_format);
break;
case RTGCMD_SETCLUT: {
//printf("Command: SetCLUT.\n");
@@ -571,7 +584,7 @@ static void handle_rtg_command(uint32_t cmd) {
}
break;
case RTGCMD_FILLRECT:
if (rtg_u8[0] == 0xFF || rtg_format != RTGFMT_8BIT) {
if (rtg_u8[0] == 0xFF || rtg_format != RTGFMT_8BIT_CLUT) {
rtg_fillrect_solid(rtg_x[0], rtg_y[0], rtg_x[1], rtg_y[1], rtg_rgb[0], rtg_x[2], rtg_format);
gdebug("FillRect Solid\n");
}
@@ -585,7 +598,7 @@ static void handle_rtg_command(uint32_t cmd) {
gdebug("InvertRect\n");
break;
case RTGCMD_BLITRECT:
if (rtg_u8[0] == 0xFF || rtg_format != RTGFMT_8BIT) {
if (rtg_u8[0] == 0xFF || rtg_format != RTGFMT_8BIT_CLUT) {
rtg_blitrect_solid(rtg_x[0], rtg_y[0], rtg_x[1], rtg_y[1], rtg_x[2], rtg_y[2], rtg_x[3], rtg_format);
gdebug("BlitRect Solid\n");
}

48
platforms/amiga/rtg/rtg.h
View File

@@ -82,7 +82,7 @@ void rtg_p2d (int16_t sx, int16_t sy, int16_t dx, int16_t dy, int16_t w, int16_t
#define INVERT_RTG_PIXELS(dest, format) \
switch (format) { \
case RTGFMT_8BIT: \
case RTGFMT_8BIT_CLUT: \
if (cur_byte & 0x80) (dest)[0] ^= mask; \
if (cur_byte & 0x40) (dest)[1] ^= mask; \
if (cur_byte & 0x20) (dest)[2] ^= mask; \
@@ -92,7 +92,8 @@ void rtg_p2d (int16_t sx, int16_t sy, int16_t dx, int16_t dy, int16_t w, int16_t
if (cur_byte & 0x02) (dest)[6] ^= mask; \
if (cur_byte & 0x01) (dest)[7] ^= mask; \
break; \
case RTGFMT_RBG565: \
case RTGFMT_RGB565_LE: case RTGFMT_RGB565_BE: case RTGFMT_BGR565_LE: \
case RTGFMT_RGB555_LE: case RTGFMT_RGB555_BE: case RTGFMT_BGR555_LE: \
if (cur_byte & 0x80) ((uint16_t *)dest)[0] = ~((uint16_t *)dest)[0]; \
if (cur_byte & 0x40) ((uint16_t *)dest)[1] = ~((uint16_t *)dest)[1]; \
if (cur_byte & 0x20) ((uint16_t *)dest)[2] = ~((uint16_t *)dest)[2]; \
@@ -102,7 +103,8 @@ void rtg_p2d (int16_t sx, int16_t sy, int16_t dx, int16_t dy, int16_t w, int16_t
if (cur_byte & 0x02) ((uint16_t *)dest)[6] = ~((uint16_t *)dest)[6]; \
if (cur_byte & 0x01) ((uint16_t *)dest)[7] = ~((uint16_t *)dest)[7]; \
break; \
case RTGFMT_RGB32: \
case RTGFMT_RGB32_ABGR: case RTGFMT_RGB32_ARGB: \
case RTGFMT_RGB32_BGRA: case RTGFMT_RGB32_RGBA: \
if (cur_byte & 0x80) ((uint32_t *)dest)[0] = ~((uint32_t *)dest)[0]; \
if (cur_byte & 0x40) ((uint32_t *)dest)[1] = ~((uint32_t *)dest)[1]; \
if (cur_byte & 0x20) ((uint32_t *)dest)[2] = ~((uint32_t *)dest)[2]; \
@@ -137,7 +139,7 @@ void rtg_p2d (int16_t sx, int16_t sy, int16_t dx, int16_t dy, int16_t w, int16_t
#define SET_RTG_PIXELS(dest, src, format) \
switch (format) { \
case RTGFMT_8BIT: \
case RTGFMT_8BIT_CLUT: \
if (cur_byte & 0x80) (dest)[0] = src; \
if (cur_byte & 0x40) (dest)[1] = src; \
if (cur_byte & 0x20) (dest)[2] = src; \
@@ -147,7 +149,8 @@ void rtg_p2d (int16_t sx, int16_t sy, int16_t dx, int16_t dy, int16_t w, int16_t
if (cur_byte & 0x02) (dest)[6] = src; \
if (cur_byte & 0x01) (dest)[7] = src; \
break; \
case RTGFMT_RBG565: \
case RTGFMT_RGB565_LE: case RTGFMT_RGB565_BE: case RTGFMT_BGR565_LE: \
case RTGFMT_RGB555_LE: case RTGFMT_RGB555_BE: case RTGFMT_BGR555_LE: \
if (cur_byte & 0x80) ((uint16_t *)dest)[0] = src; \
if (cur_byte & 0x40) ((uint16_t *)dest)[1] = src; \
if (cur_byte & 0x20) ((uint16_t *)dest)[2] = src; \
@@ -157,7 +160,8 @@ void rtg_p2d (int16_t sx, int16_t sy, int16_t dx, int16_t dy, int16_t w, int16_t
if (cur_byte & 0x02) ((uint16_t *)dest)[6] = src; \
if (cur_byte & 0x01) ((uint16_t *)dest)[7] = src; \
break; \
case RTGFMT_RGB32: \
case RTGFMT_RGB32_ABGR: case RTGFMT_RGB32_ARGB: \
case RTGFMT_RGB32_BGRA: case RTGFMT_RGB32_RGBA: \
if (cur_byte & 0x80) ((uint32_t *)dest)[0] = src; \
if (cur_byte & 0x40) ((uint32_t *)dest)[1] = src; \
if (cur_byte & 0x20) ((uint32_t *)dest)[2] = src; \
@@ -171,7 +175,7 @@ void rtg_p2d (int16_t sx, int16_t sy, int16_t dx, int16_t dy, int16_t w, int16_t
#define SET_RTG_PIXELS2_COND(dest, src, src2, format) \
switch (format) { \
case RTGFMT_8BIT: \
case RTGFMT_8BIT_CLUT: \
(dest)[0] = (cur_byte & 0x80) ? src : src2; \
(dest)[1] = (cur_byte & 0x40) ? src : src2; \
(dest)[2] = (cur_byte & 0x20) ? src : src2; \
@@ -181,7 +185,8 @@ void rtg_p2d (int16_t sx, int16_t sy, int16_t dx, int16_t dy, int16_t w, int16_t
(dest)[6] = (cur_byte & 0x02) ? src : src2; \
(dest)[7] = (cur_byte & 0x01) ? src : src2; \
break; \
case RTGFMT_RBG565: \
case RTGFMT_RGB565_LE: case RTGFMT_RGB565_BE: case RTGFMT_BGR565_LE: \
case RTGFMT_RGB555_LE: case RTGFMT_RGB555_BE: case RTGFMT_BGR555_LE: \
((uint16_t *)dest)[0] = (cur_byte & 0x80) ? src : src2; \
((uint16_t *)dest)[1] = (cur_byte & 0x40) ? src : src2; \
((uint16_t *)dest)[2] = (cur_byte & 0x20) ? src : src2; \
@@ -191,7 +196,8 @@ void rtg_p2d (int16_t sx, int16_t sy, int16_t dx, int16_t dy, int16_t w, int16_t
((uint16_t *)dest)[6] = (cur_byte & 0x02) ? src : src2; \
((uint16_t *)dest)[7] = (cur_byte & 0x01) ? src : src2; \
break; \
case RTGFMT_RGB32: \
case RTGFMT_RGB32_ABGR: case RTGFMT_RGB32_ARGB: \
case RTGFMT_RGB32_BGRA: case RTGFMT_RGB32_RGBA: \
((uint32_t *)dest)[0] = (cur_byte & 0x80) ? src : src2; \
((uint32_t *)dest)[1] = (cur_byte & 0x40) ? src : src2; \
((uint32_t *)dest)[2] = (cur_byte & 0x20) ? src : src2; \
@@ -207,39 +213,45 @@ void rtg_p2d (int16_t sx, int16_t sy, int16_t dx, int16_t dy, int16_t w, int16_t
#define SET_RTG_PIXEL(dest, src, format) \
switch (format) { \
case RTGFMT_8BIT: \
case RTGFMT_8BIT_CLUT: \
*(dest) = src; \
break; \
case RTGFMT_RBG565: \
case RTGFMT_RGB565_LE: case RTGFMT_RGB565_BE: case RTGFMT_BGR565_LE: \
case RTGFMT_RGB555_LE: case RTGFMT_RGB555_BE: case RTGFMT_BGR555_LE: \
*((uint16_t *)dest) = src; \
break; \
case RTGFMT_RGB32: \
case RTGFMT_RGB32_ABGR: case RTGFMT_RGB32_ARGB: \
case RTGFMT_RGB32_BGRA: case RTGFMT_RGB32_RGBA: \
*((uint32_t *)dest) = src; \
break; \
}
#define SET_RTG_PIXEL_MASK(dest, src, format) \
switch (format) { \
case RTGFMT_8BIT: \
case RTGFMT_8BIT_CLUT: \
*(dest) = src ^ (*(dest) & ~mask); \
break; \
case RTGFMT_RBG565: \
case RTGFMT_RGB565_LE: case RTGFMT_RGB565_BE: case RTGFMT_BGR565_LE: \
case RTGFMT_RGB555_LE: case RTGFMT_RGB555_BE: case RTGFMT_BGR555_LE: \
*((uint16_t *)dest) = src; \
break; \
case RTGFMT_RGB32: \
case RTGFMT_RGB32_ABGR: case RTGFMT_RGB32_ARGB: \
case RTGFMT_RGB32_BGRA: case RTGFMT_RGB32_RGBA: \
*((uint32_t *)dest) = src; \
break; \
}
#define INVERT_RTG_PIXEL(dest, format) \
switch (format) { \
case RTGFMT_8BIT: \
case RTGFMT_8BIT_CLUT: \
*(dest) ^= mask; \
break; \
case RTGFMT_RBG565: \
case RTGFMT_RGB565_LE: case RTGFMT_RGB565_BE: case RTGFMT_BGR565_LE: \
case RTGFMT_RGB555_LE: case RTGFMT_RGB555_BE: case RTGFMT_BGR555_LE: \
*((uint16_t *)dest) = ~*((uint16_t *)dest); \
break; \
case RTGFMT_RGB32: \
case RTGFMT_RGB32_ABGR: case RTGFMT_RGB32_ARGB: \
case RTGFMT_RGB32_BGRA: case RTGFMT_RGB32_RGBA: \
*((uint32_t *)dest) = ~*((uint32_t *)dest); \
break; \
}

53
platforms/amiga/rtg/rtg_driver_amiga/pigfx-2.c
View File

@@ -208,7 +208,6 @@ ULONG ExtFuncLib(void)
return 0; \
} \
int __attribute__((used)) FindCard(__REGA0(struct BoardInfo* b)) {
uint16_t card_check = CHECKRTG;
if (card_check != 0xFFCF) {
@@ -242,15 +241,8 @@ int __attribute__((used)) FindCard(__REGA0(struct BoardInfo* b)) {
return 1;
}
#define HWSPRITE 1
#define VGASPLIT (1 << 6)
#define FLICKERFIXER (1 << 12)
#define INDISPLAYCHAIN (1 << 20)
#define DIRECTACCESS (1 << 26)
int __attribute__((used)) InitCard(__REGA0(struct BoardInfo* b)) {
int i;
kprintf("Wueh! %ld\n", sizeof(BOOL));
b->CardBase = (struct CardBase *)_gfxbase;
b->ExecBase = SysBase;
@@ -260,7 +252,7 @@ int __attribute__((used)) InitCard(__REGA0(struct BoardInfo* b)) {
b->GraphicsControllerType = GCT_S3ViRGE;
b->Flags |= BIF_GRANTDIRECTACCESS | BIF_HARDWARESPRITE | BIF_FLICKERFIXER;// | BIF_BLITTER;
b->RGBFormats = 1 | 2 | 512 | 1024 | 2048;
b->RGBFormats = RGBFF_HICOLOR | RGBFF_TRUECOLOR | RGBFF_TRUEALPHA | RGBFF_CLUT | RGBFF_NONE;
b->SoftSpriteFlags = 0;
b->BitsPerCannon = 8;
@@ -379,6 +371,7 @@ void SetPanning (__REGA0(struct BoardInfo *b), __REGA1(UBYTE *addr), __REGD0(UWO
WRITELONG(RTG_ADDR1, (unsigned long)addr);
WRITESHORT(RTG_X1, width);
WRITESHORT(RTG_FORMAT, rgbf_to_rtg[format]);
WRITESHORT(RTG_X2, b->XOffset);
WRITESHORT(RTG_Y2, b->YOffset);
WRITESHORT(RTG_COMMAND, RTGCMD_SETPAN);
@@ -412,11 +405,20 @@ UWORD CalculateBytesPerRow (__REGA0(struct BoardInfo *b), __REGD0(UWORD width),
UWORD pitch = width;
switch(format) {
default:
case RGBFB_CLUT:
return pitch;
case 0x05: case 0x0A: case 0x0B: case 0x0D:
default:
return 128;
case RGBFB_R5G6B5PC: case RGBFB_R5G5B5PC:
case RGBFB_R5G6B5: case RGBFB_R5G5B5:
case RGBFB_B5G6R5PC: case RGBFB_B5G5R5PC:
return (width * 2);
case 0x08: case 0x09:
case RGBFB_R8G8B8: case RGBFB_B8G8R8:
// Should actually return width * 3, but I'm not sure if
// the Pi VC supports 24-bit color formats.
//return (width * 3);
case RGBFB_B8G8R8A8: case RGBFB_R8G8B8A8:
case RGBFB_A8B8G8R8: case RGBFB_A8R8G8B8:
return (width * 4);
}
}
@@ -432,32 +434,7 @@ APTR CalculateMemory (__REGA0(struct BoardInfo *b), __REGA1(unsigned long addr),
return (APTR)addr;
}
enum fake_rgbftypes {
RGBF_8BPP_CLUT,
RGBF_24BPP_RGB,
RGBF_24BPP_BGR,
RGBF_16BPP_RGB565_PC,
RGBF_16BPP_RGB555_PC,
RGBF_32BPP_ARGB,
RGBF_32BPP_ABGR,
RGBF_32BPP_RGBA,
RGBF_32BPP_BGRA,
RGBF_16BPP_RGB565,
RGBF_16BPP_RGB555,
RGBF_16BPP_BGR565_PC,
RGBF_16BPP_BGR555_PC,
RGBF_YUV_422_0, // (Actually 4:2:0?) Just a duplicate of RGBF_YUV_422?
RGBF_YUV_411, // No, these are 4:2:0
RGBF_YUV_411_PC, // No, these are 4:2:0
RGBF_YUV_422,
RGBF_YUV_422_PC,
RGBF_YUV_422_PLANAR,
RGBF_YUV_422_PLANAR_PC,
};
#define BIP(a) (1 << a)
ULONG GetCompatibleFormats (__REGA0(struct BoardInfo *b), __REGD7(RGBFTYPE format)) {
//return BIP(RGBF_8BPP_CLUT) | BIP(RGBF_24BPP_RGB) | BIP(RGBF_24BPP_BGR) | BIP(RGBF_32BPP_ARGB) | BIP(RGBF_32BPP_ABGR) | BIP(RGBF_32BPP_RGBA) | BIP(RGBF_32BPP_BGRA);
return 0xFFFFFFFF;
}
@@ -896,7 +873,7 @@ struct InitTable
};
const uint32_t auto_init_tables[4] = {
sizeof(struct Library),
sizeof(struct GFXBase),
(uint32_t)device_vectors,
0,
(uint32_t)InitLib,

BIN
platforms/amiga/rtg/rtg_driver_amiga/pigfx020.card
View File

Binary file not shown.

87
platforms/amiga/rtg/rtg_enums.h
View File

@@ -56,10 +56,21 @@ enum rtg_cmds {
};
enum rtg_formats {
RTGFMT_8BIT,
RTGFMT_RBG565,
RTGFMT_RGB32,
RTGFMT_RGB555,
RTGFMT_4BIT_PLANAR,
RTGFMT_8BIT_CLUT,
RTGFMT_RGB565_BE,
RTGFMT_RGB565_LE,
RTGFMT_BGR565_LE,
RTGFMT_RGB24,
RTGFMT_BGR24,
RTGFMT_RGB32_ARGB,
RTGFMT_RGB32_ABGR,
RTGFMT_RGB32_RGBA,
RTGFMT_RGB32_BGRA,
RTGFMT_RGB555_BE,
RTGFMT_RGB555_LE,
RTGFMT_BGR555_LE,
RTGFMT_NONE,
RTGFMT_NUM,
};
@@ -89,21 +100,55 @@ enum gfx_draw_modes {
DRAWMODE_INVERSVID = 4,
};
static const unsigned short rgbf_to_rtg[16] = {
RTGFMT_8BIT, // 0x00
RTGFMT_8BIT, // 0x01
0, // 0x02
0, // 0x03
0, // 0x04
RTGFMT_RGB555, // 0x05
0, // 0x06
0, // 0x07
RTGFMT_RGB32, // 0x08
RTGFMT_RGB32, // 0x09
RTGFMT_RBG565, // 0x0A
RTGFMT_RGB555, // 0x0B
0, // 0x0C
RTGFMT_RGB555, // 0x0D
0, // 0x0E
0, // 0x0F
static const unsigned short rgbf_to_rtg[32] = {
RTGFMT_4BIT_PLANAR, // 0x00
RTGFMT_8BIT_CLUT, // 0x01
RTGFMT_RGB24, // 0x02
RTGFMT_BGR24, // 0x03
RTGFMT_RGB565_LE, // 0x04
RTGFMT_RGB555_LE, // 0x05
RTGFMT_RGB32_ARGB, // 0x08
RTGFMT_RGB32_ABGR, // 0x09
RTGFMT_RGB32_RGBA, // 0x06
RTGFMT_RGB32_BGRA, // 0x07
RTGFMT_RGB565_BE, // 0x0A
RTGFMT_RGB555_BE, // 0x0B
RTGFMT_BGR565_LE, // 0x0C
RTGFMT_BGR555_LE, // 0x0D
RTGFMT_NONE, // 0x0E
RTGFMT_NONE, // 0x0F
RTGFMT_NONE, // 0x10
RTGFMT_NONE, // 0x11
RTGFMT_NONE, // 0x12
RTGFMT_NONE, // 0x13
RTGFMT_NONE, // 0x14
RTGFMT_NONE, // 0x15
RTGFMT_NONE, // 0x16
RTGFMT_NONE, // 0x17
RTGFMT_NONE, // 0x18
RTGFMT_NONE, // 0x19
RTGFMT_NONE, // 0x1A
RTGFMT_NONE, // 0x1B
RTGFMT_NONE, // 0x1C
RTGFMT_NONE, // 0x1D
RTGFMT_NONE, // 0x1E
RTGFMT_NONE, // 0x1F
};
static const unsigned int rtg_pixel_size[RTGFMT_NUM] = {
1, // 4BIT_PLANAR, (actually 0.5)
1, // 8BIT_CLUT,
2, // RGB565_BE,
2, // RGB565_LE,
2, // BGR565_LE,
3, // RGB24,
3, // BGR24,
4, // RGB32_ARGB,
4, // RGB32_ABGR,
4, // RGB32_RGBA,
4, // RGB32_BGRA,
2, // RGB555_BE,
2, // RGB555_LE,
2, // BGR555_LE,
1, // NONE,
};