Renamed PPU to Screen

build.sh

@@ -14,8 +14,8 @@ then
 	echo "Formatting.."
 	clang-format -i src/uxn.h
 	clang-format -i src/uxn.c
-	clang-format -i src/devices/ppu.h
+	clang-format -i src/devices/screen.h
-	clang-format -i src/devices/ppu.c
+	clang-format -i src/devices/screen.c
 	clang-format -i src/devices/apu.h
 	clang-format -i src/devices/apu.c
 	clang-format -i src/devices/file.h
@@ -62,7 +62,7 @@ fi
 
 echo "Building.."
 ${CC} ${CFLAGS} src/uxnasm.c -o bin/uxnasm
-${CC} ${CFLAGS} ${CORE} src/devices/file.c src/devices/mouse.c src/devices/controller.c src/devices/ppu.c src/devices/apu.c src/uxnemu.c ${UXNEMU_LDFLAGS} -o bin/uxnemu
+${CC} ${CFLAGS} ${CORE} src/devices/file.c src/devices/mouse.c src/devices/controller.c src/devices/screen.c src/devices/apu.c src/uxnemu.c ${UXNEMU_LDFLAGS} -o bin/uxnemu
 ${CC} ${CFLAGS} ${CORE} src/devices/file.c src/uxncli.c -o bin/uxncli
 
 if [ -d "$HOME/bin" ]

mkfile

@@ -8,7 +8,7 @@ HFILES=\
 	/sys/include/npe/stdio.h\
 	src/devices/apu.h\
 	src/devices/file.h\
-	src/devices/ppu.h\
+	src/devices/screen.h\
 	src/uxn.h\
 
 CLEANFILES=$TARG $ROM
@@ -35,13 +35,13 @@ bin/uxncli: file.$O uxncli.$O uxn.$O
 bin/uxnasm: uxnasm.$O
 	$LD $LDFLAGS -o $target $prereq
 
-bin/uxnemu: uxnemu.$O apu.$O file.$O ppu.$O uxn.$O
+bin/uxnemu: uxnemu.$O apu.$O file.$O screen.$O uxn.$O
 	$LD $LDFLAGS -o $target $prereq
 
 (uxnasm|uxncli|uxnemu|uxn)\.$O:R: src/\1.c
 	$CC $CFLAGS -Isrc -o $target src/$stem1.c
 
-(apu|file|ppu)\.$O:R: src/devices/\1.c
+(apu|file|screen)\.$O:R: src/devices/\1.c
 	$CC $CFLAGS -Isrc -o $target src/devices/$stem1.c
 
 nuke:V: clean

src/devices/ppu.h

@@ -1,37 +0,0 @@
-#include <stdlib.h>
-
-/*
-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.
-*/
-
-typedef unsigned char Uint8;
-typedef unsigned short Uint16;
-typedef unsigned int Uint32;
-
-typedef struct Layer {
-	Uint8 *pixels;
-	Uint8 changed;
-} Layer;
-
-typedef struct Ppu {
-	Uint32 palette[4], *screen;
-	Uint16 width, height;
-	Layer fg, bg;
-} Ppu;
-
-void ppu_palette(Ppu *p, Uint8 *addr);
-void ppu_resize(Ppu *p, Uint16 width, Uint16 height);
-void ppu_clear(Ppu *p, Layer *layer);
-void ppu_redraw(Ppu *p, Uint32 *screen);
-
-void ppu_write(Ppu *p, Layer *layer, Uint16 x, Uint16 y, Uint8 color);
-void ppu_blit(Ppu *p, Layer *layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color, Uint8 flipx, Uint8 flipy, Uint8 twobpp);
-void ppu_debug(Ppu *p, Uint8 *stack, Uint8 wptr, Uint8 rptr, Uint8 *memory);

src/devices/screen.c

@@ -1,4 +1,5 @@
-#include "ppu.h"
+#include "../uxn.h"
+#include "screen.h"
 
 /*
 Copyright (c) 2021 Devine Lu Linvega
@@ -12,6 +13,8 @@ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 WITH REGARD TO THIS SOFTWARE.
 */
 
+Screen screen;
+
 static Uint8 blending[5][16] = {
 	{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},
@@ -37,8 +40,39 @@ static Uint8 font[][8] = {
 	{0x00, 0x7c, 0x82, 0x80, 0xf0, 0x80, 0x82, 0x7c},
 	{0x00, 0x7c, 0x82, 0x80, 0xf0, 0x80, 0x80, 0x80}};
 
+static void
+screen_write(Screen *p, Layer *layer, Uint16 x, Uint16 y, Uint8 color)
+{
+	if(x < p->width && y < p->height) {
+		Uint32 i = x + y * p->width;
+		Uint8 prev = layer->pixels[i];
+		if(color != prev) {
+			layer->pixels[i] = color;
+			layer->changed = 1;
+		}
+	}
+}
+
+static void
+screen_blit(Screen *p, Layer *layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color, Uint8 flipx, Uint8 flipy, Uint8 twobpp)
+{
+	int v, h, opaque = blending[4][color];
+	for(v = 0; v < 8; ++v) {
+		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]);
+		}
+	}
+}
+
 void
-ppu_palette(Ppu *p, Uint8 *addr)
+screen_palette(Screen *p, Uint8 *addr)
 {
 	int i, shift;
 	for(i = 0, shift = 4; i < 4; ++i, shift ^= 4) {
@@ -53,27 +87,27 @@ ppu_palette(Ppu *p, Uint8 *addr)
 }
 
 void
-ppu_resize(Ppu *p, Uint16 width, Uint16 height)
+screen_resize(Screen *p, Uint16 width, Uint16 height)
 {
 	Uint8
 		*bg = realloc(p->bg.pixels, width * height),
 		*fg = realloc(p->fg.pixels, width * height);
 	Uint32
-		*screen = realloc(p->screen, width * height * sizeof(Uint32));
+		*pixels = realloc(p->pixels, width * height * sizeof(Uint32));
 	if(bg) p->bg.pixels = bg;
 	if(fg) p->fg.pixels = fg;
-	if(screen) p->screen = screen;
+	if(pixels) p->pixels = pixels;
-	if(bg && fg && screen) {
+	if(bg && fg && pixels) {
 		p->width = width;
 		p->height = height;
-		p->screen = screen;
+		p->pixels = pixels;
-		ppu_clear(p, &p->bg);
+		screen_clear(p, &p->bg);
-		ppu_clear(p, &p->fg);
+		screen_clear(p, &p->fg);
 	}
 }
 
 void
-ppu_clear(Ppu *p, Layer *layer)
+screen_clear(Screen *p, Layer *layer)
 {
 	Uint32 i, size = p->width * p->height;
 	for(i = 0; i < size; ++i)
@@ -82,72 +116,87 @@ ppu_clear(Ppu *p, Layer *layer)
 }
 
 void
-ppu_redraw(Ppu *p, Uint32 *screen)
+screen_redraw(Screen *p, Uint32 *pixels)
 {
 	Uint32 i, size = p->width * p->height, palette[16];
 	for(i = 0; i < 16; ++i)
 		palette[i] = p->palette[(i >> 2) ? (i >> 2) : (i & 3)];
 	for(i = 0; i < size; ++i)
-		screen[i] = palette[p->fg.pixels[i] << 2 | p->bg.pixels[i]];
+		pixels[i] = palette[p->fg.pixels[i] << 2 | p->bg.pixels[i]];
 	p->fg.changed = p->bg.changed = 0;
 }
 
 void
-ppu_write(Ppu *p, Layer *layer, Uint16 x, Uint16 y, Uint8 color)
+screen_debug(Screen *p, Uint8 *stack, Uint8 wptr, Uint8 rptr, Uint8 *memory)
-{
-	if(x < p->width && y < p->height) {
-		Uint32 i = x + y * p->width;
-		Uint8 prev = layer->pixels[i];
-		if(color != prev) {
-			layer->pixels[i] = color;
-			layer->changed = 1;
-		}
-	}
-}
-
-void
-ppu_blit(Ppu *p, Layer *layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color, Uint8 flipx, Uint8 flipy, Uint8 twobpp)
-{
-	int v, h, opaque = blending[4][color];
-	for(v = 0; v < 8; ++v) {
-		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)
-				ppu_write(p,
-					layer,
-					x + (flipx ? 7 - h : h),
-					y + (flipy ? 7 - v : v),
-					blending[ch][color]);
-		}
-	}
-}
-
-void
-ppu_debug(Ppu *p, Uint8 *stack, Uint8 wptr, Uint8 rptr, Uint8 *memory)
 {
 	Uint8 i, x, y, b;
 	for(i = 0; i < 0x20; ++i) {
 		x = ((i % 8) * 3 + 1) * 8, y = (i / 8 + 1) * 8, b = stack[i];
 		/* working stack */
-		ppu_blit(p, &p->fg, x, y, font[(b >> 4) & 0xf], 1 + (wptr == i) * 0x7, 0, 0, 0);
+		screen_blit(p, &p->fg, x, y, font[(b >> 4) & 0xf], 1 + (wptr == i) * 0x7, 0, 0, 0);
-		ppu_blit(p, &p->fg, x + 8, y, font[b & 0xf], 1 + (wptr == i) * 0x7, 0, 0, 0);
+		screen_blit(p, &p->fg, x + 8, y, font[b & 0xf], 1 + (wptr == i) * 0x7, 0, 0, 0);
 		y = 0x28 + (i / 8 + 1) * 8;
 		b = memory[i];
 		/* return stack */
-		ppu_blit(p, &p->fg, x, y, font[(b >> 4) & 0xf], 3, 0, 0, 0);
+		screen_blit(p, &p->fg, x, y, font[(b >> 4) & 0xf], 3, 0, 0, 0);
-		ppu_blit(p, &p->fg, x + 8, y, font[b & 0xf], 3, 0, 0, 0);
+		screen_blit(p, &p->fg, x + 8, y, font[b & 0xf], 3, 0, 0, 0);
 	}
 	/* return pointer */
-	ppu_blit(p, &p->fg, 0x8, y + 0x10, font[(rptr >> 4) & 0xf], 0x2, 0, 0, 0);
+	screen_blit(p, &p->fg, 0x8, y + 0x10, font[(rptr >> 4) & 0xf], 0x2, 0, 0, 0);
-	ppu_blit(p, &p->fg, 0x10, y + 0x10, font[rptr & 0xf], 0x2, 0, 0, 0);
+	screen_blit(p, &p->fg, 0x10, y + 0x10, font[rptr & 0xf], 0x2, 0, 0, 0);
 	/* guides */
 	for(x = 0; x < 0x10; ++x) {
-		ppu_write(p, &p->fg, x, p->height / 2, 2);
+		screen_write(p, &p->fg, x, p->height / 2, 2);
-		ppu_write(p, &p->fg, p->width - x, p->height / 2, 2);
+		screen_write(p, &p->fg, p->width - x, p->height / 2, 2);
-		ppu_write(p, &p->fg, p->width / 2, p->height - x, 2);
+		screen_write(p, &p->fg, p->width / 2, p->height - x, 2);
-		ppu_write(p, &p->fg, p->width / 2, x, 2);
+		screen_write(p, &p->fg, p->width / 2, x, 2);
-		ppu_write(p, &p->fg, p->width / 2 - 0x10 / 2 + x, p->height / 2, 2);
+		screen_write(p, &p->fg, p->width / 2 - 0x10 / 2 + x, p->height / 2, 2);
-		ppu_write(p, &p->fg, p->width / 2, p->height / 2 - 0x10 / 2 + x, 2);
+		screen_write(p, &p->fg, p->width / 2, p->height / 2 - 0x10 / 2 + x, 2);
+	}
+}
+
+/* APIs */
+
+Uint8
+screen_dei(Device *d, Uint8 port)
+{
+	switch(port) {
+	case 0x2: return screen.width >> 8;
+	case 0x3: return screen.width;
+	case 0x4: return screen.height >> 8;
+	case 0x5: return screen.height;
+	default: return d->dat[port];
+	}
+}
+
+void
+screen_deo(Device *d, Uint8 port)
+{
+	switch(port) {
+	case 0x1: d->vector = peek16(d->dat, 0x0); break;
+	case 0x5:
+		/* TODO: 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;
+		screen_write(&screen, layer ? &screen.fg : &screen.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) ? &screen.fg : &screen.bg;
+		Uint8 *addr = &d->mem[peek16(d->dat, 0xc)];
+		Uint8 twobpp = !!(d->dat[0xf] & 0x80);
+		screen_blit(&screen, 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;
+	}
 	}
 }

src/devices/screen.h

@@ -0,0 +1,37 @@
+#include <stdlib.h>
+
+/*
+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.
+*/
+
+#define FIXED_SIZE 0
+
+typedef struct Layer {
+	Uint8 *pixels;
+	Uint8 changed;
+} Layer;
+
+typedef struct Screen {
+	Uint32 palette[4], *pixels;
+	Uint16 width, height;
+	Layer fg, bg;
+} Screen;
+
+extern Screen screen;
+
+void screen_palette(Screen *p, Uint8 *addr);
+void screen_resize(Screen *p, Uint16 width, Uint16 height);
+void screen_clear(Screen *p, Layer *layer);
+void screen_redraw(Screen *p, Uint32 *pixels);
+void screen_debug(Screen *p, Uint8 *stack, Uint8 wptr, Uint8 rptr, Uint8 *memory);
+
+Uint8 screen_dei(Device *d, Uint8 port);
+void screen_deo(Device *d, Uint8 port);

src/uxnemu.c

@@ -8,7 +8,7 @@
 #pragma GCC diagnostic ignored "-Wpedantic"
 #pragma clang diagnostic ignored "-Wtypedef-redefinition"
 #include <SDL.h>
-#include "devices/ppu.h"
+#include "devices/screen.h"
 #include "devices/apu.h"
 #include "devices/file.h"
 #include "devices/controller.h"
@@ -30,7 +30,6 @@ WITH REGARD TO THIS SOFTWARE.
 #define WIDTH 64 * 8
 #define HEIGHT 40 * 8
 #define PAD 4
-#define FIXED_SIZE 0
 #define POLYPHONY 4
 #define BENCH 0
 
@@ -39,8 +38,9 @@ static SDL_Texture *gTexture;
 static SDL_Renderer *gRenderer;
 static SDL_AudioDeviceID audio_id;
 static SDL_Rect gRect;
+
 /* devices */
-static Ppu ppu;
+
 static Apu apu[POLYPHONY];
 static Device *devsystem, *devscreen, *devmouse, *devctrl, *devaudio0, *devconsole;
 static Uint8 zoom = 1;
@@ -106,20 +106,20 @@ set_window_size(SDL_Window *window, int w, int h)
 static int
 set_size(Uint16 width, Uint16 height, int is_resize)
 {
-	ppu_resize(&ppu, width, height);
+	screen_resize(&screen, width, height);
 	gRect.x = PAD;
 	gRect.y = PAD;
-	gRect.w = ppu.width;
+	gRect.w = screen.width;
-	gRect.h = ppu.height;
+	gRect.h = screen.height;
 	if(gTexture != NULL) SDL_DestroyTexture(gTexture);
-	SDL_RenderSetLogicalSize(gRenderer, ppu.width + PAD * 2, ppu.height + PAD * 2);
+	SDL_RenderSetLogicalSize(gRenderer, screen.width + PAD * 2, screen.height + PAD * 2);
-	gTexture = SDL_CreateTexture(gRenderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STATIC, ppu.width + PAD * 2, ppu.height + PAD * 2);
+	gTexture = SDL_CreateTexture(gRenderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STATIC, screen.width + PAD * 2, screen.height + PAD * 2);
 	if(gTexture == NULL || SDL_SetTextureBlendMode(gTexture, SDL_BLENDMODE_NONE))
 		return error("gTexture", SDL_GetError());
-	if(SDL_UpdateTexture(gTexture, NULL, ppu.screen, sizeof(Uint32)) != 0)
+	if(SDL_UpdateTexture(gTexture, NULL, screen.pixels, sizeof(Uint32)) != 0)
 		return error("SDL_UpdateTexture", SDL_GetError());
 	if(is_resize)
-		set_window_size(gWindow, (ppu.width + PAD * 2) * zoom, (ppu.height + PAD * 2) * zoom);
+		set_window_size(gWindow, (screen.width + PAD * 2) * zoom, (screen.height + PAD * 2) * zoom);
 	return 1;
 }
 
@@ -127,9 +127,9 @@ static void
 redraw(Uxn *u)
 {
 	if(devsystem->dat[0xe])
-		ppu_debug(&ppu, u->wst.dat, u->wst.ptr, u->rst.ptr, u->ram.dat);
+		screen_debug(&screen, u->wst.dat, u->wst.ptr, u->rst.ptr, u->ram.dat);
-	ppu_redraw(&ppu, ppu.screen);
+	screen_redraw(&screen, screen.pixels);
-	if(SDL_UpdateTexture(gTexture, &gRect, ppu.screen, ppu.width * sizeof(Uint32)) != 0)
+	if(SDL_UpdateTexture(gTexture, &gRect, screen.pixels, screen.width * sizeof(Uint32)) != 0)
 		error("SDL_UpdateTexture", SDL_GetError());
 	SDL_RenderClear(gRenderer);
 	SDL_RenderCopy(gRenderer, gTexture, NULL, NULL);
@@ -197,7 +197,7 @@ system_deo(Device *d, Uint8 port)
 	case 0x3: d->u->rst.ptr = d->dat[port]; break;
 	}
 	if(port > 0x7 && port < 0xe)
-		ppu_palette(&ppu, &d->dat[0x8]);
+		screen_palette(&screen, &d->dat[0x8]);
 }
 
 static void
@@ -209,50 +209,6 @@ console_deo(Device *d, Uint8 port)
 		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
 audio_dei(Device *d, Uint8 port)
 {
@@ -370,14 +326,14 @@ static void
 set_zoom(Uint8 scale)
 {
 	zoom = clamp(scale, 1, 3);
-	set_window_size(gWindow, (ppu.width + PAD * 2) * zoom, (ppu.height + PAD * 2) * zoom);
+	set_window_size(gWindow, (screen.width + PAD * 2) * zoom, (screen.height + PAD * 2) * zoom);
 }
 
 static void
 toggle_debugger(void)
 {
 	devsystem->dat[0xe] = !devsystem->dat[0xe];
-	ppu_clear(&ppu, &ppu.fg);
+	screen_clear(&screen, &screen.fg);
 }
 
 static void
@@ -502,8 +458,8 @@ run(Uxn *u)
 			/* Mouse */
 			else if(event.type == SDL_MOUSEMOTION)
 				mouse_pos(devmouse,
-					clamp(event.motion.x - PAD, 0, ppu.width - 1),
+					clamp(event.motion.x - PAD, 0, screen.width - 1),
-					clamp(event.motion.y - PAD, 0, ppu.height - 1));
+					clamp(event.motion.y - PAD, 0, screen.height - 1));
 			else if(event.type == SDL_MOUSEBUTTONUP)
 				mouse_up(devmouse, 0x1 << (event.button.button - 1));
 			else if(event.type == SDL_MOUSEBUTTONDOWN)
@@ -537,7 +493,7 @@ run(Uxn *u)
 				console_input(u, event.cbutton.button);
 		}
 		uxn_eval(u, devscreen->vector);
-		if(ppu.fg.changed || ppu.bg.changed || devsystem->dat[0xe])
+		if(screen.fg.changed || screen.bg.changed || devsystem->dat[0xe])
 			redraw(u);
 		if(!BENCH) {
 			elapsed = (SDL_GetPerformanceCounter() - begin) / (double)SDL_GetPerformanceFrequency() * 1000.0f;