Add a 3rd BG to act as a shade while BG register changes

This helps create a double buffering effect but unfortunately due to
delays in setting up BG priority, this creates tearing artifacts.

2 files changed, 70 insertions, 87 deletions

diff --git a/src/main.c b/src/main.c
index a7bad92..a52ad7c 100644
--- a/src/main.c
+++ b/src/main.c
@@ -119,24 +119,25 @@ int main(void) {
     // Register interrupts.
     irq_init();
     irs_set(IRQ_VBLANK, irs_stub);
-
-    // Initialize sequencer.
-    // flip_buffer();
-    // screen_fill(1);
-    // screen_fill(2);
-    // backbuf[0] = 0x11111111;
-    // screen_fill(1);
-    // flip_buffer();
-    // screen_fill(2);
-    // flip_buffer();
+    flip_buffer();
 
     // Main loop.
     PROF_INIT();
+    int x = 0;
+    int inc = 1;
     while (true) {
         bios_vblank_wait();
 
         PROF(test_clear(), test_clear_cycles);
         // PROF(test_lines(), test_lines_cycles);
+        draw_rect(0 + x, 0, 100 + x, 100, 2);
+        x += inc;
+        if (x >= 50) {
+            inc = -8;
+        } else if (x <= 0) {
+            inc = 8;
+        }
+        // draw_rect(50, 10, 200, 110, 1);
         // PROF(test_rect(), test_rect_cycles);
         // PROF(test_fill_rect(), test_fill_rect_cycles);
         // PROF(test_chr(), test_chr_cycles);
diff --git a/src/renderer_m0.c b/src/renderer_m0.c
index 3034d40..b0d4a6e 100644
--- a/src/renderer_m0.c
+++ b/src/renderer_m0.c
@@ -27,8 +27,12 @@
 // Charblock and screenblock for both render buffers.
 #define CB_0 0
 #define CB_1 1
+// NOTE: CB_2 could be at the end of 2 (0x0600:8000) since we only need a clear
+// color tile. Testing at 3 for now.
+#define CB_2 3
 #define SB_0 20
 #define SB_1 21
+#define SB_2 23
 
 // Available storage for other memory.
 // #define FG_PIXELS ((u32*)(MEM_VRAM + KB(44)))
@@ -71,11 +75,11 @@ static u32 *backbuf = BUF_1;
 
 IWRAM_CODE
 void screen_fill(u8 clr)  {
-#if 0
-//     u32 *dst = backbuf;
-//     for(int i = 0; i < KB(75) / 8; i++) {
-//         *dst++ = 0x01010101 * clr;
-//     }
+#if 1
+    u32 *dst = backbuf;
+    for(int i = 0; i < KB(20) / 4; i++) {
+        *dst++ = 0x11111111 * clr;
+    }
 #else
     dma_fill(backbuf, 0x11111111 * clr, KB(20), 3);
 #endif
@@ -105,7 +109,13 @@ IWRAM_CODE
 static inline
 void
 draw_hline(size_t x0, size_t x1, size_t y0, u8 clr) {
-    // TODO
+    BOUNDCHECK_SCREEN(x0, y0);
+    BOUNDCHECK_SCREEN(x1, y0);
+
+    // TODO: perf
+    for (size_t x = x0; x <= x1; x++) {
+        draw_pixel(x, y0, clr);
+    }
 }
 
 IWRAM_CODE
@@ -113,14 +123,20 @@ UNROLL_LOOPS
 static inline
 void
 draw_vline(size_t x0, size_t y0, size_t y1, u8 clr) {
-    // TODO
+    BOUNDCHECK_SCREEN(x0, y0);
+    BOUNDCHECK_SCREEN(x0, y1);
+
+    // TODO: perf
+    for (size_t y = y0; y <= y1; y++) {
+        draw_pixel(x0, y, clr);
+    }
 }
 
 IWRAM_CODE
 void
 draw_line(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
-    // BOUNDCHECK_SCREEN(x0, y0);
-    // BOUNDCHECK_SCREEN(x1, y1);
+    BOUNDCHECK_SCREEN(x0, y0);
+    BOUNDCHECK_SCREEN(x1, y1);
     if (y0 == y1) {
         MAYBE_SWAP(x0, x1);
         draw_hline(x0, x1, y0, clr);
@@ -271,51 +287,6 @@ draw_rect(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
     draw_hline(x0, x1, y1, clr);
     draw_vline(x0, y0, y1, clr);
     draw_vline(x1, y0, y1, clr);
-
-    // TODO: check if this is better.
-//     BOUNDCHECK_SCREEN(x0, y0);
-//     BOUNDCHECK_SCREEN(x1, y1);
-
-//     // Find row positions for the given x/y coordinates.
-//     size_t tile_x0 = x0 / 8;
-//     size_t tile_y0 = y0 / 8;
-//     size_t tile_x1 = x1 / 8;
-//     size_t tile_y1 = y1 / 8;
-//     size_t start_col0 = x0 % 8;
-//     size_t start_col1 = x1 % 8;
-//     size_t start_row0 = y0 % 8;
-//     size_t start_row1 = y1 % 8;
-
-//     // Get a pointer to the backbuffer and the tile row.
-//     u32 *buf_top = &BACKBUF[start_row0 + (tile_x0 + tile_y0 * 32) * 8];
-//     u32 *buf_bot = &BACKBUF[start_row1 + (tile_x0 + tile_y1 * 32) * 8];
-
-//     size_t dx = tile_x1 - tile_x0;
-//     size_t dy = tile_y1 - tile_y0;
-
-//     memset(buf_top, 3, x1 - x0);
-//     memset(buf_bot, 3, x1 - x0);
-
-//     if (dx < 1) {
-//         dirty_tiles[tile_y0] |= 1 << tile_x0;
-//         dirty_tiles[tile_y1] |= 1 << tile_x0;
-//     } else {
-//         dirty_tiles[tile_y0] |= 1 << tile_x0;
-//         dirty_tiles[tile_y1] |= 1 << tile_x0;
-//         for (size_t i = 1; i < dx; i++) {
-//             dirty_tiles[tile_y0] |= 1 << (tile_x0 + i);
-//             dirty_tiles[tile_y1] |= 1 << (tile_x0 + i);
-//         }
-//         dirty_tiles[tile_y0] |= 1 << (tile_x0 + dx);
-//         dirty_tiles[tile_y1] |= 1 << (tile_x0 + dx);
-//     }
-//     if (dy < 1) {
-//     } else {
-//         for (size_t j = 1; j < dy; j++) {
-//             dirty_tiles[tile_y0 + j] |= 1 << tile_x0;
-//             dirty_tiles[tile_y0 + j] |= 1 << (tile_x0 + dx);
-//         }
-//     }
 }
 
 IWRAM_CODE
@@ -345,21 +316,21 @@ draw_filled_rect(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
 
     // size_t dx = x1 - x0;
     // size_t dy = y1 - y0;
-    // u8 *buf = &BACKBUF[0];
+    // u8 *buf = &backbuf[0];
     // memset(buf, 0x11 * clr, 16);
     //for (size_t j = 0; j < 1; j++) {
     //    // for (size_t i = 0; i < dx; i++) {
     //    //     buf[i + j * 16] = clr;
     //    // }
     //    //
-    //    // BACKBUF[j + 0] = 0x11111111 * clr;
-    //    // BACKBUF[j + 1] = 0x11111111 * clr;
-    //    // BACKBUF[j + 2] = 0x11111111 * clr;
-    //    // BACKBUF[j + 3] = 0x11111111 * clr;
-    //    // BACKBUF[j + 4] = 0x11111111 * clr;
-    //    // BACKBUF[j + 5] = 0x11111111 * clr;
-    //    // BACKBUF[j + 6] = 0x11111111 * clr;
-    //    // BACKBUF[j + 7] = 0x11111111 * clr;
+    //    // backbuf[j + 0] = 0x11111111 * clr;
+    //    // backbuf[j + 1] = 0x11111111 * clr;
+    //    // backbuf[j + 2] = 0x11111111 * clr;
+    //    // backbuf[j + 3] = 0x11111111 * clr;
+    //    // backbuf[j + 4] = 0x11111111 * clr;
+    //    // backbuf[j + 5] = 0x11111111 * clr;
+    //    // backbuf[j + 6] = 0x11111111 * clr;
+    //    // backbuf[j + 7] = 0x11111111 * clr;
 
     //    buf[j + 0] = 0x1 * clr;
     //    buf[j + 1] = 0x1 * clr;
@@ -370,7 +341,7 @@ draw_filled_rect(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
     //    // buf[j + 6] = 0x1111 * clr;
     //    // buf[j + 7] = 0x1111 * clr;
     //}
-    // u8 *buf = &BACKBUF[0];
+    // u8 *buf = &backbuf[0];
     // buf[8 * 16 + 0] = clr;
     // buf[8 * 16 + 1] = clr;
     // buf[8 * 16 + 2] = clr;
@@ -404,7 +375,7 @@ draw_filled_rect(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
 
 //     // Get a pointer to the backbuffer and the tile row.
 //     size_t pos = start_row + (tile_x + tile_y * 32) * 8;
-//     u32 *backbuffer = &BACKBUF[pos];
+//     u32 *backbuffer = &backbuf[pos];
 //     u32 *row = tile;
 
 //     // This will blend all colors weirdly if using tiles that contain colors
@@ -474,20 +445,18 @@ void
 flip_buffer(void) {
     if (backbuf == BUF_0) {
         backbuf = BUF_1;
-        DISP_CTRL = DISP_MODE_0 | DISP_BG_1 | DISP_OBJ;
-        BG_CTRL(0) = BG_CHARBLOCK(CB_0) | BG_SCREENBLOCK(SB_0) | BG_PRIORITY(2);
-        BG_CTRL(1) = BG_CHARBLOCK(CB_1) | BG_SCREENBLOCK(SB_1) | BG_PRIORITY(1);
+        BG_CTRL(0) = BG_CHARBLOCK(CB_0) | BG_SCREENBLOCK(SB_0) | BG_PRIORITY(0);
+        BG_CTRL(1) = BG_CHARBLOCK(CB_1) | BG_SCREENBLOCK(SB_1) | BG_PRIORITY(2);
     } else {
         backbuf = BUF_0;
-        DISP_CTRL = DISP_MODE_0 | DISP_BG_0 | DISP_OBJ;
-        BG_CTRL(0) = BG_CHARBLOCK(CB_0) | BG_SCREENBLOCK(SB_0) | BG_PRIORITY(1);
-        BG_CTRL(1) = BG_CHARBLOCK(CB_1) | BG_SCREENBLOCK(SB_1) | BG_PRIORITY(2);
+        BG_CTRL(0) = BG_CHARBLOCK(CB_0) | BG_SCREENBLOCK(SB_0) | BG_PRIORITY(2);
+        BG_CTRL(1) = BG_CHARBLOCK(CB_1) | BG_SCREENBLOCK(SB_1) | BG_PRIORITY(0);
     }
     // TODO: Copying all tiles for now. Study if it's better to use dirty_tiles
     // or dirty_lines.
     // Copy dirty tiles from the backbuffer to the frontbuffer.
     // Tile *dst = FRONTBUF;
-    // Tile *src = BACKBUF;
+    // Tile *src = backbuf;
     // for (size_t j = 0; j < 20; ++j) {
     //     // if (dirty_tiles[j] == 0) {
     //     //     continue;
@@ -647,30 +616,43 @@ txt_drawc(char c, size_t x, size_t y, u8 clr) {
 void
 renderer_init(void) {
     // Initialize display mode and bg palette.
-    DISP_CTRL = DISP_MODE_0 | DISP_BG_0 | DISP_BG_1 | DISP_OBJ;
+    DISP_CTRL = DISP_MODE_0 | DISP_BG_0 | DISP_BG_1 | DISP_BG_2 | DISP_OBJ;
+    // DISP_CTRL = DISP_MODE_0 | DISP_BG_0 | DISP_BG_1 | DISP_OBJ;
+    // TODO: black/grey background to block font/back buffers?
 
     // Clear VRAM.
     dma_fill(MEM_VRAM, 0, KB(96), 3);
 
-
     // Initialize backgrounds.
-    BG_CTRL(0) = BG_CHARBLOCK(CB_0) | BG_SCREENBLOCK(SB_0) | BG_PRIORITY(1);
+    BG_CTRL(0) = BG_CHARBLOCK(CB_0) | BG_SCREENBLOCK(SB_0) | BG_PRIORITY(0);
+    BG_CTRL(2) = BG_CHARBLOCK(CB_2) | BG_SCREENBLOCK(SB_2) | BG_PRIORITY(1);
     BG_CTRL(1) = BG_CHARBLOCK(CB_1) | BG_SCREENBLOCK(SB_1) | BG_PRIORITY(2);
 
-    DISP_CTRL = DISP_MODE_0 | DISP_OBJ;
-
     // Initialize background memory map for frontbuffer.
     // for (size_t i = 0; i < 32 * 20; ++i) {
     //     TILE_MAP[i] = i;
     // }
     u16 *mem_map_fg = SCREENBLOCK_MEM[SB_0];
     u16 *mem_map_bg = SCREENBLOCK_MEM[SB_1];
+    u16 *mem_map_clr = SCREENBLOCK_MEM[SB_2];
     size_t k = 0;
     for (size_t i = 0; i < 32 * 20; ++i, ++k) {
         mem_map_fg[i] = k;
         mem_map_bg[i] = k + 32 * 4;
+        mem_map_clr[i] = 0;
     }
 
+    // FIXME: clean this up.
+    u32 *clr_tile =((u32*)(MEM_VRAM) + 0xC000 / 4);
+    clr_tile[0] = 0x22222222;
+    clr_tile[1] = 0x22222222;
+    clr_tile[2] = 0x22222222;
+    clr_tile[3] = 0x22222222;
+    clr_tile[4] = 0x22222222;
+    clr_tile[5] = 0x22222222;
+    clr_tile[6] = 0x22222222;
+    clr_tile[7] = 0x22222222;
+
     // Initialize default palette.
     PAL_BUFFER_BG[0] = COLOR_BLACK;
     PAL_BUFFER_BG[1] = COLOR_WHITE;