Implement double buffering drawing

1 files changed, 50 insertions, 20 deletions

diff --git a/src/uxn/devices/ppu.c b/src/uxn/devices/ppu.c
index 836b7f0..d9208a5 100644
--- a/src/uxn/devices/ppu.c
+++ b/src/uxn/devices/ppu.c
@@ -32,6 +32,10 @@ static Uint8 font[][8] = {
     {0x00, 0x7c, 0x82, 0x80, 0xf0, 0x80, 0x82, 0x7c},
     {0x00, 0x7c, 0x82, 0x80, 0xf0, 0x80, 0x80, 0x80}};
 
+u32 *backbuffer_bg0;
+u32 *backbuffer_bg1;
+static u8 dirty_tiles[20][30] = {0};
+
 void
 putcolors(Ppu *p, Uint8 *addr) {
     int i;
@@ -49,31 +53,38 @@ putcolors(Ppu *p, Uint8 *addr) {
 
 void
 putpixel(Ppu *p, Uint32 *layer, Uint16 x, Uint16 y, Uint8 color) {
-    if(x >= 30 * 8 || y >= 20 * 8)
-        return;
-
     Uint32 pos = ((y & 7) + (((x >> 3) + (y >> 3) * 30) * 8));
     Uint32 shift = (x & 7) << 2;
     layer[pos] = (layer[pos] & (~(0xF << shift))) | (color << shift);
+    dirty_tiles[y >> 3][x >> 3] = 1;
 }
 
 void
-puticn(Ppu *p, Uint32 *layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color, Uint8 flipx, Uint8 flipy) {
+puticn(Ppu *p, Uint32 *layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color,
+        Uint8 flipx, Uint8 flipy) {
     Uint16 v, h;
-    for(v = 0; v < 8; v++)
+    for(v = 0; v < 8; v++) {
         for(h = 0; h < 8; h++) {
             Uint8 ch1 = ((sprite[v] >> (7 - h)) & 0x1);
-            if(ch1 == 1 || (color != 0x05 && color != 0x0a && color != 0x0f))
-                putpixel(p,
-                    layer,
-                    x + (flipx ? 7 - h : h),
-                    y + (flipy ? 7 - v : v),
-                    ch1 ? color % 4 : color / 4);
+            // if(ch1 == 1 || (color != 0x05 && color != 0x0a && color != 0x0f))
+                // putpixel(p,
+                //     layer,
+                //     x + (flipx ? 7 - h : h),
+                //     y + (flipy ? 7 - v : v),
+                //     ch1 ? color % 4 : color / 4);
+            // TODO: Add flip options directly to the screenblock?
+            putpixel(p,
+                layer,
+                x + h,
+                y + v,
+                ch1 ? color & 0x3 : color >> 2);
         }
+    }
 }
 
 void
-putchr(Ppu *p, Uint32 *layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color, Uint8 flipx, Uint8 flipy) {
+putchr(Ppu *p, Uint32 *layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color,
+        Uint8 flipx, Uint8 flipy) {
     Uint16 v, h;
     for(v = 0; v < 8; v++)
         for(h = 0; h < 8; h++) {
@@ -87,6 +98,23 @@ putchr(Ppu *p, Uint32 *layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color, Ui
         }
 }
 
+void
+flipbuf(Ppu *p) {
+    Tile *mem_fg = &TILE_MEM[0];
+    Tile *mem_bg = &TILE_MEM[2];
+    for (size_t j = 0; j < 20; ++j) {
+        for (size_t i = 0; i < 30; ++i) {
+            if (dirty_tiles[j][i] != 0) {
+                Tile *tile_fg = p->fg;
+                Tile *tile_bg = p->bg;
+                mem_fg[i + j * 30] = tile_fg[i + j * 30];
+                mem_bg[i + j * 30] = tile_bg[i + j * 30];
+                dirty_tiles[j][i] = 0;
+            }
+        }
+    }
+}
+
 int
 initppu(Ppu *p, Uint8 hor, Uint8 ver, Uint8 pad) {
     p->hor = hor;
@@ -100,15 +128,19 @@ initppu(Ppu *p, Uint8 hor, Uint8 ver, Uint8 pad) {
 
     // Initialize backgrounds.
     u8 cb_fg = 0;
-    u8 sb_fg = 10;
     u8 cb_bg = 2;
-    u8 sb_bg = 26;
-    BG_CTRL(0) = BG_CHARBLOCK(cb_fg) | BG_SCREENBLOCK(sb_fg) | BG_PRIORITY(1);
-    BG_CTRL(1) = BG_CHARBLOCK(cb_bg) | BG_SCREENBLOCK(sb_bg) | BG_PRIORITY(2);
+    u8 sb_idx = 10;
+    BG_CTRL(0) = BG_CHARBLOCK(cb_fg) | BG_SCREENBLOCK(sb_idx) | BG_PRIORITY(1);
+    BG_CTRL(1) = BG_CHARBLOCK(cb_bg) | BG_SCREENBLOCK(sb_idx) | BG_PRIORITY(2);
+
+    backbuffer_bg0 = malloc(30 * 20 * sizeof(Tile));
+    backbuffer_bg1 = malloc(30 * 20 * sizeof(Tile));
 
     // Clear tile memory.
     p->fg = &TILE_MEM[cb_fg];
     p->bg = &TILE_MEM[cb_bg];
+    p->fg = backbuffer_bg0;
+    p->bg = backbuffer_bg1;
     for (size_t i = 0; i < 30 * 20 * 8; ++i) {
         p->fg[i] = 0;
         p->bg[i] = 0;
@@ -121,13 +153,11 @@ initppu(Ppu *p, Uint8 hor, Uint8 ver, Uint8 pad) {
     PAL_BUFFER_BG[3] = COLOR_BLUE;
 
     // Initialize memory map.
-    u16 *fg_mem = SCREENBLOCK_MEM[sb_fg];
-    u16 *bg_mem = SCREENBLOCK_MEM[sb_bg];
+    u16 *mem_map = SCREENBLOCK_MEM[sb_idx];
     size_t k = 0;
     for (size_t j = 0; j < 20; ++j) {
         for (size_t i = 0; i < 30; ++i, ++k) {
-            fg_mem[i + j * 32] = k;
-            bg_mem[i + j * 32] = k;
+            mem_map[i + j * 32] = k;
         }
     }