58f3213c62
- Updated include paths for various GUI-related headers to improve organization and clarity. - Introduced new components for better modularity, including PaletteEditorWidget and EditorCardManager. - Refactored existing code to utilize the new components, ensuring consistency across the GUI subsystem. Benefits: - Enhances maintainability and readability of the GUI code. - Facilitates future enhancements and optimizations within the GUI subsystem.
297 lines
9.5 KiB
C++
297 lines
9.5 KiB
C++
#include "app/gui/widgets/dungeon_object_emulator_preview.h"
|
|
#include "app/gfx/backend/irenderer.h"
|
|
|
|
#include "zelda3/dungeon/room.h"
|
|
#include "zelda3/dungeon/room_object.h"
|
|
#include "app/gui/automation/widget_auto_register.h"
|
|
#include "app/core/window.h"
|
|
#include <cstdio>
|
|
|
|
namespace yaze {
|
|
namespace gui {
|
|
|
|
DungeonObjectEmulatorPreview::DungeonObjectEmulatorPreview() {
|
|
snes_instance_ = std::make_unique<emu::Snes>();
|
|
}
|
|
|
|
DungeonObjectEmulatorPreview::~DungeonObjectEmulatorPreview() {
|
|
// if (object_texture_) {
|
|
// renderer_->DestroyTexture(object_texture_);
|
|
// }
|
|
}
|
|
|
|
void DungeonObjectEmulatorPreview::Initialize(gfx::IRenderer* renderer, Rom* rom) {
|
|
renderer_ = renderer;
|
|
rom_ = rom;
|
|
snes_instance_ = std::make_unique<emu::Snes>();
|
|
std::vector<uint8_t> rom_data = rom->vector();
|
|
snes_instance_->Init(rom_data);
|
|
|
|
// object_texture_ = renderer_->CreateTexture(256, 256);
|
|
}
|
|
|
|
void DungeonObjectEmulatorPreview::Render() {
|
|
if (!show_window_) return;
|
|
|
|
if (ImGui::Begin("Dungeon Object Emulator Preview", &show_window_, ImGuiWindowFlags_AlwaysAutoResize)) {
|
|
AutoWidgetScope scope("DungeonEditor/EmulatorPreview");
|
|
|
|
// ROM status indicator
|
|
if (rom_ && rom_->is_loaded()) {
|
|
ImGui::TextColored(ImVec4(0.0f, 1.0f, 0.0f, 1.0f), "ROM: Loaded ✓");
|
|
} else {
|
|
ImGui::TextColored(ImVec4(1.0f, 0.0f, 0.0f, 1.0f), "ROM: Not loaded ✗");
|
|
}
|
|
|
|
ImGui::Separator();
|
|
RenderControls();
|
|
ImGui::Separator();
|
|
|
|
// Preview image with border
|
|
if (object_texture_) {
|
|
ImGui::BeginChild("PreviewRegion", ImVec2(260, 260), true, ImGuiWindowFlags_NoScrollbar);
|
|
ImGui::Image((ImTextureID)object_texture_, ImVec2(256, 256));
|
|
ImGui::EndChild();
|
|
} else {
|
|
ImGui::TextColored(ImVec4(1.0f, 1.0f, 0.0f, 1.0f), "No texture available");
|
|
}
|
|
|
|
// Debug info section
|
|
ImGui::Separator();
|
|
ImGui::Text("Execution:");
|
|
ImGui::Indent();
|
|
ImGui::Text("Cycles: %d %s", last_cycle_count_,
|
|
last_cycle_count_ >= 100000 ? "(TIMEOUT)" : "");
|
|
ImGui::Unindent();
|
|
|
|
// Status with color coding
|
|
ImGui::Text("Status:");
|
|
ImGui::Indent();
|
|
if (last_error_.empty()) {
|
|
ImGui::TextColored(ImVec4(0.0f, 1.0f, 0.0f, 1.0f), "✓ OK");
|
|
} else {
|
|
ImGui::TextColored(ImVec4(1.0f, 0.0f, 0.0f, 1.0f), "✗ %s", last_error_.c_str());
|
|
}
|
|
ImGui::Unindent();
|
|
|
|
// Help text
|
|
ImGui::Separator();
|
|
ImGui::TextWrapped("This tool uses the SNES emulator to render objects by "
|
|
"executing the game's native drawing routines from bank $01.");
|
|
}
|
|
ImGui::End();
|
|
}
|
|
|
|
void DungeonObjectEmulatorPreview::RenderControls() {
|
|
ImGui::Text("Object Configuration:");
|
|
ImGui::Indent();
|
|
|
|
// Object ID with hex display
|
|
AutoInputInt("Object ID", &object_id_, 1, 10, ImGuiInputTextFlags_CharsHexadecimal);
|
|
ImGui::SameLine();
|
|
ImGui::TextDisabled("($%03X)", object_id_);
|
|
|
|
// Room context
|
|
AutoInputInt("Room Context", &room_id_, 1, 10);
|
|
ImGui::SameLine();
|
|
ImGui::TextDisabled("(for graphics/palette)");
|
|
|
|
// Position controls
|
|
AutoSliderInt("X Position", &object_x_, 0, 63);
|
|
AutoSliderInt("Y Position", &object_y_, 0, 63);
|
|
|
|
ImGui::Unindent();
|
|
|
|
// Render button - large and prominent
|
|
ImGui::Separator();
|
|
if (ImGui::Button("Render Object", ImVec2(-1, 0))) {
|
|
TriggerEmulatedRender();
|
|
}
|
|
|
|
// Quick test buttons
|
|
if (ImGui::BeginPopup("QuickTests")) {
|
|
if (ImGui::MenuItem("Floor tile (0x00)")) { object_id_ = 0x00; TriggerEmulatedRender(); }
|
|
if (ImGui::MenuItem("Wall N (0x60)")) { object_id_ = 0x60; TriggerEmulatedRender(); }
|
|
if (ImGui::MenuItem("Door (0xF0)")) { object_id_ = 0xF0; TriggerEmulatedRender(); }
|
|
ImGui::EndPopup();
|
|
}
|
|
if (ImGui::Button("Quick Tests...", ImVec2(-1, 0))) {
|
|
ImGui::OpenPopup("QuickTests");
|
|
}
|
|
}
|
|
|
|
void DungeonObjectEmulatorPreview::TriggerEmulatedRender() {
|
|
if (!rom_ || !rom_->is_loaded()) {
|
|
last_error_ = "ROM not loaded";
|
|
return;
|
|
}
|
|
|
|
last_error_.clear();
|
|
last_cycle_count_ = 0;
|
|
|
|
// 1. Reset and configure the SNES state
|
|
snes_instance_->Reset(true);
|
|
auto& cpu = snes_instance_->cpu();
|
|
auto& ppu = snes_instance_->ppu();
|
|
auto& memory = snes_instance_->memory();
|
|
|
|
// 2. Load room context (graphics, palettes)
|
|
zelda3::Room default_room = zelda3::LoadRoomFromRom(rom_, room_id_);
|
|
|
|
// 3. Load palette into CGRAM
|
|
auto dungeon_main_pal_group = rom_->palette_group().dungeon_main;
|
|
|
|
// Validate and clamp palette ID
|
|
int palette_id = default_room.palette;
|
|
if (palette_id < 0 || palette_id >= static_cast<int>(dungeon_main_pal_group.size())) {
|
|
printf("[EMU] Warning: Room palette %d out of bounds, using palette 0\n", palette_id);
|
|
palette_id = 0;
|
|
}
|
|
|
|
auto palette = dungeon_main_pal_group[palette_id];
|
|
for (size_t i = 0; i < palette.size() && i < 256; ++i) {
|
|
ppu.cgram[i] = palette[i].snes();
|
|
}
|
|
|
|
// 4. Load graphics into VRAM
|
|
default_room.LoadRoomGraphics(default_room.blockset);
|
|
default_room.CopyRoomGraphicsToBuffer();
|
|
const auto& gfx_buffer = default_room.get_gfx_buffer();
|
|
for (size_t i = 0; i < gfx_buffer.size() / 2 && i < 0x8000; ++i) {
|
|
ppu.vram[i] = gfx_buffer[i * 2] | (gfx_buffer[i * 2 + 1] << 8);
|
|
}
|
|
|
|
// 5. CRITICAL: Initialize tilemap buffers in WRAM
|
|
// Game uses $7E:2000 for BG1 tilemap buffer, $7E:4000 for BG2
|
|
for (uint32_t i = 0; i < 0x2000; i++) {
|
|
snes_instance_->Write(0x7E2000 + i, 0x00); // BG1 tilemap buffer
|
|
snes_instance_->Write(0x7E4000 + i, 0x00); // BG2 tilemap buffer
|
|
}
|
|
|
|
// 6. Setup PPU registers for dungeon rendering
|
|
snes_instance_->Write(0x002105, 0x09); // BG Mode 1 (4bpp for BG1/2)
|
|
snes_instance_->Write(0x002107, 0x40); // BG1 tilemap at VRAM $4000 (32x32)
|
|
snes_instance_->Write(0x002108, 0x48); // BG2 tilemap at VRAM $4800 (32x32)
|
|
snes_instance_->Write(0x002109, 0x00); // BG1 chr data at VRAM $0000
|
|
snes_instance_->Write(0x00210A, 0x00); // BG2 chr data at VRAM $0000
|
|
snes_instance_->Write(0x00212C, 0x03); // Enable BG1+BG2 on main screen
|
|
snes_instance_->Write(0x002100, 0x0F); // Screen display on, full brightness
|
|
|
|
// 7. Setup WRAM variables for drawing context
|
|
snes_instance_->Write(0x7E00AF, room_id_ & 0xFF);
|
|
snes_instance_->Write(0x7E049C, 0x00);
|
|
snes_instance_->Write(0x7E049E, 0x00);
|
|
|
|
// 8. Create object and encode to bytes
|
|
zelda3::RoomObject obj(object_id_, object_x_, object_y_, 0, 0);
|
|
auto bytes = obj.EncodeObjectToBytes();
|
|
|
|
const uint32_t object_data_addr = 0x7E1000;
|
|
snes_instance_->Write(object_data_addr, bytes.b1);
|
|
snes_instance_->Write(object_data_addr + 1, bytes.b2);
|
|
snes_instance_->Write(object_data_addr + 2, bytes.b3);
|
|
snes_instance_->Write(object_data_addr + 3, 0xFF); // Terminator
|
|
snes_instance_->Write(object_data_addr + 4, 0xFF);
|
|
|
|
// 9. Setup object pointer in WRAM
|
|
snes_instance_->Write(0x7E00B7, object_data_addr & 0xFF);
|
|
snes_instance_->Write(0x7E00B8, (object_data_addr >> 8) & 0xFF);
|
|
snes_instance_->Write(0x7E00B9, (object_data_addr >> 16) & 0xFF);
|
|
|
|
// 10. Setup CPU state
|
|
cpu.PB = 0x01;
|
|
cpu.DB = 0x7E;
|
|
cpu.D = 0x0000;
|
|
cpu.SetSP(0x01FF);
|
|
cpu.status = 0x30; // 8-bit mode
|
|
|
|
// Calculate X register (tilemap position)
|
|
cpu.X = (object_y_ * 0x80) + (object_x_ * 2);
|
|
cpu.Y = 0; // Object data offset
|
|
|
|
// 11. Lookup the object's drawing handler
|
|
uint16_t handler_offset = 0;
|
|
auto rom_data = rom_->data();
|
|
uint32_t table_addr = 0;
|
|
|
|
if (object_id_ < 0x100) {
|
|
table_addr = 0x018200 + (object_id_ * 2);
|
|
} else if (object_id_ < 0x200) {
|
|
table_addr = 0x018470 + ((object_id_ - 0x100) * 2);
|
|
} else {
|
|
table_addr = 0x0185F0 + ((object_id_ - 0x200) * 2);
|
|
}
|
|
|
|
if (table_addr < rom_->size() - 1) {
|
|
uint8_t lo = rom_data[table_addr];
|
|
uint8_t hi = rom_data[table_addr + 1];
|
|
handler_offset = lo | (hi << 8);
|
|
} else {
|
|
last_error_ = "Object ID out of bounds for handler lookup";
|
|
return;
|
|
}
|
|
|
|
if (handler_offset == 0x0000) {
|
|
char buf[256];
|
|
snprintf(buf, sizeof(buf), "Object $%04X has no drawing routine", object_id_);
|
|
last_error_ = buf;
|
|
return;
|
|
}
|
|
|
|
// 12. Setup return address and jump to handler
|
|
const uint16_t return_addr = 0x8000;
|
|
snes_instance_->Write(0x018000, 0x6B); // RTL instruction (0x6B not 0x60!)
|
|
|
|
// Push return address for RTL (3 bytes: bank, high, low)
|
|
uint16_t sp = cpu.SP();
|
|
snes_instance_->Write(0x010000 | sp--, 0x01); // Bank byte
|
|
snes_instance_->Write(0x010000 | sp--, (return_addr - 1) >> 8); // High
|
|
snes_instance_->Write(0x010000 | sp--, (return_addr - 1) & 0xFF); // Low
|
|
cpu.SetSP(sp);
|
|
|
|
// Jump to handler (offset is relative to RoomDrawObjectData base)
|
|
cpu.PC = handler_offset;
|
|
|
|
printf("[EMU] Rendering object $%04X at (%d,%d), handler=$%04X\n",
|
|
object_id_, object_x_, object_y_, handler_offset);
|
|
|
|
// 13. Run emulator with timeout
|
|
int max_cycles = 100000;
|
|
int cycles = 0;
|
|
while (cycles < max_cycles) {
|
|
if (cpu.PB == 0x01 && cpu.PC == return_addr) {
|
|
break; // Hit return address
|
|
}
|
|
snes_instance_->RunCycle();
|
|
cycles++;
|
|
}
|
|
|
|
last_cycle_count_ = cycles;
|
|
|
|
printf("[EMU] Completed after %d cycles, PC=$%02X:%04X\n",
|
|
cycles, cpu.PB, cpu.PC);
|
|
|
|
if (cycles >= max_cycles) {
|
|
last_error_ = "Timeout: exceeded max cycles";
|
|
return;
|
|
}
|
|
|
|
// 14. Force PPU to render the tilemaps
|
|
ppu.HandleFrameStart();
|
|
for (int line = 0; line < 224; line++) {
|
|
ppu.RunLine(line);
|
|
}
|
|
ppu.HandleVblank();
|
|
|
|
// 15. Get the rendered pixels from PPU
|
|
void* pixels = nullptr;
|
|
int pitch = 0;
|
|
if (renderer_->LockTexture(object_texture_, nullptr, &pixels, &pitch)) {
|
|
snes_instance_->SetPixels(static_cast<uint8_t*>(pixels));
|
|
renderer_->UnlockTexture(object_texture_);
|
|
}
|
|
}
|
|
|
|
} // namespace gui
|
|
} // namespace yaze
|