Update draw_vline with performance improvements

3 files changed, 136 insertions, 79 deletions

diff --git a/src/main.c b/src/main.c
index d2137c3..7e7dfd4 100644
--- a/src/main.c
+++ b/src/main.c
@@ -120,15 +120,8 @@ int main(void) {
     irq_init();
     irs_set(IRQ_VBLANK, irs_stub);
 
-    // draw_filled_rect(0, 0, 7, 7, 2);
-    // draw_filled_rect(8, 0, 15, 7, 3);
-    // BG_H_SCROLL_0 = 240;
-    // BG_H_SCROLL_0 = 240;
-    // BG_H_SCROLL_1 = 0;
     // Main loop.
     PROF_INIT();
-    int x = 0;
-    int inc = 1;
     while (true) {
         bios_vblank_wait();
 
diff --git a/src/renderer_m0.c b/src/renderer_m0.c
index 8f23376..18d1c5d 100644
--- a/src/renderer_m0.c
+++ b/src/renderer_m0.c
@@ -115,7 +115,7 @@ 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 < dx; i++) {
-            *dst = (*dst & ~mask) | row;
+            *dst = row;
             dst += 8;
         }
         *dst = (*dst & ~(mask >> shift_right)) | (row >> shift_right);
@@ -131,20 +131,35 @@ draw_vline(size_t x0, size_t y0, size_t y1, u8 clr) {
     BOUNDCHECK_SCREEN(x0, y1);
     size_t tile_x = x0 / 8;
     size_t tile_y = y0 / 8;
-    size_t start_row = y0 % 8;
+    size_t tile_y0 = y0 / 8;
+    size_t tile_y1 = y1 / 8;
     size_t start_col = x0 % 8;
+    size_t start_row0 = y0 % 8;
+    size_t start_row1 = y1 % 8;
+
     size_t shift_left = start_col * 4;
-    u32 *dst = &backbuf[tile_x * 8 + tile_y * 8 * 32 + start_row];
-    u32 cur_row = start_row;
-    u32 mask = 0x0000000F;
-    for (size_t i = 0; i <= y1 - y0; i++) {
-        *dst = (*dst & ~(mask << shift_left)) | (clr << shift_left);
-        if (cur_row == 7) {
-            dst += 8 * 31 + 1;
-            cur_row = 0;
-        } else {
-            cur_row++;
-            dst++;
+
+    u32 *dst = &backbuf[tile_x * 8 + tile_y * 8 * 32 + start_row0];
+    u32 mask = 0x0000000F << shift_left;
+    u32 row = (0x11111111 * clr) & mask;
+    u32 dy = tile_y1 - tile_y0;
+    if (dy < 1) {
+        for (size_t i = 0; i < y1 - y0; i++, dst++) {
+            dst[0] = (dst[0] & ~mask) | row;
+        }
+    } else {
+        for (size_t i = 0; i < (8 - start_row0); i++, dst++) {
+            dst[0] = (dst[0] & ~mask) | row;
+        }
+        dst += 8 * 31;
+        for (size_t j = 1; j < dy; j++) {
+            for (size_t i = 0; i < 8; i++, dst++) {
+                dst[0] = (dst[0] & ~mask) | row;
+            }
+            dst += 8 * 31;
+        }
+        for (size_t i = 0; i < start_row1; i++, dst++) {
+            dst[0] = (dst[0] & ~mask) | row;
         }
     }
 }
@@ -296,6 +311,7 @@ draw_line(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
 IWRAM_CODE
 void
 draw_rect(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
+#if 1
     BOUNDCHECK_SCREEN(x0, y0);
     BOUNDCHECK_SCREEN(x1, y1);
     MAYBE_SWAP(x0, x1);
@@ -305,6 +321,96 @@ 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);
+#else
+    BOUNDCHECK_SCREEN(x0, y0);
+    BOUNDCHECK_SCREEN(x1, y1);
+    MAYBE_SWAP(x0, x1);
+    MAYBE_SWAP(y0, 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 *dst0 = &backbuf[start_row0 + (tile_x0 + tile_y0 * 32) * 8];
+    u32 *dst1 = &backbuf[start_row1 + (tile_x0 + tile_y1 * 32) * 8];
+
+    size_t dx = tile_x1 - tile_x0;
+    size_t dy = tile_y1 - tile_y0;
+
+    // We can update two lines at a time, which is faster than calling draw_line
+    // four times.
+    if (dx < 1) {
+        u32 mask = 0xFFFFFFFF;
+        mask >>= (7 - start_col1 - dx) * 4;
+        mask &= 0xFFFFFFFF << start_col0 * 4;
+        u32 row = (0x11111111 * clr) & mask;
+        *dst0 = (*dst0 & ~mask) | row;
+        *dst1 = (*dst1 & ~mask) | row;
+    } else {
+        size_t shift_left = start_col0 * 4;
+        size_t shift_right = (7 - start_col1) * 4;
+        u32 mask = 0xFFFFFFFF;
+        u32 row = 0x11111111 * clr;
+        *dst0 = (*dst0 & ~(mask << shift_left)) | (row << shift_left);
+        *dst1 = (*dst1 & ~(mask << shift_left)) | (row << shift_left);
+        for (size_t i = 1; i < dx; i++) {
+            dst0[i * 8] = row;
+            dst1[i * 8] = row;
+        }
+        dst0[dx * 8] = (dst0[dx * 8] & ~(mask >> shift_right)) | (row >> shift_right);
+        dst1[dx * 8] = (dst1[dx * 8] & ~(mask >> shift_right)) | (row >> shift_right);
+    }
+    u32 mask_left = 0xF << start_col0 * 4;
+    u32 mask_right = 0xF << start_col1 * 4;
+    u32 row_left = (0x11111111 * clr) & mask_left;
+    u32 row_right = (0x11111111 * clr) & mask_right;
+    // u32 cur_row = start_row0;
+    // dst0 = &backbuf[start_row0 + (tile_x0 + tile_y0 * 32) * 8];
+    // dst1 = &backbuf[start_row0 + (tile_x1 + tile_y0 * 32) * 8];
+    // for (size_t i = 0; i <= y1 - y0; i++) {
+    //     *dst0 = (*dst0 & ~mask_left) | row_left;
+    //     *dst1 = (*dst1 & ~mask_right) | row_right;
+    //     if (cur_row == 7) {
+    //         dst0 += 8 * 31 + 1;
+    //         dst1 += 8 * 31 + 1;
+    //         cur_row = 0;
+    //     } else {
+    //         cur_row++;
+    //         dst0++;
+    //         dst1++;
+    //     }
+    // }
+    if (dy < 1) {
+        for (size_t i = 1; i < y1 - y0; i++, dst0++) {
+            dst0[1] = (dst0[1] & ~mask_left) | row_left;
+            dst0[1 + 8 * dx] = (dst0[1 + 8 * dx] & ~mask_right) | row_right;
+        }
+    } else {
+        for (size_t i = 1; i < (8 - start_row0); i++, dst0++) {
+            dst0[1] = (dst0[1] & ~mask_left) | row_left;
+            dst0[1 + 8 * dx] = (dst0[1 + 8 * dx] & ~mask_right) | row_right;
+        }
+        dst0 += 8 * 31;
+        for (size_t j = 1; j < dy; j++) {
+            for (size_t i = 0; i < 8; i++, dst0++) {
+                dst0[1] = (dst0[1] & ~mask_left) | row_left;
+                dst0[1 + 8 * dx] = (dst0[1 + 8 * dx] & ~mask_right) | row_right;
+            }
+            dst0 += 8 * 31;
+        }
+        for (size_t i = 0; i < start_row1; i++, dst0++) {
+            dst0[1] = (dst0[1] & ~mask_left) | row_left;
+            dst0[1 + 8 * dx] = (dst0[1 + 8 * dx] & ~mask_right) | row_right;
+        }
+    }
+#endif
 }
 
 IWRAM_CODE
@@ -322,61 +428,21 @@ draw_filled_rect(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
         return;
     }
 
+#if 1
     // Drawline implementation.
     for (size_t y = y0; y <= y1; y++) {
         draw_hline(x0, x1, y, clr);
     }
-
-    // TODO: check if this is better.
-    // BOUNDCHECK_SCREEN(x0, y0);
-    // BOUNDCHECK_SCREEN(x1, y1);
-
-    // size_t dx = x1 - x0;
-    // size_t dy = y1 - y0;
-    // 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;
-
-    //    buf[j + 0] = 0x1 * clr;
-    //    buf[j + 1] = 0x1 * clr;
-    //    buf[j + 2] = 0x1 * clr;
-    //    buf[j + 3] = 0x1 * clr;
-    //    // buf[j + 4] = 0x1111 * clr;
-    //    // buf[j + 5] = 0x1111 * clr;
-    //    // buf[j + 6] = 0x1111 * clr;
-    //    // buf[j + 7] = 0x1111 * clr;
-    //}
-    // u8 *buf = &backbuf[0];
-    // buf[8 * 16 + 0] = clr;
-    // buf[8 * 16 + 1] = clr;
-    // buf[8 * 16 + 2] = clr;
-    // buf[8 * 16 + 3] = clr;
-    // buf[8 * 16 + 4] = clr;
-    // buf[8 * 16 + 5] = clr;
-    // buf[8 * 16 + 6] = clr;
-    // buf[8 * 16 + 7] = clr;
-    // for (size_t j = 0; j < dy; j++) {
-    //     for (size_t i = 0; i < dx; i++) {
-    //         buf[i + j * 16] = clr;
-    //     }
-    // }
-    // size_t n_rect = MIN(dx, dy);
-    // n_rect = n_rect / 2 + 1;
-    // for (size_t i = 0; i < n_rect; i++) {
-    //     draw_rect(x0 + i, y0 + i, x1 - i, y1 - i, clr);
-    // }
+#else
+    // draw_rect implementation.
+    size_t dx = x1 - x0;
+    size_t dy = y1 - y0;
+    size_t n_rect = MIN(dx, dy);
+    n_rect = n_rect / 2 + 1;
+    for (size_t i = 0; i < n_rect; i++) {
+        draw_rect(x0 + i, y0 + i, x1 - i, y1 - i, clr);
+    }
+#endif
 }
 
 IWRAM_CODE
@@ -557,11 +623,9 @@ void
 renderer_init(void) {
     // Initialize display mode and bg palette.
     DISP_CTRL = DISP_MODE_0 | DISP_BG_0 | DISP_BG_1;
-    // 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);
+    dma_fill((u32*)MEM_VRAM, 0, KB(96), 3);
 
     // Initialize backgrounds.
     BG_CTRL(0) = BG_CHARBLOCK(CB_0) | BG_SCREENBLOCK(SB_0) | BG_PRIORITY(0) | BG_SIZE(1);
diff --git a/src/renderer_m4.c b/src/renderer_m4.c
index 1539ccb..cc9da58 100644
--- a/src/renderer_m4.c
+++ b/src/renderer_m4.c
@@ -1,7 +1,7 @@
 #include "renderer.h"
 #include "text.h"
 
-static u16 *backbuf = (u16 *)(MEM_VRAM ^ 0x0A000);
+static u16 *backbuf = (u16*)(MEM_VRAM ^ 0x0A000);
 
 // Keep track of which tiles need to be copied to the frontbuffer.
 static bool screen_updated = true;
@@ -81,7 +81,7 @@ draw_hline(size_t x0, size_t x1, size_t y0, u8 clr) {
         // No DMA.
         *dst++ = (*dst & ~(row_mask << shift_left)) | row << shift_left;
         for (size_t i = 1; i < dx; i++) {
-            *dst++ = (*dst & ~row_mask) | row;
+            *dst++ = row;
         }
         *dst = (*dst & ~(row_mask >> shift_right)) | row >> shift_right;
 #else
@@ -144,7 +144,7 @@ draw_line(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
         if (dx >= dy) {
             int diff = 2 * dy - dx;
             for (int i = 0; i < dx + 1; i++) {
-                dst = (u16 *)(addr - (mask >> 31));
+                dst = (u16*)(addr - (mask >> 31));
                 *dst = (*dst & ~mask) | (color & mask);
                 if (diff >= 0) {
                     diff -= 2 * dx;
@@ -157,7 +157,7 @@ draw_line(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
         } else {
             int diff = 2 * dx - dy;
             for (int i = 0; i < dy + 1; i++) {
-                dst = (u16 *)(addr - (mask >> 31));
+                dst = (u16*)(addr - (mask >> 31));
                 *dst = (*dst & ~mask) | (color & mask);
                 if (diff >= 0) {
                     diff -= 2 * dy;
@@ -370,7 +370,7 @@ renderer_init(void) {
     DISP_CTRL = DISP_MODE_4 | DISP_BG_2;
 
     // Clear VRAM.
-    dma_fill((u16 *)MEM_VRAM, 0x01010101 * 0, KB(96), 3);
+    dma_fill((u16*)MEM_VRAM, 0x01010101 * 0, KB(96), 3);
 
     // Initialize default palette.
     PAL_BUFFER_BG[0] = COLOR_BLACK;