Add example run-slice bresenham using a buf pointer

This is thus far slower than the previous run-slice approach, but not by
much. There could still be some savings by reducing the number of ops
but doubt it's worth it at this point.

2 files changed, 131 insertions, 19 deletions

diff --git a/src/main.c b/src/main.c
index 44e8fdb..29e420d 100644
--- a/src/main.c
+++ b/src/main.c
@@ -130,7 +130,8 @@ int main(void) {
 
         // DX is bigger
         // left -> right && top -> bot
-        //PROF(draw_line(0, 0, 239, 159, 1), test_lines_cycles);
+        // PROF(draw_line(0, 0, 64, 32, 1), test_lines_cycles);
+        // 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);
@@ -142,8 +143,8 @@ int main(void) {
         //draw_line(239, 81, 0, 129, 3);
         ////// right -> left && bot -> top
         //draw_line(239, 129, 0, 40, 5);
-            // txt_render();
-            // txt_clear();
+            txt_render();
+            txt_clear();
 
         // draw_line(239, 149, 0, 10, 3);
 
diff --git a/src/renderer_m0.c b/src/renderer_m0.c
index ce9cfc8..ece7dbb 100644
--- a/src/renderer_m0.c
+++ b/src/renderer_m0.c
@@ -222,27 +222,117 @@ draw_line(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
 
         // 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;
+            int step = dxf / dyf;
+            int remaining = dx;
+
+            //
+            // NOTE: Reference with pointers.
+            // 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;
+            // }
+            //
+
+            while (remaining > (step - 1)) {
+                distance += step * 2 * dyf;
+                size_t start_row = y0 % 8;
+                u32 a = x0;
+                size_t start_col = a % 8;
+                size_t tile_x0 = a / 8;
+                size_t shift_left = start_col * 4;
                 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;
+                    u32 b = x0 + step - 1;
+                    size_t tile_x1 = b / 8;
+                    size_t end_col = b % 8;
+                    size_t shift_right = (7 - end_col) * 4;
+                    size_t dtx = tile_x1 - tile_x0;
+                    if (dtx < 1) {
+                        u32 mask = (0xFFFFFFFF >> shift_right) & (0xFFFFFFFF << shift_left);
+                        u32 row = (0x11111111 * clr) & mask;
+                        *dst = (*dst & ~mask) | row;
+                        if ((start_col + x_step) >= 8 || end_col == 7) {
+                            dst += 8 * x_step;
+                        }
+                    } else {
+                        u32 mask = 0xFFFFFFFF;
+                        u32 row = 0x11111111 * clr;
+                        *dst = (*dst & ~(mask << shift_left)) | (row << shift_left);
+                        dst += 8 * x_step;
+                        for (size_t i = 1; i < dtx; i++) {
+                            *dst = row;
+                            dst += 8 * x_step;
+                        }
+                        *dst = (*dst & ~(mask >> shift_right)) | (row >> shift_right);
+                        if (end_col == 7) {
+                            dst += 8 * x_step;
+                        }
+                    }
+                    // draw_hline(a, b, y0, clr);
+                    x0 += step;
+                    remaining -= step;
+                } else {
+                    if (remaining < step) {
+                        break;
                     }
-                    dst += y_step;
+                    u32 b = x0 + step;
+                    size_t tile_x1 = b / 8;
+                    size_t end_col = b % 8;
+                    size_t dtx = tile_x1 - tile_x0;
+                    size_t shift_right = (7 - end_col) * 4;
+                    if (dtx < 1) {
+                        u32 mask = (0xFFFFFFFF >> shift_right) & (0xFFFFFFFF << shift_left);
+                        u32 row = (0x11111111 * clr) & mask;
+                        *dst = (*dst & ~mask) | row;
+                        if ((start_col + x_step) >= 8 || end_col == 7) {
+                            dst += 8 * x_step;
+                        }
+                    } else {
+                        u32 mask = 0xFFFFFFFF;
+                        u32 row = 0x11111111 * clr;
+                        *dst = (*dst & ~(mask << shift_left)) | (row << shift_left);
+                        dst += 8 * x_step;
+                        for (size_t i = 1; i < dtx; i++) {
+                            *dst = row;
+                            dst += 8 * x_step;
+                        }
+                        *dst = (*dst & ~(mask >> shift_right)) | (row >> shift_right);
+                        if (end_col == 7) {
+                            dst += 8 * x_step;
+                        }
+                    }
+                    // draw_hline(a, b, y0, clr);
+                    distance += 2 * dyf;
+                    x0 += (step + 1);
+                    remaining -= step + 1;
                 }
-                *dst = (*dst & ~mask) | row;
-                distance += 2 * dyf;
-                if ((int)(start_col + x_step) >= 8 ||(int)(start_col + x_step) < 0) {
-                    dst += 8;
+                if (((int)start_row + y_step) >=  8 || ((int)start_row + y_step) < 0) {
+                    dst += 8 * 31 * y_step;
                 }
-                x0 += x_step;
+                dst += y_step;
+                distance -= 2 * dxf;
+                y0 += y_step;
             }
+            if (remaining >= 0) {
+                draw_hline(x0, x0 + remaining, y0, clr);
+            }
+
         // for (int i = 0; i <= dx; i++) {
         //     if (distance >= 0) {
         //         distance -= 2 * dxf;
@@ -252,6 +342,27 @@ draw_line(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
         //     distance += 2 * dyf;
         //     x0 += x_step;
         // }
+        } else {
+            // int step = dyf / dxf;
+            // int remaining = dy;
+            // while (remaining > (step - 1)) {
+            //         distance += step * 2 * dxf;
+            //         if (distance >= 0) {
+            //             draw_vline(x0, y0, y0 + step - 1, clr);
+            //             y0 += y_step * step;
+            //             remaining -= step;
+            //         } else {
+            //             draw_vline(x0, y0, y0 + step, clr);
+            //             distance += 2 * dxf;
+            //             y0 += y_step * (step + 1);
+            //             remaining -= step + 1;
+            //         }
+            //         distance -= 2 * dyf;
+            //         x0 += x_step;
+            // }
+            // if (remaining >= 0) {
+            //     draw_vline(x0, y0, y0 + remaining, clr);
+            // }
         }
 #else
         // Fixed Precision constants.