Add initial double buffering mode0 renderer

2 files changed, 703 insertions, 8 deletions

diff --git a/src/main.c b/src/main.c
index 23f4fe3..a7bad92 100644
--- a/src/main.c
+++ b/src/main.c
@@ -11,7 +11,7 @@ WITH REGARD TO THIS SOFTWARE.
 
 #include "gba/gba.h"
 
-#include "renderer.c"
+#include "renderer_m0.c"
 
 //
 // Config parameters.
@@ -121,6 +121,14 @@ int main(void) {
     irs_set(IRQ_VBLANK, irs_stub);
 
     // Initialize sequencer.
+    // flip_buffer();
+    // screen_fill(1);
+    // screen_fill(2);
+    // backbuf[0] = 0x11111111;
+    // screen_fill(1);
+    // flip_buffer();
+    // screen_fill(2);
+    // flip_buffer();
 
     // Main loop.
     PROF_INIT();
@@ -128,13 +136,13 @@ int main(void) {
         bios_vblank_wait();
 
         PROF(test_clear(), test_clear_cycles);
-        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(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
new file mode 100644
index 0000000..3034d40
--- /dev/null
+++ b/src/renderer_m0.c
@@ -0,0 +1,687 @@
+//
+// This Mode 0 renderer provides a way of drawing directly to a framebuffer
+// (similar to Mode 3 and 4) while retaining the flexibility of using other
+// backgrounds if needed. It also performs double buffering to avoid tearing
+// artifacts and tries to only draw tiles that changed on each frame.
+//
+// In addition to the frontbuffer (displayed on background 0), a tiled text
+// layer is displayed on background 1, which can be used for application
+// development or for debug information.
+//
+// These two layers occupy the first and second background charblocks, leaving
+// the remaining two available for other background layers. There are 14KB of
+// sprite memory available, since the backbuffer is located at the end of the
+// VRAM, but if more space is needed it can be moved to the end of the BG
+// charblocks instead.
+//
+
+#include "renderer.h"
+#include "text.h"
+
+// Front/back buffers for double buffering.
+#define BUF_0 ((u32*)(MEM_VRAM))
+#define BUF_1 ((u32*)(MEM_VRAM + KB(20)))
+// Position of the tilemap.
+#define TILE_MAP  ((u32*)(MEM_VRAM + KB(40)))
+
+// Charblock and screenblock for both render buffers.
+#define CB_0 0
+#define CB_1 1
+#define SB_0 20
+#define SB_1 21
+
+// Available storage for other memory.
+// #define FG_PIXELS ((u32*)(MEM_VRAM + KB(44)))
+// #define BG_PIXELS ((u32*)(MEM_VRAM + KB(64)))
+
+// // The frontbuffs,eer is located at the beginning of the VRAM, and requires 20KB of
+// // video memory for 32 * 20 tiles at 4bpp.
+// #define FRONTBUF ((u32*)(MEM_VRAM))
+
+// // Adjust both of these if the location of the map changes. Each screnblock
+// // requires less than 2KB.
+// #define FRONTBUF_TILEMAP ((u16*)(MEM_VRAM + KB(20)))
+// #define FRONTBUF_SB      10
+
+// The backbuffer is located at the end of the VRAM. This can allow us to use
+// more backgrounds but eats into the available memory for sprites. This should
+// be fine for non sprite intensive applications. If more sprite memory is
+// needed, the backbuffer can be located at the end of the background memory
+// instead (64KB - 20KB).
+// #define BACKBUF  ((u32*)(MEM_VRAM + KB(96) - KB(20)))
+
+// Keep track of which tiles need to be copied to the frontbuffer.
+static u32 dirty_tiles[21] = {0};
+static u32 *backbuf = BUF_1;
+
+// Boundchecks can be disable at compile time but this will not always improve
+// the performance and can in fact make it worse. It is possible that this is
+// due to some aliasing optimiztions but not sure at this moment.
+#ifdef DISABLE_BOUNDCHECK_SCREEN
+#define BOUNDCHECK_SCREEN(X,Y)
+#else
+#define BOUNDCHECK_SCREEN(X,Y) if ((X) >= SCREEN_WIDTH || (Y) >= SCREEN_HEIGHT) return;
+#endif
+
+// Swap A and B values without a tmp variable.
+#define SWAP(A, B) (((A) ^= (B)), ((B) ^= (A)), ((A) ^= (B)))
+
+// Swap A and B values to make sure A <= B.
+#define MAYBE_SWAP(A,B) if ((A) > (B)) { SWAP(A,B); }
+
+IWRAM_CODE
+void screen_fill(u8 clr)  {
+#if 0
+//     u32 *dst = backbuf;
+//     for(int i = 0; i < KB(75) / 8; i++) {
+//         *dst++ = 0x01010101 * clr;
+//     }
+#else
+    dma_fill(backbuf, 0x11111111 * clr, KB(20), 3);
+#endif
+}
+
+IWRAM_CODE
+void
+draw_pixel(size_t x, size_t y, u8 clr) {
+    BOUNDCHECK_SCREEN(x, y);
+
+    // Find row position for the given x/y coordinates.
+    size_t tile_x = x / 8;
+    size_t tile_y = y / 8;
+    size_t start_col = x % 8;
+    size_t start_row = y % 8;
+    size_t pos = start_row + (tile_x + tile_y * 32) * 8;
+
+    // Update backbuffer.
+    size_t shift = start_col * sizeof(u32);
+    backbuf[pos] = (backbuf[pos] & ~(0xF << shift)) | clr << shift;
+
+    // Mark tile as dirty.
+    dirty_tiles[tile_y] |= 1 << tile_x;
+}
+
+IWRAM_CODE
+static inline
+void
+draw_hline(size_t x0, size_t x1, size_t y0, u8 clr) {
+    // TODO
+}
+
+IWRAM_CODE
+UNROLL_LOOPS
+static inline
+void
+draw_vline(size_t x0, size_t y0, size_t y1, u8 clr) {
+    // TODO
+}
+
+IWRAM_CODE
+void
+draw_line(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
+    // BOUNDCHECK_SCREEN(x0, y0);
+    // BOUNDCHECK_SCREEN(x1, y1);
+    if (y0 == y1) {
+        MAYBE_SWAP(x0, x1);
+        draw_hline(x0, x1, y0, clr);
+    } else if (x0 == x1) {
+        MAYBE_SWAP(y0, y1);
+        draw_vline(x0, y0, y1, clr);
+    } else {
+        // // Diagonal line.
+        // int     dx = x0 > x1 ?       x0 - x1 : x1 - x0;
+        // int     dy = y0 > y1 ?       y0 - y1 : y1 - y0;
+        // int x_step = x0 > x1 ?            -1 : 1;
+        // int y_step = y0 > y1 ? -SCREEN_WIDTH : SCREEN_WIDTH;
+
+        // 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 diff = 2 * dy - dx;
+        //     for (int i = 0; i < dx + 1; i++) {
+        //         dst = (u16 *)(addr - (mask >> 31));
+        //         *dst = (*dst & ~mask) | (color & mask);
+        //         if (diff >= 0) {
+        //             diff -= 2 * dx;
+        //             addr += y_step;
+        //         }
+        //         diff += 2 * dy;
+        //         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;
+        //     }
+        // }
+    }
+
+    // // Find row positions for the given x/y coordinates.
+    // size_t tile_x0 = x0 / 8;
+    // size_t tile_y0 = y0 / 8;
+    // size_t tile_x1 = x1 / 8;
+    // size_t tile_y1 = y1 / 8;
+    // size_t start_col0 = x0 % 8;
+    // size_t start_col1 = x1 % 8;
+    // size_t start_row0 = y0 % 8;
+    // size_t start_row1 = y1 % 8;
+
+    // // Get a pointer to the backbuffer and the tile row.
+    // u32 *backbuffer = &BACKBUF[start_row0 + (tile_x0 + tile_y0 * 32) * 8];
+
+    // if (y0 == y1) {
+    //     // Horizontal line. There are 3 cases:
+    //     //     1. Lines fit on a single tile.
+    //     //     2. Lines go through 2 tiles, both require partial row updates.
+    //     //     3. Lines go through 3 or more tiles, first and last tiles use
+    //     //        partial row updates, rows in the middle can write the.
+    //     size_t dx = tile_x1 - tile_x0;
+    //     if (dx < 1) {
+    //         u32 row_mask = 0xFFFFFFFF;
+    //         row_mask >>= (7 - start_col1 - dx) * 4;
+    //         row_mask &= 0xFFFFFFFF << start_col0 * 4;
+    //         u32 row = (0x11111111 * clr) & row_mask;
+    //         backbuffer[0] = (backbuffer[0] & ~row_mask) | row;
+    //         dirty_tiles[tile_y0] |= 1 << tile_x0;
+    //     } else {
+    //         size_t shift_left = start_col0 * 4;
+    //         size_t shift_right = (7 - start_col1) * 4;
+    //         u32 row_mask = 0xFFFFFFFF;
+    //         u32 row = 0x11111111 * clr;
+    //         backbuffer[0] = backbuffer[0] & ~(row_mask << shift_left);
+    //         backbuffer[0] |= row << shift_left;
+    //         dirty_tiles[tile_y0] |= 1 << tile_x0;
+    //         for (size_t i = 1; i < dx; i++) {
+    //             backbuffer[i * 8] = row;
+    //             dirty_tiles[tile_y0] |= 1 << (tile_x0 + i);
+    //         }
+    //         backbuffer[dx * 8] = backbuffer[dx * 8] & ~(row_mask >> shift_right);
+    //         backbuffer[dx * 8] |= row >> shift_right;
+    //         dirty_tiles[tile_y0] |= 1 << (tile_x0 + dx);
+    //     }
+    // } else if (x0 == x1) {
+    //     // Vertical line. The cases are analogous to the horizontal ones.
+    //     size_t dy = tile_y1 - tile_y0;
+    //     u32 row_mask = 0xF << start_col0 * 4;
+    //     u32 row_left = (0x11111111 * clr) & row_mask;
+    //     if (dy < 1) {
+    //         for (size_t i = 0; i <= y1 - y0; i++, backbuffer++) {
+    //             backbuffer[0] = (backbuffer[0] & ~row_mask) | row_left;
+    //         }
+    //     } else {
+    //         for (size_t i = 0; i < (8 - start_row0); i++, backbuffer++) {
+    //             backbuffer[0] = (backbuffer[0] & ~row_mask) | row_left;
+    //         }
+    //         dirty_tiles[tile_y0] |= 1 << tile_x0;
+    //         backbuffer += 8 * 31;
+    //         for (size_t j = 1; j < dy; j++) {
+    //             for (size_t i = 0; i < 8; i++, backbuffer++) {
+    //                 backbuffer[0] = (backbuffer[0] & ~row_mask) | row_left;
+    //             }
+    //             backbuffer += 8 * 31;
+    //             dirty_tiles[tile_y0 + j] |= 1 << tile_x0;
+    //         }
+    //         for (size_t i = 0; i <= start_row1; i++, backbuffer++) {
+    //             backbuffer[0] = (backbuffer[0] & ~row_mask) | row_left;
+    //         }
+    //         dirty_tiles[tile_y1] |= 1 << tile_x0;
+    //     }
+    // } else {
+    //     // Diagonal line.
+    //     int dx = x0 > x1 ? x0 - x1 : x1 - x0;
+    //     int dy = y0 > y1 ? y1 - y0 : y0 - y1;
+    //     int x_step = x0 < x1 ? 1 : -1;
+    //     int y_step = y0 < y1 ? 1 : -1;
+    //     int err = dx + dy;
+    //     while (!(x0 == x1 && y0 == y1)) {
+    //         draw_pixel(x0, y0, clr);
+    //         int diff = 2 * err;
+    //         if (diff >= dy) {
+    //             err += dy;
+    //             x0 += x_step;
+    //         }
+    //         if (diff <= dx) {
+    //             err += dx;
+    //             y0 += y_step;
+    //         }
+    //     }
+    // }
+}
+
+IWRAM_CODE
+void
+draw_rect(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
+    BOUNDCHECK_SCREEN(x0, y0);
+    BOUNDCHECK_SCREEN(x1, y1);
+    MAYBE_SWAP(x0, x1);
+    MAYBE_SWAP(y0, y1);
+
+    draw_hline(x0, x1, y0, clr);
+    draw_hline(x0, x1, y1, clr);
+    draw_vline(x0, y0, y1, clr);
+    draw_vline(x1, y0, y1, clr);
+
+    // TODO: check if this is better.
+//     BOUNDCHECK_SCREEN(x0, y0);
+//     BOUNDCHECK_SCREEN(x1, y1);
+
+//     // Find row positions for the given x/y coordinates.
+//     size_t tile_x0 = x0 / 8;
+//     size_t tile_y0 = y0 / 8;
+//     size_t tile_x1 = x1 / 8;
+//     size_t tile_y1 = y1 / 8;
+//     size_t start_col0 = x0 % 8;
+//     size_t start_col1 = x1 % 8;
+//     size_t start_row0 = y0 % 8;
+//     size_t start_row1 = y1 % 8;
+
+//     // Get a pointer to the backbuffer and the tile row.
+//     u32 *buf_top = &BACKBUF[start_row0 + (tile_x0 + tile_y0 * 32) * 8];
+//     u32 *buf_bot = &BACKBUF[start_row1 + (tile_x0 + tile_y1 * 32) * 8];
+
+//     size_t dx = tile_x1 - tile_x0;
+//     size_t dy = tile_y1 - tile_y0;
+
+//     memset(buf_top, 3, x1 - x0);
+//     memset(buf_bot, 3, x1 - x0);
+
+//     if (dx < 1) {
+//         dirty_tiles[tile_y0] |= 1 << tile_x0;
+//         dirty_tiles[tile_y1] |= 1 << tile_x0;
+//     } else {
+//         dirty_tiles[tile_y0] |= 1 << tile_x0;
+//         dirty_tiles[tile_y1] |= 1 << tile_x0;
+//         for (size_t i = 1; i < dx; i++) {
+//             dirty_tiles[tile_y0] |= 1 << (tile_x0 + i);
+//             dirty_tiles[tile_y1] |= 1 << (tile_x0 + i);
+//         }
+//         dirty_tiles[tile_y0] |= 1 << (tile_x0 + dx);
+//         dirty_tiles[tile_y1] |= 1 << (tile_x0 + dx);
+//     }
+//     if (dy < 1) {
+//     } else {
+//         for (size_t j = 1; j < dy; j++) {
+//             dirty_tiles[tile_y0 + j] |= 1 << tile_x0;
+//             dirty_tiles[tile_y0 + j] |= 1 << (tile_x0 + dx);
+//         }
+//     }
+}
+
+IWRAM_CODE
+void
+draw_filled_rect(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
+    BOUNDCHECK_SCREEN(x0, y0);
+    BOUNDCHECK_SCREEN(x1, y1);
+    MAYBE_SWAP(x0, x1);
+    MAYBE_SWAP(y0, y1);
+
+    // Special condition. If the screen is to be completely filled, use the DMA
+    // instead.
+    if (x0 == 0 && x1 >= (SCREEN_WIDTH - 1) && y0 == 0 && y1 >= (SCREEN_HEIGHT - 1)) {
+        screen_fill(clr);
+        return;
+    }
+
+    // Drawline implementation.
+    for (size_t y = y0; y <= y1; y++) {
+        // NOTE: Unclear why here draw_hline is faster than draw_line.
+        draw_hline(x0, x1, y, clr);
+    }
+
+    // TODO: check if this is better.
+    // BOUNDCHECK_SCREEN(x0, y0);
+    // BOUNDCHECK_SCREEN(x1, y1);
+
+    // size_t dx = x1 - x0;
+    // size_t dy = y1 - y0;
+    // u8 *buf = &BACKBUF[0];
+    // memset(buf, 0x11 * clr, 16);
+    //for (size_t j = 0; j < 1; j++) {
+    //    // for (size_t i = 0; i < dx; i++) {
+    //    //     buf[i + j * 16] = clr;
+    //    // }
+    //    //
+    //    // BACKBUF[j + 0] = 0x11111111 * clr;
+    //    // BACKBUF[j + 1] = 0x11111111 * clr;
+    //    // BACKBUF[j + 2] = 0x11111111 * clr;
+    //    // BACKBUF[j + 3] = 0x11111111 * clr;
+    //    // BACKBUF[j + 4] = 0x11111111 * clr;
+    //    // BACKBUF[j + 5] = 0x11111111 * clr;
+    //    // BACKBUF[j + 6] = 0x11111111 * clr;
+    //    // BACKBUF[j + 7] = 0x11111111 * clr;
+
+    //    buf[j + 0] = 0x1 * clr;
+    //    buf[j + 1] = 0x1 * clr;
+    //    buf[j + 2] = 0x1 * clr;
+    //    buf[j + 3] = 0x1 * clr;
+    //    // buf[j + 4] = 0x1111 * clr;
+    //    // buf[j + 5] = 0x1111 * clr;
+    //    // buf[j + 6] = 0x1111 * clr;
+    //    // buf[j + 7] = 0x1111 * clr;
+    //}
+    // u8 *buf = &BACKBUF[0];
+    // buf[8 * 16 + 0] = clr;
+    // buf[8 * 16 + 1] = clr;
+    // buf[8 * 16 + 2] = clr;
+    // buf[8 * 16 + 3] = clr;
+    // buf[8 * 16 + 4] = clr;
+    // buf[8 * 16 + 5] = clr;
+    // buf[8 * 16 + 6] = clr;
+    // buf[8 * 16 + 7] = clr;
+    // for (size_t j = 0; j < dy; j++) {
+    //     for (size_t i = 0; i < dx; i++) {
+    //         buf[i + j * 16] = clr;
+    //     }
+    // }
+    // size_t n_rect = MIN(dx, dy);
+    // n_rect = n_rect / 2 + 1;
+    // for (size_t i = 0; i < n_rect; i++) {
+    //     draw_rect(x0 + i, y0 + i, x1 - i, y1 - i, clr);
+    // }
+}
+
+// IWRAM_CODE
+// void
+// draw_tile(size_t x, size_t y, Tile *tile, u8 clr) {
+//     BOUNDCHECK_SCREEN(x, y);
+
+//     // Find row position for the given x/y coordinates.
+//     size_t tile_x = x / 8;
+//     size_t tile_y = y / 8;
+//     size_t start_col = x % 8;
+//     size_t start_row = y % 8;
+
+//     // Get a pointer to the backbuffer and the tile row.
+//     size_t pos = start_row + (tile_x + tile_y * 32) * 8;
+//     u32 *backbuffer = &BACKBUF[pos];
+//     u32 *row = tile;
+
+//     // This will blend all colors weirdly if using tiles that contain colors
+//     // higher than 1.
+//     size_t shift_left = start_col * 4;
+//     size_t shift_right = (8 - start_col) * 4;
+//     // u32 row_mask_left = merge ? 0 : 0xFFFFFFFF << shift_left;
+//     // u32 row_mask_right = merge ? 0 : 0xFFFFFFFF >> shift_right;
+
+//     // Draw the tiles. There are 4 possible cases:
+//     //     1. The tile is exactly at the tile boundary.
+//     //     2. The tile spans 2 tiles horizontally.
+//     //     3. The tile spans 2 tiles vertically.
+//     //     4. The tile spans 4 tiles.
+//     if (start_col == 0 && start_row == 0) {
+//         for (size_t i = 0; i < (8 - start_row); i++, backbuffer++) {
+//             BOUNDCHECK_SCREEN(x, y + i);
+//             backbuffer[0] = (backbuffer[0] & ~row_mask_left) | row[i] * clr;
+//         }
+//         dirty_tiles[tile_y] |= 1 << tile_x;
+//     } else if (start_row == 0) {
+//         for (size_t i = 0; i < 8; i++, backbuffer++) {
+//             BOUNDCHECK_SCREEN(x, y + i);
+//             backbuffer[0] = (backbuffer[0] & ~row_mask_left) | (row[i] * clr << shift_left);
+//             backbuffer[8] = (backbuffer[8] & ~row_mask_right) | (row[i] * clr >> shift_right);
+//         }
+//         dirty_tiles[tile_y] |= 1 << tile_x;
+//         dirty_tiles[tile_y] |= 1 << (tile_x + 1);
+//     } else if (start_col == 0) {
+//         for (size_t i = 0; i < (8 - start_row); i++, backbuffer++) {
+//             BOUNDCHECK_SCREEN(x, y + i);
+//             backbuffer[0] = (backbuffer[0] & ~row_mask_left) | row[i] * clr;
+//         }
+//         backbuffer += 8 * 31;
+//         for (size_t i = (8 - start_row); i < 8; i++, backbuffer++) {
+//             BOUNDCHECK_SCREEN(x, y + i);
+//             backbuffer[0] = (backbuffer[0] & ~row_mask_left) | row[i] * clr;
+//         }
+//         dirty_tiles[tile_y] |= 1 << tile_x;
+//         dirty_tiles[tile_y + 1] |= 1 << tile_x;
+//     } else {
+//         for (size_t i = 0; i < (8 - start_row); i++, backbuffer++) {
+//             BOUNDCHECK_SCREEN(x, y + i);
+//             backbuffer[0] = (backbuffer[0] & ~row_mask_left) | (row[i] * clr << shift_left);
+//             backbuffer[8] = (backbuffer[8] & ~row_mask_right) | (row[i] * clr >> shift_right);
+//         }
+//         backbuffer += 8 * 31;
+//         for (size_t i = (8 - start_row); i < 8; i++, backbuffer++) {
+//             BOUNDCHECK_SCREEN(x, y + i);
+//             backbuffer[0] = (backbuffer[0] & ~row_mask_left) | (row[i] * clr << shift_left);
+//             backbuffer[8] = (backbuffer[8] & ~row_mask_right) | (row[i] * clr >> shift_right);
+//         }
+//         dirty_tiles[tile_y] |= 1 << tile_x;
+//         dirty_tiles[tile_y] |= 1 << (tile_x + 1);
+//         dirty_tiles[tile_y + 1] |= 1 << tile_x;
+//         dirty_tiles[tile_y + 1] |= 1 << (tile_x + 1);
+//     }
+// }
+
+// void
+// clear_screen(void) {
+//     dma_fill(FRONTBUF, 0, KB(20), 3);
+// }
+
+IWRAM_CODE
+void
+flip_buffer(void) {
+    if (backbuf == BUF_0) {
+        backbuf = BUF_1;
+        DISP_CTRL = DISP_MODE_0 | DISP_BG_1 | DISP_OBJ;
+        BG_CTRL(0) = BG_CHARBLOCK(CB_0) | BG_SCREENBLOCK(SB_0) | BG_PRIORITY(2);
+        BG_CTRL(1) = BG_CHARBLOCK(CB_1) | BG_SCREENBLOCK(SB_1) | BG_PRIORITY(1);
+    } else {
+        backbuf = BUF_0;
+        DISP_CTRL = DISP_MODE_0 | DISP_BG_0 | DISP_OBJ;
+        BG_CTRL(0) = BG_CHARBLOCK(CB_0) | BG_SCREENBLOCK(SB_0) | BG_PRIORITY(1);
+        BG_CTRL(1) = BG_CHARBLOCK(CB_1) | BG_SCREENBLOCK(SB_1) | BG_PRIORITY(2);
+    }
+    // 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;
+    // }
+}
+
+static u32 dec_nibble[] = {
+    0x00000000, 0x01000000, 0x00010000, 0x01010000,
+    0x00000100, 0x01000100, 0x00010100, 0x01010100,
+    0x00000001, 0x01000001, 0x00010001, 0x01010001,
+    0x00000101, 0x01000101, 0x00010101, 0x01010101,
+};
+
+static u32 dec_nibble_flip_x[] = {
+    0x00000000, 0x00000001, 0x00000100, 0x00000101,
+    0x00010000, 0x00010001, 0x00010100, 0x00010101,
+    0x01000000, 0x01000001, 0x01000100, 0x01000101,
+    0x01010000, 0x01010001, 0x01010100, 0x01010101,
+};
+
+IWRAM_CODE
+static inline
+u64
+decode_1bpp(u8 row, u8 flip_x) {
+    if (flip_x) {
+        u32 *lut = dec_nibble_flip_x;
+        return (u64)lut[(row >> 4) & 0xF] << 32 | (u64)lut[(row >> 0) & 0xF];
+    }
+    u32 *lut = dec_nibble;
+    return (u64)lut[(row >> 0) & 0xF] << 32 | (u64)lut[(row >> 4) & 0xF];
+}
+
+IWRAM_CODE
+static inline
+void
+draw_2bpp_row(size_t x, size_t y, u8 a, u8 b, u8 flip_x) {
+    // BOUNDCHECK_SCREEN(x, y);
+
+    // size_t tile_x = x / 8;
+    // size_t start_col = x % 8;
+    // size_t shift_left = start_col * 8;
+    // size_t shift_right = (8 - start_col) * 8;
+
+    // u64 *dst = &backbuf[(y * 30 + tile_x) * 8 / 2];
+    // if (start_col == 0) {
+    //     u64 clr_a = decode_1bpp(a, flip_x);
+    //     u64 clr_b = decode_1bpp(b, flip_x);
+    //     u64 mask_a = (clr_a * 0xF);
+    //     u64 mask_b = (clr_b * 0xF);
+    //     u64 mask = (mask_a | mask_b);
+    //     u64 color = clr_a + (clr_b << 1);
+    //     dst[0] = (dst[0] & ~mask) | color;
+    // } else {
+    //     u64 clr_a = decode_1bpp(a, flip_x);
+    //     u64 clr_b = decode_1bpp(b, flip_x);
+    //     u64 mask_a = (clr_a * 0xF);
+    //     u64 mask_b = (clr_b * 0xF);
+    //     u64 mask = (mask_a | mask_b);
+    //     u64 color = clr_a + (clr_b << 1);
+    //     dst[0] = (dst[0] & ~(mask << shift_left))  | (color << shift_left);
+    //     if ((x + 7) > (SCREEN_WIDTH)) {
+    //         return;
+    //     }
+    //     dst[1] = (dst[1] & ~(mask >> shift_right)) | (color >> shift_right);
+    // }
+
+    // TODO: different blend modes?
+}
+
+IWRAM_CODE
+static inline
+void
+draw_1bpp_row(size_t x, size_t y, u8 a, u8 clr, u8 flip_x) {
+    // BOUNDCHECK_SCREEN(x, y);
+
+    // size_t tile_x = x / 8;
+    // size_t start_col = x % 8;
+    // size_t shift_left = start_col * 8;
+    // size_t shift_right = (8 - start_col) * 8;
+
+    // u64 *dst = &backbuf[(y * 30 + tile_x) * 8 / 2];
+    // if (start_col == 0) {
+    //     u64 color = decode_1bpp(a, flip_x);
+    //     u64 mask = (color * 0xF);
+    //     color *= clr;
+    //     dst[0] = (dst[0] & ~mask) | color;
+    // } else {
+    //     u64 color = decode_1bpp(a, flip_x);
+    //     u64 mask = (color * 0xF);
+    //     color *= clr;
+    //     dst[0] = (dst[0] & ~(mask << shift_left))  | (color << shift_left);
+    //     if ((x + 7) > (SCREEN_WIDTH)) {
+    //         return;
+    //     }
+    //     dst[1] = (dst[1] & ~(mask >> shift_right)) | (color >> shift_right);
+    // }
+
+    // TODO: different blend modes?
+}
+
+IWRAM_CODE
+void
+draw_chr(size_t x, size_t y, u8 *sprite, u8 flip_x, u8 flip_y) {
+    // BOUNDCHECK_SCREEN(x, y);
+    // if (!flip_y) {
+    //     for(size_t v = 0; v < 8; v++) {
+    //         if ((y + v) >= SCREEN_HEIGHT) break;
+    //         u8 ch1 = sprite[v + 0];
+    //         u8 ch2 = sprite[v + 8];
+    //         draw_2bpp_row(x, y + v, ch1, ch2, flip_x);
+    //     }
+    // } else {
+    //     for(size_t v = 0; v < 8; v++) {
+    //         if ((y + v) >= SCREEN_HEIGHT) break;
+    //         u8 ch1 = sprite[(7 - v) + 0];
+    //         u8 ch2 = sprite[(7 - v) + 8];
+    //         draw_2bpp_row(x, y + v, ch1, ch2, flip_x);
+    //     }
+    // }
+}
+
+IWRAM_CODE
+void
+draw_icn(size_t x, size_t y, u8 *sprite, u8 clr, u8 flip_x, u8 flip_y) {
+    // BOUNDCHECK_SCREEN(x, y);
+    // if (!flip_y) {
+    //     for(size_t v = 0; v < 8; v++) {
+    //         if ((y + v) >= SCREEN_HEIGHT) break;
+    //         u8 ch1 = sprite[v];
+    //         draw_1bpp_row(x, y + v, ch1, clr, flip_x);
+    //     }
+    // } else {
+    //     for(size_t v = 0; v < 8; v++) {
+    //         if ((y + v) >= SCREEN_HEIGHT) break;
+    //         u8 ch1 = sprite[(7 - v)];
+    //         draw_1bpp_row(x, y + v, ch1, clr, flip_x);
+    //     }
+    // }
+}
+
+#include "font.h"
+
+// Font rendering function for the text engine.
+void
+txt_drawc(char c, size_t x, size_t y, u8 clr) {
+    u8 *tile = font_icn;
+    draw_icn(x, y, tile + 8 * c, clr, 1, 0);
+}
+
+void
+renderer_init(void) {
+    // Initialize display mode and bg palette.
+    DISP_CTRL = DISP_MODE_0 | DISP_BG_0 | DISP_BG_1 | DISP_OBJ;
+
+    // Clear VRAM.
+    dma_fill(MEM_VRAM, 0, KB(96), 3);
+
+
+    // Initialize backgrounds.
+    BG_CTRL(0) = BG_CHARBLOCK(CB_0) | BG_SCREENBLOCK(SB_0) | BG_PRIORITY(1);
+    BG_CTRL(1) = BG_CHARBLOCK(CB_1) | BG_SCREENBLOCK(SB_1) | BG_PRIORITY(2);
+
+    DISP_CTRL = DISP_MODE_0 | DISP_OBJ;
+
+    // Initialize background memory map for frontbuffer.
+    // for (size_t i = 0; i < 32 * 20; ++i) {
+    //     TILE_MAP[i] = i;
+    // }
+    u16 *mem_map_fg = SCREENBLOCK_MEM[SB_0];
+    u16 *mem_map_bg = SCREENBLOCK_MEM[SB_1];
+    size_t k = 0;
+    for (size_t i = 0; i < 32 * 20; ++i, ++k) {
+        mem_map_fg[i] = k;
+        mem_map_bg[i] = k + 32 * 4;
+    }
+
+    // Initialize default palette.
+    PAL_BUFFER_BG[0] = COLOR_BLACK;
+    PAL_BUFFER_BG[1] = COLOR_WHITE;
+    PAL_BUFFER_BG[2] = COLOR_RED;
+    PAL_BUFFER_BG[3] = COLOR_BLUE;
+    PAL_BUFFER_BG[4] = COLOR_CYAN;
+    PAL_BUFFER_BG[5] = COLOR_PURPLE;
+    PAL_BUFFER_BG[6] = COLOR_YELLOW;
+    PAL_BUFFER_BG[7] = COLOR_GREEN;
+    PAL_BUFFER_BG[8] = COLOR_GREY;
+
+    // Initialize text engine.
+    txt_init(txt_drawc);
+}