Add line movement test

3 files changed, 151 insertions, 22 deletions

diff --git a/src/main.c b/src/main.c
index fa4457a..88ca24e 100644
--- a/src/main.c
+++ b/src/main.c
@@ -122,11 +122,51 @@ int main(void) {
 
     // Main loop.
     PROF_INIT();
+    int x = 0;
+    int y = 0;
+    int inc_x = 1;
+    int inc_y = 0;
     while (true) {
         bios_vblank_wait();
 
         PROF(test_clear(), test_clear_cycles);
+        draw_line(x, y, 239 - x, 159 - y, 2);
+        x += inc_x;
+        y += inc_y;
+        if (x == 239 && inc_x == 1) {
+            inc_x = 0;
+            inc_y = 1;
+        }
+        if (y == 159 && inc_y == 1) {
+            x = 0;
+            y = 0;
+            inc_x = 1;
+            inc_y = 0;
+        }
+
+        // draw_line(x, 229 - x, y, 129 - y, 2);
         // screen_fill(0);
+        // draw_pixel(0,  100 + 0, 5);
+        // draw_pixel(1,  100 + 0, 6);
+        // draw_pixel(2,  100 + 0, 5);
+        // draw_pixel(3,  100 + 0, 6);
+        // draw_pixel(4,  100 + 0, 5);
+        // draw_pixel(5,  100 + 0, 6);
+        // draw_pixel(6,  100 + 0, 5);
+        // draw_pixel(7,  100 + 0, 6);
+        // draw_pixel(8,  100 + 0, 5);
+        // draw_pixel(9,  100 + 0, 6);
+        // draw_pixel(10, 100 + 0, 5);
+        // draw_pixel(11, 100 + 0, 6);
+        // draw_pixel(12, 100 + 0, 5);
+        // draw_pixel(13, 100 + 0, 6);
+        // draw_pixel(14, 100 + 0, 5);
+        // draw_pixel(15, 100 + 0, 6);
+
+        // draw_hline(0, 10 + 4, 100 + 1, 2);
+        // draw_hline(0, 10 + 5, 100 + 2, 2);
+        // draw_hline(1, 10 + 4, 100 + 3, 5);
+        // draw_hline(1, 10 + 5, 100 + 4, 5);
 
         // DX is bigger
         // left -> right && top -> bot
@@ -134,7 +174,7 @@ int main(void) {
         // 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(0, 159, 239, 0, 2);
         ////// draw_line(10, 159, 229, 0, 2);
         //////
         ////draw_line(0, 0, 239, 159, 1);
@@ -158,12 +198,12 @@ int main(void) {
         // draw_line(0, 0, 19, 159, 6);
         // 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);
-        draw_filled_rect(0, 0, 140, 60, 0);
+        // 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);
+        // 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 6be01a4..c9aa7ae 100644
--- a/src/renderer_m0.c
+++ b/src/renderer_m0.c
@@ -173,14 +173,41 @@ draw_line(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
 
         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);
         }
 
+#if 0
+        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;
+            }
+        }
+#else
+        int dxf = (dx << fp_bit);
+        int dyf = (dy << fp_bit);
         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;
@@ -232,6 +259,7 @@ draw_line(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
                 draw_vline(x0, y0, y0 + remaining, clr);
             }
         }
+#endif
     }
 }
 
diff --git a/src/renderer_m4.c b/src/renderer_m4.c
index a70cff9..de052df 100644
--- a/src/renderer_m4.c
+++ b/src/renderer_m4.c
@@ -138,39 +138,86 @@ draw_line(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
         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) {
+            // u64 *dst = ((u64*)addr);
             // int step = dxf / dyf;
             // int remaining = dx;
             // int y_step = y0 > y1 ? -1 : 1;
+            // y_step /= 8;
             // while (remaining > (step - 1)) {
             //     distance += step * 2 * dyf;
+            //     size_t a = x0;
+            //     size_t b;
             //     if (distance >= 0) {
-            //         draw_hline(x0, x0 + step - 1, y0, clr);
-            //         x0 += x_step * step;
+            //         b = a + step - 1;
+            //         x0 += step;
             //         remaining -= step;
             //     } else {
             //         if (remaining < step) {
             //             break;
             //         }
-            //         draw_hline(x0, x0 + step, y0, clr);
+            //         b = a + step;
             //         distance += 2 * dyf;
-            //         x0 += x_step * (step + 1);
+            //         x0 += (step + 1);
             //         remaining -= step + 1;
             //     }
+            //     draw_hline(a, b, y0, 8); // DEBUG: reference
+
+            //     // size_t tile_x0 = a / 8;
+            //     // size_t tile_x1 = b / 8;
+            //     // size_t start_col = a % 8;
+            //     // size_t end_col = b % 8;
+            //     // size_t dtx = tile_x1 - tile_x0;
+            //     // size_t shift_left = start_col * 8;
+            //     // size_t shift_right = (7 - end_col) * 8;
+            //     // // size_t dtx = b/8 - a/8;
+            //     // u64 mask = 0xFFFFFFFFFFFFFFFF;
+            //     // u64 row = 0x0101010101010101 * clr;
+            //     // if (dtx < 1) {
+            //     //     mask = (mask >> shift_right) & (mask << shift_left);
+            //     //     *dst = (*dst & ~mask) | (row & mask);
+            //     // } else {
+            //     //     *dst = (*dst & ~(mask << shift_left)) | row << shift_left;
+            //     //     if (dtx != 1) {
+            //     //         dma_fill(&dst[1], 0x01010101 * clr, (dtx - 1) * 8, 3);
+            //     //     }
+            //     //     dst += dtx;
+            //     //     *dst = (*dst & ~(mask >> shift_right)) | row >> shift_right;
+            //     // }
+            //     // if (end_col == 7) {
+            //     //     dst++;
+            //     // }
+
+            //     dst += y_step;
             //     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++) {
+            // Subpixel accurate version.
+            // int distance = (frac_y - fp_half) * dx - (frac_x - fp_half) * dy;
+            // int distance = ( dx * ( frac_y - fp_half ) ) - ( dy * ( frac_x - fp_half ) );
+            // distance -= ( dx << ( fp_bit - 1 ) );
+            //
+            int distance = (frac_y - fp_one) * dx - (frac_x - fp_half) * dy;
+            int remaining = dx;
+            while (distance <= 0  && remaining > 0) {
+                dst = (u16*)(addr - (mask >> 31));
+                *dst = (*dst & ~mask) | (color & mask);
+                distance += 2 * dyf;
+                addr += x_step;
+                remaining--;
+                mask = ~mask;
+            }
+            distance -= 2 * dxf;
+            addr += y_step;
+
+            while (remaining >= 0) {
                 dst = (u16*)(addr - (mask >> 31));
                 *dst = (*dst & ~mask) | (color & mask);
                 if (distance >= 0) {
@@ -180,19 +227,33 @@ draw_line(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
                 distance += 2 * dyf;
                 addr += x_step;
                 mask = ~mask;
+                remaining--;
             }
         } else {
-            int diff = 2 * dx - dy;
-            for (int i = 0; i < dy + 1; i++) {
+            int distance = (frac_x - fp_one) * dy - (frac_y - fp_half) * dx;
+            int remaining = dy;
+            while (distance <= 0  && remaining > 0) {
                 dst = (u16*)(addr - (mask >> 31));
                 *dst = (*dst & ~mask) | (color & mask);
-                if (diff >= 0) {
-                    diff -= 2 * dy;
+                distance += 2 * dxf;
+                addr += y_step;
+                remaining--;
+            }
+            distance -= 2 * dyf;
+            addr += x_step;
+            mask = ~mask;
+
+            while (remaining >= 0) {
+                dst = (u16*)(addr - (mask >> 31));
+                *dst = (*dst & ~mask) | (color & mask);
+                if (distance >= 0) {
+                    distance -= 2 * dyf;
                     addr += x_step;
                     mask = ~mask;
                 }
-                diff += 2 * dx;
+                distance += 2 * dxf;
                 addr += y_step;
+                remaining--;
             }
         }
 #else