Add dirty tiles and dirty lines method for buffer flipping

3 files changed, 70 insertions, 26 deletions

diff --git a/src/main.c b/src/main.c
index d97a110..55edea1 100644
--- a/src/main.c
+++ b/src/main.c
@@ -244,6 +244,8 @@ test_sprites_bounce(void) {
         {210 , 75  , 1  , 2  , 15 , 1 , 1},
     };
     int should_move = 1;
+    screen_fill(8);
+    flip_buffer();
     while (true) {
         poll_keys();
         if (key_tap(KEY_A)) {
@@ -257,12 +259,26 @@ test_sprites_bounce(void) {
         bios_vblank_wait();
         FRAME_START();
         PROF(flip_buffer(), flip_cycles);
+#if FLIP_TYPE == 0
         PROF(screen_fill(8), clear_cycles);
-        for (size_t i = 0; i < LEN(sprites); i++) {
+#endif
+        for (size_t i = 0; i < LEN(sprites) * should_move; i++) {
             Sprite *s = &sprites[i];
             PROF(draw_icn(
                     s->x, s->y,
                     sprite_icn,
+                    8,
+                    s->flip_x, s->flip_y), icn_cycles);
+            PROF(draw_chr(
+                    (240 - s->x - 8), (160 - s->y - 8),
+                    sprite_chr,
+                    8,
+                    s->flip_x, s->flip_y), chr_cycles);
+            s->x += s->inc_x;
+            s->y += s->inc_y;
+            PROF(draw_icn(
+                    s->x, s->y,
+                    sprite_icn,
                     s->clr,
                     s->flip_x, s->flip_y), icn_cycles);
             PROF(draw_chr(
@@ -270,20 +286,14 @@ test_sprites_bounce(void) {
                     sprite_chr,
                     s->clr,
                     s->flip_x, s->flip_y), chr_cycles);
-            s->x += s->inc_x * should_move;
-            s->y += s->inc_y * should_move;
             if (s->x > (240 - 8) && s->inc_x > 0) {
-                s->x = (240 - 8);
                 s->inc_x *= -1;
             } else if (s->x <= 0 && s->inc_x < 0){
-                s->x = 0;
                 s->inc_x *= -1;
             }
             if (s->y > (160 - 8) && s->inc_y > 0) {
-                s->y = 160 - 8;
                 s->inc_y *= -1;
             } else if (s->y <= 0 && s->inc_y < 0){
-                s->y = 0;
                 s->inc_y *= -1;
             }
         }
diff --git a/src/profiling.c b/src/profiling.c
index 4475aa8..a464372 100644
--- a/src/profiling.c
+++ b/src/profiling.c
@@ -41,7 +41,7 @@
 #endif
 
 static bool profile_show = true;
-static bool profile_bg_show = false;
+static bool profile_bg_show = true;
 
 #define PROF_SHOW() \
     do { \
diff --git a/src/renderer_m0.c b/src/renderer_m0.c
index ecb0402..e4d2dfc 100644
--- a/src/renderer_m0.c
+++ b/src/renderer_m0.c
@@ -14,6 +14,7 @@
 
 #define SUBPIXEL_LINES 1
 #define DEC_BIG_LUT 1
+#define FLIP_TYPE 2
 
 // Front/back buffers for double buffering.
 #define BUF_0 ((u32*)(MEM_VRAM))
@@ -53,11 +54,20 @@ static u32 dirty_tiles[21] = {0};
 // Basic primitives.
 //
 
+static inline
+void
+redraw(void) {
+    for (size_t i = 0; i < 21; i++) {
+        dirty_tiles[i] = 0xFFFFFFFF;
+    }
+}
+
 IWRAM_CODE
 void screen_fill(u8 clr)  {
     // We have to make sure we leave the last tile blank to use as alpha channel
     // when moving the BG during double buffering.
     dma_fill(backbuf, 0x11111111 * clr, KB(20) - 32, 3);
+    redraw();
 }
 
 IWRAM_CODE
@@ -613,8 +623,8 @@ draw_icn(size_t x, size_t y, u8 *sprite, u8 clr, u8 flip_x, u8 flip_y) {
 IWRAM_CODE
 void
 flip_buffer(void) {
-    // NOTE: can this be branchless? Either way is probably unnecessary other
-    // than code clarity maybe?.
+// Mode 0: double buffering without dirty tiles.
+#if FLIP_TYPE == 0
     if (backbuf == BUF_0) {
         backbuf = BUF_1;
         BG_H_SCROLL_0 = 0;
@@ -624,22 +634,46 @@ flip_buffer(void) {
         BG_H_SCROLL_0 = -240;
         BG_H_SCROLL_1 = 0;
     }
-    // TODO: Copying all tiles for now. Study if it's better to use dirty_tiles
-    // or dirty_lines.
-    // Copy dirty tiles from the backbuffer to the frontbuffer.
-    // Tile *dst = FRONTBUF;
-    // Tile *src = backbuf;
-    // for (size_t j = 0; j < 20; ++j) {
-    //     // if (dirty_tiles[j] == 0) {
-    //     //     continue;
-    //     // }
-    //     for (size_t i = 0, k = 1; i < 30; ++i, k <<= 1) {
-    //         // if (dirty_tiles[j] & k) {
-    //             dst[i + j * 32] = src[i + j * 32];
-    //         // }
-    //     }
-    //     // dirty_tiles[j] = 0;
-    // }
+
+// Mode 1: single buffer, copy the dirty lines from backbuffer (BUF_1) to
+// frontbuffer (BUF_0) using the DMA.
+#elif FLIP_TYPE == 1
+    u32 *front = BUF_0;
+    u32 *back = BUF_1;
+    BG_H_SCROLL_0 = 0;
+    BG_H_SCROLL_1 = -240;
+    for (size_t j = 0; j < 20; ++j) {
+        if (dirty_tiles[j] == 0) {
+            continue;
+        }
+        u32 offset = j * 32 * 8;
+        dma_copy(front + offset, back + offset, (30 * 8 * 4), 3);
+        dirty_tiles[j] = 0;
+    }
+
+// Mode 2: single buffer, copy the dirty tiles from backbuffer (BUF_1) to
+// frontbuffer (BUF_0).
+#elif FLIP_TYPE == 2
+    u32 *front = BUF_0;
+    u32 *back = BUF_1;
+    BG_H_SCROLL_0 = 0;
+    BG_H_SCROLL_1 = -240;
+    for (size_t j = 0; j < 20; ++j) {
+        if (dirty_tiles[j] == 0) {
+            continue;
+        }
+        u32 offset = j * 32 * 8;
+        size_t k = 1;
+        for (size_t i = 0; i < 30; ++i, k <<= 1) {
+            if (dirty_tiles[j] & k) {
+                Tile *mem_front = front;
+                Tile *mem_back = back;
+                mem_front[i + j * 32] = mem_back[i + j * 32];
+            }
+        }
+        dirty_tiles[j] = 0;
+    }
+#endif
 }
 
 //