Remove unused code paths and #if #else testing grounds

2 files changed, 84 insertions, 190 deletions

diff --git a/src/renderer_m0.c b/src/renderer_m0.c
index 7dd5b22..6be01a4 100644
--- a/src/renderer_m0.c
+++ b/src/renderer_m0.c
@@ -12,6 +12,9 @@
 #define BUF_0 ((u32*)(MEM_VRAM))
 #define BUF_1 ((u32*)(MEM_VRAM + KB(20)))
 
+// Pointer to the backbuffer.
+static u32 *backbuf = BUF_1;
+
 // Position of the tilemap.
 #define TILE_MAP  ((u32*)(MEM_VRAM + KB(40)))
 
@@ -21,15 +24,6 @@
 #define SB_0 20
 #define SB_1 22
 
-// Available storage for other memory.
-// #define FG_PIXELS ((u32*)(MEM_VRAM + KB(44)))
-// #define BG_PIXELS ((u32*)(MEM_VRAM + KB(64)))
-
-// Keep track of which tiles need to be copied to the frontbuffer.
-static u32 dirty_tiles[21] = {0};
-
-static u32 *backbuf = BUF_1;
-
 // Boundchecks can be disable at compile time but this will not always improve
 // the performance and can in fact make it worse. It is possible that this is
 // due to some aliasing optimiztions but not sure at this moment.
@@ -45,18 +39,15 @@ static u32 *backbuf = BUF_1;
 // Swap A and B values to make sure A <= B.
 #define MAYBE_SWAP(A,B) if ((A) > (B)) { SWAP(A,B); }
 
+//
+// Basic primitives.
+//
+
 IWRAM_CODE
 void screen_fill(u8 clr)  {
     // We have to make sure we leave the last tile blank to use as alpha channel
     // when moving the BG during double buffering.
-#if 0
-    u32 *dst = backbuf;
-    for(int i = 0; i < KB(20) / 4 - 8; i++) {
-        *dst++ = 0x11111111 * clr;
-    }
-#else
     dma_fill(backbuf, 0x11111111 * clr, KB(20) - 32, 3);
-#endif
 }
 
 IWRAM_CODE
@@ -76,9 +67,6 @@ draw_pixel(size_t x, size_t y, u8 clr) {
     u32 mask = 0xF << shift;
     u32 row = clr << shift;
     *dst = (*dst & ~mask) | row;
-
-    // Mark tile as dirty.
-    dirty_tiles[tile_y] |= 1 << tile_x;
 }
 
 IWRAM_CODE
@@ -250,7 +238,6 @@ 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);
@@ -260,102 +247,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);
-#else
-    // NOTE: This is the specialized version trying to update 2 pixels at
-    // a time. As of writing this it is slightly slower than using
-    // 4 draw_hline/vline functions. The horizontal drawing part seems
-    // marginally faster but the vertical one is slower. Potentially the
-    // vertical part could be optimized or just use 2 draw_vline instead. The
-    // perf improvements seem marginal enough that it doesn't seem worth it.
-    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
@@ -373,54 +264,15 @@ 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);
     }
-#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
-void
-flip_buffer(void) {
-    // NOTE: can this be branchless? Either way is probably unnecessary other
-    // than code clarity maybe?.
-    if (backbuf == BUF_0) {
-        backbuf = BUF_1;
-        BG_H_SCROLL_0 = 0;
-        BG_H_SCROLL_1 = -240;
-    } else {
-        backbuf = BUF_0;
-        BG_H_SCROLL_0 = -240;
-        BG_H_SCROLL_1 = 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;
-    // for (size_t j = 0; j < 20; ++j) {
-    //     // if (dirty_tiles[j] == 0) {
-    //     //     continue;
-    //     // }
-    //     for (size_t i = 0, k = 1; i < 30; ++i, k <<= 1) {
-    //         // if (dirty_tiles[j] & k) {
-    //             dst[i + j * 32] = src[i + j * 32];
-    //         // }
-    //     }
-    //     // dirty_tiles[j] = 0;
-    // }
-}
+//
+// Sprites (chr/icn).
+//
 
 #define DEC_BIG_LUT 1
 
@@ -544,7 +396,6 @@ decode_1bpp(u8 row, u8 flip_x) {
     }
     return dec_byte[row];
 }
-
 #else
 static u16 dec_nibble[] = {
     0x0000, 0x1000, 0x0100, 0x1100,
@@ -679,6 +530,46 @@ draw_icn(size_t x, size_t y, u8 *sprite, u8 clr, u8 flip_x, u8 flip_y) {
     }
 }
 
+//
+// Flipping buffers/copying memory.
+//
+
+IWRAM_CODE
+void
+flip_buffer(void) {
+    // NOTE: can this be branchless? Either way is probably unnecessary other
+    // than code clarity maybe?.
+    if (backbuf == BUF_0) {
+        backbuf = BUF_1;
+        BG_H_SCROLL_0 = 0;
+        BG_H_SCROLL_1 = -240;
+    } else {
+        backbuf = BUF_0;
+        BG_H_SCROLL_0 = -240;
+        BG_H_SCROLL_1 = 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;
+    // for (size_t j = 0; j < 20; ++j) {
+    //     // if (dirty_tiles[j] == 0) {
+    //     //     continue;
+    //     // }
+    //     for (size_t i = 0, k = 1; i < 30; ++i, k <<= 1) {
+    //         // if (dirty_tiles[j] & k) {
+    //             dst[i + j * 32] = src[i + j * 32];
+    //         // }
+    //     }
+    //     // dirty_tiles[j] = 0;
+    // }
+}
+
+//
+// Text rendering.
+//
+
 #include "font.h"
 
 // Font rendering function for the text engine.
@@ -688,6 +579,10 @@ txt_drawc(char c, size_t x, size_t y, u8 clr) {
     draw_icn(x, y, tile + 8 * c, clr, 1, 0);
 }
 
+//
+// Initialization.
+//
+
 void
 renderer_init(void) {
     // Initialize display mode and bg palette.
diff --git a/src/renderer_m4.c b/src/renderer_m4.c
index 6da7996..4e8868a 100644
--- a/src/renderer_m4.c
+++ b/src/renderer_m4.c
@@ -1,10 +1,12 @@
 #include "renderer.h"
 #include "text.h"
 
-static u16 *backbuf = (u16*)(MEM_VRAM ^ 0x0A000);
+// Front/back buffers for double buffering.
+#define BUF_0 ((u32*)(MEM_VRAM))
+#define BUF_1 ((u32*)(MEM_VRAM ^ 0x0A000))
 
-// Keep track of which tiles need to be copied to the frontbuffer.
-static bool screen_updated = true;
+// Pointer to the backbuffer.
+static u16 *backbuf = BUF_1;
 
 // Boundchecks can be disable at compile time but this will not always improve
 // the performance and can in fact make it worse. It is possible that this is
@@ -21,17 +23,13 @@ static bool screen_updated = true;
 // Swap A and B values to make sure A <= B.
 #define MAYBE_SWAP(A,B) if ((A) > (B)) { SWAP(A,B); }
 
+//
+// Basic primitives.
+//
+
 IWRAM_CODE
 void screen_fill(u8 clr)  {
-#if 0
-    u32 *dst = backbuf;
-    for(int i = 0; i < KB(75) / 8; i++) {
-        *dst++ = 0x01010101 * clr;
-    }
-#else
     dma_fill(backbuf, 0x01010101 * clr, KB(75) / 2, 3);
-    screen_updated = true;
-#endif
 }
 
 IWRAM_CODE
@@ -44,7 +42,6 @@ draw_pixel(size_t x, size_t y, u8 clr) {
     } else {
         *dst = (*dst & ~0xFF) | clr;
     }
-    screen_updated = true;
 }
 
 IWRAM_CODE
@@ -77,22 +74,12 @@ draw_hline(size_t x0, size_t x1, size_t y0, u8 clr) {
         size_t shift_right = (7 - end_col) * 8;
         u64 row_mask = 0xFFFFFFFFFFFFFFFF;
         u64 row = 0x0101010101010101 * clr;
-#if 0
-        // No DMA.
-        *dst++ = (*dst & ~(row_mask << shift_left)) | row << shift_left;
-        for (size_t i = 1; i < dx; i++) {
-            *dst++ = row;
-        }
-        *dst = (*dst & ~(row_mask >> shift_right)) | row >> shift_right;
-#else
-        // DMA.
         dst[0] = (dst[0] & ~(row_mask << shift_left)) | row << shift_left;
         if (dx != 1) {
             dma_fill(&dst[1], 0x01010101 * clr, (dx - 1) * 8, 3);
         }
         dst[dx] = dst[dx] & ~(row_mask >> shift_right);
         dst[dx] |= row >> shift_right;
-#endif
     }
 }
 
@@ -169,7 +156,6 @@ draw_line(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
             }
         }
     }
-    screen_updated = true;
 }
 
 IWRAM_CODE
@@ -184,7 +170,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);
-    screen_updated = true;
 }
 
 IWRAM_CODE
@@ -204,15 +189,18 @@ draw_filled_rect(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
 
     // Drawline implementation.
     for (size_t y = y0; y <= y1; y++) {
-        // NOTE: Unclear why here draw_hline is faster than draw_line.
         draw_hline(x0, x1, y, clr);
     }
-    screen_updated = true;
 }
 
+//
+// Sprites (chr/icn).
+//
+
 #define DEC_BIG_LUT 1
 
 #if DEC_BIG_LUT
+
 static u64 dec_byte_flip_x[256] = {
     0x0000000000000000, 0x0000000000000001, 0x0000000000000100, 0x0000000000000101, 0x0000000000010000,
     0x0000000000010001, 0x0000000000010100, 0x0000000000010101, 0x0000000001000000, 0x0000000001000001,
@@ -322,6 +310,7 @@ static u64 dec_byte[256] = {
     0x0001000101010101, 0x0101000101010101, 0x0000010101010101, 0x0100010101010101, 0x0001010101010101,
     0x0101010101010101
 };
+
 IWRAM_CODE
 static inline
 u64
@@ -331,6 +320,7 @@ decode_1bpp(u8 row, u8 flip_x) {
     }
     return dec_byte[row];
 }
+
 #else
 
 static u32 dec_nibble[] = {
@@ -358,6 +348,7 @@ decode_1bpp(u8 row, u8 flip_x) {
     u32 *lut = dec_nibble;
     return (u64)lut[(row >> 0) & 0xF] << 32 | (u64)lut[(row >> 4) & 0xF];
 }
+
 #endif
 
 IWRAM_CODE
@@ -471,17 +462,21 @@ draw_icn(size_t x, size_t y, u8 *sprite, u8 clr, u8 flip_x, u8 flip_y) {
     }
 }
 
+//
+// Flipping buffers/copying memory.
+//
+
 IWRAM_CODE
 void
 flip_buffer(void) {
-    if (!screen_updated) {
-        return;
-    }
     backbuf = (u16*)((u32)backbuf ^ 0x0A000);
     DISP_CTRL ^= DISP_PAGE;
-    screen_updated = false;
 }
 
+//
+// Text rendering.
+//
+
 #include "font.h"
 
 // Font rendering function for the text engine.
@@ -491,13 +486,17 @@ txt_drawc(char c, size_t x, size_t y, u8 clr) {
     draw_icn(x, y, tile + 8 * c, clr, 1, 0);
 }
 
+//
+// Initialization.
+//
+
 void
 renderer_init(void) {
     // Initialize display mode and bg palette.
     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, 0, KB(96), 3);
 
     // Initialize default palette.
     PAL_BUFFER_BG[0] = COLOR_BLACK;