Remove outdated comments

1 files changed, 9 insertions, 115 deletions

diff --git a/src/renderer_m0.c b/src/renderer_m0.c
index 97899aa..5c57278 100644
--- a/src/renderer_m0.c
+++ b/src/renderer_m0.c
@@ -4,16 +4,6 @@
 // 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"
@@ -21,42 +11,24 @@
 // 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
-// NOTE: CB_2 could be at the end of 2 (0x0600:8000) since we only need a clear
-// color tile. Testing at 3 for now.
-// #define CB_2 3
 #define SB_0 20
 #define SB_1 22
-// #define SB_2 23
 
 // 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_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
@@ -146,7 +118,7 @@ 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 {
-        // ...
+        // TODO
         // // Diagonal line.
         // int     dx = x0 > x1 ?       x0 - x1 : x1 - x0;
         // int     dy = y0 > y1 ?       y0 - y1 : y1 - y0;
@@ -309,7 +281,6 @@ draw_filled_rect(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
 
     // 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);
     }
 
@@ -365,84 +336,6 @@ draw_filled_rect(size_t x0, size_t y0, size_t x1, size_t y1, u8 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) {
@@ -632,10 +525,11 @@ renderer_init(void) {
     BG_CTRL(0) = BG_CHARBLOCK(CB_0) | BG_SCREENBLOCK(SB_0) | BG_PRIORITY(0) | BG_SIZE(1);
     BG_CTRL(1) = BG_CHARBLOCK(CB_1) | BG_SCREENBLOCK(SB_1) | BG_PRIORITY(1) | BG_SIZE(1);
 
-    // Initialize background memory map for frontbuffer.
-    // for (size_t i = 0; i < 32 * 20; ++i) {
-    //     TILE_MAP[i] = i;
-    // }
+    // Initialize background memory map for the render buffers. The backgrounds
+    // are 64x32 each, with the second screenblock pointing to a zeroed tile.
+    // This makes it so while scrolling the backgrounds to the second screen we
+    // effectively disabling them. Thanks to this we can perform double
+    // buffering with mode 0 rendering.
     u16 *mem_map_fg = SCREENBLOCK_MEM[SB_0];
     u16 *mem_map_fg_blank = SCREENBLOCK_MEM[SB_0 + 1];
     u16 *mem_map_bg = SCREENBLOCK_MEM[SB_1];