object_renderer.cc

Go to the documentation of this file.

#include "app/zelda3/dungeon/object_renderer.h"
 
#include "app/gfx/arena.h"
 
namespace yaze {
namespace zelda3 {
 
void DungeonObjectRenderer::LoadObject(uint32_t routine_ptr,
                                       std::array<uint8_t, 16>& sheet_ids) {
  vram_.sheets = sheet_ids;
 
  rom_data_ = rom()->vector();
  snes_.memory().Initialize(rom_data_);
 
  // Configure the object based on the fetched information
  ConfigureObject();
 
  // Run the CPU emulation for the object's draw routines
  RenderObject(routine_ptr);
}
 
void DungeonObjectRenderer::ConfigureObject() {
  snes_.cpu().A = 0x03D8;
  snes_.cpu().X = 0x03D8;
  snes_.cpu().DB = 0x7E;
  // VRAM target destinations
  snes_.cpu().WriteLong(0xBF, 0x7E2000);
  snes_.cpu().WriteLong(0xCB, 0x7E2080);
  snes_.cpu().WriteLong(0xC2, 0x7E2002);
  snes_.cpu().WriteLong(0xCE, 0x7E2082);
  snes_.cpu().SetAccumulatorSize(false);
  snes_.cpu().SetIndexSize(false);
}

void DungeonObjectRenderer::RenderObject(uint32_t routine_ptr) {
  snes_.cpu().PB = 0x01;
  snes_.cpu().PC = routine_ptr;
 
  // Set up initial state for object drawing
  snes_.cpu().Y = 0;     // Start at the beginning of the tilemap
  snes_.cpu().D = 0x7E;  // Direct page register for memory access
 
  // Push return address to stack
  snes_.cpu().PushLong(0x01 << 16 | 0xFFFF);  // Push a dummy return address
 
  // Set up a maximum instruction count to prevent infinite loops
  const int MAX_INSTRUCTIONS = 10000;
  int instruction_count = 0;
 
  // Execute instructions until we hit a return instruction or max count
  while (instruction_count < MAX_INSTRUCTIONS) {
    uint8_t opcode =
        snes_.cpu().ReadByte(snes_.cpu().PB << 16 | snes_.cpu().PC);
 
    // Check for RTS (Return from Subroutine) instruction
    if (opcode == 0x60) {
      // Execute the RTS instruction
      snes_.cpu().ExecuteInstruction(opcode);
      break;  // Exit the loop after RTS
    }
 
    // Execute the instruction
    snes_.cpu().ExecuteInstruction(opcode);
    instruction_count++;
  }
 
  // If we hit the max instruction count, log a warning
  if (instruction_count >= MAX_INSTRUCTIONS) {
    std::cerr << "Warning: Object rendering hit maximum instruction count"
              << std::endl;
  }
 
  UpdateObjectBitmap();
}
 
// In the underworld, this holds a copy of the entire BG tilemap for
// Layer 1 (BG2) in TILEMAPA
// Layer 2 (BG1) in TILEMAPB
void DungeonObjectRenderer::UpdateObjectBitmap() {
  // Initialize the tilemap with zeros
  tilemap_.resize(0x2000, 0);
 
  // Iterate over tilemap in memory to read tile IDs
  for (int tile_index = 0; tile_index < 512; tile_index++) {
    // Read the tile ID from memory
    uint16_t tile_id = snes_.memory().ReadWord(0x7E2000 + tile_index * 2);
 
    // Skip empty tiles (0x0000)
    if (tile_id == 0) continue;
 
    // Calculate sheet number (each sheet contains 32 tiles)
    int sheet_number = tile_id / 32;
 
    // Ensure sheet number is valid
    if (sheet_number >= vram_.sheets.size()) {
      std::cerr << "Warning: Invalid sheet number " << sheet_number
                << std::endl;
      continue;
    }
 
    // Calculate position in the tilemap
    int tile_x = (tile_index % 32) * 8;
    int tile_y = (tile_index / 32) * 8;
 
    // Get the graphics sheet
    auto& sheet =
        gfx::Arena::Get().mutable_gfx_sheets()->at(vram_.sheets[sheet_number]);
 
    // Calculate the offset in the tilemap
    int tilemap_offset = tile_y * 256 + tile_x;
 
    // Copy the tile from the graphics sheet to the tilemap
    sheet.Get8x8Tile(tile_id % 32, 0, 0, tilemap_, tilemap_offset);
  }
}
 
}  // namespace zelda3
}  // namespace yaze