2022-01-08 22:38:53 -05:00
|
|
|
#include <stdlib.h>
|
|
|
|
|
2021-12-28 16:37:26 -05:00
|
|
|
#include "../uxn.h"
|
|
|
|
#include "screen.h"
|
2021-05-12 21:28:45 -04:00
|
|
|
|
2021-04-07 20:32:18 -04:00
|
|
|
/*
|
|
|
|
Copyright (c) 2021 Devine Lu Linvega
|
|
|
|
Copyright (c) 2021 Andrew Alderwick
|
|
|
|
|
|
|
|
Permission to use, copy, modify, and distribute this software for any
|
|
|
|
purpose with or without fee is hereby granted, provided that the above
|
|
|
|
copyright notice and this permission notice appear in all copies.
|
|
|
|
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
|
|
WITH REGARD TO THIS SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
2021-12-29 12:11:03 -05:00
|
|
|
UxnScreen uxn_screen;
|
2021-12-28 16:37:26 -05:00
|
|
|
|
2021-08-01 14:16:29 -04:00
|
|
|
static Uint8 blending[5][16] = {
|
2021-08-01 14:00:07 -04:00
|
|
|
{0, 0, 0, 0, 1, 0, 1, 1, 2, 2, 0, 2, 3, 3, 3, 0},
|
|
|
|
{0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3},
|
|
|
|
{1, 2, 3, 1, 1, 2, 3, 1, 1, 2, 3, 1, 1, 2, 3, 1},
|
2021-08-01 14:16:29 -04:00
|
|
|
{2, 3, 1, 2, 2, 3, 1, 2, 2, 3, 1, 2, 2, 3, 1, 2},
|
|
|
|
{1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0}};
|
2021-08-01 14:00:07 -04:00
|
|
|
|
2021-12-28 16:37:26 -05:00
|
|
|
static void
|
2021-12-29 12:11:03 -05:00
|
|
|
screen_write(UxnScreen *p, Layer *layer, Uint16 x, Uint16 y, Uint8 color)
|
2021-12-28 16:37:26 -05:00
|
|
|
{
|
|
|
|
if(x < p->width && y < p->height) {
|
|
|
|
Uint32 i = x + y * p->width;
|
2021-12-28 16:47:35 -05:00
|
|
|
if(color != layer->pixels[i]) {
|
2021-12-28 16:37:26 -05:00
|
|
|
layer->pixels[i] = color;
|
|
|
|
layer->changed = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2021-12-29 12:11:03 -05:00
|
|
|
screen_blit(UxnScreen *p, Layer *layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color, Uint8 flipx, Uint8 flipy, Uint8 twobpp)
|
2021-12-28 16:37:26 -05:00
|
|
|
{
|
|
|
|
int v, h, opaque = blending[4][color];
|
2022-01-03 21:04:09 -05:00
|
|
|
for(v = 0; v < 8; v++) {
|
2021-12-28 16:37:26 -05:00
|
|
|
Uint16 c = sprite[v] | (twobpp ? sprite[v + 8] : 0) << 8;
|
|
|
|
for(h = 7; h >= 0; --h, c >>= 1) {
|
|
|
|
Uint8 ch = (c & 1) | ((c >> 7) & 2);
|
|
|
|
if(opaque || ch)
|
|
|
|
screen_write(p,
|
|
|
|
layer,
|
|
|
|
x + (flipx ? 7 - h : h),
|
|
|
|
y + (flipy ? 7 - v : v),
|
|
|
|
blending[ch][color]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-24 12:39:51 -05:00
|
|
|
void
|
2021-12-29 12:11:03 -05:00
|
|
|
screen_palette(UxnScreen *p, Uint8 *addr)
|
2021-12-24 12:39:51 -05:00
|
|
|
{
|
2021-12-25 16:42:34 -05:00
|
|
|
int i, shift;
|
|
|
|
for(i = 0, shift = 4; i < 4; ++i, shift ^= 4) {
|
2021-12-24 12:39:51 -05:00
|
|
|
Uint8
|
2021-12-25 16:42:34 -05:00
|
|
|
r = (addr[0 + i / 2] >> shift) & 0x0f,
|
|
|
|
g = (addr[2 + i / 2] >> shift) & 0x0f,
|
|
|
|
b = (addr[4 + i / 2] >> shift) & 0x0f;
|
|
|
|
p->palette[i] = 0x0f000000 | r << 16 | g << 8 | b;
|
|
|
|
p->palette[i] |= p->palette[i] << 4;
|
2021-12-24 12:39:51 -05:00
|
|
|
}
|
2021-12-24 15:01:10 -05:00
|
|
|
p->fg.changed = p->bg.changed = 1;
|
2021-12-24 12:39:51 -05:00
|
|
|
}
|
|
|
|
|
2021-11-03 18:03:33 -04:00
|
|
|
void
|
2021-12-29 12:11:03 -05:00
|
|
|
screen_resize(UxnScreen *p, Uint16 width, Uint16 height)
|
2021-09-30 13:44:40 -04:00
|
|
|
{
|
2021-12-24 15:01:10 -05:00
|
|
|
Uint8
|
|
|
|
*bg = realloc(p->bg.pixels, width * height),
|
|
|
|
*fg = realloc(p->fg.pixels, width * height);
|
2021-12-27 12:57:48 -05:00
|
|
|
Uint32
|
2021-12-28 16:37:26 -05:00
|
|
|
*pixels = realloc(p->pixels, width * height * sizeof(Uint32));
|
2021-12-25 10:06:30 -05:00
|
|
|
if(bg) p->bg.pixels = bg;
|
|
|
|
if(fg) p->fg.pixels = fg;
|
2021-12-28 16:37:26 -05:00
|
|
|
if(pixels) p->pixels = pixels;
|
|
|
|
if(bg && fg && pixels) {
|
2021-12-25 10:06:30 -05:00
|
|
|
p->width = width;
|
|
|
|
p->height = height;
|
2021-12-28 16:37:26 -05:00
|
|
|
screen_clear(p, &p->bg);
|
|
|
|
screen_clear(p, &p->fg);
|
2021-12-25 09:05:33 -05:00
|
|
|
}
|
2021-09-30 13:44:40 -04:00
|
|
|
}
|
|
|
|
|
2021-12-19 15:20:13 -05:00
|
|
|
void
|
2021-12-29 12:11:03 -05:00
|
|
|
screen_clear(UxnScreen *p, Layer *layer)
|
2021-12-19 15:20:13 -05:00
|
|
|
{
|
2021-12-24 12:59:18 -05:00
|
|
|
Uint32 i, size = p->width * p->height;
|
2022-01-03 21:04:09 -05:00
|
|
|
for(i = 0; i < size; i++)
|
2021-12-24 15:01:10 -05:00
|
|
|
layer->pixels[i] = 0x00;
|
2021-12-24 17:27:41 -05:00
|
|
|
layer->changed = 1;
|
2021-12-19 15:20:13 -05:00
|
|
|
}
|
|
|
|
|
2021-12-24 12:46:21 -05:00
|
|
|
void
|
2021-12-29 12:11:03 -05:00
|
|
|
screen_redraw(UxnScreen *p, Uint32 *pixels)
|
2021-12-24 12:46:21 -05:00
|
|
|
{
|
2021-12-25 09:57:43 -05:00
|
|
|
Uint32 i, size = p->width * p->height, palette[16];
|
2022-01-03 21:04:09 -05:00
|
|
|
for(i = 0; i < 16; i++)
|
2021-12-25 09:57:43 -05:00
|
|
|
palette[i] = p->palette[(i >> 2) ? (i >> 2) : (i & 3)];
|
2022-01-03 21:04:09 -05:00
|
|
|
for(i = 0; i < size; i++)
|
2021-12-28 16:37:26 -05:00
|
|
|
pixels[i] = palette[p->fg.pixels[i] << 2 | p->bg.pixels[i]];
|
2021-12-24 15:01:10 -05:00
|
|
|
p->fg.changed = p->bg.changed = 0;
|
2021-12-24 12:46:21 -05:00
|
|
|
}
|
|
|
|
|
2021-12-28 20:22:40 -05:00
|
|
|
/* IO */
|
2021-12-28 16:37:26 -05:00
|
|
|
|
|
|
|
Uint8
|
|
|
|
screen_dei(Device *d, Uint8 port)
|
|
|
|
{
|
|
|
|
switch(port) {
|
2021-12-29 12:11:03 -05:00
|
|
|
case 0x2: return uxn_screen.width >> 8;
|
|
|
|
case 0x3: return uxn_screen.width;
|
|
|
|
case 0x4: return uxn_screen.height >> 8;
|
|
|
|
case 0x5: return uxn_screen.height;
|
2021-12-28 16:37:26 -05:00
|
|
|
default: return d->dat[port];
|
2021-11-04 11:42:15 -04:00
|
|
|
}
|
|
|
|
}
|
2021-12-28 16:37:26 -05:00
|
|
|
|
|
|
|
void
|
|
|
|
screen_deo(Device *d, Uint8 port)
|
|
|
|
{
|
|
|
|
switch(port) {
|
|
|
|
case 0x5:
|
2022-01-03 16:23:57 -05:00
|
|
|
if(!FIXED_SIZE) {
|
|
|
|
Uint16 w, h;
|
|
|
|
DEVPEEK16(w, 0x2);
|
|
|
|
DEVPEEK16(h, 0x4);
|
|
|
|
set_size(w, h, 1);
|
|
|
|
}
|
2021-12-28 16:37:26 -05:00
|
|
|
break;
|
|
|
|
case 0xe: {
|
2022-01-03 16:23:57 -05:00
|
|
|
Uint16 x, y;
|
2021-12-28 16:37:26 -05:00
|
|
|
Uint8 layer = d->dat[0xe] & 0x40;
|
2022-01-03 16:23:57 -05:00
|
|
|
DEVPEEK16(x, 0x8);
|
|
|
|
DEVPEEK16(y, 0xa);
|
2021-12-29 12:11:03 -05:00
|
|
|
screen_write(&uxn_screen, layer ? &uxn_screen.fg : &uxn_screen.bg, x, y, d->dat[0xe] & 0x3);
|
2022-01-03 16:23:57 -05:00
|
|
|
if(d->dat[0x6] & 0x01) DEVPOKE16(0x8, x + 1); /* auto x+1 */
|
|
|
|
if(d->dat[0x6] & 0x02) DEVPOKE16(0xa, y + 1); /* auto y+1 */
|
2021-12-28 16:37:26 -05:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case 0xf: {
|
2022-01-03 16:23:57 -05:00
|
|
|
Uint16 x, y, addr;
|
2021-12-28 16:37:26 -05:00
|
|
|
Uint8 twobpp = !!(d->dat[0xf] & 0x80);
|
2022-01-03 16:23:57 -05:00
|
|
|
Layer *layer = (d->dat[0xf] & 0x40) ? &uxn_screen.fg : &uxn_screen.bg;
|
|
|
|
DEVPEEK16(x, 0x8);
|
|
|
|
DEVPEEK16(y, 0xa);
|
|
|
|
DEVPEEK16(addr, 0xc);
|
|
|
|
screen_blit(&uxn_screen, layer, x, y, &d->mem[addr], d->dat[0xf] & 0xf, d->dat[0xf] & 0x10, d->dat[0xf] & 0x20, twobpp);
|
|
|
|
if(d->dat[0x6] & 0x04) DEVPOKE16(0xc, addr + 8 + twobpp * 8); /* auto addr+length */
|
|
|
|
if(d->dat[0x6] & 0x01) DEVPOKE16(0x8, x + 8); /* auto x+8 */
|
|
|
|
if(d->dat[0x6] & 0x02) DEVPOKE16(0xa, y + 8); /* auto y+8 */
|
2021-12-28 16:37:26 -05:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2022-01-07 17:46:39 -05:00
|
|
|
}
|