scawful/yaze
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor DungeonCanvasViewer for enhanced rendering and object management

Browse Source 
- Introduced new rendering methods for various object types including stairs, chests, doors, walls, pots, and sprites, improving visual representation in the dungeon canvas.
- Updated the DrawDungeonCanvas method to streamline object rendering and enhance graphics handling.
- Added detailed layer information overlay to provide context on room objects and sprites.
- Implemented object dimension calculations for walls to ensure accurate rendering based on size properties.
- Improved fallback rendering for objects without valid graphics, enhancing user experience during object placement and editing.
This commit is contained in:
scawful
2025-09-25 20:58:40 -04:00
parent e63bcf3202
commit 7ca841d6a5
9 changed files with 925 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files

463
src/app/editor/dungeon/dungeon_canvas_viewer.cc
View File

@@ -5,28 +5,17 @@
#include "app/gfx/arena.h"
#include "app/gfx/snes_palette.h"
#include "app/gui/canvas.h"
#include "app/gui/color.h"
#include "app/gui/icons.h"
#include "app/gui/input.h"
#include "app/rom.h"
#include "app/zelda3/dungeon/object_renderer.h"
#include "app/zelda3/dungeon/room.h"
#include "app/zelda3/sprite/sprite.h"
#include "imgui/imgui.h"
#include "util/hex.h"
namespace yaze::editor {
using core::Renderer;
using ImGui::BeginChild;
using ImGui::BeginTabBar;
using ImGui::BeginTabItem;
using ImGui::Button;
using ImGui::EndChild;
using ImGui::EndTabBar;
using ImGui::EndTabItem;
using ImGui::Separator;
using ImGui::Text;
void DungeonCanvasViewer::DrawDungeonTabView() {
static int next_tab_id = 0;
@@ -125,17 +114,41 @@ void DungeonCanvasViewer::DrawDungeonCanvas(int room_id) {
// Render background layers with proper positioning
RenderRoomBackgroundLayers(room_id);
// Render room objects on top of background using the room's palette
// Render room objects with proper graphics
if (current_palette_id_ < current_palette_group_.size()) {
auto room_palette = current_palette_group_[current_palette_id_];
// Render regular objects with proper graphics
for (const auto& object : room.GetTileObjects()) {
RenderObjectInCanvas(object, room_palette);
}
// Render special objects with primitive shapes
RenderStairObjects(room, room_palette);
RenderChests(room);
RenderDoorObjects(room);
RenderWallObjects(room);
RenderPotObjects(room);
// Render sprites as simple 16x16 squares with labels
RenderSprites(room);
}
}
canvas_.DrawGrid();
canvas_.DrawOverlay();
// Draw layer information overlay
if (rooms_ && rom_->is_loaded()) {
auto& room = (*rooms_)[room_id];
std::string layer_info = absl::StrFormat(
"Room %03X - Objects: %zu, Sprites: %zu\n"
"Layers are game concept: Objects exist on different levels\n"
"connected by stair objects for player navigation",
room_id, room.GetTileObjects().size(), room.GetSprites().size());
canvas_.DrawText(layer_info, 10, canvas_.height() - 60);
}
}
void DungeonCanvasViewer::RenderObjectInCanvas(const zelda3::RoomObject &object,
@@ -145,40 +158,63 @@ void DungeonCanvasViewer::RenderObjectInCanvas(const zelda3::RoomObject &object,
return;
}
// Convert room coordinates to canvas coordinates
auto [canvas_x, canvas_y] = RoomToCanvasCoordinates(object.x_, object.y_);
// Check if object is within canvas bounds
if (!IsWithinCanvasBounds(canvas_x, canvas_y, 32)) {
return; // Skip objects outside visible area
}
// Create a mutable copy of the object to ensure tiles are loaded
auto mutable_object = object;
mutable_object.set_rom(rom_);
mutable_object.EnsureTilesLoaded();
// Check if tiles were loaded successfully
if (mutable_object.tiles().empty()) {
return; // Skip objects without tiles
}
// Convert room coordinates to canvas coordinates using helper function
auto [canvas_x, canvas_y] = RoomToCanvasCoordinates(object.x_, object.y_);
// Check if object is within canvas bounds (accounting for scrolling)
if (!IsWithinCanvasBounds(canvas_x, canvas_y, 32)) {
return; // Skip objects outside visible area
}
// Render the object to a bitmap
// Try to render the object with proper graphics
auto render_result = object_renderer_.RenderObject(mutable_object, palette);
if (!render_result.ok()) {
return; // Skip if rendering failed
if (render_result.ok()) {
auto object_bitmap = std::move(render_result.value());
// Ensure the bitmap is valid and has content
if (object_bitmap.width() > 0 && object_bitmap.height() > 0) {
object_bitmap.SetPalette(palette);
core::Renderer::Get().RenderBitmap(&object_bitmap);
canvas_.DrawBitmap(object_bitmap, canvas_x, canvas_y, 1.0f, 255);
return;
}
}
auto object_bitmap = std::move(render_result.value());
// Set the palette for the bitmap
object_bitmap.SetPalette(palette);
// Render the bitmap to a texture so it can be drawn
core::Renderer::Get().RenderBitmap(&object_bitmap);
// Draw the object bitmap to the canvas
canvas_.DrawBitmap(object_bitmap, canvas_x, canvas_y, 1.0f, 255);
// Fallback: Draw object as colored rectangle with ID if rendering fails
ImVec4 object_color;
// Color-code objects based on layer
switch (object.layer_) {
case zelda3::RoomObject::LayerType::BG1:
object_color = ImVec4(0.8f, 0.4f, 0.4f, 0.8f); // Red-ish for BG1
break;
case zelda3::RoomObject::LayerType::BG2:
object_color = ImVec4(0.4f, 0.8f, 0.4f, 0.8f); // Green-ish for BG2
break;
case zelda3::RoomObject::LayerType::BG3:
object_color = ImVec4(0.4f, 0.4f, 0.8f, 0.8f); // Blue-ish for BG3
break;
default:
object_color = ImVec4(0.6f, 0.6f, 0.6f, 0.8f); // Gray for unknown
break;
}
// Calculate object size (16x16 is base, size affects width/height)
int object_width = 16 + (object.size_ & 0x0F) * 8;
int object_height = 16 + ((object.size_ >> 4) & 0x0F) * 8;
canvas_.DrawRect(canvas_x, canvas_y, object_width, object_height, object_color);
canvas_.DrawRect(canvas_x, canvas_y, object_width, object_height,
ImVec4(0.0f, 0.0f, 0.0f, 1.0f)); // Black border
// Draw object ID
std::string object_text = absl::StrFormat("0x%X", object.id_);
canvas_.DrawText(object_text, canvas_x + object_width + 2, canvas_y);
}
void DungeonCanvasViewer::DisplayObjectInfo(const zelda3::RoomObject &object,
@@ -191,65 +227,280 @@ void DungeonCanvasViewer::DisplayObjectInfo(const zelda3::RoomObject &object,
canvas_.DrawText(info_text, canvas_x, canvas_y - 12);
}
void DungeonCanvasViewer::RenderLayoutObjects(const zelda3::RoomLayout &layout,
const gfx::SnesPalette &palette) {
// Render layout objects (walls, floors, etc.) as simple colored rectangles
for (const auto &layout_obj : layout.GetObjects()) {
// Convert room coordinates to canvas coordinates using helper function
auto [canvas_x, canvas_y] =
RoomToCanvasCoordinates(layout_obj.x(), layout_obj.y());
// Check if layout object is within canvas bounds
if (!IsWithinCanvasBounds(canvas_x, canvas_y, 16)) {
continue; // Skip objects outside visible area
void DungeonCanvasViewer::RenderStairObjects(const zelda3::Room& room,
const gfx::SnesPalette& palette) {
// Render stair objects with special highlighting to show they enable layer transitions
// Stair object IDs from room.h: {0x139, 0x138, 0x13B, 0x12E, 0x12D}
constexpr uint16_t stair_ids[] = {0x139, 0x138, 0x13B, 0x12E, 0x12D};
for (const auto& object : room.GetTileObjects()) {
bool is_stair = false;
for (uint16_t stair_id : stair_ids) {
if (object.id_ == stair_id) {
is_stair = true;
break;
}
}
// Choose color based on object type
gfx::SnesColor color;
switch (layout_obj.type()) {
case zelda3::RoomLayoutObject::Type::kWall:
color = gfx::SnesColor(0x7FFF); // Gray
break;
case zelda3::RoomLayoutObject::Type::kFloor:
color = gfx::SnesColor(0x4210); // Dark brown
break;
case zelda3::RoomLayoutObject::Type::kCeiling:
color = gfx::SnesColor(0x739C); // Light gray
break;
case zelda3::RoomLayoutObject::Type::kPit:
color = gfx::SnesColor(0x0000); // Black
break;
case zelda3::RoomLayoutObject::Type::kWater:
color = gfx::SnesColor(0x001F); // Blue
break;
case zelda3::RoomLayoutObject::Type::kStairs:
color = gfx::SnesColor(0x7E0F); // Yellow
break;
case zelda3::RoomLayoutObject::Type::kDoor:
color = gfx::SnesColor(0xF800); // Red
break;
default:
color = gfx::SnesColor(0x7C1F); // Magenta for unknown
break;
if (is_stair) {
auto [canvas_x, canvas_y] = RoomToCanvasCoordinates(object.x_, object.y_);
if (IsWithinCanvasBounds(canvas_x, canvas_y, 32)) {
// Draw stair object with special highlighting
canvas_.DrawRect(canvas_x - 2, canvas_y - 2, 20, 20,
ImVec4(1.0f, 1.0f, 0.0f, 0.8f)); // Yellow highlight
// Draw text label
std::string stair_text = absl::StrFormat("STAIR\n0x%X", object.id_);
canvas_.DrawText(stair_text, canvas_x + 22, canvas_y);
}
}
// Draw a simple rectangle for the layout object
canvas_.DrawRect(canvas_x, canvas_y, 16, 16,
gui::ConvertSnesColorToImVec4(color));
}
}
// Coordinate conversion helper functions
void DungeonCanvasViewer::RenderSprites(const zelda3::Room& room) {
// Render sprites as simple 16x16 squares with sprite name/ID
for (const auto& sprite : room.GetSprites()) {
auto [canvas_x, canvas_y] = RoomToCanvasCoordinates(sprite.x(), sprite.y());
if (IsWithinCanvasBounds(canvas_x, canvas_y, 16)) {
// Draw 16x16 square for sprite
ImVec4 sprite_color;
// Color-code sprites based on layer
if (sprite.layer() == 0) {
sprite_color = ImVec4(0.2f, 0.8f, 0.2f, 0.8f); // Green for layer 0
} else {
sprite_color = ImVec4(0.2f, 0.2f, 0.8f, 0.8f); // Blue for layer 1
}
canvas_.DrawRect(canvas_x, canvas_y, 16, 16, sprite_color);
// Draw sprite border
canvas_.DrawRect(canvas_x, canvas_y, 16, 16, ImVec4(0.0f, 0.0f, 0.0f, 1.0f));
// Draw sprite ID and name
std::string sprite_text;
if (sprite.id() >= 0) { // sprite.id() is uint8_t so always < 256
// Extract just the sprite name part (remove ID prefix)
std::string full_name = zelda3::kSpriteDefaultNames[sprite.id()];
auto space_pos = full_name.find(' ');
if (space_pos != std::string::npos && space_pos < full_name.length() - 1) {
std::string sprite_name = full_name.substr(space_pos + 1);
// Truncate long names
if (sprite_name.length() > 8) {
sprite_name = sprite_name.substr(0, 8) + "...";
}
sprite_text = absl::StrFormat("%02X\n%s", sprite.id(), sprite_name.c_str());
} else {
sprite_text = absl::StrFormat("%02X", sprite.id());
}
} else {
sprite_text = absl::StrFormat("%02X", sprite.id());
}
canvas_.DrawText(sprite_text, canvas_x + 18, canvas_y);
}
}
}
void DungeonCanvasViewer::RenderChests(const zelda3::Room& room) {
// Render chest objects from tile objects - chests are objects with IDs 0xF9, 0xFA
for (const auto& object : room.GetTileObjects()) {
if (object.id_ == 0xF9 || object.id_ == 0xFA) { // Chest object IDs
auto [canvas_x, canvas_y] = RoomToCanvasCoordinates(object.x_, object.y_);
if (IsWithinCanvasBounds(canvas_x, canvas_y, 16)) {
// Determine if it's a big chest based on object ID
bool is_big_chest = (object.id_ == 0xFA);
// Draw chest base
ImVec4 chest_color = is_big_chest ?
ImVec4(0.8f, 0.6f, 0.2f, 0.9f) : // Gold for big chest
ImVec4(0.6f, 0.4f, 0.2f, 0.9f); // Brown for small chest
int chest_size = is_big_chest ? 24 : 16; // Big chests are larger
canvas_.DrawRect(canvas_x, canvas_y + 8, chest_size, 8, chest_color);
// Draw chest lid (slightly lighter)
ImVec4 lid_color = is_big_chest ?
ImVec4(0.9f, 0.7f, 0.3f, 0.9f) :
ImVec4(0.7f, 0.5f, 0.3f, 0.9f);
canvas_.DrawRect(canvas_x, canvas_y + 4, chest_size, 6, lid_color);
// Draw chest borders
canvas_.DrawRect(canvas_x, canvas_y + 4, chest_size, 12, ImVec4(0.0f, 0.0f, 0.0f, 1.0f));
// Draw text label
std::string chest_text = is_big_chest ? "BIG\nCHEST" : "CHEST";
canvas_.DrawText(chest_text, canvas_x + chest_size + 2, canvas_y + 6);
}
}
}
}
void DungeonCanvasViewer::RenderDoorObjects(const zelda3::Room& room) {
// Render door objects from tile objects based on IDs from assembly constants
constexpr uint16_t door_ids[] = {0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E};
for (const auto& object : room.GetTileObjects()) {
bool is_door = false;
for (uint16_t door_id : door_ids) {
if (object.id_ == door_id) {
is_door = true;
break;
}
}
if (is_door) {
auto [canvas_x, canvas_y] = RoomToCanvasCoordinates(object.x_, object.y_);
if (IsWithinCanvasBounds(canvas_x, canvas_y, 32)) {
// Draw door frame
canvas_.DrawRect(canvas_x, canvas_y, 32, 32, ImVec4(0.5f, 0.3f, 0.2f, 0.8f)); // Brown frame
// Draw door opening (darker)
canvas_.DrawRect(canvas_x + 4, canvas_y + 4, 24, 24, ImVec4(0.1f, 0.1f, 0.1f, 0.9f));
// Draw door border
canvas_.DrawRect(canvas_x, canvas_y, 32, 32, ImVec4(0.0f, 0.0f, 0.0f, 1.0f));
// Draw text label
std::string door_text = absl::StrFormat("DOOR\n0x%X", object.id_);
canvas_.DrawText(door_text, canvas_x + 34, canvas_y + 8);
}
}
}
}
void DungeonCanvasViewer::RenderWallObjects(const zelda3::Room& room) {
// Render wall objects with proper dimensions based on properties
for (const auto& object : room.GetTileObjects()) {
if (object.id_ >= 0x10 && object.id_ <= 0x1F) { // Wall objects range
auto [canvas_x, canvas_y] = RoomToCanvasCoordinates(object.x_, object.y_);
if (IsWithinCanvasBounds(canvas_x, canvas_y, 32)) {
// Different wall types based on ID
ImVec4 wall_color;
std::string wall_type;
switch (object.id_) {
case 0x10: // Basic wall
wall_color = ImVec4(0.6f, 0.6f, 0.6f, 0.8f);
wall_type = "WALL";
break;
case 0x11: // Corner wall
wall_color = ImVec4(0.7f, 0.7f, 0.6f, 0.8f);
wall_type = "CORNER";
break;
case 0x12: // Decorative wall
wall_color = ImVec4(0.8f, 0.7f, 0.6f, 0.8f);
wall_type = "DEC_WALL";
break;
default:
wall_color = ImVec4(0.5f, 0.5f, 0.5f, 0.8f);
wall_type = "WALL";
break;
}
// Calculate wall size with proper length handling
int wall_width, wall_height;
// For walls, use the size field to determine length
if (object.id_ >= 0x10 && object.id_ <= 0x1F) {
uint8_t size_x = object.size_ & 0x0F;
uint8_t size_y = (object.size_ >> 4) & 0x0F;
if (size_x > size_y) {
// Horizontal wall
wall_width = 16 + size_x * 16;
wall_height = 16;
} else if (size_y > size_x) {
// Vertical wall
wall_width = 16;
wall_height = 16 + size_y * 16;
} else {
// Square wall or corner
wall_width = 16 + size_x * 8;
wall_height = 16 + size_y * 8;
}
} else {
wall_width = 16 + (object.size_ & 0x0F) * 8;
wall_height = 16 + ((object.size_ >> 4) & 0x0F) * 8;
}
wall_width = std::min(wall_width, 256);
wall_height = std::min(wall_height, 256);
canvas_.DrawRect(canvas_x, canvas_y, wall_width, wall_height, wall_color);
canvas_.DrawRect(canvas_x, canvas_y, wall_width, wall_height, ImVec4(0.0f, 0.0f, 0.0f, 1.0f));
// Add stone block pattern
for (int i = 0; i < wall_width; i += 8) {
for (int j = 0; j < wall_height; j += 8) {
canvas_.DrawRect(canvas_x + i, canvas_y + j, 6, 6,
ImVec4(wall_color.x * 0.9f, wall_color.y * 0.9f, wall_color.z * 0.9f, wall_color.w));
}
}
// Draw text label
std::string wall_text = absl::StrFormat("%s\n0x%X\n%dx%d", wall_type.c_str(), object.id_, wall_width/16, wall_height/16);
canvas_.DrawText(wall_text, canvas_x + wall_width + 2, canvas_y + 4);
}
}
}
}
void DungeonCanvasViewer::RenderPotObjects(const zelda3::Room& room) {
// Render pot objects based on assembly constants - Object_Pot is 0x2F
for (const auto& object : room.GetTileObjects()) {
if (object.id_ == 0x2F || object.id_ == 0x2B) { // Pot objects from assembly
auto [canvas_x, canvas_y] = RoomToCanvasCoordinates(object.x_, object.y_);
if (IsWithinCanvasBounds(canvas_x, canvas_y, 16)) {
// Draw pot base (wider at bottom)
canvas_.DrawRect(canvas_x + 2, canvas_y + 10, 12, 6, ImVec4(0.7f, 0.5f, 0.3f, 0.8f)); // Brown base
// Draw pot middle
canvas_.DrawRect(canvas_x + 3, canvas_y + 6, 10, 6, ImVec4(0.8f, 0.6f, 0.4f, 0.8f)); // Lighter middle
// Draw pot rim
canvas_.DrawRect(canvas_x + 4, canvas_y + 4, 8, 4, ImVec4(0.9f, 0.7f, 0.5f, 0.8f)); // Lightest top
// Draw pot outline
canvas_.DrawRect(canvas_x + 2, canvas_y + 4, 12, 12, ImVec4(0.0f, 0.0f, 0.0f, 1.0f));
// Draw text label
std::string pot_text = absl::StrFormat("POT\n0x%X", object.id_);
canvas_.DrawText(pot_text, canvas_x + 18, canvas_y + 6);
}
}
}
}
// Coordinate conversion helper functions
std::pair<int, int> DungeonCanvasViewer::RoomToCanvasCoordinates(int room_x,
int room_y) const {
// Convert room coordinates (16x16 tile units) to canvas coordinates (pixels)
return {room_x * 16, room_y * 16};
// Convert room coordinates (tile units) to canvas coordinates (pixels)
// Account for canvas scaling and offset
float scale = canvas_.global_scale();
int offset_x = static_cast<int>(canvas_.drawn_tile_position().x);
int offset_y = static_cast<int>(canvas_.drawn_tile_position().y);
return {static_cast<int>((room_x * 16 + offset_x) * scale),
static_cast<int>((room_y * 16 + offset_y) * scale)};
}
std::pair<int, int> DungeonCanvasViewer::CanvasToRoomCoordinates(int canvas_x,
int canvas_y) const {
// Convert canvas coordinates (pixels) to room coordinates (16x16 tile units)
return {canvas_x / 16, canvas_y / 16};
// Convert canvas coordinates (pixels) to room coordinates (tile units)
// Account for canvas scaling and offset
float scale = canvas_.global_scale();
int offset_x = static_cast<int>(canvas_.drawn_tile_position().x);
int offset_y = static_cast<int>(canvas_.drawn_tile_position().y);
if (scale <= 0.0f) scale = 1.0f; // Prevent division by zero
return {static_cast<int>((canvas_x / scale - offset_x) / 16),
static_cast<int>((canvas_y / scale - offset_y) / 16)};
}
bool DungeonCanvasViewer::IsWithinCanvasBounds(int canvas_x, int canvas_y,
@@ -262,6 +513,42 @@ bool DungeonCanvasViewer::IsWithinCanvasBounds(int canvas_x, int canvas_y,
canvas_y <= canvas_height + margin);
}
void DungeonCanvasViewer::CalculateWallDimensions(const zelda3::RoomObject& object, int& width, int& height) {
// Default base size
width = 16;
height = 16;
// For walls, use the size field to determine length and orientation
if (object.id_ >= 0x10 && object.id_ <= 0x1F) {
// Wall objects: size determines length and orientation
uint8_t size_x = object.size_ & 0x0F;
uint8_t size_y = (object.size_ >> 4) & 0x0F;
// Walls can be horizontal or vertical based on size parameters
if (size_x > size_y) {
// Horizontal wall
width = 16 + size_x * 16; // Each unit adds 16 pixels
height = 16;
} else if (size_y > size_x) {
// Vertical wall
width = 16;
height = 16 + size_y * 16;
} else {
// Square wall or corner
width = 16 + size_x * 8;
height = 16 + size_y * 8;
}
} else {
// For other objects, use standard size calculation
width = 16 + (object.size_ & 0x0F) * 8;
height = 16 + ((object.size_ >> 4) & 0x0F) * 8;
}
// Clamp to reasonable limits
width = std::min(width, 256);
height = std::min(height, 256);
}
// Room graphics management methods
absl::Status DungeonCanvasViewer::LoadAndRenderRoomGraphics(int room_id) {
if (room_id < 0 || room_id >= 128) {

17
src/app/editor/dungeon/dungeon_canvas_viewer.h
View File

@@ -13,6 +13,11 @@ namespace editor {
/**
* @brief Handles the main dungeon canvas rendering and interaction
*
* In Link to the Past, dungeon "layers" are not separate visual layers
* but a game concept where objects exist on different logical levels.
* Players move between these levels using stair objects that act as
* transitions between the different object planes.
*/
class DungeonCanvasViewer {
public:
@@ -47,14 +52,22 @@ class DungeonCanvasViewer {
const gfx::SnesPalette &palette);
void DisplayObjectInfo(const zelda3::RoomObject &object, int canvas_x,
int canvas_y);
void RenderLayoutObjects(const zelda3::RoomLayout &layout,
const gfx::SnesPalette &palette);
void RenderStairObjects(const zelda3::Room& room,
const gfx::SnesPalette& palette);
void RenderSprites(const zelda3::Room& room);
void RenderChests(const zelda3::Room& room);
void RenderDoorObjects(const zelda3::Room& room);
void RenderWallObjects(const zelda3::Room& room);
void RenderPotObjects(const zelda3::Room& room);
// Coordinate conversion helpers
std::pair<int, int> RoomToCanvasCoordinates(int room_x, int room_y) const;
std::pair<int, int> CanvasToRoomCoordinates(int canvas_x, int canvas_y) const;
bool IsWithinCanvasBounds(int canvas_x, int canvas_y, int margin = 32) const;
// Object dimension calculation
void CalculateWallDimensions(const zelda3::RoomObject& object, int& width, int& height);
// Room graphics management
absl::Status LoadAndRenderRoomGraphics(int room_id);
absl::Status UpdateRoomBackgroundLayers(int room_id);

7
src/app/editor/dungeon/dungeon_editor.cc
View File

@@ -630,12 +630,17 @@ void DungeonEditor::DrawDungeonCanvas(int room_id) {
// Render background layers with proper positioning
renderer_.RenderRoomBackgroundLayers(room_id);
// Render room objects on top of background using the room's palette
// Render room objects and sprites with improved graphics
if (current_palette_id_ < current_palette_group_.size()) {
auto room_palette = current_palette_group_[current_palette_id_];
// Render regular objects with improved fallback
for (const auto& object : rooms_[room_id].GetTileObjects()) {
renderer_.RenderObjectInCanvas(object, room_palette);
}
// Render sprites as simple 16x16 squares with labels
renderer_.RenderSprites(rooms_[room_id]);
}
}

341
src/app/editor/dungeon/dungeon_object_selector.cc
View File

@@ -6,6 +6,7 @@
#include "app/gfx/arena.h"
#include "app/gfx/snes_palette.h"
#include "app/gui/canvas.h"
#include "app/gui/modules/asset_browser.h"
#include "app/rom.h"
#include "app/zelda3/dungeon/object_renderer.h"
#include "app/zelda3/dungeon/room.h"
@@ -42,29 +43,42 @@ void DungeonObjectSelector::DrawTileSelector() {
}
void DungeonObjectSelector::DrawObjectRenderer() {
// Create a comprehensive object browser with previews
// Use AssetBrowser for better object selection
if (ImGui::BeginTable("DungeonObjectEditorTable", 2, ImGuiTableFlags_Resizable | ImGuiTableFlags_Reorderable | ImGuiTableFlags_Hideable | ImGuiTableFlags_BordersOuter | ImGuiTableFlags_BordersV, ImVec2(0, 0))) {
ImGui::TableSetupColumn("Object Browser", ImGuiTableColumnFlags_WidthFixed, 280);
ImGui::TableSetupColumn("Object Browser", ImGuiTableColumnFlags_WidthFixed, 400);
ImGui::TableSetupColumn("Preview Canvas", ImGuiTableColumnFlags_WidthStretch);
ImGui::TableHeadersRow();
// Left column: Object browser with previews
// Left column: AssetBrowser for object selection
ImGui::TableNextColumn();
BeginChild("ObjectBrowser", ImVec2(0, 0), true, ImGuiWindowFlags_AlwaysVerticalScrollbar);
ImGui::BeginChild("AssetBrowser", ImVec2(0, 0), true, ImGuiWindowFlags_AlwaysVerticalScrollbar);
DrawObjectBrowser();
DrawObjectAssetBrowser();
EndChild();
ImGui::EndChild();
// Right column: Large preview canvas
// Right column: Preview and placement controls
ImGui::TableNextColumn();
BeginChild("PreviewCanvas", ImVec2(0, 0), true);
ImGui::BeginChild("PreviewCanvas", ImVec2(0, 0), true);
// Object placement controls
ImGui::SeparatorText("Object Placement");
static int place_x = 0, place_y = 0;
ImGui::InputInt("X Position", &place_x);
ImGui::InputInt("Y Position", &place_y);
if (ImGui::Button("Place Object") && object_loaded_) {
PlaceObjectAtPosition(place_x, place_y);
}
ImGui::Separator();
// Preview canvas
object_canvas_.DrawBackground(ImVec2(256 + 1, 0x10 * 0x40 + 1));
object_canvas_.DrawContextMenu();
object_canvas_.DrawTileSelector(32);
object_canvas_.DrawGrid(32.0f);
// Render selected object preview
// Render selected object preview with primitive fallback
if (object_loaded_ && preview_object_.id_ >= 0) {
int preview_x = 128 - 16; // Center horizontally
int preview_y = 128 - 16; // Center vertically
@@ -72,14 +86,22 @@ void DungeonObjectSelector::DrawObjectRenderer() {
auto preview_result = object_renderer_.RenderObject(preview_object_, preview_palette_);
if (preview_result.ok()) {
auto preview_bitmap = std::move(preview_result.value());
preview_bitmap.SetPalette(preview_palette_);
core::Renderer::Get().RenderBitmap(&preview_bitmap);
object_canvas_.DrawBitmap(preview_bitmap, preview_x, preview_y, 1.0f, 255);
if (preview_bitmap.width() > 0 && preview_bitmap.height() > 0) {
preview_bitmap.SetPalette(preview_palette_);
core::Renderer::Get().RenderBitmap(&preview_bitmap);
object_canvas_.DrawBitmap(preview_bitmap, preview_x, preview_y, 1.0f, 255);
} else {
// Fallback: Draw primitive shape
RenderObjectPrimitive(preview_object_, preview_x, preview_y);
}
} else {
// Fallback: Draw primitive shape
RenderObjectPrimitive(preview_object_, preview_x, preview_y);
}
}
object_canvas_.DrawOverlay();
EndChild();
ImGui::EndChild();
ImGui::EndTable();
}
@@ -174,32 +196,34 @@ void DungeonObjectSelector::DrawObjectBrowser() {
ImVec2 preview_pos = ImVec2(cursor_pos.x + (item_width - preview_size) / 2,
cursor_pos.y - item_height + 5);
// Try to render object preview
auto preview_result = object_renderer_.GetObjectPreview(test_object, palette);
if (preview_result.ok()) {
auto preview_bitmap = std::move(preview_result.value());
preview_bitmap.SetPalette(palette);
core::Renderer::Get().RenderBitmap(&preview_bitmap);
// Draw preview using ImGui image
ImGui::SetCursorScreenPos(preview_pos);
ImGui::Image((ImTextureID)(intptr_t)preview_bitmap.texture(),
ImVec2(preview_size, preview_size));
} else {
// Draw placeholder if preview fails
ImGui::SetCursorScreenPos(preview_pos);
ImGui::GetWindowDrawList()->AddRectFilled(
preview_pos,
ImVec2(preview_pos.x + preview_size, preview_pos.y + preview_size),
IM_COL32(64, 64, 64, 255));
ImGui::GetWindowDrawList()->AddText(
ImVec2(preview_pos.x + 8, preview_pos.y + 12),
IM_COL32(255, 255, 255, 255),
"?");
}
// Draw simplified primitive preview for object selector
ImGui::SetCursorScreenPos(preview_pos);
// Draw object ID and name with better positioning
ImGui::SetCursorScreenPos(ImVec2(cursor_pos.x + 2, cursor_pos.y - 22));
// Draw object as colored rectangle with ID
ImU32 object_color = GetObjectTypeColor(obj_id);
ImGui::GetWindowDrawList()->AddRectFilled(
preview_pos,
ImVec2(preview_pos.x + preview_size, preview_pos.y + preview_size),
object_color);
// Draw border
ImGui::GetWindowDrawList()->AddRect(
preview_pos,
ImVec2(preview_pos.x + preview_size, preview_pos.y + preview_size),
IM_COL32(0, 0, 0, 255), 0.0f, 0, 2.0f);
// Draw object type symbol in center
std::string symbol = GetObjectTypeSymbol(obj_id);
ImVec2 text_size = ImGui::CalcTextSize(symbol.c_str());
ImVec2 text_pos = ImVec2(
preview_pos.x + (preview_size - text_size.x) / 2,
preview_pos.y + (preview_size - text_size.y) / 2);
ImGui::GetWindowDrawList()->AddText(
text_pos, IM_COL32(255, 255, 255, 255), symbol.c_str());
// Draw object ID below preview
ImGui::SetCursorScreenPos(ImVec2(preview_pos.x, preview_pos.y + preview_size + 2));
ImGui::PushStyleColor(ImGuiCol_Text, IM_COL32(255, 255, 255, 255));
ImGui::Text("0x%02X", obj_id);
ImGui::PopStyleColor();
@@ -269,9 +293,9 @@ void DungeonObjectSelector::DrawObjectBrowser() {
void DungeonObjectSelector::Draw() {
if (ImGui::BeginTabBar("##ObjectSelectorTabBar")) {
// Object Selector tab - for placing objects
// Object Selector tab - for placing objects with new AssetBrowser
if (ImGui::BeginTabItem("Object Selector")) {
DrawObjectBrowser();
DrawObjectRenderer();
ImGui::EndTabItem();
}
@@ -470,6 +494,241 @@ void DungeonObjectSelector::DrawCompactObjectEditor() {
}
}
ImU32 DungeonObjectSelector::GetObjectTypeColor(int object_id) {
// Color-code objects based on their type and function
if (object_id >= 0x10 && object_id <= 0x1F) {
return IM_COL32(128, 128, 128, 255); // Gray for walls
} else if (object_id >= 0x20 && object_id <= 0x2F) {
return IM_COL32(139, 69, 19, 255); // Brown for floors
} else if (object_id == 0xF9 || object_id == 0xFA) {
return IM_COL32(255, 215, 0, 255); // Gold for chests
} else if (object_id >= 0x17 && object_id <= 0x1E) {
return IM_COL32(139, 69, 19, 255); // Brown for doors
} else if (object_id == 0x2F || object_id == 0x2B) {
return IM_COL32(160, 82, 45, 255); // Saddle brown for pots
} else if (object_id >= 0x138 && object_id <= 0x13B) {
return IM_COL32(255, 255, 0, 255); // Yellow for stairs
} else if (object_id >= 0x30 && object_id <= 0x3F) {
return IM_COL32(105, 105, 105, 255); // Dim gray for decorations
} else {
return IM_COL32(96, 96, 96, 255); // Default gray
}
}
std::string DungeonObjectSelector::GetObjectTypeSymbol(int object_id) {
// Return symbol representing object type
if (object_id >= 0x10 && object_id <= 0x1F) {
return "■"; // Wall
} else if (object_id >= 0x20 && object_id <= 0x2F) {
return "□"; // Floor
} else if (object_id == 0xF9 || object_id == 0xFA) {
return "⬛"; // Chest
} else if (object_id >= 0x17 && object_id <= 0x1E) {
return "◊"; // Door
} else if (object_id == 0x2F || object_id == 0x2B) {
return "●"; // Pot
} else if (object_id >= 0x138 && object_id <= 0x13B) {
return "▲"; // Stairs
} else if (object_id >= 0x30 && object_id <= 0x3F) {
return "◆"; // Decoration
} else {
return "?"; // Unknown
}
}
void DungeonObjectSelector::RenderObjectPrimitive(const zelda3::RoomObject& object, int x, int y) {
// Render object as primitive shape on canvas
ImU32 color = GetObjectTypeColor(object.id_);
// Calculate object size with proper wall length handling
int obj_width, obj_height;
CalculateObjectDimensions(object, obj_width, obj_height);
// Draw object rectangle
ImVec4 color_vec = ImGui::ColorConvertU32ToFloat4(color);
object_canvas_.DrawRect(x, y, obj_width, obj_height, color_vec);
object_canvas_.DrawRect(x, y, obj_width, obj_height, ImVec4(0.0f, 0.0f, 0.0f, 1.0f));
// Draw object ID as text
std::string obj_text = absl::StrFormat("0x%X", object.id_);
object_canvas_.DrawText(obj_text, x + obj_width + 2, y + 4);
}
void DungeonObjectSelector::DrawObjectAssetBrowser() {
ImGui::SeparatorText("Dungeon Objects");
// Debug info
ImGui::Text("Asset Browser Debug: Available width: %.1f", ImGui::GetContentRegionAvail().x);
// Object type filter
static int object_type_filter = 0;
const char* object_types[] = {"All", "Walls", "Floors", "Chests", "Doors", "Decorations", "Stairs"};
if (ImGui::Combo("Object Type", &object_type_filter, object_types, 7)) {
// Filter will be applied in the loop below
}
ImGui::Separator();
// Create asset browser-style grid
const float item_size = 64.0f;
const float item_spacing = 8.0f;
const int columns = std::max(1, static_cast<int>((ImGui::GetContentRegionAvail().x - item_spacing) / (item_size + item_spacing)));
ImGui::Text("Columns: %d, Item size: %.1f", columns, item_size);
int current_column = 0;
int items_drawn = 0;
// Draw object grid based on filter
for (int obj_id = 0; obj_id <= 0xFF && items_drawn < 100; ++obj_id) {
// Apply object type filter
if (object_type_filter > 0 && !MatchesObjectFilter(obj_id, object_type_filter)) {
continue;
}
if (current_column > 0) {
ImGui::SameLine();
}
ImGui::PushID(obj_id);
// Create selectable button for object
bool is_selected = (selected_object_id_ == obj_id);
ImVec2 button_size(item_size, item_size);
if (ImGui::Selectable("", is_selected, ImGuiSelectableFlags_None, button_size)) {
selected_object_id_ = obj_id;
// Create and update preview object
preview_object_ = zelda3::RoomObject(obj_id, 0, 0, 0x12, 0);
preview_object_.set_rom(rom_);
if (rom_) {
auto palette = rom_->palette_group().dungeon_main[current_palette_group_id_];
preview_palette_ = palette;
}
object_loaded_ = true;
// Notify callback
if (object_selected_callback_) {
object_selected_callback_(preview_object_);
}
}
// Draw object preview on the button
ImVec2 button_pos = ImGui::GetItemRectMin();
ImDrawList* draw_list = ImGui::GetWindowDrawList();
// Draw object as colored rectangle with symbol
ImU32 obj_color = GetObjectTypeColor(obj_id);
draw_list->AddRectFilled(button_pos,
ImVec2(button_pos.x + item_size, button_pos.y + item_size),
obj_color);
// Draw border
ImU32 border_color = is_selected ? IM_COL32(255, 255, 0, 255) : IM_COL32(0, 0, 0, 255);
draw_list->AddRect(button_pos,
ImVec2(button_pos.x + item_size, button_pos.y + item_size),
border_color, 0.0f, 0, is_selected ? 3.0f : 1.0f);
// Draw object symbol
std::string symbol = GetObjectTypeSymbol(obj_id);
ImVec2 text_size = ImGui::CalcTextSize(symbol.c_str());
ImVec2 text_pos = ImVec2(
button_pos.x + (item_size - text_size.x) / 2,
button_pos.y + (item_size - text_size.y) / 2);
draw_list->AddText(text_pos, IM_COL32(255, 255, 255, 255), symbol.c_str());
// Draw object ID at bottom
std::string id_text = absl::StrFormat("%02X", obj_id);
ImVec2 id_size = ImGui::CalcTextSize(id_text.c_str());
ImVec2 id_pos = ImVec2(
button_pos.x + (item_size - id_size.x) / 2,
button_pos.y + item_size - id_size.y - 2);
draw_list->AddText(id_pos, IM_COL32(255, 255, 255, 255), id_text.c_str());
ImGui::PopID();
current_column = (current_column + 1) % columns;
if (current_column == 0) {
// Force new line
}
items_drawn++;
}
ImGui::Separator();
ImGui::Text("Items drawn: %d", items_drawn);
}
bool DungeonObjectSelector::MatchesObjectFilter(int obj_id, int filter_type) {
switch (filter_type) {
case 1: // Walls
return obj_id >= 0x10 && obj_id <= 0x1F;
case 2: // Floors
return obj_id >= 0x20 && obj_id <= 0x2F;
case 3: // Chests
return obj_id == 0xF9 || obj_id == 0xFA;
case 4: // Doors
return obj_id >= 0x17 && obj_id <= 0x1E;
case 5: // Decorations
return obj_id >= 0x30 && obj_id <= 0x3F;
case 6: // Stairs
return obj_id >= 0x138 && obj_id <= 0x13B;
default: // All
return true;
}
}
void DungeonObjectSelector::CalculateObjectDimensions(const zelda3::RoomObject& object, int& width, int& height) {
// Default base size
width = 16;
height = 16;
// For walls, use the size field to determine length
if (object.id_ >= 0x10 && object.id_ <= 0x1F) {
// Wall objects: size determines length and orientation
uint8_t size_x = object.size_ & 0x0F;
uint8_t size_y = (object.size_ >> 4) & 0x0F;
// Walls can be horizontal or vertical based on size parameters
if (size_x > size_y) {
// Horizontal wall
width = 16 + size_x * 16; // Each unit adds 16 pixels
height = 16;
} else if (size_y > size_x) {
// Vertical wall
width = 16;
height = 16 + size_y * 16;
} else {
// Square wall or corner
width = 16 + size_x * 8;
height = 16 + size_y * 8;
}
} else {
// For other objects, use standard size calculation
width = 16 + (object.size_ & 0x0F) * 8;
height = 16 + ((object.size_ >> 4) & 0x0F) * 8;
}
// Clamp to reasonable limits
width = std::min(width, 256);
height = std::min(height, 256);
}
void DungeonObjectSelector::PlaceObjectAtPosition(int x, int y) {
if (!object_loaded_ || !object_placement_callback_) {
return;
}
// Create object with specified position
auto placed_object = preview_object_;
placed_object.set_x(static_cast<uint8_t>(x));
placed_object.set_y(static_cast<uint8_t>(y));
// Call placement callback
object_placement_callback_(placed_object);
}
void DungeonObjectSelector::DrawCompactSpriteEditor() {
if (!dungeon_editor_system_ || !*dungeon_editor_system_) {
ImGui::Text("Dungeon editor system not initialized");

19
src/app/editor/dungeon/dungeon_object_selector.h
View File

@@ -56,6 +56,10 @@ class DungeonObjectSelector {
object_selected_callback_ = callback;
}
void SetObjectPlacementCallback(std::function<void(const zelda3::RoomObject&)> callback) {
object_placement_callback_ = callback;
}
// Get current preview object for placement
const zelda3::RoomObject& GetPreviewObject() const { return preview_object_; }
bool IsObjectLoaded() const { return object_loaded_; }
@@ -65,6 +69,17 @@ class DungeonObjectSelector {
void DrawObjectBrowser();
void DrawCompactObjectEditor();
void DrawCompactSpriteEditor();
// Helper methods for primitive object rendering
ImU32 GetObjectTypeColor(int object_id);
std::string GetObjectTypeSymbol(int object_id);
void RenderObjectPrimitive(const zelda3::RoomObject& object, int x, int y);
// AssetBrowser-style object selection
void DrawObjectAssetBrowser();
bool MatchesObjectFilter(int obj_id, int filter_type);
void CalculateObjectDimensions(const zelda3::RoomObject& object, int& width, int& height);
void PlaceObjectAtPosition(int x, int y);
void DrawCompactItemEditor();
void DrawCompactEntranceEditor();
void DrawCompactDoorEditor();
@@ -96,6 +111,10 @@ class DungeonObjectSelector {
// Callback for object selection
std::function<void(const zelda3::RoomObject&)> object_selected_callback_;
std::function<void(const zelda3::RoomObject&)> object_placement_callback_;
// Object selection state
int selected_object_id_ = -1;
};
} // namespace editor

160
src/app/editor/dungeon/dungeon_renderer.cc
View File

@@ -16,14 +16,12 @@ void DungeonRenderer::RenderObjectInCanvas(const zelda3::RoomObject& object,
return;
}
// Create a mutable copy of the object to ensure tiles are loaded
auto mutable_object = object;
mutable_object.set_rom(rom_);
mutable_object.EnsureTilesLoaded();
// Convert room coordinates to canvas coordinates
auto [canvas_x, canvas_y] = RoomToCanvasCoordinates(object.x_, object.y_);
// Check if tiles were loaded successfully
if (mutable_object.tiles().empty()) {
return; // Skip objects without tiles
// Check if object is within canvas bounds
if (!IsWithinCanvasBounds(canvas_x, canvas_y, 32)) {
return; // Skip objects outside visible area
}
// Calculate palette hash for caching
@@ -33,14 +31,6 @@ void DungeonRenderer::RenderObjectInCanvas(const zelda3::RoomObject& object,
(palette_hash << 6) + (palette_hash >> 2);
}
// Convert room coordinates to canvas coordinates
auto [canvas_x, canvas_y] = RoomToCanvasCoordinates(object.x_, object.y_);
// Check if object is within canvas bounds
if (!IsWithinCanvasBounds(canvas_x, canvas_y, 32)) {
return; // Skip objects outside visible area
}
// Check cache first
for (auto& cached : object_render_cache_) {
if (cached.object_id == object.id_ && cached.object_x == object.x_ &&
@@ -51,34 +41,67 @@ void DungeonRenderer::RenderObjectInCanvas(const zelda3::RoomObject& object,
}
}
// Render the object to a bitmap
// Create a mutable copy of the object to ensure tiles are loaded
auto mutable_object = object;
mutable_object.set_rom(rom_);
mutable_object.EnsureTilesLoaded();
// Try to render the object with proper graphics
auto render_result = object_renderer_.RenderObject(mutable_object, palette);
if (!render_result.ok()) {
return; // Skip if rendering failed
if (render_result.ok()) {
auto object_bitmap = std::move(render_result.value());
// Ensure the bitmap is valid and has meaningful content
if (object_bitmap.width() > 0 && object_bitmap.height() > 0 &&
object_bitmap.data() != nullptr) {
object_bitmap.SetPalette(palette);
core::Renderer::Get().RenderBitmap(&object_bitmap);
canvas_->DrawBitmap(object_bitmap, canvas_x, canvas_y, 1.0f, 255);
// Cache the successfully rendered bitmap
ObjectRenderCache cache_entry;
cache_entry.object_id = object.id_;
cache_entry.object_x = object.x_;
cache_entry.object_y = object.y_;
cache_entry.object_size = object.size_;
cache_entry.palette_hash = palette_hash;
cache_entry.rendered_bitmap = object_bitmap;
cache_entry.is_valid = true;
// Add to cache (limit cache size)
if (object_render_cache_.size() >= 100) {
object_render_cache_.erase(object_render_cache_.begin());
}
object_render_cache_.push_back(std::move(cache_entry));
return;
}
}
auto object_bitmap = std::move(render_result.value());
object_bitmap.SetPalette(palette);
core::Renderer::Get().RenderBitmap(&object_bitmap);
// Draw the object bitmap to the canvas
canvas_->DrawBitmap(object_bitmap, canvas_x, canvas_y, 1.0f, 255);
// Cache the rendered bitmap
ObjectRenderCache cache_entry;
cache_entry.object_id = object.id_;
cache_entry.object_x = object.x_;
cache_entry.object_y = object.y_;
cache_entry.object_size = object.size_;
cache_entry.palette_hash = palette_hash;
cache_entry.rendered_bitmap = object_bitmap;
cache_entry.is_valid = true;
// Add to cache (limit cache size)
if (object_render_cache_.size() >= 100) {
object_render_cache_.erase(object_render_cache_.begin());
// Fallback: Draw object as colored rectangle with ID if rendering fails
ImVec4 object_color;
// Color-code objects based on layer for better identification
switch (object.layer_) {
case zelda3::RoomObject::LayerType::BG1:
object_color = ImVec4(0.8f, 0.4f, 0.4f, 0.8f); // Red-ish for BG1
break;
case zelda3::RoomObject::LayerType::BG2:
object_color = ImVec4(0.4f, 0.8f, 0.4f, 0.8f); // Green-ish for BG2
break;
case zelda3::RoomObject::LayerType::BG3:
object_color = ImVec4(0.4f, 0.4f, 0.8f, 0.8f); // Blue-ish for BG3
break;
default:
object_color = ImVec4(0.6f, 0.6f, 0.6f, 0.8f); // Gray for unknown
break;
}
object_render_cache_.push_back(std::move(cache_entry));
// Calculate object size (16x16 is base, size affects width/height)
int object_width = 16 + (object.size_ & 0x0F) * 8;
int object_height = 16 + ((object.size_ >> 4) & 0x0F) * 8;
canvas_->DrawRect(canvas_x, canvas_y, object_width, object_height, object_color);
canvas_->DrawRect(canvas_x, canvas_y, object_width, object_height,
ImVec4(0.0f, 0.0f, 0.0f, 1.0f)); // Black border
}
void DungeonRenderer::DisplayObjectInfo(const zelda3::RoomObject& object,
@@ -88,46 +111,25 @@ void DungeonRenderer::DisplayObjectInfo(const zelda3::RoomObject& object,
canvas_->DrawText(info_text, canvas_x, canvas_y - 12);
}
void DungeonRenderer::RenderLayoutObjects(const zelda3::RoomLayout& layout,
const gfx::SnesPalette& palette) {
for (const auto& layout_obj : layout.GetObjects()) {
auto [canvas_x, canvas_y] = RoomToCanvasCoordinates(layout_obj.x(), layout_obj.y());
if (!IsWithinCanvasBounds(canvas_x, canvas_y, 16)) {
continue;
void DungeonRenderer::RenderSprites(const zelda3::Room& room) {
// Render sprites as simple 16x16 squares with sprite name/ID
for (const auto& sprite : room.GetSprites()) {
auto [canvas_x, canvas_y] = RoomToCanvasCoordinates(sprite.x(), sprite.y());
if (IsWithinCanvasBounds(canvas_x, canvas_y, 16)) {
// Draw 16x16 square for sprite
ImVec4 sprite_color;
// Color-code sprites based on layer for identification
if (sprite.layer() == 0) {
sprite_color = ImVec4(0.2f, 0.8f, 0.2f, 0.8f); // Green for layer 0
} else {
sprite_color = ImVec4(0.2f, 0.2f, 0.8f, 0.8f); // Blue for layer 1
}
canvas_->DrawRect(canvas_x, canvas_y, 16, 16, sprite_color);
canvas_->DrawRect(canvas_x, canvas_y, 16, 16, ImVec4(0.0f, 0.0f, 0.0f, 1.0f)); // Border
}
// Choose color based on object type
gfx::SnesColor color;
switch (layout_obj.type()) {
case zelda3::RoomLayoutObject::Type::kWall:
color = gfx::SnesColor(0x7FFF); // Gray
break;
case zelda3::RoomLayoutObject::Type::kFloor:
color = gfx::SnesColor(0x4210); // Dark brown
break;
case zelda3::RoomLayoutObject::Type::kCeiling:
color = gfx::SnesColor(0x739C); // Light gray
break;
case zelda3::RoomLayoutObject::Type::kPit:
color = gfx::SnesColor(0x0000); // Black
break;
case zelda3::RoomLayoutObject::Type::kWater:
color = gfx::SnesColor(0x001F); // Blue
break;
case zelda3::RoomLayoutObject::Type::kStairs:
color = gfx::SnesColor(0x7E0F); // Yellow
break;
case zelda3::RoomLayoutObject::Type::kDoor:
color = gfx::SnesColor(0xF800); // Red
break;
default:
color = gfx::SnesColor(0x7C1F); // Magenta for unknown
break;
}
canvas_->DrawRect(canvas_x, canvas_y, 16, 16,
gui::ConvertSnesColorToImVec4(color));
}
}

3
src/app/editor/dungeon/dungeon_renderer.h
View File

@@ -30,8 +30,7 @@ class DungeonRenderer {
void RenderObjectInCanvas(const zelda3::RoomObject& object,
const gfx::SnesPalette& palette);
void DisplayObjectInfo(const zelda3::RoomObject& object, int canvas_x, int canvas_y);
void RenderLayoutObjects(const zelda3::RoomLayout& layout,
const gfx::SnesPalette& palette);
void RenderSprites(const zelda3::Room& room);
// Background rendering
void RenderRoomBackgroundLayers(int room_id);