Add initial run slice bresengham implementation

2 files changed, 76 insertions, 6 deletions

diff --git a/src/main.c b/src/main.c
index 25e9893..aee8f56 100644
--- a/src/main.c
+++ b/src/main.c
@@ -126,15 +126,17 @@ int main(void) {
         bios_vblank_wait();
 
         PROF(test_clear(), test_clear_cycles);
-        // draw_line(0, 0, 100, 31, 2);
+        // draw_line(0, 0, 100, 50, 2);
+        // draw_line(0, 0, 100, 21, 5);
+        // draw_line(0, 0, 15, 7, 2);
         // draw_line(0, 31, 100, 0, 5);
         // txt_render();
         // txt_clear();
         PROF(test_lines(), test_lines_cycles);
-        // PROF(test_rect(), test_rect_cycles);
-        // PROF(test_fill_rect(), test_fill_rect_cycles);
-        // PROF(test_chr(), test_chr_cycles);
-        // PROF(test_icn(), test_icn_cycles);
+        PROF(test_rect(), test_rect_cycles);
+        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);
         PROF_SHOW();
         PROF(flip_buffer(), flip_cycles);
diff --git a/src/renderer_m0.c b/src/renderer_m0.c
index 904c2a1..02f1e31 100644
--- a/src/renderer_m0.c
+++ b/src/renderer_m0.c
@@ -179,6 +179,74 @@ 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
+        // NOTE: WIP run slice bresenham
+        int fp_bit = 6;
+        int fp_one = FP_NUM(1, fp_bit);
+        int fp_half = fp_one >> 1;
+        int dx     = x0 > x1 ? x0 - x1 : x1 - x0;
+        int dy     = y0 > y1 ? y0 - y1 : y1 - y0;
+        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 dxf = (dx << fp_bit);
+        int dyf = (dy << fp_bit);
+        if (dx >= dy) {
+            int step = dx / dy;
+            if (step == 1) {
+                // If the line is mostly diagonal, default to regular bresengham.
+                int distance = (frac_y - fp_one) * dx - (frac_x - fp_half) * dy;
+                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 {
+                int distance = (frac_y - fp_one) * dx - (frac_x - fp_half) * dy;
+                int remaining = dx;
+                while (remaining > (step - 1)) {
+                    distance += step * 2 * dyf;
+                    if (distance >= 0) {
+                        draw_hline(x0, x0 + step - 1, y0, clr);
+                        x0 += x_step * (step + 0);
+                        remaining -= step;
+                    } else {
+                        draw_hline(x0, x0 + step, y0, clr);
+                        distance += 2 * dyf;
+                        x0 += x_step * (step + 1);
+                        remaining -= step + 1;
+                    }
+                    distance -= 2 * dxf;
+                    y0 += y_step;
+                }
+                // Default to regular bresengham for the final segment.
+                for (int i = 0; i <= remaining; i++) {
+                    if (distance >= 0) {
+                        distance -= 2 * dxf;
+                        y0 += y_step;
+                    }
+                    draw_pixel(x0, y0, clr);
+                    distance += 2 * dyf;
+                    x0 += x_step;
+                }
+            }
+        } else {
+            int distance = (frac_x - fp_one) * dy - (frac_y - fp_half) * dx;
+            for (int i = 0; i <= dy; i++) {
+                draw_pixel(x0, y0, clr);
+                if (distance >= 0) {
+                    distance -= 2 * dyf;
+                    x0 += x_step;
+                }
+                distance += 2 * dxf;
+                y0 += y_step;
+            }
+        }
+#elif 0
         int fp_bit = 6;
         int fp_one = FP_NUM(1, fp_bit);
         int fp_half = fp_one >> 1;
@@ -213,7 +281,7 @@ draw_line(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
                 y0 += y_step;
             }
         }
-#else
+#elif 0
         int dx = x0 > x1 ? x0 - x1 : x1 - x0;
         int dy = y0 > y1 ? y0 - y1 : y1 - y0;
         int x_step = x0 > x1 ? -1 : 1;