mirror of https://gitlab.com/nakst/essence
355 lines
10 KiB
C
355 lines
10 KiB
C
// Ported by nakst.
|
|
// TODO Keyboard support.
|
|
// TODO Audio support.
|
|
// TODO Time and date support.
|
|
|
|
#include <essence.h>
|
|
|
|
#define PPW (sizeof(unsigned int) * 2)
|
|
#define realloc EsCRTrealloc
|
|
#define Uint32 uint32_t
|
|
|
|
typedef struct Ppu {
|
|
unsigned short width, height;
|
|
unsigned int *dat, stride;
|
|
} Ppu;
|
|
|
|
#ifdef DEBUG_BUILD
|
|
#include "../../bin/uxn/src/uxn.c"
|
|
#else
|
|
#include "../../bin/uxn/src/uxn-fast.c"
|
|
#endif
|
|
#include "../../bin/uxn/src/devices/ppu.c"
|
|
|
|
/*
|
|
Copyright (c) 2021 Devine Lu Linvega
|
|
|
|
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.
|
|
*/
|
|
|
|
static Ppu ppu;
|
|
static Uxn u;
|
|
static Device *devsystem, *devscreen, *devmouse, *devctrl;
|
|
static Uint32 palette[16];
|
|
|
|
static unsigned int reqdraw = 0;
|
|
|
|
static int
|
|
clamp(int val, int min, int max)
|
|
{
|
|
return (val >= min) ? (val <= max) ? val : max : min;
|
|
}
|
|
|
|
static int
|
|
error(char *msg, const char *err)
|
|
{
|
|
EsPrint("%z: %z\n", msg, err);
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
domouse(int mx, int my, bool pressed, bool released, bool right)
|
|
{
|
|
Uint8 flag = 0x00;
|
|
Uint16 x = clamp(mx, 0, ppu.width - 1);
|
|
Uint16 y = clamp(my, 0, ppu.height - 1);
|
|
poke16(devmouse->dat, 0x2, x);
|
|
poke16(devmouse->dat, 0x4, y);
|
|
flag = right ? 0x10 : 0x01;
|
|
if (pressed) devmouse->dat[6] |= flag;
|
|
if (released) devmouse->dat[6] &= ~flag;
|
|
}
|
|
|
|
static Uint8
|
|
get_pixel(int x, int y)
|
|
{
|
|
unsigned int i = x / PPW + y * ppu.stride, shift = x % PPW * 4;
|
|
return (ppu.dat[i] >> shift) & 0xf;
|
|
}
|
|
|
|
void
|
|
update_palette(Uint8 *addr)
|
|
{
|
|
int i;
|
|
for(i = 0; i < 4; ++i) {
|
|
Uint8
|
|
r = (*(addr + i / 2) >> (!(i % 2) << 2)) & 0x0f,
|
|
g = (*(addr + 2 + i / 2) >> (!(i % 2) << 2)) & 0x0f,
|
|
b = (*(addr + 4 + i / 2) >> (!(i % 2) << 2)) & 0x0f;
|
|
palette[i] = 0xff000000 | (r << 20) | (r << 16) | (g << 12) | (g << 8) | (b << 4) | b;
|
|
}
|
|
for(i = 4; i < 16; ++i)
|
|
palette[i] = palette[i / 4];
|
|
reqdraw = 1;
|
|
}
|
|
|
|
static int
|
|
system_talk(Device *d, Uint8 b0, Uint8 w)
|
|
{
|
|
if(!w) { /* read */
|
|
switch(b0) {
|
|
case 0x2: d->dat[0x2] = d->u->wst.ptr; break;
|
|
case 0x3: d->dat[0x3] = d->u->rst.ptr; break;
|
|
}
|
|
} else { /* write */
|
|
switch(b0) {
|
|
case 0x2: d->u->wst.ptr = d->dat[0x2]; break;
|
|
case 0x3: d->u->rst.ptr = d->dat[0x3]; break;
|
|
case 0xf: return 0;
|
|
}
|
|
if(b0 > 0x7 && b0 < 0xe)
|
|
update_palette(&d->dat[0x8]);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
console_talk(Device *d, Uint8 b0, Uint8 w)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
screen_talk(Device *d, Uint8 b0, Uint8 w)
|
|
{
|
|
if(!w) switch(b0) {
|
|
case 0x2: d->dat[0x2] = ppu.width >> 8; break;
|
|
case 0x3: d->dat[0x3] = ppu.width; break;
|
|
case 0x4: d->dat[0x4] = ppu.height >> 8; break;
|
|
case 0x5: d->dat[0x5] = ppu.height; break;
|
|
}
|
|
else
|
|
switch(b0) {
|
|
case 0x5:
|
|
ppu_set_size(&ppu, peek16(d->dat, 0x2), peek16(d->dat, 0x4));
|
|
break;
|
|
case 0xe: {
|
|
Uint16 x = peek16(d->dat, 0x8);
|
|
Uint16 y = peek16(d->dat, 0xa);
|
|
Uint8 layer = d->dat[0xe] & 0x40;
|
|
reqdraw |= ppu_pixel(&ppu, layer, x, y, d->dat[0xe] & 0x3);
|
|
if(d->dat[0x6] & 0x01) poke16(d->dat, 0x8, x + 1); /* auto x+1 */
|
|
if(d->dat[0x6] & 0x02) poke16(d->dat, 0xa, y + 1); /* auto y+1 */
|
|
break;
|
|
}
|
|
case 0xf: {
|
|
Uint16 x = peek16(d->dat, 0x8);
|
|
Uint16 y = peek16(d->dat, 0xa);
|
|
Uint8 layer = d->dat[0xf] & 0x40;
|
|
Uint8 *addr = &d->mem[peek16(d->dat, 0xc)];
|
|
if(d->dat[0xf] & 0x80) {
|
|
reqdraw |= ppu_2bpp(&ppu, layer, x, y, addr, d->dat[0xf] & 0xf, d->dat[0xf] & 0x10, d->dat[0xf] & 0x20);
|
|
if(d->dat[0x6] & 0x04) poke16(d->dat, 0xc, peek16(d->dat, 0xc) + 16); /* auto addr+16 */
|
|
} else {
|
|
reqdraw |= ppu_1bpp(&ppu, layer, x, y, addr, d->dat[0xf] & 0xf, d->dat[0xf] & 0x10, d->dat[0xf] & 0x20);
|
|
if(d->dat[0x6] & 0x04) poke16(d->dat, 0xc, peek16(d->dat, 0xc) + 8); /* auto addr+8 */
|
|
}
|
|
if(d->dat[0x6] & 0x01) poke16(d->dat, 0x8, x + 8); /* auto x+8 */
|
|
if(d->dat[0x6] & 0x02) poke16(d->dat, 0xa, y + 8); /* auto y+8 */
|
|
break;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
file_talk(Device *d, Uint8 b0, Uint8 w)
|
|
{
|
|
Uint8 read = b0 == 0xd;
|
|
if(w && (read || b0 == 0xf)) {
|
|
char *name = (char *)&d->mem[peek16(d->dat, 0x8)];
|
|
Uint16 result = 0, length = peek16(d->dat, 0xa);
|
|
long offset = (peek16(d->dat, 0x4) << 16) + peek16(d->dat, 0x6);
|
|
Uint16 addr = peek16(d->dat, b0 - 1);
|
|
|
|
size_t pathBytes;
|
|
char *path = EsStringAllocateAndFormat(&pathBytes, "|Settings:/%z", name);
|
|
EsFileInformation file = EsFileOpen(path, pathBytes, read ? (ES_FILE_READ | ES_NODE_FAIL_IF_NOT_FOUND) : (ES_FILE_WRITE));
|
|
EsHeapFree(path, 0, NULL);
|
|
|
|
if (file.error != ES_SUCCESS) {
|
|
result = 0;
|
|
} else if (read) {
|
|
result = EsFileReadSync(file.handle, offset, length, &d->mem[addr]);
|
|
EsHandleClose(file.handle);
|
|
} else {
|
|
if (!offset) EsFileResize(file.handle, length);
|
|
result = EsFileWriteSync(file.handle, offset, length, &d->mem[addr]);
|
|
EsHandleClose(file.handle);
|
|
}
|
|
|
|
poke16(d->dat, 0x2, result);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
datetime_talk(Device *d, Uint8 b0, Uint8 w)
|
|
{
|
|
poke16(d->dat, 0x0, 0);
|
|
d->dat[0x2] = 0;
|
|
d->dat[0x3] = 0;
|
|
d->dat[0x4] = 0;
|
|
d->dat[0x5] = 0;
|
|
d->dat[0x6] = 0;
|
|
d->dat[0x7] = 0;
|
|
poke16(d->dat, 0x08, 0);
|
|
d->dat[0xa] = 0;
|
|
(void)b0;
|
|
(void)w;
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
nil_talk(Device *d, Uint8 b0, Uint8 w)
|
|
{
|
|
(void)d;
|
|
(void)b0;
|
|
(void)w;
|
|
return 1;
|
|
}
|
|
|
|
static const char *errors[] = {"underflow", "overflow", "division by zero"};
|
|
|
|
int
|
|
uxn_halt(Uxn *u, Uint8 error, char *name, int id)
|
|
{
|
|
EsPrint("Halted: %z %z#%x, at 0x%x\n", name, errors[error - 1], id, u->ram.ptr);
|
|
return 0;
|
|
}
|
|
|
|
bool Launch(const void *rom, size_t romBytes) {
|
|
if (romBytes > sizeof(u.ram.dat) - PAGE_PROGRAM) {
|
|
return false;
|
|
}
|
|
|
|
if (!uxn_boot(&u)) return false;
|
|
EsMemoryCopy(u.ram.dat + PAGE_PROGRAM, rom, romBytes);
|
|
reqdraw = 1;
|
|
const Uint16 width = 64 * 8, height = 40 * 8;
|
|
ppu_set_size(&ppu, width, height);
|
|
|
|
/* system */ devsystem = uxn_port(&u, 0x0, system_talk);
|
|
/* console */ uxn_port(&u, 0x1, console_talk);
|
|
/* screen */ devscreen = uxn_port(&u, 0x2, screen_talk);
|
|
/* audio0 */ uxn_port(&u, 0x3, nil_talk);
|
|
/* audio1 */ uxn_port(&u, 0x4, nil_talk);
|
|
/* audio2 */ uxn_port(&u, 0x5, nil_talk);
|
|
/* audio3 */ uxn_port(&u, 0x6, nil_talk);
|
|
/* unused */ uxn_port(&u, 0x7, nil_talk);
|
|
/* control */ devctrl = uxn_port(&u, 0x8, nil_talk);
|
|
/* mouse */ devmouse = uxn_port(&u, 0x9, nil_talk);
|
|
/* file */ uxn_port(&u, 0xa, file_talk);
|
|
/* datetime */ uxn_port(&u, 0xb, datetime_talk);
|
|
/* unused */ uxn_port(&u, 0xc, nil_talk);
|
|
/* unused */ uxn_port(&u, 0xd, nil_talk);
|
|
/* unused */ uxn_port(&u, 0xe, nil_talk);
|
|
/* unused */ uxn_port(&u, 0xf, nil_talk);
|
|
|
|
uxn_eval(&u, PAGE_PROGRAM);
|
|
|
|
return true;
|
|
}
|
|
|
|
EsElement *canvas;
|
|
uint32_t imageWidth, imageHeight;
|
|
uint32_t *imageBits;
|
|
uint16_t timeDeltaMs;
|
|
bool inImageBounds;
|
|
|
|
EsRectangle GetImageBounds(EsRectangle bounds /* canvas bounds */) {
|
|
if (!imageWidth || !imageHeight) return ES_RECT_1(0);
|
|
int zoomX = ES_RECT_WIDTH(bounds) / imageWidth, zoomY = ES_RECT_HEIGHT(bounds) / imageHeight;
|
|
int zoom = zoomX < 1 || zoomY < 1 ? 1 : zoomX > zoomY ? zoomY : zoomX;
|
|
return EsRectangleCenter(bounds, ES_RECT_2S(imageWidth * zoom, imageHeight * zoom));
|
|
}
|
|
|
|
void MouseEvent(bool pressed, bool released, bool right) {
|
|
if (!imageWidth) return;
|
|
EsPoint point = EsMouseGetPosition(canvas);
|
|
EsRectangle imageBounds = GetImageBounds(EsElementGetInsetBounds(canvas));
|
|
inImageBounds = EsRectangleContains(imageBounds, point.x, point.y);
|
|
int zoom = ES_RECT_WIDTH(imageBounds) / imageWidth;
|
|
domouse((point.x - imageBounds.l) / zoom, (point.y - imageBounds.t) / zoom, pressed, released, right);
|
|
uxn_eval(&u, peek16(devmouse->dat, 0));
|
|
}
|
|
|
|
int CanvasMessage(EsElement *element, EsMessage *message) {
|
|
if (message->type == ES_MSG_PAINT) {
|
|
EsRectangle bounds = EsPainterBoundsInset(message->painter);
|
|
EsRectangle imageBounds = GetImageBounds(bounds);
|
|
EsDrawBitmapScaled(message->painter, imageBounds, ES_RECT_2S(imageWidth, imageHeight), imageBits, imageWidth * 4, ES_DRAW_BITMAP_OPAQUE);
|
|
EsDrawBlock(message->painter, ES_RECT_4(bounds.l, imageBounds.l, bounds.t, bounds.b), 0xFF000000);
|
|
EsDrawBlock(message->painter, ES_RECT_4(imageBounds.r, bounds.r, bounds.t, bounds.b), 0xFF000000);
|
|
EsDrawBlock(message->painter, ES_RECT_4(imageBounds.l, imageBounds.r, bounds.t, imageBounds.t), 0xFF000000);
|
|
EsDrawBlock(message->painter, ES_RECT_4(imageBounds.l, imageBounds.r, imageBounds.b, bounds.b), 0xFF000000);
|
|
} else if (message->type == ES_MSG_MOUSE_MOVED || message->type == ES_MSG_MOUSE_LEFT_DRAG || message->type == ES_MSG_MOUSE_RIGHT_DRAG) {
|
|
MouseEvent(false, false, false);
|
|
} else if (message->type == ES_MSG_MOUSE_LEFT_DOWN) {
|
|
MouseEvent(true, false, false);
|
|
} else if (message->type == ES_MSG_MOUSE_LEFT_UP) {
|
|
MouseEvent(false, true, false);
|
|
} else if (message->type == ES_MSG_MOUSE_RIGHT_DOWN) {
|
|
MouseEvent(true, false, true);
|
|
} else if (message->type == ES_MSG_MOUSE_RIGHT_UP) {
|
|
MouseEvent(false, true, false);
|
|
} else if (message->type == ES_MSG_GET_CURSOR && inImageBounds) {
|
|
message->cursorStyle = ES_CURSOR_BLANK;
|
|
} else if (message->type == ES_MSG_ANIMATE) {
|
|
message->animate.complete = false;
|
|
message->animate.waitMs = 16;
|
|
timeDeltaMs += message->animate.deltaMs;
|
|
bool needsRedraw = reqdraw;
|
|
|
|
while (timeDeltaMs > 16) {
|
|
uxn_eval(&u, peek16(devscreen->dat, 0));
|
|
if(devsystem->dat[0xe]) needsRedraw = true;
|
|
timeDeltaMs -= 16;
|
|
}
|
|
|
|
if (needsRedraw) {
|
|
if (imageWidth != ppu.width || imageHeight != ppu.height) {
|
|
imageWidth = ppu.width, imageHeight = ppu.height;
|
|
imageBits = (uint32_t *) EsHeapReallocate(imageBits, imageWidth * imageHeight * 4, false, NULL);
|
|
}
|
|
|
|
for (uint16_t y = 0; y < ppu.height; y++) {
|
|
for (uint16_t x = 0; x < ppu.width; x++) {
|
|
imageBits[x + y * ppu.width] = palette[get_pixel(x, y)] | 0xFF000000;
|
|
}
|
|
}
|
|
|
|
EsRectangle imageBounds = GetImageBounds(EsElementGetInsetBounds(element));
|
|
EsElementRepaint(element, &imageBounds);
|
|
reqdraw = false;
|
|
}
|
|
} else {
|
|
return 0;
|
|
}
|
|
|
|
return ES_HANDLED;
|
|
}
|
|
|
|
void _start() {
|
|
while (true) {
|
|
EsMessage *message = EsMessageReceive();
|
|
|
|
if (message->type == ES_MSG_INSTANCE_CREATE) {
|
|
EsInstance *instance = EsInstanceCreate(message, "Uxn Emulator", -1);
|
|
canvas = EsCustomElementCreate(instance->window, ES_CELL_FILL, ES_STYLE_PANEL_WINDOW_DIVIDER);
|
|
canvas->messageUser = (EsUICallback) CanvasMessage;
|
|
EsElementStartAnimating(canvas);
|
|
} else if (message->type == ES_MSG_INSTANCE_OPEN) {
|
|
size_t romBytes;
|
|
void *rom = EsFileStoreReadAll(message->instanceOpen.file, &romBytes);
|
|
EsInstanceOpenComplete(message, rom && Launch(rom, romBytes), NULL, 0);
|
|
EsHeapFree(rom, 0, NULL);
|
|
}
|
|
}
|
|
}
|