Investigating Why All Tiles Are Empty During Rendering

Summary

Detailed checks were implemented to investigate why all tiles read from VRAM are empty (0x00) during rendering. Added diagnostic logs at multiple points in the render pipeline: VRAM check during rendering (not just at LY=0), logs of which tiles are read from the tilemap and their content, detailed verification of empty tiles, and tile loading vs rendering timing logs. The logs confirm that VRAM is completely empty when rendering (0/6144 non-zero bytes), all tiles are empty (0/20 tiles with data), and the tilemap points to empty tiles (all tile IDs are 0x00). The root cause identified is that VRAM is empty when rendering, indicating that the tiles have not been loaded yet or the game is not loading them yet.

Hardware Concept

Tiles Loading Timing on Game Boy

On the real Game Boy, tiles are loaded into VRAM during V-Blank (when the LCD is off or during lines 144-153). However, some games load tiles during H-Blank or even during active rendering.

Timing problem in emulators:

• If the emulator renders before the tiles load, you will see empty tiles
• Yeahvram_is_empty_updated only once per frame (at LY=0), may be out of date during rendering
• The temporary checkerboard is activated when all tiles are empty, but if the tiles are loaded later, the checkerboard will remain active

Verification of Empty Tiles

The verification of empty tiles must be precise:

• A tile is empty ifallits 8 lines (16 bytes) are 0x00
• Some legitimate tiles may have lines with 0x00, but not all
• If the verification is incorrect, you can mark tiles with data as empty

Temporary Checkerboard

The temporary checkerboard is a visual aid that is activated when:

1. The tile is completely empty (tile_is_empty == true)
2. VRAM is completely empty (vram_is_empty_ == true)
3. The checkerboard is enabled (enable_checkerboard_temporary == true)

If any of these conditions are not met, normal rendering should work.

Implementation

4 types of verifications were implemented to investigate the empty tiles problem:

1. VRAM Check During Rendering

Added VRAM checking not only at LY=0, but also during rendering (LY=0, LY=72, LY=143) to detect if VRAM is loaded after it is updatedvram_is_empty_.

// Check VRAM at this time
int vram_non_zero = 0;
for (uint16_t i = 0; i< 6144; i++) {
    if (mmu_->read(0x8000 + i) != 0x00) {
        vram_non_zero++;
    }
}

printf("[PPU-VRAM-DURING-RENDER] Frame %llu | LY: %d | Mode: %d | "
       "VRAM non-zero: %d/6144 (%.2f%%) | vram_is_empty_: %s\n",
       frame_counter_ + 1, ly_, mode_,
       vram_non_zero, (vram_non_zero * 100.0) / 6144,
       vram_is_empty_ ? "YES" : "NO");

2. Verification of Which Tiles are Read from the Tilemap

Added detailed logs of which tiles are read from the tilemap and their content, checking if the tiles have data or are empty.

// Read tile ID from tilemap
uint8_t tile_id = mmu_->read(tilemap_addr);

// Calculate tile address
uint16_t tile_addr;
if (unsigned_addressing) {
    tile_addr = data_base + (tile_id * 16);
} else {
    int8_t signed_tile_id = static_cast(tile_id);
    tile_addr = data_base + ((signed_tile_id + 128) * 16);
}

// Check tile content
uint8_t tile_byte1 = mmu_->read(tile_addr);
uint8_t tile_byte2 = mmu_->read(tile_addr + 1);
bool tile_has_data = (tile_byte1 != 0x00 || tile_byte2 != 0x00);

printf("[PPU-TILEMAP-READ] Frame %llu | LY: %d | X: %d | "
       "Tilemap[0x%04X]=0x%02X | TileAddr=0x%04X | "
       "Byte1=0x%02X Byte2=0x%02X | HasData=%s\n",
       frame_counter_ + 1, ly_, x,
       tilemap_addr, tile_id, tile_addr,
       tile_byte1, tile_byte2, tile_has_data ? "YES" : "NO");

3. Detailed Verification of Empty Tiles

Added detailed logs of the verification of empty tiles, showing how many lines have data and how many are empty, and why the checkerboard is activated or not.

// Check each line of the tile
int lines_with_data = 0;
int lines_empty = 0;
for (uint8_t line_check = 0; line_check< 8; line_check++) {
    uint16_t check_addr = tile_addr + (line_check * 2);
    uint8_t check_byte1 = mmu_->read(check_addr);
    uint8_t check_byte2 = mmu_->read(check_addr + 1);
    
    if (check_byte1 != 0x00 || check_byte2 != 0x00) {
        lines_with_data++;
    } else {
        lines_empty++;
    }
}

bool tile_is_empty_result = (lines_with_data == 0);

printf("[PPU-TILE-EMPTY-CHECK] Frame %llu | LY: %d | X: %d | "
       "TileAddr=0x%04X | LinesWithData=%d LinesEmpty=%d | "
       "tile_is_empty=%s | vram_is_empty_=%s | enable_checkerboard=%s\n",
       frame_counter_ + 1, ly_, x,
       tile_addr, lines_with_data, lines_empty,
       tile_is_empty_result ? "YES" : "NO",
       vram_is_empty_ ? "YES" : "NO",
       enable_checkerboard_temporary ? "YES" : "NO");

4. Verification of Available Tiles and Timing

Added verification of available tiles at the start ofrender_scanline()and write timing logs to VRAM inMMU.cpp.

// Check first 20 tiles of the tilemap
for (int i = 0; i< 20; i++) {
    uint8_t tile_id = mmu_->read(map_base + i);
    uint16_t tile_addr;
    // ... calculate tile address ...
    
    // Check if the tile has data
    bool has_data = false;
    for (int j = 0; j< 16; j++) {
        if (mmu_->read(tile_addr + j) != 0x00) {
            has_data = true;
            break;
        }
    }
    
    if (has_data) tiles_with_data++;
    else tiles_empty++;
}

printf("[PPU-TILES-AVAILABLE] Frame %llu | LY: %d | "
       "Tiles with data: %d/20 | Tiles empty: %d/20\n",
       frame_counter_ + 1, ly_,
       tiles_with_data, tiles_empty);

Timing Logs in MMU.cpp

Added timing logs when writing non-zero tiles to VRAM, showing the frame, LY and mode when writing occurs.

// In MMU.cpp, when writing to VRAM
if (addr >= 0x8000 && addr<= 0x97FF && value != 0x00) {
    uint64_t frame_counter_from_ppu = 0;
    uint8_t ly_from_ppu = 0;
    uint8_t mode_from_ppu = 0;
    
    if (ppu_ != nullptr) {
        frame_counter_from_ppu = ppu_->get_frame_counter();
        ly_from_ppu = ppu_->get_ly();
        mode_from_ppu = ppu_->get_mode();
    }
    
    printf("[MMU-VRAM-WRITE-TIMING] PC:0x%04X | Addr:0x%04X | Value:0x%02X | "
           "Frame: %llu | LY: %d | Mode: %d\n",
           debug_current_pc, addr, value,
           frame_counter_from_ppu, ly_from_ppu, mode_from_ppu);
}

Affected Files

• src/core/cpp/PPU.cpp- Added VRAM checks during rendering, logs of tiles read from the tilemap, detailed check of empty tiles, and check of available tiles
• src/core/cpp/MMU.cpp- Added write timing logs to VRAM

Tests and Verification

Tests were executed with test ROMs (Tetris, Mario, Oro) to generate diagnostic logs. The logs confirm the identified problem:

• VRAM is completely empty: Non-zero VRAM: 0/6144 (0.00%)both at LY=0 and at LY=72
• All tiles are empty: Tiles with data: 0/20 | Tiles empty: 20/20
• The tilemap points to empty tiles:All tile IDs are0x00, which point to tile 0 (which is empty)
• The checkerboard is activated correctly: Checkerboard will be activated for this tile

Example of Generated Logs

[PPU-VRAM-DURING-RENDER] Frame 1 | LY: 0 | Mode: 2 | Non-zero VRAM: 0/6144 (0.00%) | vram_is_empty_: YES
[PPU-TILES-AVAILABLE] Frame 1 | LY: 0 | Tiles with data: 0/20 | Tiles empty: 20/20
[PPU-TILES-AVAILABLE] ⚠️ PROBLEM: All tiles are empty, checkerboard will be activated
[PPU-TILEMAP-READ] Frame 1 | LY: 0 | X: 0 | Tilemap[0x9800]=0x00 | TileAddr=0x8000 | Byte1=0x00 Byte2=0x00 | HasData=NO
[PPU-TILEMAP-READ] ⚠️ Empty tile detected - will activate checkerboard if vram_is_empty_=true
[PPU-TILE-EMPTY-CHECK] Frame 1 | LY: 0 | X: 0 | TileAddr=0x8000 | LinesWithData=0 LinesEmpty=8 | tile_is_empty=YES | vram_is_empty_=YES | enable_checkerboard=YES
[PPU-TILE-EMPTY-CHECK] ✅ Checkerboard will be activated for this tile

Compiled C++ module validation:The code was compiled successfully and the logs are generated correctly during execution.

Key Findings

Initial Findings (Short Run)

On the initial run (30-60 seconds), the logs confirmed:

• VRAM is completely empty:0/6144 non-zero bytes during rendering (Frame 1-5)
• All tiles initially empty:0/20 tiles with data in the first frames
• The tilemap points to empty tiles:All tile IDs are 0x00 in the first frames
• The checkerboard is activated correctly:Triggered when it detects empty tiles

Extended Run Findings (2.5 minutes)

After running all ROMs for 2.5 minutes, important findings were discovered:

1. The tiles DO load after a few frames:
   • After Frame 5-6, the logs show:Tiles with data: 20/20 | Tiles empty: 0/20
   • This confirms that the tiles are loaded eventually, but not in the first frame
2. There are writes to VRAM during V-Blank:
   • The logs of[MMU-VRAM-WRITE-TIMING]show writes during V-Blank (Mode: 1, LY: 145-149)
   • Example:Frame: 4720 | LY: 145 | Mode: 1 | Addr:0x8800 | Value:0xFF
   • This is correct depending on the hardware: tiles are loaded during V-Blank
3. vram_is_empty_ changes eventually:
   • In some games (Oro.gbc, PKMN Amarillo, PKMN),vram_is_empty_changes from YES to NO after several thousand frames
   • Example:Frame 4723 | vram_is_empty_ changed: YES -> NO(Gold.gbc)
   • Example:Frame 4719 | vram_is_empty_ changed: YES -> NO(PKMN Yellow)
   • Example:Frame 4946 | vram_is_empty_ changed: YES -> NO(PKMN)
4. VRAM verification discrepancy:
   • The logs show that the tiles have data (Tiles with data: 20/20) but VRAM check showsNon-zero VRAM: 0/6144
   • This suggests that there may be a problem with the VRAM check or that the tiles are in a different part of VRAM
   • Or that the VRAM check runs at a different time than the tile check

Identified Root Cause

The tiles load after the first frame, but there is a timing or verification problem.

• Tiles load during V-Blank (correct depending on hardware)
• The tiles have data after Frame 5-6 (confirmed by logs)
• But VRAM check shows 0/6144 even when tiles have data (mismatch)
• The problem may be thatvram_is_empty_is updated only at LY=0, and if the tiles are loaded after, it will still betruethroughout the frame

Sources consulted

• Pan Docs: "Tile Data", "Tile Map", "VRAM (Video RAM)"
• Pan Docs: "LCD Timing", "Background", "Window"

Educational Integrity

Next Steps

Extended Run Completed

✅ All ROMs were run for 2.5 minutes. The findings confirm that:

• ✅ The tiles DO load after a few frames (Frame 5-6)
• ✅ There are writes to VRAM during V-Blank (correct depending on hardware)
• ✅ vram_is_empty_it changes eventually in some games

Suggested Next Steps

• [ ] Investigate discrepancy between VRAM check (0/6144) and tile check (20/20 with data)
• [ ] Check if the problem is thatvram_is_empty_is updated only at LY=0, and if the tiles are loaded after, it will still betruethroughout the frame
• [ ] Consider upgradingvram_is_empty_more frequently or at different times (not just at LY=0)
• [ ] Check if the VRAM check is checking the correct range (0x8000-0x97FF) or if there is a problem with how VRAM is read
• [ ] If the tiles have data but VRAM shows 0/6144, investigate if the tiles are in a different part of VRAM or if there is a problem with the verification