Experiment with a more performant basic bresenham

2 files changed, 87 insertions, 40 deletions

diff --git a/src/main.c b/src/main.c
index 6ea2619..44e8fdb 100644
--- a/src/main.c
+++ b/src/main.c
@@ -130,17 +130,17 @@ int main(void) {
 
         // DX is bigger
         // left -> right && top -> bot
-        //draw_line(0, 0, 239, 159, 1);
-        //// draw_line(10, 0, 229, 159, 1);
-        //// left -> right && bot -> top
+        //PROF(draw_line(0, 0, 239, 159, 1), test_lines_cycles);
+        ////// draw_line(10, 0, 229, 159, 1);
+        ////// left -> right && bot -> top
         //draw_line(0, 159, 239, 0, 2);
-        //// draw_line(10, 159, 229, 0, 2);
-        ////
-        //draw_line(0, 0, 239, 159, 1);
-        //draw_line(0, 129, 239, 40, 2);
-        //// right -> left && top -> bot
+        ////// draw_line(10, 159, 229, 0, 2);
+        //////
+        ////draw_line(0, 0, 239, 159, 1);
+        ////draw_line(0, 129, 239, 40, 2);
+        ////// right -> left && top -> bot
         //draw_line(239, 81, 0, 129, 3);
-        //// right -> left && bot -> top
+        ////// right -> left && bot -> top
         //draw_line(239, 129, 0, 40, 5);
             // txt_render();
             // txt_clear();
@@ -162,7 +162,7 @@ int main(void) {
         // PROF(test_fill_rect(), test_fill_rect_cycles);
         // PROF(test_chr(), test_chr_cycles);
         // PROF(test_icn(), test_icn_cycles);
-        // draw_filled_rect(0, 0, 140, 60, 0);
+        draw_filled_rect(0, 0, 140, 60, 0);
         PROF_SHOW();
         PROF(flip_buffer(), flip_cycles);
     }
diff --git a/src/renderer_m0.c b/src/renderer_m0.c
index 593dd10..ce9cfc8 100644
--- a/src/renderer_m0.c
+++ b/src/renderer_m0.c
@@ -179,6 +179,81 @@ draw_line(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
         draw_vline(x0, y0, y1, clr);
     } else {
 #if 1
+
+        // Fixed Precision constants.
+        const int fp_bit = 6;
+        const int fp_one = FP_NUM(1, fp_bit);
+        const int fp_half = fp_one >> 1;
+
+        int dx = x0 > x1 ? x0 - x1 : x1 - x0;
+        int dy = y0 > y1 ? y0 - y1 : y1 - y0;
+        int dxf = (dx << fp_bit);
+        int dyf = (dy << fp_bit);
+
+        if ((dx >= dy && x0 > x1) || (dx < dy && y0 > y1)) {
+            SWAP(x0, x1);
+            SWAP(y0, y1);
+        }
+
+        int frac_x = x0 > x1 ? FP_NUM(x0 - x1, fp_bit) : FP_NUM(x1 - x0, fp_bit);
+        int frac_y = y0 > y1 ? FP_NUM(y0 - y1, fp_bit) : FP_NUM(y1 - y0, fp_bit);
+        int x_step = x0 > x1 ? -1 : 1;
+        int y_step = y0 > y1 ? -1 : 1;
+        int distance = (frac_y - fp_one) * dx - (frac_x - fp_half) * dy;
+
+        //
+        // DEBUG: reference
+        // for (int i = 0; i <= dx; i++) {
+        //     if (distance >= 0) {
+        //         distance -= 2 * dxf;
+        //         y0 += y_step;
+        //     }
+        //     draw_pixel(x0, y0, clr);
+        //     distance += 2 * dyf;
+        //     x0 += x_step;
+        // }
+        //
+
+        size_t tile_x = x0 / 8;
+        size_t tile_y = y0 / 8;
+        size_t start_col = x0 % 8;
+        size_t start_row = y0 % 8;
+        u32 *dst = &backbuf[start_row + (tile_x + tile_y * 32) * 8];
+
+        // Update backbuffer.
+        if (dx >= dy) {
+            for (int i = 0; i <= dx; i++) {
+                start_col = x0 % 8;
+                start_row = y0 % 8;
+                size_t shift = start_col * sizeof(u32);
+                u32 mask = 0xF << shift;
+                u32 row = clr << shift;
+                if (distance >= 0) {
+                    distance -= 2 * dxf;
+                    y0 += y_step;
+                    if (((int)start_row + y_step) >=  8 || ((int)start_row + y_step) < 0) {
+                        dst += 8 * 31 * y_step;
+                    }
+                    dst += y_step;
+                }
+                *dst = (*dst & ~mask) | row;
+                distance += 2 * dyf;
+                if ((int)(start_col + x_step) >= 8 ||(int)(start_col + x_step) < 0) {
+                    dst += 8;
+                }
+                x0 += x_step;
+            }
+        // for (int i = 0; i <= dx; i++) {
+        //     if (distance >= 0) {
+        //         distance -= 2 * dxf;
+        //         y0 += y_step;
+        //     }
+        //     draw_pixel(x0, y0, clr);
+        //     distance += 2 * dyf;
+        //     x0 += x_step;
+        // }
+        }
+#else
         // Fixed Precision constants.
         const int fp_bit = 6;
         const int fp_one = FP_NUM(1, fp_bit);
@@ -200,7 +275,7 @@ draw_line(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
         int y_step = y0 > y1 ? -1 : 1;
         int distance = (frac_y - fp_one) * dx - (frac_x - fp_half) * dy;
         if (dx >= dy) {
-            int step = dx / dy;
+            int step = dxf / dyf;
             int remaining = dx;
             while (remaining > (step - 1)) {
                 distance += step * 2 * dyf;
@@ -224,7 +299,7 @@ draw_line(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
                 draw_hline(x0, x0 + remaining, y0, clr);
             }
         } else {
-            int step = dy / dx;
+            int step = dyf / dxf;
             int remaining = dy;
             while (remaining > (step - 1)) {
                     distance += step * 2 * dxf;
@@ -245,34 +320,6 @@ draw_line(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
                 draw_vline(x0, y0, y0 + remaining, 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 ? -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
     }
 }