Implement subpixel precision for line drawing

2 files changed, 25 insertions, 27 deletions

diff --git a/src/main.c b/src/main.c
index bd50a99..25e9893 100644
--- a/src/main.c
+++ b/src/main.c
@@ -126,12 +126,15 @@ int main(void) {
         bios_vblank_wait();
 
         PROF(test_clear(), test_clear_cycles);
-        // draw_line(0, 0, 50, 20, 2);
+        // draw_line(0, 0, 100, 31, 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 94a3d9d..36ed01b 100644
--- a/src/renderer_m0.c
+++ b/src/renderer_m0.c
@@ -179,42 +179,37 @@ 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
+        int precision_bits = 6;
+        int precision_one = (1 << precision_bits);
+        int precision_half = precision_one >> 1;
         int dx = x0 > x1 ? x0 - x1 : x1 - x0;
         int dy = y0 > y1 ? y0 - y1 : y1 - y0;
+        int frac_x = x0 > x1 ? ((x0 - x1) << precision_bits) : ((x1 - x0) << precision_bits);
+        int frac_y = y0 > y1 ? ((y0 - y1) << precision_bits) : ((y1 - y0) << precision_bits);
         int x_step = x0 > x1 ? -1 : 1;
         int y_step = y0 > y1 ? -1 : 1;
+        int dxf = (dx << precision_bits);
+        int dyf = (dy << precision_bits);
         if (dx >= dy) {
-            // int diff = 2 * dy - dx;
-            // int distance = dx * dy - (y1 - y0) * dx;
-            int distance = (dy - dx) / 2;
-            for (int i = 0; i < dx + 1; i++) {
-                // Previous implementation (Tom Forsyth).
-                if (distance > dx / 2) {
-                    distance -= dx;
+            int distance = (frac_y - precision_one) * dx - (frac_x - precision_half) * dy;
+            for (int i = 0; i <= dx; i++) {
+                if (distance >= 0) {
+                    distance -= 2 * dxf;
                     y0 += y_step;
                 }
                 draw_pixel(x0, y0, clr);
-                distance += dy;
+                distance += 2 * dyf;
                 x0 += x_step;
-
-                // Previous implementation, slightly faster.
-                // 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++) {
+            int distance = (frac_x - precision_one) * dy - (frac_y - precision_half) * dx;
+            for (int i = 0; i <= dy; i++) {
                 draw_pixel(x0, y0, clr);
-                if (diff >= 0) {
-                    diff -= 2 * dy;
+                if (distance >= 0) {
+                    distance -= 2 * dyf;
                     x0 += x_step;
                 }
-                diff += 2 * dx;
+                distance += 2 * dxf;
                 y0 += y_step;
             }
         }