Change dx >= dy mode 4 line drawing to be subpixel accurate

1 files changed, 79 insertions, 0 deletions

diff --git a/src/renderer_m4.c b/src/renderer_m4.c
index 4e8868a..a70cff9 100644
--- a/src/renderer_m4.c
+++ b/src/renderer_m4.c
@@ -118,6 +118,84 @@ 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
+        // 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 ? -SCREEN_WIDTH : SCREEN_WIDTH;
+        int distance = (frac_y - fp_one) * dx - (frac_x - fp_half) * dy;
+
+        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 step = dxf / dyf;
+            // int remaining = dx;
+            // int y_step = y0 > y1 ? -1 : 1;
+            // while (remaining > (step - 1)) {
+            //     distance += step * 2 * dyf;
+            //     if (distance >= 0) {
+            //         draw_hline(x0, x0 + step - 1, y0, clr);
+            //         x0 += x_step * step;
+            //         remaining -= step;
+            //     } else {
+            //         if (remaining < step) {
+            //             break;
+            //         }
+            //         draw_hline(x0, x0 + step, y0, clr);
+            //         distance += 2 * dyf;
+            //         x0 += x_step * (step + 1);
+            //         remaining -= step + 1;
+            //     }
+            //     distance -= 2 * dxf;
+            //     y0 += y_step;
+            // }
+            // if (remaining >= 0) {
+            //     draw_hline(x0, x0 + remaining, y0, clr);
+            // }
+            // int distance = 2 * dy - dx;
+            for (int i = 0; i < dx + 1; i++) {
+                dst = (u16*)(addr - (mask >> 31));
+                *dst = (*dst & ~mask) | (color & mask);
+                if (distance >= 0) {
+                    distance -= 2 * dxf;
+                    addr += y_step;
+                }
+                distance += 2 * dyf;
+                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;
+            }
+        }
+#else
         // Diagonal line.
         int     dx = x0 > x1 ?       x0 - x1 : x1 - x0;
         int     dy = y0 > y1 ?       y0 - y1 : y1 - y0;
@@ -155,6 +233,7 @@ draw_line(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
                 addr += y_step;
             }
         }
+#endif
     }
 }