uxn11/uxn11.c

#include <stdio.h>
#include <time.h>
#include <unistd.h>

#include <X11/Xlib.h>
#include <stdlib.h>
#include <string.h>

#define WIDTH 64 * 8
#define HEIGHT 40 * 8
#define FIXED_SIZE 0

#include "uxn.h"

#include "devices/ppu.h"
static Ppu ppu;

static Device *devsystem, *devconsole, *devscreen;
static Uint32 *ppu_screen;

static int
error(char *msg, const char *err)
{
	fprintf(stderr, "Error %s: %s\n", msg, err);
	return 0;
}

static int
set_size(Uint16 width, Uint16 height, int is_resize)
{
	ppu_resize(&ppu, width, height);
	if(!(ppu_screen =
			   realloc(ppu_screen, ppu.width * ppu.height * sizeof(Uint32))))
		return error("ppu_screen", "Memory failure");
	memset(ppu_screen, 0, ppu.width * ppu.height * sizeof(Uint32));
	printf("%d x %d(%d)\n", width, height, is_resize);
	return 1;
}

static Uint8
system_dei(Device *d, Uint8 port)
{
	switch(port) {
	case 0x2:
		return d->u->wst.ptr;
	case 0x3:
		return d->u->rst.ptr;
	default:
		return d->dat[port];
	}
}

static void
system_deo(Device *d, Uint8 port)
{
	switch(port) {
	case 0x2:
		d->u->wst.ptr = d->dat[port];
		break;
	case 0x3:
		d->u->rst.ptr = d->dat[port];
		break;
	}
	if(port > 0x7 && port < 0xe)
		ppu_palette(&ppu, &d->dat[0x8]);
}

static void
console_deo(Device *d, Uint8 port)
{
	if(port == 0x1)
		d->vector = peek16(d->dat, 0x0);
	if(port > 0x7)
		write(port - 0x7, (char *)&d->dat[port], 1);
}

static Uint8
screen_dei(Device *d, Uint8 port)
{
	switch(port) {
	case 0x2:
		return ppu.width >> 8;
	case 0x3:
		return ppu.width;
	case 0x4:
		return ppu.height >> 8;
	case 0x5:
		return ppu.height;
	default:
		return d->dat[port];
	}
}

static void
screen_deo(Device *d, Uint8 port)
{
	switch(port) {
	case 0x1:
		d->vector = peek16(d->dat, 0x0);
		break;
	case 0x5:
		if(!FIXED_SIZE)
			set_size(peek16(d->dat, 0x2), peek16(d->dat, 0x4), 1);
		break;
	case 0xe: {
		Uint16 x = peek16(d->dat, 0x8);
		Uint16 y = peek16(d->dat, 0xa);
		Uint8 layer = d->dat[0xe] & 0x40;
		ppu_write(&ppu, layer ? &ppu.fg : &ppu.bg, 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);
		Layer *layer = (d->dat[0xf] & 0x40) ? &ppu.fg : &ppu.bg;
		Uint8 *addr = &d->mem[peek16(d->dat, 0xc)];
		Uint8 twobpp = !!(d->dat[0xf] & 0x80);
		ppu_blit(&ppu, layer, x, y, addr, d->dat[0xf] & 0xf, d->dat[0xf] & 0x10, d->dat[0xf] & 0x20, twobpp);
		if(d->dat[0x6] & 0x04)
			poke16(d->dat, 0xc, peek16(d->dat, 0xc) + 8 + twobpp * 8); /* auto addr+8 / auto addr+16 */
		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;
	}
	}
}

static Uint8
nil_dei(Device *d, Uint8 port)
{
	return d->dat[port];
}

static void
nil_deo(Device *d, Uint8 port)
{
	if(port == 0x1)
		d->vector = peek16(d->dat, 0x0);
}

static const char *errors[] = {"underflow", "overflow", "division by zero"};

int
uxn_halt(Uxn *u, Uint8 error, char *name, int id)
{
	fprintf(stderr, "Halted: %s %s#%04x, at 0x%04x\n", name, errors[error - 1], id, u->ram.ptr);
	return 0;
}

static int
load(Uxn *u, char *filepath)
{
	FILE *f;
	int r;
	if(!(f = fopen(filepath, "rb")))
		return 0;
	r = fread(u->ram.dat + PAGE_PROGRAM, 1, sizeof(u->ram.dat) - PAGE_PROGRAM, f);
	fclose(f);
	if(r < 1)
		return 0;
	fprintf(stderr, "Loaded %s\n", filepath);
	return 1;
}

// ---------------------------

void
processEvent(Display *display, Window window, XImage *ximage, int width, int height)
{
	static char *tir = "This is red";
	static char *tig = "This is green";
	static char *tib = "This is blue";
	XEvent ev;
	XNextEvent(display, &ev);
	switch(ev.type) {
	case Expose:
		XPutImage(display, window, DefaultGC(display, 0), ximage, 0, 0, 0, 0, width, height);
		XSetForeground(display, DefaultGC(display, 0), 0x00ff0000); // red
		XDrawString(display, window, DefaultGC(display, 0), 32, 32, tir, strlen(tir));
		XDrawString(display, window, DefaultGC(display, 0), 32 + 256, 32, tir, strlen(tir));
		XDrawString(display, window, DefaultGC(display, 0), 32 + 256, 32 + 256, tir, strlen(tir));
		XDrawString(display, window, DefaultGC(display, 0), 32, 32 + 256, tir, strlen(tir));
		XSetForeground(display, DefaultGC(display, 0), 0x0000ff00); // green
		XDrawString(display, window, DefaultGC(display, 0), 32, 52, tig, strlen(tig));
		XDrawString(display, window, DefaultGC(display, 0), 32 + 256, 52, tig, strlen(tig));
		XDrawString(display, window, DefaultGC(display, 0), 32 + 256, 52 + 256, tig, strlen(tig));
		XDrawString(display, window, DefaultGC(display, 0), 32, 52 + 256, tig, strlen(tig));
		XSetForeground(display, DefaultGC(display, 0), 0x000000ff); // blue
		XDrawString(display, window, DefaultGC(display, 0), 32, 72, tib, strlen(tib));
		XDrawString(display, window, DefaultGC(display, 0), 32 + 256, 72, tib, strlen(tib));
		XDrawString(display, window, DefaultGC(display, 0), 32 + 256, 72 + 256, tib, strlen(tib));
		XDrawString(display, window, DefaultGC(display, 0), 32, 72 + 256, tib, strlen(tib));
		break;
	case ButtonPress:
		exit(0);
	}
}

int
main(int argc, char **argv)
{

	Uxn u;
	int i, loaded = 0;

	if(!uxn_boot(&u))
		return error("Boot", "Failed");

	/* system   */ devsystem = uxn_port(&u, 0x0, system_dei, system_deo);
	/* console  */ devconsole = uxn_port(&u, 0x1, nil_dei, console_deo);
	/* screen   */ devscreen = uxn_port(&u, 0x2, screen_dei, screen_deo);
	/* empty    */ uxn_port(&u, 0x3, nil_dei, nil_deo);
	/* empty    */ uxn_port(&u, 0x4, nil_dei, nil_deo);
	/* empty    */ uxn_port(&u, 0x5, nil_dei, nil_deo);
	/* empty    */ uxn_port(&u, 0x6, nil_dei, nil_deo);
	/* empty    */ uxn_port(&u, 0x7, nil_dei, nil_deo);
	/* empty    */ uxn_port(&u, 0x8, nil_dei, nil_deo);
	/* empty    */ uxn_port(&u, 0x9, nil_dei, nil_deo);
	/* file     */ uxn_port(&u, 0xa, nil_dei, nil_deo);
	/* datetime */ uxn_port(&u, 0xb, nil_dei, nil_deo);
	/* empty    */ uxn_port(&u, 0xc, nil_dei, nil_deo);
	/* empty    */ uxn_port(&u, 0xd, nil_dei, nil_deo);
	/* empty    */ uxn_port(&u, 0xe, nil_dei, nil_deo);
	/* empty    */ uxn_port(&u, 0xf, nil_dei, nil_deo);

	for(i = 1; i < argc; ++i) {
		if(!loaded++) {
			if(!load(&u, argv[i]))
				return error("Load", "Failed");
			if(!uxn_eval(&u, PAGE_PROGRAM))
				return error("Init", "Failed");
		}
	}
	if(!loaded)
		return error("Input", "Missing");

	if(!set_size(WIDTH, HEIGHT, 0))
		return error("Window", "Failed to set window size.");

	if(!uxn_eval(&u, PAGE_PROGRAM))
		return error("Boot", "Failed to start rom.");
	ppu_redraw(&ppu, ppu_screen);

	XImage *ximage;
	Display *display = XOpenDisplay(NULL);
	Visual *visual = DefaultVisual(display, 0);
	Window window = XCreateSimpleWindow(display, RootWindow(display, 0), 0, 0, ppu.width, ppu.height, 1, 0, 0);
	if(visual->class != TrueColor) {
		fprintf(stderr, "Cannot handle non true color visual ...\n");
		exit(1);
	}

	ximage = XCreateImage(display, visual, DefaultDepth(display, DefaultScreen(display)), ZPixmap, 0, (Uint8 *)ppu_screen, ppu.width, ppu.height, 32, 0);

	XSelectInput(display, window, ButtonPressMask | ExposureMask);
	XMapWindow(display, window);
	while(1) {
		processEvent(display, window, ximage, ppu.width, ppu.height);
	}
}