Add improved version of simple bresenham line drawing

2 files changed, 39 insertions, 138 deletions

diff --git a/src/main.c b/src/main.c
index 7e7dfd4..bd50a99 100644
--- a/src/main.c
+++ b/src/main.c
@@ -126,6 +126,7 @@ int main(void) {
         bios_vblank_wait();
 
         PROF(test_clear(), test_clear_cycles);
+        // draw_line(0, 0, 50, 20, 2);
         PROF(test_lines(), test_lines_cycles);
         PROF(test_rect(), test_rect_cycles);
         PROF(test_fill_rect(), test_fill_rect_cycles);
diff --git a/src/renderer_m0.c b/src/renderer_m0.c
index 2cb7675..d66785a 100644
--- a/src/renderer_m0.c
+++ b/src/renderer_m0.c
@@ -99,11 +99,11 @@ draw_hline(size_t x0, size_t x1, size_t y0, u8 clr) {
     //     3. Lines go through 3 or more tiles, first and last tiles use
     //        partial row updates, rows in the middle can write the entire
     //        row.
-    size_t dx = tile_x1 - tile_x0;
+    size_t dtx = tile_x1 - tile_x0;
     u32 *dst = &backbuf[tile_x0 * 8 + tile_y * 8 * 32 + start_row];
-    if (dx < 1) {
+    if (dtx < 1) {
         u32 mask = 0xFFFFFFFF;
-        mask >>= (7 - end_col - dx) * 4;
+        mask >>= (7 - end_col - dtx) * 4;
         mask &= 0xFFFFFFFF << start_col * 4;
         u32 row = (0x11111111 * clr) & mask;
         *dst = (*dst & ~mask) | row;
@@ -114,7 +114,7 @@ draw_hline(size_t x0, size_t x1, size_t y0, u8 clr) {
         u32 row = 0x11111111 * clr;
         *dst = (*dst & ~(mask << shift_left)) | (row << shift_left);
         dst += 8;
-        for (size_t i = 1; i < dx; i++) {
+        for (size_t i = 1; i < dtx; i++) {
             *dst = row;
             dst += 8;
         }
@@ -142,9 +142,9 @@ draw_vline(size_t x0, size_t y0, size_t y1, u8 clr) {
     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++) {
+    u32 dty = tile_y1 - tile_y0;
+    if (dty < 1) {
+        for (size_t i = 0; i < (y1 - y0); i++, dst++) {
             dst[0] = (dst[0] & ~mask) | row;
         }
     } else {
@@ -152,7 +152,7 @@ draw_vline(size_t x0, size_t y0, size_t y1, u8 clr) {
             dst[0] = (dst[0] & ~mask) | row;
         }
         dst += 8 * 31;
-        for (size_t j = 1; j < dy; j++) {
+        for (size_t j = 1; j < dty; j++) {
             for (size_t i = 0; i < 8; i++, dst++) {
                 dst[0] = (dst[0] & ~mask) | row;
             }
@@ -176,7 +176,7 @@ draw_line(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
         MAYBE_SWAP(y0, y1);
         draw_vline(x0, y0, y1, clr);
     } else {
-#if 1
+#if 0
         // Diagonal line.
         int dx = x0 > x1 ? x0 - x1 : x1 - x0;
         int dy = y0 > y1 ? y1 - y0 : y0 - y1;
@@ -196,135 +196,35 @@ draw_line(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
             }
         }
 #else
-        // int     dx = x0 > x1 ?       x0 - x1 : x1 - x0;
-        // int     dy = y0 > y1 ?       y0 - y1 : y1 - y0;
-        // int x_step = x0 > x1 ?            -1 : 1;
-        // int y_step = y0 > y1 ? -SCREEN_WIDTH : SCREEN_WIDTH;
-
-        // u16 *dst = NULL;
-        // uintptr_t addr = ((uintptr_t)backbuf + y0 * SCREEN_WIDTH + x0);
-        // u32 mask = x0 & 1 ? ~0xFF : 0xFF;
-        // u32 color = (clr & 0xFF) | ((clr & 0xFF) << 8);
-        // if (dx >= dy) {
-        //     int diff = 2 * dy - dx;
-        //     for (int i = 0; i < dx + 1; i++) {
-        //         dst = (u16 *)(addr - (mask >> 31));
-        //         *dst = (*dst & ~mask) | (color & mask);
-        //         if (diff >= 0) {
-        //             diff -= 2 * dx;
-        //             addr += y_step;
-        //         }
-        //         diff += 2 * dy;
-        //         addr += x_step;
-        //         mask = ~mask;
-        //     }
-        // } else {
-        //     int diff = 2 * dx - dy;
-        //     for (int i = 0; i < dy + 1; i++) {
-        //         dst = (u16 *)(addr - (mask >> 31));
-        //         *dst = (*dst & ~mask) | (color & mask);
-        //         if (diff >= 0) {
-        //             diff -= 2 * dy;
-        //             addr += x_step;
-        //             mask = ~mask;
-        //         }
-        //         diff += 2 * dx;
-        //         addr += y_step;
-        //     }
-        // }
+        int dx = x0 > x1 ? x0 - x1 : x1 - x0;
+        int dy = y0 > y1 ? y0 - y1 : y1 - y0;
+        int x_step = x0 > x1 ? -1 : 1;
+        int y_step = y0 > y1 ? -1 : 1;
+        if (dx >= dy) {
+            int diff = 2 * dy - dx;
+            for (int i = 0; i < dx + 1; i++) {
+                draw_pixel(x0, y0, clr);
+                if (diff >= 0) {
+                    diff -= 2 * dx;
+                    y0 += y_step;
+                }
+                diff += 2 * dy;
+                x0 += x_step;
+            }
+        } else {
+            int diff = 2 * dx - dy;
+            for (int i = 0; i < dy + 1; i++) {
+                draw_pixel(x0, y0, clr);
+                if (diff >= 0) {
+                    diff -= 2 * dy;
+                    x0 += x_step;
+                }
+                diff += 2 * dx;
+                y0 += y_step;
+            }
+        }
 #endif
     }
-
-    // // 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 *backbuffer = &BACKBUF[start_row0 + (tile_x0 + tile_y0 * 32) * 8];
-
-    // if (y0 == y1) {
-    //     // Horizontal line. There are 3 cases:
-    //     //     1. Lines fit on a single tile.
-    //     //     2. Lines go through 2 tiles, both require partial row updates.
-    //     //     3. Lines go through 3 or more tiles, first and last tiles use
-    //     //        partial row updates, rows in the middle can write the.
-    //     size_t dx = tile_x1 - tile_x0;
-    //     if (dx < 1) {
-    //         u32 row_mask = 0xFFFFFFFF;
-    //         row_mask >>= (7 - start_col1 - dx) * 4;
-    //         row_mask &= 0xFFFFFFFF << start_col0 * 4;
-    //         u32 row = (0x11111111 * clr) & row_mask;
-    //         backbuffer[0] = (backbuffer[0] & ~row_mask) | row;
-    //         dirty_tiles[tile_y0] |= 1 << tile_x0;
-    //     } else {
-    //         size_t shift_left = start_col0 * 4;
-    //         size_t shift_right = (7 - start_col1) * 4;
-    //         u32 row_mask = 0xFFFFFFFF;
-    //         u32 row = 0x11111111 * clr;
-    //         backbuffer[0] = backbuffer[0] & ~(row_mask << shift_left);
-    //         backbuffer[0] |= row << shift_left;
-    //         dirty_tiles[tile_y0] |= 1 << tile_x0;
-    //         for (size_t i = 1; i < dx; i++) {
-    //             backbuffer[i * 8] = row;
-    //             dirty_tiles[tile_y0] |= 1 << (tile_x0 + i);
-    //         }
-    //         backbuffer[dx * 8] = backbuffer[dx * 8] & ~(row_mask >> shift_right);
-    //         backbuffer[dx * 8] |= row >> shift_right;
-    //         dirty_tiles[tile_y0] |= 1 << (tile_x0 + dx);
-    //     }
-    // } else if (x0 == x1) {
-    //     // Vertical line. The cases are analogous to the horizontal ones.
-    //     size_t dy = tile_y1 - tile_y0;
-    //     u32 row_mask = 0xF << start_col0 * 4;
-    //     u32 row_left = (0x11111111 * clr) & row_mask;
-    //     if (dy < 1) {
-    //         for (size_t i = 0; i <= y1 - y0; i++, backbuffer++) {
-    //             backbuffer[0] = (backbuffer[0] & ~row_mask) | row_left;
-    //         }
-    //     } else {
-    //         for (size_t i = 0; i < (8 - start_row0); i++, backbuffer++) {
-    //             backbuffer[0] = (backbuffer[0] & ~row_mask) | row_left;
-    //         }
-    //         dirty_tiles[tile_y0] |= 1 << tile_x0;
-    //         backbuffer += 8 * 31;
-    //         for (size_t j = 1; j < dy; j++) {
-    //             for (size_t i = 0; i < 8; i++, backbuffer++) {
-    //                 backbuffer[0] = (backbuffer[0] & ~row_mask) | row_left;
-    //             }
-    //             backbuffer += 8 * 31;
-    //             dirty_tiles[tile_y0 + j] |= 1 << tile_x0;
-    //         }
-    //         for (size_t i = 0; i <= start_row1; i++, backbuffer++) {
-    //             backbuffer[0] = (backbuffer[0] & ~row_mask) | row_left;
-    //         }
-    //         dirty_tiles[tile_y1] |= 1 << tile_x0;
-    //     }
-    // } else {
-    //     // Diagonal line.
-    //     int dx = x0 > x1 ? x0 - x1 : x1 - x0;
-    //     int dy = y0 > y1 ? y1 - y0 : y0 - y1;
-    //     int x_step = x0 < x1 ? 1 : -1;
-    //     int y_step = y0 < y1 ? 1 : -1;
-    //     int err = dx + dy;
-    //     while (!(x0 == x1 && y0 == y1)) {
-    //         draw_pixel(x0, y0, clr);
-    //         int diff = 2 * err;
-    //         if (diff >= dy) {
-    //             err += dy;
-    //             x0 += x_step;
-    //         }
-    //         if (diff <= dx) {
-    //             err += dx;
-    //             y0 += y_step;
-    //         }
-    //     }
-    // }
 }
 
 IWRAM_CODE
@@ -399,7 +299,7 @@ draw_rect(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
     // 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++) {
+    // 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) {
@@ -413,7 +313,7 @@ draw_rect(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
     //     }
     // }
     if (dy < 1) {
-        for (size_t i = 1; i < y1 - y0; i++, dst0++) {
+        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;
         }