Add initial dirty_tiles marking for m0 and improve chr/icn perf

3 files changed, 114 insertions, 63 deletions

diff --git a/src/main.c b/src/main.c
index fa2384f..d97a110 100644
--- a/src/main.c
+++ b/src/main.c
@@ -335,9 +335,9 @@ int main(void) {
     irs_set(IRQ_VBLANK, irs_stub);
 
     while (true) {
+        test_sprites_bounce();
         test_text_rendering();
         test_growing_rects();
-        test_sprites_bounce();
         test_moving_line();
         test_all_static();
     }
diff --git a/src/profiling.c b/src/profiling.c
index a464372..4475aa8 100644
--- a/src/profiling.c
+++ b/src/profiling.c
@@ -41,7 +41,7 @@
 #endif
 
 static bool profile_show = true;
-static bool profile_bg_show = true;
+static bool profile_bg_show = false;
 
 #define PROF_SHOW() \
     do { \
diff --git a/src/renderer_m0.c b/src/renderer_m0.c
index 10bbff5..ecb0402 100644
--- a/src/renderer_m0.c
+++ b/src/renderer_m0.c
@@ -22,6 +22,9 @@
 // Pointer to the backbuffer.
 static u32 *backbuf = BUF_1;
 
+// Tracking which tiles are "dirty" and need refreshing.
+static u32 dirty_tiles[21] = {0};
+
 // Position of the tilemap.
 #define TILE_MAP  ((u32*)(MEM_VRAM + KB(40)))
 
@@ -74,6 +77,7 @@ draw_pixel(size_t x, size_t y, u8 clr) {
     u32 mask = 0xF << shift;
     u32 row = clr << shift;
     *dst = (*dst & ~mask) | row;
+    dirty_tiles[tile_y] |= 1 << tile_x;
 }
 
 IWRAM_CODE
@@ -89,6 +93,7 @@ draw_hline(size_t x0, size_t x1, size_t y0, u8 clr) {
     size_t start_col = x0 % 8;
     size_t end_col = x1 % 8;
     size_t start_row = y0 % 8;
+    u32 dirty = (1 << tile_x0) | (1 << tile_x1);
 
     // Horizontal line. There are 3 cases:
     //     1. Lines fit on a single tile.
@@ -112,11 +117,13 @@ draw_hline(size_t x0, size_t x1, size_t y0, u8 clr) {
         *dst = (*dst & ~(mask << shift_left)) | (row << shift_left);
         dst += 8;
         for (size_t i = 1; i < dtx; i++) {
+            dirty |= (1 << (tile_x0 + i));
             *dst = row;
             dst += 8;
         }
         *dst = (*dst & ~(mask >> shift_right)) | (row >> shift_right);
     }
+    dirty_tiles[tile_y] |= dirty;
 }
 
 IWRAM_CODE
@@ -135,6 +142,7 @@ draw_vline(size_t x0, size_t y0, size_t y1, u8 clr) {
     size_t start_row1 = y1 % 8;
 
     size_t shift_left = start_col * 4;
+    u32 dirty = (1 << tile_x);
 
     u32 *dst = &backbuf[start_row0 + (tile_x + tile_y * 32) * 8];
     u32 mask = 0x0000000F << shift_left;
@@ -150,6 +158,7 @@ draw_vline(size_t x0, size_t y0, size_t y1, u8 clr) {
         }
         dst += 8 * 31;
         for (size_t j = 1; j < dty; j++) {
+            dirty_tiles[tile_y0 + j] |= dirty;
             for (size_t i = 0; i < 8; i++, dst++) {
                 dst[0] = (dst[0] & ~mask) | row;
             }
@@ -159,6 +168,8 @@ draw_vline(size_t x0, size_t y0, size_t y1, u8 clr) {
             dst[0] = (dst[0] & ~mask) | row;
         }
     }
+    dirty_tiles[tile_y0] |= dirty;
+    dirty_tiles[tile_y1] |= dirty;
 }
 
 IWRAM_CODE
@@ -458,101 +469,141 @@ decode_1bpp(u8 row, u8 flip_x) {
 #endif
 
 IWRAM_CODE
-static inline
+UNROLL_LOOPS
 void
-draw_2bpp_row(size_t x, size_t y, u8 a, u8 b, u8 clr, u8 flip_x) {
+draw_chr(size_t x, size_t y, u8 *sprite, u8 clr, u8 flip_x, u8 flip_y) {
     BOUNDCHECK_SCREEN(x, y);
-
-    size_t tile_x = x / 8;
+    size_t tile_x0 = x / 8;
+    size_t tile_x1 = (x + 7) / 8;
     size_t tile_y = y / 8;
     size_t start_col = x % 8;
     size_t start_row = y % 8;
     size_t shift_left = start_col * 4;
     size_t shift_right = (8 - start_col) * 4;
-
-    u32 *dst = &backbuf[start_row + (tile_x + tile_y * 32) * 8];
+    u32 dirty = (1 << tile_x0) | (1 << tile_x1);
+    u32 *dst = &backbuf[start_row + (tile_x0 + tile_y * 32) * 8];
 #if DEC_BIG_LUT
     u32 *lut = flip_x ? dec_byte_flip_x : dec_byte;
-    u32 clr_a = lut[a];
-    u32 clr_b = lut[b];
-#else
-    u32 clr_a = decode_1bpp(a, flip_x);
-    u32 clr_b = decode_1bpp(b, flip_x);
 #endif
-    u32 mask_a = (clr_a * 0xF);
-    u32 mask_b = (clr_b * 0xF);
-    u32 mask = (mask_a | mask_b);
-    u32 color;
-    if (clr == 0) {
-        color = clr_a + (clr_b << 1);
-    } else if (clr == 15) {
-        color = 0;
-    } else {
-        color = (clr_a | clr_b) * clr;
-    }
-    dst[0] = (dst[0] & ~(mask << shift_left))  | (color << shift_left);
-    dst[8] = (dst[8] & ~(mask >> shift_right)) | (color >> shift_right);
-}
-
-IWRAM_CODE
-static inline
-void
-draw_1bpp_row(size_t x, size_t y, u8 a, u8 clr, u8 flip_x) {
-    BOUNDCHECK_SCREEN(x, y);
-
-    size_t tile_x = x / 8;
-    size_t tile_y = y / 8;
-    size_t start_col = x % 8;
-    size_t start_row = y % 8;
-    size_t shift_left = start_col * 4;
-    size_t shift_right = (8 - start_col) * 4;
-
-    u32 *dst = &backbuf[start_row + (tile_x + tile_y * 32) * 8];
-    u32 color = decode_1bpp(a, flip_x);
-    u32 mask = (color * 0xF);
-    color *= clr;
-    dst[0] = (dst[0] & ~(mask << shift_left))  | (color << shift_left);
-    dst[8] = (dst[8] & ~(mask >> shift_right)) | (color >> shift_right);
-}
-
-IWRAM_CODE
-void
-draw_chr(size_t x, size_t y, u8 *sprite, u8 clr, u8 flip_x, u8 flip_y) {
-    BOUNDCHECK_SCREEN(x, y);
     if (!flip_y) {
-        for(size_t v = 0; v < 8; v++) {
+        for(size_t v = 0; v < 8; v++, dst++) {
             if ((y + v) >= SCREEN_HEIGHT) break;
             u8 ch1 = sprite[v + 0];
             u8 ch2 = sprite[v + 8];
-            draw_2bpp_row(x, y + v, ch1, ch2, clr, flip_x);
+#if DEC_BIG_LUT
+            u32 clr_a = lut[ch1];
+            u32 clr_b = lut[ch2];
+#else
+            u32 clr_a = decode_1bpp(ch1, flip_x);
+            u32 clr_b = decode_1bpp(ch2, flip_x);
+#endif
+            u32 mask_a = (clr_a * 0xF);
+            u32 mask_b = (clr_b * 0xF);
+            u32 mask = (mask_a | mask_b);
+            u32 color;
+            if (clr == 0) {
+                color = clr_a + (clr_b << 1);
+            } else if (clr == 15) {
+                color = 0;
+            } else {
+                color = (clr_a | clr_b) * clr;
+            }
+            dst[0] = (dst[0] & ~(mask << shift_left))  | (color << shift_left);
+            dst[8] = (dst[8] & ~(mask >> shift_right)) | (color >> shift_right);
+            if ((start_row + v)  == 7) {
+                dirty_tiles[tile_y + 1] |= dirty;
+                dst += (32 - 1) * 8;
+            }
         }
     } else {
-        for(size_t v = 0; v < 8; v++) {
+        for(size_t v = 0; v < 8; v++, dst++) {
             if ((y + v) >= SCREEN_HEIGHT) break;
             u8 ch1 = sprite[(7 - v) + 0];
             u8 ch2 = sprite[(7 - v) + 8];
-            draw_2bpp_row(x, y + v, ch1, ch2, clr, flip_x);
+#if DEC_BIG_LUT
+            u32 clr_a = lut[ch1];
+            u32 clr_b = lut[ch2];
+#else
+            u32 clr_a = decode_1bpp(ch1, flip_x);
+            u32 clr_b = decode_1bpp(ch2, flip_x);
+#endif
+            u32 mask_a = (clr_a * 0xF);
+            u32 mask_b = (clr_b * 0xF);
+            u32 mask = (mask_a | mask_b);
+            u32 color;
+            if (clr == 0) {
+                color = clr_a + (clr_b << 1);
+            } else if (clr == 15) {
+                color = 0;
+            } else {
+                color = (clr_a | clr_b) * clr;
+            }
+            dst[0] = (dst[0] & ~(mask << shift_left))  | (color << shift_left);
+            dst[8] = (dst[8] & ~(mask >> shift_right)) | (color >> shift_right);
+            if ((start_row + v)  == 7) {
+                dirty_tiles[tile_y + 1] |= dirty;
+                dst += (32 - 1) * 8;
+            }
         }
     }
+    dirty_tiles[tile_y] |= dirty;
 }
 
 IWRAM_CODE
+UNROLL_LOOPS
 void
 draw_icn(size_t x, size_t y, u8 *sprite, u8 clr, u8 flip_x, u8 flip_y) {
     BOUNDCHECK_SCREEN(x, y);
+    size_t tile_x0 = x / 8;
+    size_t tile_x1 = (x + 7) / 8;
+    size_t tile_y = y / 8;
+    size_t start_col = x % 8;
+    size_t start_row = y % 8;
+    size_t shift_left = start_col * 4;
+    size_t shift_right = (8 - start_col) * 4;
+    u32 dirty = (1 << tile_x0) | (1 << tile_x1);
+    u32 *dst = &backbuf[start_row + (tile_x0 + tile_y * 32) * 8];
+#if DEC_BIG_LUT
+    u32 *lut = flip_x ? dec_byte_flip_x : dec_byte;
+#endif
     if (!flip_y) {
-        for(size_t v = 0; v < 8; v++) {
+        for(size_t v = 0; v < 8; v++, dst++) {
             if ((y + v) >= SCREEN_HEIGHT) break;
-            u8 ch1 = sprite[v];
-            draw_1bpp_row(x, y + v, ch1, clr, flip_x);
+            u8 ch1 = sprite[v + 0];
+#if DEC_BIG_LUT
+            u32 color = lut[ch1];
+#else
+            u32 color = decode_1bpp(ch1, flip_x);
+#endif
+            u32 mask = (color * 0xF);
+            color *= clr;
+            dst[0] = (dst[0] & ~(mask << shift_left))  | (color << shift_left);
+            dst[8] = (dst[8] & ~(mask >> shift_right)) | (color >> shift_right);
+            if ((start_row + v)  == 7) {
+                dirty_tiles[tile_y + 1] |= dirty;
+                dst += (32 - 1) * 8;
+            }
         }
     } else {
-        for(size_t v = 0; v < 8; v++) {
+        for(size_t v = 0; v < 8; v++, dst++) {
             if ((y + v) >= SCREEN_HEIGHT) break;
-            u8 ch1 = sprite[(7 - v)];
-            draw_1bpp_row(x, y + v, ch1, clr, flip_x);
+            u8 ch1 = sprite[v + 0];
+#if DEC_BIG_LUT
+            u32 color = lut[ch1];
+#else
+            u32 color = decode_1bpp(ch1, flip_x);
+#endif
+            u32 mask = (color * 0xF);
+            color *= clr;
+            dst[0] = (dst[0] & ~(mask << shift_left))  | (color << shift_left);
+            dst[8] = (dst[8] & ~(mask >> shift_right)) | (color >> shift_right);
+            if ((start_row + v)  == 7) {
+                dirty_tiles[tile_y + 1] |= dirty;
+                dst += (32 - 1) * 8;
+            }
         }
     }
+    dirty_tiles[tile_y] |= dirty;
 }
 
 //