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

fix: apply clang-format to all source files

Browse Source 
Fixes formatting violations that were causing CI failures.
Applied clang-format-14 to ensure consistent code formatting
across the codebase.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
scawful
2025-11-20 01:35:33 -05:00
parent c2bb90a3f1
commit fa3da8fc27
600 changed files with 32605 additions and 27962 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
.github/workflows/code-quality.yml vendored
View File

@@ -11,39 +11,27 @@ on:
workflow_dispatch:
jobs:
format-check:
name: "Format Check"
format-lint:
name: "Format & Lint"
runs-on: ubuntu-22.04
steps:
- uses: actions/checkout@v4
- name: Install clang-format
- name: Install tooling
run: |
sudo apt-get update
sudo apt-get install -y clang-format-14
sudo apt-get install -y clang-format-14 clang-tidy-14 cppcheck
- name: Check Formatting
run: |
find src test -name "*.cc" -o -name "*.h" | xargs clang-format-14 --dry-run --Werror
lint-check:
name: "Lint Check"
runs-on: ubuntu-22.04
steps:
- uses: actions/checkout@v4
- name: Install Tools
run: |
sudo apt-get update
sudo apt-get install -y clang-tidy-14 cppcheck
- name: Run cppcheck
run: |
cppcheck --enable=warning,style,performance --error-exitcode=0 \
--suppress=missingIncludeSystem --suppress=unusedFunction --inconclusive src/
- name: Run clang-tidy
run: |
find src -name "*.cc" -not -path "*/lib/*" | head -20 | \
@@ -71,4 +59,3 @@ jobs:
platform: linux
preset: ci
build-type: RelWithDebInfo

292
CMakePresets.json
View File

@@ -408,6 +408,221 @@
"YAZE_ENABLE_REMOTE_AUTOMATION": "ON",
"YAZE_ENABLE_AI_RUNTIME": "ON"
}
},
{
"name": "mac-dbg",
"inherits": "base",
"displayName": "macOS Debug",
"description": "Debug build for macOS",
"condition": {
"type": "equals",
"lhs": "${hostSystemName}",
"rhs": "Darwin"
},
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Debug",
"YAZE_BUILD_TESTS": "ON",
"YAZE_ENABLE_GRPC": "OFF",
"YAZE_ENABLE_JSON": "ON",
"YAZE_ENABLE_AI": "OFF",
"YAZE_BUILD_AGENT_UI": "ON",
"YAZE_ENABLE_REMOTE_AUTOMATION": "ON",
"YAZE_ENABLE_AI_RUNTIME": "OFF"
}
},
{
"name": "mac-dbg-v",
"inherits": "mac-dbg",
"displayName": "macOS Debug Verbose",
"description": "Debug build with verbose warnings",
"cacheVariables": {
"YAZE_SUPPRESS_WARNINGS": "OFF"
}
},
{
"name": "mac-rel",
"inherits": "base",
"displayName": "macOS Release",
"description": "Release build for macOS",
"condition": {
"type": "equals",
"lhs": "${hostSystemName}",
"rhs": "Darwin"
},
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Release",
"YAZE_BUILD_TESTS": "OFF",
"YAZE_ENABLE_GRPC": "OFF",
"YAZE_ENABLE_JSON": "ON",
"YAZE_ENABLE_AI": "OFF",
"YAZE_ENABLE_LTO": "ON",
"YAZE_BUILD_AGENT_UI": "OFF",
"YAZE_ENABLE_REMOTE_AUTOMATION": "OFF",
"YAZE_ENABLE_AI_RUNTIME": "OFF"
}
},
{
"name": "mac-dev",
"inherits": "base",
"displayName": "macOS Development",
"description": "Development build with ROM tests",
"condition": {
"type": "equals",
"lhs": "${hostSystemName}",
"rhs": "Darwin"
},
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Debug",
"YAZE_BUILD_TESTS": "ON",
"YAZE_ENABLE_GRPC": "OFF",
"YAZE_ENABLE_JSON": "ON",
"YAZE_ENABLE_AI": "OFF",
"YAZE_ENABLE_ROM_TESTS": "ON",
"YAZE_BUILD_AGENT_UI": "OFF",
"YAZE_ENABLE_REMOTE_AUTOMATION": "OFF",
"YAZE_ENABLE_AI_RUNTIME": "OFF"
}
},
{
"name": "mac-ai",
"inherits": "base",
"displayName": "macOS AI Development",
"description": "Full development build with AI features and gRPC",
"condition": {
"type": "equals",
"lhs": "${hostSystemName}",
"rhs": "Darwin"
},
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Debug",
"YAZE_BUILD_TESTS": "ON",
"YAZE_ENABLE_GRPC": "ON",
"YAZE_ENABLE_JSON": "ON",
"YAZE_ENABLE_AI": "ON",
"YAZE_ENABLE_ROM_TESTS": "ON",
"YAZE_BUILD_AGENT_UI": "ON",
"YAZE_ENABLE_REMOTE_AUTOMATION": "ON",
"YAZE_ENABLE_AI_RUNTIME": "ON"
}
},
{
"name": "mac-uni",
"inherits": "base",
"displayName": "macOS Universal Binary",
"description": "Universal binary for macOS (ARM64 + x86_64)",
"condition": {
"type": "equals",
"lhs": "${hostSystemName}",
"rhs": "Darwin"
},
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Release",
"CMAKE_OSX_ARCHITECTURES": "arm64;x86_64",
"YAZE_BUILD_TESTS": "OFF",
"YAZE_ENABLE_GRPC": "OFF",
"YAZE_ENABLE_JSON": "ON",
"YAZE_ENABLE_AI": "OFF",
"YAZE_ENABLE_LTO": "ON",
"YAZE_BUILD_AGENT_UI": "OFF",
"YAZE_ENABLE_REMOTE_AUTOMATION": "OFF",
"YAZE_ENABLE_AI_RUNTIME": "OFF"
}
},
{
"name": "lin-dbg",
"inherits": "base",
"displayName": "Linux Debug",
"description": "Debug build for Linux",
"condition": {
"type": "equals",
"lhs": "${hostSystemName}",
"rhs": "Linux"
},
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Debug",
"YAZE_BUILD_TESTS": "ON",
"YAZE_ENABLE_GRPC": "OFF",
"YAZE_ENABLE_JSON": "ON",
"YAZE_ENABLE_AI": "OFF",
"YAZE_BUILD_AGENT_UI": "OFF",
"YAZE_ENABLE_REMOTE_AUTOMATION": "OFF",
"YAZE_ENABLE_AI_RUNTIME": "OFF"
}
},
{
"name": "lin-dbg-v",
"inherits": "lin-dbg",
"displayName": "Linux Debug Verbose",
"description": "Debug build with verbose warnings",
"cacheVariables": {
"YAZE_SUPPRESS_WARNINGS": "OFF"
}
},
{
"name": "lin-rel",
"inherits": "base",
"displayName": "Linux Release",
"description": "Release build for Linux",
"condition": {
"type": "equals",
"lhs": "${hostSystemName}",
"rhs": "Linux"
},
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Release",
"YAZE_BUILD_TESTS": "OFF",
"YAZE_ENABLE_GRPC": "OFF",
"YAZE_ENABLE_JSON": "ON",
"YAZE_ENABLE_AI": "OFF",
"YAZE_ENABLE_LTO": "ON",
"YAZE_BUILD_AGENT_UI": "OFF",
"YAZE_ENABLE_REMOTE_AUTOMATION": "OFF",
"YAZE_ENABLE_AI_RUNTIME": "OFF"
}
},
{
"name": "lin-dev",
"inherits": "base",
"displayName": "Linux Development",
"description": "Development build with ROM tests",
"condition": {
"type": "equals",
"lhs": "${hostSystemName}",
"rhs": "Linux"
},
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Debug",
"YAZE_BUILD_TESTS": "ON",
"YAZE_ENABLE_GRPC": "OFF",
"YAZE_ENABLE_JSON": "ON",
"YAZE_ENABLE_AI": "OFF",
"YAZE_ENABLE_ROM_TESTS": "ON",
"YAZE_BUILD_AGENT_UI": "OFF",
"YAZE_ENABLE_REMOTE_AUTOMATION": "OFF",
"YAZE_ENABLE_AI_RUNTIME": "OFF"
}
},
{
"name": "lin-ai",
"inherits": "base",
"displayName": "Linux AI Development",
"description": "Full development build with AI features and gRPC",
"condition": {
"type": "equals",
"lhs": "${hostSystemName}",
"rhs": "Linux"
},
"cacheVariables": {
"CMAKE_BUILD_TYPE": "Debug",
"YAZE_BUILD_TESTS": "ON",
"YAZE_ENABLE_GRPC": "ON",
"YAZE_ENABLE_JSON": "ON",
"YAZE_ENABLE_AI": "ON",
"YAZE_ENABLE_ROM_TESTS": "ON",
"YAZE_BUILD_AGENT_UI": "ON",
"YAZE_ENABLE_REMOTE_AUTOMATION": "ON",
"YAZE_ENABLE_AI_RUNTIME": "ON"
}
}
],
"buildPresets": [
@@ -555,6 +770,83 @@
"displayName": "Windows AI Development Build (Visual Studio)",
"configuration": "Debug",
"jobs": 12
},
{
"name": "mac-dbg",
"configurePreset": "mac-dbg",
"displayName": "macOS Debug Build",
"configuration": "Debug",
"jobs": 12
},
{
"name": "mac-dbg-v",
"configurePreset": "mac-dbg-v",
"displayName": "macOS Debug Verbose Build",
"configuration": "Debug",
"jobs": 12
},
{
"name": "mac-rel",
"configurePreset": "mac-rel",
"displayName": "macOS Release Build",
"configuration": "Release",
"jobs": 12
},
{
"name": "mac-dev",
"configurePreset": "mac-dev",
"displayName": "macOS Development Build",
"configuration": "Debug",
"jobs": 12
},
{
"name": "mac-ai",
"configurePreset": "mac-ai",
"displayName": "macOS AI Development Build",
"configuration": "Debug",
"jobs": 12
},
{
"name": "mac-uni",
"configurePreset": "mac-uni",
"displayName": "macOS Universal Binary Build",
"configuration": "Release",
"jobs": 12
},
{
"name": "lin-dbg",
"configurePreset": "lin-dbg",
"displayName": "Linux Debug Build",
"configuration": "Debug",
"jobs": 12
},
{
"name": "lin-dbg-v",
"configurePreset": "lin-dbg-v",
"displayName": "Linux Debug Verbose Build",
"configuration": "Debug",
"jobs": 12
},
{
"name": "lin-rel",
"configurePreset": "lin-rel",
"displayName": "Linux Release Build",
"configuration": "Release",
"jobs": 12
},
{
"name": "lin-dev",
"configurePreset": "lin-dev",
"displayName": "Linux Development Build",
"configuration": "Debug",
"jobs": 12
},
{
"name": "lin-ai",
"configurePreset": "lin-ai",
"displayName": "Linux AI Development Build",
"configuration": "Debug",
"jobs": 12
}
],
"testPresets": [

25
README.md
View File

@@ -37,27 +37,10 @@ Run the environment verifier once per machine:
```
### Configure & Build
```bash
# macOS
cmake --preset mac-dbg
cmake --build --preset mac-dbg
# Linux
cmake --preset lin-dbg
cmake --build --preset lin-dbg
# Windows (core preset)
cmake --preset win-dbg
cmake --build --preset win-dbg --target yaze
# Enable AI + gRPC tooling (any platform)
cmake --preset mac-ai
cmake --build --preset mac-ai --target yaze z3ed
# Windows AI preset
cmake --preset win-ai
cmake --build --preset win-ai --target yaze z3ed
```
- Use the CMake preset that matches your platform (`mac-dbg`, `lin-dbg`, `win-dbg`, etc.).
- Build with `cmake --build --preset <name> [--target …]`.
- See [`docs/public/build/quick-reference.md`](docs/public/build/quick-reference.md) for the canonical
list of presets, AI build policy, and testing commands.
### Agent Feature Flags

2
assets/asm/usdasm

Submodule assets/asm/usdasm updated: d53311a54a...835b15b91f

47
cmake/dependencies/yaml.cmake
View File

@@ -4,10 +4,51 @@
include(cmake/CPM.cmake)
include(cmake/dependencies.lock)
if(NOT YAZE_ENABLE_AI AND NOT YAZE_ENABLE_AI_RUNTIME)
message(STATUS "Skipping yaml-cpp (AI runtime and CLI agent features disabled)")
set(YAZE_YAML_TARGETS "")
return()
endif()
message(STATUS "Setting up yaml-cpp ${YAML_CPP_VERSION} with CPM.cmake")
# Try to use system packages first if requested
if(YAZE_USE_SYSTEM_DEPS)
set(_YAZE_USE_SYSTEM_YAML ${YAZE_USE_SYSTEM_DEPS})
# Detect Homebrew installation automatically (helps offline builds)
if(APPLE AND NOT _YAZE_USE_SYSTEM_YAML)
set(_YAZE_YAML_PREFIX_CANDIDATES
/opt/homebrew/opt/yaml-cpp
/usr/local/opt/yaml-cpp)
foreach(_prefix IN LISTS _YAZE_YAML_PREFIX_CANDIDATES)
if(EXISTS "${_prefix}")
list(APPEND CMAKE_PREFIX_PATH "${_prefix}")
message(STATUS "Added Homebrew yaml-cpp prefix: ${_prefix}")
set(_YAZE_USE_SYSTEM_YAML ON)
break()
endif()
endforeach()
if(NOT _YAZE_USE_SYSTEM_YAML)
find_program(HOMEBREW_EXECUTABLE brew)
if(HOMEBREW_EXECUTABLE)
execute_process(
COMMAND "${HOMEBREW_EXECUTABLE}" --prefix yaml-cpp
OUTPUT_VARIABLE HOMEBREW_YAML_PREFIX
OUTPUT_STRIP_TRAILING_WHITESPACE
RESULT_VARIABLE HOMEBREW_YAML_RESULT
ERROR_QUIET)
if(HOMEBREW_YAML_RESULT EQUAL 0 AND EXISTS "${HOMEBREW_YAML_PREFIX}")
list(APPEND CMAKE_PREFIX_PATH "${HOMEBREW_YAML_PREFIX}")
message(STATUS "Added Homebrew yaml-cpp prefix: ${HOMEBREW_YAML_PREFIX}")
set(_YAZE_USE_SYSTEM_YAML ON)
endif()
endif()
endif()
endif()
# Try to use system packages first
if(_YAZE_USE_SYSTEM_YAML)
find_package(yaml-cpp QUIET)
if(yaml-cpp_FOUND)
message(STATUS "Using system yaml-cpp")
@@ -15,6 +56,8 @@ if(YAZE_USE_SYSTEM_DEPS)
target_link_libraries(yaze_yaml INTERFACE yaml-cpp)
set(YAZE_YAML_TARGETS yaze_yaml)
return()
elseif(YAZE_USE_SYSTEM_DEPS)
message(WARNING "System yaml-cpp not found despite YAZE_USE_SYSTEM_DEPS=ON; falling back to CPM download")
endif()
endif()

16
docs/internal/README.md
View File

@@ -10,6 +10,22 @@ speculative without impacting the published docs.
- `roadmaps/` – sequencing, feature parity analysis, and postmortems.
- `research/` – emulator investigations, timing analyses, web ideas, and development trackers.
- `legacy/` – superseded build guides and other historical docs kept for reference.
- `agents/` – includes the coordination board, personas, GH Actions remote guide, and helper scripts
(`scripts/agents/`) for common agent workflows.
When adding new internal docs, place them under the appropriate subdirectory here instead of
`docs/`.
## Version Control & Safety Guidelines
- **Coordinate before forceful changes**: Never rewrite history on shared branches. Use dedicated
feature/bugfix branches (see `docs/public/developer/git-workflow.md`) and keep `develop/master`
clean.
- **Back up ROMs and assets**: Treat sample ROMs, palettes, and project files as irreplaceable. Work
on copies, and enable the editor’s automatic backup setting before testing risky changes.
- **Run scripts/verify-build-environment.* after pulling significant build changes** to avoid
drifting tooling setups.
- **Document risky operations**: When touching migrations, asset packers, or scripts that modify
files in bulk, add notes under `docs/internal/roadmaps/` or `blueprints/` so others understand the
impact.
- **Use the coordination board** for any change that affects multiple personas or large parts of the
tree; log blockers and handoffs to reduce conflicting edits.

10
docs/public/developer/git-workflow.md
View File

@@ -13,6 +13,8 @@
- **Solo work**: Push directly when you're the only one working
- Warning: **Breaking changes**: Use feature branches and document in changelog
- Warning: **Major refactors**: Use feature branches for safety (can always revert)
- **Always keep local backups**: copy ROMs/assets before editing; never risk the only copy.
- **Before rebasing/rewriting history**, stash or copy work elsewhere to prevent accidental loss.
**Why relaxed?**
- Small team / solo development
@@ -199,6 +201,14 @@ git branch -d release/v0.4.0
- `experiment/vulkan-renderer`
- `experiment/wasm-build`
## Git Safety Crash Course
- Run `git status` often and avoid staging ROMs or build artifacts; add ignore rules when necessary.
- Never force-push shared branches (`develop`, `master`). PRs and feature branches are safer places
for rewrites.
- Keep backups of any tools that mutate large files (scripts, automation) so you can revert quickly.
- Before deleting branches that touched ROMs/assets, confirm those files were merged and backed up.
**Rules:**
- Branch from: `develop` or `master`
- May never merge (prototypes, research)

2
docs/public/developer/networking.md
View File

@@ -1,6 +1,6 @@
# B5 - Architecture and Networking
This document provides a comprehensive overview of the yaze application's architecture, focusing on its service-oriented design, gRPC integration, and real-time collaboration features.
This document provides a comprehensive overview of the yaze application's architecture, focusing on its service-oriented design, gRPC integration, and real-time collaboration features. For build/preset instructions when enabling gRPC/automation presets, refer to the [Build & Test Quick Reference](../build/quick-reference.md).
## 1. High-Level Architecture

5
docs/public/developer/testing-guide.md
View File

@@ -62,6 +62,9 @@ Based on the directory structure, tests fall into the following categories:
## 3. Running Tests
> 💡 Need a refresher on presets/commands? See the [Build & Test Quick Reference](../build/quick-reference.md)
> for the canonical `cmake`, `ctest`, and helper script usage before running the commands below.
### Using the Enhanced Test Runner (`yaze_test`)
The most flexible way to run tests is by using the `yaze_test` executable directly. It provides flags to filter tests by category, which is ideal for development and AI agent workflows.
@@ -147,4 +150,4 @@ To run E2E tests and see the GUI interactions, use the `--show-gui` flag.
The GUI testing framework is designed for AI agent automation. All major UI elements are registered with stable IDs, allowing an agent to "discover" and interact with them programmatically via the `z3ed` CLI.
Refer to the `z3ed` agent guide for details on using commands like `z3ed gui discover`, `z3ed gui click`, and `z3ed agent test replay`.
Refer to the `z3ed` agent guide for details on using commands like `z3ed gui discover`, `z3ed gui click`, and `z3ed agent test replay`.

1
docs/public/index.md
View File

@@ -13,6 +13,7 @@ and research notes were moved to `docs/internal/` so the public docs stay focuse
- [Getting Started](overview/getting-started.md)
## Build & Tooling
- [Build Quick Reference](build/quick-reference.md)
- [Build From Source](build/build-from-source.md)
- [Platform Compatibility](build/platform-compatibility.md)
- [CMake Presets](build/presets.md)

3
docs/public/overview/getting-started.md
View File

@@ -9,6 +9,9 @@ This software allows you to modify "The Legend of Zelda: A Link to the Past" (US
3. **Select an Editor** from the main toolbar (e.g., Overworld, Dungeon, Graphics).
4. **Make Changes** and save your project.
> Building from source or enabling AI tooling? Use the
> [Build & Test Quick Reference](../build/quick-reference.md) for the canonical commands and presets.
## General Tips
- **Experiment Flags**: Enable or disable new features in `File > Options > Experiment Flags`.

314
docs/public/usage/dungeon-editor.md
View File

@@ -1,262 +1,116 @@
# F2: Dungeon Editor v2 - Complete Guide
# F2: Dungeon Editor v2 Guide
**Last Updated**: October 10, 2025
**Related**: [Architecture Overview](../developer/architecture.md), [Debugging Guide](../developer/debugging-guide.md)
**Scope**: DungeonEditorV2 (card-based UI), DungeonEditorSystem, dungeon canvases
**Related**: [Architecture Overview](../developer/architecture.md), [Canvas System](../developer/canvas-system.md)
---
## Overview
## 1. Overview
The Dungeon Editor uses a modern card-based architecture (DungeonEditorV2) with self-contained room rendering. This guide covers the architecture, recent refactoring work, and next development steps.
The Dungeon Editor ships with the multi-card workspace introduced in the 0.3.x releases.
Self-contained room buffers keep graphics, objects, and palettes isolated so you can switch between
rooms without invalidating the entire renderer.
### Key Features
- **Visual room editing** with 512x512 canvas per room
- **Object position visualization** - Colored outlines by layer (Red/Green/Blue)
- **Per-room settings** - Independent BG1/BG2 visibility and layer types
- **Flexible docking** - EditorCard system for custom workspace layouts
- **Self-contained rooms** - Each room owns its bitmaps and palettes
- **Overworld integration** - Double-click entrances to open dungeon rooms
- 512×512 canvas per room with pan/zoom, grid, and collision overlays.
- Layer-specific visualization (BG1/BG2 toggles, colored object outlines, slot labels).
- Modular cards for rooms, objects, palettes, entrances, and toolsets.
- Undo/Redo shared across cards via `DungeonEditorSystem`.
- Tight overworld integration: double-click an entrance to open the linked dungeon room.
---
### Architecture Improvements
1. **Room Buffers Decoupled** - No dependency on Arena graphics sheets
2. **ObjectRenderer Removed** - Standardized on ObjectDrawer (~1000 lines deleted)
3. **LoadGraphicsSheetsIntoArena Removed** - Using per-room graphics (~66 lines)
4. **Old Tab System Removed** - EditorCard is the standard
5. **Texture Atlas Infrastructure** - Future-proof stub created
6. **Test Suite Cleaned** - Deleted 1270 lines of redundant tests
### UI Improvements
- Room ID in card title: `[003] Room Name`
- Properties reorganized into clean 4-column table
- Compact layer controls (1 row instead of 3)
- Room graphics canvas height fixed (1025px → 257px)
- Object count in status bar
---
## Architecture
### Component Overview
## 2. Architecture Snapshot
```
DungeonEditorV2 (UI Layer)
├─ Card-based UI system
├─ Room window management
├─ Component coordination
└─ Lazy loading
DungeonEditorV2 (UI)
├─ Cards & docking
├─ Canvas presenter
└─ Menu + toolbar actions
DungeonEditorSystem (Backend Layer)
├─ Sprite/Item/Entrance/Door/Chest management
├─ Undo/Redo functionality
├─ Room properties management
└─ Dungeon-wide operations
DungeonEditorSystem (Backend)
├─ Room/session state
├─ Undo/Redo stack
├─ Sprite/entrance/item helpers
└─ Persistence + ROM writes
Room (Data Layer)
├─ Self-contained buffers (bg1_buffer_, bg2_buffer_)
├─ Object storage (tile_objects_)
├─ Graphics loading
└─ Rendering pipeline
Room Model (Data)
├─ bg1_buffer_, bg2_buffer_
├─ tile_objects_, door data, metadata
└─ Palette + blockset caches
```
### Room Rendering Pipeline
1. **Load** – `DungeonRoomLoader` reads the room header, blockset pointers, and door/entrance
metadata, producing a `Room` instance with immutable layout info.
2. **Decode** – The requested blockset is converted into `current_gfx16_` bitmaps; objects are parsed
into `tile_objects_` grouped by layer and palette slot.
3. **Draw** – `DungeonCanvasViewer` builds BG1/BG2 bitmaps, then overlays each object layer via
`ObjectDrawer`. Palette state comes from the room’s 90-color dungeon palette.
4. **Queue** – The finished bitmaps are pushed into the graphics `Arena`, which uploads a bounded
number of textures per frame so UI latency stays flat.
5. **Present** – When textures become available, the canvas displays the layers, draws interaction
widgets (selection rectangles, door gizmos, entity labels), and applies zoom/grid settings.
TODO: Update this to latest code.
```
1. LoadRoomGraphics(blockset)
└─> Reads blocks[] from ROM
└─> Loads blockset data → current_gfx16_
2. LoadObjects()
└─> Parses object data from ROM
└─> Creates tile_objects_[]
└─> SETS floor1_graphics_, floor2_graphics_ ← CRITICAL!
3. RenderRoomGraphics() [SELF-CONTAINED]
├─> DrawFloor(floor1_graphics_, floor2_graphics_)
├─> DrawBackground(current_gfx16_)
├─> SetPalette(full_90_color_dungeon_palette)
├─> RenderObjectsToBackground()
│ └─> ObjectDrawer::DrawObjectList()
└─> QueueTextureCommand(UPDATE/CREATE)
4. DrawRoomBackgroundLayers(room_id)
└─> ProcessTextureQueue() → GPU textures
└─> canvas_.DrawBitmap(bg1, bg2)
5. DrawObjectPositionOutlines(room)
└─> Colored rectangles by layer
└─> Object ID labels
```
### Room Structure (Bottom to Top)
Understanding ALTTP dungeon composition is critical:
```
Room Composition:
├─ Room Layout (BASE LAYER - immovable)
│ ├─ Walls (structural boundaries, 7 configurations of squares in 2x2 grid)
│ ├─ Floors (walkable areas, repeated tile pattern set to BG1/BG2)
├─ Layer 0 Objects (floor decorations, some walls)
├─ Layer 1 Objects (chests, decorations)
└─ Layer 2 Objects (stairs, transitions)
Doors: Positioned at room edges to connect rooms
```
**Key Insight**: Layouts are immovable base structure. Objects are placed ON TOP and can be moved/edited. This allows for large rooms, 4-quadrant rooms, tall/wide rooms, etc.
Changing tiles, palettes, or objects invalidates the affected room cache so steps 2–5 rerun only for
that room.
---
## Next Development Steps
## 3. Editing Workflow
### High Priority (Must Do)
### Opening Rooms
1. Launch `yaze` with a ROM (`./build/bin/yaze --rom_file=zelda3.sfc`).
2. Use the **Room Matrix** or **Rooms List** card to choose a room. The toolbar “+” button also opens
the selector.
3. Pin multiple rooms by opening them in separate cards; each card maintains its own canvas state.
#### 1. Door Rendering at Room Edges
**What**: Render doors with proper patterns at room connections
### Working with Cards
**Pattern Reference**: ZScream's door drawing patterns
| Card | Purpose |
|------|---------|
| **Room Graphics** | Primary canvas, BG toggles, collision/grid switches. |
| **Object Editor** | Filter by type/layer, edit coordinates, duplicate/delete objects. |
| **Palette Editor** | Adjust per-room palette slots and preview results immediately. |
| **Entrances List** | Jump between overworld entrances and their mapped rooms. |
| **Room Matrix** | Visual grid of all rooms grouped per dungeon for quick navigation. |
**Implementation**:
```cpp
void DungeonCanvasViewer::DrawDoors(const zelda3::Room& room) {
// Doors stored in room data
// Position at room edges (North/South/East/West)
// Use current_gfx16_ graphics data
// TODO: Get door data from room.GetDoors() or similar
// TODO: Use ObjectDrawer patterns for door graphics
// TODO: Draw at interpolation points between rooms
}
```
Cards can be docked, detached, or saved as workspace presets; use the sidebar to store favorite
layouts (e.g., Room Graphics + Object Editor + Palette).
### Canvas Interactions
- Left-click to select an object; Shift-click to add to the selection.
- Drag handles to move objects or use the property grid for precise coordinates.
- Right-click to open the context menu, which includes quick inserts for common objects and a “jump
to entrance” helper.
- Hold Space to pan, use mouse wheel (or trackpad pinch) to zoom. The status footer shows current
zoom and cursor coordinates.
- Enable **Object Labels** from the toolbar to show layer-colored labels (e.g., `L1 Chest 0x23`).
### Saving & Undo
- The editor queues every change through `DungeonEditorSystem`. Use `Cmd/Ctrl+Z` and `Cmd/Ctrl+Shift+Z`
to undo/redo across cards.
- Saving writes back the room buffers, door metadata, and palettes for the active session. Keep
backups enabled (`File → Options → Experiment Flags`) for safety.
---
#### 2. Object Name Labels from String Array
**File**: `dungeon_canvas_viewer.cc:416` (DrawObjectPositionOutlines)
## 4. Tips & Troubleshooting
**What**: Show real object names instead of just IDs
**Implementation**:
```cpp
// Instead of:
std::string label = absl::StrFormat("0x%02X", obj.id_);
// Use:
std::string object_name = GetObjectName(obj.id_);
std::string label = absl::StrFormat("%s\n0x%02X", object_name.c_str(), obj.id_);
// Helper function:
std::string GetObjectName(int16_t object_id) {
// TODO: Reference ZScream's object name arrays
// TODO: Map object ID → name string
// Example: 0x10 → "Wall (North)"
return "Object";
}
```
- **Layer sanity**: If objects appear on the wrong layer, check the BG toggles in Room Graphics and
the layer filter in Object Editor—they operate independently.
- **Palette issues**: Palettes are per room. After editing, ensure `Palette Editor` writes the new
values before switching rooms; the status footer confirms pending writes.
- **Door alignment**: Use the entrance/door inspector popup (right-click a door marker) to verify
leads-to IDs without leaving the canvas.
- **Performance**: Large ROMs with many rooms can accumulate textures. If the editor feels sluggish,
close unused room cards; each card releases its textures when closed.
---
#### 4. Fix Plus Button to Select Any Room
**File**: `dungeon_editor_v2.cc:228` (DrawToolset)
**Current Issue**: Opens Room 0x00 (Ganon) always
**Fix**:
```cpp
if (toolbar.AddAction(ICON_MD_ADD, "Open Room")) {
// Show room selector dialog instead of opening room 0
show_room_selector_ = true;
// Or: show room picker popup
ImGui::OpenPopup("SelectRoomToOpen");
}
// Add popup:
if (ImGui::BeginPopup("SelectRoomToOpen")) {
static int selected_room = 0;
ImGui::InputInt("Room ID", &selected_room);
if (ImGui::Button("Open")) {
OnRoomSelected(selected_room);
ImGui::CloseCurrentPopup();
}
ImGui::EndPopup();
}
```
---
### Medium Priority (Should Do)
#### 6. Fix InputHexByte +/- Button Events
**File**: `src/app/gui/input.cc` (likely)
**Issue**: Buttons don't respond to clicks
**Investigation Needed**:
- Check if button click events are being captured
- Verify event logic matches working examples
- Keep existing event style if it works elsewhere
### Lower Priority (Nice to Have)
#### 9. Move Backend Logic to DungeonEditorSystem
**What**: Separate UI (V2) from data operations (System)
**Migration**:
- Sprite management → DungeonEditorSystem
- Item management → DungeonEditorSystem
- Entrance/Door/Chest → DungeonEditorSystem
- Undo/Redo → DungeonEditorSystem
**Result**: DungeonEditorV2 becomes pure UI coordinator
---
## Quick Start
### Build & Run
```bash
cd /Users/scawful/Code/yaze
cmake --preset mac-ai -B build_ai
cmake --build build_ai --target yaze -j12
# Run dungeon editor
./build_ai/bin/yaze.app/Contents/MacOS/yaze --rom_file=zelda3.sfc --editor=Dungeon
# Open specific room
./build_ai/bin/yaze.app/Contents/MacOS/yaze --rom_file=zelda3.sfc --editor=Dungeon --cards="Room 0x00"
```
---
## Testing & Verification
### Debug Commands
```bash
# Verify floor values load correctly
./build_ai/bin/yaze.app/Contents/MacOS/yaze --rom_file=zelda3.sfc --editor=Dungeon 2>&1 | grep "floor1="
# Expected: floor1=4, floor2=8 (NOT 0!)
# Check object rendering
./build_ai/bin/yaze.app/Contents/MacOS/yaze --rom_file=zelda3.sfc --editor=Dungeon 2>&1 | grep "Drawing.*objects"
# Check object drawing details
./build_ai/bin/yaze.app/Contents/MacOS/yaze --rom_file=zelda3.sfc --editor=Dungeon 2>&1 | grep "Writing Tile16"
```
## Related Documentation
- **Architecture Overview** (`../developer/architecture.md`) - Core architectural patterns
- **Debugging Guide** (`../developer/debugging-guide.md`) - Debugging workflows
- **Legacy context** - This document supersedes the legacy `F1-dungeon-editor-guide.md`.
---
**Last Updated**: October 10, 2025
**Contributors**: Dungeon Editor Refactoring Session
## 5. Related Docs
- [Developer Architecture Overview](../developer/architecture.md) – patterns shared across editors.
- [Canvas System Guide](../developer/canvas-system.md) – detailed explanation of canvas usage,
context menus, and popups.
- [Debugging Guide](../developer/debugging-guide.md) – startup flags and logging tips (e.g.,
`--editor=Dungeon --cards="Room 0"` for focused debugging).

6
scripts/verify-build-environment.sh
View File

@@ -114,7 +114,7 @@ function test_git_submodules() {
}
function test_cmake_cache() {
local build_dirs=("build" "build-test" "build-grpc-test" "build-rooms" "build-windows")
local build_dirs=("build" "build_test" "build-test" "build-grpc-test" "build-rooms" "build-windows" "build_ai" "build_ai_claude" "build_agent" "build_ci")
local cache_issues=0
for dir in "${build_dirs[@]}"; do
@@ -191,7 +191,7 @@ function test_agent_folder_structure() {
function clean_cmake_cache() {
write_status "Cleaning CMake cache and build directories..." "Step"
local build_dirs=("build" "build-test" "build-grpc-test" "build-rooms" "build-windows")
local build_dirs=("build" "build_test" "build-test" "build-grpc-test" "build-rooms" "build-windows" "build_ai" "build_ai_claude" "build_agent" "build_ci")
local cleaned=0
for dir in "${build_dirs[@]}"; do
@@ -457,4 +457,4 @@ else
echo ""
exit 0
fi
fi

14
src/app/controller.cc
View File

@@ -5,14 +5,14 @@
#include <string>
#include "absl/status/status.h"
#include "app/editor/editor_manager.h"
#include "app/gfx/backend/sdl2_renderer.h" // Add include for new renderer
#include "app/gfx/resource/arena.h" // Add include for Arena
#include "app/gui/automation/widget_id_registry.h"
#include "app/gui/core/background_renderer.h"
#include "app/gui/core/theme_manager.h"
#include "app/platform/timing.h"
#include "app/platform/window.h"
#include "app/editor/editor_manager.h"
#include "app/gui/core/background_renderer.h"
#include "app/gfx/resource/arena.h" // Add include for Arena
#include "app/gfx/backend/sdl2_renderer.h" // Add include for new renderer
#include "app/gui/core/theme_manager.h"
#include "app/gui/automation/widget_id_registry.h"
#include "imgui/backends/imgui_impl_sdl2.h"
#include "imgui/backends/imgui_impl_sdlrenderer2.h"
#include "imgui/imgui.h"
@@ -41,7 +41,7 @@ absl::Status Controller::OnEntry(std::string filename) {
}
void Controller::SetStartupEditor(const std::string& editor_name,
const std::string& cards) {
const std::string& cards) {
// Process command-line flags for editor and cards
// Example: --editor=Dungeon --cards="Rooms List,Room 0,Room 105"
if (!editor_name.empty()) {

9
src/app/controller.h
View File

@@ -6,10 +6,10 @@
#include <memory>
#include "absl/status/status.h"
#include "app/platform/window.h"
#include "app/rom.h"
#include "app/editor/editor_manager.h"
#include "app/gfx/backend/irenderer.h"
#include "app/platform/window.h"
#include "app/rom.h"
int main(int argc, char** argv);
@@ -29,9 +29,10 @@ class Controller {
absl::Status OnLoad();
void DoRender() const;
void OnExit();
// Set startup editor and cards from command-line flags
void SetStartupEditor(const std::string& editor_name, const std::string& cards);
void SetStartupEditor(const std::string& editor_name,
const std::string& cards);
auto window() -> SDL_Window* { return window_.window_.get(); }
void set_active(bool active) { active_ = active; }

63
src/app/editor/agent/agent_chat_history_codec.cc
View File

@@ -80,7 +80,8 @@ std::optional<cli::agent::ChatMessage::TableData> ParseTableData(
return table;
}
Json SerializeProposal(const cli::agent::ChatMessage::ProposalSummary& proposal) {
Json SerializeProposal(
const cli::agent::ChatMessage::ProposalSummary& proposal) {
Json json;
json["id"] = proposal.id;
json["change_count"] = proposal.change_count;
@@ -100,7 +101,8 @@ std::optional<cli::agent::ChatMessage::ProposalSummary> ParseProposal(
summary.id = json.value("id", "");
summary.change_count = json.value("change_count", 0);
summary.executed_commands = json.value("executed_commands", 0);
if (json.contains("sandbox_rom_path") && json["sandbox_rom_path"].is_string()) {
if (json.contains("sandbox_rom_path") &&
json["sandbox_rom_path"].is_string()) {
summary.sandbox_rom_path = json["sandbox_rom_path"].get<std::string>();
}
if (json.contains("proposal_json_path") &&
@@ -154,9 +156,8 @@ absl::StatusOr<AgentChatHistoryCodec::Snapshot> AgentChatHistoryCodec::Load(
cli::agent::ChatMessage message;
std::string sender = item.value("sender", "agent");
message.sender = sender == "user"
? cli::agent::ChatMessage::Sender::kUser
: cli::agent::ChatMessage::Sender::kAgent;
message.sender = sender == "user" ? cli::agent::ChatMessage::Sender::kUser
: cli::agent::ChatMessage::Sender::kAgent;
message.message = item.value("message", "");
message.timestamp = ParseTimestamp(item["timestamp"]);
message.is_internal = item.value("is_internal", false);
@@ -194,15 +195,15 @@ absl::StatusOr<AgentChatHistoryCodec::Snapshot> AgentChatHistoryCodec::Load(
}
}
}
if (item.contains("model_metadata") &&
item["model_metadata"].is_object()) {
if (item.contains("model_metadata") && item["model_metadata"].is_object()) {
const auto& meta_json = item["model_metadata"];
cli::agent::ChatMessage::ModelMetadata meta;
meta.provider = meta_json.value("provider", "");
meta.model = meta_json.value("model", "");
meta.latency_seconds = meta_json.value("latency_seconds", 0.0);
meta.tool_iterations = meta_json.value("tool_iterations", 0);
if (meta_json.contains("tool_names") && meta_json["tool_names"].is_array()) {
if (meta_json.contains("tool_names") &&
meta_json["tool_names"].is_array()) {
for (const auto& name : meta_json["tool_names"]) {
if (name.is_string()) {
meta.tool_names.push_back(name.get<std::string>());
@@ -227,8 +228,7 @@ absl::StatusOr<AgentChatHistoryCodec::Snapshot> AgentChatHistoryCodec::Load(
const auto& collab_json = json["collaboration"];
snapshot.collaboration.active = collab_json.value("active", false);
snapshot.collaboration.session_id = collab_json.value("session_id", "");
snapshot.collaboration.session_name =
collab_json.value("session_name", "");
snapshot.collaboration.session_name = collab_json.value("session_name", "");
snapshot.collaboration.participants.clear();
if (collab_json.contains("participants") &&
collab_json["participants"].is_array()) {
@@ -245,8 +245,7 @@ absl::StatusOr<AgentChatHistoryCodec::Snapshot> AgentChatHistoryCodec::Load(
}
if (snapshot.collaboration.session_name.empty() &&
!snapshot.collaboration.session_id.empty()) {
snapshot.collaboration.session_name =
snapshot.collaboration.session_id;
snapshot.collaboration.session_name = snapshot.collaboration.session_id;
}
}
@@ -274,7 +273,8 @@ absl::StatusOr<AgentChatHistoryCodec::Snapshot> AgentChatHistoryCodec::Load(
AgentConfigSnapshot config;
config.provider = config_json.value("provider", "");
config.model = config_json.value("model", "");
config.ollama_host = config_json.value("ollama_host", "http://localhost:11434");
config.ollama_host =
config_json.value("ollama_host", "http://localhost:11434");
config.gemini_api_key = config_json.value("gemini_api_key", "");
config.verbose = config_json.value("verbose", false);
config.show_reasoning = config_json.value("show_reasoning", true);
@@ -311,7 +311,8 @@ absl::StatusOr<AgentChatHistoryCodec::Snapshot> AgentChatHistoryCodec::Load(
if (config_json.contains("model_presets") &&
config_json["model_presets"].is_array()) {
for (const auto& preset_json : config_json["model_presets"]) {
if (!preset_json.is_object()) continue;
if (!preset_json.is_object())
continue;
AgentConfigSnapshot::ModelPreset preset;
preset.name = preset_json.value("name", "");
preset.model = preset_json.value("model", "");
@@ -347,12 +348,12 @@ absl::StatusOr<AgentChatHistoryCodec::Snapshot> AgentChatHistoryCodec::Load(
#else
(void)path;
return absl::UnimplementedError(
"Chat history persistence requires YAZE_WITH_GRPC=ON");
"Chat history persistence requires YAZE_WITH_GRPC=ON");
#endif
}
absl::Status AgentChatHistoryCodec::Save(
const std::filesystem::path& path, const Snapshot& snapshot) {
absl::Status AgentChatHistoryCodec::Save(const std::filesystem::path& path,
const Snapshot& snapshot) {
#if defined(YAZE_WITH_JSON)
Json json;
json["version"] = 4;
@@ -360,13 +361,12 @@ absl::Status AgentChatHistoryCodec::Save(
for (const auto& message : snapshot.history) {
Json entry;
entry["sender"] =
message.sender == cli::agent::ChatMessage::Sender::kUser ? "user"
: "agent";
entry["sender"] = message.sender == cli::agent::ChatMessage::Sender::kUser
? "user"
: "agent";
entry["message"] = message.message;
entry["timestamp"] = absl::FormatTime(absl::RFC3339_full,
message.timestamp,
absl::UTCTimeZone());
entry["timestamp"] = absl::FormatTime(absl::RFC3339_full, message.timestamp,
absl::UTCTimeZone());
entry["is_internal"] = message.is_internal;
if (message.json_pretty.has_value()) {
@@ -385,8 +385,7 @@ absl::Status AgentChatHistoryCodec::Save(
metrics_json["total_commands"] = metrics.total_commands;
metrics_json["total_proposals"] = metrics.total_proposals;
metrics_json["total_elapsed_seconds"] = metrics.total_elapsed_seconds;
metrics_json["average_latency_seconds"] =
metrics.average_latency_seconds;
metrics_json["average_latency_seconds"] = metrics.average_latency_seconds;
entry["metrics"] = metrics_json;
}
if (message.proposal.has_value()) {
@@ -420,9 +419,9 @@ absl::Status AgentChatHistoryCodec::Save(
collab_json["session_name"] = snapshot.collaboration.session_name;
collab_json["participants"] = snapshot.collaboration.participants;
if (snapshot.collaboration.last_synced != absl::InfinitePast()) {
collab_json["last_synced"] = absl::FormatTime(
absl::RFC3339_full, snapshot.collaboration.last_synced,
absl::UTCTimeZone());
collab_json["last_synced"] =
absl::FormatTime(absl::RFC3339_full, snapshot.collaboration.last_synced,
absl::UTCTimeZone());
}
json["collaboration"] = std::move(collab_json);
@@ -435,9 +434,9 @@ absl::Status AgentChatHistoryCodec::Save(
}
multimodal_json["status_message"] = snapshot.multimodal.status_message;
if (snapshot.multimodal.last_updated != absl::InfinitePast()) {
multimodal_json["last_updated"] = absl::FormatTime(
absl::RFC3339_full, snapshot.multimodal.last_updated,
absl::UTCTimeZone());
multimodal_json["last_updated"] =
absl::FormatTime(absl::RFC3339_full, snapshot.multimodal.last_updated,
absl::UTCTimeZone());
}
json["multimodal"] = std::move(multimodal_json);
@@ -510,7 +509,7 @@ absl::Status AgentChatHistoryCodec::Save(
(void)path;
(void)snapshot;
return absl::UnimplementedError(
"Chat history persistence requires YAZE_WITH_GRPC=ON");
"Chat history persistence requires YAZE_WITH_GRPC=ON");
#endif
}

295
src/app/editor/agent/agent_chat_history_popup.cc
View File

@@ -5,9 +5,9 @@
#include <string>
#include "absl/strings/ascii.h"
#include "absl/strings/match.h"
#include "absl/strings/str_format.h"
#include "absl/strings/str_join.h"
#include "absl/strings/match.h"
#include "absl/time/time.h"
#include "app/editor/agent/agent_ui_theme.h"
#include "app/editor/system/toast_manager.h"
@@ -41,116 +41,119 @@ AgentChatHistoryPopup::AgentChatHistoryPopup() {
}
void AgentChatHistoryPopup::Draw() {
if (!visible_) return;
if (!visible_)
return;
const auto& theme = AgentUI::GetTheme();
// Animate retro effects
ImGuiIO& io = ImGui::GetIO();
pulse_animation_ += io.DeltaTime * 2.0f;
scanline_offset_ += io.DeltaTime * 0.3f;
if (scanline_offset_ > 1.0f) scanline_offset_ -= 1.0f;
if (scanline_offset_ > 1.0f)
scanline_offset_ -= 1.0f;
glitch_animation_ += io.DeltaTime * 5.0f;
blink_counter_ = static_cast<int>(pulse_animation_ * 2.0f) % 2;
// Set drawer position on the LEFT side (full height)
ImGui::SetNextWindowPos(ImVec2(0, 0), ImGuiCond_Always);
ImGui::SetNextWindowSize(ImVec2(drawer_width_, io.DisplaySize.y), ImGuiCond_Always);
ImGui::SetNextWindowSize(ImVec2(drawer_width_, io.DisplaySize.y),
ImGuiCond_Always);
ImGuiWindowFlags flags = ImGuiWindowFlags_NoMove |
ImGuiWindowFlags_NoResize |
ImGuiWindowFlags_NoCollapse |
ImGuiWindowFlags_NoTitleBar;
ImGuiWindowFlags flags = ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize |
ImGuiWindowFlags_NoCollapse |
ImGuiWindowFlags_NoTitleBar;
// Use current theme colors with slight glow
ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 2.0f);
ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(10, 10));
// Pulsing border color
float border_pulse = 0.7f + 0.3f * std::sin(pulse_animation_ * 0.5f);
ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(
theme.provider_ollama.x * border_pulse,
theme.provider_ollama.y * border_pulse,
theme.provider_ollama.z * border_pulse + 0.2f,
0.8f
));
ImGui::PushStyleColor(
ImGuiCol_Border,
ImVec4(theme.provider_ollama.x * border_pulse,
theme.provider_ollama.y * border_pulse,
theme.provider_ollama.z * border_pulse + 0.2f, 0.8f));
if (ImGui::Begin("##AgentChatPopup", &visible_, flags)) {
DrawHeader();
ImGui::Separator();
ImGui::Spacing();
// Calculate proper list height
float list_height = ImGui::GetContentRegionAvail().y - 220.0f;
// Dark terminal background
ImVec4 terminal_bg = theme.code_bg_color;
terminal_bg.x *= 0.9f;
terminal_bg.y *= 0.9f;
terminal_bg.z *= 0.95f;
ImGui::PushStyleColor(ImGuiCol_ChildBg, terminal_bg);
ImGui::BeginChild("MessageList", ImVec2(0, list_height), true, ImGuiWindowFlags_AlwaysVerticalScrollbar);
ImGui::BeginChild("MessageList", ImVec2(0, list_height), true,
ImGuiWindowFlags_AlwaysVerticalScrollbar);
// Draw scanline effect
ImDrawList* draw_list = ImGui::GetWindowDrawList();
ImVec2 win_pos = ImGui::GetWindowPos();
ImVec2 win_size = ImGui::GetWindowSize();
for (float y = 0; y < win_size.y; y += 3.0f) {
float offset_y = y + scanline_offset_ * 3.0f;
if (offset_y < win_size.y) {
draw_list->AddLine(
ImVec2(win_pos.x, win_pos.y + offset_y),
ImVec2(win_pos.x + win_size.x, win_pos.y + offset_y),
IM_COL32(0, 0, 0, 15));
draw_list->AddLine(ImVec2(win_pos.x, win_pos.y + offset_y),
ImVec2(win_pos.x + win_size.x, win_pos.y + offset_y),
IM_COL32(0, 0, 0, 15));
}
}
DrawMessageList();
if (needs_scroll_) {
ImGui::SetScrollHereY(1.0f);
needs_scroll_ = false;
}
ImGui::EndChild();
ImGui::PopStyleColor();
ImGui::Spacing();
// Quick actions bar
if (show_quick_actions_) {
DrawQuickActions();
ImGui::Spacing();
}
// Input section at bottom
DrawInputSection();
}
ImGui::End();
ImGui::PopStyleColor(); // Border color
ImGui::PopStyleVar(2);
}
void AgentChatHistoryPopup::DrawMessageList() {
if (messages_.empty()) {
ImGui::TextDisabled("No messages yet. Start a conversation in the chat window.");
ImGui::TextDisabled(
"No messages yet. Start a conversation in the chat window.");
return;
}
// Calculate starting index for display limit
int start_index = messages_.size() > display_limit_ ?
messages_.size() - display_limit_ : 0;
int start_index =
messages_.size() > display_limit_ ? messages_.size() - display_limit_ : 0;
for (int i = start_index; i < messages_.size(); ++i) {
const auto& msg = messages_[i];
// Skip internal messages
if (msg.is_internal) continue;
if (msg.is_internal)
continue;
if (!MessagePassesFilters(msg, i)) {
continue;
}
@@ -159,24 +162,27 @@ void AgentChatHistoryPopup::DrawMessageList() {
}
}
void AgentChatHistoryPopup::DrawMessage(const cli::agent::ChatMessage& msg, int index) {
void AgentChatHistoryPopup::DrawMessage(const cli::agent::ChatMessage& msg,
int index) {
ImGui::PushID(index);
bool from_user = (msg.sender == cli::agent::ChatMessage::Sender::kUser);
// Retro terminal colors
ImVec4 header_color = from_user
? ImVec4(1.0f, 0.85f, 0.0f, 1.0f) // Amber/Gold for user
: ImVec4(0.0f, 1.0f, 0.7f, 1.0f); // Cyan/Green for agent
ImVec4 header_color =
from_user ? ImVec4(1.0f, 0.85f, 0.0f, 1.0f) // Amber/Gold for user
: ImVec4(0.0f, 1.0f, 0.7f, 1.0f); // Cyan/Green for agent
const char* sender_label = from_user ? "> USER:" : "> AGENT:";
// Message header with terminal prefix
ImGui::TextColored(header_color, "%s", sender_label);
ImGui::SameLine();
ImGui::TextColored(ImVec4(0.5f, 0.5f, 0.5f, 1.0f),
"[%s]", absl::FormatTime("%H:%M:%S", msg.timestamp, absl::LocalTimeZone()).c_str());
ImGui::TextColored(
ImVec4(0.5f, 0.5f, 0.5f, 1.0f), "[%s]",
absl::FormatTime("%H:%M:%S", msg.timestamp, absl::LocalTimeZone())
.c_str());
if (msg.model_metadata.has_value()) {
const auto& meta = *msg.model_metadata;
ImGui::SameLine();
@@ -204,16 +210,16 @@ void AgentChatHistoryPopup::DrawMessage(const cli::agent::ChatMessage& msg, int
if (ImGui::IsItemHovered()) {
ImGui::SetTooltip(is_pinned ? "Unpin message" : "Pin message");
}
// Message content with terminal styling
ImGui::Indent(15.0f);
if (msg.table_data.has_value()) {
ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.9f, 1.0f),
" %s [Table Data]", ICON_MD_TABLE_CHART);
ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.9f, 1.0f), " %s [Table Data]",
ICON_MD_TABLE_CHART);
} else if (msg.json_pretty.has_value()) {
ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.9f, 1.0f),
" %s [Structured Response]", ICON_MD_DATA_OBJECT);
ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.9f, 1.0f),
" %s [Structured Response]", ICON_MD_DATA_OBJECT);
} else {
// Truncate long messages with ellipsis
std::string content = msg.message;
@@ -224,18 +230,19 @@ void AgentChatHistoryPopup::DrawMessage(const cli::agent::ChatMessage& msg, int
ImGui::TextWrapped(" %s", content.c_str());
ImGui::PopStyleColor();
}
// Show proposal indicator with pulse
if (msg.proposal.has_value()) {
float proposal_pulse = 0.7f + 0.3f * std::sin(pulse_animation_ * 2.0f);
ImGui::TextColored(ImVec4(0.2f, proposal_pulse, 0.4f, 1.0f),
" %s Proposal: [%s]", ICON_MD_PREVIEW, msg.proposal->id.c_str());
ImGui::TextColored(ImVec4(0.2f, proposal_pulse, 0.4f, 1.0f),
" %s Proposal: [%s]", ICON_MD_PREVIEW,
msg.proposal->id.c_str());
}
if (msg.model_metadata.has_value()) {
const auto& meta = *msg.model_metadata;
ImGui::TextDisabled(" Latency: %.2fs | Tools: %d",
meta.latency_seconds, meta.tool_iterations);
ImGui::TextDisabled(" Latency: %.2fs | Tools: %d", meta.latency_seconds,
meta.tool_iterations);
if (!meta.tool_names.empty()) {
ImGui::TextDisabled(" Tool calls: %s",
absl::StrJoin(meta.tool_names, ", ").c_str());
@@ -246,23 +253,20 @@ void AgentChatHistoryPopup::DrawMessage(const cli::agent::ChatMessage& msg, int
ImGui::TextColored(ImVec4(0.95f, 0.6f, 0.2f, 1.0f), " %s %s",
ICON_MD_WARNING, warning.c_str());
}
ImGui::Unindent(15.0f);
ImGui::Spacing();
// Retro separator line
ImDrawList* draw_list = ImGui::GetWindowDrawList();
ImVec2 line_start = ImGui::GetCursorScreenPos();
float line_width = ImGui::GetContentRegionAvail().x;
draw_list->AddLine(
line_start,
ImVec2(line_start.x + line_width, line_start.y),
IM_COL32(60, 60, 70, 100),
1.0f
);
draw_list->AddLine(line_start,
ImVec2(line_start.x + line_width, line_start.y),
IM_COL32(60, 60, 70, 100), 1.0f);
ImGui::Dummy(ImVec2(0, 2));
ImGui::PopID();
}
@@ -271,7 +275,7 @@ void AgentChatHistoryPopup::DrawHeader() {
ImDrawList* draw_list = ImGui::GetWindowDrawList();
ImVec2 header_start = ImGui::GetCursorScreenPos();
ImVec2 header_size(ImGui::GetContentRegionAvail().x, 55);
// Retro gradient with pulse
float pulse = 0.5f + 0.5f * std::sin(pulse_animation_);
ImVec4 bg_top = ImGui::GetStyleColorVec4(ImGuiCol_WindowBg);
@@ -279,40 +283,34 @@ void AgentChatHistoryPopup::DrawHeader() {
bg_top.x += 0.1f * pulse;
bg_top.y += 0.1f * pulse;
bg_top.z += 0.15f * pulse;
ImU32 color_top = ImGui::GetColorU32(bg_top);
ImU32 color_bottom = ImGui::GetColorU32(bg_bottom);
draw_list->AddRectFilledMultiColor(
header_start,
ImVec2(header_start.x + header_size.x, header_start.y + header_size.y),
color_top, color_top, color_bottom, color_bottom);
// Pulsing accent line with glow
float line_pulse = 0.6f + 0.4f * std::sin(pulse_animation_ * 0.7f);
ImU32 accent_color = IM_COL32(
static_cast<int>(theme.provider_ollama.x * 255 * line_pulse),
static_cast<int>(theme.provider_ollama.y * 255 * line_pulse),
static_cast<int>(theme.provider_ollama.z * 255 * line_pulse + 50),
200
);
static_cast<int>(theme.provider_ollama.x * 255 * line_pulse),
static_cast<int>(theme.provider_ollama.y * 255 * line_pulse),
static_cast<int>(theme.provider_ollama.z * 255 * line_pulse + 50), 200);
draw_list->AddLine(
ImVec2(header_start.x, header_start.y + header_size.y),
ImVec2(header_start.x + header_size.x, header_start.y + header_size.y),
accent_color, 2.0f);
ImGui::Dummy(ImVec2(0, 8));
// Title with pulsing glow
ImVec4 title_color = ImVec4(
0.4f + 0.3f * pulse,
0.8f + 0.2f * pulse,
1.0f,
1.0f
);
ImVec4 title_color =
ImVec4(0.4f + 0.3f * pulse, 0.8f + 0.2f * pulse, 1.0f, 1.0f);
ImGui::PushStyleColor(ImGuiCol_Text, title_color);
ImGui::Text("%s CHAT HISTORY", ICON_MD_CHAT);
ImGui::PopStyleColor();
ImGui::SameLine();
ImGui::TextDisabled("[v0.4.x]");
@@ -331,8 +329,9 @@ void AgentChatHistoryPopup::DrawHeader() {
ImGui::SameLine();
ImGui::SetNextItemWidth(150.0f);
const char* provider_preview =
provider_filters_[std::min<int>(provider_filter_index_,
static_cast<int>(provider_filters_.size() - 1))]
provider_filters_[std::min<int>(
provider_filter_index_,
static_cast<int>(provider_filters_.size() - 1))]
.c_str();
if (ImGui::BeginCombo("##provider_filter", provider_preview)) {
for (int i = 0; i < static_cast<int>(provider_filters_.size()); ++i) {
@@ -358,16 +357,18 @@ void AgentChatHistoryPopup::DrawHeader() {
if (ImGui::IsItemHovered()) {
ImGui::SetTooltip("Show pinned messages only");
}
// Buttons properly spaced from right edge
ImGui::SameLine(ImGui::GetCursorPosX() + ImGui::GetContentRegionAvail().x - 75.0f);
ImGui::SameLine(ImGui::GetCursorPosX() + ImGui::GetContentRegionAvail().x -
75.0f);
// Compact mode toggle with pulse
bool should_highlight = (blink_counter_ == 0 && compact_mode_);
if (should_highlight) {
ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.2f, 0.4f, 0.6f, 0.7f));
}
if (ImGui::SmallButton(compact_mode_ ? ICON_MD_UNFOLD_MORE : ICON_MD_UNFOLD_LESS)) {
if (ImGui::SmallButton(compact_mode_ ? ICON_MD_UNFOLD_MORE
: ICON_MD_UNFOLD_LESS)) {
compact_mode_ = !compact_mode_;
}
if (should_highlight) {
@@ -376,9 +377,9 @@ void AgentChatHistoryPopup::DrawHeader() {
if (ImGui::IsItemHovered()) {
ImGui::SetTooltip(compact_mode_ ? "Expand view" : "Compact view");
}
ImGui::SameLine();
// Full chat button
if (ImGui::SmallButton(ICON_MD_OPEN_IN_NEW)) {
if (open_chat_callback_) {
@@ -389,9 +390,9 @@ void AgentChatHistoryPopup::DrawHeader() {
if (ImGui::IsItemHovered()) {
ImGui::SetTooltip("Open full chat");
}
ImGui::SameLine();
// Close button
if (ImGui::SmallButton(ICON_MD_CLOSE)) {
visible_ = false;
@@ -399,7 +400,7 @@ void AgentChatHistoryPopup::DrawHeader() {
if (ImGui::IsItemHovered()) {
ImGui::SetTooltip("Close (Ctrl+H)");
}
// Message count with retro styling
int visible_count = 0;
for (int i = 0; i < static_cast<int>(messages_.size()); ++i) {
@@ -410,26 +411,27 @@ void AgentChatHistoryPopup::DrawHeader() {
++visible_count;
}
}
ImGui::Spacing();
ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f),
"> MESSAGES: [%d]", visible_count);
ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f), "> MESSAGES: [%d]",
visible_count);
// Animated status indicator
if (unread_count_ > 0) {
ImGui::SameLine();
float unread_pulse = 0.5f + 0.5f * std::sin(pulse_animation_ * 3.0f);
ImGui::TextColored(ImVec4(1.0f, unread_pulse * 0.5f, 0.0f, 1.0f),
"%s %d NEW", ICON_MD_NOTIFICATION_IMPORTANT, unread_count_);
"%s %d NEW", ICON_MD_NOTIFICATION_IMPORTANT,
unread_count_);
}
ImGui::Dummy(ImVec2(0, 5));
}
void AgentChatHistoryPopup::DrawQuickActions() {
// 4 buttons with narrower width
float button_width = (ImGui::GetContentRegionAvail().x - 15) / 4.0f;
// Multimodal snapshot button
if (ImGui::Button(ICON_MD_CAMERA, ImVec2(button_width, 30))) {
if (capture_snapshot_callback_) {
@@ -439,11 +441,12 @@ void AgentChatHistoryPopup::DrawQuickActions() {
if (ImGui::IsItemHovered()) {
ImGui::SetTooltip("Capture screenshot");
}
ImGui::SameLine();
// Filter button with icon indicator
const char* filter_icons[] = {ICON_MD_FILTER_LIST, ICON_MD_PERSON, ICON_MD_SMART_TOY};
const char* filter_icons[] = {ICON_MD_FILTER_LIST, ICON_MD_PERSON,
ICON_MD_SMART_TOY};
int filter_idx = static_cast<int>(message_filter_);
if (ImGui::Button(filter_icons[filter_idx], ImVec2(button_width, 30))) {
ImGui::OpenPopup("FilterPopup");
@@ -452,35 +455,39 @@ void AgentChatHistoryPopup::DrawQuickActions() {
const char* filter_names[] = {"All", "User only", "Agent only"};
ImGui::SetTooltip("Filter: %s", filter_names[filter_idx]);
}
// Filter popup
if (ImGui::BeginPopup("FilterPopup")) {
if (ImGui::Selectable(ICON_MD_FILTER_LIST " All Messages", message_filter_ == MessageFilter::kAll)) {
if (ImGui::Selectable(ICON_MD_FILTER_LIST " All Messages",
message_filter_ == MessageFilter::kAll)) {
message_filter_ = MessageFilter::kAll;
}
if (ImGui::Selectable(ICON_MD_PERSON " User Only", message_filter_ == MessageFilter::kUserOnly)) {
if (ImGui::Selectable(ICON_MD_PERSON " User Only",
message_filter_ == MessageFilter::kUserOnly)) {
message_filter_ = MessageFilter::kUserOnly;
}
if (ImGui::Selectable(ICON_MD_SMART_TOY " Agent Only", message_filter_ == MessageFilter::kAgentOnly)) {
if (ImGui::Selectable(ICON_MD_SMART_TOY " Agent Only",
message_filter_ == MessageFilter::kAgentOnly)) {
message_filter_ = MessageFilter::kAgentOnly;
}
ImGui::EndPopup();
}
ImGui::SameLine();
// Save session button
if (ImGui::Button(ICON_MD_SAVE, ImVec2(button_width, 30))) {
if (toast_manager_) {
toast_manager_->Show(ICON_MD_SAVE " Session auto-saved", ToastType::kSuccess, 1.5f);
toast_manager_->Show(ICON_MD_SAVE " Session auto-saved",
ToastType::kSuccess, 1.5f);
}
}
if (ImGui::IsItemHovered()) {
ImGui::SetTooltip("Save chat session");
}
ImGui::SameLine();
// Clear button
if (ImGui::Button(ICON_MD_DELETE, ImVec2(button_width, 30))) {
ClearHistory();
@@ -566,35 +573,38 @@ void AgentChatHistoryPopup::TogglePin(int index) {
void AgentChatHistoryPopup::DrawInputSection() {
ImGui::Separator();
ImGui::Spacing();
// Input field using theme colors
bool send_message = false;
if (ImGui::InputTextMultiline("##popup_input", input_buffer_, sizeof(input_buffer_),
ImVec2(-1, 60),
ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_CtrlEnterForNewLine)) {
if (ImGui::InputTextMultiline("##popup_input", input_buffer_,
sizeof(input_buffer_), ImVec2(-1, 60),
ImGuiInputTextFlags_EnterReturnsTrue |
ImGuiInputTextFlags_CtrlEnterForNewLine)) {
send_message = true;
}
// Focus input on first show
if (focus_input_) {
ImGui::SetKeyboardFocusHere(-1);
focus_input_ = false;
}
// Send button (proper width)
ImGui::Spacing();
float send_button_width = ImGui::GetContentRegionAvail().x;
if (ImGui::Button(absl::StrFormat("%s Send", ICON_MD_SEND).c_str(), ImVec2(send_button_width, 32)) || send_message) {
if (ImGui::Button(absl::StrFormat("%s Send", ICON_MD_SEND).c_str(),
ImVec2(send_button_width, 32)) ||
send_message) {
if (std::strlen(input_buffer_) > 0) {
SendMessage(input_buffer_);
std::memset(input_buffer_, 0, sizeof(input_buffer_));
}
}
if (ImGui::IsItemHovered()) {
ImGui::SetTooltip("Send message (Enter) • Ctrl+Enter for newline");
}
// Info text
ImGui::Spacing();
ImGui::TextDisabled(ICON_MD_INFO " Enter: send • Ctrl+Enter: newline");
@@ -603,20 +613,22 @@ void AgentChatHistoryPopup::DrawInputSection() {
void AgentChatHistoryPopup::SendMessage(const std::string& message) {
if (send_message_callback_) {
send_message_callback_(message);
if (toast_manager_) {
toast_manager_->Show(ICON_MD_SEND " Message sent", ToastType::kSuccess, 1.5f);
toast_manager_->Show(ICON_MD_SEND " Message sent", ToastType::kSuccess,
1.5f);
}
// Auto-scroll to see response
needs_scroll_ = true;
}
}
void AgentChatHistoryPopup::UpdateHistory(const std::vector<cli::agent::ChatMessage>& history) {
void AgentChatHistoryPopup::UpdateHistory(
const std::vector<cli::agent::ChatMessage>& history) {
bool had_messages = !messages_.empty();
int old_size = messages_.size();
messages_ = history;
std::unordered_set<int> updated_pins;
@@ -627,7 +639,7 @@ void AgentChatHistoryPopup::UpdateHistory(const std::vector<cli::agent::ChatMess
}
pinned_messages_.swap(updated_pins);
RefreshProviderFilters();
// Auto-scroll if new messages arrived
if (auto_scroll_ && messages_.size() > old_size) {
needs_scroll_ = true;
@@ -638,10 +650,11 @@ void AgentChatHistoryPopup::NotifyNewMessage() {
if (auto_scroll_) {
needs_scroll_ = true;
}
// Flash the window to draw attention
if (toast_manager_ && !visible_) {
toast_manager_->Show(ICON_MD_CHAT " New message received", ToastType::kInfo, 2.0f);
toast_manager_->Show(ICON_MD_CHAT " New message received", ToastType::kInfo,
2.0f);
}
}
@@ -651,7 +664,7 @@ void AgentChatHistoryPopup::ClearHistory() {
provider_filters_.clear();
provider_filters_.push_back("All providers");
provider_filter_index_ = 0;
if (toast_manager_) {
toast_manager_->Show("Chat history popup cleared", ToastType::kInfo, 2.0f);
}

32
src/app/editor/agent/agent_chat_history_popup.h
View File

@@ -48,7 +48,7 @@ class AgentChatHistoryPopup {
// Update history from service
void UpdateHistory(const std::vector<cli::agent::ChatMessage>& history);
// Notify of new message (triggers auto-scroll)
void NotifyNewMessage();
@@ -57,20 +57,20 @@ class AgentChatHistoryPopup {
void SetOpenChatCallback(OpenChatCallback callback) {
open_chat_callback_ = std::move(callback);
}
// Set callback for sending messages
using SendMessageCallback = std::function<void(const std::string&)>;
void SetSendMessageCallback(SendMessageCallback callback) {
send_message_callback_ = std::move(callback);
}
// Set callback for capturing snapshots
using CaptureSnapshotCallback = std::function<void()>;
void SetCaptureSnapshotCallback(CaptureSnapshotCallback callback) {
capture_snapshot_callback_ = std::move(callback);
}
private:
private:
void DrawHeader();
void DrawQuickActions();
void DrawInputSection();
@@ -80,55 +80,51 @@ private:
int index) const;
void RefreshProviderFilters();
void TogglePin(int index);
void SendMessage(const std::string& message);
void ClearHistory();
void ExportHistory();
void ScrollToBottom();
bool visible_ = false;
bool needs_scroll_ = false;
bool auto_scroll_ = true;
bool compact_mode_ = true;
bool show_quick_actions_ = true;
// History state
std::vector<cli::agent::ChatMessage> messages_;
int display_limit_ = 50; // Show last 50 messages
// Input state
char input_buffer_[512] = {};
char search_buffer_[160] = {};
bool focus_input_ = false;
// UI state
float drawer_width_ = 420.0f;
float min_drawer_width_ = 300.0f;
float max_drawer_width_ = 700.0f;
bool is_resizing_ = false;
// Filter state
enum class MessageFilter {
kAll,
kUserOnly,
kAgentOnly
};
enum class MessageFilter { kAll, kUserOnly, kAgentOnly };
MessageFilter message_filter_ = MessageFilter::kAll;
std::vector<std::string> provider_filters_;
int provider_filter_index_ = 0;
bool show_pinned_only_ = false;
std::unordered_set<int> pinned_messages_;
// Visual state
float header_pulse_ = 0.0f;
int unread_count_ = 0;
// Retro hacker aesthetic animations
float pulse_animation_ = 0.0f;
float scanline_offset_ = 0.0f;
float glitch_animation_ = 0.0f;
int blink_counter_ = 0;
// Dependencies
ToastManager* toast_manager_ = nullptr;
OpenChatCallback open_chat_callback_;

1090
src/app/editor/agent/agent_chat_widget.cc
View File

File diff suppressed because it is too large Load Diff

88
src/app/editor/agent/agent_chat_widget.h
View File

@@ -12,11 +12,11 @@
#include "absl/time/time.h"
#include "app/editor/agent/agent_chat_history_codec.h"
#include "app/gui/widgets/text_editor.h"
#include "cli/service/ai/ollama_ai_service.h"
#include "cli/service/agent/conversational_agent_service.h"
#include "cli/service/agent/advanced_routing.h"
#include "cli/service/agent/agent_pretraining.h"
#include "cli/service/agent/conversational_agent_service.h"
#include "cli/service/agent/prompt_manager.h"
#include "cli/service/ai/ollama_ai_service.h"
#include "core/project.h"
namespace yaze {
@@ -50,7 +50,7 @@ class AgentChatHistoryPopup;
class AgentChatWidget {
public:
AgentChatWidget();
void Draw();
void SetRomContext(Rom* rom);
@@ -62,15 +62,19 @@ class AgentChatWidget {
std::vector<std::string> participants;
};
std::function<absl::StatusOr<SessionContext>(const std::string&)> host_session;
std::function<absl::StatusOr<SessionContext>(const std::string&)> join_session;
std::function<absl::StatusOr<SessionContext>(const std::string&)>
host_session;
std::function<absl::StatusOr<SessionContext>(const std::string&)>
join_session;
std::function<absl::Status()> leave_session;
std::function<absl::StatusOr<SessionContext>()> refresh_session;
};
struct MultimodalCallbacks {
std::function<absl::Status(std::filesystem::path*)> capture_snapshot;
std::function<absl::Status(const std::filesystem::path&, const std::string&)> send_to_gemini;
std::function<absl::Status(const std::filesystem::path&,
const std::string&)>
send_to_gemini;
};
struct AutomationCallbacks {
@@ -91,8 +95,10 @@ class AgentChatWidget {
// Z3ED Command Callbacks
struct Z3EDCommandCallbacks {
std::function<absl::Status(const std::string&)> run_agent_task;
std::function<absl::StatusOr<std::string>(const std::string&)> plan_agent_task;
std::function<absl::StatusOr<std::string>(const std::string&)> diff_proposal;
std::function<absl::StatusOr<std::string>(const std::string&)>
plan_agent_task;
std::function<absl::StatusOr<std::string>(const std::string&)>
diff_proposal;
std::function<absl::Status(const std::string&)> accept_proposal;
std::function<absl::Status(const std::string&)> reject_proposal;
std::function<absl::StatusOr<std::vector<std::string>>()> list_proposals;
@@ -101,12 +107,13 @@ class AgentChatWidget {
// ROM Sync Callbacks
struct RomSyncCallbacks {
std::function<absl::StatusOr<std::string>()> generate_rom_diff;
std::function<absl::Status(const std::string&, const std::string&)> apply_rom_diff;
std::function<absl::Status(const std::string&, const std::string&)>
apply_rom_diff;
std::function<std::string()> get_rom_hash;
};
void RenderSnapshotPreviewPanel();
// Screenshot preview and region selection
void LoadScreenshotPreview(const std::filesystem::path& image_path);
void UnloadScreenshotPreview();
@@ -119,7 +126,7 @@ class AgentChatWidget {
void SetToastManager(ToastManager* toast_manager);
void SetProposalDrawer(ProposalDrawer* drawer);
void SetChatHistoryPopup(AgentChatHistoryPopup* popup);
void SetCollaborationCallbacks(const CollaborationCallbacks& callbacks) {
@@ -135,7 +142,7 @@ class AgentChatWidget {
void UpdateHarnessTelemetry(const AutomationTelemetry& telemetry);
void SetLastPlanSummary(const std::string& summary);
// Automation status polling
void PollAutomationStatus();
bool CheckHarnessConnection();
@@ -152,8 +159,8 @@ class AgentChatWidget {
bool is_active() const { return active_; }
void set_active(bool active) { active_ = active; }
enum class CollaborationMode {
kLocal = 0, // Filesystem-based collaboration
kNetwork = 1 // WebSocket-based collaboration
kLocal = 0, // Filesystem-based collaboration
kNetwork = 1 // WebSocket-based collaboration
};
struct CollaborationState {
@@ -282,20 +289,20 @@ class AgentChatWidget {
bool command_running = false;
char command_input_buffer[512] = {};
};
void SetPromptMode(cli::agent::PromptMode mode) { prompt_mode_ = mode; }
cli::agent::PromptMode GetPromptMode() const { return prompt_mode_; }
// Accessors for capture settings
CaptureMode capture_mode() const { return multimodal_state_.capture_mode; }
const char* specific_window_name() const {
return multimodal_state_.specific_window_buffer;
const char* specific_window_name() const {
return multimodal_state_.specific_window_buffer;
}
// Agent configuration accessors
const AgentConfigState& GetAgentConfig() const { return agent_config_; }
void UpdateAgentConfig(const AgentConfigState& config);
// Load agent settings from project
void LoadAgentSettingsFromProject(const project::YazeProject& project);
void SaveAgentSettingsToProject(project::YazeProject& project);
@@ -303,7 +310,7 @@ class AgentChatWidget {
// Collaboration history management (public so EditorManager can call them)
void SwitchToSharedHistory(const std::string& session_id);
void SwitchToLocalHistory();
// File editing
void OpenFileInEditor(const std::string& filepath);
void CreateNewFileInEditor(const std::string& filename);
@@ -344,10 +351,12 @@ class AgentChatWidget {
bool update_action_timestamp);
void MarkHistoryDirty();
void PollSharedHistory(); // For real-time collaboration sync
void HandleRomSyncReceived(const std::string& diff_data, const std::string& rom_hash);
void HandleSnapshotReceived(const std::string& snapshot_data, const std::string& snapshot_type);
void HandleRomSyncReceived(const std::string& diff_data,
const std::string& rom_hash);
void HandleSnapshotReceived(const std::string& snapshot_data,
const std::string& snapshot_type);
void HandleProposalReceived(const std::string& proposal_data);
void RefreshOllamaModels();
void RefreshModels();
cli::AIServiceConfig BuildAIServiceConfig() const;
void ApplyToolPreferences();
void ApplyHistoryAgentConfig(
@@ -355,7 +364,7 @@ class AgentChatWidget {
AgentChatHistoryCodec::AgentConfigSnapshot BuildHistoryAgentConfig() const;
void MarkPresetUsage(const std::string& model_name);
void ApplyModelPreset(const AgentConfigState::ModelPreset& preset);
// History synchronization
void SyncHistoryToPopup();
@@ -363,7 +372,7 @@ class AgentChatWidget {
bool waiting_for_response_ = false;
float thinking_animation_ = 0.0f;
std::string pending_message_;
// Chat session management
struct ChatSession {
std::string id;
@@ -376,20 +385,20 @@ class AgentChatWidget {
std::filesystem::path history_path;
absl::Time created_at = absl::Now();
absl::Time last_persist_time = absl::InfinitePast();
ChatSession(const std::string& session_id, const std::string& session_name)
: id(session_id), name(session_name) {}
};
void SaveChatSession(const ChatSession& session);
void LoadChatSession(const std::string& session_id);
void DeleteChatSession(const std::string& session_id);
std::vector<std::string> GetSavedSessions();
std::filesystem::path GetSessionsDirectory();
std::vector<ChatSession> chat_sessions_;
int active_session_index_ = 0;
// Legacy single session support (will migrate to sessions)
cli::agent::ConversationalAgentService agent_service_;
char input_buffer_[1024];
@@ -407,7 +416,7 @@ class AgentChatWidget {
AgentChatHistoryPopup* chat_history_popup_ = nullptr;
std::string pending_focus_proposal_id_;
absl::Time last_persist_time_ = absl::InfinitePast();
// Main state
CollaborationState collaboration_state_;
MultimodalState multimodal_state_;
@@ -423,37 +432,38 @@ class AgentChatWidget {
bool active = false;
} persona_profile_;
bool persona_highlight_active_ = false;
// Callbacks
CollaborationCallbacks collaboration_callbacks_;
MultimodalCallbacks multimodal_callbacks_;
AutomationCallbacks automation_callbacks_;
Z3EDCommandCallbacks z3ed_callbacks_;
RomSyncCallbacks rom_sync_callbacks_;
// Input buffers
char session_name_buffer_[64] = {};
char join_code_buffer_[64] = {};
char server_url_buffer_[256] = "ws://localhost:8765";
char multimodal_prompt_buffer_[256] = {};
// Timing
absl::Time last_collaboration_action_ = absl::InfinitePast();
absl::Time last_shared_history_poll_ = absl::InfinitePast();
size_t last_known_history_size_ = 0;
// UI state
int active_tab_ = 0; // 0=Chat, 1=Config, 2=Commands, 3=Collab, 4=ROM Sync, 5=Files, 6=Prompt
int active_tab_ =
0; // 0=Chat, 1=Config, 2=Commands, 3=Collab, 4=ROM Sync, 5=Files, 6=Prompt
bool show_agent_config_ = false;
cli::agent::PromptMode prompt_mode_ = cli::agent::PromptMode::kStandard;
bool show_z3ed_commands_ = false;
bool show_rom_sync_ = false;
bool show_snapshot_preview_ = false;
std::vector<uint8_t> snapshot_preview_data_;
// Reactive UI colors
ImVec4 collaboration_status_color_ = ImVec4(0.6f, 0.6f, 0.6f, 1.0f);
// File editing state
struct FileEditorTab {
std::string filepath;
@@ -466,10 +476,10 @@ class AgentChatWidget {
int active_file_tab_ = -1;
// Model roster cache
std::vector<cli::OllamaAIService::ModelInfo> ollama_model_info_cache_;
std::vector<std::string> ollama_model_cache_;
std::vector<cli::ModelInfo> model_info_cache_;
std::vector<std::string> model_name_cache_;
absl::Time last_model_refresh_ = absl::InfinitePast();
bool ollama_models_loading_ = false;
bool models_loading_ = false;
char model_search_buffer_[64] = {};
char new_preset_name_[64] = {};
int active_model_preset_index_ = -1;

34
src/app/editor/agent/agent_collaboration_coordinator.cc
View File

@@ -18,8 +18,8 @@
#include "absl/strings/str_format.h"
#include "absl/strings/strip.h"
#include "util/file_util.h"
#include "util/platform_paths.h"
#include "util/macro.h"
#include "util/platform_paths.h"
#include <filesystem>
namespace fs = std::filesystem;
@@ -213,7 +213,8 @@ absl::Status AgentCollaborationCoordinator::EnsureDirectory() const {
std::string AgentCollaborationCoordinator::LocalUserName() const {
const char* override_name = std::getenv("YAZE_USER_NAME");
const char* user = override_name != nullptr ? override_name : std::getenv("USER");
const char* user =
override_name != nullptr ? override_name : std::getenv("USER");
if (user == nullptr) {
user = std::getenv("USERNAME");
}
@@ -236,17 +237,17 @@ std::string AgentCollaborationCoordinator::LocalUserName() const {
std::string AgentCollaborationCoordinator::NormalizeSessionCode(
const std::string& input) const {
std::string normalized = Trimmed(input);
normalized.erase(std::remove_if(normalized.begin(), normalized.end(),
[](unsigned char c) {
return !std::isalnum(
static_cast<unsigned char>(c));
}),
normalized.end());
std::transform(normalized.begin(), normalized.end(), normalized.begin(),
[](unsigned char c) {
return static_cast<char>(
std::toupper(static_cast<unsigned char>(c)));
});
normalized.erase(
std::remove_if(normalized.begin(), normalized.end(),
[](unsigned char c) {
return !std::isalnum(static_cast<unsigned char>(c));
}),
normalized.end());
std::transform(
normalized.begin(), normalized.end(), normalized.begin(),
[](unsigned char c) {
return static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
});
return normalized;
}
@@ -304,8 +305,8 @@ AgentCollaborationCoordinator::LoadSessionFile(
data.host = value;
data.participants.push_back(value);
} else if (key == "participant") {
if (std::find(data.participants.begin(), data.participants.end(), value) ==
data.participants.end()) {
if (std::find(data.participants.begin(), data.participants.end(),
value) == data.participants.end()) {
data.participants.push_back(value);
}
}
@@ -320,8 +321,7 @@ AgentCollaborationCoordinator::LoadSessionFile(
if (host_it == data.participants.end()) {
data.participants.insert(data.participants.begin(), data.host);
} else if (host_it != data.participants.begin()) {
std::rotate(data.participants.begin(), host_it,
std::next(host_it));
std::rotate(data.participants.begin(), host_it, std::next(host_it));
}
}

47
src/app/editor/agent/agent_editor.cc
View File

@@ -8,14 +8,14 @@
#include "absl/strings/match.h"
#include "absl/strings/str_format.h"
#include "absl/time/clock.h"
#include "app/platform/asset_loader.h"
#include "app/editor/agent/agent_chat_widget.h"
#include "app/editor/agent/agent_collaboration_coordinator.h"
#include "app/editor/system/proposal_drawer.h"
#include "app/editor/system/toast_manager.h"
#include "app/gui/core/icons.h"
#include "imgui/misc/cpp/imgui_stdlib.h"
#include "app/platform/asset_loader.h"
#include "app/rom.h"
#include "imgui/misc/cpp/imgui_stdlib.h"
#include "util/file_util.h"
#include "util/platform_paths.h"
@@ -156,18 +156,16 @@ void AgentEditor::DrawDashboard() {
ImGuiIO& io = ImGui::GetIO();
pulse_animation_ += io.DeltaTime * 2.0f;
scanline_offset_ += io.DeltaTime * 0.4f;
if (scanline_offset_ > 1.0f) scanline_offset_ -= 1.0f;
if (scanline_offset_ > 1.0f)
scanline_offset_ -= 1.0f;
glitch_timer_ += io.DeltaTime * 5.0f;
blink_counter_ = static_cast<int>(pulse_animation_ * 2.0f) % 2;
// Pulsing glow for window
float pulse = 0.5f + 0.5f * std::sin(pulse_animation_);
ImGui::PushStyleColor(ImGuiCol_TitleBgActive, ImVec4(
0.1f + 0.1f * pulse,
0.2f + 0.15f * pulse,
0.3f + 0.2f * pulse,
1.0f
));
ImGui::PushStyleColor(ImGuiCol_TitleBgActive,
ImVec4(0.1f + 0.1f * pulse, 0.2f + 0.15f * pulse,
0.3f + 0.2f * pulse, 1.0f));
ImGui::SetNextWindowSize(ImVec2(1200, 800), ImGuiCond_FirstUseEver);
ImGui::Begin(ICON_MD_SMART_TOY " AI AGENT PLATFORM [v0.4.x]", &active_,
@@ -324,7 +322,7 @@ void AgentEditor::DrawDashboard() {
}
ImGui::End();
// Pop the TitleBgActive color pushed at the beginning of DrawDashboard
ImGui::PopStyleColor();
}
@@ -1040,8 +1038,7 @@ void AgentEditor::DrawNewPromptCreator() {
}
if (ImGui::Button(ICON_MD_FILE_COPY " v2 (Enhanced)", ImVec2(-1, 0))) {
auto content =
AssetLoader::LoadTextFile("agent/system_prompt_v2.txt");
auto content = AssetLoader::LoadTextFile("agent/system_prompt_v2.txt");
if (content.ok() && prompt_editor_) {
prompt_editor_->SetText(*content);
if (toast_manager_) {
@@ -1051,8 +1048,7 @@ void AgentEditor::DrawNewPromptCreator() {
}
if (ImGui::Button(ICON_MD_FILE_COPY " v3 (Proactive)", ImVec2(-1, 0))) {
auto content =
AssetLoader::LoadTextFile("agent/system_prompt_v3.txt");
auto content = AssetLoader::LoadTextFile("agent/system_prompt_v3.txt");
if (content.ok() && prompt_editor_) {
prompt_editor_->SetText(*content);
if (toast_manager_) {
@@ -1149,9 +1145,9 @@ void AgentEditor::DrawAgentBuilderPanel() {
ImGui::TextColored(ImVec4(0.9f, 0.9f, 0.6f, 1.0f), "Stage Details");
ImGui::Separator();
int stage_index = std::clamp(builder_state_.active_stage, 0,
static_cast<int>(builder_state_.stages.size()) -
1);
int stage_index =
std::clamp(builder_state_.active_stage, 0,
static_cast<int>(builder_state_.stages.size()) - 1);
int completed_stages = 0;
for (const auto& stage : builder_state_.stages) {
if (stage.completed) {
@@ -1163,8 +1159,7 @@ void AgentEditor::DrawAgentBuilderPanel() {
static std::string new_goal;
ImGui::Text("Persona + Goals");
ImGui::InputTextMultiline("##persona_notes",
&builder_state_.persona_notes,
ImVec2(-1, 120));
&builder_state_.persona_notes, ImVec2(-1, 120));
ImGui::Spacing();
ImGui::TextDisabled("Add Goal");
ImGui::InputTextWithHint("##goal_input", "e.g. Document dungeon plan",
@@ -1293,8 +1288,8 @@ void AgentEditor::DrawAgentBuilderPanel() {
toast_manager_->Show("Builder blueprint saved", ToastType::kSuccess,
2.0f);
} else {
toast_manager_->Show(std::string(status.message()),
ToastType::kError, 3.5f);
toast_manager_->Show(std::string(status.message()), ToastType::kError,
3.5f);
}
}
}
@@ -1306,8 +1301,8 @@ void AgentEditor::DrawAgentBuilderPanel() {
toast_manager_->Show("Builder blueprint loaded", ToastType::kSuccess,
2.0f);
} else {
toast_manager_->Show(std::string(status.message()),
ToastType::kError, 3.5f);
toast_manager_->Show(std::string(status.message()), ToastType::kError,
3.5f);
}
}
}
@@ -1337,9 +1332,9 @@ absl::Status AgentEditor::SaveBuilderBlueprint(
};
json["stages"] = nlohmann::json::array();
for (const auto& stage : builder_state_.stages) {
json["stages"].push_back(
{{"name", stage.name}, {"summary", stage.summary},
{"completed", stage.completed}});
json["stages"].push_back({{"name", stage.name},
{"summary", stage.summary},
{"completed", stage.completed}});
}
std::error_code ec;

81
src/app/editor/agent/agent_editor.h
View File

@@ -1,10 +1,10 @@
#ifndef YAZE_APP_EDITOR_AGENT_AGENT_EDITOR_H_
#define YAZE_APP_EDITOR_AGENT_AGENT_EDITOR_H_
#include <filesystem>
#include <memory>
#include <optional>
#include <string>
#include <filesystem>
#include <vector>
#include "absl/status/status.h"
@@ -57,20 +57,30 @@ class AgentEditor : public Editor {
absl::Status Load() override;
absl::Status Save() override;
absl::Status Update() override;
absl::Status Cut() override { return absl::UnimplementedError("Not applicable"); }
absl::Status Copy() override { return absl::UnimplementedError("Not applicable"); }
absl::Status Paste() override { return absl::UnimplementedError("Not applicable"); }
absl::Status Undo() override { return absl::UnimplementedError("Not applicable"); }
absl::Status Redo() override { return absl::UnimplementedError("Not applicable"); }
absl::Status Find() override { return absl::UnimplementedError("Not applicable"); }
absl::Status Cut() override {
return absl::UnimplementedError("Not applicable");
}
absl::Status Copy() override {
return absl::UnimplementedError("Not applicable");
}
absl::Status Paste() override {
return absl::UnimplementedError("Not applicable");
}
absl::Status Undo() override {
return absl::UnimplementedError("Not applicable");
}
absl::Status Redo() override {
return absl::UnimplementedError("Not applicable");
}
absl::Status Find() override {
return absl::UnimplementedError("Not applicable");
}
// Initialization with dependencies
void InitializeWithDependencies(ToastManager* toast_manager,
ProposalDrawer* proposal_drawer,
Rom* rom);
void InitializeWithDependencies(ToastManager* toast_manager,
ProposalDrawer* proposal_drawer, Rom* rom);
void SetRomContext(Rom* rom);
// Main rendering (called by Update())
void DrawDashboard();
@@ -129,13 +139,13 @@ class AgentEditor : public Editor {
std::string blueprint_path;
bool ready_for_e2e = false;
};
// Retro hacker animation state
float pulse_animation_ = 0.0f;
float scanline_offset_ = 0.0f;
float glitch_timer_ = 0.0f;
int blink_counter_ = 0;
AgentConfig GetCurrentConfig() const;
void ApplyConfig(const AgentConfig& config);
@@ -146,7 +156,8 @@ class AgentEditor : public Editor {
std::vector<BotProfile> GetAllProfiles() const;
BotProfile GetCurrentProfile() const { return current_profile_; }
void SetCurrentProfile(const BotProfile& profile);
absl::Status ExportProfile(const BotProfile& profile, const std::filesystem::path& path);
absl::Status ExportProfile(const BotProfile& profile,
const std::filesystem::path& path);
absl::Status ImportProfile(const std::filesystem::path& path);
// Chat widget access (for EditorManager)
@@ -155,8 +166,8 @@ class AgentEditor : public Editor {
void SetChatActive(bool active);
void ToggleChat();
void OpenChatWindow();
// Collaboration and session management
// Collaboration and session management
enum class CollaborationMode {
kLocal, // Filesystem-based collaboration
kNetwork // WebSocket-based collaboration
@@ -168,25 +179,23 @@ class AgentEditor : public Editor {
std::vector<std::string> participants;
};
absl::StatusOr<SessionInfo> HostSession(const std::string& session_name,
CollaborationMode mode = CollaborationMode::kLocal);
absl::StatusOr<SessionInfo> JoinSession(const std::string& session_code,
CollaborationMode mode = CollaborationMode::kLocal);
absl::StatusOr<SessionInfo> HostSession(
const std::string& session_name,
CollaborationMode mode = CollaborationMode::kLocal);
absl::StatusOr<SessionInfo> JoinSession(
const std::string& session_code,
CollaborationMode mode = CollaborationMode::kLocal);
absl::Status LeaveSession();
absl::StatusOr<SessionInfo> RefreshSession();
struct CaptureConfig {
enum class CaptureMode {
kFullWindow,
kActiveEditor,
kSpecificWindow
};
enum class CaptureMode { kFullWindow, kActiveEditor, kSpecificWindow };
CaptureMode mode = CaptureMode::kActiveEditor;
std::string specific_window_name;
};
absl::Status CaptureSnapshot(std::filesystem::path* output_path,
const CaptureConfig& config);
const CaptureConfig& config);
absl::Status SendToGemini(const std::filesystem::path& image_path,
const std::string& prompt);
@@ -201,9 +210,13 @@ class AgentEditor : public Editor {
std::optional<SessionInfo> GetCurrentSession() const;
// Access to underlying components
AgentCollaborationCoordinator* GetLocalCoordinator() { return local_coordinator_.get(); }
AgentCollaborationCoordinator* GetLocalCoordinator() {
return local_coordinator_.get();
}
#ifdef YAZE_WITH_GRPC
NetworkCollaborationCoordinator* GetNetworkCoordinator() { return network_coordinator_.get(); }
NetworkCollaborationCoordinator* GetNetworkCoordinator() {
return network_coordinator_.get();
}
#endif
private:
@@ -244,12 +257,12 @@ class AgentEditor : public Editor {
// Configuration state (legacy)
AgentConfig current_config_;
// Bot Profile System
BotProfile current_profile_;
std::vector<BotProfile> loaded_profiles_;
AgentBuilderState builder_state_;
// System Prompt Editor
std::unique_ptr<TextEditor> prompt_editor_;
std::unique_ptr<TextEditor> common_tiles_editor_;
@@ -257,14 +270,14 @@ class AgentEditor : public Editor {
bool common_tiles_initialized_ = false;
std::string active_prompt_file_ = "system_prompt_v3.txt";
char new_prompt_name_[128] = {};
// Collaboration state
CollaborationMode current_mode_ = CollaborationMode::kLocal;
bool in_session_ = false;
std::string current_session_id_;
std::string current_session_name_;
std::vector<std::string> current_participants_;
// UI state
bool show_advanced_settings_ = false;
bool show_prompt_editor_ = false;
@@ -272,7 +285,7 @@ class AgentEditor : public Editor {
bool show_chat_history_ = false;
bool show_metrics_dashboard_ = false;
int selected_tab_ = 0; // 0=Config, 1=Prompts, 2=Bots, 3=History, 4=Metrics
// Chat history viewer state
std::vector<cli::agent::ChatMessage> cached_history_;
bool history_needs_refresh_ = true;

120
src/app/editor/agent/agent_ui_theme.cc
View File

@@ -1,7 +1,7 @@
#include "app/editor/agent/agent_ui_theme.h"
#include "app/gui/core/theme_manager.h"
#include "app/gui/core/color.h"
#include "app/gui/core/theme_manager.h"
#include "imgui/imgui.h"
namespace yaze {
@@ -14,70 +14,61 @@ static bool g_theme_initialized = false;
AgentUITheme AgentUITheme::FromCurrentTheme() {
AgentUITheme theme;
const auto& current = gui::ThemeManager::Get().GetCurrentTheme();
// Message colors - derived from theme primary/secondary
theme.user_message_color = ImVec4(
current.primary.red * 1.1f,
current.primary.green * 0.95f,
current.primary.blue * 0.6f,
1.0f
);
theme.agent_message_color = ImVec4(
current.secondary.red * 0.9f,
current.secondary.green * 1.3f,
current.secondary.blue * 1.0f,
1.0f
);
theme.system_message_color = ImVec4(
current.info.red,
current.info.green,
current.info.blue,
1.0f
);
theme.user_message_color =
ImVec4(current.primary.red * 1.1f, current.primary.green * 0.95f,
current.primary.blue * 0.6f, 1.0f);
theme.agent_message_color =
ImVec4(current.secondary.red * 0.9f, current.secondary.green * 1.3f,
current.secondary.blue * 1.0f, 1.0f);
theme.system_message_color =
ImVec4(current.info.red, current.info.green, current.info.blue, 1.0f);
// Content colors
theme.json_text_color = ConvertColorToImVec4(current.text_secondary);
theme.command_text_color = ConvertColorToImVec4(current.accent);
theme.code_bg_color = ConvertColorToImVec4(current.code_background);
theme.text_secondary_color = ConvertColorToImVec4(current.text_secondary);
// UI element colors
theme.panel_bg_color = ImVec4(0.12f, 0.14f, 0.18f, 0.95f);
theme.panel_bg_darker = ImVec4(0.08f, 0.10f, 0.14f, 0.95f);
theme.panel_border_color = ConvertColorToImVec4(current.border);
theme.accent_color = ConvertColorToImVec4(current.accent);
// Status colors
theme.status_active = ConvertColorToImVec4(current.success);
theme.status_inactive = ImVec4(0.6f, 0.6f, 0.6f, 1.0f);
theme.status_success = ConvertColorToImVec4(current.success);
theme.status_warning = ConvertColorToImVec4(current.warning);
theme.status_error = ConvertColorToImVec4(current.error);
// Provider-specific colors
theme.provider_ollama = ImVec4(0.2f, 0.8f, 0.4f, 1.0f); // Green
theme.provider_gemini = ImVec4(0.196f, 0.6f, 0.8f, 1.0f); // Blue
theme.provider_mock = ImVec4(0.6f, 0.6f, 0.6f, 1.0f); // Gray
theme.provider_ollama = ImVec4(0.2f, 0.8f, 0.4f, 1.0f); // Green
theme.provider_gemini = ImVec4(0.196f, 0.6f, 0.8f, 1.0f); // Blue
theme.provider_mock = ImVec4(0.6f, 0.6f, 0.6f, 1.0f); // Gray
// Collaboration colors
theme.collaboration_active = ImVec4(0.133f, 0.545f, 0.133f, 1.0f); // Forest green
theme.collaboration_active =
ImVec4(0.133f, 0.545f, 0.133f, 1.0f); // Forest green
theme.collaboration_inactive = ImVec4(0.6f, 0.6f, 0.6f, 1.0f);
// Proposal colors
theme.proposal_panel_bg = ImVec4(0.20f, 0.35f, 0.20f, 0.35f);
theme.proposal_accent = ImVec4(0.8f, 1.0f, 0.8f, 1.0f);
// Button colors
theme.button_copy = ImVec4(0.3f, 0.3f, 0.4f, 0.6f);
theme.button_copy_hover = ImVec4(0.4f, 0.4f, 0.5f, 0.8f);
// Gradient colors
theme.gradient_top = ImVec4(0.18f, 0.22f, 0.28f, 1.0f);
theme.gradient_bottom = ImVec4(0.12f, 0.16f, 0.22f, 1.0f);
return theme;
}
@@ -107,7 +98,8 @@ void PopPanelStyle() {
ImGui::PopStyleColor();
}
void RenderSectionHeader(const char* icon, const char* label, const ImVec4& color) {
void RenderSectionHeader(const char* icon, const char* label,
const ImVec4& color) {
ImGui::TextColored(color, "%s %s", icon, label);
ImGui::Separator();
}
@@ -115,23 +107,23 @@ void RenderSectionHeader(const char* icon, const char* label, const ImVec4& colo
void RenderStatusIndicator(const char* label, bool active) {
const auto& theme = GetTheme();
ImVec4 color = active ? theme.status_active : theme.status_inactive;
ImDrawList* draw_list = ImGui::GetWindowDrawList();
ImVec2 pos = ImGui::GetCursorScreenPos();
float radius = 4.0f;
pos.x += radius + 2;
pos.y += ImGui::GetTextLineHeight() * 0.5f;
draw_list->AddCircleFilled(pos, radius, ImGui::GetColorU32(color));
ImGui::SetCursorPosX(ImGui::GetCursorPosX() + radius * 2 + 8);
ImGui::Text("%s", label);
}
void RenderProviderBadge(const char* provider) {
const auto& theme = GetTheme();
ImVec4 badge_color;
if (strcmp(provider, "ollama") == 0) {
badge_color = theme.provider_ollama;
@@ -140,7 +132,7 @@ void RenderProviderBadge(const char* provider) {
} else {
badge_color = theme.provider_mock;
}
ImGui::PushStyleColor(ImGuiCol_Button, badge_color);
ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 12.0f);
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(8, 4));
@@ -151,16 +143,26 @@ void RenderProviderBadge(const char* provider) {
void StatusBadge(const char* text, ButtonColor color) {
const auto& theme = GetTheme();
ImVec4 badge_color;
switch (color) {
case ButtonColor::Success: badge_color = theme.status_success; break;
case ButtonColor::Warning: badge_color = theme.status_warning; break;
case ButtonColor::Error: badge_color = theme.status_error; break;
case ButtonColor::Info: badge_color = theme.accent_color; break;
default: badge_color = theme.status_inactive; break;
case ButtonColor::Success:
badge_color = theme.status_success;
break;
case ButtonColor::Warning:
badge_color = theme.status_warning;
break;
case ButtonColor::Error:
badge_color = theme.status_error;
break;
case ButtonColor::Info:
badge_color = theme.accent_color;
break;
default:
badge_color = theme.status_inactive;
break;
}
ImGui::PushStyleColor(ImGuiCol_Button, badge_color);
ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 10.0f);
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(6, 2));
@@ -180,27 +182,29 @@ void HorizontalSpacing(float amount) {
bool StyledButton(const char* label, const ImVec4& color, const ImVec2& size) {
ImGui::PushStyleColor(ImGuiCol_Button, color);
ImGui::PushStyleColor(ImGuiCol_ButtonHovered,
ImVec4(color.x * 1.2f, color.y * 1.2f, color.z * 1.2f, color.w));
ImGui::PushStyleColor(ImGuiCol_ButtonActive,
ImVec4(color.x * 0.8f, color.y * 0.8f, color.z * 0.8f, color.w));
ImGui::PushStyleColor(
ImGuiCol_ButtonHovered,
ImVec4(color.x * 1.2f, color.y * 1.2f, color.z * 1.2f, color.w));
ImGui::PushStyleColor(
ImGuiCol_ButtonActive,
ImVec4(color.x * 0.8f, color.y * 0.8f, color.z * 0.8f, color.w));
ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 4.0f);
bool result = ImGui::Button(label, size);
ImGui::PopStyleVar();
ImGui::PopStyleColor(3);
return result;
}
bool IconButton(const char* icon, const char* tooltip) {
bool result = ImGui::SmallButton(icon);
if (tooltip && ImGui::IsItemHovered()) {
ImGui::SetTooltip("%s", tooltip);
}
return result;
}

28
src/app/editor/agent/agent_ui_theme.h
View File

@@ -1,9 +1,9 @@
#ifndef YAZE_APP_EDITOR_AGENT_AGENT_UI_THEME_H
#define YAZE_APP_EDITOR_AGENT_AGENT_UI_THEME_H
#include "imgui/imgui.h"
#include "app/gui/core/theme_manager.h"
#include "app/gui/core/color.h"
#include "app/gui/core/theme_manager.h"
#include "imgui/imgui.h"
namespace yaze {
namespace editor {
@@ -22,46 +22,46 @@ struct AgentUITheme {
ImVec4 system_message_color;
ImVec4 text_secondary_color;
// Content colors
ImVec4 json_text_color;
ImVec4 command_text_color;
ImVec4 code_bg_color;
// UI element colors
ImVec4 panel_bg_color;
ImVec4 panel_bg_darker;
ImVec4 panel_border_color;
ImVec4 accent_color;
// Status colors
ImVec4 status_active;
ImVec4 status_inactive;
ImVec4 status_success;
ImVec4 status_warning;
ImVec4 status_error;
// Provider colors
ImVec4 provider_ollama;
ImVec4 provider_gemini;
ImVec4 provider_mock;
// Collaboration colors
ImVec4 collaboration_active;
ImVec4 collaboration_inactive;
// Proposal colors
ImVec4 proposal_panel_bg;
ImVec4 proposal_accent;
// Button colors
ImVec4 button_copy;
ImVec4 button_copy_hover;
// Gradient colors
ImVec4 gradient_top;
ImVec4 gradient_bottom;
// Initialize from current theme
static AgentUITheme FromCurrentTheme();
};
@@ -79,7 +79,8 @@ void RefreshTheme();
void PushPanelStyle();
void PopPanelStyle();
void RenderSectionHeader(const char* icon, const char* label, const ImVec4& color);
void RenderSectionHeader(const char* icon, const char* label,
const ImVec4& color);
void RenderStatusIndicator(const char* label, bool active);
void RenderProviderBadge(const char* provider);
@@ -92,7 +93,8 @@ void VerticalSpacing(float amount = 8.0f);
void HorizontalSpacing(float amount = 8.0f);
// Common button styles
bool StyledButton(const char* label, const ImVec4& color, const ImVec2& size = ImVec2(0, 0));
bool StyledButton(const char* label, const ImVec4& color,
const ImVec2& size = ImVec2(0, 0));
bool IconButton(const char* icon, const char* tooltip = nullptr);
} // namespace AgentUI

4
src/app/editor/agent/automation_bridge.cc
View File

@@ -26,8 +26,8 @@ void AutomationBridge::OnHarnessTestUpdated(
telemetry.message = execution.error_message;
telemetry.updated_at = (execution.completed_at == absl::InfiniteFuture() ||
execution.completed_at == absl::InfinitePast())
? absl::Now()
: execution.completed_at;
? absl::Now()
: execution.completed_at;
chat_widget_->UpdateHarnessTelemetry(telemetry);
}

251
src/app/editor/agent/network_collaboration_coordinator.cc
View File

@@ -34,15 +34,17 @@ class WebSocketClient {
client_ = std::make_unique<httplib::Client>(host_.c_str(), port_);
client_->set_connection_timeout(5); // 5 seconds
client_->set_read_timeout(30); // 30 seconds
// For now, mark as connected and use HTTP polling fallback
// A full WebSocket implementation would do the upgrade handshake here
connected_ = true;
std::cout << "✓ Connected to collaboration server at " << host_ << ":" << port_ << std::endl;
std::cout << "✓ Connected to collaboration server at " << host_ << ":"
<< port_ << std::endl;
return true;
} catch (const std::exception& e) {
std::cerr << "Failed to connect to " << host_ << ":" << port_ << ": " << e.what() << std::endl;
std::cerr << "Failed to connect to " << host_ << ":" << port_ << ": "
<< e.what() << std::endl;
return false;
}
}
@@ -53,8 +55,9 @@ class WebSocketClient {
}
bool Send(const std::string& message) {
if (!connected_ || !client_) return false;
if (!connected_ || !client_)
return false;
// For HTTP fallback: POST message to server
// A full WebSocket would send WebSocket frames
auto res = client_->Post("/message", message, "application/json");
@@ -62,8 +65,9 @@ class WebSocketClient {
}
std::string Receive() {
if (!connected_ || !client_) return "";
if (!connected_ || !client_)
return "";
// For HTTP fallback: Poll for messages
// A full WebSocket would read frames from the socket
auto res = client_->Get("/poll");
@@ -108,7 +112,7 @@ void NetworkCollaborationCoordinator::ConnectWebSocket() {
// Parse URL (simple implementation - assumes ws://host:port format)
std::string host = "localhost";
int port = 8765;
// Extract from server_url_ if needed
if (server_url_.find("ws://") == 0) {
std::string url_part = server_url_.substr(5); // Skip "ws://"
@@ -122,10 +126,10 @@ void NetworkCollaborationCoordinator::ConnectWebSocket() {
}
ws_client_ = std::make_unique<detail::WebSocketClient>(host, port);
if (ws_client_->Connect("/")) {
connected_ = true;
// Start receive thread
should_stop_ = false;
receive_thread_ = std::make_unique<std::thread>(
@@ -147,26 +151,22 @@ NetworkCollaborationCoordinator::HostSession(const std::string& session_name,
const std::string& rom_hash,
bool ai_enabled) {
if (!connected_) {
return absl::FailedPreconditionError("Not connected to collaboration server");
return absl::FailedPreconditionError(
"Not connected to collaboration server");
}
username_ = username;
// Build host_session message with v2.0 fields
Json payload = {
{"session_name", session_name},
{"username", username},
{"ai_enabled", ai_enabled}
};
Json payload = {{"session_name", session_name},
{"username", username},
{"ai_enabled", ai_enabled}};
if (!rom_hash.empty()) {
payload["rom_hash"] = rom_hash;
}
Json message = {
{"type", "host_session"},
{"payload", payload}
};
Json message = {{"type", "host_session"}, {"payload", payload}};
SendWebSocketMessage("host_session", message["payload"].dump());
@@ -176,7 +176,7 @@ NetworkCollaborationCoordinator::HostSession(const std::string& session_name,
info.session_name = session_name;
info.session_code = "PENDING"; // Will be updated from server response
info.participants = {username};
in_session_ = true;
session_name_ = session_name;
@@ -187,7 +187,8 @@ absl::StatusOr<NetworkCollaborationCoordinator::SessionInfo>
NetworkCollaborationCoordinator::JoinSession(const std::string& session_code,
const std::string& username) {
if (!connected_) {
return absl::FailedPreconditionError("Not connected to collaboration server");
return absl::FailedPreconditionError(
"Not connected to collaboration server");
}
username_ = username;
@@ -196,18 +197,14 @@ NetworkCollaborationCoordinator::JoinSession(const std::string& session_code,
// Build join_session message
Json message = {
{"type", "join_session"},
{"payload", {
{"session_code", session_code},
{"username", username}
}}
};
{"payload", {{"session_code", session_code}, {"username", username}}}};
SendWebSocketMessage("join_session", message["payload"].dump());
// TODO: Wait for session_joined response and parse it
SessionInfo info;
info.session_code = session_code;
in_session_ = true;
return info;
@@ -237,19 +234,13 @@ absl::Status NetworkCollaborationCoordinator::SendChatMessage(
}
Json payload = {
{"sender", sender},
{"message", message},
{"message_type", message_type}
};
{"sender", sender}, {"message", message}, {"message_type", message_type}};
if (!metadata.empty()) {
payload["metadata"] = Json::parse(metadata);
}
Json msg = {
{"type", "chat_message"},
{"payload", payload}
};
Json msg = {{"type", "chat_message"}, {"payload", payload}};
SendWebSocketMessage("chat_message", msg["payload"].dump());
return absl::OkStatus();
@@ -264,12 +255,8 @@ absl::Status NetworkCollaborationCoordinator::SendRomSync(
Json msg = {
{"type", "rom_sync"},
{"payload", {
{"sender", sender},
{"diff_data", diff_data},
{"rom_hash", rom_hash}
}}
};
{"payload",
{{"sender", sender}, {"diff_data", diff_data}, {"rom_hash", rom_hash}}}};
SendWebSocketMessage("rom_sync", msg["payload"].dump());
return absl::OkStatus();
@@ -282,14 +269,11 @@ absl::Status NetworkCollaborationCoordinator::SendSnapshot(
return absl::FailedPreconditionError("Not in a session");
}
Json msg = {
{"type", "snapshot_share"},
{"payload", {
{"sender", sender},
{"snapshot_data", snapshot_data},
{"snapshot_type", snapshot_type}
}}
};
Json msg = {{"type", "snapshot_share"},
{"payload",
{{"sender", sender},
{"snapshot_data", snapshot_data},
{"snapshot_type", snapshot_type}}}};
SendWebSocketMessage("snapshot_share", msg["payload"].dump());
return absl::OkStatus();
@@ -301,13 +285,10 @@ absl::Status NetworkCollaborationCoordinator::SendProposal(
return absl::FailedPreconditionError("Not in a session");
}
Json msg = {
{"type", "proposal_share"},
{"payload", {
{"sender", sender},
{"proposal_data", Json::parse(proposal_data_json)}
}}
};
Json msg = {{"type", "proposal_share"},
{"payload",
{{"sender", sender},
{"proposal_data", Json::parse(proposal_data_json)}}}};
SendWebSocketMessage("proposal_share", msg["payload"].dump());
return absl::OkStatus();
@@ -319,13 +300,8 @@ absl::Status NetworkCollaborationCoordinator::UpdateProposal(
return absl::FailedPreconditionError("Not in a session");
}
Json msg = {
{"type", "proposal_update"},
{"payload", {
{"proposal_id", proposal_id},
{"status", status}
}}
};
Json msg = {{"type", "proposal_update"},
{"payload", {{"proposal_id", proposal_id}, {"status", status}}}};
SendWebSocketMessage("proposal_update", msg["payload"].dump());
return absl::OkStatus();
@@ -337,13 +313,8 @@ absl::Status NetworkCollaborationCoordinator::SendAIQuery(
return absl::FailedPreconditionError("Not in a session");
}
Json msg = {
{"type", "ai_query"},
{"payload", {
{"username", username},
{"query", query}
}}
};
Json msg = {{"type", "ai_query"},
{"payload", {{"username", username}, {"query", query}}}};
SendWebSocketMessage("ai_query", msg["payload"].dump());
return absl::OkStatus();
@@ -353,7 +324,8 @@ bool NetworkCollaborationCoordinator::IsConnected() const {
return connected_;
}
void NetworkCollaborationCoordinator::SetMessageCallback(MessageCallback callback) {
void NetworkCollaborationCoordinator::SetMessageCallback(
MessageCallback callback) {
absl::MutexLock lock(&mutex_);
message_callback_ = std::move(callback);
}
@@ -369,27 +341,32 @@ void NetworkCollaborationCoordinator::SetErrorCallback(ErrorCallback callback) {
error_callback_ = std::move(callback);
}
void NetworkCollaborationCoordinator::SetRomSyncCallback(RomSyncCallback callback) {
void NetworkCollaborationCoordinator::SetRomSyncCallback(
RomSyncCallback callback) {
absl::MutexLock lock(&mutex_);
rom_sync_callback_ = std::move(callback);
}
void NetworkCollaborationCoordinator::SetSnapshotCallback(SnapshotCallback callback) {
void NetworkCollaborationCoordinator::SetSnapshotCallback(
SnapshotCallback callback) {
absl::MutexLock lock(&mutex_);
snapshot_callback_ = std::move(callback);
}
void NetworkCollaborationCoordinator::SetProposalCallback(ProposalCallback callback) {
void NetworkCollaborationCoordinator::SetProposalCallback(
ProposalCallback callback) {
absl::MutexLock lock(&mutex_);
proposal_callback_ = std::move(callback);
}
void NetworkCollaborationCoordinator::SetProposalUpdateCallback(ProposalUpdateCallback callback) {
void NetworkCollaborationCoordinator::SetProposalUpdateCallback(
ProposalUpdateCallback callback) {
absl::MutexLock lock(&mutex_);
proposal_update_callback_ = std::move(callback);
}
void NetworkCollaborationCoordinator::SetAIResponseCallback(AIResponseCallback callback) {
void NetworkCollaborationCoordinator::SetAIResponseCallback(
AIResponseCallback callback) {
absl::MutexLock lock(&mutex_);
ai_response_callback_ = std::move(callback);
}
@@ -400,10 +377,7 @@ void NetworkCollaborationCoordinator::SendWebSocketMessage(
return;
}
Json message = {
{"type", type},
{"payload", Json::parse(payload_json)}
};
Json message = {{"type", type}, {"payload", Json::parse(payload_json)}};
ws_client_->Send(message.dump());
}
@@ -419,7 +393,7 @@ void NetworkCollaborationCoordinator::HandleWebSocketMessage(
session_id_ = payload["session_id"];
session_code_ = payload["session_code"];
session_name_ = payload["session_name"];
if (payload.contains("participants")) {
absl::MutexLock lock(&mutex_);
if (participant_callback_) {
@@ -432,7 +406,7 @@ void NetworkCollaborationCoordinator::HandleWebSocketMessage(
session_id_ = payload["session_id"];
session_code_ = payload["session_code"];
session_name_ = payload["session_name"];
if (payload.contains("participants")) {
absl::MutexLock lock(&mutex_);
if (participant_callback_) {
@@ -450,7 +424,7 @@ void NetworkCollaborationCoordinator::HandleWebSocketMessage(
if (payload.contains("metadata") && !payload["metadata"].is_null()) {
msg.metadata = payload["metadata"].dump();
}
absl::MutexLock lock(&mutex_);
if (message_callback_) {
message_callback_(msg);
@@ -463,7 +437,7 @@ void NetworkCollaborationCoordinator::HandleWebSocketMessage(
sync.diff_data = payload["diff_data"];
sync.rom_hash = payload["rom_hash"];
sync.timestamp = payload["timestamp"];
absl::MutexLock lock(&mutex_);
if (rom_sync_callback_) {
rom_sync_callback_(sync);
@@ -476,7 +450,7 @@ void NetworkCollaborationCoordinator::HandleWebSocketMessage(
snapshot.snapshot_data = payload["snapshot_data"];
snapshot.snapshot_type = payload["snapshot_type"];
snapshot.timestamp = payload["timestamp"];
absl::MutexLock lock(&mutex_);
if (snapshot_callback_) {
snapshot_callback_(snapshot);
@@ -489,7 +463,7 @@ void NetworkCollaborationCoordinator::HandleWebSocketMessage(
proposal.proposal_data = payload["proposal_data"].dump();
proposal.status = payload["status"];
proposal.timestamp = payload["timestamp"];
absl::MutexLock lock(&mutex_);
if (proposal_callback_) {
proposal_callback_(proposal);
@@ -498,7 +472,7 @@ void NetworkCollaborationCoordinator::HandleWebSocketMessage(
Json payload = message["payload"];
std::string proposal_id = payload["proposal_id"];
std::string status = payload["status"];
absl::MutexLock lock(&mutex_);
if (proposal_update_callback_) {
proposal_update_callback_(proposal_id, status);
@@ -511,20 +485,21 @@ void NetworkCollaborationCoordinator::HandleWebSocketMessage(
response.query = payload["query"];
response.response = payload["response"];
response.timestamp = payload["timestamp"];
absl::MutexLock lock(&mutex_);
if (ai_response_callback_) {
ai_response_callback_(response);
}
} else if (type == "server_shutdown") {
Json payload = message["payload"];
std::string error = "Server shutdown: " + payload["message"].get<std::string>();
std::string error =
"Server shutdown: " + payload["message"].get<std::string>();
absl::MutexLock lock(&mutex_);
if (error_callback_) {
error_callback_(error);
}
// Disconnect
connected_ = false;
} else if (type == "participant_joined" || type == "participant_left") {
@@ -539,7 +514,7 @@ void NetworkCollaborationCoordinator::HandleWebSocketMessage(
} else if (type == "error") {
Json payload = message["payload"];
std::string error = payload["error"];
absl::MutexLock lock(&mutex_);
if (error_callback_) {
error_callback_(error);
@@ -552,13 +527,14 @@ void NetworkCollaborationCoordinator::HandleWebSocketMessage(
void NetworkCollaborationCoordinator::WebSocketReceiveLoop() {
while (!should_stop_ && connected_) {
if (!ws_client_) break;
if (!ws_client_)
break;
std::string message = ws_client_->Receive();
if (!message.empty()) {
HandleWebSocketMessage(message);
}
// Small sleep to avoid busy-waiting
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
@@ -568,69 +544,92 @@ void NetworkCollaborationCoordinator::WebSocketReceiveLoop() {
// Stub implementations when JSON is not available
NetworkCollaborationCoordinator::NetworkCollaborationCoordinator(
const std::string& server_url) : server_url_(server_url) {}
const std::string& server_url)
: server_url_(server_url) {}
NetworkCollaborationCoordinator::~NetworkCollaborationCoordinator() = default;
absl::StatusOr<NetworkCollaborationCoordinator::SessionInfo>
NetworkCollaborationCoordinator::HostSession(const std::string&, const std::string&,
NetworkCollaborationCoordinator::HostSession(const std::string&,
const std::string&,
const std::string&, bool) {
return absl::UnimplementedError("Network collaboration requires JSON support");
return absl::UnimplementedError(
"Network collaboration requires JSON support");
}
absl::StatusOr<NetworkCollaborationCoordinator::SessionInfo>
NetworkCollaborationCoordinator::JoinSession(const std::string&, const std::string&) {
return absl::UnimplementedError("Network collaboration requires JSON support");
NetworkCollaborationCoordinator::JoinSession(const std::string&,
const std::string&) {
return absl::UnimplementedError(
"Network collaboration requires JSON support");
}
absl::Status NetworkCollaborationCoordinator::LeaveSession() {
return absl::UnimplementedError("Network collaboration requires JSON support");
return absl::UnimplementedError(
"Network collaboration requires JSON support");
}
absl::Status NetworkCollaborationCoordinator::SendChatMessage(
const std::string&, const std::string&, const std::string&, const std::string&) {
return absl::UnimplementedError("Network collaboration requires JSON support");
const std::string&, const std::string&, const std::string&,
const std::string&) {
return absl::UnimplementedError(
"Network collaboration requires JSON support");
}
absl::Status NetworkCollaborationCoordinator::SendRomSync(
const std::string&, const std::string&, const std::string&) {
return absl::UnimplementedError("Network collaboration requires JSON support");
absl::Status NetworkCollaborationCoordinator::SendRomSync(const std::string&,
const std::string&,
const std::string&) {
return absl::UnimplementedError(
"Network collaboration requires JSON support");
}
absl::Status NetworkCollaborationCoordinator::SendSnapshot(
const std::string&, const std::string&, const std::string&) {
return absl::UnimplementedError("Network collaboration requires JSON support");
absl::Status NetworkCollaborationCoordinator::SendSnapshot(const std::string&,
const std::string&,
const std::string&) {
return absl::UnimplementedError(
"Network collaboration requires JSON support");
}
absl::Status NetworkCollaborationCoordinator::SendProposal(
const std::string&, const std::string&) {
return absl::UnimplementedError("Network collaboration requires JSON support");
absl::Status NetworkCollaborationCoordinator::SendProposal(const std::string&,
const std::string&) {
return absl::UnimplementedError(
"Network collaboration requires JSON support");
}
absl::Status NetworkCollaborationCoordinator::UpdateProposal(
const std::string&, const std::string&) {
return absl::UnimplementedError("Network collaboration requires JSON support");
return absl::UnimplementedError(
"Network collaboration requires JSON support");
}
absl::Status NetworkCollaborationCoordinator::SendAIQuery(
const std::string&, const std::string&) {
return absl::UnimplementedError("Network collaboration requires JSON support");
absl::Status NetworkCollaborationCoordinator::SendAIQuery(const std::string&,
const std::string&) {
return absl::UnimplementedError(
"Network collaboration requires JSON support");
}
bool NetworkCollaborationCoordinator::IsConnected() const { return false; }
bool NetworkCollaborationCoordinator::IsConnected() const {
return false;
}
void NetworkCollaborationCoordinator::SetMessageCallback(MessageCallback) {}
void NetworkCollaborationCoordinator::SetParticipantCallback(ParticipantCallback) {}
void NetworkCollaborationCoordinator::SetParticipantCallback(
ParticipantCallback) {}
void NetworkCollaborationCoordinator::SetErrorCallback(ErrorCallback) {}
void NetworkCollaborationCoordinator::SetRomSyncCallback(RomSyncCallback) {}
void NetworkCollaborationCoordinator::SetSnapshotCallback(SnapshotCallback) {}
void NetworkCollaborationCoordinator::SetProposalCallback(ProposalCallback) {}
void NetworkCollaborationCoordinator::SetProposalUpdateCallback(ProposalUpdateCallback) {}
void NetworkCollaborationCoordinator::SetAIResponseCallback(AIResponseCallback) {}
void NetworkCollaborationCoordinator::SetProposalUpdateCallback(
ProposalUpdateCallback) {}
void NetworkCollaborationCoordinator::SetAIResponseCallback(
AIResponseCallback) {}
void NetworkCollaborationCoordinator::ConnectWebSocket() {}
void NetworkCollaborationCoordinator::DisconnectWebSocket() {}
void NetworkCollaborationCoordinator::SendWebSocketMessage(const std::string&, const std::string&) {}
void NetworkCollaborationCoordinator::HandleWebSocketMessage(const std::string&) {}
void NetworkCollaborationCoordinator::SendWebSocketMessage(const std::string&,
const std::string&) {
}
void NetworkCollaborationCoordinator::HandleWebSocketMessage(
const std::string&) {}
void NetworkCollaborationCoordinator::WebSocketReceiveLoop() {}
#endif // YAZE_WITH_JSON

45
src/app/editor/agent/network_collaboration_coordinator.h
View File

@@ -74,12 +74,14 @@ class NetworkCollaborationCoordinator {
// Callbacks for handling incoming events
using MessageCallback = std::function<void(const ChatMessage&)>;
using ParticipantCallback = std::function<void(const std::vector<std::string>&)>;
using ParticipantCallback =
std::function<void(const std::vector<std::string>&)>;
using ErrorCallback = std::function<void(const std::string&)>;
using RomSyncCallback = std::function<void(const RomSync&)>;
using SnapshotCallback = std::function<void(const Snapshot&)>;
using ProposalCallback = std::function<void(const Proposal&)>;
using ProposalUpdateCallback = std::function<void(const std::string&, const std::string&)>;
using ProposalUpdateCallback =
std::function<void(const std::string&, const std::string&)>;
using AIResponseCallback = std::function<void(const AIResponse&)>;
explicit NetworkCollaborationCoordinator(const std::string& server_url);
@@ -95,28 +97,28 @@ class NetworkCollaborationCoordinator {
absl::Status LeaveSession();
// Communication methods
absl::Status SendChatMessage(const std::string& sender,
const std::string& message,
const std::string& message_type = "chat",
const std::string& metadata = "");
absl::Status SendChatMessage(const std::string& sender,
const std::string& message,
const std::string& message_type = "chat",
const std::string& metadata = "");
// Advanced features
absl::Status SendRomSync(const std::string& sender,
const std::string& diff_data,
const std::string& rom_hash);
const std::string& diff_data,
const std::string& rom_hash);
absl::Status SendSnapshot(const std::string& sender,
const std::string& snapshot_data,
const std::string& snapshot_type);
const std::string& snapshot_data,
const std::string& snapshot_type);
absl::Status SendProposal(const std::string& sender,
const std::string& proposal_data_json);
const std::string& proposal_data_json);
absl::Status UpdateProposal(const std::string& proposal_id,
const std::string& status);
const std::string& status);
absl::Status SendAIQuery(const std::string& username,
const std::string& query);
const std::string& query);
// Connection status
bool IsConnected() const;
@@ -137,7 +139,8 @@ class NetworkCollaborationCoordinator {
private:
void ConnectWebSocket();
void DisconnectWebSocket();
void SendWebSocketMessage(const std::string& type, const std::string& payload_json);
void SendWebSocketMessage(const std::string& type,
const std::string& payload_json);
void HandleWebSocketMessage(const std::string& message);
void WebSocketReceiveLoop();
@@ -147,12 +150,12 @@ class NetworkCollaborationCoordinator {
std::string session_code_;
std::string session_name_;
bool in_session_ = false;
std::unique_ptr<detail::WebSocketClient> ws_client_;
std::atomic<bool> connected_{false};
std::atomic<bool> should_stop_{false};
std::unique_ptr<std::thread> receive_thread_;
mutable absl::Mutex mutex_;
MessageCallback message_callback_ ABSL_GUARDED_BY(mutex_);
ParticipantCallback participant_callback_ ABSL_GUARDED_BY(mutex_);

151
src/app/editor/code/assembly_editor.cc
View File

@@ -5,12 +5,12 @@
#include <string>
#include <vector>
#include "absl/strings/str_cat.h"
#include "absl/strings/match.h"
#include "util/file_util.h"
#include "absl/strings/str_cat.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/ui_helpers.h"
#include "app/gui/widgets/text_editor.h"
#include "util/file_util.h"
namespace yaze::editor {
@@ -18,7 +18,7 @@ using util::FileDialogWrapper;
namespace {
static const char *const kKeywords[] = {
static const char* const kKeywords[] = {
"ADC", "AND", "ASL", "BCC", "BCS", "BEQ", "BIT", "BMI", "BNE", "BPL",
"BRA", "BRL", "BVC", "BVS", "CLC", "CLD", "CLI", "CLV", "CMP", "CPX",
"CPY", "DEC", "DEX", "DEY", "EOR", "INC", "INX", "INY", "JMP", "JSR",
@@ -29,7 +29,7 @@ static const char *const kKeywords[] = {
"TCS", "TDC", "TRB", "TSB", "TSC", "TSX", "TXA", "TXS", "TXY", "TYA",
"TYX", "WAI", "WDM", "XBA", "XCE", "ORG", "LOROM", "HIROM"};
static const char *const kIdentifiers[] = {
static const char* const kIdentifiers[] = {
"abort", "abs", "acos", "asin", "atan", "atexit",
"atof", "atoi", "atol", "ceil", "clock", "cosh",
"ctime", "div", "exit", "fabs", "floor", "fmod",
@@ -42,9 +42,10 @@ static const char *const kIdentifiers[] = {
TextEditor::LanguageDefinition GetAssemblyLanguageDef() {
TextEditor::LanguageDefinition language_65816;
for (auto &k : kKeywords) language_65816.mKeywords.emplace(k);
for (auto& k : kKeywords)
language_65816.mKeywords.emplace(k);
for (auto &k : kIdentifiers) {
for (auto& k : kIdentifiers) {
TextEditor::Identifier id;
id.mDeclaration = "Built-in function";
language_65816.mIdentifiers.insert(std::make_pair(std::string(k), id));
@@ -175,27 +176,35 @@ FolderItem LoadFolder(const std::string& folder) {
void AssemblyEditor::Initialize() {
text_editor_.SetLanguageDefinition(GetAssemblyLanguageDef());
// Register cards with EditorCardManager
if (!dependencies_.card_registry) return;
if (!dependencies_.card_registry)
return;
auto* card_registry = dependencies_.card_registry;
card_registry->RegisterCard({.card_id = "assembly.editor", .display_name = "Assembly Editor",
.icon = ICON_MD_CODE, .category = "Assembly",
.shortcut_hint = "", .priority = 10});
card_registry->RegisterCard({.card_id = "assembly.file_browser", .display_name = "File Browser",
.icon = ICON_MD_FOLDER_OPEN, .category = "Assembly",
.shortcut_hint = "", .priority = 20});
card_registry->RegisterCard({.card_id = "assembly.editor",
.display_name = "Assembly Editor",
.icon = ICON_MD_CODE,
.category = "Assembly",
.shortcut_hint = "",
.priority = 10});
card_registry->RegisterCard({.card_id = "assembly.file_browser",
.display_name = "File Browser",
.icon = ICON_MD_FOLDER_OPEN,
.category = "Assembly",
.shortcut_hint = "",
.priority = 20});
// Don't show by default - only show when user explicitly opens Assembly Editor
}
absl::Status AssemblyEditor::Load() {
// Register cards with EditorCardRegistry (dependency injection)
// Note: Assembly editor uses dynamic file tabs, so we register the main editor window
if (!dependencies_.card_registry) return absl::OkStatus();
if (!dependencies_.card_registry)
return absl::OkStatus();
auto* card_registry = dependencies_.card_registry;
return absl::OkStatus();
return absl::OkStatus();
}
void AssemblyEditor::OpenFolder(const std::string& folder_path) {
@@ -239,7 +248,8 @@ void AssemblyEditor::UpdateCodeView() {
gui::VerticalSpacing(2.0f);
// Create session-aware card (non-static for multi-session support)
gui::EditorCard file_browser_card(MakeCardTitle("File Browser").c_str(), ICON_MD_FOLDER);
gui::EditorCard file_browser_card(MakeCardTitle("File Browser").c_str(),
ICON_MD_FOLDER);
bool file_browser_open = true;
if (file_browser_card.Begin(&file_browser_open)) {
if (current_folder_.name != "") {
@@ -259,22 +269,22 @@ void AssemblyEditor::UpdateCodeView() {
// Ensure we have a TextEditor instance for this file
if (file_id >= open_files_.size()) {
open_files_.resize(file_id + 1);
open_files_.resize(file_id + 1);
}
if (file_id >= files_.size()) {
// This can happen if a file was closed and its ID is being reused.
// For now, we just skip it.
continue;
// This can happen if a file was closed and its ID is being reused.
// For now, we just skip it.
continue;
}
// Create session-aware card title for each file
std::string card_name = MakeCardTitle(files_[file_id]);
gui::EditorCard file_card(card_name.c_str(), ICON_MD_DESCRIPTION, &open);
if (file_card.Begin()) {
if (ImGui::IsWindowFocused(ImGuiFocusedFlags_RootAndChildWindows)) {
active_file_id_ = file_id;
}
open_files_[file_id].Render(absl::StrCat("##", card_name).c_str());
if (ImGui::IsWindowFocused(ImGuiFocusedFlags_RootAndChildWindows)) {
active_file_id_ = file_id;
}
open_files_[file_id].Render(absl::StrCat("##", card_name).c_str());
}
file_card.End(); // ALWAYS call End after Begin
@@ -286,26 +296,26 @@ void AssemblyEditor::UpdateCodeView() {
}
absl::Status AssemblyEditor::Save() {
if (active_file_id_ != -1 && active_file_id_ < open_files_.size()) {
std::string content = open_files_[active_file_id_].GetText();
util::SaveFile(files_[active_file_id_], content);
return absl::OkStatus();
}
return absl::FailedPreconditionError("No active file to save.");
if (active_file_id_ != -1 && active_file_id_ < open_files_.size()) {
std::string content = open_files_[active_file_id_].GetText();
util::SaveFile(files_[active_file_id_], content);
return absl::OkStatus();
}
return absl::FailedPreconditionError("No active file to save.");
}
void AssemblyEditor::DrawToolset() {
static gui::Toolset toolbar;
toolbar.Begin();
static gui::Toolset toolbar;
toolbar.Begin();
if (toolbar.AddAction(ICON_MD_FOLDER_OPEN, "Open Folder")) {
current_folder_ = LoadFolder(FileDialogWrapper::ShowOpenFolderDialog());
}
if (toolbar.AddAction(ICON_MD_SAVE, "Save File")) {
Save();
}
if (toolbar.AddAction(ICON_MD_FOLDER_OPEN, "Open Folder")) {
current_folder_ = LoadFolder(FileDialogWrapper::ShowOpenFolderDialog());
}
if (toolbar.AddAction(ICON_MD_SAVE, "Save File")) {
Save();
}
toolbar.End();
toolbar.End();
}
void AssemblyEditor::DrawCurrentFolder() {
@@ -358,7 +368,6 @@ void AssemblyEditor::DrawCurrentFolder() {
}
}
void AssemblyEditor::DrawFileMenu() {
if (ImGui::BeginMenu("File")) {
if (ImGui::MenuItem("Open", "Ctrl+O")) {
@@ -398,36 +407,36 @@ void AssemblyEditor::DrawEditMenu() {
}
}
void AssemblyEditor::ChangeActiveFile(const std::string_view &filename) {
// Check if file is already open
for (int i = 0; i < active_files_.Size; ++i) {
int file_id = active_files_[i];
if (files_[file_id] == filename) {
// Optional: Focus window
return;
}
void AssemblyEditor::ChangeActiveFile(const std::string_view& filename) {
// Check if file is already open
for (int i = 0; i < active_files_.Size; ++i) {
int file_id = active_files_[i];
if (files_[file_id] == filename) {
// Optional: Focus window
return;
}
}
// Add new file
int new_file_id = files_.size();
files_.push_back(std::string(filename));
active_files_.push_back(new_file_id);
// Add new file
int new_file_id = files_.size();
files_.push_back(std::string(filename));
active_files_.push_back(new_file_id);
// Resize open_files_ if needed
if (new_file_id >= open_files_.size()) {
open_files_.resize(new_file_id + 1);
}
// Resize open_files_ if needed
if (new_file_id >= open_files_.size()) {
open_files_.resize(new_file_id + 1);
}
// Load file content using utility
std::string content = util::LoadFile(std::string(filename));
if (!content.empty()) {
open_files_[new_file_id].SetText(content);
open_files_[new_file_id].SetLanguageDefinition(GetAssemblyLanguageDef());
open_files_[new_file_id].SetPalette(TextEditor::GetDarkPalette());
} else {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error opening file: %s\n",
std::string(filename).c_str());
}
// Load file content using utility
std::string content = util::LoadFile(std::string(filename));
if (!content.empty()) {
open_files_[new_file_id].SetText(content);
open_files_[new_file_id].SetLanguageDefinition(GetAssemblyLanguageDef());
open_files_[new_file_id].SetPalette(TextEditor::GetDarkPalette());
} else {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error opening file: %s\n",
std::string(filename).c_str());
}
}
absl::Status AssemblyEditor::Cut() {
@@ -455,6 +464,8 @@ absl::Status AssemblyEditor::Redo() {
return absl::OkStatus();
}
absl::Status AssemblyEditor::Update() { return absl::OkStatus(); }
absl::Status AssemblyEditor::Update() {
return absl::OkStatus();
}
} // namespace yaze::editor

8
src/app/editor/code/assembly_editor.h
View File

@@ -6,9 +6,9 @@
#include "absl/container/flat_hash_map.h"
#include "app/editor/editor.h"
#include "app/gui/widgets/text_editor.h"
#include "app/gui/app/editor_layout.h"
#include "app/gui/core/style.h"
#include "app/gui/widgets/text_editor.h"
#include "app/rom.h"
namespace yaze {
@@ -31,11 +31,11 @@ class AssemblyEditor : public Editor {
text_editor_.SetShowWhitespaces(false);
type_ = EditorType::kAssembly;
}
void ChangeActiveFile(const std::string_view &filename);
void ChangeActiveFile(const std::string_view& filename);
void Initialize() override;
absl::Status Load() override;
void Update(bool &is_loaded);
void Update(bool& is_loaded);
void InlineUpdate();
void UpdateCodeView();
@@ -52,7 +52,7 @@ class AssemblyEditor : public Editor {
absl::Status Save() override;
void OpenFolder(const std::string &folder_path);
void OpenFolder(const std::string& folder_path);
void set_rom(Rom* rom) { rom_ = rom; }
Rom* rom() const { return rom_; }

110
src/app/editor/code/memory_editor.cc
View File

@@ -12,14 +12,14 @@ void MemoryEditorWithDiffChecker::DrawToolbar() {
// Modern compact toolbar with icon-only buttons
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(6, 4));
ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(4, 4));
if (ImGui::Button(ICON_MD_LOCATION_SEARCHING " Jump")) {
ImGui::OpenPopup("JumpToAddress");
}
if (ImGui::IsItemHovered()) {
ImGui::SetTooltip("Jump to specific address");
}
ImGui::SameLine();
if (ImGui::Button(ICON_MD_SEARCH " Search")) {
ImGui::OpenPopup("SearchPattern");
@@ -27,7 +27,7 @@ void MemoryEditorWithDiffChecker::DrawToolbar() {
if (ImGui::IsItemHovered()) {
ImGui::SetTooltip("Search for hex pattern");
}
ImGui::SameLine();
if (ImGui::Button(ICON_MD_BOOKMARK " Bookmarks")) {
ImGui::OpenPopup("Bookmarks");
@@ -35,35 +35,38 @@ void MemoryEditorWithDiffChecker::DrawToolbar() {
if (ImGui::IsItemHovered()) {
ImGui::SetTooltip("Manage address bookmarks");
}
ImGui::SameLine();
ImGui::Text(ICON_MD_MORE_VERT);
ImGui::SameLine();
// Show current address
if (current_address_ != 0) {
ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f),
ICON_MD_LOCATION_ON " 0x%06X", current_address_);
ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f),
ICON_MD_LOCATION_ON " 0x%06X", current_address_);
}
ImGui::PopStyleVar(2);
ImGui::Separator();
DrawJumpToAddressPopup();
DrawSearchPopup();
DrawBookmarksPopup();
}
void MemoryEditorWithDiffChecker::DrawJumpToAddressPopup() {
if (ImGui::BeginPopupModal("JumpToAddress", nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f),
ICON_MD_LOCATION_SEARCHING " Jump to Address");
if (ImGui::BeginPopupModal("JumpToAddress", nullptr,
ImGuiWindowFlags_AlwaysAutoResize)) {
ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f),
ICON_MD_LOCATION_SEARCHING " Jump to Address");
ImGui::Separator();
ImGui::Spacing();
ImGui::SetNextItemWidth(200);
if (ImGui::InputText("##jump_addr", jump_address_, IM_ARRAYSIZE(jump_address_),
ImGuiInputTextFlags_CharsHexadecimal | ImGuiInputTextFlags_EnterReturnsTrue)) {
if (ImGui::InputText("##jump_addr", jump_address_,
IM_ARRAYSIZE(jump_address_),
ImGuiInputTextFlags_CharsHexadecimal |
ImGuiInputTextFlags_EnterReturnsTrue)) {
// Parse and jump on Enter key
unsigned int addr;
if (sscanf(jump_address_, "%X", &addr) == 1) {
@@ -72,11 +75,11 @@ void MemoryEditorWithDiffChecker::DrawJumpToAddressPopup() {
}
}
ImGui::TextDisabled("Format: 0x1C800 or 1C800");
ImGui::Spacing();
ImGui::Separator();
ImGui::Spacing();
if (ImGui::Button(ICON_MD_CHECK " Go", ImVec2(120, 0))) {
unsigned int addr;
if (sscanf(jump_address_, "%X", &addr) == 1) {
@@ -93,21 +96,23 @@ void MemoryEditorWithDiffChecker::DrawJumpToAddressPopup() {
}
void MemoryEditorWithDiffChecker::DrawSearchPopup() {
if (ImGui::BeginPopupModal("SearchPattern", nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
ImGui::TextColored(ImVec4(0.4f, 0.8f, 0.4f, 1.0f),
ICON_MD_SEARCH " Search Hex Pattern");
if (ImGui::BeginPopupModal("SearchPattern", nullptr,
ImGuiWindowFlags_AlwaysAutoResize)) {
ImGui::TextColored(ImVec4(0.4f, 0.8f, 0.4f, 1.0f),
ICON_MD_SEARCH " Search Hex Pattern");
ImGui::Separator();
ImGui::Spacing();
ImGui::SetNextItemWidth(300);
if (ImGui::InputText("##search_pattern", search_pattern_, IM_ARRAYSIZE(search_pattern_),
ImGuiInputTextFlags_EnterReturnsTrue)) {
if (ImGui::InputText("##search_pattern", search_pattern_,
IM_ARRAYSIZE(search_pattern_),
ImGuiInputTextFlags_EnterReturnsTrue)) {
// TODO: Implement search
ImGui::CloseCurrentPopup();
}
ImGui::TextDisabled("Use ?? for wildcard (e.g. FF 00 ?? 12)");
ImGui::Spacing();
// Quick preset patterns
ImGui::Text(ICON_MD_LIST " Quick Patterns:");
if (ImGui::SmallButton("LDA")) {
@@ -121,11 +126,11 @@ void MemoryEditorWithDiffChecker::DrawSearchPopup() {
if (ImGui::SmallButton("JSR")) {
snprintf(search_pattern_, sizeof(search_pattern_), "20 ?? ??");
}
ImGui::Spacing();
ImGui::Separator();
ImGui::Spacing();
if (ImGui::Button(ICON_MD_SEARCH " Search", ImVec2(120, 0))) {
// TODO: Implement search using hex-search handler
ImGui::CloseCurrentPopup();
@@ -139,64 +144,71 @@ void MemoryEditorWithDiffChecker::DrawSearchPopup() {
}
void MemoryEditorWithDiffChecker::DrawBookmarksPopup() {
if (ImGui::BeginPopupModal("Bookmarks", nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
ImGui::TextColored(ImVec4(1.0f, 0.843f, 0.0f, 1.0f),
ICON_MD_BOOKMARK " Memory Bookmarks");
if (ImGui::BeginPopupModal("Bookmarks", nullptr,
ImGuiWindowFlags_AlwaysAutoResize)) {
ImGui::TextColored(ImVec4(1.0f, 0.843f, 0.0f, 1.0f),
ICON_MD_BOOKMARK " Memory Bookmarks");
ImGui::Separator();
ImGui::Spacing();
if (bookmarks_.empty()) {
ImGui::TextDisabled(ICON_MD_INFO " No bookmarks yet");
ImGui::Spacing();
ImGui::Separator();
ImGui::Spacing();
if (ImGui::Button(ICON_MD_ADD " Add Current Address", ImVec2(250, 0))) {
Bookmark new_bookmark;
new_bookmark.address = current_address_;
new_bookmark.name = absl::StrFormat("Bookmark %zu", bookmarks_.size() + 1);
new_bookmark.name =
absl::StrFormat("Bookmark %zu", bookmarks_.size() + 1);
new_bookmark.description = "User-defined bookmark";
bookmarks_.push_back(new_bookmark);
}
} else {
// Bookmarks table
ImGui::BeginChild("##bookmarks_list", ImVec2(500, 300), true);
if (ImGui::BeginTable("##bookmarks_table", 3,
ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg |
ImGuiTableFlags_Resizable)) {
if (ImGui::BeginTable("##bookmarks_table", 3,
ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg |
ImGuiTableFlags_Resizable)) {
ImGui::TableSetupColumn("Name", ImGuiTableColumnFlags_WidthFixed, 150);
ImGui::TableSetupColumn("Address", ImGuiTableColumnFlags_WidthFixed, 100);
ImGui::TableSetupColumn("Description", ImGuiTableColumnFlags_WidthStretch);
ImGui::TableSetupColumn("Address", ImGuiTableColumnFlags_WidthFixed,
100);
ImGui::TableSetupColumn("Description",
ImGuiTableColumnFlags_WidthStretch);
ImGui::TableHeadersRow();
for (size_t i = 0; i < bookmarks_.size(); ++i) {
const auto& bm = bookmarks_[i];
ImGui::PushID(static_cast<int>(i));
ImGui::TableNextRow();
ImGui::TableNextColumn();
if (ImGui::Selectable(bm.name.c_str(), false, ImGuiSelectableFlags_SpanAllColumns)) {
if (ImGui::Selectable(bm.name.c_str(), false,
ImGuiSelectableFlags_SpanAllColumns)) {
current_address_ = bm.address;
ImGui::CloseCurrentPopup();
}
ImGui::TableNextColumn();
ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f), "0x%06X", bm.address);
ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f), "0x%06X",
bm.address);
ImGui::TableNextColumn();
ImGui::TextDisabled("%s", bm.description.c_str());
ImGui::PopID();
}
ImGui::EndTable();
}
ImGui::EndChild();
ImGui::Spacing();
if (ImGui::Button(ICON_MD_ADD " Add Bookmark", ImVec2(150, 0))) {
Bookmark new_bookmark;
new_bookmark.address = current_address_;
new_bookmark.name = absl::StrFormat("Bookmark %zu", bookmarks_.size() + 1);
new_bookmark.name =
absl::StrFormat("Bookmark %zu", bookmarks_.size() + 1);
new_bookmark.description = "User-defined bookmark";
bookmarks_.push_back(new_bookmark);
}
@@ -205,15 +217,15 @@ void MemoryEditorWithDiffChecker::DrawBookmarksPopup() {
bookmarks_.clear();
}
}
ImGui::Spacing();
ImGui::Separator();
ImGui::Spacing();
if (ImGui::Button(ICON_MD_CLOSE " Close", ImVec2(250, 0))) {
ImGui::CloseCurrentPopup();
}
ImGui::EndPopup();
}
}

22
src/app/editor/code/memory_editor.h
View File

@@ -1,7 +1,6 @@
#ifndef YAZE_APP_EDITOR_CODE_MEMORY_EDITOR_H
#define YAZE_APP_EDITOR_CODE_MEMORY_EDITOR_H
#include "util/file_util.h"
#include "absl/container/flat_hash_map.h"
#include "app/editor/editor.h"
#include "app/gui/core/input.h"
@@ -9,6 +8,7 @@
#include "app/snes.h"
#include "imgui/imgui.h"
#include "imgui_memory_editor.h"
#include "util/file_util.h"
#include "util/macro.h"
namespace yaze {
@@ -19,8 +19,8 @@ using ImGui::Text;
struct MemoryEditorWithDiffChecker {
explicit MemoryEditorWithDiffChecker(Rom* rom = nullptr) : rom_(rom) {}
void Update(bool &show_memory_editor) {
void Update(bool& show_memory_editor) {
DrawToolbar();
ImGui::Separator();
static MemoryEditor mem_edit;
@@ -35,7 +35,7 @@ struct MemoryEditorWithDiffChecker {
}
static uint64_t convert_address = 0;
gui::InputHex("SNES to PC", (int *)&convert_address, 6, 200.f);
gui::InputHex("SNES to PC", (int*)&convert_address, 6, 200.f);
SameLine();
Text("%x", SnesToPc(convert_address));
@@ -46,15 +46,15 @@ struct MemoryEditorWithDiffChecker {
NEXT_COLUMN()
Text("%s", rom()->filename().data());
mem_edit.DrawContents((void *)&(*rom()), rom()->size());
mem_edit.DrawContents((void*)&(*rom()), rom()->size());
NEXT_COLUMN()
if (show_compare_rom) {
comp_edit.SetComparisonData((void *)&(*rom()));
comp_edit.SetComparisonData((void*)&(*rom()));
ImGui::BeginGroup();
ImGui::BeginChild("Comparison ROM");
Text("%s", comparison_rom.filename().data());
comp_edit.DrawContents((void *)&(comparison_rom), comparison_rom.size());
comp_edit.DrawContents((void*)&(comparison_rom), comparison_rom.size());
ImGui::EndChild();
ImGui::EndGroup();
}
@@ -65,7 +65,7 @@ struct MemoryEditorWithDiffChecker {
// Set the ROM pointer
void set_rom(Rom* rom) { rom_ = rom; }
// Get the ROM pointer
Rom* rom() const { return rom_; }
@@ -74,14 +74,14 @@ struct MemoryEditorWithDiffChecker {
void DrawJumpToAddressPopup();
void DrawSearchPopup();
void DrawBookmarksPopup();
Rom* rom_;
// Toolbar state
char jump_address_[16] = "0x000000";
char search_pattern_[256] = "";
uint32_t current_address_ = 0;
struct Bookmark {
uint32_t address;
std::string name;

124
src/app/editor/code/project_file_editor.cc
View File

@@ -6,11 +6,11 @@
#include "absl/strings/match.h"
#include "absl/strings/str_format.h"
#include "absl/strings/str_split.h"
#include "core/project.h"
#include "util/file_util.h"
#include "app/editor/system/toast_manager.h"
#include "app/gui/core/icons.h"
#include "core/project.h"
#include "imgui/imgui.h"
#include "util/file_util.h"
namespace yaze {
namespace editor {
@@ -22,38 +22,43 @@ ProjectFileEditor::ProjectFileEditor() {
}
void ProjectFileEditor::Draw() {
if (!active_) return;
if (!active_)
return;
ImGui::SetNextWindowSize(ImVec2(900, 700), ImGuiCond_FirstUseEver);
if (!ImGui::Begin(absl::StrFormat("%s Project Editor###ProjectFileEditor",
ICON_MD_DESCRIPTION).c_str(),
&active_)) {
ICON_MD_DESCRIPTION)
.c_str(),
&active_)) {
ImGui::End();
return;
}
// Toolbar
if (ImGui::BeginTable("ProjectEditorToolbar", 8, ImGuiTableFlags_SizingFixedFit)) {
if (ImGui::BeginTable("ProjectEditorToolbar", 8,
ImGuiTableFlags_SizingFixedFit)) {
ImGui::TableNextColumn();
if (ImGui::Button(absl::StrFormat("%s New", ICON_MD_NOTE_ADD).c_str())) {
NewFile();
}
ImGui::TableNextColumn();
if (ImGui::Button(absl::StrFormat("%s Open", ICON_MD_FOLDER_OPEN).c_str())) {
if (ImGui::Button(
absl::StrFormat("%s Open", ICON_MD_FOLDER_OPEN).c_str())) {
auto file = util::FileDialogWrapper::ShowOpenFileDialog();
if (!file.empty()) {
auto status = LoadFile(file);
if (!status.ok() && toast_manager_) {
toast_manager_->Show(std::string(status.message()),
ToastType::kError);
toast_manager_->Show(std::string(status.message()),
ToastType::kError);
}
}
}
ImGui::TableNextColumn();
bool can_save = !filepath_.empty() && IsModified();
if (!can_save) ImGui::BeginDisabled();
if (!can_save)
ImGui::BeginDisabled();
if (ImGui::Button(absl::StrFormat("%s Save", ICON_MD_SAVE).c_str())) {
auto status = SaveFile();
if (status.ok() && toast_manager_) {
@@ -62,8 +67,9 @@ void ProjectFileEditor::Draw() {
toast_manager_->Show(std::string(status.message()), ToastType::kError);
}
}
if (!can_save) ImGui::EndDisabled();
if (!can_save)
ImGui::EndDisabled();
ImGui::TableNextColumn();
if (ImGui::Button(absl::StrFormat("%s Save As", ICON_MD_SAVE_AS).c_str())) {
auto file = util::FileDialogWrapper::ShowSaveFileDialog(
@@ -73,41 +79,43 @@ void ProjectFileEditor::Draw() {
if (status.ok() && toast_manager_) {
toast_manager_->Show("Project file saved", ToastType::kSuccess);
} else if (!status.ok() && toast_manager_) {
toast_manager_->Show(std::string(status.message()), ToastType::kError);
toast_manager_->Show(std::string(status.message()),
ToastType::kError);
}
}
}
ImGui::TableNextColumn();
ImGui::Text("|");
ImGui::TableNextColumn();
if (ImGui::Button(absl::StrFormat("%s Validate", ICON_MD_CHECK_CIRCLE).c_str())) {
if (ImGui::Button(
absl::StrFormat("%s Validate", ICON_MD_CHECK_CIRCLE).c_str())) {
ValidateContent();
show_validation_ = true;
}
ImGui::TableNextColumn();
ImGui::Checkbox("Show Validation", &show_validation_);
ImGui::TableNextColumn();
if (!filepath_.empty()) {
ImGui::TextDisabled("%s", filepath_.c_str());
} else {
ImGui::TextDisabled("No file loaded");
}
ImGui::EndTable();
}
ImGui::Separator();
// Validation errors panel
if (show_validation_ && !validation_errors_.empty()) {
ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(0.3f, 0.2f, 0.2f, 0.5f));
if (ImGui::BeginChild("ValidationErrors", ImVec2(0, 100), true)) {
ImGui::TextColored(ImVec4(1.0f, 0.4f, 0.4f, 1.0f),
"%s Validation Errors:", ICON_MD_ERROR);
ImGui::TextColored(ImVec4(1.0f, 0.4f, 0.4f, 1.0f),
"%s Validation Errors:", ICON_MD_ERROR);
for (const auto& error : validation_errors_) {
ImGui::BulletText("%s", error.c_str());
}
@@ -115,11 +123,11 @@ void ProjectFileEditor::Draw() {
ImGui::EndChild();
ImGui::PopStyleColor();
}
// Main editor
ImVec2 editor_size = ImGui::GetContentRegionAvail();
text_editor_.Render("##ProjectEditor", editor_size);
ImGui::End();
}
@@ -129,17 +137,17 @@ absl::Status ProjectFileEditor::LoadFile(const std::string& filepath) {
return absl::InvalidArgumentError(
absl::StrFormat("Cannot open file: %s", filepath));
}
std::stringstream buffer;
buffer << file.rdbuf();
file.close();
text_editor_.SetText(buffer.str());
filepath_ = filepath;
modified_ = false;
ValidateContent();
return absl::OkStatus();
}
@@ -147,7 +155,7 @@ absl::Status ProjectFileEditor::SaveFile() {
if (filepath_.empty()) {
return absl::InvalidArgumentError("No file path specified");
}
return SaveFileAs(filepath_);
}
@@ -157,24 +165,24 @@ absl::Status ProjectFileEditor::SaveFileAs(const std::string& filepath) {
if (!absl::EndsWith(final_path, ".yaze")) {
final_path += ".yaze";
}
std::ofstream file(final_path);
if (!file.is_open()) {
return absl::InvalidArgumentError(
absl::StrFormat("Cannot create file: %s", final_path));
}
file << text_editor_.GetText();
file.close();
filepath_ = final_path;
modified_ = false;
// Add to recent files
auto& recent_mgr = project::RecentFilesManager::GetInstance();
recent_mgr.AddFile(filepath_);
recent_mgr.Save();
return absl::OkStatus();
}
@@ -217,7 +225,7 @@ autosave_enabled=true
autosave_interval_secs=300
theme=dark
)";
text_editor_.SetText(template_content);
filepath_.clear();
modified_ = true;
@@ -231,54 +239,54 @@ void ProjectFileEditor::ApplySyntaxHighlighting() {
void ProjectFileEditor::ValidateContent() {
validation_errors_.clear();
std::string content = text_editor_.GetText();
std::vector<std::string> lines = absl::StrSplit(content, '\n');
std::string current_section;
int line_num = 0;
for (const auto& line : lines) {
line_num++;
std::string trimmed = std::string(absl::StripAsciiWhitespace(line));
// Skip empty lines and comments
if (trimmed.empty() || trimmed[0] == '#') continue;
if (trimmed.empty() || trimmed[0] == '#')
continue;
// Check for section headers
if (trimmed[0] == '[' && trimmed[trimmed.size() - 1] == ']') {
current_section = trimmed.substr(1, trimmed.size() - 2);
// Validate known sections
if (current_section != "project" &&
current_section != "files" &&
if (current_section != "project" && current_section != "files" &&
current_section != "feature_flags" &&
current_section != "workspace_settings" &&
current_section != "build_settings") {
validation_errors_.push_back(
absl::StrFormat("Line %d: Unknown section [%s]",
line_num, current_section));
validation_errors_.push_back(absl::StrFormat(
"Line %d: Unknown section [%s]", line_num, current_section));
}
continue;
}
// Check for key=value pairs
size_t equals_pos = trimmed.find('=');
if (equals_pos == std::string::npos) {
validation_errors_.push_back(
absl::StrFormat("Line %d: Invalid format, expected key=value", line_num));
validation_errors_.push_back(absl::StrFormat(
"Line %d: Invalid format, expected key=value", line_num));
continue;
}
}
if (validation_errors_.empty() && show_validation_ && toast_manager_) {
toast_manager_->Show("Project file validation passed", ToastType::kSuccess);
}
}
void ProjectFileEditor::ShowValidationErrors() {
if (validation_errors_.empty()) return;
if (validation_errors_.empty())
return;
ImGui::TextColored(ImVec4(1.0f, 0.3f, 0.3f, 1.0f), "Validation Errors:");
for (const auto& error : validation_errors_) {
ImGui::BulletText("%s", error.c_str());

26
src/app/editor/code/project_file_editor.h
View File

@@ -4,8 +4,8 @@
#include <string>
#include "absl/status/status.h"
#include "core/project.h"
#include "app/gui/widgets/text_editor.h"
#include "core/project.h"
namespace yaze {
namespace editor {
@@ -25,61 +25,61 @@ class ToastManager;
class ProjectFileEditor {
public:
ProjectFileEditor();
void Draw();
/**
* @brief Load a project file into the editor
*/
absl::Status LoadFile(const std::string& filepath);
/**
* @brief Save the current editor contents to disk
*/
absl::Status SaveFile();
/**
* @brief Save to a new file path
*/
absl::Status SaveFileAs(const std::string& filepath);
/**
* @brief Get whether the file has unsaved changes
*/
bool IsModified() const { return text_editor_.IsTextChanged() || modified_; }
/**
* @brief Get the current filepath
*/
const std::string& filepath() const { return filepath_; }
/**
* @brief Set whether the editor window is active
*/
void set_active(bool active) { active_ = active; }
/**
* @brief Get pointer to active state for ImGui
*/
bool* active() { return &active_; }
/**
* @brief Set toast manager for notifications
*/
void SetToastManager(ToastManager* toast_manager) {
toast_manager_ = toast_manager;
}
/**
* @brief Create a new empty project file
*/
void NewFile();
private:
void ApplySyntaxHighlighting();
void ValidateContent();
void ShowValidationErrors();
TextEditor text_editor_;
std::string filepath_;
bool active_ = false;

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

File diff suppressed because it is too large Load Diff

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

@@ -3,12 +3,12 @@
#include <map>
#include "app/gfx/types/snes_palette.h"
#include "app/gui/canvas/canvas.h"
#include "app/rom.h"
#include "zelda3/dungeon/room.h"
#include "app/gfx/types/snes_palette.h"
#include "dungeon_object_interaction.h"
#include "imgui/imgui.h"
#include "zelda3/dungeon/room.h"
namespace yaze {
namespace editor {
@@ -29,10 +29,8 @@ class DungeonCanvasViewer {
// DrawDungeonTabView() removed - using EditorCard system instead
void DrawDungeonCanvas(int room_id);
void Draw(int room_id);
void SetRom(Rom* rom) {
rom_ = rom;
}
void SetRom(Rom* rom) { rom_ = rom; }
Rom* rom() const { return rom_; }
// Room data access
@@ -42,70 +40,80 @@ class DungeonCanvasViewer {
void set_current_active_room_tab(int tab) { current_active_room_tab_ = tab; }
// Palette access
void set_current_palette_group_id(uint64_t id) { current_palette_group_id_ = id; }
void set_current_palette_group_id(uint64_t id) {
current_palette_group_id_ = id;
}
void SetCurrentPaletteId(uint64_t id) { current_palette_id_ = id; }
void SetCurrentPaletteGroup(const gfx::PaletteGroup& group) { current_palette_group_ = group; }
void SetCurrentPaletteGroup(const gfx::PaletteGroup& group) {
current_palette_group_ = group;
}
// Canvas access
gui::Canvas& canvas() { return canvas_; }
const gui::Canvas& canvas() const { return canvas_; }
// Object interaction access
DungeonObjectInteraction& object_interaction() { return object_interaction_; }
// Enable/disable object interaction mode
void SetObjectInteractionEnabled(bool enabled) { object_interaction_enabled_ = enabled; }
bool IsObjectInteractionEnabled() const { return object_interaction_enabled_; }
void SetObjectInteractionEnabled(bool enabled) {
object_interaction_enabled_ = enabled;
}
bool IsObjectInteractionEnabled() const {
return object_interaction_enabled_;
}
// Layer visibility controls (per-room)
void SetBG1Visible(int room_id, bool visible) {
GetRoomLayerSettings(room_id).bg1_visible = visible;
void SetBG1Visible(int room_id, bool visible) {
GetRoomLayerSettings(room_id).bg1_visible = visible;
}
void SetBG2Visible(int room_id, bool visible) {
GetRoomLayerSettings(room_id).bg2_visible = visible;
void SetBG2Visible(int room_id, bool visible) {
GetRoomLayerSettings(room_id).bg2_visible = visible;
}
bool IsBG1Visible(int room_id) const {
bool IsBG1Visible(int room_id) const {
auto it = room_layer_settings_.find(room_id);
return it != room_layer_settings_.end() ? it->second.bg1_visible : true;
}
bool IsBG2Visible(int room_id) const {
bool IsBG2Visible(int room_id) const {
auto it = room_layer_settings_.find(room_id);
return it != room_layer_settings_.end() ? it->second.bg2_visible : true;
}
// BG2 layer type controls (per-room)
void SetBG2LayerType(int room_id, int type) {
GetRoomLayerSettings(room_id).bg2_layer_type = type;
void SetBG2LayerType(int room_id, int type) {
GetRoomLayerSettings(room_id).bg2_layer_type = type;
}
int GetBG2LayerType(int room_id) const {
int GetBG2LayerType(int room_id) const {
auto it = room_layer_settings_.find(room_id);
return it != room_layer_settings_.end() ? it->second.bg2_layer_type : 0;
}
// Set the object to be placed
void SetPreviewObject(const zelda3::RoomObject& object) {
object_interaction_.SetPreviewObject(object, true);
}
void ClearPreviewObject() {
object_interaction_.SetPreviewObject(zelda3::RoomObject{0, 0, 0, 0, 0}, false);
object_interaction_.SetPreviewObject(zelda3::RoomObject{0, 0, 0, 0, 0},
false);
}
private:
void DisplayObjectInfo(const zelda3::RoomObject &object, int canvas_x,
void DisplayObjectInfo(const zelda3::RoomObject& object, int canvas_x,
int canvas_y);
void RenderSprites(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);
void CalculateWallDimensions(const zelda3::RoomObject& object, int& width,
int& height);
// Visualization
void DrawObjectPositionOutlines(const zelda3::Room& room);
// Room graphics management
// Load: Read from ROM, Render: Process pixels, Draw: Display on canvas
absl::Status LoadAndRenderRoomGraphics(int room_id);
@@ -115,16 +123,16 @@ class DungeonCanvasViewer {
gui::Canvas canvas_{"##DungeonCanvas", ImVec2(0x200, 0x200)};
// ObjectRenderer removed - use ObjectDrawer for rendering (production system)
DungeonObjectInteraction object_interaction_;
// Room data
std::array<zelda3::Room, 0x128>* rooms_ = nullptr;
// Used by overworld editor for double-click entrance → open dungeon room
ImVector<int> active_rooms_;
int current_active_room_tab_ = 0;
// Object interaction state
bool object_interaction_enabled_ = true;
// Per-room layer visibility settings
struct RoomLayerSettings {
bool bg1_visible = true;
@@ -132,12 +140,12 @@ class DungeonCanvasViewer {
int bg2_layer_type = 0; // 0=Normal, 1=Translucent, 2=Addition, etc.
};
std::map<int, RoomLayerSettings> room_layer_settings_;
// Helper to get settings for a room (creates default if not exists)
RoomLayerSettings& GetRoomLayerSettings(int room_id) {
return room_layer_settings_[room_id];
}
// Palette data
uint64_t current_palette_group_id_ = 0;
uint64_t current_palette_id_ = 0;
@@ -153,13 +161,13 @@ class DungeonCanvasViewer {
};
std::vector<ObjectRenderCache> object_render_cache_;
uint64_t last_palette_hash_ = 0;
// Debug state flags
bool show_room_debug_info_ = false;
bool show_texture_debug_ = false;
bool show_object_bounds_ = false;
bool show_layer_info_ = false;
int layout_override_ = -1; // -1 for no override
int layout_override_ = -1; // -1 for no override
// Object outline filtering toggles
struct ObjectOutlineToggles {

653
src/app/editor/dungeon/dungeon_editor_v2.cc
View File

File diff suppressed because it is too large Load Diff

61
src/app/editor/dungeon/dungeon_editor_v2.h
View File

@@ -8,18 +8,18 @@
#include "absl/strings/str_format.h"
#include "app/editor/editor.h"
#include "app/gfx/types/snes_palette.h"
#include "app/rom.h"
#include "dungeon_room_selector.h"
#include "dungeon_canvas_viewer.h"
#include "dungeon_object_selector.h"
#include "dungeon_room_loader.h"
#include "object_editor_card.h"
#include "zelda3/dungeon/room.h"
#include "zelda3/dungeon/room_entrance.h"
#include "app/gui/app/editor_layout.h"
#include "app/gui/widgets/dungeon_object_emulator_preview.h"
#include "app/gui/widgets/palette_editor_widget.h"
#include "app/rom.h"
#include "dungeon_canvas_viewer.h"
#include "dungeon_object_selector.h"
#include "dungeon_room_loader.h"
#include "dungeon_room_selector.h"
#include "imgui/imgui.h"
#include "object_editor_card.h"
#include "zelda3/dungeon/room.h"
#include "zelda3/dungeon/room_entrance.h"
namespace yaze {
namespace editor {
@@ -81,20 +81,23 @@ class DungeonEditorV2 : public Editor {
// ROM state
bool IsRomLoaded() const override { return rom_ && rom_->is_loaded(); }
std::string GetRomStatus() const override {
if (!rom_) return "No ROM loaded";
if (!rom_->is_loaded()) return "ROM failed to load";
if (!rom_)
return "No ROM loaded";
if (!rom_->is_loaded())
return "ROM failed to load";
return absl::StrFormat("ROM loaded: %s", rom_->title());
}
// Card visibility flags - Public for command-line flag access
bool show_room_selector_ = false; // Room selector/list card
bool show_room_matrix_ = false; // Dungeon matrix layout
bool show_entrances_list_ = false; // Entrance list card (renamed from entrances_matrix_)
bool show_room_graphics_ = false; // Room graphics card
bool show_object_editor_ = false; // Object editor card
bool show_palette_editor_ = false; // Palette editor card
bool show_debug_controls_ = false; // Debug controls card
bool show_control_panel_ = true; // Control panel (visible by default)
bool show_room_selector_ = false; // Room selector/list card
bool show_room_matrix_ = false; // Dungeon matrix layout
bool show_entrances_list_ =
false; // Entrance list card (renamed from entrances_matrix_)
bool show_room_graphics_ = false; // Room graphics card
bool show_object_editor_ = false; // Object editor card
bool show_palette_editor_ = false; // Palette editor card
bool show_debug_controls_ = false; // Debug controls card
bool show_control_panel_ = true; // Control panel (visible by default)
private:
gfx::IRenderer* renderer_ = nullptr;
@@ -106,10 +109,10 @@ class DungeonEditorV2 : public Editor {
void DrawEntrancesListCard();
void DrawRoomGraphicsCard();
void DrawDebugControlsCard();
// Texture processing (critical for rendering)
void ProcessDeferredTextures();
// Room selection callback
void OnRoomSelected(int room_id);
void OnEntranceSelected(int entrance_id);
@@ -118,23 +121,23 @@ class DungeonEditorV2 : public Editor {
Rom* rom_;
std::array<zelda3::Room, 0x128> rooms_;
std::array<zelda3::RoomEntrance, 0x8C> entrances_;
// Current selection state
int current_entrance_id_ = 0;
// Active room tabs and card tracking for jump-to
ImVector<int> active_rooms_;
std::unordered_map<int, std::shared_ptr<gui::EditorCard>> room_cards_;
int current_room_id_ = 0;
bool control_panel_minimized_ = false;
// Palette management
gfx::SnesPalette current_palette_;
gfx::PaletteGroup current_palette_group_;
uint64_t current_palette_id_ = 0;
uint64_t current_palette_group_id_ = 0;
// Components - these do all the work
DungeonRoomLoader room_loader_;
DungeonRoomSelector room_selector_;
@@ -142,10 +145,11 @@ class DungeonEditorV2 : public Editor {
DungeonObjectSelector object_selector_;
gui::DungeonObjectEmulatorPreview object_emulator_preview_;
gui::PaletteEditorWidget palette_editor_;
std::unique_ptr<ObjectEditorCard> object_editor_card_; // Unified object editor
std::unique_ptr<ObjectEditorCard>
object_editor_card_; // Unified object editor
bool is_loaded_ = false;
// Docking class for room windows to dock together
ImGuiWindowClass room_window_class_;
};
@@ -154,4 +158,3 @@ class DungeonEditorV2 : public Editor {
} // namespace yaze
#endif // YAZE_APP_EDITOR_DUNGEON_EDITOR_V2_H

262
src/app/editor/dungeon/dungeon_object_interaction.cc
View File

@@ -8,21 +8,21 @@ namespace yaze::editor {
void DungeonObjectInteraction::HandleCanvasMouseInput() {
const ImGuiIO& io = ImGui::GetIO();
// Check if mouse is over the canvas
if (!canvas_->IsMouseHovering()) {
return;
}
// Get mouse position relative to canvas
ImVec2 mouse_pos = io.MousePos;
ImVec2 canvas_pos = canvas_->zero_point();
ImVec2 canvas_size = canvas_->canvas_size();
// Convert to canvas coordinates
ImVec2 canvas_mouse_pos =
ImVec2(mouse_pos.x - canvas_pos.x, mouse_pos.y - canvas_pos.y);
// Handle mouse clicks
if (ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
if (ImGui::IsKeyDown(ImGuiKey_LeftCtrl) ||
@@ -48,18 +48,18 @@ void DungeonObjectInteraction::HandleCanvasMouseInput() {
}
}
}
// Handle mouse drag
if (is_selecting_ && ImGui::IsMouseDragging(ImGuiMouseButton_Left)) {
select_current_pos_ = canvas_mouse_pos;
UpdateSelectedObjects();
}
if (is_dragging_ && ImGui::IsMouseDragging(ImGuiMouseButton_Left)) {
drag_current_pos_ = canvas_mouse_pos;
DrawDragPreview();
}
// Handle mouse release
if (ImGui::IsMouseReleased(ImGuiMouseButton_Left)) {
if (is_selecting_) {
@@ -69,28 +69,31 @@ void DungeonObjectInteraction::HandleCanvasMouseInput() {
if (is_dragging_) {
is_dragging_ = false;
// Apply drag transformation to selected objects
if (!selected_object_indices_.empty() && rooms_ && current_room_id_ >= 0 && current_room_id_ < 296) {
if (!selected_object_indices_.empty() && rooms_ &&
current_room_id_ >= 0 && current_room_id_ < 296) {
auto& room = (*rooms_)[current_room_id_];
ImVec2 drag_delta = ImVec2(drag_current_pos_.x - drag_start_pos_.x,
drag_current_pos_.y - drag_start_pos_.y);
// Convert pixel delta to tile delta
int tile_delta_x = static_cast<int>(drag_delta.x) / 8;
int tile_delta_y = static_cast<int>(drag_delta.y) / 8;
// Move all selected objects
auto& objects = room.GetTileObjects();
for (size_t index : selected_object_indices_) {
if (index < objects.size()) {
objects[index].x_ += tile_delta_x;
objects[index].y_ += tile_delta_y;
// Clamp to room bounds (64x64 tiles)
objects[index].x_ = std::clamp(static_cast<int>(objects[index].x_), 0, 63);
objects[index].y_ = std::clamp(static_cast<int>(objects[index].y_), 0, 63);
objects[index].x_ =
std::clamp(static_cast<int>(objects[index].x_), 0, 63);
objects[index].y_ =
std::clamp(static_cast<int>(objects[index].y_), 0, 63);
}
}
// Trigger cache invalidation and re-render
if (cache_invalidation_callback_) {
cache_invalidation_callback_();
@@ -103,7 +106,7 @@ void DungeonObjectInteraction::HandleCanvasMouseInput() {
void DungeonObjectInteraction::CheckForObjectSelection() {
// Draw object selection rectangle similar to OverworldEditor
DrawObjectSelectRect();
// Handle object selection when rectangle is active
if (object_select_active_) {
SelectObjectsInRect();
@@ -111,16 +114,17 @@ void DungeonObjectInteraction::CheckForObjectSelection() {
}
void DungeonObjectInteraction::DrawObjectSelectRect() {
if (!canvas_->IsMouseHovering()) return;
if (!canvas_->IsMouseHovering())
return;
const ImGuiIO& io = ImGui::GetIO();
const ImVec2 canvas_pos = canvas_->zero_point();
const ImVec2 mouse_pos =
ImVec2(io.MousePos.x - canvas_pos.x, io.MousePos.y - canvas_pos.y);
static bool dragging = false;
static ImVec2 drag_start_pos;
// Right click to start object selection
if (ImGui::IsMouseClicked(ImGuiMouseButton_Right) && !object_loaded_) {
drag_start_pos = mouse_pos;
@@ -129,24 +133,24 @@ void DungeonObjectInteraction::DrawObjectSelectRect() {
object_select_active_ = false;
dragging = false;
}
// Right drag to create selection rectangle
if (ImGui::IsMouseDragging(ImGuiMouseButton_Right) && !object_loaded_) {
object_select_end_ = mouse_pos;
dragging = true;
// Draw selection rectangle
ImVec2 start =
ImVec2(canvas_pos.x + std::min(drag_start_pos.x, mouse_pos.x),
canvas_pos.y + std::min(drag_start_pos.y, mouse_pos.y));
ImVec2 end = ImVec2(canvas_pos.x + std::max(drag_start_pos.x, mouse_pos.x),
canvas_pos.y + std::max(drag_start_pos.y, mouse_pos.y));
ImDrawList* draw_list = ImGui::GetWindowDrawList();
draw_list->AddRect(start, end, IM_COL32(255, 255, 0, 255), 0.0f, 0, 2.0f);
draw_list->AddRectFilled(start, end, IM_COL32(255, 255, 0, 32));
}
// Complete selection on mouse release
if (dragging && !ImGui::IsMouseDown(ImGuiMouseButton_Right)) {
dragging = false;
@@ -156,11 +160,12 @@ void DungeonObjectInteraction::DrawObjectSelectRect() {
}
void DungeonObjectInteraction::SelectObjectsInRect() {
if (!rooms_ || current_room_id_ < 0 || current_room_id_ >= 296) return;
if (!rooms_ || current_room_id_ < 0 || current_room_id_ >= 296)
return;
auto& room = (*rooms_)[current_room_id_];
selected_object_indices_.clear();
// Calculate selection bounds in room coordinates
auto [start_room_x, start_room_y] = CanvasToRoomCoordinates(
static_cast<int>(std::min(object_select_start_.x, object_select_end_.x)),
@@ -168,7 +173,7 @@ void DungeonObjectInteraction::SelectObjectsInRect() {
auto [end_room_x, end_room_y] = CanvasToRoomCoordinates(
static_cast<int>(std::max(object_select_start_.x, object_select_end_.x)),
static_cast<int>(std::max(object_select_start_.y, object_select_end_.y)));
// Find objects within selection rectangle
const auto& objects = room.GetTileObjects();
for (size_t i = 0; i < objects.size(); ++i) {
@@ -181,79 +186,83 @@ void DungeonObjectInteraction::SelectObjectsInRect() {
}
void DungeonObjectInteraction::DrawSelectionHighlights() {
if (!rooms_ || current_room_id_ < 0 || current_room_id_ >= 296) return;
if (!rooms_ || current_room_id_ < 0 || current_room_id_ >= 296)
return;
auto& room = (*rooms_)[current_room_id_];
const auto& objects = room.GetTileObjects();
// Draw highlights for all selected objects
ImDrawList* draw_list = ImGui::GetWindowDrawList();
ImVec2 canvas_pos = canvas_->zero_point();
for (size_t index : selected_object_indices_) {
if (index < objects.size()) {
const auto& object = objects[index];
auto [canvas_x, canvas_y] = RoomToCanvasCoordinates(object.x_, object.y_);
// Calculate object size for highlight
int obj_width = 8 + (object.size_ & 0x0F) * 4;
int obj_height = 8 + ((object.size_ >> 4) & 0x0F) * 4;
obj_width = std::min(obj_width, 64);
obj_height = std::min(obj_height, 64);
// Draw cyan selection highlight
ImVec2 obj_start(canvas_pos.x + canvas_x - 2,
canvas_pos.y + canvas_y - 2);
ImVec2 obj_end(canvas_pos.x + canvas_x + obj_width + 2,
canvas_pos.y + canvas_y + obj_height + 2);
// Animated selection (pulsing effect)
float pulse = 0.7f + 0.3f * std::sin(static_cast<float>(ImGui::GetTime()) * 4.0f);
draw_list->AddRect(obj_start, obj_end,
IM_COL32(0, static_cast<int>(255 * pulse), 255, 255),
0.0f, 0, 2.5f);
float pulse =
0.7f + 0.3f * std::sin(static_cast<float>(ImGui::GetTime()) * 4.0f);
draw_list->AddRect(obj_start, obj_end,
IM_COL32(0, static_cast<int>(255 * pulse), 255, 255),
0.0f, 0, 2.5f);
// Draw corner handles for selected objects
constexpr float handle_size = 4.0f;
draw_list->AddRectFilled(
ImVec2(obj_start.x - handle_size/2, obj_start.y - handle_size/2),
ImVec2(obj_start.x + handle_size/2, obj_start.y + handle_size/2),
ImVec2(obj_start.x - handle_size / 2, obj_start.y - handle_size / 2),
ImVec2(obj_start.x + handle_size / 2, obj_start.y + handle_size / 2),
IM_COL32(0, 255, 255, 255));
draw_list->AddRectFilled(
ImVec2(obj_end.x - handle_size/2, obj_start.y - handle_size/2),
ImVec2(obj_end.x + handle_size/2, obj_start.y + handle_size/2),
ImVec2(obj_end.x - handle_size / 2, obj_start.y - handle_size / 2),
ImVec2(obj_end.x + handle_size / 2, obj_start.y + handle_size / 2),
IM_COL32(0, 255, 255, 255));
draw_list->AddRectFilled(
ImVec2(obj_start.x - handle_size/2, obj_end.y - handle_size/2),
ImVec2(obj_start.x + handle_size/2, obj_end.y + handle_size/2),
ImVec2(obj_start.x - handle_size / 2, obj_end.y - handle_size / 2),
ImVec2(obj_start.x + handle_size / 2, obj_end.y + handle_size / 2),
IM_COL32(0, 255, 255, 255));
draw_list->AddRectFilled(
ImVec2(obj_end.x - handle_size/2, obj_end.y - handle_size/2),
ImVec2(obj_end.x + handle_size/2, obj_end.y + handle_size/2),
ImVec2(obj_end.x - handle_size / 2, obj_end.y - handle_size / 2),
ImVec2(obj_end.x + handle_size / 2, obj_end.y + handle_size / 2),
IM_COL32(0, 255, 255, 255));
}
}
}
void DungeonObjectInteraction::PlaceObjectAtPosition(int room_x, int room_y) {
if (!object_loaded_ || preview_object_.id_ < 0 || !rooms_) return;
if (current_room_id_ < 0 || current_room_id_ >= 296) return;
if (!object_loaded_ || preview_object_.id_ < 0 || !rooms_)
return;
if (current_room_id_ < 0 || current_room_id_ >= 296)
return;
// Create new object at the specified position
auto new_object = preview_object_;
new_object.x_ = room_x;
new_object.y_ = room_y;
// Add object to room
auto& room = (*rooms_)[current_room_id_];
room.AddTileObject(new_object);
// Notify callback if set
if (object_placed_callback_) {
object_placed_callback_(new_object);
}
// Trigger cache invalidation
if (cache_invalidation_callback_) {
cache_invalidation_callback_();
@@ -261,11 +270,12 @@ void DungeonObjectInteraction::PlaceObjectAtPosition(int room_x, int room_y) {
}
void DungeonObjectInteraction::DrawSelectBox() {
if (!is_selecting_) return;
if (!is_selecting_)
return;
ImDrawList* draw_list = ImGui::GetWindowDrawList();
ImVec2 canvas_pos = canvas_->zero_point();
// Calculate select box bounds
ImVec2 start = ImVec2(
canvas_pos.x + std::min(select_start_pos_.x, select_current_pos_.x),
@@ -273,58 +283,65 @@ void DungeonObjectInteraction::DrawSelectBox() {
ImVec2 end = ImVec2(
canvas_pos.x + std::max(select_start_pos_.x, select_current_pos_.x),
canvas_pos.y + std::max(select_start_pos_.y, select_current_pos_.y));
// Draw selection box
draw_list->AddRect(start, end, IM_COL32(255, 255, 0, 255), 0.0f, 0, 2.0f);
draw_list->AddRectFilled(start, end, IM_COL32(255, 255, 0, 32));
}
void DungeonObjectInteraction::DrawDragPreview() {
if (!is_dragging_ || selected_object_indices_.empty() || !rooms_) return;
if (current_room_id_ < 0 || current_room_id_ >= 296) return;
if (!is_dragging_ || selected_object_indices_.empty() || !rooms_)
return;
if (current_room_id_ < 0 || current_room_id_ >= 296)
return;
// Draw drag preview for selected objects
ImDrawList* draw_list = ImGui::GetWindowDrawList();
ImVec2 canvas_pos = canvas_->zero_point();
ImVec2 drag_delta = ImVec2(drag_current_pos_.x - drag_start_pos_.x,
drag_current_pos_.y - drag_start_pos_.y);
auto& room = (*rooms_)[current_room_id_];
const auto& objects = room.GetTileObjects();
// Draw preview of where objects would be moved
for (size_t index : selected_object_indices_) {
if (index < objects.size()) {
const auto& object = objects[index];
auto [canvas_x, canvas_y] = RoomToCanvasCoordinates(object.x_, object.y_);
// Calculate object size
int obj_width = 8 + (object.size_ & 0x0F) * 4;
int obj_height = 8 + ((object.size_ >> 4) & 0x0F) * 4;
obj_width = std::min(obj_width, 64);
obj_height = std::min(obj_height, 64);
// Draw semi-transparent preview at new position
ImVec2 preview_start(canvas_pos.x + canvas_x + drag_delta.x,
canvas_pos.y + canvas_y + drag_delta.y);
ImVec2 preview_end(preview_start.x + obj_width, preview_start.y + obj_height);
canvas_pos.y + canvas_y + drag_delta.y);
ImVec2 preview_end(preview_start.x + obj_width,
preview_start.y + obj_height);
// Draw ghosted object
draw_list->AddRectFilled(preview_start, preview_end, IM_COL32(0, 255, 255, 64));
draw_list->AddRect(preview_start, preview_end, IM_COL32(0, 255, 255, 255), 0.0f, 0, 1.5f);
draw_list->AddRectFilled(preview_start, preview_end,
IM_COL32(0, 255, 255, 64));
draw_list->AddRect(preview_start, preview_end, IM_COL32(0, 255, 255, 255),
0.0f, 0, 1.5f);
}
}
}
void DungeonObjectInteraction::UpdateSelectedObjects() {
if (!is_selecting_ || !rooms_) return;
if (!is_selecting_ || !rooms_)
return;
selected_objects_.clear();
if (current_room_id_ < 0 || current_room_id_ >= 296) return;
if (current_room_id_ < 0 || current_room_id_ >= 296)
return;
auto& room = (*rooms_)[current_room_id_];
// Check each object in the room
for (const auto& object : room.GetTileObjects()) {
if (IsObjectInSelectBox(object)) {
@@ -335,49 +352,55 @@ void DungeonObjectInteraction::UpdateSelectedObjects() {
bool DungeonObjectInteraction::IsObjectInSelectBox(
const zelda3::RoomObject& object) const {
if (!is_selecting_) return false;
if (!is_selecting_)
return false;
// Convert object position to canvas coordinates
auto [canvas_x, canvas_y] = RoomToCanvasCoordinates(object.x_, object.y_);
// Calculate select box bounds
float min_x = std::min(select_start_pos_.x, select_current_pos_.x);
float max_x = std::max(select_start_pos_.x, select_current_pos_.x);
float min_y = std::min(select_start_pos_.y, select_current_pos_.y);
float max_y = std::max(select_start_pos_.y, select_current_pos_.y);
// Check if object is within select box
return (canvas_x >= min_x && canvas_x <= max_x && canvas_y >= min_y &&
canvas_y <= max_y);
}
std::pair<int, int> DungeonObjectInteraction::RoomToCanvasCoordinates(int room_x, int room_y) const {
std::pair<int, int> DungeonObjectInteraction::RoomToCanvasCoordinates(
int room_x, int room_y) const {
// Dungeon tiles are 8x8 pixels, convert room coordinates (tiles) to pixels
return {room_x * 8, room_y * 8};
}
std::pair<int, int> DungeonObjectInteraction::CanvasToRoomCoordinates(int canvas_x, int canvas_y) const {
std::pair<int, int> DungeonObjectInteraction::CanvasToRoomCoordinates(
int canvas_x, int canvas_y) const {
// Convert canvas pixels back to room coordinates (tiles)
return {canvas_x / 8, canvas_y / 8};
}
bool DungeonObjectInteraction::IsWithinCanvasBounds(int canvas_x, int canvas_y, int margin) const {
bool DungeonObjectInteraction::IsWithinCanvasBounds(int canvas_x, int canvas_y,
int margin) const {
auto canvas_size = canvas_->canvas_size();
auto global_scale = canvas_->global_scale();
int scaled_width = static_cast<int>(canvas_size.x * global_scale);
int scaled_height = static_cast<int>(canvas_size.y * global_scale);
return (canvas_x >= -margin && canvas_y >= -margin &&
canvas_x <= scaled_width + margin &&
canvas_y <= scaled_height + margin);
}
void DungeonObjectInteraction::SetCurrentRoom(std::array<zelda3::Room, 0x128>* rooms, int room_id) {
void DungeonObjectInteraction::SetCurrentRoom(
std::array<zelda3::Room, 0x128>* rooms, int room_id) {
rooms_ = rooms;
current_room_id_ = room_id;
}
void DungeonObjectInteraction::SetPreviewObject(const zelda3::RoomObject& object, bool loaded) {
void DungeonObjectInteraction::SetPreviewObject(
const zelda3::RoomObject& object, bool loaded) {
preview_object_ = object;
object_loaded_ = loaded;
}
@@ -390,13 +413,14 @@ void DungeonObjectInteraction::ClearSelection() {
}
void DungeonObjectInteraction::ShowContextMenu() {
if (!canvas_->IsMouseHovering()) return;
if (!canvas_->IsMouseHovering())
return;
// Show context menu on right-click when not dragging
if (ImGui::IsMouseClicked(ImGuiMouseButton_Right) && !is_dragging_) {
ImGui::OpenPopup("DungeonObjectContextMenu");
}
if (ImGui::BeginPopup("DungeonObjectContextMenu")) {
// Show different options based on current state
if (!selected_object_indices_.empty()) {
@@ -408,14 +432,14 @@ void DungeonObjectInteraction::ShowContextMenu() {
}
ImGui::Separator();
}
if (has_clipboard_data_) {
if (ImGui::MenuItem("Paste Objects", "Ctrl+V")) {
HandlePasteObjects();
}
ImGui::Separator();
}
if (object_loaded_) {
ImGui::Text("Placing: Object 0x%02X", preview_object_.id_);
if (ImGui::MenuItem("Cancel Placement", "Esc")) {
@@ -425,29 +449,31 @@ void DungeonObjectInteraction::ShowContextMenu() {
ImGui::Text("Right-click + drag to select");
ImGui::Text("Left-click + drag to move");
}
ImGui::EndPopup();
}
}
void DungeonObjectInteraction::HandleDeleteSelected() {
if (selected_object_indices_.empty() || !rooms_) return;
if (current_room_id_ < 0 || current_room_id_ >= 296) return;
if (selected_object_indices_.empty() || !rooms_)
return;
if (current_room_id_ < 0 || current_room_id_ >= 296)
return;
auto& room = (*rooms_)[current_room_id_];
// Sort indices in descending order to avoid index shifts during deletion
std::vector<size_t> sorted_indices = selected_object_indices_;
std::sort(sorted_indices.rbegin(), sorted_indices.rend());
// Delete selected objects using Room's RemoveTileObject method
for (size_t index : sorted_indices) {
room.RemoveTileObject(index);
}
// Clear selection
ClearSelection();
// Trigger cache invalidation and re-render
if (cache_invalidation_callback_) {
cache_invalidation_callback_();
@@ -455,12 +481,14 @@ void DungeonObjectInteraction::HandleDeleteSelected() {
}
void DungeonObjectInteraction::HandleCopySelected() {
if (selected_object_indices_.empty() || !rooms_) return;
if (current_room_id_ < 0 || current_room_id_ >= 296) return;
if (selected_object_indices_.empty() || !rooms_)
return;
if (current_room_id_ < 0 || current_room_id_ >= 296)
return;
auto& room = (*rooms_)[current_room_id_];
const auto& objects = room.GetTileObjects();
// Copy selected objects to clipboard
clipboard_.clear();
for (size_t index : selected_object_indices_) {
@@ -468,44 +496,46 @@ void DungeonObjectInteraction::HandleCopySelected() {
clipboard_.push_back(objects[index]);
}
}
has_clipboard_data_ = !clipboard_.empty();
}
void DungeonObjectInteraction::HandlePasteObjects() {
if (!has_clipboard_data_ || !rooms_) return;
if (current_room_id_ < 0 || current_room_id_ >= 296) return;
if (!has_clipboard_data_ || !rooms_)
return;
if (current_room_id_ < 0 || current_room_id_ >= 296)
return;
auto& room = (*rooms_)[current_room_id_];
// Get mouse position for paste location
const ImGuiIO& io = ImGui::GetIO();
ImVec2 mouse_pos = io.MousePos;
ImVec2 canvas_pos = canvas_->zero_point();
ImVec2 canvas_mouse_pos =
ImVec2(mouse_pos.x - canvas_pos.x, mouse_pos.y - canvas_pos.y);
auto [paste_x, paste_y] = CanvasToRoomCoordinates(
static_cast<int>(canvas_mouse_pos.x),
static_cast<int>(canvas_mouse_pos.y));
auto [paste_x, paste_y] =
CanvasToRoomCoordinates(static_cast<int>(canvas_mouse_pos.x),
static_cast<int>(canvas_mouse_pos.y));
// Calculate offset from first object in clipboard
if (!clipboard_.empty()) {
int offset_x = paste_x - clipboard_[0].x_;
int offset_y = paste_y - clipboard_[0].y_;
// Paste all objects with offset
for (const auto& obj : clipboard_) {
auto new_obj = obj;
new_obj.x_ = obj.x_ + offset_x;
new_obj.y_ = obj.y_ + offset_y;
// Clamp to room bounds
new_obj.x_ = std::clamp(static_cast<int>(new_obj.x_), 0, 63);
new_obj.y_ = std::clamp(static_cast<int>(new_obj.y_), 0, 63);
room.AddTileObject(new_obj);
}
// Trigger cache invalidation and re-render
if (cache_invalidation_callback_) {
cache_invalidation_callback_();

37
src/app/editor/dungeon/dungeon_object_interaction.h
View File

@@ -1,11 +1,11 @@
#ifndef YAZE_APP_EDITOR_DUNGEON_DUNGEON_OBJECT_INTERACTION_H
#define YAZE_APP_EDITOR_DUNGEON_DUNGEON_OBJECT_INTERACTION_H
#include <vector>
#include <functional>
#include <vector>
#include "imgui/imgui.h"
#include "app/gui/canvas/canvas.h"
#include "imgui/imgui.h"
#include "zelda3/dungeon/room.h"
#include "zelda3/dungeon/room_object.h"
@@ -21,45 +21,48 @@ namespace editor {
class DungeonObjectInteraction {
public:
explicit DungeonObjectInteraction(gui::Canvas* canvas) : canvas_(canvas) {}
// Main interaction handling
void HandleCanvasMouseInput();
void CheckForObjectSelection();
void PlaceObjectAtPosition(int room_x, int room_y);
// Selection rectangle (like OverworldEditor)
void DrawObjectSelectRect();
void SelectObjectsInRect();
void DrawSelectionHighlights(); // Draw highlights for selected objects
// Drag and select box functionality
void DrawSelectBox();
void DrawDragPreview();
void UpdateSelectedObjects();
bool IsObjectInSelectBox(const zelda3::RoomObject& object) const;
// Coordinate conversion
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;
// State management
void SetCurrentRoom(std::array<zelda3::Room, 0x128>* rooms, int room_id);
void SetPreviewObject(const zelda3::RoomObject& object, bool loaded);
// Selection state
const std::vector<size_t>& GetSelectedObjectIndices() const { return selected_object_indices_; }
const std::vector<size_t>& GetSelectedObjectIndices() const {
return selected_object_indices_;
}
bool IsObjectSelectActive() const { return object_select_active_; }
void ClearSelection();
// Context menu
void ShowContextMenu();
void HandleDeleteSelected();
void HandleCopySelected();
void HandlePasteObjects();
// Callbacks
void SetObjectPlacedCallback(std::function<void(const zelda3::RoomObject&)> callback) {
void SetObjectPlacedCallback(
std::function<void(const zelda3::RoomObject&)> callback) {
object_placed_callback_ = callback;
}
void SetCacheInvalidationCallback(std::function<void()> callback) {
@@ -70,11 +73,11 @@ class DungeonObjectInteraction {
gui::Canvas* canvas_;
std::array<zelda3::Room, 0x128>* rooms_ = nullptr;
int current_room_id_ = 0;
// Preview object state
zelda3::RoomObject preview_object_{0, 0, 0, 0, 0};
bool object_loaded_ = false;
// Drag and select infrastructure
bool is_dragging_ = false;
bool is_selecting_ = false;
@@ -83,17 +86,17 @@ class DungeonObjectInteraction {
ImVec2 select_start_pos_;
ImVec2 select_current_pos_;
std::vector<int> selected_objects_;
// Object selection rectangle (like OverworldEditor)
bool object_select_active_ = false;
ImVec2 object_select_start_;
ImVec2 object_select_end_;
std::vector<size_t> selected_object_indices_;
// Callbacks
std::function<void(const zelda3::RoomObject&)> object_placed_callback_;
std::function<void()> cache_invalidation_callback_;
// Clipboard for copy/paste
std::vector<zelda3::RoomObject> clipboard_;
bool has_clipboard_data_ = false;

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

@@ -1,19 +1,19 @@
#include "dungeon_object_selector.h"
#include <algorithm>
#include <iterator>
#include <cstring>
#include <iterator>
#include "app/platform/window.h"
#include "app/gfx/resource/arena.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gui/canvas/canvas.h"
#include "app/gui/widgets/asset_browser.h"
#include "app/platform/window.h"
#include "app/rom.h"
#include "zelda3/dungeon/room.h"
#include "imgui/imgui.h"
#include "zelda3/dungeon/dungeon_editor_system.h"
#include "zelda3/dungeon/dungeon_object_editor.h"
#include "imgui/imgui.h"
#include "zelda3/dungeon/room.h"
namespace yaze::editor {
@@ -26,7 +26,7 @@ using ImGui::Separator;
void DungeonObjectSelector::DrawTileSelector() {
if (ImGui::BeginTabBar("##TabBar", ImGuiTabBarFlags_FittingPolicyScroll)) {
if (ImGui::BeginTabItem("Room Graphics")) {
if (ImGuiID child_id = ImGui::GetID((void *)(intptr_t)3);
if (ImGuiID child_id = ImGui::GetID((void*)(intptr_t)3);
BeginChild(child_id, ImGui::GetContentRegionAvail(), true,
ImGuiWindowFlags_AlwaysVerticalScrollbar)) {
DrawRoomGraphics();
@@ -45,17 +45,25 @@ void DungeonObjectSelector::DrawTileSelector() {
void DungeonObjectSelector::DrawObjectRenderer() {
// 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, 400);
ImGui::TableSetupColumn("Preview Canvas", ImGuiTableColumnFlags_WidthStretch);
if (ImGui::BeginTable(
"DungeonObjectEditorTable", 2,
ImGuiTableFlags_Resizable | ImGuiTableFlags_Reorderable |
ImGuiTableFlags_Hideable | ImGuiTableFlags_BordersOuter |
ImGuiTableFlags_BordersV,
ImVec2(0, 0))) {
ImGui::TableSetupColumn("Object Browser", ImGuiTableColumnFlags_WidthFixed,
400);
ImGui::TableSetupColumn("Preview Canvas",
ImGuiTableColumnFlags_WidthStretch);
ImGui::TableHeadersRow();
// Left column: AssetBrowser for object selection
ImGui::TableNextColumn();
ImGui::BeginChild("AssetBrowser", ImVec2(0, 0), true, ImGuiWindowFlags_AlwaysVerticalScrollbar);
ImGui::BeginChild("AssetBrowser", ImVec2(0, 0), true,
ImGuiWindowFlags_AlwaysVerticalScrollbar);
DrawObjectAssetBrowser();
ImGui::EndChild();
// Right column: Preview and placement controls
@@ -67,13 +75,13 @@ void DungeonObjectSelector::DrawObjectRenderer() {
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();
@@ -101,19 +109,19 @@ void DungeonObjectSelector::DrawObjectRenderer() {
ImGui::Text("Position: (%d, %d)", preview_object_.x_, preview_object_.y_);
ImGui::Text("Size: 0x%02X", preview_object_.size_);
ImGui::Text("Layer: %d", static_cast<int>(preview_object_.layer_));
// Add object placement controls
ImGui::Separator();
ImGui::Text("Placement Controls:");
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")) {
// TODO: Implement object placement in the main canvas
ImGui::Text("Object placed at (%d, %d)", place_x, place_y);
}
ImGui::End();
}
}
@@ -121,129 +129,156 @@ void DungeonObjectSelector::DrawObjectRenderer() {
void DungeonObjectSelector::DrawObjectBrowser() {
static int selected_object_type = 0;
static int selected_object_id = 0;
// Object type selector
const char* object_types[] = {"Type 1 (0x00-0xFF)", "Type 2 (0x100-0x1FF)", "Type 3 (0x200+)"};
const char* object_types[] = {"Type 1 (0x00-0xFF)", "Type 2 (0x100-0x1FF)",
"Type 3 (0x200+)"};
if (ImGui::Combo("Object Type", &selected_object_type, object_types, 3)) {
selected_object_id = 0; // Reset selection when changing type
selected_object_id = 0; // Reset selection when changing type
}
ImGui::Separator();
// Object list with previews - optimized for 300px column width
const int preview_size = 48; // Larger 48x48 pixel preview for better visibility
const int items_per_row = 5; // 5 items per row to fit in 300px column
const int preview_size =
48; // Larger 48x48 pixel preview for better visibility
const int items_per_row = 5; // 5 items per row to fit in 300px column
if (rom_ && rom_->is_loaded()) {
auto palette = rom_->palette_group().dungeon_main[current_palette_group_id_];
auto palette =
rom_->palette_group().dungeon_main[current_palette_group_id_];
// Determine object range based on type
int start_id, end_id;
switch (selected_object_type) {
case 0: start_id = 0x00; end_id = 0xFF; break;
case 1: start_id = 0x100; end_id = 0x1FF; break;
case 2: start_id = 0x200; end_id = 0x2FF; break;
default: start_id = 0x00; end_id = 0xFF; break;
case 0:
start_id = 0x00;
end_id = 0xFF;
break;
case 1:
start_id = 0x100;
end_id = 0x1FF;
break;
case 2:
start_id = 0x200;
end_id = 0x2FF;
break;
default:
start_id = 0x00;
end_id = 0xFF;
break;
}
// Create a grid layout for object previews
int current_row = 0;
int current_col = 0;
for (int obj_id = start_id; obj_id <= end_id && obj_id <= start_id + 63; ++obj_id) { // Limit to 64 objects for performance
for (int obj_id = start_id; obj_id <= end_id && obj_id <= start_id + 63;
++obj_id) { // Limit to 64 objects for performance
// Create object for preview
auto test_object = zelda3::RoomObject(obj_id, 0, 0, 0x12, 0);
test_object.set_rom(rom_);
test_object.EnsureTilesLoaded();
// Calculate position in grid - better sizing for 300px column
float available_width = ImGui::GetContentRegionAvail().x;
float spacing = ImGui::GetStyle().ItemSpacing.x;
float item_width = (available_width - (items_per_row - 1) * spacing) / items_per_row;
float item_height = preview_size + 30; // Preview + text (reduced padding)
float item_width =
(available_width - (items_per_row - 1) * spacing) / items_per_row;
float item_height =
preview_size + 30; // Preview + text (reduced padding)
ImGui::PushID(obj_id);
// Create a selectable button with preview
bool is_selected = (selected_object_id == obj_id);
if (ImGui::Selectable("", is_selected, ImGuiSelectableFlags_None, ImVec2(item_width, item_height))) {
if (ImGui::Selectable("", is_selected, ImGuiSelectableFlags_None,
ImVec2(item_width, item_height))) {
selected_object_id = obj_id;
// Update preview object
preview_object_ = test_object;
preview_palette_ = palette;
object_loaded_ = true;
// Notify the main editor that an object was selected
if (object_selected_callback_) {
object_selected_callback_(preview_object_);
}
}
// Draw preview image
ImVec2 cursor_pos = ImGui::GetCursorScreenPos();
ImVec2 preview_pos = ImVec2(cursor_pos.x + (item_width - preview_size) / 2,
cursor_pos.y - item_height + 5);
ImVec2 preview_pos =
ImVec2(cursor_pos.x + (item_width - preview_size) / 2,
cursor_pos.y - item_height + 5);
// Draw simplified primitive preview for object selector
ImGui::SetCursorScreenPos(preview_pos);
// 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);
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);
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);
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());
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::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();
// Try to get object name
std::string object_name = "Unknown";
if (obj_id < 0x100) { // Type1RoomObjectNames has 248 elements (0-247, 0x00-0xF7)
if (obj_id <
0x100) { // Type1RoomObjectNames has 248 elements (0-247, 0x00-0xF7)
if (obj_id < std::size(zelda3::Type1RoomObjectNames)) {
const char* name_ptr = zelda3::Type1RoomObjectNames[obj_id];
if (name_ptr != nullptr) {
object_name = std::string(name_ptr);
}
}
} else if (obj_id < 0x140) { // Type2RoomObjectNames has 64 elements (0x100-0x13F)
} else if (obj_id <
0x140) { // Type2RoomObjectNames has 64 elements (0x100-0x13F)
int type2_index = obj_id - 0x100;
if (type2_index >= 0 && type2_index < std::size(zelda3::Type2RoomObjectNames)) {
if (type2_index >= 0 &&
type2_index < std::size(zelda3::Type2RoomObjectNames)) {
const char* name_ptr = zelda3::Type2RoomObjectNames[type2_index];
if (name_ptr != nullptr) {
object_name = std::string(name_ptr);
}
}
} else if (obj_id < 0x1C0) { // Type3RoomObjectNames has 128 elements (0x140-0x1BF)
} else if (
obj_id <
0x1C0) { // Type3RoomObjectNames has 128 elements (0x140-0x1BF)
int type3_index = obj_id - 0x140;
if (type3_index >= 0 && type3_index < std::size(zelda3::Type3RoomObjectNames)) {
if (type3_index >= 0 &&
type3_index < std::size(zelda3::Type3RoomObjectNames)) {
const char* name_ptr = zelda3::Type3RoomObjectNames[type3_index];
if (name_ptr != nullptr) {
object_name = std::string(name_ptr);
}
}
}
// Draw object name with better sizing
ImGui::SetCursorScreenPos(ImVec2(cursor_pos.x + 2, cursor_pos.y - 8));
ImGui::PushStyleColor(ImGuiCol_Text, IM_COL32(200, 200, 200, 255));
@@ -253,9 +288,9 @@ void DungeonObjectSelector::DrawObjectBrowser() {
}
ImGui::Text("%s", object_name.c_str());
ImGui::PopStyleColor();
ImGui::PopID();
// Move to next position
current_col++;
if (current_col >= items_per_row) {
@@ -269,9 +304,9 @@ void DungeonObjectSelector::DrawObjectBrowser() {
} else {
ImGui::Text("ROM not loaded");
}
ImGui::Separator();
// Selected object info
if (object_loaded_) {
ImGui::Text("Selected: 0x%03X", selected_object_id);
@@ -287,19 +322,19 @@ void DungeonObjectSelector::Draw() {
DrawObjectRenderer();
ImGui::EndTabItem();
}
// Room Graphics tab - 8 bitmaps viewer
if (ImGui::BeginTabItem("Room Graphics")) {
DrawRoomGraphics();
ImGui::EndTabItem();
}
// Object Editor tab - experimental editor
if (ImGui::BeginTabItem("Object Editor")) {
DrawIntegratedEditingPanels();
ImGui::EndTabItem();
}
ImGui::EndTabBar();
}
}
@@ -309,46 +344,48 @@ void DungeonObjectSelector::DrawRoomGraphics() {
room_gfx_canvas_.DrawBackground();
room_gfx_canvas_.DrawContextMenu();
room_gfx_canvas_.DrawTileSelector(32);
if (rom_ && rom_->is_loaded() && rooms_) {
int active_room_id = current_room_id_;
auto& room = (*rooms_)[active_room_id];
auto blocks = room.blocks();
// Load graphics for this room if not already loaded
if (blocks.empty()) {
room.LoadRoomGraphics(room.blockset);
blocks = room.blocks();
}
int current_block = 0;
const int max_blocks_per_row = 2; // 2 blocks per row for 300px column
const int block_width = 128; // Reduced size to fit column
const int block_height = 32; // Reduced height
const int max_blocks_per_row = 2; // 2 blocks per row for 300px column
const int block_width = 128; // Reduced size to fit column
const int block_height = 32; // Reduced height
for (int block : blocks) {
if (current_block >= 16) break; // Only show first 16 blocks
if (current_block >= 16)
break; // Only show first 16 blocks
// Ensure the graphics sheet is loaded and has a valid texture
if (block < gfx::Arena::Get().gfx_sheets().size()) {
auto& gfx_sheet = gfx::Arena::Get().gfx_sheets()[block];
// Calculate position in a grid layout instead of horizontal concatenation
int row = current_block / max_blocks_per_row;
int col = current_block % max_blocks_per_row;
int x = room_gfx_canvas_.zero_point().x + 2 + (col * block_width);
int y = room_gfx_canvas_.zero_point().y + 2 + (row * block_height);
// Ensure we don't exceed canvas bounds
if (x + block_width <= room_gfx_canvas_.zero_point().x + room_gfx_canvas_.width() &&
y + block_height <= room_gfx_canvas_.zero_point().y + room_gfx_canvas_.height()) {
if (x + block_width <=
room_gfx_canvas_.zero_point().x + room_gfx_canvas_.width() &&
y + block_height <=
room_gfx_canvas_.zero_point().y + room_gfx_canvas_.height()) {
// Only draw if the texture is valid
if (gfx_sheet.texture() != 0) {
room_gfx_canvas_.draw_list()->AddImage(
(ImTextureID)(intptr_t)gfx_sheet.texture(),
ImVec2(x, y),
(ImTextureID)(intptr_t)gfx_sheet.texture(), ImVec2(x, y),
ImVec2(x + block_width, y + block_height));
}
}
@@ -421,13 +458,14 @@ void DungeonObjectSelector::DrawCompactObjectEditor() {
}
auto& editor = *object_editor_;
ImGui::Text("Object Editor");
Separator();
// Display current editing mode
auto mode = editor.GetMode();
const char *mode_names[] = {"Select", "Insert", "Delete", "Edit", "Layer", "Preview"};
const char* mode_names[] = {"Select", "Insert", "Delete",
"Edit", "Layer", "Preview"};
ImGui::Text("Mode: %s", mode_names[static_cast<int>(mode)]);
// Compact mode selection
@@ -486,58 +524,60 @@ 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
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
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
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
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
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
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
return IM_COL32(105, 105, 105, 255); // Dim gray for decorations
} else {
return IM_COL32(96, 96, 96, 255); // Default gray
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
return "■"; // Wall
} else if (object_id >= 0x20 && object_id <= 0x2F) {
return "□"; // Floor
return "□"; // Floor
} else if (object_id == 0xF9 || object_id == 0xFA) {
return "⬛"; // Chest
return "⬛"; // Chest
} else if (object_id >= 0x17 && object_id <= 0x1E) {
return "◊"; // Door
return "◊"; // Door
} else if (object_id == 0x2F || object_id == 0x2B) {
return "●"; // Pot
return "●"; // Pot
} else if (object_id >= 0x138 && object_id <= 0x13B) {
return "▲"; // Stairs
return "▲"; // Stairs
} else if (object_id >= 0x30 && object_id <= 0x3F) {
return "◆"; // Decoration
return "◆"; // Decoration
} else {
return "?"; // Unknown
return "?"; // Unknown
}
}
void DungeonObjectSelector::RenderObjectPrimitive(const zelda3::RoomObject& object, int x, int y) {
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));
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);
@@ -545,144 +585,151 @@ void DungeonObjectSelector::RenderObjectPrimitive(const zelda3::RoomObject& obje
void DungeonObjectSelector::DrawObjectAssetBrowser() {
ImGui::SeparatorText("Dungeon Objects");
// Debug info
ImGui::Text("Asset Browser Debug: Available width: %.1f", ImGui::GetContentRegionAvail().x);
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"};
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)));
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)) {
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)) {
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_];
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_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);
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);
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);
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
case 1: // Walls
return obj_id >= 0x10 && obj_id <= 0x1F;
case 2: // Floors
case 2: // Floors
return obj_id >= 0x20 && obj_id <= 0x2F;
case 3: // Chests
case 3: // Chests
return obj_id == 0xF9 || obj_id == 0xFA;
case 4: // Doors
case 4: // Doors
return obj_id >= 0x17 && obj_id <= 0x1E;
case 5: // Decorations
case 5: // Decorations
return obj_id >= 0x30 && obj_id <= 0x3F;
case 6: // Stairs
case 6: // Stairs
return obj_id >= 0x138 && obj_id <= 0x13B;
default: // All
default: // All
return true;
}
}
void DungeonObjectSelector::CalculateObjectDimensions(const zelda3::RoomObject& object, int& width, int& height) {
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
width = 16 + size_x * 16; // Each unit adds 16 pixels
height = 16;
} else if (size_y > size_x) {
// Vertical wall
@@ -698,7 +745,7 @@ void DungeonObjectSelector::CalculateObjectDimensions(const zelda3::RoomObject&
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);
@@ -708,12 +755,12 @@ 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);
}
@@ -725,7 +772,7 @@ void DungeonObjectSelector::DrawCompactSpriteEditor() {
}
auto& system = **dungeon_editor_system_;
ImGui::Text("Sprite Editor");
Separator();
@@ -740,7 +787,7 @@ void DungeonObjectSelector::DrawCompactSpriteEditor() {
// Show first few sprites in compact format
int display_count = std::min(3, static_cast<int>(sprites.size()));
for (int i = 0; i < display_count; ++i) {
const auto &sprite = sprites[i];
const auto& sprite = sprites[i];
ImGui::Text("ID:%d Type:%d (%d,%d)", sprite.sprite_id,
static_cast<int>(sprite.type), sprite.x, sprite.y);
}
@@ -785,7 +832,7 @@ void DungeonObjectSelector::DrawCompactItemEditor() {
}
auto& system = **dungeon_editor_system_;
ImGui::Text("Item Editor");
Separator();
@@ -800,7 +847,7 @@ void DungeonObjectSelector::DrawCompactItemEditor() {
// Show first few items in compact format
int display_count = std::min(3, static_cast<int>(items.size()));
for (int i = 0; i < display_count; ++i) {
const auto &item = items[i];
const auto& item = items[i];
ImGui::Text("ID:%d Type:%d (%d,%d)", item.item_id,
static_cast<int>(item.type), item.x, item.y);
}
@@ -846,7 +893,7 @@ void DungeonObjectSelector::DrawCompactEntranceEditor() {
}
auto& system = **dungeon_editor_system_;
ImGui::Text("Entrance Editor");
Separator();
@@ -858,7 +905,7 @@ void DungeonObjectSelector::DrawCompactEntranceEditor() {
auto entrances = entrances_result.value();
ImGui::Text("Entrances: %zu", entrances.size());
for (const auto &entrance : entrances) {
for (const auto& entrance : entrances) {
ImGui::Text("ID:%d -> Room:%d (%d,%d)", entrance.entrance_id,
entrance.target_room_id, entrance.target_x,
entrance.target_y);
@@ -884,7 +931,8 @@ void DungeonObjectSelector::DrawCompactEntranceEditor() {
ImGui::InputInt("Target Y", &target_y);
if (ImGui::Button("Connect")) {
auto status = system.ConnectRooms(current_room, target_room_id, source_x, source_y, target_x, target_y);
auto status = system.ConnectRooms(current_room, target_room_id, source_x,
source_y, target_x, target_y);
if (!status.ok()) {
ImGui::Text("Error connecting rooms");
}
@@ -898,7 +946,7 @@ void DungeonObjectSelector::DrawCompactDoorEditor() {
}
auto& system = **dungeon_editor_system_;
ImGui::Text("Door Editor");
Separator();
@@ -910,7 +958,7 @@ void DungeonObjectSelector::DrawCompactDoorEditor() {
auto doors = doors_result.value();
ImGui::Text("Doors: %zu", doors.size());
for (const auto &door : doors) {
for (const auto& door : doors) {
ImGui::Text("ID:%d (%d,%d) -> Room:%d", door.door_id, door.x, door.y,
door.target_room_id);
}
@@ -959,7 +1007,7 @@ void DungeonObjectSelector::DrawCompactChestEditor() {
}
auto& system = **dungeon_editor_system_;
ImGui::Text("Chest Editor");
Separator();
@@ -971,7 +1019,7 @@ void DungeonObjectSelector::DrawCompactChestEditor() {
auto chests = chests_result.value();
ImGui::Text("Chests: %zu", chests.size());
for (const auto &chest : chests) {
for (const auto& chest : chests) {
ImGui::Text("ID:%d (%d,%d) Item:%d", chest.chest_id, chest.x, chest.y,
chest.item_id);
}
@@ -1016,16 +1064,16 @@ void DungeonObjectSelector::DrawCompactPropertiesEditor() {
}
auto& system = **dungeon_editor_system_;
ImGui::Text("Room Properties");
Separator();
auto current_room = system.GetCurrentRoom();
auto properties_result = system.GetRoomProperties(current_room);
if (properties_result.ok()) {
auto properties = properties_result.value();
static char room_name[128] = {0};
static int dungeon_id = 0;
static int floor_level = 0;
@@ -1060,7 +1108,7 @@ void DungeonObjectSelector::DrawCompactPropertiesEditor() {
new_properties.is_boss_room = is_boss_room;
new_properties.is_save_room = is_save_room;
new_properties.music_id = music_id;
auto status = system.SetRoomProperties(current_room, new_properties);
if (!status.ok()) {
ImGui::Text("Error saving properties");
@@ -1073,7 +1121,7 @@ void DungeonObjectSelector::DrawCompactPropertiesEditor() {
// Dungeon settings summary
Separator();
ImGui::Text("Dungeon Settings");
auto dungeon_settings_result = system.GetDungeonSettings();
if (dungeon_settings_result.ok()) {
auto settings = dungeon_settings_result.value();

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

@@ -4,10 +4,10 @@
#include "app/gui/canvas/canvas.h"
#include "app/rom.h"
// object_renderer.h removed - using ObjectDrawer for production rendering
#include "zelda3/dungeon/dungeon_object_editor.h"
#include "zelda3/dungeon/dungeon_editor_system.h"
#include "app/gfx/types/snes_palette.h"
#include "imgui/imgui.h"
#include "zelda3/dungeon/dungeon_editor_system.h"
#include "zelda3/dungeon/dungeon_object_editor.h"
namespace yaze {
namespace editor {
@@ -23,20 +23,17 @@ class DungeonObjectSelector {
void DrawObjectRenderer();
void DrawIntegratedEditingPanels();
void Draw();
void set_rom(Rom* rom) {
rom_ = rom;
}
void SetRom(Rom* rom) {
rom_ = rom;
}
void set_rom(Rom* rom) { rom_ = rom; }
void SetRom(Rom* rom) { rom_ = rom; }
Rom* rom() const { return rom_; }
// Editor system access
void set_dungeon_editor_system(std::unique_ptr<zelda3::DungeonEditorSystem>* system) {
dungeon_editor_system_ = system;
void set_dungeon_editor_system(
std::unique_ptr<zelda3::DungeonEditorSystem>* system) {
dungeon_editor_system_ = system;
}
void set_object_editor(std::unique_ptr<zelda3::DungeonObjectEditor>* editor) {
void set_object_editor(std::unique_ptr<zelda3::DungeonObjectEditor>* editor) {
object_editor_ = editor ? editor->get() : nullptr;
}
@@ -45,19 +42,27 @@ class DungeonObjectSelector {
void set_current_room_id(int room_id) { current_room_id_ = room_id; }
// Palette access
void set_current_palette_group_id(uint64_t id) { current_palette_group_id_ = id; }
void SetCurrentPaletteGroup(const gfx::PaletteGroup& palette_group) { current_palette_group_ = palette_group; }
void SetCurrentPaletteId(uint64_t palette_id) { current_palette_id_ = palette_id; }
void set_current_palette_group_id(uint64_t id) {
current_palette_group_id_ = id;
}
void SetCurrentPaletteGroup(const gfx::PaletteGroup& palette_group) {
current_palette_group_ = palette_group;
}
void SetCurrentPaletteId(uint64_t palette_id) {
current_palette_id_ = palette_id;
}
// Object selection callbacks
void SetObjectSelectedCallback(std::function<void(const zelda3::RoomObject&)> callback) {
void SetObjectSelectedCallback(
std::function<void(const zelda3::RoomObject&)> callback) {
object_selected_callback_ = callback;
}
void SetObjectPlacementCallback(std::function<void(const zelda3::RoomObject&)> 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_; }
@@ -67,16 +72,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 CalculateObjectDimensions(const zelda3::RoomObject& object, int& width,
int& height);
void PlaceObjectAtPosition(int x, int y);
void DrawCompactItemEditor();
void DrawCompactEntranceEditor();
@@ -85,32 +91,34 @@ class DungeonObjectSelector {
void DrawCompactPropertiesEditor();
Rom* rom_ = nullptr;
gui::Canvas room_gfx_canvas_{"##RoomGfxCanvas", ImVec2(0x100 + 1, 0x10 * 0x40 + 1)};
gui::Canvas room_gfx_canvas_{"##RoomGfxCanvas",
ImVec2(0x100 + 1, 0x10 * 0x40 + 1)};
gui::Canvas object_canvas_;
// ObjectRenderer removed - using ObjectDrawer in Room::RenderObjectsToBackground()
// Editor systems
std::unique_ptr<zelda3::DungeonEditorSystem>* dungeon_editor_system_ = nullptr;
std::unique_ptr<zelda3::DungeonEditorSystem>* dungeon_editor_system_ =
nullptr;
zelda3::DungeonObjectEditor* object_editor_ = nullptr;
// Room data
std::array<zelda3::Room, 0x128>* rooms_ = nullptr;
int current_room_id_ = 0;
// Palette data
uint64_t current_palette_group_id_ = 0;
uint64_t current_palette_id_ = 0;
gfx::PaletteGroup current_palette_group_;
// Object preview system
zelda3::RoomObject preview_object_{0, 0, 0, 0, 0};
gfx::SnesPalette preview_palette_;
bool object_loaded_ = false;
// 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;
};

95
src/app/editor/dungeon/dungeon_room_loader.cc
View File

@@ -1,15 +1,15 @@
#include "dungeon_room_loader.h"
#include <algorithm>
#include <map>
#include <future>
#include <thread>
#include <map>
#include <mutex>
#include <thread>
#include "app/gfx/debug/performance/performance_profiler.h"
#include "app/gfx/types/snes_palette.h"
#include "zelda3/dungeon/room.h"
#include "util/log.h"
#include "zelda3/dungeon/room.h"
namespace yaze::editor {
@@ -27,55 +27,60 @@ absl::Status DungeonRoomLoader::LoadRoom(int room_id, zelda3::Room& room) {
return absl::OkStatus();
}
absl::Status DungeonRoomLoader::LoadAllRooms(std::array<zelda3::Room, 0x128>& rooms) {
absl::Status DungeonRoomLoader::LoadAllRooms(
std::array<zelda3::Room, 0x128>& rooms) {
if (!rom_ || !rom_->is_loaded()) {
return absl::FailedPreconditionError("ROM not loaded");
}
constexpr int kTotalRooms = 0x100 + 40; // 296 rooms
constexpr int kMaxConcurrency = 8; // Reasonable thread limit for room loading
constexpr int kTotalRooms = 0x100 + 40; // 296 rooms
constexpr int kMaxConcurrency =
8; // Reasonable thread limit for room loading
// Determine optimal number of threads
const int max_concurrency = std::min(kMaxConcurrency,
static_cast<int>(std::thread::hardware_concurrency()));
const int rooms_per_thread = (kTotalRooms + max_concurrency - 1) / max_concurrency;
LOG_DEBUG("Dungeon", "Loading %d dungeon rooms using %d threads (%d rooms per thread)",
kTotalRooms, max_concurrency, rooms_per_thread);
const int max_concurrency = std::min(
kMaxConcurrency, static_cast<int>(std::thread::hardware_concurrency()));
const int rooms_per_thread =
(kTotalRooms + max_concurrency - 1) / max_concurrency;
LOG_DEBUG("Dungeon",
"Loading %d dungeon rooms using %d threads (%d rooms per thread)",
kTotalRooms, max_concurrency, rooms_per_thread);
// Thread-safe data structures for collecting results
std::mutex results_mutex;
std::vector<std::pair<int, zelda3::RoomSize>> room_size_results;
std::vector<std::pair<int, ImVec4>> room_palette_results;
// Process rooms in parallel batches
std::vector<std::future<absl::Status>> futures;
for (int thread_id = 0; thread_id < max_concurrency; ++thread_id) {
auto task = [this, &rooms, thread_id, rooms_per_thread, &results_mutex,
&room_size_results, &room_palette_results, kTotalRooms]() -> absl::Status {
auto task = [this, &rooms, thread_id, rooms_per_thread, &results_mutex,
&room_size_results, &room_palette_results,
kTotalRooms]() -> absl::Status {
const int start_room = thread_id * rooms_per_thread;
const int end_room = std::min(start_room + rooms_per_thread, kTotalRooms);
auto dungeon_man_pal_group = rom_->palette_group().dungeon_main;
for (int i = start_room; i < end_room; ++i) {
// Load room data (this is the expensive operation)
rooms[i] = zelda3::LoadRoomFromRom(rom_, i);
// Calculate room size
auto room_size = zelda3::CalculateRoomSize(rom_, i);
// Load room objects
rooms[i].LoadObjects();
// Process palette
auto dungeon_palette_ptr = rom_->paletteset_ids[rooms[i].palette][0];
auto palette_id = rom_->ReadWord(0xDEC4B + dungeon_palette_ptr);
if (palette_id.status() == absl::OkStatus()) {
int p_id = palette_id.value() / 180;
auto color = dungeon_man_pal_group[p_id][3];
// Thread-safe collection of results
{
std::lock_guard<std::mutex> lock(results_mutex);
@@ -84,28 +89,28 @@ absl::Status DungeonRoomLoader::LoadAllRooms(std::array<zelda3::Room, 0x128>& ro
}
}
}
return absl::OkStatus();
};
futures.emplace_back(std::async(std::launch::async, task));
}
// Wait for all threads to complete
for (auto& future : futures) {
RETURN_IF_ERROR(future.get());
}
// Process collected results on main thread
{
gfx::ScopedTimer postprocess_timer("DungeonRoomLoader::PostProcessResults");
// Sort results by room ID for consistent ordering
std::sort(room_size_results.begin(), room_size_results.end(),
std::sort(room_size_results.begin(), room_size_results.end(),
[](const auto& a, const auto& b) { return a.first < b.first; });
std::sort(room_palette_results.begin(), room_palette_results.end(),
[](const auto& a, const auto& b) { return a.first < b.first; });
// Process room size results
for (const auto& [room_id, room_size] : room_size_results) {
room_size_pointers_.push_back(room_size.room_size_pointer);
@@ -114,22 +119,23 @@ absl::Status DungeonRoomLoader::LoadAllRooms(std::array<zelda3::Room, 0x128>& ro
room_size_addresses_[room_id] = room_size.room_size_pointer;
}
}
// Process palette results
for (const auto& [palette_id, color] : room_palette_results) {
room_palette_[palette_id] = color;
}
}
LoadDungeonRoomSize();
return absl::OkStatus();
}
absl::Status DungeonRoomLoader::LoadRoomEntrances(std::array<zelda3::RoomEntrance, 0x8C>& entrances) {
absl::Status DungeonRoomLoader::LoadRoomEntrances(
std::array<zelda3::RoomEntrance, 0x8C>& entrances) {
if (!rom_ || !rom_->is_loaded()) {
return absl::FailedPreconditionError("ROM not loaded");
}
// Load entrances
for (int i = 0; i < 0x07; ++i) {
entrances[i] = zelda3::RoomEntrance(rom_, i, true);
@@ -138,7 +144,7 @@ absl::Status DungeonRoomLoader::LoadRoomEntrances(std::array<zelda3::RoomEntranc
for (int i = 0; i < 0x85; ++i) {
entrances[i + 0x07] = zelda3::RoomEntrance(rom_, i, false);
}
return absl::OkStatus();
}
@@ -182,29 +188,30 @@ absl::Status DungeonRoomLoader::LoadAndRenderRoomGraphics(zelda3::Room& room) {
if (!rom_ || !rom_->is_loaded()) {
return absl::FailedPreconditionError("ROM not loaded");
}
// Load room graphics with proper blockset
room.LoadRoomGraphics(room.blockset);
// Render the room graphics to the graphics arena
room.RenderRoomGraphics();
return absl::OkStatus();
}
absl::Status DungeonRoomLoader::ReloadAllRoomGraphics(std::array<zelda3::Room, 0x128>& rooms) {
absl::Status DungeonRoomLoader::ReloadAllRoomGraphics(
std::array<zelda3::Room, 0x128>& rooms) {
if (!rom_ || !rom_->is_loaded()) {
return absl::FailedPreconditionError("ROM not loaded");
}
// Reload graphics for all rooms
for (auto& room : rooms) {
auto status = LoadAndRenderRoomGraphics(room);
if (!status.ok()) {
continue; // Log error but continue with other rooms
continue; // Log error but continue with other rooms
}
}
return absl::OkStatus();
}

27
src/app/editor/dungeon/dungeon_room_loader.h
View File

@@ -1,8 +1,8 @@
#ifndef YAZE_APP_EDITOR_DUNGEON_DUNGEON_ROOM_LOADER_H
#define YAZE_APP_EDITOR_DUNGEON_DUNGEON_ROOM_LOADER_H
#include <vector>
#include <unordered_map>
#include <vector>
#include "absl/status/status.h"
#include "app/rom.h"
@@ -21,29 +21,36 @@ namespace editor {
class DungeonRoomLoader {
public:
explicit DungeonRoomLoader(Rom* rom) : rom_(rom) {}
// Room loading
absl::Status LoadRoom(int room_id, zelda3::Room& room);
absl::Status LoadAllRooms(std::array<zelda3::Room, 0x128>& rooms);
absl::Status LoadRoomEntrances(std::array<zelda3::RoomEntrance, 0x8C>& entrances);
absl::Status LoadRoomEntrances(
std::array<zelda3::RoomEntrance, 0x8C>& entrances);
// Room size management
void LoadDungeonRoomSize();
uint64_t GetTotalRoomSize() const { return total_room_size_; }
// Room graphics
absl::Status LoadAndRenderRoomGraphics(zelda3::Room& room);
absl::Status ReloadAllRoomGraphics(std::array<zelda3::Room, 0x128>& rooms);
// Data access
const std::vector<int64_t>& GetRoomSizePointers() const { return room_size_pointers_; }
const std::vector<int64_t>& GetRoomSizePointers() const {
return room_size_pointers_;
}
const std::vector<int64_t>& GetRoomSizes() const { return room_sizes_; }
const std::unordered_map<int, int>& GetRoomSizeAddresses() const { return room_size_addresses_; }
const std::unordered_map<int, ImVec4>& GetRoomPalette() const { return room_palette_; }
const std::unordered_map<int, int>& GetRoomSizeAddresses() const {
return room_size_addresses_;
}
const std::unordered_map<int, ImVec4>& GetRoomPalette() const {
return room_palette_;
}
private:
Rom* rom_;
std::vector<int64_t> room_size_pointers_;
std::vector<int64_t> room_sizes_;
std::unordered_map<int, int> room_size_addresses_;

10
src/app/editor/dungeon/dungeon_room_selector.cc
View File

@@ -1,10 +1,10 @@
#include "dungeon_room_selector.h"
#include "app/gui/core/input.h"
#include "zelda3/dungeon/room.h"
#include "zelda3/dungeon/room_entrance.h"
#include "imgui/imgui.h"
#include "util/hex.h"
#include "zelda3/dungeon/room.h"
#include "zelda3/dungeon/room_entrance.h"
namespace yaze::editor {
@@ -34,7 +34,7 @@ void DungeonRoomSelector::DrawRoomSelector() {
gui::InputHexWord("Room ID", &current_room_id_, 50.f, true);
if (ImGuiID child_id = ImGui::GetID((void *)(intptr_t)9);
if (ImGuiID child_id = ImGui::GetID((void*)(intptr_t)9);
BeginChild(child_id, ImGui::GetContentRegionAvail(), true,
ImGuiWindowFlags_AlwaysVerticalScrollbar)) {
int i = 0;
@@ -125,8 +125,8 @@ void DungeonRoomSelector::DrawEntranceSelector() {
entrance_name = std::string(zelda3::kEntranceNames[i]);
}
rom_->resource_label()->SelectableLabelWithNameEdit(
current_entrance_id_ == i, "Dungeon Entrance Names",
util::HexByte(i), entrance_name);
current_entrance_id_ == i, "Dungeon Entrance Names", util::HexByte(i),
entrance_name);
if (ImGui::IsItemClicked()) {
current_entrance_id_ = i;

24
src/app/editor/dungeon/dungeon_room_selector.h
View File

@@ -2,10 +2,10 @@
#define YAZE_APP_EDITOR_DUNGEON_DUNGEON_ROOM_SELECTOR_H
#include <functional>
#include "imgui/imgui.h"
#include "app/rom.h"
#include "zelda3/dungeon/room_entrance.h"
#include "imgui/imgui.h"
#include "zelda3/dungeon/room.h"
#include "zelda3/dungeon/room_entrance.h"
namespace yaze {
namespace editor {
@@ -20,29 +20,33 @@ class DungeonRoomSelector {
void Draw();
void DrawRoomSelector();
void DrawEntranceSelector();
void set_rom(Rom* rom) { rom_ = rom; }
Rom* rom() const { return rom_; }
// Room selection
void set_current_room_id(uint16_t room_id) { current_room_id_ = room_id; }
int current_room_id() const { return current_room_id_; }
void set_active_rooms(const ImVector<int>& rooms) { active_rooms_ = rooms; }
const ImVector<int>& active_rooms() const { return active_rooms_; }
ImVector<int>& mutable_active_rooms() { return active_rooms_; }
// Entrance selection
void set_current_entrance_id(int entrance_id) { current_entrance_id_ = entrance_id; }
void set_current_entrance_id(int entrance_id) {
current_entrance_id_ = entrance_id;
}
int current_entrance_id() const { return current_entrance_id_; }
// Room data access
void set_rooms(std::array<zelda3::Room, 0x128>* rooms) { rooms_ = rooms; }
void set_entrances(std::array<zelda3::RoomEntrance, 0x8C>* entrances) { entrances_ = entrances; }
void set_entrances(std::array<zelda3::RoomEntrance, 0x8C>* entrances) {
entrances_ = entrances;
}
// Callback for room selection events
void set_room_selected_callback(std::function<void(int)> callback) {
room_selected_callback_ = callback;
void set_room_selected_callback(std::function<void(int)> callback) {
room_selected_callback_ = callback;
}
private:
@@ -50,10 +54,10 @@ class DungeonRoomSelector {
uint16_t current_room_id_ = 0;
int current_entrance_id_ = 0;
ImVector<int> active_rooms_;
std::array<zelda3::Room, 0x128>* rooms_ = nullptr;
std::array<zelda3::RoomEntrance, 0x8C>* entrances_ = nullptr;
// Callback for room selection events
std::function<void(int)> room_selected_callback_;
};

18
src/app/editor/dungeon/dungeon_toolset.cc
View File

@@ -17,7 +17,8 @@ using ImGui::TableSetupColumn;
using ImGui::Text;
void DungeonToolset::Draw() {
if (BeginTable("DWToolset", 16, ImGuiTableFlags_SizingFixedFit, ImVec2(0, 0))) {
if (BeginTable("DWToolset", 16, ImGuiTableFlags_SizingFixedFit,
ImVec2(0, 0))) {
static std::array<const char*, 16> tool_names = {
"Undo", "Redo", "Separator", "All", "BG1", "BG2",
"BG3", "Separator", "Object", "Sprite", "Item", "Entrance",
@@ -28,13 +29,15 @@ void DungeonToolset::Draw() {
// Undo button
TableNextColumn();
if (Button(ICON_MD_UNDO)) {
if (undo_callback_) undo_callback_();
if (undo_callback_)
undo_callback_();
}
// Redo button
TableNextColumn();
if (Button(ICON_MD_REDO)) {
if (redo_callback_) redo_callback_();
if (redo_callback_)
redo_callback_();
}
// Separator
@@ -138,14 +141,17 @@ void DungeonToolset::Draw() {
// Palette button
TableNextColumn();
if (Button(ICON_MD_PALETTE)) {
if (palette_toggle_callback_) palette_toggle_callback_();
if (palette_toggle_callback_)
palette_toggle_callback_();
}
ImGui::EndTable();
}
ImGui::Separator();
ImGui::Text("Instructions: Click to place objects, Ctrl+Click to select, drag to move");
ImGui::Text(
"Instructions: Click to place objects, Ctrl+Click to select, drag to "
"move");
}
} // namespace yaze::editor

30
src/app/editor/dungeon/dungeon_toolset.h
View File

@@ -1,8 +1,8 @@
#ifndef YAZE_APP_EDITOR_DUNGEON_DUNGEON_TOOLSET_H
#define YAZE_APP_EDITOR_DUNGEON_DUNGEON_TOOLSET_H
#include <functional>
#include <array>
#include <functional>
#include "imgui/imgui.h"
@@ -24,9 +24,9 @@ class DungeonToolset {
kBackground3,
kBackgroundAny,
};
enum PlacementType {
kNoType,
enum PlacementType {
kNoType,
kObject, // Object editing mode
kSprite, // Sprite editing mode
kItem, // Item placement mode
@@ -37,26 +37,32 @@ class DungeonToolset {
};
DungeonToolset() = default;
void Draw();
// Getters
BackgroundType background_type() const { return background_type_; }
PlacementType placement_type() const { return placement_type_; }
// Setters
void set_background_type(BackgroundType type) { background_type_ = type; }
void set_placement_type(PlacementType type) { placement_type_ = type; }
// Callbacks
void SetUndoCallback(std::function<void()> callback) { undo_callback_ = callback; }
void SetRedoCallback(std::function<void()> callback) { redo_callback_ = callback; }
void SetPaletteToggleCallback(std::function<void()> callback) { palette_toggle_callback_ = callback; }
void SetUndoCallback(std::function<void()> callback) {
undo_callback_ = callback;
}
void SetRedoCallback(std::function<void()> callback) {
redo_callback_ = callback;
}
void SetPaletteToggleCallback(std::function<void()> callback) {
palette_toggle_callback_ = callback;
}
private:
BackgroundType background_type_ = kBackgroundAny;
PlacementType placement_type_ = kNoType;
// Callbacks for editor actions
std::function<void()> undo_callback_;
std::function<void()> redo_callback_;

22
src/app/editor/dungeon/dungeon_usage_tracker.cc
View File

@@ -4,11 +4,12 @@
namespace yaze::editor {
void DungeonUsageTracker::CalculateUsageStats(const std::array<zelda3::Room, 0x128>& rooms) {
void DungeonUsageTracker::CalculateUsageStats(
const std::array<zelda3::Room, 0x128>& rooms) {
blockset_usage_.clear();
spriteset_usage_.clear();
palette_usage_.clear();
for (const auto& room : rooms) {
if (blockset_usage_.find(room.blockset) == blockset_usage_.end()) {
blockset_usage_[room.blockset] = 1;
@@ -34,29 +35,29 @@ void DungeonUsageTracker::DrawUsageStats() {
if (ImGui::Button("Refresh")) {
ClearUsageStats();
}
ImGui::Text("Usage Statistics");
ImGui::Separator();
ImGui::Text("Blocksets: %zu used", blockset_usage_.size());
ImGui::Text("Spritesets: %zu used", spriteset_usage_.size());
ImGui::Text("Palettes: %zu used", palette_usage_.size());
ImGui::Separator();
// Detailed usage breakdown
if (ImGui::CollapsingHeader("Blockset Usage")) {
for (const auto& [blockset, count] : blockset_usage_) {
ImGui::Text("Blockset 0x%02X: %d rooms", blockset, count);
}
}
if (ImGui::CollapsingHeader("Spriteset Usage")) {
for (const auto& [spriteset, count] : spriteset_usage_) {
ImGui::Text("Spriteset 0x%02X: %d rooms", spriteset, count);
}
}
if (ImGui::CollapsingHeader("Palette Usage")) {
for (const auto& [palette, count] : palette_usage_) {
ImGui::Text("Palette 0x%02X: %d rooms", palette, count);
@@ -69,8 +70,9 @@ void DungeonUsageTracker::DrawUsageGrid() {
ImGui::Text("Usage grid visualization not yet implemented");
}
void DungeonUsageTracker::RenderSetUsage(const absl::flat_hash_map<uint16_t, int>& usage_map,
uint16_t& selected_set, int spriteset_offset) {
void DungeonUsageTracker::RenderSetUsage(
const absl::flat_hash_map<uint16_t, int>& usage_map, uint16_t& selected_set,
int spriteset_offset) {
// TODO: Implement set usage rendering
ImGui::Text("Set usage rendering not yet implemented");
}

26
src/app/editor/dungeon/dungeon_usage_tracker.h
View File

@@ -16,28 +16,36 @@ namespace editor {
class DungeonUsageTracker {
public:
DungeonUsageTracker() = default;
// Statistics calculation
void CalculateUsageStats(const std::array<zelda3::Room, 0x128>& rooms);
void DrawUsageStats();
void DrawUsageGrid();
void RenderSetUsage(const absl::flat_hash_map<uint16_t, int>& usage_map,
uint16_t& selected_set, int spriteset_offset = 0x00);
// Data access
const absl::flat_hash_map<uint16_t, int>& GetBlocksetUsage() const { return blockset_usage_; }
const absl::flat_hash_map<uint16_t, int>& GetSpritesetUsage() const { return spriteset_usage_; }
const absl::flat_hash_map<uint16_t, int>& GetPaletteUsage() const { return palette_usage_; }
const absl::flat_hash_map<uint16_t, int>& GetBlocksetUsage() const {
return blockset_usage_;
}
const absl::flat_hash_map<uint16_t, int>& GetSpritesetUsage() const {
return spriteset_usage_;
}
const absl::flat_hash_map<uint16_t, int>& GetPaletteUsage() const {
return palette_usage_;
}
// Selection state
uint16_t GetSelectedBlockset() const { return selected_blockset_; }
uint16_t GetSelectedSpriteset() const { return selected_spriteset_; }
uint16_t GetSelectedPalette() const { return selected_palette_; }
void SetSelectedBlockset(uint16_t blockset) { selected_blockset_ = blockset; }
void SetSelectedSpriteset(uint16_t spriteset) { selected_spriteset_ = spriteset; }
void SetSelectedSpriteset(uint16_t spriteset) {
selected_spriteset_ = spriteset;
}
void SetSelectedPalette(uint16_t palette) { selected_palette_ = palette; }
// Clear data
void ClearUsageStats();

200
src/app/editor/dungeon/object_editor_card.cc
View File

@@ -8,8 +8,12 @@
namespace yaze::editor {
ObjectEditorCard::ObjectEditorCard(gfx::IRenderer* renderer, Rom* rom, DungeonCanvasViewer* canvas_viewer)
: renderer_(renderer), rom_(rom), canvas_viewer_(canvas_viewer), object_selector_(rom) {
ObjectEditorCard::ObjectEditorCard(gfx::IRenderer* renderer, Rom* rom,
DungeonCanvasViewer* canvas_viewer)
: renderer_(renderer),
rom_(rom),
canvas_viewer_(canvas_viewer),
object_selector_(rom) {
emulator_preview_.Initialize(renderer, rom);
}
@@ -17,20 +21,22 @@ void ObjectEditorCard::Draw(bool* p_open) {
gui::EditorCard card("Object Editor", ICON_MD_CONSTRUCTION, p_open);
card.SetDefaultSize(450, 750);
card.SetPosition(gui::EditorCard::Position::Right);
if (card.Begin(p_open)) {
// Interaction mode controls at top (moved from tab)
ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.7f, 1.0f), "Mode:");
ImGui::SameLine();
if (ImGui::RadioButton("None", interaction_mode_ == InteractionMode::None)) {
if (ImGui::RadioButton("None",
interaction_mode_ == InteractionMode::None)) {
interaction_mode_ = InteractionMode::None;
canvas_viewer_->SetObjectInteractionEnabled(false);
canvas_viewer_->ClearPreviewObject();
}
ImGui::SameLine();
if (ImGui::RadioButton("Place", interaction_mode_ == InteractionMode::Place)) {
if (ImGui::RadioButton("Place",
interaction_mode_ == InteractionMode::Place)) {
interaction_mode_ = InteractionMode::Place;
canvas_viewer_->SetObjectInteractionEnabled(true);
if (has_preview_object_) {
@@ -38,40 +44,42 @@ void ObjectEditorCard::Draw(bool* p_open) {
}
}
ImGui::SameLine();
if (ImGui::RadioButton("Select", interaction_mode_ == InteractionMode::Select)) {
if (ImGui::RadioButton("Select",
interaction_mode_ == InteractionMode::Select)) {
interaction_mode_ = InteractionMode::Select;
canvas_viewer_->SetObjectInteractionEnabled(true);
canvas_viewer_->ClearPreviewObject();
}
ImGui::SameLine();
if (ImGui::RadioButton("Delete", interaction_mode_ == InteractionMode::Delete)) {
if (ImGui::RadioButton("Delete",
interaction_mode_ == InteractionMode::Delete)) {
interaction_mode_ = InteractionMode::Delete;
canvas_viewer_->SetObjectInteractionEnabled(true);
canvas_viewer_->ClearPreviewObject();
}
// Current object info
DrawSelectedObjectInfo();
ImGui::Separator();
// Tabbed interface for Browser and Preview
if (ImGui::BeginTabBar("##ObjectEditorTabs", ImGuiTabBarFlags_None)) {
// Tab 1: Object Browser
if (ImGui::BeginTabItem(ICON_MD_LIST " Browser")) {
DrawObjectSelector();
ImGui::EndTabItem();
}
// Tab 2: Emulator Preview (enhanced)
if (ImGui::BeginTabItem(ICON_MD_MONITOR " Preview")) {
DrawEmulatorPreview();
ImGui::EndTabItem();
}
ImGui::EndTabBar();
}
}
@@ -81,61 +89,61 @@ void ObjectEditorCard::Draw(bool* p_open) {
void ObjectEditorCard::DrawObjectSelector() {
ImGui::Text(ICON_MD_INFO " Select an object to place on the canvas");
ImGui::Separator();
// Text filter for objects
static char object_filter[256] = "";
ImGui::SetNextItemWidth(-1);
if (ImGui::InputTextWithHint("##ObjectFilter",
ICON_MD_SEARCH " Filter objects...",
if (ImGui::InputTextWithHint("##ObjectFilter",
ICON_MD_SEARCH " Filter objects...",
object_filter, sizeof(object_filter))) {
// Filter updated
}
ImGui::Separator();
// Object list with categories
if (ImGui::BeginChild("##ObjectList", ImVec2(0, 0), true)) {
// Floor objects
if (ImGui::CollapsingHeader(ICON_MD_GRID_ON " Floor Objects",
if (ImGui::CollapsingHeader(ICON_MD_GRID_ON " Floor Objects",
ImGuiTreeNodeFlags_DefaultOpen)) {
for (int i = 0; i < 0x100; i++) {
std::string filter_str = object_filter;
if (!filter_str.empty()) {
// Simple name-based filtering
std::string object_name = absl::StrFormat("Object %02X", i);
std::transform(filter_str.begin(), filter_str.end(),
filter_str.begin(), ::tolower);
std::transform(filter_str.begin(), filter_str.end(),
filter_str.begin(), ::tolower);
std::transform(object_name.begin(), object_name.end(),
object_name.begin(), ::tolower);
object_name.begin(), ::tolower);
if (object_name.find(filter_str) == std::string::npos) {
continue;
}
}
// Create preview icon with small canvas
ImGui::BeginGroup();
// Small preview canvas (32x32 pixels)
DrawObjectPreviewIcon(i, ImVec2(32, 32));
ImGui::SameLine();
// Object label and selection
std::string object_label = absl::StrFormat("%02X - Floor Object", i);
if (ImGui::Selectable(object_label.c_str(),
has_preview_object_ && preview_object_.id_ == i,
0, ImVec2(0, 32))) { // Match preview height
preview_object_ = zelda3::RoomObject{
static_cast<int16_t>(i), 0, 0, 0, 0};
if (ImGui::Selectable(object_label.c_str(),
has_preview_object_ && preview_object_.id_ == i,
0, ImVec2(0, 32))) { // Match preview height
preview_object_ =
zelda3::RoomObject{static_cast<int16_t>(i), 0, 0, 0, 0};
has_preview_object_ = true;
canvas_viewer_->SetPreviewObject(preview_object_);
canvas_viewer_->SetObjectInteractionEnabled(true);
interaction_mode_ = InteractionMode::Place;
}
ImGui::EndGroup();
if (ImGui::IsItemHovered()) {
ImGui::BeginTooltip();
ImGui::Text("Object ID: 0x%02X", i);
@@ -145,17 +153,17 @@ void ObjectEditorCard::DrawObjectSelector() {
}
}
}
// Wall objects
if (ImGui::CollapsingHeader(ICON_MD_BORDER_ALL " Wall Objects")) {
for (int i = 0; i < 0x50; i++) {
std::string object_label = absl::StrFormat(
"%s %02X - Wall Object", ICON_MD_BORDER_VERTICAL, i);
std::string object_label = absl::StrFormat("%s %02X - Wall Object",
ICON_MD_BORDER_VERTICAL, i);
if (ImGui::Selectable(object_label.c_str())) {
// Wall objects have special handling
preview_object_ = zelda3::RoomObject{
static_cast<int16_t>(i), 0, 0, 0, 1}; // layer=1 for walls
preview_object_ = zelda3::RoomObject{static_cast<int16_t>(i), 0, 0, 0,
1}; // layer=1 for walls
has_preview_object_ = true;
canvas_viewer_->SetPreviewObject(preview_object_);
canvas_viewer_->SetObjectInteractionEnabled(true);
@@ -163,22 +171,21 @@ void ObjectEditorCard::DrawObjectSelector() {
}
}
}
// Special objects
if (ImGui::CollapsingHeader(ICON_MD_STAR " Special Objects")) {
const char* special_objects[] = {
"Stairs Down", "Stairs Up", "Chest", "Door", "Pot", "Block",
"Switch", "Torch"
};
const char* special_objects[] = {"Stairs Down", "Stairs Up", "Chest",
"Door", "Pot", "Block",
"Switch", "Torch"};
for (int i = 0; i < IM_ARRAYSIZE(special_objects); i++) {
std::string object_label = absl::StrFormat(
"%s %s", ICON_MD_STAR, special_objects[i]);
std::string object_label =
absl::StrFormat("%s %s", ICON_MD_STAR, special_objects[i]);
if (ImGui::Selectable(object_label.c_str())) {
// Special object IDs start at 0xF8
preview_object_ = zelda3::RoomObject{
static_cast<int16_t>(0xF8 + i), 0, 0, 0, 2};
preview_object_ =
zelda3::RoomObject{static_cast<int16_t>(0xF8 + i), 0, 0, 0, 2};
has_preview_object_ = true;
canvas_viewer_->SetPreviewObject(preview_object_);
canvas_viewer_->SetObjectInteractionEnabled(true);
@@ -186,10 +193,10 @@ void ObjectEditorCard::DrawObjectSelector() {
}
}
}
ImGui::EndChild();
}
// Quick actions at bottom
if (ImGui::Button(ICON_MD_CLEAR " Clear Selection", ImVec2(-1, 0))) {
has_preview_object_ = false;
@@ -200,110 +207,115 @@ void ObjectEditorCard::DrawObjectSelector() {
}
void ObjectEditorCard::DrawEmulatorPreview() {
ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.7f, 1.0f),
ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.7f, 1.0f),
ICON_MD_INFO " Real-time object rendering preview");
ImGui::Separator();
// Toggle emulator preview visibility
ImGui::Checkbox("Enable Preview", &show_emulator_preview_);
ImGui::SameLine();
gui::HelpMarker("Uses SNES emulation to render objects accurately.\n"
"May impact performance.");
gui::HelpMarker(
"Uses SNES emulation to render objects accurately.\n"
"May impact performance.");
if (show_emulator_preview_) {
ImGui::Separator();
// Embed the emulator preview with improved layout
ImGui::BeginChild("##EmulatorPreviewRegion", ImVec2(0, 0), true);
emulator_preview_.Render();
ImGui::EndChild();
} else {
ImGui::Separator();
ImGui::TextDisabled(ICON_MD_PREVIEW " Preview disabled for performance");
ImGui::TextWrapped("Enable to see accurate object rendering using "
"SNES emulation.");
ImGui::TextWrapped(
"Enable to see accurate object rendering using "
"SNES emulation.");
}
}
// DrawInteractionControls removed - controls moved to top of card
void ObjectEditorCard::DrawObjectPreviewIcon(int object_id, const ImVec2& size) {
void ObjectEditorCard::DrawObjectPreviewIcon(int object_id,
const ImVec2& size) {
// Create a small preview box for the object
ImDrawList* draw_list = ImGui::GetWindowDrawList();
ImVec2 cursor_pos = ImGui::GetCursorScreenPos();
ImVec2 box_min = cursor_pos;
ImVec2 box_max = ImVec2(cursor_pos.x + size.x, cursor_pos.y + size.y);
// Draw background
draw_list->AddRectFilled(box_min, box_max, IM_COL32(40, 40, 45, 255));
draw_list->AddRect(box_min, box_max, IM_COL32(100, 100, 100, 255));
// Draw a simple representation based on object ID
// For now, use colored squares and icons as placeholders
// Later this can be replaced with actual object bitmaps
// Color based on object ID for visual variety
float hue = (object_id % 16) / 16.0f;
ImU32 obj_color = ImGui::ColorConvertFloat4ToU32(
ImVec4(0.5f + hue * 0.3f, 0.4f, 0.6f - hue * 0.2f, 1.0f));
// Draw inner colored square (16x16 in the center)
ImVec2 inner_min = ImVec2(cursor_pos.x + 8, cursor_pos.y + 8);
ImVec2 inner_max = ImVec2(cursor_pos.x + 24, cursor_pos.y + 24);
draw_list->AddRectFilled(inner_min, inner_max, obj_color);
draw_list->AddRect(inner_min, inner_max, IM_COL32(200, 200, 200, 255));
// Draw object ID text (very small)
std::string id_text = absl::StrFormat("%02X", object_id);
ImVec2 text_size = ImGui::CalcTextSize(id_text.c_str());
ImVec2 text_pos = ImVec2(
cursor_pos.x + (size.x - text_size.x) * 0.5f,
cursor_pos.y + size.y - text_size.y - 2);
ImVec2 text_pos = ImVec2(cursor_pos.x + (size.x - text_size.x) * 0.5f,
cursor_pos.y + size.y - text_size.y - 2);
draw_list->AddText(text_pos, IM_COL32(180, 180, 180, 255), id_text.c_str());
// Advance cursor
ImGui::Dummy(size);
}
void ObjectEditorCard::DrawSelectedObjectInfo() {
ImGui::BeginGroup();
// Show current object for placement
ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f),
ICON_MD_INFO " Current:");
ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f), ICON_MD_INFO " Current:");
if (has_preview_object_) {
ImGui::SameLine();
ImGui::Text("ID: 0x%02X", preview_object_.id_);
ImGui::SameLine();
ImGui::Text("Layer: %s",
preview_object_.layer_ == zelda3::RoomObject::BG1 ? "BG1" :
preview_object_.layer_ == zelda3::RoomObject::BG2 ? "BG2" : "BG3");
ImGui::Text("Layer: %s",
preview_object_.layer_ == zelda3::RoomObject::BG1 ? "BG1"
: preview_object_.layer_ == zelda3::RoomObject::BG2 ? "BG2"
: "BG3");
} else {
ImGui::SameLine();
ImGui::TextDisabled("None");
}
// Show selection count
auto& interaction = canvas_viewer_->object_interaction();
const auto& selected = interaction.GetSelectedObjectIndices();
ImGui::SameLine();
ImGui::Text("|");
ImGui::SameLine();
ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.4f, 1.0f),
ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.4f, 1.0f),
ICON_MD_CHECKLIST " Selected: %zu", selected.size());
ImGui::SameLine();
ImGui::Text("|");
ImGui::SameLine();
ImGui::Text("Mode: %s",
interaction_mode_ == InteractionMode::Place ? ICON_MD_ADD_BOX " Place" :
interaction_mode_ == InteractionMode::Select ? ICON_MD_CHECK_BOX " Select" :
interaction_mode_ == InteractionMode::Delete ? ICON_MD_DELETE " Delete" : "None");
ImGui::Text("Mode: %s", interaction_mode_ == InteractionMode::Place
? ICON_MD_ADD_BOX " Place"
: interaction_mode_ == InteractionMode::Select
? ICON_MD_CHECK_BOX " Select"
: interaction_mode_ == InteractionMode::Delete
? ICON_MD_DELETE " Delete"
: "None");
// Show quick actions for selections
if (!selected.empty()) {
ImGui::SameLine();
@@ -311,7 +323,7 @@ void ObjectEditorCard::DrawSelectedObjectInfo() {
interaction.ClearSelection();
}
}
ImGui::EndGroup();
}

38
src/app/editor/dungeon/object_editor_card.h
View File

@@ -5,10 +5,10 @@
#include <unordered_map>
#include "app/editor/dungeon/dungeon_canvas_viewer.h"
#include "app/gfx/backend/irenderer.h"
#include "app/gui/canvas/canvas.h"
#include "app/editor/dungeon/dungeon_object_selector.h"
#include "app/gfx/backend/irenderer.h"
#include "app/gui/app/editor_layout.h"
#include "app/gui/canvas/canvas.h"
#include "app/gui/widgets/dungeon_object_emulator_preview.h"
#include "app/rom.h"
#include "zelda3/dungeon/room_object.h"
@@ -28,51 +28,49 @@ namespace editor {
*/
class ObjectEditorCard {
public:
ObjectEditorCard(gfx::IRenderer* renderer, Rom* rom, DungeonCanvasViewer* canvas_viewer);
ObjectEditorCard(gfx::IRenderer* renderer, Rom* rom,
DungeonCanvasViewer* canvas_viewer);
// Main update function
void Draw(bool* p_open);
// Access to components
DungeonObjectSelector& object_selector() { return object_selector_; }
gui::DungeonObjectEmulatorPreview& emulator_preview() { return emulator_preview_; }
gui::DungeonObjectEmulatorPreview& emulator_preview() {
return emulator_preview_;
}
// Update current room context
void SetCurrentRoom(int room_id) { current_room_id_ = room_id; }
private:
void DrawObjectSelector();
void DrawEmulatorPreview();
void DrawInteractionControls();
void DrawSelectedObjectInfo();
void DrawObjectPreviewIcon(int object_id, const ImVec2& size);
Rom* rom_;
DungeonCanvasViewer* canvas_viewer_;
int current_room_id_ = 0;
// Components
DungeonObjectSelector object_selector_;
gui::DungeonObjectEmulatorPreview emulator_preview_;
// Object preview canvases (one per object type)
std::unordered_map<int, gui::Canvas> object_preview_canvases_;
// UI state
int selected_tab_ = 0;
bool show_emulator_preview_ = false; // Disabled by default for performance
bool show_object_list_ = true;
bool show_interaction_controls_ = true;
// Object interaction mode
enum class InteractionMode {
None,
Place,
Select,
Delete
};
enum class InteractionMode { None, Place, Select, Delete };
InteractionMode interaction_mode_ = InteractionMode::None;
// Selected object for placement
zelda3::RoomObject preview_object_{0, 0, 0, 0, 0};
bool has_preview_object_ = false;

26
src/app/editor/editor.h
View File

@@ -3,8 +3,8 @@
#include <array>
#include <cstddef>
#include <vector>
#include <functional>
#include <vector>
#include "absl/status/status.h"
#include "absl/status/statusor.h"
@@ -108,9 +108,9 @@ enum class EditorType {
};
constexpr std::array<const char*, 14> kEditorNames = {
"Unknown",
"Assembly", "Dungeon", "Emulator", "Graphics", "Music", "Overworld",
"Palette", "Screen", "Sprite", "Message", "Hex", "Agent", "Settings",
"Unknown", "Assembly", "Dungeon", "Emulator", "Graphics",
"Music", "Overworld", "Palette", "Screen", "Sprite",
"Message", "Hex", "Agent", "Settings",
};
/**
@@ -157,7 +157,9 @@ class Editor {
// ROM loading state helpers (default implementations)
virtual bool IsRomLoaded() const { return false; }
virtual std::string GetRomStatus() const { return "ROM state not implemented"; }
virtual std::string GetRomStatus() const {
return "ROM state not implemented";
}
protected:
bool active_ = false;
@@ -171,7 +173,7 @@ class Editor {
}
return base_title;
}
// Helper method to create session-aware card IDs for multi-session support
std::string MakeCardId(const std::string& base_id) const {
if (dependencies_.session_id > 0) {
@@ -181,18 +183,20 @@ class Editor {
}
// Helper method for ROM access with safety check
template<typename T>
absl::StatusOr<T> SafeRomAccess(std::function<T()> accessor, const std::string& operation = "") const {
template <typename T>
absl::StatusOr<T> SafeRomAccess(std::function<T()> accessor,
const std::string& operation = "") const {
if (!IsRomLoaded()) {
return absl::FailedPreconditionError(
operation.empty() ? "ROM not loaded" :
absl::StrFormat("%s: ROM not loaded", operation));
operation.empty() ? "ROM not loaded"
: absl::StrFormat("%s: ROM not loaded", operation));
}
try {
return accessor();
} catch (const std::exception& e) {
return absl::InternalError(absl::StrFormat(
"%s: %s", operation.empty() ? "ROM access failed" : operation, e.what()));
"%s: %s", operation.empty() ? "ROM access failed" : operation,
e.what()));
}
}
};

311
src/app/editor/editor_manager.cc
View File

@@ -16,10 +16,6 @@
#include "absl/strings/match.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_format.h"
#include "core/features.h"
#include "core/project.h"
#include "app/platform/timing.h"
#include "app/editor/session_types.h"
#include "app/editor/code/assembly_editor.h"
#include "app/editor/dungeon/dungeon_editor_v2.h"
#include "app/editor/graphics/graphics_editor.h"
@@ -27,6 +23,7 @@
#include "app/editor/music/music_editor.h"
#include "app/editor/overworld/overworld_editor.h"
#include "app/editor/palette/palette_editor.h"
#include "app/editor/session_types.h"
#include "app/editor/sprite/sprite_editor.h"
#include "app/editor/system/editor_card_registry.h"
#include "app/editor/system/editor_registry.h"
@@ -42,8 +39,11 @@
#include "app/gui/core/icons.h"
#include "app/gui/core/input.h"
#include "app/gui/core/theme_manager.h"
#include "app/platform/timing.h"
#include "app/rom.h"
#include "app/test/test_manager.h"
#include "core/features.h"
#include "core/project.h"
#include "imgui/imgui.h"
#include "util/file_util.h"
#include "util/log.h"
@@ -65,13 +65,13 @@
#include "app/gfx/debug/performance/performance_dashboard.h"
#ifdef YAZE_WITH_GRPC
#include "app/service/screenshot_utils.h"
#include "app/editor/agent/agent_chat_widget.h"
#include "app/editor/agent/automation_bridge.h"
#include "app/service/screenshot_utils.h"
#include "app/test/z3ed_test_suite.h"
#include "cli/service/agent/agent_control_server.h"
#include "cli/service/agent/conversational_agent_service.h"
#include "cli/service/ai/gemini_ai_service.h"
#include "app/editor/agent/automation_bridge.h"
#endif
#include "imgui/misc/cpp/imgui_stdlib.h"
@@ -105,7 +105,7 @@ void EditorManager::HideCurrentEditorCards() {
// Using EditorCardRegistry directly
std::string category =
editor_registry_.GetEditorCategory(current_editor_->type());
editor_registry_.GetEditorCategory(current_editor_->type());
card_registry_.HideAllCardsInCategory(category);
}
@@ -124,7 +124,7 @@ void EditorManager::ShowChatHistory() {
}
#endif
EditorManager::EditorManager()
EditorManager::EditorManager()
: blank_editor_set_(nullptr, &user_settings_),
project_manager_(&toast_manager_),
rom_file_manager_(&toast_manager_) {
@@ -132,7 +132,7 @@ EditorManager::EditorManager()
ss << YAZE_VERSION_MAJOR << "." << YAZE_VERSION_MINOR << "."
<< YAZE_VERSION_PATCH;
ss >> version_;
// ============================================================================
// DELEGATION INFRASTRUCTURE INITIALIZATION
// ============================================================================
@@ -163,31 +163,32 @@ EditorManager::EditorManager()
// If this order is violated, you will get SIGSEGV crashes when menu callbacks
// try to call popup_manager_.Show() with an uninitialized PopupManager!
// ============================================================================
// STEP 1: Initialize PopupManager FIRST
popup_manager_ = std::make_unique<PopupManager>(this);
popup_manager_->Initialize(); // Registers all popups with PopupID constants
// STEP 2: Initialize SessionCoordinator (independent of popups)
session_coordinator_ = std::make_unique<SessionCoordinator>(
static_cast<void*>(&sessions_), &card_registry_, &toast_manager_, &user_settings_);
static_cast<void*>(&sessions_), &card_registry_, &toast_manager_,
&user_settings_);
// STEP 3: Initialize MenuOrchestrator (depends on popup_manager_, session_coordinator_)
menu_orchestrator_ = std::make_unique<MenuOrchestrator>(
this, menu_builder_, rom_file_manager_, project_manager_,
editor_registry_, *session_coordinator_, toast_manager_, *popup_manager_);
session_coordinator_->SetEditorManager(this);
// STEP 4: Initialize UICoordinator (depends on popup_manager_, session_coordinator_, card_registry_)
ui_coordinator_ = std::make_unique<UICoordinator>(
this, rom_file_manager_, project_manager_, editor_registry_, card_registry_,
*session_coordinator_, window_delegate_, toast_manager_, *popup_manager_,
shortcut_manager_);
this, rom_file_manager_, project_manager_, editor_registry_,
card_registry_, *session_coordinator_, window_delegate_, toast_manager_,
*popup_manager_, shortcut_manager_);
// STEP 4.5: Initialize LayoutManager (DockBuilder layouts for editors)
layout_manager_ = std::make_unique<LayoutManager>();
// STEP 5: ShortcutConfigurator created later in Initialize() method
// It depends on all above coordinators being available
}
@@ -258,55 +259,55 @@ void EditorManager::Initialize(gfx::IRenderer* renderer,
// Register emulator cards early (emulator Initialize might not be called)
// Using EditorCardRegistry directly
card_registry_.RegisterCard({.card_id = "emulator.cpu_debugger",
.display_name = "CPU Debugger",
.icon = ICON_MD_BUG_REPORT,
.category = "Emulator",
.priority = 10});
.display_name = "CPU Debugger",
.icon = ICON_MD_BUG_REPORT,
.category = "Emulator",
.priority = 10});
card_registry_.RegisterCard({.card_id = "emulator.ppu_viewer",
.display_name = "PPU Viewer",
.icon = ICON_MD_VIDEOGAME_ASSET,
.category = "Emulator",
.priority = 20});
.display_name = "PPU Viewer",
.icon = ICON_MD_VIDEOGAME_ASSET,
.category = "Emulator",
.priority = 20});
card_registry_.RegisterCard({.card_id = "emulator.memory_viewer",
.display_name = "Memory Viewer",
.icon = ICON_MD_MEMORY,
.category = "Emulator",
.priority = 30});
.display_name = "Memory Viewer",
.icon = ICON_MD_MEMORY,
.category = "Emulator",
.priority = 30});
card_registry_.RegisterCard({.card_id = "emulator.breakpoints",
.display_name = "Breakpoints",
.icon = ICON_MD_STOP,
.category = "Emulator",
.priority = 40});
.display_name = "Breakpoints",
.icon = ICON_MD_STOP,
.category = "Emulator",
.priority = 40});
card_registry_.RegisterCard({.card_id = "emulator.performance",
.display_name = "Performance",
.icon = ICON_MD_SPEED,
.category = "Emulator",
.priority = 50});
.display_name = "Performance",
.icon = ICON_MD_SPEED,
.category = "Emulator",
.priority = 50});
card_registry_.RegisterCard({.card_id = "emulator.ai_agent",
.display_name = "AI Agent",
.icon = ICON_MD_SMART_TOY,
.category = "Emulator",
.priority = 60});
.display_name = "AI Agent",
.icon = ICON_MD_SMART_TOY,
.category = "Emulator",
.priority = 60});
card_registry_.RegisterCard({.card_id = "emulator.save_states",
.display_name = "Save States",
.icon = ICON_MD_SAVE,
.category = "Emulator",
.priority = 70});
.display_name = "Save States",
.icon = ICON_MD_SAVE,
.category = "Emulator",
.priority = 70});
card_registry_.RegisterCard({.card_id = "emulator.keyboard_config",
.display_name = "Keyboard Config",
.icon = ICON_MD_KEYBOARD,
.category = "Emulator",
.priority = 80});
.display_name = "Keyboard Config",
.icon = ICON_MD_KEYBOARD,
.category = "Emulator",
.priority = 80});
card_registry_.RegisterCard({.card_id = "emulator.apu_debugger",
.display_name = "APU Debugger",
.icon = ICON_MD_AUDIOTRACK,
.category = "Emulator",
.priority = 90});
.display_name = "APU Debugger",
.icon = ICON_MD_AUDIOTRACK,
.category = "Emulator",
.priority = 90});
card_registry_.RegisterCard({.card_id = "emulator.audio_mixer",
.display_name = "Audio Mixer",
.icon = ICON_MD_AUDIO_FILE,
.category = "Emulator",
.priority = 100});
.display_name = "Audio Mixer",
.icon = ICON_MD_AUDIO_FILE,
.category = "Emulator",
.priority = 100});
// Show CPU debugger and PPU viewer by default for emulator
card_registry_.ShowCard("emulator.cpu_debugger");
@@ -314,10 +315,10 @@ void EditorManager::Initialize(gfx::IRenderer* renderer,
// Register memory/hex editor card
card_registry_.RegisterCard({.card_id = "memory.hex_editor",
.display_name = "Hex Editor",
.icon = ICON_MD_MEMORY,
.category = "Memory",
.priority = 10});
.display_name = "Hex Editor",
.icon = ICON_MD_MEMORY,
.category = "Memory",
.priority = 10});
// Initialize project file editor
project_file_editor_.SetToastManager(&toast_manager_);
@@ -419,8 +420,8 @@ void EditorManager::Initialize(gfx::IRenderer* renderer,
return absl::OkStatus();
};
#else
multimodal_callbacks.send_to_gemini =
[](const std::filesystem::path&, const std::string&) -> absl::Status {
multimodal_callbacks.send_to_gemini = [](const std::filesystem::path&,
const std::string&) -> absl::Status {
return absl::FailedPreconditionError(
"Gemini AI runtime is disabled in this build");
};
@@ -591,8 +592,8 @@ void EditorManager::OpenEditorAndCardsFromFlags(const std::string& editor_name,
// Activate the main editor window
if (auto* editor_set = GetCurrentEditorSet()) {
auto* editor = editor_set
->active_editors_[static_cast<int>(editor_type_to_open)];
auto* editor =
editor_set->active_editors_[static_cast<int>(editor_type_to_open)];
if (editor) {
editor->set_active(true);
}
@@ -601,40 +602,40 @@ void EditorManager::OpenEditorAndCardsFromFlags(const std::string& editor_name,
// Handle specific cards for the Dungeon Editor
if (editor_type_to_open == EditorType::kDungeon && !cards_str.empty()) {
if (auto* editor_set = GetCurrentEditorSet()) {
std::stringstream ss(cards_str);
std::string card_name;
while (std::getline(ss, card_name, ',')) {
// Trim whitespace
card_name.erase(0, card_name.find_first_not_of(" \t"));
card_name.erase(card_name.find_last_not_of(" \t") + 1);
std::stringstream ss(cards_str);
std::string card_name;
while (std::getline(ss, card_name, ',')) {
// Trim whitespace
card_name.erase(0, card_name.find_first_not_of(" \t"));
card_name.erase(card_name.find_last_not_of(" \t") + 1);
LOG_DEBUG("EditorManager", "Attempting to open card: '%s'",
card_name.c_str());
LOG_DEBUG("EditorManager", "Attempting to open card: '%s'",
card_name.c_str());
if (card_name == "Rooms List") {
editor_set->dungeon_editor_.show_room_selector_ = true;
} else if (card_name == "Room Matrix") {
editor_set->dungeon_editor_.show_room_matrix_ = true;
} else if (card_name == "Entrances List") {
editor_set->dungeon_editor_.show_entrances_list_ = true;
} else if (card_name == "Room Graphics") {
editor_set->dungeon_editor_.show_room_graphics_ = true;
} else if (card_name == "Object Editor") {
editor_set->dungeon_editor_.show_object_editor_ = true;
} else if (card_name == "Palette Editor") {
editor_set->dungeon_editor_.show_palette_editor_ = true;
} else if (absl::StartsWith(card_name, "Room ")) {
try {
int room_id = std::stoi(card_name.substr(5));
editor_set->dungeon_editor_.add_room(room_id);
} catch (const std::exception& e) {
LOG_WARN("EditorManager", "Invalid room ID format: %s",
if (card_name == "Rooms List") {
editor_set->dungeon_editor_.show_room_selector_ = true;
} else if (card_name == "Room Matrix") {
editor_set->dungeon_editor_.show_room_matrix_ = true;
} else if (card_name == "Entrances List") {
editor_set->dungeon_editor_.show_entrances_list_ = true;
} else if (card_name == "Room Graphics") {
editor_set->dungeon_editor_.show_room_graphics_ = true;
} else if (card_name == "Object Editor") {
editor_set->dungeon_editor_.show_object_editor_ = true;
} else if (card_name == "Palette Editor") {
editor_set->dungeon_editor_.show_palette_editor_ = true;
} else if (absl::StartsWith(card_name, "Room ")) {
try {
int room_id = std::stoi(card_name.substr(5));
editor_set->dungeon_editor_.add_room(room_id);
} catch (const std::exception& e) {
LOG_WARN("EditorManager", "Invalid room ID format: %s",
card_name.c_str());
}
} else {
LOG_WARN("EditorManager", "Unknown card name for Dungeon Editor: %s",
card_name.c_str());
}
} else {
LOG_WARN("EditorManager", "Unknown card name for Dungeon Editor: %s",
card_name.c_str());
}
}
}
}
@@ -663,10 +664,10 @@ absl::Status EditorManager::Update() {
// Delegate to PopupManager for modal dialog rendering
popup_manager_->DrawPopups();
// Execute keyboard shortcuts (registered via ShortcutConfigurator)
ExecuteShortcuts(shortcut_manager_);
// Delegate to ToastManager for notification rendering
toast_manager_.Draw();
@@ -874,7 +875,8 @@ absl::Status EditorManager::Update() {
for (auto editor : session.editors.active_editors_) {
if (*editor->active() && IsCardBasedEditor(editor->type())) {
std::string category = EditorRegistry::GetEditorCategory(editor->type());
std::string category =
EditorRegistry::GetEditorCategory(editor->type());
if (std::find(active_categories.begin(), active_categories.end(),
category) == active_categories.end()) {
active_categories.push_back(category);
@@ -903,7 +905,8 @@ absl::Status EditorManager::Update() {
if (!sidebar_category.empty()) {
// Callback to switch editors when category button is clicked
auto category_switch_callback = [this](const std::string& new_category) {
EditorType editor_type = EditorRegistry::GetEditorTypeFromCategory(new_category);
EditorType editor_type =
EditorRegistry::GetEditorTypeFromCategory(new_category);
if (editor_type != EditorType::kUnknown) {
SwitchToEditor(editor_type);
}
@@ -916,7 +919,7 @@ absl::Status EditorManager::Update() {
};
card_registry_.DrawSidebar(sidebar_category, active_categories,
category_switch_callback, collapse_callback);
category_switch_callback, collapse_callback);
}
}
@@ -984,7 +987,7 @@ void EditorManager::DrawMenuBar() {
ui_coordinator_->SetImGuiDemoVisible(false);
}
}
if (ui_coordinator_ && ui_coordinator_->IsImGuiMetricsVisible()) {
bool visible = true;
ImGui::ShowMetricsWindow(&visible);
@@ -1003,11 +1006,11 @@ void EditorManager::DrawMenuBar() {
}
if (ui_coordinator_ && ui_coordinator_->IsAsmEditorVisible()) {
bool visible = true;
editor_set->assembly_editor_.Update(visible);
if (!visible) {
ui_coordinator_->SetAsmEditorVisible(false);
}
bool visible = true;
editor_set->assembly_editor_.Update(visible);
if (!visible) {
ui_coordinator_->SetAsmEditorVisible(false);
}
}
}
@@ -1055,7 +1058,7 @@ void EditorManager::DrawMenuBar() {
bool visible = true;
ImGui::Begin("Palette Editor", &visible);
if (auto* editor_set = GetCurrentEditorSet()) {
status_ = editor_set->palette_editor_.Update();
status_ = editor_set->palette_editor_.Update();
}
// Route palette editor errors to toast manager
@@ -1071,7 +1074,8 @@ void EditorManager::DrawMenuBar() {
}
}
if (ui_coordinator_ && ui_coordinator_->IsResourceLabelManagerVisible() && GetCurrentRom()) {
if (ui_coordinator_ && ui_coordinator_->IsResourceLabelManagerVisible() &&
GetCurrentRom()) {
bool visible = true;
GetCurrentRom()->resource_label()->DisplayLabels(&visible);
if (current_project_.project_opened() &&
@@ -1129,12 +1133,14 @@ absl::Status EditorManager::LoadRom() {
Rom temp_rom;
RETURN_IF_ERROR(rom_file_manager_.LoadRom(&temp_rom, file_name));
auto session_or = session_coordinator_->CreateSessionFromRom(std::move(temp_rom), file_name);
auto session_or = session_coordinator_->CreateSessionFromRom(
std::move(temp_rom), file_name);
if (!session_or.ok()) {
return session_or.status();
}
ConfigureEditorDependencies(GetCurrentEditorSet(), GetCurrentRom(), GetCurrentSessionId());
ConfigureEditorDependencies(GetCurrentEditorSet(), GetCurrentRom(),
GetCurrentSessionId());
#ifdef YAZE_ENABLE_TESTING
test::TestManager::Get().SetCurrentRom(GetCurrentRom());
@@ -1147,9 +1153,9 @@ absl::Status EditorManager::LoadRom() {
RETURN_IF_ERROR(LoadAssets());
if (ui_coordinator_) {
ui_coordinator_->SetWelcomeScreenVisible(false);
editor_selection_dialog_.ClearRecentEditors();
ui_coordinator_->SetEditorSelectionVisible(true);
ui_coordinator_->SetWelcomeScreenVisible(false);
editor_selection_dialog_.ClearRecentEditors();
ui_coordinator_->SetEditorSelectionVisible(true);
}
return absl::OkStatus();
@@ -1179,7 +1185,8 @@ absl::Status EditorManager::LoadAssets() {
current_editor_set->palette_editor_.Initialize();
current_editor_set->assembly_editor_.Initialize();
current_editor_set->music_editor_.Initialize();
current_editor_set->settings_editor_.Initialize(); // Initialize settings editor to register System cards
current_editor_set->settings_editor_
.Initialize(); // Initialize settings editor to register System cards
// Initialize the dungeon editor with the renderer
current_editor_set->dungeon_editor_.Initialize(renderer_, current_rom);
ASSIGN_OR_RETURN(*gfx::Arena::Get().mutable_gfx_sheets(),
@@ -1284,14 +1291,16 @@ absl::Status EditorManager::OpenRomOrProject(const std::string& filename) {
} else {
Rom temp_rom;
RETURN_IF_ERROR(rom_file_manager_.LoadRom(&temp_rom, filename));
auto session_or = session_coordinator_->CreateSessionFromRom(std::move(temp_rom), filename);
auto session_or = session_coordinator_->CreateSessionFromRom(
std::move(temp_rom), filename);
if (!session_or.ok()) {
return session_or.status();
}
RomSession* session = *session_or;
ConfigureEditorDependencies(GetCurrentEditorSet(), GetCurrentRom(), GetCurrentSessionId());
ConfigureEditorDependencies(GetCurrentEditorSet(), GetCurrentRom(),
GetCurrentSessionId());
// Apply project feature flags to the session
session->feature_flags = current_project_.feature_flags;
@@ -1304,9 +1313,9 @@ absl::Status EditorManager::OpenRomOrProject(const std::string& filename) {
test::TestManager::Get().SetCurrentRom(GetCurrentRom());
#endif
if (auto* editor_set = GetCurrentEditorSet(); editor_set && !current_project_.code_folder.empty()) {
editor_set->assembly_editor_.OpenFolder(
current_project_.code_folder);
if (auto* editor_set = GetCurrentEditorSet();
editor_set && !current_project_.code_folder.empty()) {
editor_set->assembly_editor_.OpenFolder(current_project_.code_folder);
}
RETURN_IF_ERROR(LoadAssets());
@@ -1324,8 +1333,8 @@ absl::Status EditorManager::CreateNewProject(const std::string& template_name) {
auto status = project_manager_.CreateNewProject(template_name);
if (status.ok()) {
current_project_ = project_manager_.GetCurrentProject();
// Show project creation dialog
popup_manager_->Show("Create New Project");
// Show project creation dialog
popup_manager_->Show("Create New Project");
}
return status;
}
@@ -1357,14 +1366,16 @@ absl::Status EditorManager::OpenProject() {
Rom temp_rom;
RETURN_IF_ERROR(
rom_file_manager_.LoadRom(&temp_rom, current_project_.rom_filename));
auto session_or = session_coordinator_->CreateSessionFromRom(std::move(temp_rom), current_project_.rom_filename);
auto session_or = session_coordinator_->CreateSessionFromRom(
std::move(temp_rom), current_project_.rom_filename);
if (!session_or.ok()) {
return session_or.status();
}
RomSession* session = *session_or;
ConfigureEditorDependencies(GetCurrentEditorSet(), GetCurrentRom(), GetCurrentSessionId());
ConfigureEditorDependencies(GetCurrentEditorSet(), GetCurrentRom(),
GetCurrentSessionId());
// Apply project feature flags to the session
session->feature_flags = current_project_.feature_flags;
@@ -1377,9 +1388,9 @@ absl::Status EditorManager::OpenProject() {
test::TestManager::Get().SetCurrentRom(GetCurrentRom());
#endif
if (auto* editor_set = GetCurrentEditorSet(); editor_set && !current_project_.code_folder.empty()) {
editor_set->assembly_editor_.OpenFolder(
current_project_.code_folder);
if (auto* editor_set = GetCurrentEditorSet();
editor_set && !current_project_.code_folder.empty()) {
editor_set->assembly_editor_.OpenFolder(current_project_.code_folder);
}
RETURN_IF_ERROR(LoadAssets());
@@ -1534,11 +1545,11 @@ absl::Status EditorManager::SetCurrentRom(Rom* rom) {
void EditorManager::CreateNewSession() {
if (session_coordinator_) {
session_coordinator_->CreateNewSession();
// Wire editor contexts for new session
if (!sessions_.empty()) {
RomSession& session = sessions_.back();
session.editors.set_user_settings(&user_settings_);
RomSession& session = sessions_.back();
session.editors.set_user_settings(&user_settings_);
ConfigureEditorDependencies(&session.editors, &session.rom,
session.editors.session_id());
session_coordinator_->SwitchToSession(sessions_.size() - 1);
@@ -1567,7 +1578,7 @@ void EditorManager::DuplicateCurrentSession() {
if (session_coordinator_) {
session_coordinator_->DuplicateCurrentSession();
// Wire editor contexts for duplicated session
if (!sessions_.empty()) {
RomSession& session = sessions_.back();
@@ -1581,7 +1592,7 @@ void EditorManager::DuplicateCurrentSession() {
void EditorManager::CloseCurrentSession() {
if (session_coordinator_) {
session_coordinator_->CloseCurrentSession();
// Update current pointers after session change -- no longer needed
}
}
@@ -1589,7 +1600,7 @@ void EditorManager::CloseCurrentSession() {
void EditorManager::RemoveSession(size_t index) {
if (session_coordinator_) {
session_coordinator_->RemoveSession(index);
// Update current pointers after session change -- no longer needed
}
}
@@ -1599,8 +1610,8 @@ void EditorManager::SwitchToSession(size_t index) {
return;
}
session_coordinator_->SwitchToSession(index);
session_coordinator_->SwitchToSession(index);
if (index >= sessions_.size()) {
return;
}
@@ -1616,7 +1627,7 @@ size_t EditorManager::GetCurrentSessionIndex() const {
if (session_coordinator_) {
return session_coordinator_->GetActiveSessionIndex();
}
// Fallback to finding by ROM pointer
for (size_t i = 0; i < sessions_.size(); ++i) {
if (&sessions_[i].rom == GetCurrentRom() &&
@@ -1631,7 +1642,7 @@ size_t EditorManager::GetActiveSessionCount() const {
if (session_coordinator_) {
return session_coordinator_->GetActiveSessionCount();
}
// Fallback to counting non-closed sessions
size_t count = 0;
for (const auto& session : sessions_) {
@@ -1699,9 +1710,10 @@ void EditorManager::SwitchToEditor(EditorType editor_type) {
// Editor activated - set its category
card_registry_.SetActiveCategory(
EditorRegistry::GetEditorCategory(editor_type));
// Initialize default layout on first activation
if (layout_manager_ && !layout_manager_->IsLayoutInitialized(editor_type)) {
if (layout_manager_ &&
!layout_manager_->IsLayoutInitialized(editor_type)) {
ImGuiID dockspace_id = ImGui::GetID("MainDockSpace");
layout_manager_->InitializeEditorLayout(editor_type, dockspace_id);
}
@@ -1710,8 +1722,8 @@ void EditorManager::SwitchToEditor(EditorType editor_type) {
for (auto* other : editor_set->active_editors_) {
if (*other->active() && IsCardBasedEditor(other->type()) &&
other != editor) {
card_registry_.SetActiveCategory(
EditorRegistry::GetEditorCategory(other->type()));
card_registry_.SetActiveCategory(
EditorRegistry::GetEditorCategory(other->type()));
break;
}
}
@@ -1723,12 +1735,15 @@ void EditorManager::SwitchToEditor(EditorType editor_type) {
// Handle non-editor-class cases
if (editor_type == EditorType::kAssembly) {
if (ui_coordinator_) ui_coordinator_->SetAsmEditorVisible(!ui_coordinator_->IsAsmEditorVisible());
if (ui_coordinator_)
ui_coordinator_->SetAsmEditorVisible(
!ui_coordinator_->IsAsmEditorVisible());
} else if (editor_type == EditorType::kEmulator) {
if (ui_coordinator_) {
ui_coordinator_->SetEmulatorVisible(!ui_coordinator_->IsEmulatorVisible());
ui_coordinator_->SetEmulatorVisible(
!ui_coordinator_->IsEmulatorVisible());
if (ui_coordinator_->IsEmulatorVisible()) {
card_registry_.SetActiveCategory("Emulator");
card_registry_.SetActiveCategory("Emulator");
}
}
}
@@ -1741,7 +1756,7 @@ EditorManager::SessionScope::SessionScope(EditorManager* manager,
prev_rom_(manager->GetCurrentRom()),
prev_editor_set_(manager->GetCurrentEditorSet()),
prev_session_id_(manager->GetCurrentSessionId()) {
// Set new session context
manager_->session_coordinator_->SwitchToSession(session_id);
}

48
src/app/editor/editor_manager.h
View File

@@ -4,9 +4,9 @@
#define IMGUI_DEFINE_MATH_OPERATORS
#include "app/editor/editor.h"
#include "app/editor/session_types.h"
#include "app/editor/system/user_settings.h"
#include "app/editor/ui/workspace_manager.h"
#include "app/editor/session_types.h"
#include "imgui/imgui.h"
@@ -16,7 +16,6 @@
#include <string>
#include "absl/status/status.h"
#include "core/project.h"
#include "app/editor/agent/agent_chat_history_popup.h"
#include "app/editor/code/project_file_editor.h"
#include "app/editor/system/editor_card_registry.h"
@@ -35,9 +34,10 @@
#include "app/editor/ui/ui_coordinator.h"
#include "app/editor/ui/welcome_screen.h"
#include "app/emu/emulator.h"
#include "zelda3/overworld/overworld.h"
#include "app/rom.h"
#include "core/project.h"
#include "yaze_config.h"
#include "zelda3/overworld/overworld.h"
#ifdef YAZE_WITH_GRPC
#include "app/editor/agent/agent_editor.h"
@@ -85,14 +85,23 @@ class EditorManager {
WorkspaceManager* workspace_manager() { return &workspace_manager_; }
absl::Status SetCurrentRom(Rom* rom);
auto GetCurrentRom() const -> Rom* { return session_coordinator_ ? session_coordinator_->GetCurrentRom() : nullptr; }
auto GetCurrentEditorSet() const -> EditorSet* { return session_coordinator_ ? session_coordinator_->GetCurrentEditorSet() : nullptr; }
auto GetCurrentRom() const -> Rom* {
return session_coordinator_ ? session_coordinator_->GetCurrentRom()
: nullptr;
}
auto GetCurrentEditorSet() const -> EditorSet* {
return session_coordinator_ ? session_coordinator_->GetCurrentEditorSet()
: nullptr;
}
auto GetCurrentEditor() const -> Editor* { return current_editor_; }
size_t GetCurrentSessionId() const { return session_coordinator_ ? session_coordinator_->GetActiveSessionIndex() : 0; }
size_t GetCurrentSessionId() const {
return session_coordinator_ ? session_coordinator_->GetActiveSessionIndex()
: 0;
}
UICoordinator* ui_coordinator() { return ui_coordinator_.get(); }
auto overworld() const -> yaze::zelda3::Overworld* {
if (auto* editor_set = GetCurrentEditorSet()) {
return &editor_set->overworld_editor_.overworld();
return &editor_set->overworld_editor_.overworld();
}
return nullptr;
}
@@ -204,9 +213,18 @@ class EditorManager {
ui_coordinator_->SetImGuiMetricsVisible(true);
}
void ShowHexEditor();
void ShowEmulator() { if (ui_coordinator_) ui_coordinator_->SetEmulatorVisible(true); }
void ShowMemoryEditor() { if (ui_coordinator_) ui_coordinator_->SetMemoryEditorVisible(true); }
void ShowResourceLabelManager() { if (ui_coordinator_) ui_coordinator_->SetResourceLabelManagerVisible(true); }
void ShowEmulator() {
if (ui_coordinator_)
ui_coordinator_->SetEmulatorVisible(true);
}
void ShowMemoryEditor() {
if (ui_coordinator_)
ui_coordinator_->SetMemoryEditorVisible(true);
}
void ShowResourceLabelManager() {
if (ui_coordinator_)
ui_coordinator_->SetResourceLabelManagerVisible(true);
}
void ShowCardBrowser() {
if (ui_coordinator_)
ui_coordinator_->ShowCardBrowser();
@@ -240,8 +258,8 @@ class EditorManager {
absl::Status RepairCurrentProject();
private:
absl::Status DrawRomSelector() = delete; // Moved to UICoordinator
void DrawContextSensitiveCardControl(); // Card control for current editor
absl::Status DrawRomSelector() = delete; // Moved to UICoordinator
void DrawContextSensitiveCardControl(); // Card control for current editor
absl::Status LoadAssets();
@@ -252,7 +270,7 @@ class EditorManager {
// Note: All show_* flags are being moved to UICoordinator
// Access via ui_coordinator_->IsXxxVisible() or SetXxxVisible()
// Workspace dialog flags (managed by EditorManager, not UI)
bool show_workspace_layout = false;
size_t session_to_rename_ = 0;
@@ -292,7 +310,6 @@ class EditorManager {
emu::Emulator emulator_;
public:
private:
std::deque<RomSession> sessions_;
Editor* current_editor_ = nullptr;
@@ -319,7 +336,8 @@ class EditorManager {
std::unique_ptr<UICoordinator> ui_coordinator_;
WindowDelegate window_delegate_;
std::unique_ptr<SessionCoordinator> session_coordinator_;
std::unique_ptr<LayoutManager> layout_manager_; // DockBuilder layout management
std::unique_ptr<LayoutManager>
layout_manager_; // DockBuilder layout management
WorkspaceManager workspace_manager_{&toast_manager_};
float autosave_timer_ = 0.0f;

24
src/app/editor/editor_safeguards.h
View File

@@ -9,26 +9,28 @@ namespace yaze {
namespace editor {
// Macro for checking ROM loading state in editor methods
#define REQUIRE_ROM_LOADED(rom_ptr, operation) \
do { \
if (!(rom_ptr) || !(rom_ptr)->is_loaded()) { \
return absl::FailedPreconditionError( \
#define REQUIRE_ROM_LOADED(rom_ptr, operation) \
do { \
if (!(rom_ptr) || !(rom_ptr)->is_loaded()) { \
return absl::FailedPreconditionError( \
absl::StrFormat("%s: ROM not loaded", (operation))); \
} \
} \
} while (0)
// Macro for ROM state checking with custom error message
#define CHECK_ROM_STATE(rom_ptr, message) \
do { \
if (!(rom_ptr) || !(rom_ptr)->is_loaded()) { \
#define CHECK_ROM_STATE(rom_ptr, message) \
do { \
if (!(rom_ptr) || !(rom_ptr)->is_loaded()) { \
return absl::FailedPreconditionError(message); \
} \
} \
} while (0)
// Helper function for generating consistent ROM status messages
inline std::string GetRomStatusMessage(const Rom* rom) {
if (!rom) return "No ROM loaded";
if (!rom->is_loaded()) return "ROM failed to load";
if (!rom)
return "No ROM loaded";
if (!rom->is_loaded())
return "ROM failed to load";
return absl::StrFormat("ROM loaded: %s", rom->title());
}

30
src/app/editor/graphics/gfx_group_editor.cc
View File

@@ -112,7 +112,7 @@ void GfxGroupEditor::DrawBlocksetViewer(bool sheet_only) {
BeginGroup();
for (int i = 0; i < 8; i++) {
int sheet_id = rom()->main_blockset_ids[selected_blockset_][i];
auto &sheet = gfx::Arena::Get().mutable_gfx_sheets()->at(sheet_id);
auto& sheet = gfx::Arena::Get().mutable_gfx_sheets()->at(sheet_id);
gui::BitmapCanvasPipeline(blockset_canvas_, sheet, 256, 0x10 * 0x04,
0x20, true, false, 22);
}
@@ -165,7 +165,7 @@ void GfxGroupEditor::DrawRoomsetViewer() {
BeginGroup();
for (int i = 0; i < 4; i++) {
int sheet_id = rom()->room_blockset_ids[selected_roomset_][i];
auto &sheet = gfx::Arena::Get().mutable_gfx_sheets()->at(sheet_id);
auto& sheet = gfx::Arena::Get().mutable_gfx_sheets()->at(sheet_id);
gui::BitmapCanvasPipeline(roomset_canvas_, sheet, 256, 0x10 * 0x04,
0x20, true, false, 23);
}
@@ -203,7 +203,7 @@ void GfxGroupEditor::DrawSpritesetViewer(bool sheet_only) {
BeginGroup();
for (int i = 0; i < 4; i++) {
int sheet_id = rom()->spriteset_ids[selected_spriteset_][i];
auto &sheet =
auto& sheet =
gfx::Arena::Get().mutable_gfx_sheets()->at(115 + sheet_id);
gui::BitmapCanvasPipeline(spriteset_canvas_, sheet, 256, 0x10 * 0x04,
0x20, true, false, 24);
@@ -215,20 +215,20 @@ void GfxGroupEditor::DrawSpritesetViewer(bool sheet_only) {
}
namespace {
void DrawPaletteFromPaletteGroup(gfx::SnesPalette &palette) {
void DrawPaletteFromPaletteGroup(gfx::SnesPalette& palette) {
if (palette.empty()) {
return;
}
for (size_t n = 0; n < palette.size(); n++) {
PushID(n);
if ((n % 8) != 0) SameLine(0.0f, GetStyle().ItemSpacing.y);
if ((n % 8) != 0)
SameLine(0.0f, GetStyle().ItemSpacing.y);
// Small icon of the color in the palette
if (gui::SnesColorButton(absl::StrCat("Palette", n), palette[n],
ImGuiColorEditFlags_NoAlpha |
ImGuiColorEditFlags_NoPicker |
ImGuiColorEditFlags_NoTooltip)) {
}
ImGuiColorEditFlags_NoTooltip)) {}
PopID();
}
@@ -247,13 +247,13 @@ void GfxGroupEditor::DrawPaletteViewer() {
false, "paletteset", "0x" + std::to_string(selected_paletteset_),
"Paletteset " + std::to_string(selected_paletteset_));
uint8_t &dungeon_main_palette_val =
uint8_t& dungeon_main_palette_val =
rom()->paletteset_ids[selected_paletteset_][0];
uint8_t &dungeon_spr_pal_1_val =
uint8_t& dungeon_spr_pal_1_val =
rom()->paletteset_ids[selected_paletteset_][1];
uint8_t &dungeon_spr_pal_2_val =
uint8_t& dungeon_spr_pal_2_val =
rom()->paletteset_ids[selected_paletteset_][2];
uint8_t &dungeon_spr_pal_3_val =
uint8_t& dungeon_spr_pal_3_val =
rom()->paletteset_ids[selected_paletteset_][3];
gui::InputHexByte("Dungeon Main", &dungeon_main_palette_val);
@@ -261,13 +261,13 @@ void GfxGroupEditor::DrawPaletteViewer() {
rom()->resource_label()->SelectableLabelWithNameEdit(
false, kPaletteGroupNames[PaletteCategory::kDungeons].data(),
std::to_string(dungeon_main_palette_val), "Unnamed dungeon palette");
auto &palette = *rom()->mutable_palette_group()->dungeon_main.mutable_palette(
auto& palette = *rom()->mutable_palette_group()->dungeon_main.mutable_palette(
rom()->paletteset_ids[selected_paletteset_][0]);
DrawPaletteFromPaletteGroup(palette);
Separator();
gui::InputHexByte("Dungeon Spr Pal 1", &dungeon_spr_pal_1_val);
auto &spr_aux_pal1 =
auto& spr_aux_pal1 =
*rom()->mutable_palette_group()->sprites_aux1.mutable_palette(
rom()->paletteset_ids[selected_paletteset_][1]);
DrawPaletteFromPaletteGroup(spr_aux_pal1);
@@ -278,7 +278,7 @@ void GfxGroupEditor::DrawPaletteViewer() {
Separator();
gui::InputHexByte("Dungeon Spr Pal 2", &dungeon_spr_pal_2_val);
auto &spr_aux_pal2 =
auto& spr_aux_pal2 =
*rom()->mutable_palette_group()->sprites_aux2.mutable_palette(
rom()->paletteset_ids[selected_paletteset_][2]);
DrawPaletteFromPaletteGroup(spr_aux_pal2);
@@ -289,7 +289,7 @@ void GfxGroupEditor::DrawPaletteViewer() {
Separator();
gui::InputHexByte("Dungeon Spr Pal 3", &dungeon_spr_pal_3_val);
auto &spr_aux_pal3 =
auto& spr_aux_pal3 =
*rom()->mutable_palette_group()->sprites_aux3.mutable_palette(
rom()->paletteset_ids[selected_paletteset_][3]);
DrawPaletteFromPaletteGroup(spr_aux_pal3);

201
src/app/editor/graphics/graphics_editor.cc
View File

@@ -6,26 +6,26 @@
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/str_cat.h"
#include "app/gui/core/ui_helpers.h"
#include "util/file_util.h"
#include "app/platform/window.h"
#include "app/gfx/resource/arena.h"
#include "app/gfx/core/bitmap.h"
#include "app/gfx/util/compression.h"
#include "app/gfx/util/scad_format.h"
#include "app/gfx/debug/performance/performance_profiler.h"
#include "app/gfx/resource/arena.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gfx/types/snes_tile.h"
#include "app/gfx/util/compression.h"
#include "app/gfx/util/scad_format.h"
#include "app/gui/canvas/canvas.h"
#include "app/gui/core/color.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/input.h"
#include "app/gui/widgets/asset_browser.h"
#include "app/gui/core/style.h"
#include "app/gui/core/ui_helpers.h"
#include "app/gui/widgets/asset_browser.h"
#include "app/platform/window.h"
#include "app/rom.h"
#include "app/gfx/debug/performance/performance_profiler.h"
#include "imgui/imgui.h"
#include "imgui/misc/cpp/imgui_stdlib.h"
#include "imgui_memory_editor.h"
#include "util/file_util.h"
#include "util/log.h"
namespace yaze {
@@ -44,47 +44,61 @@ constexpr ImGuiTableFlags kGfxEditTableFlags =
ImGuiTableFlags_SizingFixedFit;
void GraphicsEditor::Initialize() {
if (!dependencies_.card_registry) return;
if (!dependencies_.card_registry)
return;
auto* card_registry = dependencies_.card_registry;
card_registry->RegisterCard({.card_id = "graphics.sheet_editor", .display_name = "Sheet Editor",
.icon = ICON_MD_EDIT, .category = "Graphics",
.shortcut_hint = "Ctrl+Shift+1", .priority = 10});
card_registry->RegisterCard({.card_id = "graphics.sheet_browser", .display_name = "Sheet Browser",
.icon = ICON_MD_VIEW_LIST, .category = "Graphics",
.shortcut_hint = "Ctrl+Shift+2", .priority = 20});
card_registry->RegisterCard({.card_id = "graphics.player_animations", .display_name = "Player Animations",
.icon = ICON_MD_PERSON, .category = "Graphics",
.shortcut_hint = "Ctrl+Shift+3", .priority = 30});
card_registry->RegisterCard({.card_id = "graphics.prototype_viewer", .display_name = "Prototype Viewer",
.icon = ICON_MD_CONSTRUCTION, .category = "Graphics",
.shortcut_hint = "Ctrl+Shift+4", .priority = 40});
card_registry->RegisterCard({.card_id = "graphics.sheet_editor",
.display_name = "Sheet Editor",
.icon = ICON_MD_EDIT,
.category = "Graphics",
.shortcut_hint = "Ctrl+Shift+1",
.priority = 10});
card_registry->RegisterCard({.card_id = "graphics.sheet_browser",
.display_name = "Sheet Browser",
.icon = ICON_MD_VIEW_LIST,
.category = "Graphics",
.shortcut_hint = "Ctrl+Shift+2",
.priority = 20});
card_registry->RegisterCard({.card_id = "graphics.player_animations",
.display_name = "Player Animations",
.icon = ICON_MD_PERSON,
.category = "Graphics",
.shortcut_hint = "Ctrl+Shift+3",
.priority = 30});
card_registry->RegisterCard({.card_id = "graphics.prototype_viewer",
.display_name = "Prototype Viewer",
.icon = ICON_MD_CONSTRUCTION,
.category = "Graphics",
.shortcut_hint = "Ctrl+Shift+4",
.priority = 40});
// Show sheet editor by default when Graphics Editor is activated
card_registry->ShowCard("graphics.sheet_editor");
}
absl::Status GraphicsEditor::Load() {
absl::Status GraphicsEditor::Load() {
gfx::ScopedTimer timer("GraphicsEditor::Load");
// Initialize all graphics sheets with appropriate palettes from ROM
// This ensures textures are created for editing
if (rom()->is_loaded()) {
auto& sheets = gfx::Arena::Get().gfx_sheets();
// Apply default palettes to all sheets based on common SNES ROM structure
// Sheets 0-112: Use overworld/dungeon palettes
// Sheets 113-127: Use sprite palettes
// Sheets 128-222: Use auxiliary/menu palettes
LOG_INFO("GraphicsEditor", "Initializing textures for %d graphics sheets", kNumGfxSheets);
LOG_INFO("GraphicsEditor", "Initializing textures for %d graphics sheets",
kNumGfxSheets);
int sheets_queued = 0;
for (int i = 0; i < kNumGfxSheets; i++) {
if (!sheets[i].is_active() || !sheets[i].surface()) {
continue; // Skip inactive or surface-less sheets
}
// Palettes are now applied during ROM loading in LoadAllGraphicsData()
// Just queue texture creation for sheets that don't have textures yet
if (!sheets[i].texture()) {
@@ -93,21 +107,24 @@ absl::Status GraphicsEditor::Load() {
sheets_queued++;
}
}
LOG_INFO("GraphicsEditor", "Queued texture creation for %d graphics sheets", sheets_queued);
LOG_INFO("GraphicsEditor", "Queued texture creation for %d graphics sheets",
sheets_queued);
}
return absl::OkStatus();
return absl::OkStatus();
}
absl::Status GraphicsEditor::Update() {
if (!dependencies_.card_registry) return absl::OkStatus();
if (!dependencies_.card_registry)
return absl::OkStatus();
auto* card_registry = dependencies_.card_registry;
static gui::EditorCard sheet_editor_card("Sheet Editor", ICON_MD_EDIT);
static gui::EditorCard sheet_browser_card("Sheet Browser", ICON_MD_VIEW_LIST);
static gui::EditorCard player_anims_card("Player Animations", ICON_MD_PERSON);
static gui::EditorCard prototype_card("Prototype Viewer", ICON_MD_CONSTRUCTION);
static gui::EditorCard prototype_card("Prototype Viewer",
ICON_MD_CONSTRUCTION);
sheet_editor_card.SetDefaultSize(900, 700);
sheet_browser_card.SetDefaultSize(400, 600);
@@ -115,7 +132,8 @@ absl::Status GraphicsEditor::Update() {
prototype_card.SetDefaultSize(600, 500);
// Sheet Editor Card - Check visibility flag exists and is true before rendering
bool* sheet_editor_visible = card_registry->GetVisibilityFlag("graphics.sheet_editor");
bool* sheet_editor_visible =
card_registry->GetVisibilityFlag("graphics.sheet_editor");
if (sheet_editor_visible && *sheet_editor_visible) {
if (sheet_editor_card.Begin(sheet_editor_visible)) {
status_ = UpdateGfxEdit();
@@ -124,7 +142,8 @@ absl::Status GraphicsEditor::Update() {
}
// Sheet Browser Card - Check visibility flag exists and is true before rendering
bool* sheet_browser_visible = card_registry->GetVisibilityFlag("graphics.sheet_browser");
bool* sheet_browser_visible =
card_registry->GetVisibilityFlag("graphics.sheet_browser");
if (sheet_browser_visible && *sheet_browser_visible) {
if (sheet_browser_card.Begin(sheet_browser_visible)) {
if (asset_browser_.Initialized == false) {
@@ -136,7 +155,8 @@ absl::Status GraphicsEditor::Update() {
}
// Player Animations Card - Check visibility flag exists and is true before rendering
bool* player_anims_visible = card_registry->GetVisibilityFlag("graphics.player_animations");
bool* player_anims_visible =
card_registry->GetVisibilityFlag("graphics.player_animations");
if (player_anims_visible && *player_anims_visible) {
if (player_anims_card.Begin(player_anims_visible)) {
status_ = UpdateLinkGfxView();
@@ -145,7 +165,8 @@ absl::Status GraphicsEditor::Update() {
}
// Prototype Viewer Card - Check visibility flag exists and is true before rendering
bool* prototype_visible = card_registry->GetVisibilityFlag("graphics.prototype_viewer");
bool* prototype_visible =
card_registry->GetVisibilityFlag("graphics.prototype_viewer");
if (prototype_visible && *prototype_visible) {
if (prototype_card.Begin(prototype_visible)) {
status_ = UpdateScadView();
@@ -158,28 +179,28 @@ absl::Status GraphicsEditor::Update() {
}
absl::Status GraphicsEditor::UpdateGfxEdit() {
if (ImGui::BeginTable("##GfxEditTable", 3, kGfxEditTableFlags,
ImVec2(0, 0))) {
for (const auto& name :
{"Tilesheets", "Current Graphics", "Palette Controls"})
ImGui::TableSetupColumn(name);
if (ImGui::BeginTable("##GfxEditTable", 3, kGfxEditTableFlags,
ImVec2(0, 0))) {
for (const auto& name :
{"Tilesheets", "Current Graphics", "Palette Controls"})
ImGui::TableSetupColumn(name);
ImGui::TableHeadersRow();
ImGui::TableNextColumn();
status_ = UpdateGfxSheetList();
ImGui::TableHeadersRow();
ImGui::TableNextColumn();
status_ = UpdateGfxSheetList();
ImGui::TableNextColumn();
if (rom()->is_loaded()) {
DrawGfxEditToolset();
status_ = UpdateGfxTabView();
}
ImGui::TableNextColumn();
if (rom()->is_loaded()) {
status_ = UpdatePaletteColumn();
}
ImGui::TableNextColumn();
if (rom()->is_loaded()) {
DrawGfxEditToolset();
status_ = UpdateGfxTabView();
}
ImGui::EndTable();
ImGui::TableNextColumn();
if (rom()->is_loaded()) {
status_ = UpdatePaletteColumn();
}
}
ImGui::EndTable();
return absl::OkStatus();
}
@@ -254,31 +275,32 @@ void GraphicsEditor::DrawGfxEditToolset() {
// Enhanced palette color picker with SNES-specific features
auto bitmap = gfx::Arena::Get().gfx_sheets()[current_sheet_];
auto palette = bitmap.palette();
// Display palette colors in a grid layout for better ROM hacking workflow
for (int i = 0; i < palette.size(); i++) {
if (i > 0 && i % 8 == 0) {
ImGui::NewLine(); // New row every 8 colors (SNES palette standard)
ImGui::NewLine(); // New row every 8 colors (SNES palette standard)
}
ImGui::SameLine();
// Convert SNES color to ImGui format with proper scaling
auto color = ImVec4(palette[i].rgb().x / 255.0f, palette[i].rgb().y / 255.0f,
palette[i].rgb().z / 255.0f, 1.0f);
auto color =
ImVec4(palette[i].rgb().x / 255.0f, palette[i].rgb().y / 255.0f,
palette[i].rgb().z / 255.0f, 1.0f);
// Enhanced color button with tooltip showing SNES color value
if (ImGui::ColorButton(absl::StrFormat("Palette Color %d", i).c_str(),
color, ImGuiColorEditFlags_NoTooltip)) {
current_color_ = color;
}
// Add tooltip with SNES color information
if (ImGui::IsItemHovered()) {
ImGui::SetTooltip("SNES Color: $%04X\nRGB: (%d, %d, %d)",
palette[i].snes(),
static_cast<int>(palette[i].rgb().x),
static_cast<int>(palette[i].rgb().y),
static_cast<int>(palette[i].rgb().z));
ImGui::SetTooltip("SNES Color: $%04X\nRGB: (%d, %d, %d)",
palette[i].snes(),
static_cast<int>(palette[i].rgb().x),
static_cast<int>(palette[i].rgb().y),
static_cast<int>(palette[i].rgb().z));
}
}
@@ -322,7 +344,7 @@ absl::Status GraphicsEditor::UpdateGfxSheetList() {
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::CREATE, &value);
}
auto texture = value.texture();
if (texture) {
graphics_bin_canvas_.draw_list()->AddImage(
@@ -347,8 +369,8 @@ absl::Status GraphicsEditor::UpdateGfxSheetList() {
ImVec2 rect_min(text_pos.x, text_pos.y);
ImVec2 rect_max(text_pos.x + text_size.x, text_pos.y + text_size.y);
graphics_bin_canvas_.draw_list()->AddRectFilled(rect_min, rect_max,
IM_COL32(0, 125, 0, 128));
graphics_bin_canvas_.draw_list()->AddRectFilled(
rect_min, rect_max, IM_COL32(0, 125, 0, 128));
graphics_bin_canvas_.draw_list()->AddText(
text_pos, IM_COL32(125, 255, 125, 255),
@@ -371,7 +393,7 @@ absl::Status GraphicsEditor::UpdateGfxSheetList() {
absl::Status GraphicsEditor::UpdateGfxTabView() {
gfx::ScopedTimer timer("graphics_editor_update_gfx_tab_view");
static int next_tab_id = 0;
constexpr ImGuiTabBarFlags kGfxEditTabBarFlags =
ImGuiTabBarFlags_AutoSelectNewTabs | ImGuiTabBarFlags_Reorderable |
@@ -412,8 +434,8 @@ absl::Status GraphicsEditor::UpdateGfxTabView() {
auto draw_tile_event = [&]() {
current_sheet_canvas_.DrawTileOnBitmap(tile_size_, &current_bitmap,
current_color_);
// Notify Arena that this sheet has been modified for cross-editor synchronization
gfx::Arena::Get().NotifySheetModified(sheet_id);
// Notify Arena that this sheet has been modified for cross-editor synchronization
gfx::Arena::Get().NotifySheetModified(sheet_id);
};
current_sheet_canvas_.UpdateColorPainter(
@@ -427,7 +449,8 @@ absl::Status GraphicsEditor::UpdateGfxTabView() {
ImGui::EndTabItem();
}
if (!open) release_queue_.push(sheet_id);
if (!open)
release_queue_.push(sheet_id);
}
ImGui::EndTabBar();
@@ -453,7 +476,8 @@ absl::Status GraphicsEditor::UpdateGfxTabView() {
current_sheet_ = id;
// ImVec2(0x100, 0x40),
current_sheet_canvas_.UpdateColorPainter(
nullptr, gfx::Arena::Get().mutable_gfx_sheets()->at(id), current_color_,
nullptr, gfx::Arena::Get().mutable_gfx_sheets()->at(id),
current_color_,
[&]() {
},
@@ -478,7 +502,7 @@ absl::Status GraphicsEditor::UpdatePaletteColumn() {
kPaletteGroupAddressesKeys[edit_palette_group_name_index_]);
auto palette = palette_group.palette(edit_palette_index_);
gui::TextWithSeparators("ROM Palette Management");
// Quick palette presets for common SNES graphics types
ImGui::Text("Quick Presets:");
if (ImGui::Button("Overworld")) {
@@ -499,7 +523,7 @@ absl::Status GraphicsEditor::UpdatePaletteColumn() {
refresh_graphics_ = true;
}
ImGui::Separator();
// Apply current palette to current sheet
if (ImGui::Button("Apply to Current Sheet") && !open_sheets_.empty()) {
refresh_graphics_ = true;
@@ -517,7 +541,7 @@ absl::Status GraphicsEditor::UpdatePaletteColumn() {
}
}
ImGui::Separator();
ImGui::SetNextItemWidth(150.f);
ImGui::Combo("Palette Group", (int*)&edit_palette_group_name_index_,
kPaletteGroupAddressesKeys,
@@ -531,7 +555,8 @@ absl::Status GraphicsEditor::UpdatePaletteColumn() {
palette);
if (refresh_graphics_ && !open_sheets_.empty()) {
auto& current = gfx::Arena::Get().mutable_gfx_sheets()->data()[current_sheet_];
auto& current =
gfx::Arena::Get().mutable_gfx_sheets()->data()[current_sheet_];
if (current.is_active() && current.surface()) {
current.SetPaletteWithTransparent(palette, edit_palette_sub_index_);
// Notify Arena that this sheet has been modified
@@ -613,7 +638,9 @@ absl::Status GraphicsEditor::UpdateScadView() {
status_ = DrawExperimentalFeatures();
}
NEXT_COLUMN() { status_ = DrawPaletteControls(); }
NEXT_COLUMN() {
status_ = DrawPaletteControls();
}
NEXT_COLUMN()
gui::BitmapCanvasPipeline(scr_canvas_, scr_bitmap_, 0x200, 0x200, 0x20,
@@ -908,8 +935,8 @@ absl::Status GraphicsEditor::DecompressImportData(int size) {
}
}
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::UPDATE, &bin_bitmap_);
gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::UPDATE,
&bin_bitmap_);
gfx_loaded_ = true;
return absl::OkStatus();

12
src/app/editor/graphics/graphics_editor.h
View File

@@ -8,13 +8,13 @@
#include "app/editor/palette/palette_editor.h"
#include "app/gfx/core/bitmap.h"
#include "app/gfx/types/snes_tile.h"
#include "app/gui/canvas/canvas.h"
#include "app/gui/app/editor_layout.h"
#include "app/gui/canvas/canvas.h"
#include "app/gui/widgets/asset_browser.h"
#include "app/rom.h"
#include "zelda3/overworld/overworld.h"
#include "imgui/imgui.h"
#include "imgui_memory_editor.h"
#include "zelda3/overworld/overworld.h"
namespace yaze {
namespace editor {
@@ -57,8 +57,8 @@ const std::string kSuperDonkeySprites[] = {
*/
class GraphicsEditor : public Editor {
public:
explicit GraphicsEditor(Rom* rom = nullptr) : rom_(rom) {
type_ = EditorType::kGraphics;
explicit GraphicsEditor(Rom* rom = nullptr) : rom_(rom) {
type_ = EditorType::kGraphics;
}
void Initialize() override;
@@ -71,10 +71,10 @@ class GraphicsEditor : public Editor {
absl::Status Undo() override { return absl::UnimplementedError("Undo"); }
absl::Status Redo() override { return absl::UnimplementedError("Redo"); }
absl::Status Find() override { return absl::UnimplementedError("Find"); }
// Set the ROM pointer
void set_rom(Rom* rom) { rom_ = rom; }
// Get the ROM pointer
Rom* rom() const { return rom_; }

298
src/app/editor/graphics/screen_editor.cc
View File

@@ -6,45 +6,60 @@
#include <string>
#include "absl/strings/str_format.h"
#include "app/gfx/debug/performance/performance_profiler.h"
#include "util/file_util.h"
#include "app/gfx/resource/arena.h"
#include "app/gfx/core/bitmap.h"
#include "app/gfx/debug/performance/performance_profiler.h"
#include "app/gfx/resource/arena.h"
#include "app/gfx/types/snes_tile.h"
#include "app/gui/canvas/canvas.h"
#include "app/gui/core/color.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/input.h"
#include "imgui/imgui.h"
#include "util/file_util.h"
#include "util/hex.h"
#include "util/macro.h"
namespace yaze {
namespace editor {
constexpr uint32_t kRedPen = 0xFF0000FF;
void ScreenEditor::Initialize() {
if (!dependencies_.card_registry) return;
if (!dependencies_.card_registry)
return;
auto* card_registry = dependencies_.card_registry;
card_registry->RegisterCard({.card_id = "screen.dungeon_maps", .display_name = "Dungeon Maps",
.icon = ICON_MD_MAP, .category = "Screen",
.shortcut_hint = "Alt+1", .priority = 10});
card_registry->RegisterCard({.card_id = "screen.inventory_menu", .display_name = "Inventory Menu",
.icon = ICON_MD_INVENTORY, .category = "Screen",
.shortcut_hint = "Alt+2", .priority = 20});
card_registry->RegisterCard({.card_id = "screen.overworld_map", .display_name = "Overworld Map",
.icon = ICON_MD_PUBLIC, .category = "Screen",
.shortcut_hint = "Alt+3", .priority = 30});
card_registry->RegisterCard({.card_id = "screen.title_screen", .display_name = "Title Screen",
.icon = ICON_MD_TITLE, .category = "Screen",
.shortcut_hint = "Alt+4", .priority = 40});
card_registry->RegisterCard({.card_id = "screen.naming_screen", .display_name = "Naming Screen",
.icon = ICON_MD_EDIT, .category = "Screen",
.shortcut_hint = "Alt+5", .priority = 50});
card_registry->RegisterCard({.card_id = "screen.dungeon_maps",
.display_name = "Dungeon Maps",
.icon = ICON_MD_MAP,
.category = "Screen",
.shortcut_hint = "Alt+1",
.priority = 10});
card_registry->RegisterCard({.card_id = "screen.inventory_menu",
.display_name = "Inventory Menu",
.icon = ICON_MD_INVENTORY,
.category = "Screen",
.shortcut_hint = "Alt+2",
.priority = 20});
card_registry->RegisterCard({.card_id = "screen.overworld_map",
.display_name = "Overworld Map",
.icon = ICON_MD_PUBLIC,
.category = "Screen",
.shortcut_hint = "Alt+3",
.priority = 30});
card_registry->RegisterCard({.card_id = "screen.title_screen",
.display_name = "Title Screen",
.icon = ICON_MD_TITLE,
.category = "Screen",
.shortcut_hint = "Alt+4",
.priority = 40});
card_registry->RegisterCard({.card_id = "screen.naming_screen",
.display_name = "Naming Screen",
.icon = ICON_MD_EDIT,
.category = "Screen",
.shortcut_hint = "Alt+5",
.priority = 50});
// Show title screen by default
card_registry->ShowCard("screen.title_screen");
}
@@ -76,45 +91,48 @@ absl::Status ScreenEditor::Load() {
const int tile8_width = 128;
const int tile8_height = 128; // 4 sheets × 32 pixels each
std::vector<uint8_t> tile8_data(tile8_width * tile8_height);
// Copy data from all 4 sheets into the combined bitmap
for (int sheet_idx = 0; sheet_idx < 4; sheet_idx++) {
const auto& sheet = sheets_[sheet_idx];
int dest_y_offset = sheet_idx * 32; // Each sheet is 32 pixels tall
for (int y = 0; y < 32; y++) {
for (int x = 0; x < 128; x++) {
int src_index = y * 128 + x;
int dest_index = (dest_y_offset + y) * 128 + x;
if (src_index < sheet.size() && dest_index < tile8_data.size()) {
tile8_data[dest_index] = sheet.data()[src_index];
}
}
}
}
// Create tilemap with 8x8 tile size
tile8_tilemap_.tile_size = {8, 8};
tile8_tilemap_.map_size = {256, 256}; // Logical size for tile count
tile8_tilemap_.atlas.Create(tile8_width, tile8_height, 8, tile8_data);
tile8_tilemap_.atlas.SetPalette(*rom()->mutable_dungeon_palette(3));
// Queue single texture creation for the atlas (not individual tiles)
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::CREATE, &tile8_tilemap_.atlas);
gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::CREATE,
&tile8_tilemap_.atlas);
return absl::OkStatus();
}
absl::Status ScreenEditor::Update() {
if (!dependencies_.card_registry) return absl::OkStatus();
if (!dependencies_.card_registry)
return absl::OkStatus();
auto* card_registry = dependencies_.card_registry;
static gui::EditorCard dungeon_maps_card("Dungeon Maps", ICON_MD_MAP);
static gui::EditorCard inventory_menu_card("Inventory Menu", ICON_MD_INVENTORY);
static gui::EditorCard inventory_menu_card("Inventory Menu",
ICON_MD_INVENTORY);
static gui::EditorCard overworld_map_card("Overworld Map", ICON_MD_PUBLIC);
static gui::EditorCard title_screen_card("Title Screen", ICON_MD_TITLE);
static gui::EditorCard naming_screen_card("Naming Screen", ICON_MD_EDIT_ATTRIBUTES);
static gui::EditorCard naming_screen_card("Naming Screen",
ICON_MD_EDIT_ATTRIBUTES);
dungeon_maps_card.SetDefaultSize(800, 600);
inventory_menu_card.SetDefaultSize(800, 600);
@@ -123,43 +141,48 @@ absl::Status ScreenEditor::Update() {
naming_screen_card.SetDefaultSize(500, 400);
// Dungeon Maps Card - Check visibility flag exists and is true before rendering
bool* dungeon_maps_visible = card_registry->GetVisibilityFlag("screen.dungeon_maps");
bool* dungeon_maps_visible =
card_registry->GetVisibilityFlag("screen.dungeon_maps");
if (dungeon_maps_visible && *dungeon_maps_visible) {
if (dungeon_maps_card.Begin(dungeon_maps_visible)) {
DrawDungeonMapsEditor();
}
dungeon_maps_card.End();
}
// Inventory Menu Card - Check visibility flag exists and is true before rendering
bool* inventory_menu_visible = card_registry->GetVisibilityFlag("screen.inventory_menu");
bool* inventory_menu_visible =
card_registry->GetVisibilityFlag("screen.inventory_menu");
if (inventory_menu_visible && *inventory_menu_visible) {
if (inventory_menu_card.Begin(inventory_menu_visible)) {
DrawInventoryMenuEditor();
}
inventory_menu_card.End();
}
// Overworld Map Card - Check visibility flag exists and is true before rendering
bool* overworld_map_visible = card_registry->GetVisibilityFlag("screen.overworld_map");
bool* overworld_map_visible =
card_registry->GetVisibilityFlag("screen.overworld_map");
if (overworld_map_visible && *overworld_map_visible) {
if (overworld_map_card.Begin(overworld_map_visible)) {
DrawOverworldMapEditor();
}
overworld_map_card.End();
}
// Title Screen Card - Check visibility flag exists and is true before rendering
bool* title_screen_visible = card_registry->GetVisibilityFlag("screen.title_screen");
bool* title_screen_visible =
card_registry->GetVisibilityFlag("screen.title_screen");
if (title_screen_visible && *title_screen_visible) {
if (title_screen_card.Begin(title_screen_visible)) {
DrawTitleScreenEditor();
}
title_screen_card.End();
}
// Naming Screen Card - Check visibility flag exists and is true before rendering
bool* naming_screen_visible = card_registry->GetVisibilityFlag("screen.naming_screen");
bool* naming_screen_visible =
card_registry->GetVisibilityFlag("screen.naming_screen");
if (naming_screen_visible && *naming_screen_visible) {
if (naming_screen_card.Begin(naming_screen_visible)) {
DrawNamingScreenEditor();
@@ -176,58 +199,58 @@ void ScreenEditor::DrawToolset() {
}
void ScreenEditor::DrawInventoryMenuEditor() {
static bool create = false;
if (!create && rom()->is_loaded()) {
status_ = inventory_.Create(rom());
if (status_.ok()) {
palette_ = inventory_.palette();
create = true;
} else {
ImGui::TextColored(ImVec4(1, 0, 0, 1), "Error loading inventory: %s",
status_.message().data());
return;
}
static bool create = false;
if (!create && rom()->is_loaded()) {
status_ = inventory_.Create(rom());
if (status_.ok()) {
palette_ = inventory_.palette();
create = true;
} else {
ImGui::TextColored(ImVec4(1, 0, 0, 1), "Error loading inventory: %s",
status_.message().data());
return;
}
}
DrawInventoryToolset();
DrawInventoryToolset();
if (ImGui::BeginTable("InventoryScreen", 4, ImGuiTableFlags_Resizable)) {
ImGui::TableSetupColumn("Canvas");
ImGui::TableSetupColumn("Tilesheet");
ImGui::TableSetupColumn("Item Icons");
ImGui::TableSetupColumn("Palette");
ImGui::TableHeadersRow();
if (ImGui::BeginTable("InventoryScreen", 4, ImGuiTableFlags_Resizable)) {
ImGui::TableSetupColumn("Canvas");
ImGui::TableSetupColumn("Tilesheet");
ImGui::TableSetupColumn("Item Icons");
ImGui::TableSetupColumn("Palette");
ImGui::TableHeadersRow();
ImGui::TableNextColumn();
screen_canvas_.DrawBackground();
screen_canvas_.DrawContextMenu();
screen_canvas_.DrawBitmap(inventory_.bitmap(), 2, create);
screen_canvas_.DrawGrid(32.0f);
screen_canvas_.DrawOverlay();
ImGui::TableNextColumn();
screen_canvas_.DrawBackground();
screen_canvas_.DrawContextMenu();
screen_canvas_.DrawBitmap(inventory_.bitmap(), 2, create);
screen_canvas_.DrawGrid(32.0f);
screen_canvas_.DrawOverlay();
ImGui::TableNextColumn();
tilesheet_canvas_.DrawBackground(ImVec2(128 * 2 + 2, (192 * 2) + 4));
tilesheet_canvas_.DrawContextMenu();
tilesheet_canvas_.DrawBitmap(inventory_.tilesheet(), 2, create);
tilesheet_canvas_.DrawGrid(16.0f);
tilesheet_canvas_.DrawOverlay();
ImGui::TableNextColumn();
tilesheet_canvas_.DrawBackground(ImVec2(128 * 2 + 2, (192 * 2) + 4));
tilesheet_canvas_.DrawContextMenu();
tilesheet_canvas_.DrawBitmap(inventory_.tilesheet(), 2, create);
tilesheet_canvas_.DrawGrid(16.0f);
tilesheet_canvas_.DrawOverlay();
ImGui::TableNextColumn();
DrawInventoryItemIcons();
ImGui::TableNextColumn();
DrawInventoryItemIcons();
ImGui::TableNextColumn();
gui::DisplayPalette(palette_, create);
ImGui::TableNextColumn();
gui::DisplayPalette(palette_, create);
ImGui::EndTable();
}
ImGui::Separator();
ImGui::EndTable();
}
ImGui::Separator();
// TODO(scawful): Future Oracle of Secrets menu editor integration
// - Full inventory screen layout editor
// - Item slot assignment and positioning
// - Heart container and magic meter editor
// - Equipment display customization
// - A/B button equipment quick-select editor
// TODO(scawful): Future Oracle of Secrets menu editor integration
// - Full inventory screen layout editor
// - Item slot assignment and positioning
// - Heart container and magic meter editor
// - Equipment display customization
// - A/B button equipment quick-select editor
}
void ScreenEditor::DrawInventoryToolset() {
@@ -283,8 +306,9 @@ void ScreenEditor::DrawInventoryItemIcons() {
auto& icons = inventory_.item_icons();
if (icons.empty()) {
ImGui::TextWrapped("No item icons loaded. Icons will be loaded when the "
"inventory is initialized.");
ImGui::TextWrapped(
"No item icons loaded. Icons will be loaded when the "
"inventory is initialized.");
ImGui::EndChild();
return;
}
@@ -366,11 +390,12 @@ void ScreenEditor::DrawDungeonMapScreen(int i) {
const int tiles_per_row = tile16_blockset_.atlas.width() / 16;
const int tile_x = (tile16_id % tiles_per_row) * 16;
const int tile_y = (tile16_id / tiles_per_row) * 16;
std::vector<uint8_t> tile_data(16 * 16);
int tile_data_offset = 0;
tile16_blockset_.atlas.Get16x16Tile(tile_x, tile_y, tile_data, tile_data_offset);
tile16_blockset_.atlas.Get16x16Tile(tile_x, tile_y, tile_data,
tile_data_offset);
// Create or update cached tile
auto* cached_tile = tile16_blockset_.tile_cache.GetTile(tile16_id);
if (!cached_tile) {
@@ -383,7 +408,7 @@ void ScreenEditor::DrawDungeonMapScreen(int i) {
// Update existing cached tile data
cached_tile->set_data(tile_data);
}
if (cached_tile && cached_tile->is_active()) {
// Ensure the cached tile has a valid texture
if (!cached_tile->texture()) {
@@ -535,17 +560,18 @@ void ScreenEditor::DrawDungeonMapsRoomGfx() {
ImGui::Separator();
current_tile_canvas_.DrawBackground(); // ImVec2(64 * 2 + 2, 64 * 2 + 4));
current_tile_canvas_.DrawContextMenu();
// Get tile8 from cache on-demand (only create texture when needed)
if (selected_tile8_ >= 0 && selected_tile8_ < 256) {
auto* cached_tile8 = tile8_tilemap_.tile_cache.GetTile(selected_tile8_);
if (!cached_tile8) {
// Extract tile from atlas and cache it
const int tiles_per_row = tile8_tilemap_.atlas.width() / 8; // 128 / 8 = 16
const int tiles_per_row =
tile8_tilemap_.atlas.width() / 8; // 128 / 8 = 16
const int tile_x = (selected_tile8_ % tiles_per_row) * 8;
const int tile_y = (selected_tile8_ / tiles_per_row) * 8;
// Extract 8x8 tile data from atlas
std::vector<uint8_t> tile_data(64);
for (int py = 0; py < 8; py++) {
@@ -554,26 +580,27 @@ void ScreenEditor::DrawDungeonMapsRoomGfx() {
int src_y = tile_y + py;
int src_index = src_y * tile8_tilemap_.atlas.width() + src_x;
int dst_index = py * 8 + px;
if (src_index < tile8_tilemap_.atlas.size() && dst_index < 64) {
tile_data[dst_index] = tile8_tilemap_.atlas.data()[src_index];
}
}
}
gfx::Bitmap new_tile8(8, 8, 8, tile_data);
new_tile8.SetPalette(tile8_tilemap_.atlas.palette());
tile8_tilemap_.tile_cache.CacheTile(selected_tile8_, std::move(new_tile8));
tile8_tilemap_.tile_cache.CacheTile(selected_tile8_,
std::move(new_tile8));
cached_tile8 = tile8_tilemap_.tile_cache.GetTile(selected_tile8_);
}
if (cached_tile8 && cached_tile8->is_active()) {
// Create texture on-demand only when needed
if (!cached_tile8->texture()) {
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::CREATE, cached_tile8);
}
if (current_tile_canvas_.DrawTilePainter(*cached_tile8, 16)) {
// Modify the tile16 based on the selected tile and current_tile16_info
gfx::ModifyTile16(tile16_blockset_, rom()->graphics_buffer(),
@@ -775,13 +802,14 @@ void ScreenEditor::DrawTitleScreenEditor() {
ImGui::Checkbox("Show BG1", &show_title_bg1_);
ImGui::SameLine();
ImGui::Checkbox("Show BG2", &show_title_bg2_);
// Re-render composite if visibility changed
if (prev_bg1 != show_title_bg1_ || prev_bg2 != show_title_bg2_) {
status_ = title_screen_.RenderCompositeLayer(show_title_bg1_, show_title_bg2_);
status_ =
title_screen_.RenderCompositeLayer(show_title_bg1_, show_title_bg2_);
if (status_.ok()) {
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::UPDATE,
gfx::Arena::TextureCommandType::UPDATE,
&title_screen_.composite_bitmap());
}
}
@@ -822,27 +850,30 @@ void ScreenEditor::DrawTitleScreenCompositeCanvas() {
auto click_pos = title_bg1_canvas_.points().front();
int tile_x = static_cast<int>(click_pos.x) / 8;
int tile_y = static_cast<int>(click_pos.y) / 8;
if (tile_x >= 0 && tile_x < 32 && tile_y >= 0 && tile_y < 32) {
int tilemap_index = tile_y * 32 + tile_x;
// Create tile word: tile_id | (palette << 10) | h_flip | v_flip
uint16_t tile_word = selected_title_tile16_ & 0x3FF;
tile_word |= (title_palette_ & 0x07) << 10;
if (title_h_flip_) tile_word |= 0x4000;
if (title_v_flip_) tile_word |= 0x8000;
if (title_h_flip_)
tile_word |= 0x4000;
if (title_v_flip_)
tile_word |= 0x8000;
// Update BG1 buffer and re-render both layers and composite
title_screen_.mutable_bg1_buffer()[tilemap_index] = tile_word;
status_ = title_screen_.RenderBG1Layer();
if (status_.ok()) {
// Update BG1 texture
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::UPDATE,
gfx::Arena::TextureCommandType::UPDATE,
&title_screen_.bg1_bitmap());
// Re-render and update composite
status_ = title_screen_.RenderCompositeLayer(show_title_bg1_, show_title_bg2_);
status_ = title_screen_.RenderCompositeLayer(show_title_bg1_,
show_title_bg2_);
if (status_.ok()) {
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::UPDATE, &composite_bitmap);
@@ -874,16 +905,18 @@ void ScreenEditor::DrawTitleScreenBG1Canvas() {
auto click_pos = title_bg1_canvas_.points().front();
int tile_x = static_cast<int>(click_pos.x) / 8;
int tile_y = static_cast<int>(click_pos.y) / 8;
if (tile_x >= 0 && tile_x < 32 && tile_y >= 0 && tile_y < 32) {
int tilemap_index = tile_y * 32 + tile_x;
// Create tile word: tile_id | (palette << 10) | h_flip | v_flip
uint16_t tile_word = selected_title_tile16_ & 0x3FF;
tile_word |= (title_palette_ & 0x07) << 10;
if (title_h_flip_) tile_word |= 0x4000;
if (title_v_flip_) tile_word |= 0x8000;
if (title_h_flip_)
tile_word |= 0x4000;
if (title_v_flip_)
tile_word |= 0x8000;
// Update buffer and re-render
title_screen_.mutable_bg1_buffer()[tilemap_index] = tile_word;
status_ = title_screen_.RenderBG1Layer();
@@ -917,16 +950,18 @@ void ScreenEditor::DrawTitleScreenBG2Canvas() {
auto click_pos = title_bg2_canvas_.points().front();
int tile_x = static_cast<int>(click_pos.x) / 8;
int tile_y = static_cast<int>(click_pos.y) / 8;
if (tile_x >= 0 && tile_x < 32 && tile_y >= 0 && tile_y < 32) {
int tilemap_index = tile_y * 32 + tile_x;
// Create tile word: tile_id | (palette << 10) | h_flip | v_flip
uint16_t tile_word = selected_title_tile16_ & 0x3FF;
tile_word |= (title_palette_ & 0x07) << 10;
if (title_h_flip_) tile_word |= 0x4000;
if (title_v_flip_) tile_word |= 0x8000;
if (title_h_flip_)
tile_word |= 0x4000;
if (title_v_flip_)
tile_word |= 0x8000;
// Update buffer and re-render
title_screen_.mutable_bg2_buffer()[tilemap_index] = tile_word;
status_ = title_screen_.RenderBG2Layer();
@@ -971,20 +1006,19 @@ void ScreenEditor::DrawTitleScreenBlocksetSelector() {
// Show selected tile preview and controls
if (selected_title_tile16_ >= 0) {
ImGui::Text("Selected Tile: %d", selected_title_tile16_);
// Flip controls
ImGui::Checkbox("H Flip", &title_h_flip_);
ImGui::SameLine();
ImGui::Checkbox("V Flip", &title_v_flip_);
// Palette selector (0-7 for 3BPP graphics)
ImGui::SetNextItemWidth(100);
ImGui::SliderInt("Palette", &title_palette_, 0, 7);
}
}
void ScreenEditor::DrawNamingScreenEditor() {
}
void ScreenEditor::DrawNamingScreenEditor() {}
void ScreenEditor::DrawOverworldMapEditor() {
// Initialize overworld map on first draw
@@ -1015,7 +1049,7 @@ void ScreenEditor::DrawOverworldMapEditor() {
}
}
ImGui::SameLine();
// World toggle
if (ImGui::Button(ow_show_dark_world_ ? "Dark World" : "Light World")) {
ow_show_dark_world_ = !ow_show_dark_world_;
@@ -1027,7 +1061,7 @@ void ScreenEditor::DrawOverworldMapEditor() {
}
}
ImGui::SameLine();
// Custom map load/save buttons
if (ImGui::Button("Load Custom Map...")) {
std::string path = util::FileDialogWrapper::ShowOpenFileDialog();
@@ -1048,10 +1082,10 @@ void ScreenEditor::DrawOverworldMapEditor() {
}
}
}
ImGui::SameLine();
ImGui::Text("Selected Tile: %d", selected_ow_tile_);
// Custom map error/success popups
if (ImGui::BeginPopup("CustomMapLoadError")) {
ImGui::Text("Error loading custom map: %s", status_.message().data());
@@ -1093,17 +1127,17 @@ void ScreenEditor::DrawOverworldMapEditor() {
auto click_pos = ow_map_canvas_.points().front();
int tile_x = static_cast<int>(click_pos.x) / 8;
int tile_y = static_cast<int>(click_pos.y) / 8;
if (tile_x >= 0 && tile_x < 64 && tile_y >= 0 && tile_y < 64) {
int tile_index = tile_x + (tile_y * 64);
// Update appropriate world's tile data
if (ow_show_dark_world_) {
ow_map_screen_.mutable_dw_tiles()[tile_index] = selected_ow_tile_;
} else {
ow_map_screen_.mutable_lw_tiles()[tile_index] = selected_ow_tile_;
}
// Re-render map
status_ = ow_map_screen_.RenderMapLayer(ow_show_dark_world_);
if (status_.ok()) {
@@ -1143,7 +1177,7 @@ void ScreenEditor::DrawOverworldMapEditor() {
// Column 3: Palette Display
ImGui::TableNextColumn();
auto& palette = ow_show_dark_world_ ? ow_map_screen_.dw_palette()
auto& palette = ow_show_dark_world_ ? ow_map_screen_.dw_palette()
: ow_map_screen_.lw_palette();
// Use inline palette editor for full 128-color palette
gui::InlinePaletteEditor(palette, "Overworld Map Palette");

11
src/app/editor/graphics/screen_editor.h
View File

@@ -6,16 +6,16 @@
#include "absl/status/status.h"
#include "app/editor/editor.h"
#include "app/gfx/core/bitmap.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gfx/render/tilemap.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gui/app/editor_layout.h"
#include "app/gui/canvas/canvas.h"
#include "app/rom.h"
#include "imgui/imgui.h"
#include "zelda3/screen/dungeon_map.h"
#include "zelda3/screen/inventory.h"
#include "zelda3/screen/title_screen.h"
#include "zelda3/screen/overworld_map_screen.h"
#include "app/gui/app/editor_layout.h"
#include "imgui/imgui.h"
#include "zelda3/screen/title_screen.h"
namespace yaze {
namespace editor {
@@ -120,8 +120,7 @@ class ScreenEditor : public Editor {
gui::Canvas title_bg2_canvas_{"##TitleBG2Canvas", ImVec2(256, 256),
gui::CanvasGridSize::k8x8, 2.0f};
// Blockset is 128 pixels wide x 512 pixels tall (16x64 8x8 tiles)
gui::Canvas title_blockset_canvas_{"##TitleBlocksetCanvas",
ImVec2(128, 512),
gui::Canvas title_blockset_canvas_{"##TitleBlocksetCanvas", ImVec2(128, 512),
gui::CanvasGridSize::k8x8, 2.0f};
zelda3::Inventory inventory_;

26
src/app/editor/message/message_data.cc
View File

@@ -97,7 +97,7 @@ std::string ParseTextDataByte(uint8_t value) {
// Check for dictionary.
int8_t dictionary = FindDictionaryEntry(value);
if (dictionary >= 0) {
return absl::StrFormat("[%s:%02X]", DICTIONARYTOKEN,
return absl::StrFormat("[%s:%02X]", DICTIONARYTOKEN,
static_cast<unsigned char>(dictionary));
}
@@ -181,8 +181,8 @@ std::vector<DictionaryEntry> BuildDictionaryEntries(Rom* rom) {
return AllDictionaries;
}
std::string ReplaceAllDictionaryWords(std::string str,
const std::vector<DictionaryEntry>& dictionary) {
std::string ReplaceAllDictionaryWords(
std::string str, const std::vector<DictionaryEntry>& dictionary) {
std::string temp = std::move(str);
for (const auto& entry : dictionary) {
if (entry.ContainedInString(temp)) {
@@ -251,7 +251,8 @@ absl::StatusOr<MessageData> ParseSingleMessage(
current_message_raw.append("[");
current_message_raw.append(DICTIONARYTOKEN);
current_message_raw.append(":");
current_message_raw.append(util::HexWord(static_cast<unsigned char>(dictionary)));
current_message_raw.append(
util::HexWord(static_cast<unsigned char>(dictionary)));
current_message_raw.append("]");
auto mutable_rom_data = const_cast<uint8_t*>(rom_data.data());
@@ -292,13 +293,13 @@ std::vector<std::string> ParseMessageData(
// Use index-based loop to properly skip argument bytes
for (size_t pos = 0; pos < message.Data.size(); ++pos) {
uint8_t byte = message.Data[pos];
// Check for text commands first (they may have arguments to skip)
auto text_element = FindMatchingCommand(byte);
if (text_element != std::nullopt) {
// Add newline for certain commands
if (text_element->ID == kScrollVertical ||
text_element->ID == kLine2 || text_element->ID == kLine3) {
if (text_element->ID == kScrollVertical || text_element->ID == kLine2 ||
text_element->ID == kLine3) {
parsed_message.append("\n");
}
// If command has an argument, get it from next byte and skip it
@@ -311,14 +312,14 @@ std::vector<std::string> ParseMessageData(
}
continue; // Move to next byte
}
// Check for special characters
auto special_element = FindMatchingSpecial(byte);
if (special_element != std::nullopt) {
parsed_message.append(special_element->GetParamToken());
continue;
}
// Check for dictionary entries
if (byte >= DICTOFF && byte < (DICTOFF + 97)) {
DictionaryEntry dic_entry;
@@ -331,7 +332,7 @@ std::vector<std::string> ParseMessageData(
parsed_message.append(dic_entry.Contents);
continue;
}
// Finally check for regular characters
if (CharEncoder.contains(byte)) {
parsed_message.push_back(CharEncoder.at(byte));
@@ -401,8 +402,9 @@ std::vector<MessageData> ReadAllTextData(uint8_t* rom, int pos) {
// Check for dictionary.
int8_t dictionary = FindDictionaryEntry(current_byte);
if (dictionary >= 0) {
current_raw_message.append(absl::StrFormat("[%s:%s]", DICTIONARYTOKEN,
util::HexByte(static_cast<unsigned char>(dictionary))));
current_raw_message.append(absl::StrFormat(
"[%s:%s]", DICTIONARYTOKEN,
util::HexByte(static_cast<unsigned char>(dictionary))));
uint32_t address =
Get24LocalFromPC(rom, kPointersDictionaries + (dictionary * 2));

40
src/app/editor/message/message_data.h
View File

@@ -42,7 +42,7 @@
// ## Data Flow
//
// ### Reading from ROM:
// ROM bytes → ReadAllTextData() → MessageData (raw) → ParseMessageData() →
// ROM bytes → ReadAllTextData() → MessageData (raw) → ParseMessageData() →
// Human-readable string with [command] tokens
//
// ### Writing to ROM:
@@ -64,7 +64,7 @@
//
// Messages are stored as byte sequences terminated by 0x7F:
// Example: [0x00, 0x01, 0x02, 0x7F] = "ABC"
// Example: [0x6A, 0x59, 0x2C, 0x61, 0x32, 0x28, 0x2B, 0x23, 0x7F]
// Example: [0x6A, 0x59, 0x2C, 0x61, 0x32, 0x28, 0x2B, 0x23, 0x7F]
// = "[L] saved Hyrule" (0x6A = player name command)
//
// ## Token Syntax (Human-Readable Format)
@@ -81,13 +81,13 @@
#include <optional>
#include <regex>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
#include <string_view>
#include "absl/strings/match.h"
#include "absl/strings/str_format.h"
#include "absl/strings/str_replace.h"
#include "absl/strings/match.h"
#include "app/rom.h"
namespace yaze {
@@ -137,11 +137,11 @@ std::vector<uint8_t> ParseMessageToData(std::string str);
// Dictionary entries are stored separately in ROM and referenced by bytes 0x88-0xE8
// Example: Dictionary entry 0x00 might contain "the" and be referenced as [D:00]
struct DictionaryEntry {
uint8_t ID = 0; // Dictionary index (0-96)
std::string Contents = ""; // The actual text this entry represents
std::vector<uint8_t> Data; // Binary representation of Contents
int Length = 0; // Character count
std::string Token = ""; // Human-readable token like "[D:00]"
uint8_t ID = 0; // Dictionary index (0-96)
std::string Contents = ""; // The actual text this entry represents
std::vector<uint8_t> Data; // Binary representation of Contents
int Length = 0; // Character count
std::string Token = ""; // Human-readable token like "[D:00]"
DictionaryEntry() = default;
DictionaryEntry(uint8_t i, std::string_view s)
@@ -183,8 +183,8 @@ std::vector<DictionaryEntry> BuildDictionaryEntries(Rom* rom);
// Replaces all dictionary words in a string with their [D:XX] tokens
// Used for text compression when saving messages back to ROM
std::string ReplaceAllDictionaryWords(std::string str,
const std::vector<DictionaryEntry>& dictionary);
std::string ReplaceAllDictionaryWords(
std::string str, const std::vector<DictionaryEntry>& dictionary);
// Looks up a dictionary entry by its ROM byte value
DictionaryEntry FindRealDictionaryEntry(
@@ -199,12 +199,12 @@ const std::string CHEESE = "\uBEBE";
// 1. Raw: Direct ROM bytes with dictionary references as [D:XX] tokens
// 2. Parsed: Fully expanded with dictionary words replaced by actual text
struct MessageData {
int ID = 0; // Message index in the ROM
int Address = 0; // ROM address where this message is stored
std::string RawString; // Human-readable with [D:XX] dictionary tokens
std::string ContentsParsed; // Fully expanded human-readable text
std::vector<uint8_t> Data; // Raw ROM bytes (may contain dict references)
std::vector<uint8_t> DataParsed; // Expanded bytes (dict entries expanded)
int ID = 0; // Message index in the ROM
int Address = 0; // ROM address where this message is stored
std::string RawString; // Human-readable with [D:XX] dictionary tokens
std::string ContentsParsed; // Fully expanded human-readable text
std::vector<uint8_t> Data; // Raw ROM bytes (may contain dict references)
std::vector<uint8_t> DataParsed; // Expanded bytes (dict entries expanded)
MessageData() = default;
MessageData(int id, int address, const std::string& rawString,
@@ -410,9 +410,9 @@ std::optional<TextElement> FindMatchingSpecial(uint8_t b);
// Result of parsing a text token like "[W:02]"
// Contains both the command definition and its argument value
struct ParsedElement {
TextElement Parent; // The command or special character definition
uint8_t Value; // Argument value (if command has argument)
bool Active = false; // True if parsing was successful
TextElement Parent; // The command or special character definition
uint8_t Value; // Argument value (if command has argument)
bool Active = false; // True if parsing was successful
ParsedElement() = default;
ParsedElement(const TextElement& textElement, uint8_t value)

149
src/app/editor/message/message_editor.cc
View File

@@ -7,19 +7,19 @@
#include "absl/status/status.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_format.h"
#include "app/gfx/resource/arena.h"
#include "app/gfx/debug/performance/performance_profiler.h"
#include "util/file_util.h"
#include "app/gfx/core/bitmap.h"
#include "app/gfx/debug/performance/performance_profiler.h"
#include "app/gfx/resource/arena.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gfx/types/snes_tile.h"
#include "app/gui/canvas/canvas.h"
#include "app/gui/core/style.h"
#include "app/gui/core/icons.h"
#include "app/rom.h"
#include "app/gui/core/input.h"
#include "app/gui/core/style.h"
#include "app/rom.h"
#include "imgui.h"
#include "imgui/misc/cpp/imgui_stdlib.h"
#include "util/file_util.h"
#include "util/hex.h"
#include "util/log.h"
@@ -41,7 +41,6 @@ std::string DisplayTextOverflowError(int pos, bool bank) {
}
} // namespace
using ImGui::BeginChild;
using ImGui::BeginTable;
using ImGui::Button;
@@ -64,45 +63,38 @@ constexpr ImGuiTableFlags kMessageTableFlags = ImGuiTableFlags_Hideable |
void MessageEditor::Initialize() {
// Register cards with EditorCardRegistry (dependency injection)
if (!dependencies_.card_registry) return;
if (!dependencies_.card_registry)
return;
auto* card_registry = dependencies_.card_registry;
card_registry->RegisterCard({
.card_id = MakeCardId("message.message_list"),
.display_name = "Message List",
.icon = ICON_MD_LIST,
.category = "Message",
.priority = 10
});
card_registry->RegisterCard({
.card_id = MakeCardId("message.message_editor"),
.display_name = "Message Editor",
.icon = ICON_MD_EDIT,
.category = "Message",
.priority = 20
});
card_registry->RegisterCard({
.card_id = MakeCardId("message.font_atlas"),
.display_name = "Font Atlas",
.icon = ICON_MD_FONT_DOWNLOAD,
.category = "Message",
.priority = 30
});
card_registry->RegisterCard({
.card_id = MakeCardId("message.dictionary"),
.display_name = "Dictionary",
.icon = ICON_MD_BOOK,
.category = "Message",
.priority = 40
});
card_registry->RegisterCard({.card_id = MakeCardId("message.message_list"),
.display_name = "Message List",
.icon = ICON_MD_LIST,
.category = "Message",
.priority = 10});
card_registry->RegisterCard({.card_id = MakeCardId("message.message_editor"),
.display_name = "Message Editor",
.icon = ICON_MD_EDIT,
.category = "Message",
.priority = 20});
card_registry->RegisterCard({.card_id = MakeCardId("message.font_atlas"),
.display_name = "Font Atlas",
.icon = ICON_MD_FONT_DOWNLOAD,
.category = "Message",
.priority = 30});
card_registry->RegisterCard({.card_id = MakeCardId("message.dictionary"),
.display_name = "Dictionary",
.icon = ICON_MD_BOOK,
.category = "Message",
.priority = 40});
// Show message list by default
card_registry->ShowCard(MakeCardId("message.message_list"));
for (int i = 0; i < kWidthArraySize; i++) {
message_preview_.width_array[i] = rom()->data()[kCharactersWidth + i];
}
@@ -116,16 +108,17 @@ void MessageEditor::Initialize() {
}
message_preview_.font_gfx16_data_ =
gfx::SnesTo8bppSheet(raw_font_gfx_data_, /*bpp=*/2, /*num_sheets=*/2);
// Create bitmap for font graphics
font_gfx_bitmap_.Create(kFontGfxMessageSize, kFontGfxMessageSize,
kFontGfxMessageDepth, message_preview_.font_gfx16_data_);
font_gfx_bitmap_.Create(kFontGfxMessageSize, kFontGfxMessageSize,
kFontGfxMessageDepth,
message_preview_.font_gfx16_data_);
font_gfx_bitmap_.SetPalette(font_preview_colors_);
// Queue texture creation - will be processed in render loop
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::CREATE, &font_gfx_bitmap_);
gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::CREATE,
&font_gfx_bitmap_);
LOG_INFO("MessageEditor", "Font bitmap created and texture queued");
*current_font_gfx16_bitmap_.mutable_palette() = font_preview_colors_;
@@ -140,18 +133,20 @@ void MessageEditor::Initialize() {
DrawMessagePreview();
}
absl::Status MessageEditor::Load() {
absl::Status MessageEditor::Load() {
gfx::ScopedTimer timer("MessageEditor::Load");
return absl::OkStatus();
return absl::OkStatus();
}
absl::Status MessageEditor::Update() {
if (!dependencies_.card_registry) return absl::OkStatus();
if (!dependencies_.card_registry)
return absl::OkStatus();
auto* card_registry = dependencies_.card_registry;
// Message List Card - Get visibility flag and pass to Begin() for proper X button
bool* list_visible = card_registry->GetVisibilityFlag(MakeCardId("message.message_list"));
bool* list_visible =
card_registry->GetVisibilityFlag(MakeCardId("message.message_list"));
if (list_visible && *list_visible) {
static gui::EditorCard list_card("Message List", ICON_MD_LIST);
list_card.SetDefaultSize(400, 600);
@@ -160,9 +155,10 @@ absl::Status MessageEditor::Update() {
}
list_card.End();
}
// Message Editor Card - Get visibility flag and pass to Begin() for proper X button
bool* editor_visible = card_registry->GetVisibilityFlag(MakeCardId("message.message_editor"));
bool* editor_visible =
card_registry->GetVisibilityFlag(MakeCardId("message.message_editor"));
if (editor_visible && *editor_visible) {
static gui::EditorCard editor_card("Message Editor", ICON_MD_EDIT);
editor_card.SetDefaultSize(500, 600);
@@ -171,9 +167,10 @@ absl::Status MessageEditor::Update() {
}
editor_card.End();
}
// Font Atlas Card - Get visibility flag and pass to Begin() for proper X button
bool* font_visible = card_registry->GetVisibilityFlag(MakeCardId("message.font_atlas"));
bool* font_visible =
card_registry->GetVisibilityFlag(MakeCardId("message.font_atlas"));
if (font_visible && *font_visible) {
static gui::EditorCard font_card("Font Atlas", ICON_MD_FONT_DOWNLOAD);
font_card.SetDefaultSize(400, 500);
@@ -183,9 +180,10 @@ absl::Status MessageEditor::Update() {
}
font_card.End();
}
// Dictionary Card - Get visibility flag and pass to Begin() for proper X button
bool* dict_visible = card_registry->GetVisibilityFlag(MakeCardId("message.dictionary"));
bool* dict_visible =
card_registry->GetVisibilityFlag(MakeCardId("message.dictionary"));
if (dict_visible && *dict_visible) {
static gui::EditorCard dict_card("Dictionary", ICON_MD_BOOK);
dict_card.SetDefaultSize(400, 500);
@@ -196,7 +194,7 @@ absl::Status MessageEditor::Update() {
}
dict_card.End();
}
return absl::OkStatus();
}
@@ -405,39 +403,44 @@ void MessageEditor::DrawDictionary() {
void MessageEditor::DrawMessagePreview() {
// Render the message to the preview bitmap
message_preview_.DrawMessagePreview(current_message_);
// Validate preview data before updating
if (message_preview_.current_preview_data_.empty()) {
LOG_WARN("MessageEditor", "Preview data is empty, skipping bitmap update");
return;
}
if (current_font_gfx16_bitmap_.is_active()) {
// CRITICAL: Use set_data() to properly update both data_ AND surface_
// mutable_data() returns a reference but doesn't update the surface!
current_font_gfx16_bitmap_.set_data(message_preview_.current_preview_data_);
// Validate surface was updated
if (!current_font_gfx16_bitmap_.surface()) {
LOG_ERROR("MessageEditor", "Bitmap surface is null after set_data()");
return;
}
// Queue texture update so changes are visible immediately
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::UPDATE, &current_font_gfx16_bitmap_);
LOG_DEBUG("MessageEditor", "Updated message preview bitmap (size: %zu) and queued texture update",
message_preview_.current_preview_data_.size());
LOG_DEBUG(
"MessageEditor",
"Updated message preview bitmap (size: %zu) and queued texture update",
message_preview_.current_preview_data_.size());
} else {
// Create bitmap and queue texture creation with 8-bit indexed depth
current_font_gfx16_bitmap_.Create(kCurrentMessageWidth, kCurrentMessageHeight,
8, message_preview_.current_preview_data_);
current_font_gfx16_bitmap_.Create(kCurrentMessageWidth,
kCurrentMessageHeight, 8,
message_preview_.current_preview_data_);
current_font_gfx16_bitmap_.SetPalette(font_preview_colors_);
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::CREATE, &current_font_gfx16_bitmap_);
LOG_INFO("MessageEditor", "Created message preview bitmap (%dx%d) with 8-bit depth and queued texture creation",
LOG_INFO("MessageEditor",
"Created message preview bitmap (%dx%d) with 8-bit depth and "
"queued texture creation",
kCurrentMessageWidth, kCurrentMessageHeight);
}
}

7
src/app/editor/message/message_editor.h
View File

@@ -9,8 +9,8 @@
#include "app/editor/editor.h"
#include "app/editor/message/message_data.h"
#include "app/editor/message/message_preview.h"
#include "app/gui/app/editor_layout.h"
#include "app/gfx/core/bitmap.h"
#include "app/gui/app/editor_layout.h"
#include "app/gui/canvas/canvas.h"
#include "app/gui/core/style.h"
#include "app/rom.h"
@@ -22,7 +22,8 @@ constexpr int kGfxFont = 0x70000; // 2bpp format
constexpr int kCharactersWidth = 0x74ADF;
constexpr int kNumMessages = 396;
constexpr int kFontGfxMessageSize = 128;
constexpr int kFontGfxMessageDepth = 8; // Fixed: Must be 8 for indexed palette mode
constexpr int kFontGfxMessageDepth =
8; // Fixed: Must be 8 for indexed palette mode
constexpr int kFontGfx16Size = 172 * 4096;
constexpr uint8_t kBlockTerminator = 0x80;
@@ -90,7 +91,7 @@ class MessageEditor : public Editor {
gui::TextBox message_text_box_;
Rom* rom_;
Rom expanded_message_bin_;
// Card visibility states
bool show_message_list_ = false;
bool show_message_editor_ = false;

81
src/app/editor/music/music_editor.cc
View File

@@ -2,9 +2,9 @@
#include "app/editor/system/editor_card_registry.h"
#include "absl/strings/str_format.h"
#include "app/gfx/debug/performance/performance_profiler.h"
#include "app/editor/code/assembly_editor.h"
#include "app/emu/emulator.h"
#include "app/gfx/debug/performance/performance_profiler.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/input.h"
#include "imgui/imgui.h"
@@ -14,19 +14,29 @@ namespace yaze {
namespace editor {
void MusicEditor::Initialize() {
if (!dependencies_.card_registry) return;
if (!dependencies_.card_registry)
return;
auto* card_registry = dependencies_.card_registry;
card_registry->RegisterCard({.card_id = "music.tracker", .display_name = "Music Tracker",
.icon = ICON_MD_MUSIC_NOTE, .category = "Music",
.shortcut_hint = "Ctrl+Shift+M", .priority = 10});
card_registry->RegisterCard({.card_id = "music.instrument_editor", .display_name = "Instrument Editor",
.icon = ICON_MD_PIANO, .category = "Music",
.shortcut_hint = "Ctrl+Shift+I", .priority = 20});
card_registry->RegisterCard({.card_id = "music.assembly", .display_name = "Assembly View",
.icon = ICON_MD_CODE, .category = "Music",
.shortcut_hint = "Ctrl+Shift+A", .priority = 30});
card_registry->RegisterCard({.card_id = "music.tracker",
.display_name = "Music Tracker",
.icon = ICON_MD_MUSIC_NOTE,
.category = "Music",
.shortcut_hint = "Ctrl+Shift+M",
.priority = 10});
card_registry->RegisterCard({.card_id = "music.instrument_editor",
.display_name = "Instrument Editor",
.icon = ICON_MD_PIANO,
.category = "Music",
.shortcut_hint = "Ctrl+Shift+I",
.priority = 20});
card_registry->RegisterCard({.card_id = "music.assembly",
.display_name = "Assembly View",
.icon = ICON_MD_CODE,
.category = "Music",
.shortcut_hint = "Ctrl+Shift+A",
.priority = 30});
// Show tracker by default
card_registry->ShowCard("music.tracker");
}
@@ -37,17 +47,18 @@ absl::Status MusicEditor::Load() {
}
absl::Status MusicEditor::Update() {
if (!dependencies_.card_registry) return absl::OkStatus();
if (!dependencies_.card_registry)
return absl::OkStatus();
auto* card_registry = dependencies_.card_registry;
static gui::EditorCard tracker_card("Music Tracker", ICON_MD_MUSIC_NOTE);
static gui::EditorCard instrument_card("Instrument Editor", ICON_MD_PIANO);
static gui::EditorCard assembly_card("Assembly View", ICON_MD_CODE);
tracker_card.SetDefaultSize(900, 700);
instrument_card.SetDefaultSize(600, 500);
assembly_card.SetDefaultSize(700, 600);
// Music Tracker Card - Check visibility flag exists and is true before rendering
bool* tracker_visible = card_registry->GetVisibilityFlag("music.tracker");
if (tracker_visible && *tracker_visible) {
@@ -56,16 +67,17 @@ absl::Status MusicEditor::Update() {
}
tracker_card.End();
}
// Instrument Editor Card - Check visibility flag exists and is true before rendering
bool* instrument_visible = card_registry->GetVisibilityFlag("music.instrument_editor");
bool* instrument_visible =
card_registry->GetVisibilityFlag("music.instrument_editor");
if (instrument_visible && *instrument_visible) {
if (instrument_card.Begin(instrument_visible)) {
DrawInstrumentEditor();
}
instrument_card.End();
}
// Assembly View Card - Check visibility flag exists and is true before rendering
bool* assembly_visible = card_registry->GetVisibilityFlag("music.assembly");
if (assembly_visible && *assembly_visible) {
@@ -108,7 +120,8 @@ static void DrawPianoStaff() {
// Draw the ledger lines
const int NUM_LEDGER_LINES = 3;
for (int i = -NUM_LEDGER_LINES; i <= NUM_LINES + NUM_LEDGER_LINES; i++) {
if (i % 2 == 0) continue; // skip every other line
if (i % 2 == 0)
continue; // skip every other line
auto line_start = ImVec2(canvas_p0.x, canvas_p0.y + i * LINE_SPACING / 2);
auto line_end = ImVec2(canvas_p1.x + ImGui::GetContentRegionAvail().x,
canvas_p0.y + i * LINE_SPACING / 2);
@@ -273,19 +286,19 @@ void MusicEditor::PlaySong(int song_id) {
LOG_WARN("MusicEditor", "No emulator instance - cannot play song");
return;
}
if (!emulator_->snes().running()) {
LOG_WARN("MusicEditor", "Emulator not running - cannot play song");
return;
}
// Write song request to game memory ($7E012C)
// This triggers the NMI handler to send the song to APU
try {
emulator_->snes().Write(0x7E012C, static_cast<uint8_t>(song_id));
LOG_INFO("MusicEditor", "Requested song %d (%s)", song_id,
LOG_INFO("MusicEditor", "Requested song %d (%s)", song_id,
song_id < 30 ? kGameSongs[song_id] : "Unknown");
// Ensure audio backend is playing
if (auto* audio = emulator_->audio_backend()) {
auto status = audio->GetStatus();
@@ -294,7 +307,7 @@ void MusicEditor::PlaySong(int song_id) {
LOG_INFO("MusicEditor", "Started audio backend playback");
}
}
is_playing_ = true;
} catch (const std::exception& e) {
LOG_ERROR("MusicEditor", "Failed to play song: %s", e.what());
@@ -302,18 +315,19 @@ void MusicEditor::PlaySong(int song_id) {
}
void MusicEditor::StopSong() {
if (!emulator_) return;
if (!emulator_)
return;
// Write stop command to game memory
try {
emulator_->snes().Write(0x7E012C, 0xFF); // 0xFF = stop music
LOG_INFO("MusicEditor", "Stopped music playback");
// Optional: pause audio backend to save CPU
if (auto* audio = emulator_->audio_backend()) {
audio->Pause();
}
is_playing_ = false;
} catch (const std::exception& e) {
LOG_ERROR("MusicEditor", "Failed to stop song: %s", e.what());
@@ -321,11 +335,12 @@ void MusicEditor::StopSong() {
}
void MusicEditor::SetVolume(float volume) {
if (!emulator_) return;
if (!emulator_)
return;
// Clamp volume to valid range
volume = std::clamp(volume, 0.0f, 1.0f);
if (auto* audio = emulator_->audio_backend()) {
audio->SetVolume(volume);
LOG_DEBUG("MusicEditor", "Set volume to %.2f", volume);

6
src/app/editor/music/music_editor.h
View File

@@ -6,8 +6,8 @@
#include "app/emu/audio/apu.h"
#include "app/gui/app/editor_layout.h"
#include "app/rom.h"
#include "zelda3/music/tracker.h"
#include "imgui/imgui.h"
#include "zelda3/music/tracker.h"
namespace yaze {
@@ -84,11 +84,11 @@ class MusicEditor : public Editor {
// Get the ROM pointer
Rom* rom() const { return rom_; }
// Emulator integration for live audio playback
void set_emulator(emu::Emulator* emulator) { emulator_ = emulator; }
emu::Emulator* emulator() const { return emulator_; }
// Audio control methods
void PlaySong(int song_id);
void StopSong();

51
src/app/editor/overworld/entity.cc
View File

@@ -21,22 +21,22 @@ using ImGui::Text;
constexpr float kInputFieldSize = 30.f;
bool IsMouseHoveringOverEntity(const zelda3::GameEntity &entity,
bool IsMouseHoveringOverEntity(const zelda3::GameEntity& entity,
ImVec2 canvas_p0, ImVec2 scrolling) {
// Get the mouse position relative to the canvas
const ImGuiIO &io = ImGui::GetIO();
const ImGuiIO& io = ImGui::GetIO();
const ImVec2 origin(canvas_p0.x + scrolling.x, canvas_p0.y + scrolling.y);
const ImVec2 mouse_pos(io.MousePos.x - origin.x, io.MousePos.y - origin.y);
// Check if the mouse is hovering over the entity
return mouse_pos.x >= entity.x_ && mouse_pos.x <= entity.x_ + 16 &&
mouse_pos.y >= entity.y_ && mouse_pos.y <= entity.y_ + 16;
mouse_pos.y >= entity.y_ && mouse_pos.y <= entity.y_ + 16;
}
void MoveEntityOnGrid(zelda3::GameEntity *entity, ImVec2 canvas_p0,
void MoveEntityOnGrid(zelda3::GameEntity* entity, ImVec2 canvas_p0,
ImVec2 scrolling, bool free_movement) {
// Get the mouse position relative to the canvas
const ImGuiIO &io = ImGui::GetIO();
const ImGuiIO& io = ImGui::GetIO();
const ImVec2 origin(canvas_p0.x + scrolling.x, canvas_p0.y + scrolling.y);
const ImVec2 mouse_pos(io.MousePos.x - origin.x, io.MousePos.y - origin.y);
@@ -53,8 +53,6 @@ void MoveEntityOnGrid(zelda3::GameEntity *entity, ImVec2 canvas_p0,
entity->set_y(new_y);
}
bool DrawEntranceInserterPopup() {
bool set_done = false;
if (set_done) {
@@ -79,28 +77,28 @@ bool DrawEntranceInserterPopup() {
return set_done;
}
bool DrawOverworldEntrancePopup(zelda3::OverworldEntrance &entrance) {
bool DrawOverworldEntrancePopup(zelda3::OverworldEntrance& entrance) {
static bool set_done = false;
if (set_done) {
set_done = false;
return true;
}
if (ImGui::BeginPopupModal("Entrance Editor", NULL,
ImGuiWindowFlags_AlwaysAutoResize)) {
ImGui::Text("Entrance ID: %d", entrance.entrance_id_);
ImGui::Separator();
gui::InputHexWord("Map ID", &entrance.map_id_);
gui::InputHexByte("Entrance ID", &entrance.entrance_id_,
kInputFieldSize + 20);
gui::InputHex("X Position", &entrance.x_);
gui::InputHex("Y Position", &entrance.y_);
ImGui::Checkbox("Is Hole", &entrance.is_hole_);
ImGui::Separator();
if (Button("Save")) {
set_done = true;
ImGui::CloseCurrentPopup();
@@ -115,7 +113,7 @@ bool DrawOverworldEntrancePopup(zelda3::OverworldEntrance &entrance) {
if (Button("Cancel")) {
ImGui::CloseCurrentPopup();
}
ImGui::EndPopup();
}
return set_done;
@@ -127,10 +125,10 @@ void DrawExitInserterPopup() {
static int room_id = 0;
static int x_pos = 0;
static int y_pos = 0;
ImGui::Text("Insert New Exit");
ImGui::Separator();
gui::InputHex("Exit ID", &exit_id);
gui::InputHex("Room ID", &room_id);
gui::InputHex("X Position", &x_pos);
@@ -150,7 +148,7 @@ void DrawExitInserterPopup() {
}
}
bool DrawExitEditorPopup(zelda3::OverworldExit &exit) {
bool DrawExitEditorPopup(zelda3::OverworldExit& exit) {
static bool set_done = false;
if (set_done) {
set_done = false;
@@ -208,7 +206,8 @@ bool DrawExitEditorPopup(zelda3::OverworldExit &exit) {
if (show_properties) {
Text("Deleted? %s", exit.deleted_ ? "true" : "false");
Text("Hole? %s", exit.is_hole_ ? "true" : "false");
Text("Auto-calc scroll/camera? %s", exit.is_automatic_ ? "true" : "false");
Text("Auto-calc scroll/camera? %s",
exit.is_automatic_ ? "true" : "false");
Text("Map ID: 0x%02X", exit.map_id_);
Text("Game coords: (%d, %d)", exit.game_x_, exit.game_y_);
}
@@ -317,7 +316,7 @@ void DrawItemInsertPopup() {
}
// TODO: Implement deleting OverworldItem objects, currently only hides them
bool DrawItemEditorPopup(zelda3::OverworldItem &item) {
bool DrawItemEditorPopup(zelda3::OverworldItem& item) {
static bool set_done = false;
if (set_done) {
set_done = false;
@@ -359,7 +358,7 @@ bool DrawItemEditorPopup(zelda3::OverworldItem &item) {
return set_done;
}
const ImGuiTableSortSpecs *SpriteItem::s_current_sort_specs = nullptr;
const ImGuiTableSortSpecs* SpriteItem::s_current_sort_specs = nullptr;
void DrawSpriteTable(std::function<void(int)> onSpriteSelect) {
static ImGuiTextFilter filter;
@@ -383,7 +382,7 @@ void DrawSpriteTable(std::function<void(int)> onSpriteSelect) {
ImGui::TableHeadersRow();
// Handle sorting
if (ImGuiTableSortSpecs *sort_specs = ImGui::TableGetSortSpecs()) {
if (ImGuiTableSortSpecs* sort_specs = ImGui::TableGetSortSpecs()) {
if (sort_specs->SpecsDirty) {
SpriteItem::SortWithSortSpecs(sort_specs, items);
sort_specs->SpecsDirty = false;
@@ -391,7 +390,7 @@ void DrawSpriteTable(std::function<void(int)> onSpriteSelect) {
}
// Display filtered and sorted items
for (const auto &item : items) {
for (const auto& item : items) {
if (filter.PassFilter(item.name)) {
ImGui::TableNextRow();
ImGui::TableSetColumnIndex(0);
@@ -414,15 +413,15 @@ void DrawSpriteInserterPopup() {
static int new_sprite_id = 0;
static int x_pos = 0;
static int y_pos = 0;
ImGui::Text("Add New Sprite");
ImGui::Separator();
BeginChild("ScrollRegion", ImVec2(250, 200), true,
ImGuiWindowFlags_AlwaysVerticalScrollbar);
DrawSpriteTable([](int selected_id) { new_sprite_id = selected_id; });
EndChild();
ImGui::Separator();
ImGui::Text("Position:");
gui::InputHex("X Position", &x_pos);
@@ -445,7 +444,7 @@ void DrawSpriteInserterPopup() {
}
}
bool DrawSpriteEditorPopup(zelda3::Sprite &sprite) {
bool DrawSpriteEditorPopup(zelda3::Sprite& sprite) {
static bool set_done = false;
if (set_done) {
set_done = false;

28
src/app/editor/overworld/entity.h
View File

@@ -1,33 +1,31 @@
#ifndef YAZE_APP_EDITOR_OVERWORLD_ENTITY_H
#define YAZE_APP_EDITOR_OVERWORLD_ENTITY_H
#include "imgui/imgui.h"
#include "zelda3/common.h"
#include "zelda3/overworld/overworld_entrance.h"
#include "zelda3/overworld/overworld_exit.h"
#include "zelda3/overworld/overworld_item.h"
#include "zelda3/sprite/sprite.h"
#include "imgui/imgui.h"
namespace yaze {
namespace editor {
bool IsMouseHoveringOverEntity(const zelda3::GameEntity &entity,
bool IsMouseHoveringOverEntity(const zelda3::GameEntity& entity,
ImVec2 canvas_p0, ImVec2 scrolling);
void MoveEntityOnGrid(zelda3::GameEntity *entity, ImVec2 canvas_p0,
void MoveEntityOnGrid(zelda3::GameEntity* entity, ImVec2 canvas_p0,
ImVec2 scrolling, bool free_movement = false);
bool DrawEntranceInserterPopup();
bool DrawOverworldEntrancePopup(zelda3::OverworldEntrance &entrance);
bool DrawOverworldEntrancePopup(zelda3::OverworldEntrance& entrance);
void DrawExitInserterPopup();
bool DrawExitEditorPopup(zelda3::OverworldExit &exit);
bool DrawExitEditorPopup(zelda3::OverworldExit& exit);
void DrawItemInsertPopup();
bool DrawItemEditorPopup(zelda3::OverworldItem &item);
bool DrawItemEditorPopup(zelda3::OverworldItem& item);
/**
* @brief Column IDs for the sprite table.
@@ -41,11 +39,11 @@ enum SpriteItemColumnID {
struct SpriteItem {
int id;
const char *name;
static const ImGuiTableSortSpecs *s_current_sort_specs;
const char* name;
static const ImGuiTableSortSpecs* s_current_sort_specs;
static void SortWithSortSpecs(ImGuiTableSortSpecs *sort_specs,
std::vector<SpriteItem> &items) {
static void SortWithSortSpecs(ImGuiTableSortSpecs* sort_specs,
std::vector<SpriteItem>& items) {
s_current_sort_specs =
sort_specs; // Store for access by the compare function.
if (items.size() > 1)
@@ -53,9 +51,9 @@ struct SpriteItem {
s_current_sort_specs = nullptr;
}
static bool CompareWithSortSpecs(const SpriteItem &a, const SpriteItem &b) {
static bool CompareWithSortSpecs(const SpriteItem& a, const SpriteItem& b) {
for (int n = 0; n < s_current_sort_specs->SpecsCount; n++) {
const ImGuiTableColumnSortSpecs *sort_spec =
const ImGuiTableColumnSortSpecs* sort_spec =
&s_current_sort_specs->Specs[n];
int delta = 0;
switch (sort_spec->ColumnUserID) {
@@ -77,7 +75,7 @@ struct SpriteItem {
void DrawSpriteTable(std::function<void(int)> onSpriteSelect);
void DrawSpriteInserterPopup();
bool DrawSpriteEditorPopup(zelda3::Sprite &sprite);
bool DrawSpriteEditorPopup(zelda3::Sprite& sprite);
} // namespace editor
} // namespace yaze

189
src/app/editor/overworld/entity_operations.cc
View File

@@ -7,20 +7,20 @@ namespace yaze {
namespace editor {
absl::StatusOr<zelda3::OverworldEntrance*> InsertEntrance(
zelda3::Overworld* overworld, ImVec2 mouse_pos, int current_map,
zelda3::Overworld* overworld, ImVec2 mouse_pos, int current_map,
bool is_hole) {
if (!overworld || !overworld->is_loaded()) {
return absl::FailedPreconditionError("Overworld not loaded");
}
// Snap to 16x16 grid and clamp to bounds (ZScream: EntranceMode.cs:86-87)
ImVec2 snapped_pos = ClampToOverworldBounds(SnapToEntityGrid(mouse_pos));
// Get parent map ID (ZScream: EntranceMode.cs:78-82)
auto* current_ow_map = overworld->overworld_map(current_map);
uint8_t map_id = GetParentMapId(current_ow_map, current_map);
if (is_hole) {
// Search for first deleted hole slot (ZScream: EntranceMode.cs:74-100)
auto& holes = overworld->holes();
@@ -33,38 +33,40 @@ absl::StatusOr<zelda3::OverworldEntrance*> InsertEntrance(
holes[i].y_ = static_cast<int>(snapped_pos.y);
holes[i].entrance_id_ = 0; // Default, user configures in popup
holes[i].is_hole_ = true;
// Update map properties (ZScream: EntranceMode.cs:90)
holes[i].UpdateMapProperties(map_id, overworld);
LOG_DEBUG("EntityOps", "Inserted hole at slot %zu: pos=(%d,%d) map=0x%02X",
i, holes[i].x_, holes[i].y_, map_id);
return &holes[i];
// Update map properties (ZScream: EntranceMode.cs:90)
holes[i].UpdateMapProperties(map_id, overworld);
LOG_DEBUG("EntityOps",
"Inserted hole at slot %zu: pos=(%d,%d) map=0x%02X", i,
holes[i].x_, holes[i].y_, map_id);
return &holes[i];
}
}
}
return absl::ResourceExhaustedError(
"No space available for new hole. Delete one first.");
} else {
// Search for first deleted entrance slot (ZScream: EntranceMode.cs:104-130)
auto* entrances = overworld->mutable_entrances();
for (size_t i = 0; i < entrances->size(); ++i) {
if (entrances->at(i).deleted) {
// Reuse deleted slot
entrances->at(i).deleted = false;
entrances->at(i).map_id_ = map_id;
entrances->at(i).x_ = static_cast<int>(snapped_pos.x);
entrances->at(i).y_ = static_cast<int>(snapped_pos.y);
entrances->at(i).entrance_id_ = 0; // Default, user configures in popup
entrances->at(i).is_hole_ = false;
// Update map properties (ZScream: EntranceMode.cs:120)
entrances->at(i).UpdateMapProperties(map_id, overworld);
LOG_DEBUG("EntityOps", "Inserted entrance at slot %zu: pos=(%d,%d) map=0x%02X",
i, entrances->at(i).x_, entrances->at(i).y_, map_id);
return absl::ResourceExhaustedError(
"No space available for new hole. Delete one first.");
} else {
// Search for first deleted entrance slot (ZScream: EntranceMode.cs:104-130)
auto* entrances = overworld->mutable_entrances();
for (size_t i = 0; i < entrances->size(); ++i) {
if (entrances->at(i).deleted) {
// Reuse deleted slot
entrances->at(i).deleted = false;
entrances->at(i).map_id_ = map_id;
entrances->at(i).x_ = static_cast<int>(snapped_pos.x);
entrances->at(i).y_ = static_cast<int>(snapped_pos.y);
entrances->at(i).entrance_id_ = 0; // Default, user configures in popup
entrances->at(i).is_hole_ = false;
// Update map properties (ZScream: EntranceMode.cs:120)
entrances->at(i).UpdateMapProperties(map_id, overworld);
LOG_DEBUG("EntityOps",
"Inserted entrance at slot %zu: pos=(%d,%d) map=0x%02X", i,
entrances->at(i).x_, entrances->at(i).y_, map_id);
return &entrances->at(i);
}
}
@@ -73,20 +75,21 @@ absl::StatusOr<zelda3::OverworldEntrance*> InsertEntrance(
}
}
absl::StatusOr<zelda3::OverworldExit*> InsertExit(
zelda3::Overworld* overworld, ImVec2 mouse_pos, int current_map) {
absl::StatusOr<zelda3::OverworldExit*> InsertExit(zelda3::Overworld* overworld,
ImVec2 mouse_pos,
int current_map) {
if (!overworld || !overworld->is_loaded()) {
return absl::FailedPreconditionError("Overworld not loaded");
}
// Snap to 16x16 grid and clamp to bounds (ZScream: ExitMode.cs:71-72)
ImVec2 snapped_pos = ClampToOverworldBounds(SnapToEntityGrid(mouse_pos));
// Get parent map ID (ZScream: ExitMode.cs:63-67)
auto* current_ow_map = overworld->overworld_map(current_map);
uint8_t map_id = GetParentMapId(current_ow_map, current_map);
// Search for first deleted exit slot (ZScream: ExitMode.cs:59-124)
auto& exits = *overworld->mutable_exits();
for (size_t i = 0; i < exits.size(); ++i) {
@@ -96,7 +99,7 @@ absl::StatusOr<zelda3::OverworldExit*> InsertExit(
exits[i].map_id_ = map_id;
exits[i].x_ = static_cast<int>(snapped_pos.x);
exits[i].y_ = static_cast<int>(snapped_pos.y);
// Initialize with default values (ZScream: ExitMode.cs:95-112)
// User will configure room_id, scroll, camera in popup
exits[i].room_id_ = 0;
@@ -110,126 +113,130 @@ absl::StatusOr<zelda3::OverworldExit*> InsertExit(
exits[i].scroll_mod_y_ = 0;
exits[i].door_type_1_ = 0;
exits[i].door_type_2_ = 0;
// Update map properties with overworld context for area size detection
exits[i].UpdateMapProperties(map_id, overworld);
LOG_DEBUG("EntityOps", "Inserted exit at slot %zu: pos=(%d,%d) map=0x%02X",
i, exits[i].x_, exits[i].y_, map_id);
LOG_DEBUG("EntityOps",
"Inserted exit at slot %zu: pos=(%d,%d) map=0x%02X", i,
exits[i].x_, exits[i].y_, map_id);
return &exits[i];
}
}
return absl::ResourceExhaustedError(
"No space available for new exit. Delete one first.");
}
absl::StatusOr<zelda3::Sprite*> InsertSprite(
zelda3::Overworld* overworld, ImVec2 mouse_pos, int current_map,
int game_state, uint8_t sprite_id) {
absl::StatusOr<zelda3::Sprite*> InsertSprite(zelda3::Overworld* overworld,
ImVec2 mouse_pos, int current_map,
int game_state,
uint8_t sprite_id) {
if (!overworld || !overworld->is_loaded()) {
return absl::FailedPreconditionError("Overworld not loaded");
}
if (game_state < 0 || game_state > 2) {
return absl::InvalidArgumentError("Invalid game state (must be 0-2)");
}
// Snap to 16x16 grid and clamp to bounds (ZScream: SpriteMode.cs similar logic)
ImVec2 snapped_pos = ClampToOverworldBounds(SnapToEntityGrid(mouse_pos));
// Get parent map ID (ZScream: SpriteMode.cs:90-95)
auto* current_ow_map = overworld->overworld_map(current_map);
uint8_t map_id = GetParentMapId(current_ow_map, current_map);
// Calculate map position (ZScream uses mapHover for parent tracking)
// For sprites, we need the actual map coordinates within the 512x512 map
int map_local_x = static_cast<int>(snapped_pos.x) % 512;
int map_local_y = static_cast<int>(snapped_pos.y) % 512;
// Convert to game coordinates (0-63 for X/Y within map)
uint8_t game_x = static_cast<uint8_t>(map_local_x / 16);
uint8_t game_y = static_cast<uint8_t>(map_local_y / 16);
// Add new sprite to the game state array (ZScream: SpriteMode.cs:34-35)
auto& sprites = *overworld->mutable_sprites(game_state);
// Create new sprite
zelda3::Sprite new_sprite(
current_ow_map->current_graphics(),
static_cast<uint8_t>(map_id),
current_ow_map->current_graphics(), static_cast<uint8_t>(map_id),
sprite_id, // Sprite ID (user will configure in popup)
game_x, // X position in map coordinates
game_y, // Y position in map coordinates
static_cast<int>(snapped_pos.x), // Real X (world coordinates)
static_cast<int>(snapped_pos.y) // Real Y (world coordinates)
);
sprites.push_back(new_sprite);
// Return pointer to the newly added sprite
zelda3::Sprite* inserted_sprite = &sprites.back();
LOG_DEBUG("EntityOps", "Inserted sprite at game_state=%d: pos=(%d,%d) map=0x%02X id=0x%02X",
game_state, inserted_sprite->x_, inserted_sprite->y_, map_id, sprite_id);
LOG_DEBUG(
"EntityOps",
"Inserted sprite at game_state=%d: pos=(%d,%d) map=0x%02X id=0x%02X",
game_state, inserted_sprite->x_, inserted_sprite->y_, map_id, sprite_id);
return inserted_sprite;
}
absl::StatusOr<zelda3::OverworldItem*> InsertItem(
zelda3::Overworld* overworld, ImVec2 mouse_pos, int current_map,
uint8_t item_id) {
absl::StatusOr<zelda3::OverworldItem*> InsertItem(zelda3::Overworld* overworld,
ImVec2 mouse_pos,
int current_map,
uint8_t item_id) {
if (!overworld || !overworld->is_loaded()) {
return absl::FailedPreconditionError("Overworld not loaded");
}
// Snap to 16x16 grid and clamp to bounds (ZScream: ItemMode.cs similar logic)
ImVec2 snapped_pos = ClampToOverworldBounds(SnapToEntityGrid(mouse_pos));
// Get parent map ID (ZScream: ItemMode.cs:60-64)
auto* current_ow_map = overworld->overworld_map(current_map);
uint8_t map_id = GetParentMapId(current_ow_map, current_map);
// Calculate game coordinates (0-63 for X/Y within map)
// Following LoadItems logic in overworld.cc:840-854
int fake_id = current_map % 0x40;
int sy = fake_id / 8;
int sx = fake_id - (sy * 8);
// Calculate map-local coordinates
int map_local_x = static_cast<int>(snapped_pos.x) % 512;
int map_local_y = static_cast<int>(snapped_pos.y) % 512;
// Game coordinates (0-63 range)
uint8_t game_x = static_cast<uint8_t>(map_local_x / 16);
uint8_t game_y = static_cast<uint8_t>(map_local_y / 16);
// Add new item to the all_items array (ZScream: ItemMode.cs:92-108)
auto& items = *overworld->mutable_all_items();
// Create new item with calculated coordinates
items.emplace_back(
item_id, // Item ID
static_cast<uint16_t>(map_id), // Room map ID
static_cast<int>(snapped_pos.x), // X (world coordinates)
static_cast<int>(snapped_pos.y), // Y (world coordinates)
false // Not deleted
items.emplace_back(item_id, // Item ID
static_cast<uint16_t>(map_id), // Room map ID
static_cast<int>(snapped_pos.x), // X (world coordinates)
static_cast<int>(snapped_pos.y), // Y (world coordinates)
false // Not deleted
);
// Set game coordinates
zelda3::OverworldItem* inserted_item = &items.back();
inserted_item->game_x_ = game_x;
inserted_item->game_y_ = game_y;
LOG_DEBUG("EntityOps", "Inserted item: pos=(%d,%d) game=(%d,%d) map=0x%02X id=0x%02X",
inserted_item->x_, inserted_item->y_, game_x, game_y, map_id, item_id);
LOG_DEBUG("EntityOps",
"Inserted item: pos=(%d,%d) game=(%d,%d) map=0x%02X id=0x%02X",
inserted_item->x_, inserted_item->y_, game_x, game_y, map_id,
item_id);
return inserted_item;
}
} // namespace editor
} // namespace yaze

39
src/app/editor/overworld/entity_operations.h
View File

@@ -2,12 +2,12 @@
#define YAZE_APP_EDITOR_OVERWORLD_ENTITY_OPERATIONS_H
#include "absl/status/statusor.h"
#include "imgui/imgui.h"
#include "zelda3/overworld/overworld.h"
#include "zelda3/overworld/overworld_entrance.h"
#include "zelda3/overworld/overworld_exit.h"
#include "zelda3/overworld/overworld_item.h"
#include "zelda3/sprite/sprite.h"
#include "imgui/imgui.h"
namespace yaze {
namespace editor {
@@ -41,7 +41,7 @@ namespace editor {
* @return Pointer to newly inserted entrance, or error if no slots available
*/
absl::StatusOr<zelda3::OverworldEntrance*> InsertEntrance(
zelda3::Overworld* overworld, ImVec2 mouse_pos, int current_map,
zelda3::Overworld* overworld, ImVec2 mouse_pos, int current_map,
bool is_hole = false);
/**
@@ -58,8 +58,9 @@ absl::StatusOr<zelda3::OverworldEntrance*> InsertEntrance(
* @param current_map Current map index being edited
* @return Pointer to newly inserted exit, or error if no slots available
*/
absl::StatusOr<zelda3::OverworldExit*> InsertExit(
zelda3::Overworld* overworld, ImVec2 mouse_pos, int current_map);
absl::StatusOr<zelda3::OverworldExit*> InsertExit(zelda3::Overworld* overworld,
ImVec2 mouse_pos,
int current_map);
/**
* @brief Insert a new sprite at the specified position
@@ -76,9 +77,10 @@ absl::StatusOr<zelda3::OverworldExit*> InsertExit(
* @param sprite_id Sprite ID to insert (default 0)
* @return Pointer to newly inserted sprite
*/
absl::StatusOr<zelda3::Sprite*> InsertSprite(
zelda3::Overworld* overworld, ImVec2 mouse_pos, int current_map,
int game_state, uint8_t sprite_id = 0);
absl::StatusOr<zelda3::Sprite*> InsertSprite(zelda3::Overworld* overworld,
ImVec2 mouse_pos, int current_map,
int game_state,
uint8_t sprite_id = 0);
/**
* @brief Insert a new item at the specified position
@@ -94,9 +96,10 @@ absl::StatusOr<zelda3::Sprite*> InsertSprite(
* @param item_id Item ID to insert (default 0x00 - Nothing)
* @return Pointer to newly inserted item
*/
absl::StatusOr<zelda3::OverworldItem*> InsertItem(
zelda3::Overworld* overworld, ImVec2 mouse_pos, int current_map,
uint8_t item_id = 0);
absl::StatusOr<zelda3::OverworldItem*> InsertItem(zelda3::Overworld* overworld,
ImVec2 mouse_pos,
int current_map,
uint8_t item_id = 0);
/**
* @brief Helper to get parent map ID for multi-area maps
@@ -104,7 +107,8 @@ absl::StatusOr<zelda3::OverworldItem*> InsertItem(
* Returns the parent map ID, handling the case where a map is its own parent.
* Matches ZScream logic where ParentID == 255 means use current map.
*/
inline uint8_t GetParentMapId(const zelda3::OverworldMap* map, int current_map) {
inline uint8_t GetParentMapId(const zelda3::OverworldMap* map,
int current_map) {
uint8_t parent = map->parent();
return (parent == 0xFF) ? static_cast<uint8_t>(current_map) : parent;
}
@@ -113,24 +117,19 @@ inline uint8_t GetParentMapId(const zelda3::OverworldMap* map, int current_map)
* @brief Snap position to 16x16 grid (standard entity positioning)
*/
inline ImVec2 SnapToEntityGrid(ImVec2 pos) {
return ImVec2(
static_cast<float>(static_cast<int>(pos.x / 16) * 16),
static_cast<float>(static_cast<int>(pos.y / 16) * 16)
);
return ImVec2(static_cast<float>(static_cast<int>(pos.x / 16) * 16),
static_cast<float>(static_cast<int>(pos.y / 16) * 16));
}
/**
* @brief Clamp position to valid overworld bounds
*/
inline ImVec2 ClampToOverworldBounds(ImVec2 pos) {
return ImVec2(
std::clamp(pos.x, 0.0f, 4080.0f), // 4096 - 16
std::clamp(pos.y, 0.0f, 4080.0f)
);
return ImVec2(std::clamp(pos.x, 0.0f, 4080.0f), // 4096 - 16
std::clamp(pos.y, 0.0f, 4080.0f));
}
} // namespace editor
} // namespace yaze
#endif // YAZE_APP_EDITOR_OVERWORLD_ENTITY_OPERATIONS_H

317
src/app/editor/overworld/map_properties.cc
View File

@@ -1,16 +1,16 @@
#include "app/editor/overworld/map_properties.h"
#include "app/gfx/debug/performance/performance_profiler.h"
#include "app/editor/overworld/overworld_editor.h"
#include "app/editor/overworld/ui_constants.h"
#include "app/gfx/debug/performance/performance_profiler.h"
#include "app/gui/canvas/canvas.h"
#include "app/gui/core/color.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/input.h"
#include "app/gui/core/layout_helpers.h"
#include "imgui/imgui.h"
#include "zelda3/overworld/overworld_map.h"
#include "zelda3/overworld/overworld_version_helper.h"
#include "imgui/imgui.h"
namespace yaze {
namespace editor {
@@ -29,7 +29,7 @@ void MapPropertiesSystem::DrawSimplifiedMapSettings(
bool& show_overlay_editor, bool& show_overlay_preview, int& game_state,
int& current_mode) {
(void)show_overlay_editor; // Reserved for future use
(void)current_mode; // Reserved for future use
(void)current_mode; // Reserved for future use
// Enhanced settings table with popup buttons for quick access and integrated toolset
if (BeginTable("SimplifiedMapSettings", 9,
ImGuiTableFlags_Borders | ImGuiTableFlags_SizingFixedFit,
@@ -63,18 +63,17 @@ void MapPropertiesSystem::DrawSimplifiedMapSettings(
TableNextColumn();
// Use centralized version detection
auto rom_version = zelda3::OverworldVersionHelper::GetVersion(*rom_);
// ALL ROMs support Small/Large. Only v3+ supports Wide/Tall.
int current_area_size =
static_cast<int>(overworld_->overworld_map(current_map)->area_size());
ImGui::SetNextItemWidth(kComboAreaSizeWidth);
if (zelda3::OverworldVersionHelper::SupportsAreaEnum(rom_version)) {
// v3+ ROM: Show all 4 area size options
if (ImGui::Combo("##AreaSize", &current_area_size, kAreaSizeNames, 4)) {
auto status = overworld_->ConfigureMultiAreaMap(
current_map,
static_cast<zelda3::AreaSizeEnum>(current_area_size));
current_map, static_cast<zelda3::AreaSizeEnum>(current_area_size));
if (status.ok()) {
RefreshSiblingMapGraphics(current_map, true);
RefreshOverworldMap();
@@ -83,11 +82,13 @@ void MapPropertiesSystem::DrawSimplifiedMapSettings(
} else {
// Vanilla/v1/v2 ROM: Show only Small/Large (first 2 options)
const char* limited_names[] = {"Small (1x1)", "Large (2x2)"};
int limited_size = (current_area_size == 0 || current_area_size == 1) ? current_area_size : 0;
int limited_size = (current_area_size == 0 || current_area_size == 1)
? current_area_size
: 0;
if (ImGui::Combo("##AreaSize", &limited_size, limited_names, 2)) {
// limited_size is 0 (Small) or 1 (Large)
auto size = (limited_size == 1) ? zelda3::AreaSizeEnum::LargeArea
auto size = (limited_size == 1) ? zelda3::AreaSizeEnum::LargeArea
: zelda3::AreaSizeEnum::SmallArea;
auto status = overworld_->ConfigureMultiAreaMap(current_map, size);
if (status.ok()) {
@@ -95,8 +96,8 @@ void MapPropertiesSystem::DrawSimplifiedMapSettings(
RefreshOverworldMap();
}
}
if (rom_version == zelda3::OverworldVersion::kVanilla ||
if (rom_version == zelda3::OverworldVersion::kVanilla ||
!zelda3::OverworldVersionHelper::SupportsAreaEnum(rom_version)) {
HOVER_HINT("Small (1x1) and Large (2x2) maps. Wide/Tall require v3+");
}
@@ -125,7 +126,8 @@ void MapPropertiesSystem::DrawSimplifiedMapSettings(
DrawGraphicsPopup(current_map, game_state);
TableNextColumn();
if (ImGui::Button(ICON_MD_PALETTE " Palettes", ImVec2(kTableButtonPalettes, 0))) {
if (ImGui::Button(ICON_MD_PALETTE " Palettes",
ImVec2(kTableButtonPalettes, 0))) {
ImGui::OpenPopup("PalettesPopup");
}
if (ImGui::IsItemHovered()) {
@@ -140,7 +142,8 @@ void MapPropertiesSystem::DrawSimplifiedMapSettings(
DrawPalettesPopup(current_map, game_state, show_custom_bg_color_editor);
TableNextColumn();
if (ImGui::Button(ICON_MD_TUNE " Config", ImVec2(kTableButtonProperties, 0))) {
if (ImGui::Button(ICON_MD_TUNE " Config",
ImVec2(kTableButtonProperties, 0))) {
ImGui::OpenPopup("ConfigPopup");
}
if (ImGui::IsItemHovered()) {
@@ -161,7 +164,8 @@ void MapPropertiesSystem::DrawSimplifiedMapSettings(
TableNextColumn();
// View Controls
if (ImGui::Button(ICON_MD_VISIBILITY " View", ImVec2(kTableButtonView, 0))) {
if (ImGui::Button(ICON_MD_VISIBILITY " View",
ImVec2(kTableButtonView, 0))) {
ImGui::OpenPopup("ViewPopup");
}
if (ImGui::IsItemHovered()) {
@@ -226,7 +230,7 @@ void MapPropertiesSystem::DrawMapPropertiesPanel(
// Custom Overworld Features Tab
auto rom_version = zelda3::OverworldVersionHelper::GetVersion(*rom_);
if (rom_version != zelda3::OverworldVersion::kVanilla &&
if (rom_version != zelda3::OverworldVersion::kVanilla &&
ImGui::BeginTabItem("Custom Features")) {
DrawCustomFeaturesTab(current_map);
ImGui::EndTabItem();
@@ -311,15 +315,15 @@ void MapPropertiesSystem::DrawOverlayEditor(int current_map,
}
auto rom_version = zelda3::OverworldVersionHelper::GetVersion(*rom_);
ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f),
ICON_MD_LAYERS " Visual Effects Configuration");
ImGui::Text("Map: 0x%02X", current_map);
Separator();
if (rom_version == zelda3::OverworldVersion::kVanilla) {
ImGui::TextColored(ImVec4(1.0f, 0.6f, 0.4f, 1.0f),
ICON_MD_WARNING " Subscreen overlays require ZSCustomOverworld v1+");
ImGui::TextColored(ImVec4(1.0f, 0.6f, 0.4f, 1.0f), ICON_MD_WARNING
" Subscreen overlays require ZSCustomOverworld v1+");
ImGui::Separator();
ImGui::TextWrapped(
"To use visual effect overlays, you need to upgrade your ROM to "
@@ -334,7 +338,8 @@ void MapPropertiesSystem::DrawOverlayEditor(int current_map,
ImGui::Indent();
ImGui::TextWrapped(
"Visual effects (subscreen overlays) are semi-transparent layers drawn "
"on top of or behind your map. They reference special area maps (0x80-0x9F) "
"on top of or behind your map. They reference special area maps "
"(0x80-0x9F) "
"for their tile16 graphics data.");
ImGui::Spacing();
ImGui::Text("Common uses:");
@@ -349,7 +354,7 @@ void MapPropertiesSystem::DrawOverlayEditor(int current_map,
// Enable/disable subscreen overlay
static bool use_subscreen_overlay = false;
if (ImGui::Checkbox(ICON_MD_VISIBILITY " Enable Visual Effect for This Area",
if (ImGui::Checkbox(ICON_MD_VISIBILITY " Enable Visual Effect for This Area",
&use_subscreen_overlay)) {
// Update ROM data
(*rom_)[zelda3::OverworldCustomSubscreenOverlayEnabled] =
@@ -363,8 +368,8 @@ void MapPropertiesSystem::DrawOverlayEditor(int current_map,
ImGui::Spacing();
uint16_t current_overlay =
overworld_->overworld_map(current_map)->subscreen_overlay();
if (gui::InputHexWord(ICON_MD_PHOTO " Visual Effect Map ID", &current_overlay,
kInputFieldSize + 30)) {
if (gui::InputHexWord(ICON_MD_PHOTO " Visual Effect Map ID",
&current_overlay, kInputFieldSize + 30)) {
overworld_->mutable_overworld_map(current_map)
->set_subscreen_overlay(current_overlay);
@@ -383,11 +388,12 @@ void MapPropertiesSystem::DrawOverlayEditor(int current_map,
// Show description
std::string overlay_desc = GetOverlayDescription(current_overlay);
ImGui::TextColored(ImVec4(0.4f, 1.0f, 0.4f, 1.0f),
ICON_MD_INFO " %s", overlay_desc.c_str());
ImGui::TextColored(ImVec4(0.4f, 1.0f, 0.4f, 1.0f), ICON_MD_INFO " %s",
overlay_desc.c_str());
ImGui::Separator();
if (ImGui::CollapsingHeader(ICON_MD_LIGHTBULB " Common Visual Effect IDs")) {
if (ImGui::CollapsingHeader(ICON_MD_LIGHTBULB
" Common Visual Effect IDs")) {
ImGui::Indent();
ImGui::BulletText("0x0093 - Triforce Room Curtain");
ImGui::BulletText("0x0094 - Under the Bridge");
@@ -403,8 +409,8 @@ void MapPropertiesSystem::DrawOverlayEditor(int current_map,
}
} else {
ImGui::Spacing();
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f),
ICON_MD_BLOCK " No visual effects enabled for this area");
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), ICON_MD_BLOCK
" No visual effects enabled for this area");
}
}
@@ -415,12 +421,12 @@ void MapPropertiesSystem::SetupCanvasContextMenu(
(void)current_map; // Used for future context-sensitive menu items
// Clear any existing context menu items
canvas.ClearContextMenuItems();
// Add entity insertion submenu (only in MOUSE mode)
if (current_mode == 0 && entity_insert_callback_) { // 0 = EditingMode::MOUSE
gui::CanvasMenuItem entity_menu;
entity_menu.label = ICON_MD_ADD_LOCATION " Insert Entity";
// Entrance submenu item
gui::CanvasMenuItem entrance_item;
entrance_item.label = ICON_MD_DOOR_FRONT " Entrance";
@@ -430,7 +436,7 @@ void MapPropertiesSystem::SetupCanvasContextMenu(
}
};
entity_menu.subitems.push_back(entrance_item);
// Hole submenu item
gui::CanvasMenuItem hole_item;
hole_item.label = ICON_MD_CYCLONE " Hole";
@@ -440,7 +446,7 @@ void MapPropertiesSystem::SetupCanvasContextMenu(
}
};
entity_menu.subitems.push_back(hole_item);
// Exit submenu item
gui::CanvasMenuItem exit_item;
exit_item.label = ICON_MD_DOOR_BACK " Exit";
@@ -450,7 +456,7 @@ void MapPropertiesSystem::SetupCanvasContextMenu(
}
};
entity_menu.subitems.push_back(exit_item);
// Item submenu item
gui::CanvasMenuItem item_item;
item_item.label = ICON_MD_GRASS " Item";
@@ -460,7 +466,7 @@ void MapPropertiesSystem::SetupCanvasContextMenu(
}
};
entity_menu.subitems.push_back(item_item);
// Sprite submenu item
gui::CanvasMenuItem sprite_item;
sprite_item.label = ICON_MD_PEST_CONTROL_RODENT " Sprite";
@@ -470,7 +476,7 @@ void MapPropertiesSystem::SetupCanvasContextMenu(
}
};
entity_menu.subitems.push_back(sprite_item);
canvas.AddContextMenuItem(entity_menu);
}
@@ -540,7 +546,7 @@ void MapPropertiesSystem::SetupCanvasContextMenu(
void MapPropertiesSystem::DrawGraphicsPopup(int current_map, int game_state) {
if (ImGui::BeginPopup("GraphicsPopup")) {
ImGui::PushID("GraphicsPopup"); // Fix ImGui duplicate ID warnings
// Use theme-aware spacing instead of hardcoded constants
float spacing = gui::LayoutHelpers::GetStandardSpacing();
float padding = gui::LayoutHelpers::GetButtonPadding();
@@ -552,36 +558,36 @@ void MapPropertiesSystem::DrawGraphicsPopup(int current_map, int game_state) {
// Area Graphics
if (gui::InputHexByte(ICON_MD_IMAGE " Area Graphics",
overworld_->mutable_overworld_map(current_map)
->mutable_area_graphics(),
kHexByteInputWidth)) {
overworld_->mutable_overworld_map(current_map)
->mutable_area_graphics(),
kHexByteInputWidth)) {
// CORRECT ORDER: Properties first, then graphics reload
// 1. Propagate properties to siblings FIRST (calls LoadAreaGraphics on siblings)
RefreshMapProperties();
// 2. Force immediate refresh of current map
(*maps_bmp_)[current_map].set_modified(true);
overworld_->mutable_overworld_map(current_map)->LoadAreaGraphics();
// 3. Refresh siblings immediately
RefreshSiblingMapGraphics(current_map);
// 4. Update tile selector
// 4. Update tile selector
RefreshTile16Blockset();
// 5. Final refresh
RefreshOverworldMap();
}
HOVER_HINT("Main tileset graphics for this map area");
// Sprite Graphics
if (gui::InputHexByte(
absl::StrFormat(ICON_MD_PETS " Sprite GFX (%s)", kGameStateNames[game_state])
.c_str(),
overworld_->mutable_overworld_map(current_map)
->mutable_sprite_graphics(game_state),
kHexByteInputWidth)) {
if (gui::InputHexByte(absl::StrFormat(ICON_MD_PETS " Sprite GFX (%s)",
kGameStateNames[game_state])
.c_str(),
overworld_->mutable_overworld_map(current_map)
->mutable_sprite_graphics(game_state),
kHexByteInputWidth)) {
ForceRefreshGraphics(current_map);
RefreshMapProperties();
RefreshOverworldMap();
@@ -591,9 +597,9 @@ void MapPropertiesSystem::DrawGraphicsPopup(int current_map, int game_state) {
auto rom_version_gfx = zelda3::OverworldVersionHelper::GetVersion(*rom_);
if (zelda3::OverworldVersionHelper::SupportsAnimatedGFX(rom_version_gfx)) {
if (gui::InputHexByte(ICON_MD_ANIMATION " Animated GFX",
overworld_->mutable_overworld_map(current_map)
->mutable_animated_gfx(),
kHexByteInputWidth)) {
overworld_->mutable_overworld_map(current_map)
->mutable_animated_gfx(),
kHexByteInputWidth)) {
ForceRefreshGraphics(current_map);
RefreshMapProperties();
RefreshTile16Blockset();
@@ -603,21 +609,21 @@ void MapPropertiesSystem::DrawGraphicsPopup(int current_map, int game_state) {
}
// Custom Tile Graphics - Only available for v1+ ROMs
if (zelda3::OverworldVersionHelper::SupportsExpandedSpace(rom_version_gfx)) {
if (zelda3::OverworldVersionHelper::SupportsExpandedSpace(
rom_version_gfx)) {
ImGui::Separator();
ImGui::Text(ICON_MD_GRID_VIEW " Custom Tile Graphics");
ImGui::Separator();
// Show the 8 custom graphics IDs in a 2-column layout for density
if (BeginTable("CustomTileGraphics", 2,
ImGuiTableFlags_SizingFixedFit)) {
if (BeginTable("CustomTileGraphics", 2, ImGuiTableFlags_SizingFixedFit)) {
for (int i = 0; i < 8; i++) {
TableNextColumn();
std::string label = absl::StrFormat(ICON_MD_LAYERS " Sheet %d", i);
if (gui::InputHexByte(label.c_str(),
overworld_->mutable_overworld_map(current_map)
->mutable_custom_tileset(i),
90.f)) {
overworld_->mutable_overworld_map(current_map)
->mutable_custom_tileset(i),
90.f)) {
ForceRefreshGraphics(current_map);
RefreshMapProperties();
RefreshTile16Blockset();
@@ -631,7 +637,7 @@ void MapPropertiesSystem::DrawGraphicsPopup(int current_map, int game_state) {
}
} else if (rom_version_gfx == zelda3::OverworldVersion::kVanilla) {
ImGui::Separator();
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f),
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f),
ICON_MD_INFO " Custom Tile Graphics");
ImGui::TextWrapped(
"Custom tile graphics require ZSCustomOverworld v1+.\n"
@@ -639,7 +645,7 @@ void MapPropertiesSystem::DrawGraphicsPopup(int current_map, int game_state) {
}
ImGui::PopStyleVar(2); // Pop the 2 style variables we pushed
ImGui::PopID(); // Pop GraphicsPopup ID scope
ImGui::PopID(); // Pop GraphicsPopup ID scope
ImGui::EndPopup();
}
}
@@ -648,7 +654,7 @@ void MapPropertiesSystem::DrawPalettesPopup(int current_map, int game_state,
bool& show_custom_bg_color_editor) {
if (ImGui::BeginPopup("PalettesPopup")) {
ImGui::PushID("PalettesPopup"); // Fix ImGui duplicate ID warnings
// Use theme-aware spacing instead of hardcoded constants
float spacing = gui::LayoutHelpers::GetStandardSpacing();
float padding = gui::LayoutHelpers::GetButtonPadding();
@@ -660,9 +666,9 @@ void MapPropertiesSystem::DrawPalettesPopup(int current_map, int game_state,
// Area Palette
if (gui::InputHexByte(ICON_MD_PALETTE " Area Palette",
overworld_->mutable_overworld_map(current_map)
->mutable_area_palette(),
kHexByteInputWidth)) {
overworld_->mutable_overworld_map(current_map)
->mutable_area_palette(),
kHexByteInputWidth)) {
RefreshMapProperties();
auto status = RefreshMapPalette();
RefreshOverworldMap();
@@ -671,11 +677,12 @@ void MapPropertiesSystem::DrawPalettesPopup(int current_map, int game_state,
// Read fresh to reflect ROM upgrades
auto rom_version_pal = zelda3::OverworldVersionHelper::GetVersion(*rom_);
if (zelda3::OverworldVersionHelper::SupportsCustomBGColors(rom_version_pal)) {
if (zelda3::OverworldVersionHelper::SupportsCustomBGColors(
rom_version_pal)) {
if (gui::InputHexByte(ICON_MD_COLOR_LENS " Main Palette",
overworld_->mutable_overworld_map(current_map)
->mutable_main_palette(),
kHexByteInputWidth)) {
overworld_->mutable_overworld_map(current_map)
->mutable_main_palette(),
kHexByteInputWidth)) {
RefreshMapProperties();
auto status = RefreshMapPalette();
RefreshOverworldMap();
@@ -684,26 +691,26 @@ void MapPropertiesSystem::DrawPalettesPopup(int current_map, int game_state,
}
// Sprite Palette
if (gui::InputHexByte(
absl::StrFormat(ICON_MD_COLORIZE " Sprite Pal (%s)", kGameStateNames[game_state])
.c_str(),
overworld_->mutable_overworld_map(current_map)
->mutable_sprite_palette(game_state),
kHexByteInputWidth)) {
if (gui::InputHexByte(absl::StrFormat(ICON_MD_COLORIZE " Sprite Pal (%s)",
kGameStateNames[game_state])
.c_str(),
overworld_->mutable_overworld_map(current_map)
->mutable_sprite_palette(game_state),
kHexByteInputWidth)) {
RefreshMapProperties();
RefreshOverworldMap();
}
HOVER_HINT("Color palette for sprites in current game state");
ImGui::Separator();
if (ImGui::Button(ICON_MD_FORMAT_COLOR_FILL " Custom Background Color",
ImVec2(-1, 0))) {
if (ImGui::Button(ICON_MD_FORMAT_COLOR_FILL " Custom Background Color",
ImVec2(-1, 0))) {
show_custom_bg_color_editor = !show_custom_bg_color_editor;
}
HOVER_HINT("Open custom background color editor (v2+)");
ImGui::PopStyleVar(2); // Pop the 2 style variables we pushed
ImGui::PopID(); // Pop PalettesPopup ID scope
ImGui::PopID(); // Pop PalettesPopup ID scope
ImGui::EndPopup();
}
}
@@ -714,7 +721,7 @@ void MapPropertiesSystem::DrawPropertiesPopup(int current_map,
int& game_state) {
if (ImGui::BeginPopup("ConfigPopup")) {
ImGui::PushID("ConfigPopup"); // Fix ImGui duplicate ID warnings
// Use theme-aware spacing instead of hardcoded constants
float spacing = gui::LayoutHelpers::GetStandardSpacing();
float padding = gui::LayoutHelpers::GetButtonPadding();
@@ -751,7 +758,8 @@ void MapPropertiesSystem::DrawPropertiesPopup(int current_map,
RefreshOverworldMap();
}
if (ImGui::IsItemHovered()) {
ImGui::SetTooltip("Affects sprite graphics/palettes based on story progress");
ImGui::SetTooltip(
"Affects sprite graphics/palettes based on story progress");
}
ImGui::EndTable();
@@ -763,19 +771,18 @@ void MapPropertiesSystem::DrawPropertiesPopup(int current_map,
ImGui::Separator();
// ALL ROMs support Small/Large. Only v3+ supports Wide/Tall.
uint8_t asm_version =
(*rom_)[zelda3::OverworldCustomASMHasBeenApplied];
uint8_t asm_version = (*rom_)[zelda3::OverworldCustomASMHasBeenApplied];
int current_area_size =
static_cast<int>(overworld_->overworld_map(current_map)->area_size());
ImGui::SetNextItemWidth(kComboAreaSizeWidth);
if (asm_version >= 3 && asm_version != 0xFF) {
// v3+ ROM: Show all 4 area size options
if (ImGui::Combo(ICON_MD_PHOTO_SIZE_SELECT_LARGE " Size", &current_area_size, kAreaSizeNames, 4)) {
if (ImGui::Combo(ICON_MD_PHOTO_SIZE_SELECT_LARGE " Size",
&current_area_size, kAreaSizeNames, 4)) {
auto status = overworld_->ConfigureMultiAreaMap(
current_map,
static_cast<zelda3::AreaSizeEnum>(current_area_size));
current_map, static_cast<zelda3::AreaSizeEnum>(current_area_size));
if (status.ok()) {
RefreshSiblingMapGraphics(current_map, true);
RefreshOverworldMap();
@@ -785,10 +792,13 @@ void MapPropertiesSystem::DrawPropertiesPopup(int current_map,
} else {
// Vanilla/v1/v2 ROM: Show only Small/Large
const char* limited_names[] = {"Small (1x1)", "Large (2x2)"};
int limited_size = (current_area_size == 0 || current_area_size == 1) ? current_area_size : 0;
if (ImGui::Combo(ICON_MD_PHOTO_SIZE_SELECT_LARGE " Size", &limited_size, limited_names, 2)) {
auto size = (limited_size == 1) ? zelda3::AreaSizeEnum::LargeArea
int limited_size = (current_area_size == 0 || current_area_size == 1)
? current_area_size
: 0;
if (ImGui::Combo(ICON_MD_PHOTO_SIZE_SELECT_LARGE " Size", &limited_size,
limited_names, 2)) {
auto size = (limited_size == 1) ? zelda3::AreaSizeEnum::LargeArea
: zelda3::AreaSizeEnum::SmallArea;
auto status = overworld_->ConfigureMultiAreaMap(current_map, size);
if (status.ok()) {
@@ -817,7 +827,7 @@ void MapPropertiesSystem::DrawPropertiesPopup(int current_map,
HOVER_HINT("Open detailed area configuration with all settings tabs");
ImGui::PopStyleVar(2); // Pop the 2 style variables we pushed
ImGui::PopID(); // Pop ConfigPopup ID scope
ImGui::PopID(); // Pop ConfigPopup ID scope
ImGui::EndPopup();
}
}
@@ -990,7 +1000,8 @@ void MapPropertiesSystem::DrawSpritePropertiesTab(int current_map) {
RefreshOverworldMap();
}
if (ImGui::IsItemHovered()) {
ImGui::SetTooltip("Second sprite graphics sheet for Master Sword obtained state");
ImGui::SetTooltip(
"Second sprite graphics sheet for Master Sword obtained state");
}
TableNextColumn();
@@ -1018,7 +1029,8 @@ void MapPropertiesSystem::DrawSpritePropertiesTab(int current_map) {
RefreshOverworldMap();
}
if (ImGui::IsItemHovered()) {
ImGui::SetTooltip("Color palette for sprites - Master Sword obtained state");
ImGui::SetTooltip(
"Color palette for sprites - Master Sword obtained state");
}
ImGui::EndTable();
@@ -1036,34 +1048,36 @@ void MapPropertiesSystem::DrawCustomFeaturesTab(int current_map) {
TableNextColumn();
// ALL ROMs support Small/Large. Only v3+ supports Wide/Tall.
auto rom_version_basic = zelda3::OverworldVersionHelper::GetVersion(*rom_);
int current_area_size =
static_cast<int>(overworld_->overworld_map(current_map)->area_size());
ImGui::SetNextItemWidth(130.f);
if (zelda3::OverworldVersionHelper::SupportsAreaEnum(rom_version_basic)) {
// v3+ ROM: Show all 4 area size options
static const char* all_sizes[] = {"Small (1x1)", "Large (2x2)",
"Wide (2x1)", "Tall (1x2)"};
if (ImGui::Combo("##AreaSize", &current_area_size, all_sizes, 4)) {
auto status = overworld_->ConfigureMultiAreaMap(
current_map,
static_cast<zelda3::AreaSizeEnum>(current_area_size));
current_map, static_cast<zelda3::AreaSizeEnum>(current_area_size));
if (status.ok()) {
RefreshSiblingMapGraphics(current_map, true);
RefreshOverworldMap();
}
}
if (ImGui::IsItemHovered()) {
ImGui::SetTooltip("Map size: Small (1x1), Large (2x2), Wide (2x1), Tall (1x2)");
ImGui::SetTooltip(
"Map size: Small (1x1), Large (2x2), Wide (2x1), Tall (1x2)");
}
} else {
// Vanilla/v1/v2 ROM: Show only Small/Large
static const char* limited_sizes[] = {"Small (1x1)", "Large (2x2)"};
int limited_size = (current_area_size == 0 || current_area_size == 1) ? current_area_size : 0;
int limited_size = (current_area_size == 0 || current_area_size == 1)
? current_area_size
: 0;
if (ImGui::Combo("##AreaSize", &limited_size, limited_sizes, 2)) {
auto size = (limited_size == 1) ? zelda3::AreaSizeEnum::LargeArea
auto size = (limited_size == 1) ? zelda3::AreaSizeEnum::LargeArea
: zelda3::AreaSizeEnum::SmallArea;
auto status = overworld_->ConfigureMultiAreaMap(current_map, size);
if (status.ok()) {
@@ -1072,11 +1086,13 @@ void MapPropertiesSystem::DrawCustomFeaturesTab(int current_map) {
}
}
if (ImGui::IsItemHovered()) {
ImGui::SetTooltip("Map size: Small (1x1), Large (2x2). Wide/Tall require v3+");
ImGui::SetTooltip(
"Map size: Small (1x1), Large (2x2). Wide/Tall require v3+");
}
}
if (zelda3::OverworldVersionHelper::SupportsCustomBGColors(rom_version_basic)) {
if (zelda3::OverworldVersionHelper::SupportsCustomBGColors(
rom_version_basic)) {
TableNextColumn();
ImGui::Text(ICON_MD_COLOR_LENS " Main Palette");
TableNextColumn();
@@ -1093,7 +1109,8 @@ void MapPropertiesSystem::DrawCustomFeaturesTab(int current_map) {
}
}
if (zelda3::OverworldVersionHelper::SupportsAnimatedGFX(rom_version_basic)) {
if (zelda3::OverworldVersionHelper::SupportsAnimatedGFX(
rom_version_basic)) {
TableNextColumn();
ImGui::Text(ICON_MD_ANIMATION " Animated GFX");
TableNextColumn();
@@ -1129,7 +1146,7 @@ void MapPropertiesSystem::DrawCustomFeaturesTab(int current_map) {
void MapPropertiesSystem::DrawTileGraphicsTab(int current_map) {
auto rom_version = zelda3::OverworldVersionHelper::GetVersion(*rom_);
// Only show custom tile graphics for v1+ ROMs
if (zelda3::OverworldVersionHelper::SupportsExpandedSpace(rom_version)) {
ImGui::Text(ICON_MD_GRID_VIEW " Custom Tile Graphics (8 sheets)");
@@ -1137,7 +1154,8 @@ void MapPropertiesSystem::DrawTileGraphicsTab(int current_map) {
if (BeginTable("TileGraphics", 2,
ImGuiTableFlags_Borders | ImGuiTableFlags_SizingFixedFit)) {
ImGui::TableSetupColumn("Property", ImGuiTableColumnFlags_WidthFixed, 180);
ImGui::TableSetupColumn("Property", ImGuiTableColumnFlags_WidthFixed,
180);
ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
for (int i = 0; i < 8; i++) {
@@ -1162,10 +1180,11 @@ void MapPropertiesSystem::DrawTileGraphicsTab(int current_map) {
ImGui::EndTable();
}
Separator();
ImGui::TextWrapped("These 8 sheets allow custom tile graphics per map. "
"Each sheet references a graphics ID loaded into VRAM.");
ImGui::TextWrapped(
"These 8 sheets allow custom tile graphics per map. "
"Each sheet references a graphics ID loaded into VRAM.");
} else {
// Vanilla ROM - show info message
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f),
@@ -1191,7 +1210,7 @@ void MapPropertiesSystem::DrawMusicTab(int current_map) {
ImGuiTableColumnFlags_WidthStretch);
const char* music_state_names[] = {
ICON_MD_PLAY_ARROW " Beginning (Pre-Zelda)",
ICON_MD_PLAY_ARROW " Beginning (Pre-Zelda)",
ICON_MD_FAVORITE " Zelda Rescued",
ICON_MD_OFFLINE_BOLT " Master Sword Obtained",
ICON_MD_CASTLE " Agahnim Defeated"};
@@ -1245,12 +1264,13 @@ void MapPropertiesSystem::DrawMusicTab(int current_map) {
}
Separator();
ImGui::TextWrapped("Music tracks control the background music for different "
"game progression states on this overworld map.");
ImGui::TextWrapped(
"Music tracks control the background music for different "
"game progression states on this overworld map.");
// Show common music track IDs for reference in a collapsing section
Separator();
if (ImGui::CollapsingHeader(ICON_MD_HELP_OUTLINE " Common Music Track IDs",
if (ImGui::CollapsingHeader(ICON_MD_HELP_OUTLINE " Common Music Track IDs",
ImGuiTreeNodeFlags_DefaultOpen)) {
ImGui::Indent();
ImGui::BulletText("0x02 - Overworld Theme");
@@ -1295,19 +1315,21 @@ void MapPropertiesSystem::ForceRefreshGraphics(int map_index) {
}
}
void MapPropertiesSystem::RefreshSiblingMapGraphics(int map_index, bool include_self) {
if (!overworld_ || !maps_bmp_ || map_index < 0 || map_index >= zelda3::kNumOverworldMaps) {
void MapPropertiesSystem::RefreshSiblingMapGraphics(int map_index,
bool include_self) {
if (!overworld_ || !maps_bmp_ || map_index < 0 ||
map_index >= zelda3::kNumOverworldMaps) {
return;
}
auto* map = overworld_->mutable_overworld_map(map_index);
if (map->area_size() == zelda3::AreaSizeEnum::SmallArea) {
return; // No siblings for small areas
}
int parent_id = map->parent();
std::vector<int> siblings;
switch (map->area_size()) {
case zelda3::AreaSizeEnum::LargeArea:
siblings = {parent_id, parent_id + 1, parent_id + 8, parent_id + 9};
@@ -1321,26 +1343,26 @@ void MapPropertiesSystem::RefreshSiblingMapGraphics(int map_index, bool include_
default:
return;
}
for (int sibling : siblings) {
if (sibling >= 0 && sibling < zelda3::kNumOverworldMaps) {
// Skip self unless include_self is true
if (sibling == map_index && !include_self) {
continue;
}
// Mark as modified FIRST
(*maps_bmp_)[sibling].set_modified(true);
// Load graphics from ROM
overworld_->mutable_overworld_map(sibling)->LoadAreaGraphics();
// CRITICAL FIX: Force immediate refresh on the sibling
// This will trigger the callback to OverworldEditor's RefreshChildMapOnDemand
ForceRefreshGraphics(sibling);
}
}
// After marking all siblings, trigger a refresh
// This ensures all marked maps get processed
RefreshOverworldMap();
@@ -1382,7 +1404,7 @@ void MapPropertiesSystem::DrawOverlayControls(int current_map,
if (is_special_overworld_map) {
// Special overworld maps (0x80-0x9F) serve as visual effect sources
ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f),
ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f),
ICON_MD_INFO " Special Area Map (0x%02X)", current_map);
ImGui::Separator();
ImGui::TextWrapped(
@@ -1398,28 +1420,28 @@ void MapPropertiesSystem::DrawOverlayControls(int current_map,
// Light World (0x00-0x3F) and Dark World (0x40-0x7F) maps support subscreen overlays
// Comprehensive help section
ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f),
ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f),
ICON_MD_HELP_OUTLINE " Visual Effects Overview");
ImGui::SameLine();
if (ImGui::Button(ICON_MD_INFO "##HelpButton")) {
ImGui::OpenPopup("OverlayTypesHelp");
}
if (ImGui::BeginPopup("OverlayTypesHelp")) {
ImGui::Text(ICON_MD_HELP " Understanding Overlay Types");
ImGui::Separator();
ImGui::TextColored(ImVec4(0.4f, 1.0f, 0.4f, 1.0f),
ICON_MD_LAYERS " 1. Subscreen Overlays (Visual Effects)");
ImGui::TextColored(ImVec4(0.4f, 1.0f, 0.4f, 1.0f), ICON_MD_LAYERS
" 1. Subscreen Overlays (Visual Effects)");
ImGui::Indent();
ImGui::BulletText("Displayed as semi-transparent layers");
ImGui::BulletText("Reference special area maps (0x80-0x9F)");
ImGui::BulletText("Examples: fog, rain, forest canopy, sky");
ImGui::BulletText("Purely visual - don't affect collision");
ImGui::Unindent();
ImGui::Spacing();
ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.4f, 1.0f),
ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.4f, 1.0f),
ICON_MD_EDIT_NOTE " 2. Map Overlays (Interactive)");
ImGui::Indent();
ImGui::BulletText("Dynamic tile16 changes on the map");
@@ -1428,12 +1450,12 @@ void MapPropertiesSystem::DrawOverlayControls(int current_map,
ImGui::BulletText("Affect collision and interaction");
ImGui::BulletText("Triggered by game events/progression");
ImGui::Unindent();
ImGui::Separator();
ImGui::TextWrapped(
"Note: Subscreen overlays are what you configure here. "
"Map overlays are event-driven and edited separately.");
ImGui::EndPopup();
}
ImGui::Separator();
@@ -1460,13 +1482,13 @@ void MapPropertiesSystem::DrawOverlayControls(int current_map,
// Show subscreen overlay description with color coding
std::string overlay_desc = GetOverlayDescription(current_overlay);
if (current_overlay == 0x00FF) {
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f),
ICON_MD_CHECK " %s", overlay_desc.c_str());
ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), ICON_MD_CHECK " %s",
overlay_desc.c_str());
} else if (current_overlay >= 0x80 && current_overlay < 0xA0) {
ImGui::TextColored(ImVec4(0.4f, 1.0f, 0.4f, 1.0f),
ImGui::TextColored(ImVec4(0.4f, 1.0f, 0.4f, 1.0f),
ICON_MD_VISIBILITY " %s", overlay_desc.c_str());
} else {
ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.4f, 1.0f),
ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.4f, 1.0f),
ICON_MD_HELP_OUTLINE " %s", overlay_desc.c_str());
}
@@ -1538,9 +1560,10 @@ void MapPropertiesSystem::DrawOverlayControls(int current_map,
ImGui::BulletText("Visual effects use maps 0x80-0x9F");
ImGui::BulletText("Map overlays are read-only");
} else {
const char* version_name = zelda3::OverworldVersionHelper::GetVersionName(rom_version);
ImGui::TextColored(ImVec4(0.4f, 1.0f, 0.4f, 1.0f),
ICON_MD_UPGRADE " %s", version_name);
const char* version_name =
zelda3::OverworldVersionHelper::GetVersionName(rom_version);
ImGui::TextColored(ImVec4(0.4f, 1.0f, 0.4f, 1.0f), ICON_MD_UPGRADE " %s",
version_name);
ImGui::BulletText("Enhanced visual effect control");
if (zelda3::OverworldVersionHelper::SupportsAreaEnum(rom_version)) {
ImGui::BulletText("Extended overlay system");
@@ -1580,7 +1603,7 @@ void MapPropertiesSystem::DrawOverlayPreviewOnMap(int current_map,
int current_world,
bool show_overlay_preview) {
gfx::ScopedTimer timer("map_properties_draw_overlay_preview");
if (!show_overlay_preview || !maps_bmp_ || !canvas_)
return;
@@ -1653,7 +1676,7 @@ void MapPropertiesSystem::DrawOverlayPreviewOnMap(int current_map,
void MapPropertiesSystem::DrawViewPopup() {
if (ImGui::BeginPopup("ViewPopup")) {
ImGui::PushID("ViewPopup"); // Fix ImGui duplicate ID warnings
// Use theme-aware spacing instead of hardcoded constants
float spacing = gui::LayoutHelpers::GetStandardSpacing();
float padding = gui::LayoutHelpers::GetButtonPadding();
@@ -1683,7 +1706,7 @@ void MapPropertiesSystem::DrawViewPopup() {
HOVER_HINT("Toggle fullscreen canvas (F11)");
ImGui::PopStyleVar(2); // Pop the 2 style variables we pushed
ImGui::PopID(); // Pop ViewPopup ID scope
ImGui::PopID(); // Pop ViewPopup ID scope
ImGui::EndPopup();
}
}
@@ -1691,7 +1714,7 @@ void MapPropertiesSystem::DrawViewPopup() {
void MapPropertiesSystem::DrawQuickAccessPopup() {
if (ImGui::BeginPopup("QuickPopup")) {
ImGui::PushID("QuickPopup"); // Fix ImGui duplicate ID warnings
// Use theme-aware spacing instead of hardcoded constants
float spacing = gui::LayoutHelpers::GetStandardSpacing();
float padding = gui::LayoutHelpers::GetButtonPadding();
@@ -1723,7 +1746,7 @@ void MapPropertiesSystem::DrawQuickAccessPopup() {
HOVER_HINT("Lock/unlock current map (Ctrl+L)");
ImGui::PopStyleVar(2); // Pop the 2 style variables we pushed
ImGui::PopID(); // Pop QuickPopup ID scope
ImGui::PopID(); // Pop QuickPopup ID scope
ImGui::EndPopup();
}
}

89
src/app/editor/overworld/map_properties.h
View File

@@ -3,16 +3,16 @@
#include <functional>
#include "zelda3/overworld/overworld.h"
#include "app/rom.h"
#include "app/gui/canvas/canvas.h"
#include "app/rom.h"
#include "zelda3/overworld/overworld.h"
// Forward declaration
namespace yaze {
namespace editor {
class OverworldEditor;
}
}
} // namespace yaze
namespace yaze {
namespace editor {
@@ -23,25 +23,30 @@ class MapPropertiesSystem {
using RefreshCallback = std::function<void()>;
using RefreshPaletteCallback = std::function<absl::Status()>;
using ForceRefreshGraphicsCallback = std::function<void(int)>;
explicit MapPropertiesSystem(zelda3::Overworld* overworld, Rom* rom,
std::array<gfx::Bitmap, zelda3::kNumOverworldMaps>* maps_bmp = nullptr,
gui::Canvas* canvas = nullptr)
: overworld_(overworld), rom_(rom), maps_bmp_(maps_bmp), canvas_(canvas) {}
explicit MapPropertiesSystem(
zelda3::Overworld* overworld, Rom* rom,
std::array<gfx::Bitmap, zelda3::kNumOverworldMaps>* maps_bmp = nullptr,
gui::Canvas* canvas = nullptr)
: overworld_(overworld),
rom_(rom),
maps_bmp_(maps_bmp),
canvas_(canvas) {}
// Set callbacks for refresh operations
void SetRefreshCallbacks(RefreshCallback refresh_map_properties,
RefreshCallback refresh_overworld_map,
RefreshPaletteCallback refresh_map_palette,
RefreshPaletteCallback refresh_tile16_blockset = nullptr,
ForceRefreshGraphicsCallback force_refresh_graphics = nullptr) {
void SetRefreshCallbacks(
RefreshCallback refresh_map_properties,
RefreshCallback refresh_overworld_map,
RefreshPaletteCallback refresh_map_palette,
RefreshPaletteCallback refresh_tile16_blockset = nullptr,
ForceRefreshGraphicsCallback force_refresh_graphics = nullptr) {
refresh_map_properties_ = std::move(refresh_map_properties);
refresh_overworld_map_ = std::move(refresh_overworld_map);
refresh_map_palette_ = std::move(refresh_map_palette);
refresh_tile16_blockset_ = std::move(refresh_tile16_blockset);
force_refresh_graphics_ = std::move(force_refresh_graphics);
}
// Set callbacks for entity operations
void SetEntityCallbacks(
std::function<void(const std::string&)> insert_callback) {
@@ -49,74 +54,82 @@ class MapPropertiesSystem {
}
// Main interface methods
void DrawSimplifiedMapSettings(int& current_world, int& current_map,
bool& current_map_lock, bool& show_map_properties_panel,
bool& show_custom_bg_color_editor, bool& show_overlay_editor,
bool& show_overlay_preview, int& game_state, int& current_mode);
void DrawSimplifiedMapSettings(int& current_world, int& current_map,
bool& current_map_lock,
bool& show_map_properties_panel,
bool& show_custom_bg_color_editor,
bool& show_overlay_editor,
bool& show_overlay_preview, int& game_state,
int& current_mode);
void DrawMapPropertiesPanel(int current_map, bool& show_map_properties_panel);
void DrawCustomBackgroundColorEditor(int current_map, bool& show_custom_bg_color_editor);
void DrawCustomBackgroundColorEditor(int current_map,
bool& show_custom_bg_color_editor);
void DrawOverlayEditor(int current_map, bool& show_overlay_editor);
// Overlay preview functionality
void DrawOverlayPreviewOnMap(int current_map, int current_world, bool show_overlay_preview);
void DrawOverlayPreviewOnMap(int current_map, int current_world,
bool show_overlay_preview);
// Context menu integration
void SetupCanvasContextMenu(gui::Canvas& canvas, int current_map, bool current_map_lock,
bool& show_map_properties_panel, bool& show_custom_bg_color_editor,
bool& show_overlay_editor, int current_mode = 0);
void SetupCanvasContextMenu(gui::Canvas& canvas, int current_map,
bool current_map_lock,
bool& show_map_properties_panel,
bool& show_custom_bg_color_editor,
bool& show_overlay_editor, int current_mode = 0);
private:
// Property category drawers
void DrawGraphicsPopup(int current_map, int game_state);
void DrawPalettesPopup(int current_map, int game_state, bool& show_custom_bg_color_editor);
void DrawPropertiesPopup(int current_map, bool& show_map_properties_panel,
bool& show_overlay_preview, int& game_state);
void DrawPalettesPopup(int current_map, int game_state,
bool& show_custom_bg_color_editor);
void DrawPropertiesPopup(int current_map, bool& show_map_properties_panel,
bool& show_overlay_preview, int& game_state);
// Overlay and mosaic functionality
void DrawMosaicControls(int current_map);
void DrawOverlayControls(int current_map, bool& show_overlay_preview);
std::string GetOverlayDescription(uint16_t overlay_id);
// Integrated toolset popup functions
void DrawToolsPopup(int& current_mode);
void DrawViewPopup();
void DrawQuickAccessPopup();
// Tab content drawers
void DrawBasicPropertiesTab(int current_map);
void DrawSpritePropertiesTab(int current_map);
void DrawCustomFeaturesTab(int current_map);
void DrawTileGraphicsTab(int current_map);
void DrawMusicTab(int current_map);
// Utility methods - now call the callbacks
void RefreshMapProperties();
void RefreshOverworldMap();
absl::Status RefreshMapPalette();
absl::Status RefreshTile16Blockset();
void ForceRefreshGraphics(int map_index);
// Helper to refresh sibling map graphics for multi-area maps
void RefreshSiblingMapGraphics(int map_index, bool include_self = false);
zelda3::Overworld* overworld_;
Rom* rom_;
std::array<gfx::Bitmap, zelda3::kNumOverworldMaps>* maps_bmp_;
gui::Canvas* canvas_;
// Callbacks for refresh operations
RefreshCallback refresh_map_properties_;
RefreshCallback refresh_overworld_map_;
RefreshPaletteCallback refresh_map_palette_;
RefreshPaletteCallback refresh_tile16_blockset_;
ForceRefreshGraphicsCallback force_refresh_graphics_;
// Callback for entity insertion (generic, editor handles entity types)
std::function<void(const std::string&)> entity_insert_callback_;
// Using centralized UI constants from ui_constants.h
};

20
src/app/editor/overworld/overworld_editor.cc
View File

@@ -492,7 +492,9 @@ void OverworldEditor::DrawToolset() {
// IMPORTANT: Don't cache version - it needs to update after ROM upgrade
auto rom_version = zelda3::OverworldVersionHelper::GetVersion(*rom_);
uint8_t asm_version = (*rom_)[zelda3::OverworldCustomASMHasBeenApplied]; // Still needed for badge display
uint8_t asm_version = (*rom_)
[zelda3::
OverworldCustomASMHasBeenApplied]; // Still needed for badge display
// Don't use WidgetIdScope here - it conflicts with ImGui::Begin/End ID stack in cards
// Widgets register themselves individually instead
@@ -1258,7 +1260,8 @@ absl::Status OverworldEditor::CheckForCurrentMap() {
// Use centralized version detection
auto rom_version = zelda3::OverworldVersionHelper::GetVersion(*rom_);
bool use_v3_area_sizes = zelda3::OverworldVersionHelper::SupportsAreaEnum(rom_version);
bool use_v3_area_sizes =
zelda3::OverworldVersionHelper::SupportsAreaEnum(rom_version);
// Get area size for v3+ ROMs, otherwise use legacy logic
if (use_v3_area_sizes) {
@@ -1623,7 +1626,8 @@ void OverworldEditor::DrawOverworldCanvas() {
ow_map_canvas_.scrolling(),
dragged_entity_free_movement_);
// Pass overworld context for proper area size detection
dragged_entity_->UpdateMapProperties(dragged_entity_->map_id_, &overworld_);
dragged_entity_->UpdateMapProperties(dragged_entity_->map_id_,
&overworld_);
rom_->set_dirty(true);
}
is_dragging_entity_ = false;
@@ -1637,7 +1641,6 @@ void OverworldEditor::DrawOverworldCanvas() {
ow_map_canvas_.DrawGrid();
ow_map_canvas_.DrawOverlay();
ImGui::EndChild();
}
absl::Status OverworldEditor::DrawTile16Selector() {
@@ -2121,7 +2124,8 @@ void OverworldEditor::RefreshChildMapOnDemand(int map_index) {
// Handle multi-area maps (large, wide, tall) with safe coordination
// Use centralized version detection
auto rom_version = zelda3::OverworldVersionHelper::GetVersion(*rom_);
bool use_v3_area_sizes = zelda3::OverworldVersionHelper::SupportsAreaEnum(rom_version);
bool use_v3_area_sizes =
zelda3::OverworldVersionHelper::SupportsAreaEnum(rom_version);
if (use_v3_area_sizes) {
// Use v3 multi-area coordination
@@ -2305,7 +2309,8 @@ absl::Status OverworldEditor::RefreshMapPalette() {
// Use centralized version detection
auto rom_version = zelda3::OverworldVersionHelper::GetVersion(*rom_);
bool use_v3_area_sizes = zelda3::OverworldVersionHelper::SupportsAreaEnum(rom_version);
bool use_v3_area_sizes =
zelda3::OverworldVersionHelper::SupportsAreaEnum(rom_version);
if (use_v3_area_sizes) {
// Use v3 area size system
@@ -2447,7 +2452,8 @@ void OverworldEditor::RefreshMapProperties() {
// Use centralized version detection
auto rom_version = zelda3::OverworldVersionHelper::GetVersion(*rom_);
bool use_v3_area_sizes = zelda3::OverworldVersionHelper::SupportsAreaEnum(rom_version);
bool use_v3_area_sizes =
zelda3::OverworldVersionHelper::SupportsAreaEnum(rom_version);
if (use_v3_area_sizes) {
// Use v3 area size system

61
src/app/editor/overworld/overworld_editor.h
View File

@@ -1,23 +1,23 @@
#ifndef YAZE_APP_EDITOR_OVERWORLDEDITOR_H
#define YAZE_APP_EDITOR_OVERWORLDEDITOR_H
#include <mutex>
#include "absl/status/status.h"
#include "app/editor/editor.h"
#include "app/editor/graphics/gfx_group_editor.h"
#include "app/editor/palette/palette_editor.h"
#include "app/editor/overworld/tile16_editor.h"
#include "app/editor/overworld/map_properties.h"
#include "app/editor/overworld/overworld_entity_renderer.h"
#include "app/editor/overworld/tile16_editor.h"
#include "app/editor/palette/palette_editor.h"
#include "app/gfx/core/bitmap.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gfx/render/tilemap.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gui/canvas/canvas.h"
#include "app/gui/widgets/tile_selector_widget.h"
#include "app/gui/core/input.h"
#include "app/gui/widgets/tile_selector_widget.h"
#include "app/rom.h"
#include "zelda3/overworld/overworld.h"
#include "imgui/imgui.h"
#include <mutex>
#include "zelda3/overworld/overworld.h"
namespace yaze {
namespace editor {
@@ -86,7 +86,7 @@ class OverworldEditor : public Editor, public gfx::GfxContext {
absl::Status Save() override;
absl::Status Clear() override;
zelda3::Overworld& overworld() { return overworld_; }
/**
* @brief Apply ZSCustomOverworld ASM patch to upgrade ROM version
*/
@@ -103,18 +103,21 @@ class OverworldEditor : public Editor, public gfx::GfxContext {
// ROM state methods (from Editor base class)
bool IsRomLoaded() const override { return rom_ && rom_->is_loaded(); }
std::string GetRomStatus() const override {
if (!rom_) return "No ROM loaded";
if (!rom_->is_loaded()) return "ROM failed to load";
if (!rom_)
return "No ROM loaded";
if (!rom_->is_loaded())
return "ROM failed to load";
return absl::StrFormat("ROM loaded: %s", rom_->title());
}
Rom* rom() const { return rom_; }
// Jump-to functionality
void set_current_map(int map_id) {
if (map_id >= 0 && map_id < zelda3::kNumOverworldMaps) {
current_map_ = map_id;
current_world_ = map_id / 0x40; // Calculate which world the map belongs to
current_world_ =
map_id / 0x40; // Calculate which world the map belongs to
}
}
@@ -126,7 +129,7 @@ class OverworldEditor : public Editor, public gfx::GfxContext {
* assembling the OverworldMap Bitmap objects.
*/
absl::Status LoadGraphics();
/**
* @brief Handle entity insertion from context menu
*
@@ -171,7 +174,7 @@ class OverworldEditor : public Editor, public gfx::GfxContext {
* @brief Draw and create the tile16 IDs that are currently selected.
*/
void CheckForSelectRectangle();
// Selected tile IDs for rectangle operations (moved from local static)
std::vector<int> selected_tile16_ids_;
@@ -211,26 +214,26 @@ class OverworldEditor : public Editor, public gfx::GfxContext {
void DrawOverworldProperties();
void HandleMapInteraction();
// SetupOverworldCanvasContextMenu removed (Phase 3B) - now handled by MapPropertiesSystem
// Canvas pan/zoom helpers (Overworld Refactoring)
void HandleOverworldPan();
void HandleOverworldZoom();
void ResetOverworldView();
void CenterOverworldView();
// Canvas Automation API integration (Phase 4)
void SetupCanvasAutomation();
gui::Canvas* GetOverworldCanvas() { return &ow_map_canvas_; }
// Tile operations for automation callbacks
bool AutomationSetTile(int x, int y, int tile_id);
int AutomationGetTile(int x, int y);
/**
* @brief Scroll the blockset canvas to show the current selected tile16
*/
void ScrollBlocksetCanvasToCurrentTile();
// Scratch space canvas methods
absl::Status DrawScratchSpace();
absl::Status SaveCurrentSelectionToScratch(int slot);
@@ -239,20 +242,21 @@ class OverworldEditor : public Editor, public gfx::GfxContext {
void DrawScratchSpaceEdits();
void DrawScratchSpacePattern();
void DrawScratchSpaceSelection();
void UpdateScratchBitmapTile(int tile_x, int tile_y, int tile_id, int slot = -1);
void UpdateScratchBitmapTile(int tile_x, int tile_y, int tile_id,
int slot = -1);
absl::Status UpdateUsageStats();
void DrawUsageGrid();
void DrawDebugWindow();
enum class EditingMode {
MOUSE, // Navigation, selection, entity management via context menu
DRAW_TILE // Tile painting mode
MOUSE, // Navigation, selection, entity management via context menu
DRAW_TILE // Tile painting mode
};
EditingMode current_mode = EditingMode::DRAW_TILE;
EditingMode previous_mode = EditingMode::DRAW_TILE;
// Entity editing state (managed via context menu now)
enum class EntityEditMode {
NONE,
@@ -263,7 +267,7 @@ class OverworldEditor : public Editor, public gfx::GfxContext {
TRANSPORTS,
MUSIC
};
EntityEditMode entity_edit_mode_ = EntityEditMode::NONE;
enum OverworldProperty {
@@ -310,7 +314,7 @@ class OverworldEditor : public Editor, public gfx::GfxContext {
bool use_area_specific_bg_color_ = false;
bool show_map_properties_panel_ = false;
bool show_overlay_preview_ = false;
// Card visibility states - Start hidden to prevent crash
bool show_overworld_canvas_ = true;
bool show_tile16_selector_ = false;
@@ -324,12 +328,12 @@ class OverworldEditor : public Editor, public gfx::GfxContext {
// Map properties system for UI organization
std::unique_ptr<MapPropertiesSystem> map_properties_system_;
std::unique_ptr<OverworldEntityRenderer> entity_renderer_;
// Scratch space for large layouts
// Scratch space canvas for tile16 drawing (like a mini overworld)
struct ScratchSpaceSlot {
gfx::Bitmap scratch_bitmap;
std::array<std::array<int, 32>, 32> tile_data; // 32x32 grid of tile16 IDs
std::array<std::array<int, 32>, 32> tile_data; // 32x32 grid of tile16 IDs
bool in_use = false;
std::string name = "Empty";
int width = 16; // Default 16x16 tiles
@@ -361,7 +365,7 @@ class OverworldEditor : public Editor, public gfx::GfxContext {
std::array<gfx::Bitmap, zelda3::kNumOverworldMaps> maps_bmp_;
gfx::BitmapTable current_graphics_set_;
std::vector<gfx::Bitmap> sprite_previews_;
// Deferred texture creation for performance optimization
// Deferred texture management now handled by gfx::Arena::Get()
@@ -388,7 +392,8 @@ class OverworldEditor : public Editor, public gfx::GfxContext {
gui::Canvas graphics_bin_canvas_{"GraphicsBin", kGraphicsBinCanvasSize,
gui::CanvasGridSize::k16x16};
gui::Canvas properties_canvas_;
gui::Canvas scratch_canvas_{"ScratchSpace", ImVec2(320, 480), gui::CanvasGridSize::k32x32};
gui::Canvas scratch_canvas_{"ScratchSpace", ImVec2(320, 480),
gui::CanvasGridSize::k32x32};
absl::Status status_;
};

58
src/app/editor/overworld/overworld_entity_renderer.cc
View File

@@ -2,12 +2,12 @@
#include <string>
#include "absl/strings/str_format.h"
#include "core/features.h"
#include "app/editor/overworld/entity.h"
#include "app/gui/canvas/canvas.h"
#include "zelda3/common.h"
#include "util/hex.h"
#include "core/features.h"
#include "imgui/imgui.h"
#include "util/hex.h"
#include "zelda3/common.h"
#include "zelda3/overworld/overworld_item.h"
namespace yaze {
@@ -17,15 +17,23 @@ using namespace ImGui;
// Entity colors - solid with good visibility
namespace {
ImVec4 GetEntranceColor() { return ImVec4{1.0f, 1.0f, 0.0f, 1.0f}; } // Solid yellow (#FFFF00FF, fully opaque)
ImVec4 GetExitColor() { return ImVec4{1.0f, 1.0f, 1.0f, 1.0f}; } // Solid white (#FFFFFFFF, fully opaque)
ImVec4 GetItemColor() { return ImVec4{1.0f, 0.0f, 0.0f, 1.0f}; } // Solid red (#FF0000FF, fully opaque)
ImVec4 GetSpriteColor() { return ImVec4{1.0f, 0.0f, 1.0f, 1.0f}; } // Solid magenta (#FF00FFFF, fully opaque)
ImVec4 GetEntranceColor() {
return ImVec4{1.0f, 1.0f, 0.0f, 1.0f};
} // Solid yellow (#FFFF00FF, fully opaque)
ImVec4 GetExitColor() {
return ImVec4{1.0f, 1.0f, 1.0f, 1.0f};
} // Solid white (#FFFFFFFF, fully opaque)
ImVec4 GetItemColor() {
return ImVec4{1.0f, 0.0f, 0.0f, 1.0f};
} // Solid red (#FF0000FF, fully opaque)
ImVec4 GetSpriteColor() {
return ImVec4{1.0f, 0.0f, 1.0f, 1.0f};
} // Solid magenta (#FF00FFFF, fully opaque)
} // namespace
void OverworldEntityRenderer::DrawEntrances(ImVec2 canvas_p0, ImVec2 scrolling,
int current_world,
int current_mode) {
int current_world,
int current_mode) {
// Don't reset hovered_entity_ here - DrawExits resets it (called first)
int i = 0;
for (auto& each : overworld_->entrances()) {
@@ -43,24 +51,17 @@ void OverworldEntityRenderer::DrawEntrances(ImVec2 canvas_p0, ImVec2 scrolling,
}
std::string str = util::HexByte(each.entrance_id_);
canvas_->DrawText(str, each.x_, each.y_);
}
i++;
}
}
void OverworldEntityRenderer::DrawExits(ImVec2 canvas_p0, ImVec2 scrolling,
int current_world,
int current_mode) {
int current_world, int current_mode) {
// Reset hover state at the start of entity rendering (DrawExits is called first)
hovered_entity_ = nullptr;
int i = 0;
for (auto& each : *overworld_->mutable_exits()) {
if (each.map_id_ < 0x40 + (current_world * 0x40) &&
@@ -71,16 +72,12 @@ void OverworldEntityRenderer::DrawExits(ImVec2 canvas_p0, ImVec2 scrolling,
hovered_entity_ = &each;
}
each.entity_id_ = i;
std::string str = util::HexByte(i);
canvas_->DrawText(str, each.x_, each.y_);
}
i++;
}
}
void OverworldEntityRenderer::DrawItems(int current_world, int current_mode) {
@@ -92,11 +89,10 @@ void OverworldEntityRenderer::DrawItems(int current_world, int current_mode) {
canvas_->DrawRect(item.x_, item.y_, 16, 16, GetItemColor());
if (IsMouseHoveringOverEntity(item, canvas_->zero_point(),
canvas_->scrolling())) {
canvas_->scrolling())) {
hovered_entity_ = &item;
}
std::string item_name = "";
if (item.id_ < zelda3::kSecretItemNames.size()) {
item_name = zelda3::kSecretItemNames[item.id_];
@@ -107,12 +103,10 @@ void OverworldEntityRenderer::DrawItems(int current_world, int current_mode) {
}
i++;
}
}
void OverworldEntityRenderer::DrawSprites(int current_world, int game_state,
int current_mode) {
int current_mode) {
int i = 0;
for (auto& sprite : *overworld_->mutable_sprites(game_state)) {
// Filter sprites by current world - only show sprites for the current world
@@ -129,20 +123,19 @@ void OverworldEntityRenderer::DrawSprites(int current_world, int game_state,
canvas_->DrawRect(sprite_x, sprite_y, 16, 16, GetSpriteColor());
if (IsMouseHoveringOverEntity(sprite, canvas_->zero_point(),
canvas_->scrolling())) {
canvas_->scrolling())) {
hovered_entity_ = &sprite;
}
if (core::FeatureFlags::get().overworld.kDrawOverworldSprites) {
if ((*sprite_previews_)[sprite.id()].is_active()) {
canvas_->DrawBitmap((*sprite_previews_)[sprite.id()], sprite_x,
sprite_y, 2.0f);
sprite_y, 2.0f);
}
}
canvas_->DrawText(absl::StrFormat("%s", sprite.name()), sprite_x,
sprite_y);
sprite_y);
// Restore original coordinates
sprite.x_ = original_x;
@@ -150,10 +143,7 @@ void OverworldEntityRenderer::DrawSprites(int current_world, int game_state,
}
i++;
}
}
} // namespace editor
} // namespace yaze

12
src/app/editor/overworld/overworld_entity_renderer.h
View File

@@ -5,9 +5,9 @@
#include "app/gfx/core/bitmap.h"
#include "app/gui/canvas/canvas.h"
#include "imgui/imgui.h"
#include "zelda3/common.h"
#include "zelda3/overworld/overworld.h"
#include "imgui/imgui.h"
namespace yaze {
namespace editor {
@@ -24,15 +24,16 @@ class OverworldEditor; // Forward declaration
class OverworldEntityRenderer {
public:
OverworldEntityRenderer(zelda3::Overworld* overworld, gui::Canvas* canvas,
std::vector<gfx::Bitmap>* sprite_previews)
: overworld_(overworld), canvas_(canvas),
std::vector<gfx::Bitmap>* sprite_previews)
: overworld_(overworld),
canvas_(canvas),
sprite_previews_(sprite_previews) {}
// Main rendering methods
void DrawEntrances(ImVec2 canvas_p0, ImVec2 scrolling, int current_world,
int current_mode);
int current_mode);
void DrawExits(ImVec2 canvas_p0, ImVec2 scrolling, int current_world,
int current_mode);
int current_mode);
void DrawItems(int current_world, int current_mode);
void DrawSprites(int current_world, int game_state, int current_mode);
@@ -49,4 +50,3 @@ class OverworldEntityRenderer {
} // namespace yaze
#endif // YAZE_APP_EDITOR_OVERWORLD_OVERWORLD_ENTITY_RENDERER_H

30
src/app/editor/overworld/scratch_space.cc
View File

@@ -10,30 +10,29 @@
#include "absl/status/status.h"
#include "absl/strings/str_format.h"
#include "core/asar_wrapper.h"
#include "app/gfx/debug/performance/performance_profiler.h"
#include "app/platform/window.h"
#include "app/editor/overworld/entity.h"
#include "app/editor/overworld/map_properties.h"
#include "app/editor/overworld/tile16_editor.h"
#include "app/gfx/resource/arena.h"
#include "app/gfx/core/bitmap.h"
#include "app/gfx/debug/performance/performance_profiler.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gfx/render/tilemap.h"
#include "app/gfx/resource/arena.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gui/canvas/canvas.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/input.h"
#include "app/gui/core/style.h"
#include "app/platform/window.h"
#include "app/rom.h"
#include "zelda3/common.h"
#include "zelda3/overworld/overworld.h"
#include "zelda3/overworld/overworld_map.h"
#include "core/asar_wrapper.h"
#include "imgui/imgui.h"
#include "imgui_memory_editor.h"
#include "util/hex.h"
#include "util/log.h"
#include "util/macro.h"
#include "zelda3/common.h"
#include "zelda3/overworld/overworld.h"
#include "zelda3/overworld/overworld_map.h"
namespace yaze::editor {
@@ -229,8 +228,7 @@ void OverworldEditor::DrawScratchSpacePattern() {
return;
}
const auto& tile_ids =
dependencies_.shared_clipboard->overworld_tile16_ids;
const auto& tile_ids = dependencies_.shared_clipboard->overworld_tile16_ids;
int pattern_width = dependencies_.shared_clipboard->overworld_width;
int pattern_height = dependencies_.shared_clipboard->overworld_height;
@@ -320,8 +318,8 @@ void OverworldEditor::UpdateScratchBitmapTile(int tile_x, int tile_y,
scratch_slot.scratch_bitmap.set_modified(true);
// Queue texture update via Arena's deferred system
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::UPDATE, &scratch_slot.scratch_bitmap);
gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::UPDATE,
&scratch_slot.scratch_bitmap);
scratch_slot.in_use = true;
}
@@ -366,7 +364,7 @@ absl::Status OverworldEditor::SaveCurrentSelectionToScratch(int slot) {
scratch_spaces_[slot].scratch_bitmap.SetPalette(palette_);
// Queue texture creation via Arena's deferred system
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::CREATE,
gfx::Arena::TextureCommandType::CREATE,
&scratch_spaces_[slot].scratch_bitmap);
}
@@ -404,7 +402,6 @@ absl::Status OverworldEditor::SaveCurrentSelectionToScratch(int slot) {
scratch_spaces_[slot].in_use = true;
}
return absl::OkStatus();
}
@@ -439,10 +436,11 @@ absl::Status OverworldEditor::ClearScratchSpace(int slot) {
scratch_spaces_[slot].scratch_bitmap.set_modified(true);
// Queue texture update via Arena's deferred system
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::UPDATE, &scratch_spaces_[slot].scratch_bitmap);
gfx::Arena::TextureCommandType::UPDATE,
&scratch_spaces_[slot].scratch_bitmap);
}
return absl::OkStatus();
}
}
} // namespace yaze::editor

85
src/app/editor/overworld/tile16_editor.cc
View File

@@ -3,20 +3,20 @@
#include <array>
#include "absl/status/status.h"
#include "app/gfx/resource/arena.h"
#include "app/gfx/core/bitmap.h"
#include "app/gfx/backend/irenderer.h"
#include "app/gfx/core/bitmap.h"
#include "app/gfx/debug/performance/performance_profiler.h"
#include "app/gfx/resource/arena.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gui/canvas/canvas.h"
#include "app/gui/core/input.h"
#include "app/gui/core/style.h"
#include "app/rom.h"
#include "zelda3/overworld/overworld.h"
#include "imgui/imgui.h"
#include "util/hex.h"
#include "util/log.h"
#include "util/macro.h"
#include "zelda3/overworld/overworld.h"
namespace yaze {
namespace editor {
@@ -347,8 +347,8 @@ absl::Status Tile16Editor::RefreshTile16Blockset() {
tile16_blockset_->atlas.set_modified(true);
// Queue texture update via Arena's deferred system
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::UPDATE, &tile16_blockset_->atlas);
gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::UPDATE,
&tile16_blockset_->atlas);
util::logf("Tile16 blockset refreshed and regenerated");
return absl::OkStatus();
@@ -517,8 +517,8 @@ absl::Status Tile16Editor::RegenerateTile16BitmapFromROM() {
}
// Queue texture creation via Arena's deferred system
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::CREATE, &current_tile16_bmp_);
gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::CREATE,
&current_tile16_bmp_);
util::logf("Regenerated Tile16 bitmap for tile %d from ROM data",
current_tile16_);
@@ -610,8 +610,8 @@ absl::Status Tile16Editor::DrawToCurrentTile16(ImVec2 pos,
// Mark the bitmap as modified and queue texture update
current_tile16_bmp_.set_modified(true);
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::UPDATE, &current_tile16_bmp_);
gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::UPDATE,
&current_tile16_bmp_);
// Update ROM data when painting to tile16
auto* tile_data = GetCurrentTile16Data();
@@ -902,8 +902,7 @@ absl::Status Tile16Editor::UpdateTile16Edit() {
// CRITICAL FIX: Handle tile painting with simple click instead of click+drag
// Draw the preview first
tile16_edit_canvas_.DrawTilePainter(
display_tile, 8, 4);
tile16_edit_canvas_.DrawTilePainter(display_tile, 8, 4);
// Check for simple click to paint tile8 to tile16
if (ImGui::IsItemClicked(ImGuiMouseButton_Left)) {
@@ -913,10 +912,8 @@ absl::Status Tile16Editor::UpdateTile16Edit() {
io.MousePos.y - canvas_pos.y);
// Convert canvas coordinates to tile16 coordinates with dynamic zoom
int tile_x = static_cast<int>(mouse_pos.x /
4);
int tile_y = static_cast<int>(mouse_pos.y /
4);
int tile_x = static_cast<int>(mouse_pos.x / 4);
int tile_y = static_cast<int>(mouse_pos.y / 4);
// Clamp to valid range
tile_x = std::max(0, std::min(15, tile_x));
@@ -937,10 +934,8 @@ absl::Status Tile16Editor::UpdateTile16Edit() {
io.MousePos.y - canvas_pos.y);
// Convert with dynamic zoom
int tile_x = static_cast<int>(mouse_pos.x /
4);
int tile_y = static_cast<int>(mouse_pos.y /
4);
int tile_x = static_cast<int>(mouse_pos.x / 4);
int tile_y = static_cast<int>(mouse_pos.y / 4);
// Clamp to valid range
tile_x = std::max(0, std::min(15, tile_x));
@@ -1369,8 +1364,8 @@ absl::Status Tile16Editor::SetCurrentTile(int tile_id) {
}
// Queue texture creation via Arena's deferred system
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::CREATE, &current_tile16_bmp_);
gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::CREATE,
&current_tile16_bmp_);
// Simple success logging
util::logf("SetCurrentTile: loaded tile %d successfully", tile_id);
@@ -1390,8 +1385,8 @@ absl::Status Tile16Editor::CopyTile16ToClipboard(int tile_id) {
clipboard_tile16_.SetPalette(tile16_blockset_->atlas.palette());
}
// Queue texture creation via Arena's deferred system
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::CREATE, &clipboard_tile16_);
gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::CREATE,
&clipboard_tile16_);
clipboard_has_data_ = true;
return absl::OkStatus();
@@ -1406,8 +1401,8 @@ absl::Status Tile16Editor::PasteTile16FromClipboard() {
current_tile16_bmp_.Create(16, 16, 8, clipboard_tile16_.vector());
current_tile16_bmp_.SetPalette(clipboard_tile16_.palette());
// Queue texture creation via Arena's deferred system
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::CREATE, &current_tile16_bmp_);
gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::CREATE,
&current_tile16_bmp_);
return absl::OkStatus();
}
@@ -1421,8 +1416,8 @@ absl::Status Tile16Editor::SaveTile16ToScratchSpace(int slot) {
scratch_space_[slot].Create(16, 16, 8, current_tile16_bmp_.vector());
scratch_space_[slot].SetPalette(current_tile16_bmp_.palette());
// Queue texture creation via Arena's deferred system
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::CREATE, &scratch_space_[slot]);
gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::CREATE,
&scratch_space_[slot]);
scratch_space_used_[slot] = true;
return absl::OkStatus();
@@ -1441,8 +1436,8 @@ absl::Status Tile16Editor::LoadTile16FromScratchSpace(int slot) {
current_tile16_bmp_.Create(16, 16, 8, scratch_space_[slot].vector());
current_tile16_bmp_.SetPalette(scratch_space_[slot].palette());
// Queue texture creation via Arena's deferred system
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::CREATE, &current_tile16_bmp_);
gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::CREATE,
&current_tile16_bmp_);
return absl::OkStatus();
}
@@ -1487,8 +1482,8 @@ absl::Status Tile16Editor::FlipTile16Horizontal() {
current_tile16_bmp_.set_modified(true);
// Queue texture update via Arena's deferred system
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::UPDATE, &current_tile16_bmp_);
gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::UPDATE,
&current_tile16_bmp_);
return absl::OkStatus();
}
@@ -1522,8 +1517,8 @@ absl::Status Tile16Editor::FlipTile16Vertical() {
current_tile16_bmp_.set_modified(true);
// Queue texture update via Arena's deferred system
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::UPDATE, &current_tile16_bmp_);
gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::UPDATE,
&current_tile16_bmp_);
return absl::OkStatus();
}
@@ -1557,8 +1552,8 @@ absl::Status Tile16Editor::RotateTile16() {
current_tile16_bmp_.set_modified(true);
// Queue texture update via Arena's deferred system
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::UPDATE, &current_tile16_bmp_);
gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::UPDATE,
&current_tile16_bmp_);
return absl::OkStatus();
}
@@ -1596,8 +1591,8 @@ absl::Status Tile16Editor::FillTile16WithTile8(int tile8_id) {
current_tile16_bmp_.set_modified(true);
// Queue texture update via Arena's deferred system
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::UPDATE, &current_tile16_bmp_);
gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::UPDATE,
&current_tile16_bmp_);
return absl::OkStatus();
}
@@ -1614,8 +1609,8 @@ absl::Status Tile16Editor::ClearTile16() {
current_tile16_bmp_.set_modified(true);
// Queue texture update via Arena's deferred system
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::UPDATE, &current_tile16_bmp_);
gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::UPDATE,
&current_tile16_bmp_);
return absl::OkStatus();
}
@@ -1719,8 +1714,8 @@ absl::Status Tile16Editor::Undo() {
priority_tile = previous_state.priority;
// Queue texture update via Arena's deferred system
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::UPDATE, &current_tile16_bmp_);
gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::UPDATE,
&current_tile16_bmp_);
undo_stack_.pop_back();
return absl::OkStatus();
@@ -1744,8 +1739,8 @@ absl::Status Tile16Editor::Redo() {
priority_tile = next_state.priority;
// Queue texture update via Arena's deferred system
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::UPDATE, &current_tile16_bmp_);
gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::UPDATE,
&current_tile16_bmp_);
redo_stack_.pop_back();
return absl::OkStatus();
@@ -2111,8 +2106,8 @@ absl::Status Tile16Editor::UpdateTile8Palette(int tile8_id) {
current_gfx_individual_[tile8_id].set_modified(true);
// Queue texture update via Arena's deferred system
gfx::Arena::Get().QueueTextureCommand(
gfx::Arena::TextureCommandType::UPDATE, &current_gfx_individual_[tile8_id]);
gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::UPDATE,
&current_gfx_individual_[tile8_id]);
util::logf("Updated tile8 %d with palette slot %d (palette size: %zu colors)",
tile8_id, current_palette_, display_palette.size());

60
src/app/editor/overworld/tile16_editor.h
View File

@@ -13,9 +13,9 @@
#include "app/gfx/types/snes_tile.h"
#include "app/gui/canvas/canvas.h"
#include "app/gui/core/input.h"
#include "util/log.h"
#include "app/rom.h"
#include "imgui/imgui.h"
#include "util/log.h"
#include "util/notify.h"
namespace yaze {
@@ -54,7 +54,8 @@ class Tile16Editor : public gfx::GfxContext {
absl::Status SaveLayoutToScratch(int slot);
absl::Status LoadLayoutFromScratch(int slot);
absl::Status DrawToCurrentTile16(ImVec2 pos, const gfx::Bitmap* source_tile = nullptr);
absl::Status DrawToCurrentTile16(ImVec2 pos,
const gfx::Bitmap* source_tile = nullptr);
absl::Status UpdateTile16Edit();
@@ -111,16 +112,15 @@ class Tile16Editor : public gfx::GfxContext {
absl::Status UpdateTile8Palette(int tile8_id);
absl::Status RefreshAllPalettes();
void DrawPaletteSettings();
// Get the appropriate palette slot for current graphics sheet
int GetPaletteSlotForSheet(int sheet_index) const;
// NEW: Core palette mapping methods for fixing color alignment
int GetActualPaletteSlot(int palette_button, int sheet_index) const;
int GetSheetIndexForTile8(int tile8_id) const;
int GetActualPaletteSlotForCurrentTile16() const;
// ROM data access and modification
absl::Status UpdateROMTile16Data();
absl::Status RefreshTile16Blockset();
@@ -128,39 +128,45 @@ class Tile16Editor : public gfx::GfxContext {
absl::Status RegenerateTile16BitmapFromROM();
absl::Status UpdateBlocksetBitmap();
absl::Status PickTile8FromTile16(const ImVec2& position);
// Manual tile8 input controls
void DrawManualTile8Inputs();
void set_rom(Rom* rom) { rom_ = rom; }
Rom* rom() const { return rom_; }
// Set the palette from overworld to ensure color consistency
void set_palette(const gfx::SnesPalette& palette) {
void set_palette(const gfx::SnesPalette& palette) {
palette_ = palette;
// Store the complete 256-color overworld palette
if (palette.size() >= 256) {
overworld_palette_ = palette;
util::logf("Tile16 editor received complete overworld palette with %zu colors", palette.size());
util::logf(
"Tile16 editor received complete overworld palette with %zu colors",
palette.size());
} else {
util::logf("Warning: Received incomplete palette with %zu colors", palette.size());
util::logf("Warning: Received incomplete palette with %zu colors",
palette.size());
overworld_palette_ = palette;
}
// CRITICAL FIX: Load tile8 graphics now that we have the proper palette
if (rom_ && current_gfx_bmp_.is_active()) {
auto status = LoadTile8();
if (!status.ok()) {
util::logf("Failed to load tile8 graphics with new palette: %s", status.message().data());
util::logf("Failed to load tile8 graphics with new palette: %s",
status.message().data());
} else {
util::logf("Successfully loaded tile8 graphics with complete overworld palette");
util::logf(
"Successfully loaded tile8 graphics with complete overworld "
"palette");
}
}
util::logf("Tile16 editor palette coordination complete");
}
// Callback for when changes are committed to notify parent editor
void set_on_changes_committed(std::function<absl::Status()> callback) {
on_changes_committed_ = callback;
@@ -225,8 +231,10 @@ class Tile16Editor : public gfx::GfxContext {
// Palette management settings
bool show_palette_settings_ = false;
int current_palette_group_ = 0; // 0=overworld_main, 1=aux1, 2=aux2, etc.
uint8_t palette_normalization_mask_ = 0xFF; // Default 8-bit mask (preserve full palette index)
bool auto_normalize_pixels_ = false; // Disabled by default to preserve palette offsets
uint8_t palette_normalization_mask_ =
0xFF; // Default 8-bit mask (preserve full palette index)
bool auto_normalize_pixels_ =
false; // Disabled by default to preserve palette offsets
// Performance tracking
std::chrono::steady_clock::time_point last_edit_time_;
@@ -244,9 +252,10 @@ class Tile16Editor : public gfx::GfxContext {
gfx::Bitmap tile16_blockset_bmp_;
// Canvas for editing the selected tile - optimized for 2x2 grid of 8x8 tiles (16x16 total)
gui::Canvas tile16_edit_canvas_{"Tile16EditCanvas",
ImVec2(64, 64), // Fixed 64x64 display size (16x16 pixels at 4x scale)
gui::CanvasGridSize::k8x8, 8.0F}; // 8x8 grid with 4x scale for clarity
gui::Canvas tile16_edit_canvas_{
"Tile16EditCanvas",
ImVec2(64, 64), // Fixed 64x64 display size (16x16 pixels at 4x scale)
gui::CanvasGridSize::k8x8, 8.0F}; // 8x8 grid with 4x scale for clarity
gfx::Bitmap current_tile16_bmp_;
// Tile8 canvas to get the tile to drawing in the tile16_edit_canvas_
@@ -256,7 +265,8 @@ class Tile16Editor : public gfx::GfxContext {
gui::CanvasGridSize::k32x32};
gfx::Bitmap current_gfx_bmp_;
gui::Table tile_edit_table_{"##TileEditTable", 3, ImGuiTableFlags_Borders, ImVec2(0, 0)};
gui::Table tile_edit_table_{"##TileEditTable", 3, ImGuiTableFlags_Borders,
ImVec2(0, 0)};
gfx::Tilemap* tile16_blockset_ = nullptr;
std::vector<gfx::Bitmap> current_gfx_individual_;
@@ -266,10 +276,10 @@ class Tile16Editor : public gfx::GfxContext {
gfx::SnesPalette overworld_palette_; // Complete 256-color overworld palette
absl::Status status_;
// Callback to notify parent editor when changes are committed
std::function<absl::Status()> on_changes_committed_;
// Instance variable to store current tile16 data for proper persistence
gfx::Tile16 current_tile16_data_;
};

22
src/app/editor/overworld/ui_constants.h
View File

@@ -5,26 +5,16 @@ namespace yaze {
namespace editor {
// Game State Labels
inline constexpr const char* kGameStateNames[] = {
"Rain & Rescue Zelda",
"Pendants",
"Crystals"
};
inline constexpr const char* kGameStateNames[] = {"Rain & Rescue Zelda",
"Pendants", "Crystals"};
// World Labels
inline constexpr const char* kWorldNames[] = {
"Light World",
"Dark World",
"Special World"
};
inline constexpr const char* kWorldNames[] = {"Light World", "Dark World",
"Special World"};
// Area Size Names
inline constexpr const char* kAreaSizeNames[] = {
"Small (1x1)",
"Large (2x2)",
"Wide (2x1)",
"Tall (1x2)"
};
inline constexpr const char* kAreaSizeNames[] = {"Small (1x1)", "Large (2x2)",
"Wide (2x1)", "Tall (1x2)"};
// UI Styling Constants
inline constexpr float kInputFieldSize = 30.f;

327
src/app/editor/palette/palette_editor.cc
View File

@@ -3,11 +3,11 @@
#include "absl/status/status.h"
#include "absl/strings/str_cat.h"
#include "app/gfx/util/palette_manager.h"
#include "app/gfx/debug/performance/performance_profiler.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gui/core/color.h"
#include "app/gfx/util/palette_manager.h"
#include "app/gui/app/editor_layout.h"
#include "app/gui/core/color.h"
#include "app/gui/core/icons.h"
#include "imgui/imgui.h"
@@ -64,8 +64,10 @@ int CustomFormatString(char* buf, size_t buf_size, const char* fmt, ...) {
int w = vsnprintf(buf, buf_size, fmt, args);
#endif
va_end(args);
if (buf == nullptr) return w;
if (w == -1 || w >= (int)buf_size) w = (int)buf_size - 1;
if (buf == nullptr)
return w;
if (w == -1 || w >= (int)buf_size)
w = (int)buf_size - 1;
buf[w] = 0;
return w;
}
@@ -137,8 +139,7 @@ absl::Status DisplayPalette(gfx::SnesPalette& palette, bool loaded) {
SameLine();
Text("Previous");
if (Button("Update Map Palette")) {
}
if (Button("Update Map Palette")) {}
ColorButton(
"##current", color,
@@ -157,7 +158,8 @@ absl::Status DisplayPalette(gfx::SnesPalette& palette, bool loaded) {
Text("Palette");
for (int n = 0; n < IM_ARRAYSIZE(current_palette); n++) {
PushID(n);
if ((n % 8) != 0) SameLine(0.0f, GetStyle().ItemSpacing.y);
if ((n % 8) != 0)
SameLine(0.0f, GetStyle().ItemSpacing.y);
if (ColorButton("##palette", current_palette[n], kPalButtonFlags,
ImVec2(20, 20)))
@@ -185,119 +187,98 @@ absl::Status DisplayPalette(gfx::SnesPalette& palette, bool loaded) {
void PaletteEditor::Initialize() {
// Register all cards with EditorCardRegistry (done once during initialization)
if (!dependencies_.card_registry) return;
if (!dependencies_.card_registry)
return;
auto* card_registry = dependencies_.card_registry;
card_registry->RegisterCard({
.card_id = "palette.control_panel",
.display_name = "Palette Controls",
.icon = ICON_MD_PALETTE,
.category = "Palette",
.shortcut_hint = "Ctrl+Shift+P",
.visibility_flag = &show_control_panel_,
.priority = 10
});
card_registry->RegisterCard({.card_id = "palette.control_panel",
.display_name = "Palette Controls",
.icon = ICON_MD_PALETTE,
.category = "Palette",
.shortcut_hint = "Ctrl+Shift+P",
.visibility_flag = &show_control_panel_,
.priority = 10});
card_registry->RegisterCard({
.card_id = "palette.ow_main",
.display_name = "Overworld Main",
.icon = ICON_MD_LANDSCAPE,
.category = "Palette",
.shortcut_hint = "Ctrl+Alt+1",
.visibility_flag = &show_ow_main_card_,
.priority = 20
});
card_registry->RegisterCard({.card_id = "palette.ow_main",
.display_name = "Overworld Main",
.icon = ICON_MD_LANDSCAPE,
.category = "Palette",
.shortcut_hint = "Ctrl+Alt+1",
.visibility_flag = &show_ow_main_card_,
.priority = 20});
card_registry->RegisterCard({
.card_id = "palette.ow_animated",
.display_name = "Overworld Animated",
.icon = ICON_MD_WATER,
.category = "Palette",
.shortcut_hint = "Ctrl+Alt+2",
.visibility_flag = &show_ow_animated_card_,
.priority = 30
});
card_registry->RegisterCard({.card_id = "palette.ow_animated",
.display_name = "Overworld Animated",
.icon = ICON_MD_WATER,
.category = "Palette",
.shortcut_hint = "Ctrl+Alt+2",
.visibility_flag = &show_ow_animated_card_,
.priority = 30});
card_registry->RegisterCard({
.card_id = "palette.dungeon_main",
.display_name = "Dungeon Main",
.icon = ICON_MD_CASTLE,
.category = "Palette",
.shortcut_hint = "Ctrl+Alt+3",
.visibility_flag = &show_dungeon_main_card_,
.priority = 40
});
card_registry->RegisterCard({.card_id = "palette.dungeon_main",
.display_name = "Dungeon Main",
.icon = ICON_MD_CASTLE,
.category = "Palette",
.shortcut_hint = "Ctrl+Alt+3",
.visibility_flag = &show_dungeon_main_card_,
.priority = 40});
card_registry->RegisterCard({
.card_id = "palette.sprites",
.display_name = "Global Sprite Palettes",
.icon = ICON_MD_PETS,
.category = "Palette",
.shortcut_hint = "Ctrl+Alt+4",
.visibility_flag = &show_sprite_card_,
.priority = 50
});
card_registry->RegisterCard({.card_id = "palette.sprites",
.display_name = "Global Sprite Palettes",
.icon = ICON_MD_PETS,
.category = "Palette",
.shortcut_hint = "Ctrl+Alt+4",
.visibility_flag = &show_sprite_card_,
.priority = 50});
card_registry->RegisterCard({
.card_id = "palette.sprites_aux1",
.display_name = "Sprites Aux 1",
.icon = ICON_MD_FILTER_1,
.category = "Palette",
.shortcut_hint = "Ctrl+Alt+7",
.visibility_flag = &show_sprites_aux1_card_,
.priority = 51
});
card_registry->RegisterCard({.card_id = "palette.sprites_aux1",
.display_name = "Sprites Aux 1",
.icon = ICON_MD_FILTER_1,
.category = "Palette",
.shortcut_hint = "Ctrl+Alt+7",
.visibility_flag = &show_sprites_aux1_card_,
.priority = 51});
card_registry->RegisterCard({
.card_id = "palette.sprites_aux2",
.display_name = "Sprites Aux 2",
.icon = ICON_MD_FILTER_2,
.category = "Palette",
.shortcut_hint = "Ctrl+Alt+8",
.visibility_flag = &show_sprites_aux2_card_,
.priority = 52
});
card_registry->RegisterCard({.card_id = "palette.sprites_aux2",
.display_name = "Sprites Aux 2",
.icon = ICON_MD_FILTER_2,
.category = "Palette",
.shortcut_hint = "Ctrl+Alt+8",
.visibility_flag = &show_sprites_aux2_card_,
.priority = 52});
card_registry->RegisterCard({
.card_id = "palette.sprites_aux3",
.display_name = "Sprites Aux 3",
.icon = ICON_MD_FILTER_3,
.category = "Palette",
.shortcut_hint = "Ctrl+Alt+9",
.visibility_flag = &show_sprites_aux3_card_,
.priority = 53
});
card_registry->RegisterCard({.card_id = "palette.sprites_aux3",
.display_name = "Sprites Aux 3",
.icon = ICON_MD_FILTER_3,
.category = "Palette",
.shortcut_hint = "Ctrl+Alt+9",
.visibility_flag = &show_sprites_aux3_card_,
.priority = 53});
card_registry->RegisterCard({
.card_id = "palette.equipment",
.display_name = "Equipment Palettes",
.icon = ICON_MD_SHIELD,
.category = "Palette",
.shortcut_hint = "Ctrl+Alt+5",
.visibility_flag = &show_equipment_card_,
.priority = 60
});
card_registry->RegisterCard({.card_id = "palette.equipment",
.display_name = "Equipment Palettes",
.icon = ICON_MD_SHIELD,
.category = "Palette",
.shortcut_hint = "Ctrl+Alt+5",
.visibility_flag = &show_equipment_card_,
.priority = 60});
card_registry->RegisterCard({
.card_id = "palette.quick_access",
.display_name = "Quick Access",
.icon = ICON_MD_COLOR_LENS,
.category = "Palette",
.shortcut_hint = "Ctrl+Alt+Q",
.visibility_flag = &show_quick_access_,
.priority = 70
});
card_registry->RegisterCard({.card_id = "palette.quick_access",
.display_name = "Quick Access",
.icon = ICON_MD_COLOR_LENS,
.category = "Palette",
.shortcut_hint = "Ctrl+Alt+Q",
.visibility_flag = &show_quick_access_,
.priority = 70});
card_registry->RegisterCard({.card_id = "palette.custom",
.display_name = "Custom Palette",
.icon = ICON_MD_BRUSH,
.category = "Palette",
.shortcut_hint = "Ctrl+Alt+C",
.visibility_flag = &show_custom_palette_,
.priority = 80});
card_registry->RegisterCard({
.card_id = "palette.custom",
.display_name = "Custom Palette",
.icon = ICON_MD_BRUSH,
.category = "Palette",
.shortcut_hint = "Ctrl+Alt+C",
.visibility_flag = &show_custom_palette_,
.priority = 80
});
// Show control panel by default when Palette Editor is activated
show_control_panel_ = true;
}
@@ -339,7 +320,8 @@ absl::Status PaletteEditor::Update() {
gui::EditorCard loading_card("Palette Editor Loading", ICON_MD_PALETTE);
loading_card.SetDefaultSize(400, 200);
if (loading_card.Begin()) {
ImGui::TextColored(ImVec4(0.5f, 0.5f, 0.5f, 1.0f), "Loading palette data...");
ImGui::TextColored(ImVec4(0.5f, 0.5f, 0.5f, 1.0f),
"Loading palette data...");
ImGui::TextWrapped("Palette cards will appear once ROM data is loaded.");
}
loading_card.End();
@@ -356,11 +338,10 @@ absl::Status PaletteEditor::Update() {
// Draw floating icon button to reopen
ImGui::SetNextWindowPos(ImVec2(10, 100));
ImGui::SetNextWindowSize(ImVec2(50, 50));
ImGuiWindowFlags icon_flags = ImGuiWindowFlags_NoTitleBar |
ImGuiWindowFlags_NoResize |
ImGuiWindowFlags_NoScrollbar |
ImGuiWindowFlags_NoCollapse |
ImGuiWindowFlags_NoDocking;
ImGuiWindowFlags icon_flags =
ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoCollapse |
ImGuiWindowFlags_NoDocking;
if (ImGui::Begin("##PaletteControlIcon", nullptr, icon_flags)) {
if (ImGui::Button(ICON_MD_PALETTE, ImVec2(40, 40))) {
@@ -377,52 +358,68 @@ absl::Status PaletteEditor::Update() {
// Draw all independent palette cards
// Each card has its own show_ flag that needs to be synced with our visibility flags
if (show_ow_main_card_ && ow_main_card_) {
if (!ow_main_card_->IsVisible()) ow_main_card_->Show();
if (!ow_main_card_->IsVisible())
ow_main_card_->Show();
ow_main_card_->Draw();
// Sync back if user closed the card with X button
if (!ow_main_card_->IsVisible()) show_ow_main_card_ = false;
if (!ow_main_card_->IsVisible())
show_ow_main_card_ = false;
}
if (show_ow_animated_card_ && ow_animated_card_) {
if (!ow_animated_card_->IsVisible()) ow_animated_card_->Show();
if (!ow_animated_card_->IsVisible())
ow_animated_card_->Show();
ow_animated_card_->Draw();
if (!ow_animated_card_->IsVisible()) show_ow_animated_card_ = false;
if (!ow_animated_card_->IsVisible())
show_ow_animated_card_ = false;
}
if (show_dungeon_main_card_ && dungeon_main_card_) {
if (!dungeon_main_card_->IsVisible()) dungeon_main_card_->Show();
if (!dungeon_main_card_->IsVisible())
dungeon_main_card_->Show();
dungeon_main_card_->Draw();
if (!dungeon_main_card_->IsVisible()) show_dungeon_main_card_ = false;
if (!dungeon_main_card_->IsVisible())
show_dungeon_main_card_ = false;
}
if (show_sprite_card_ && sprite_card_) {
if (!sprite_card_->IsVisible()) sprite_card_->Show();
if (!sprite_card_->IsVisible())
sprite_card_->Show();
sprite_card_->Draw();
if (!sprite_card_->IsVisible()) show_sprite_card_ = false;
if (!sprite_card_->IsVisible())
show_sprite_card_ = false;
}
if (show_sprites_aux1_card_ && sprites_aux1_card_) {
if (!sprites_aux1_card_->IsVisible()) sprites_aux1_card_->Show();
if (!sprites_aux1_card_->IsVisible())
sprites_aux1_card_->Show();
sprites_aux1_card_->Draw();
if (!sprites_aux1_card_->IsVisible()) show_sprites_aux1_card_ = false;
if (!sprites_aux1_card_->IsVisible())
show_sprites_aux1_card_ = false;
}
if (show_sprites_aux2_card_ && sprites_aux2_card_) {
if (!sprites_aux2_card_->IsVisible()) sprites_aux2_card_->Show();
if (!sprites_aux2_card_->IsVisible())
sprites_aux2_card_->Show();
sprites_aux2_card_->Draw();
if (!sprites_aux2_card_->IsVisible()) show_sprites_aux2_card_ = false;
if (!sprites_aux2_card_->IsVisible())
show_sprites_aux2_card_ = false;
}
if (show_sprites_aux3_card_ && sprites_aux3_card_) {
if (!sprites_aux3_card_->IsVisible()) sprites_aux3_card_->Show();
if (!sprites_aux3_card_->IsVisible())
sprites_aux3_card_->Show();
sprites_aux3_card_->Draw();
if (!sprites_aux3_card_->IsVisible()) show_sprites_aux3_card_ = false;
if (!sprites_aux3_card_->IsVisible())
show_sprites_aux3_card_ = false;
}
if (show_equipment_card_ && equipment_card_) {
if (!equipment_card_->IsVisible()) equipment_card_->Show();
if (!equipment_card_->IsVisible())
equipment_card_->Show();
equipment_card_->Draw();
if (!equipment_card_->IsVisible()) show_equipment_card_ = false;
if (!equipment_card_->IsVisible())
show_equipment_card_ = false;
}
// Draw quick access and custom palette cards
@@ -475,7 +472,8 @@ void PaletteEditor::DrawQuickAccessTab() {
Text("Recently Used Colors");
for (int i = 0; i < recently_used_colors_.size(); i++) {
PushID(i);
if (i % 8 != 0) SameLine();
if (i % 8 != 0)
SameLine();
ImVec4 displayColor =
gui::ConvertSnesColorToImVec4(recently_used_colors_[i]);
if (ImGui::ColorButton("##recent", displayColor)) {
@@ -508,7 +506,8 @@ void PaletteEditor::DrawCustomPalette() {
ImGuiWindowFlags_HorizontalScrollbar)) {
for (int i = 0; i < custom_palette_.size(); i++) {
PushID(i);
if (i > 0) SameLine(0.0f, GetStyle().ItemSpacing.y);
if (i > 0)
SameLine(0.0f, GetStyle().ItemSpacing.y);
// Enhanced color button with context menu and drag-drop support
ImVec4 displayColor = gui::ConvertSnesColorToImVec4(custom_palette_[i]);
@@ -588,7 +587,8 @@ void PaletteEditor::DrawCustomPalette() {
}
}
absl::Status PaletteEditor::DrawPaletteGroup(int category, bool /*right_side*/) {
absl::Status PaletteEditor::DrawPaletteGroup(int category,
bool /*right_side*/) {
if (!rom()->is_loaded()) {
return absl::NotFoundError("ROM not open, no palettes to display");
}
@@ -613,7 +613,8 @@ absl::Status PaletteEditor::DrawPaletteGroup(int category, bool /*right_side*/)
for (int n = 0; n < pal_size; n++) {
PushID(n);
if (n > 0 && n % 8 != 0) SameLine(0.0f, 2.0f);
if (n > 0 && n % 8 != 0)
SameLine(0.0f, 2.0f);
auto popup_id =
absl::StrCat(kPaletteCategoryNames[category].data(), j, "_", n);
@@ -685,22 +686,27 @@ absl::Status PaletteEditor::HandleColorPopup(gfx::SnesPalette& palette, int i,
Separator();
if (Button("Copy as..", ImVec2(-1, 0))) OpenPopup("Copy");
if (Button("Copy as..", ImVec2(-1, 0)))
OpenPopup("Copy");
if (BeginPopup("Copy")) {
CustomFormatString(buf, IM_ARRAYSIZE(buf), "(%.3ff, %.3ff, %.3ff)", col[0],
col[1], col[2]);
if (Selectable(buf)) SetClipboardText(buf);
if (Selectable(buf))
SetClipboardText(buf);
CustomFormatString(buf, IM_ARRAYSIZE(buf), "(%d,%d,%d)", cr, cg, cb);
if (Selectable(buf)) SetClipboardText(buf);
if (Selectable(buf))
SetClipboardText(buf);
CustomFormatString(buf, IM_ARRAYSIZE(buf), "#%02X%02X%02X", cr, cg, cb);
if (Selectable(buf)) SetClipboardText(buf);
if (Selectable(buf))
SetClipboardText(buf);
// SNES Format
CustomFormatString(buf, IM_ARRAYSIZE(buf), "$%04X",
ConvertRgbToSnes(ImVec4(col[0], col[1], col[2], 1.0f)));
if (Selectable(buf)) SetClipboardText(buf);
if (Selectable(buf))
SetClipboardText(buf);
EndPopup();
}
@@ -760,7 +766,8 @@ void PaletteEditor::DrawControlPanel() {
ImGuiWindowFlags flags = ImGuiWindowFlags_None;
if (ImGui::Begin(ICON_MD_PALETTE " Palette Controls", &show_control_panel_, flags)) {
if (ImGui::Begin(ICON_MD_PALETTE " Palette Controls", &show_control_panel_,
flags)) {
// Toolbar with quick toggles
DrawToolset();
@@ -858,8 +865,9 @@ void PaletteEditor::DrawControlPanel() {
size_t modified_count = gfx::PaletteManager::Get().GetModifiedColorCount();
ImGui::BeginDisabled(!has_unsaved);
if (ImGui::Button(absl::StrFormat("Save All (%zu colors)", modified_count).c_str(),
ImVec2(-1, 0))) {
if (ImGui::Button(
absl::StrFormat("Save All (%zu colors)", modified_count).c_str(),
ImVec2(-1, 0))) {
auto status = gfx::PaletteManager::Get().SaveAllToRom();
if (!status.ok()) {
// TODO: Show error toast/notification
@@ -895,7 +903,8 @@ void PaletteEditor::DrawControlPanel() {
ImGuiWindowFlags_AlwaysAutoResize)) {
ImGui::Text("Discard all unsaved changes?");
ImGui::TextColored(ImVec4(1.0f, 0.6f, 0.0f, 1.0f),
"This will revert %zu modified colors.", modified_count);
"This will revert %zu modified colors.",
modified_count);
ImGui::Separator();
if (ImGui::Button("Discard", ImVec2(120, 0))) {
@@ -912,7 +921,8 @@ void PaletteEditor::DrawControlPanel() {
// Error popup for save failures
if (ImGui::BeginPopupModal("SaveError", nullptr,
ImGuiWindowFlags_AlwaysAutoResize)) {
ImGui::TextColored(ImVec4(1.0f, 0.3f, 0.3f, 1.0f), "Failed to save changes");
ImGui::TextColored(ImVec4(1.0f, 0.3f, 0.3f, 1.0f),
"Failed to save changes");
ImGui::Text("An error occurred while saving to ROM.");
ImGui::Separator();
@@ -930,14 +940,15 @@ void PaletteEditor::DrawControlPanel() {
}
if (ImGui::BeginPopup("PaletteCardManager")) {
ImGui::TextColored(ImVec4(0.7f, 0.9f, 1.0f, 1.0f),
"%s Palette Card Manager", ICON_MD_PALETTE);
ImGui::TextColored(ImVec4(0.7f, 0.9f, 1.0f, 1.0f),
"%s Palette Card Manager", ICON_MD_PALETTE);
ImGui::Separator();
// View menu section now handled by EditorCardRegistry in EditorManager
if (!dependencies_.card_registry) return;
if (!dependencies_.card_registry)
return;
auto* card_registry = dependencies_.card_registry;
ImGui::EndPopup();
}
@@ -992,7 +1003,8 @@ void PaletteEditor::DrawQuickAccessCard() {
} else {
for (int i = 0; i < recently_used_colors_.size(); i++) {
PushID(i);
if (i % 8 != 0) SameLine();
if (i % 8 != 0)
SameLine();
ImVec4 displayColor =
gui::ConvertSnesColorToImVec4(recently_used_colors_[i]);
if (ImGui::ColorButton("##recent", displayColor, kPalButtonFlags,
@@ -1011,8 +1023,7 @@ void PaletteEditor::DrawQuickAccessCard() {
}
void PaletteEditor::DrawCustomPaletteCard() {
gui::EditorCard card("Custom Palette", ICON_MD_BRUSH,
&show_custom_palette_);
gui::EditorCard card("Custom Palette", ICON_MD_BRUSH, &show_custom_palette_);
card.SetDefaultSize(420, 200);
card.SetPosition(gui::EditorCard::Position::Bottom);
@@ -1030,13 +1041,14 @@ void PaletteEditor::DrawCustomPaletteCard() {
} else {
for (int i = 0; i < custom_palette_.size(); i++) {
PushID(i);
if (i > 0 && i % 16 != 0) SameLine(0.0f, 2.0f);
if (i > 0 && i % 16 != 0)
SameLine(0.0f, 2.0f);
// Enhanced color button with context menu and drag-drop support
ImVec4 displayColor = gui::ConvertSnesColorToImVec4(custom_palette_[i]);
bool open_color_picker = ImGui::ColorButton(
absl::StrFormat("##customPal%d", i).c_str(), displayColor,
kPalButtonFlags, ImVec2(28, 28));
bool open_color_picker =
ImGui::ColorButton(absl::StrFormat("##customPal%d", i).c_str(),
displayColor, kPalButtonFlags, ImVec2(28, 28));
if (open_color_picker) {
current_color_ = custom_palette_[i];
@@ -1122,7 +1134,8 @@ void PaletteEditor::DrawCustomPaletteCard() {
}
}
void PaletteEditor::JumpToPalette(const std::string& group_name, int palette_index) {
void PaletteEditor::JumpToPalette(const std::string& group_name,
int palette_index) {
// Hide all cards first
show_ow_main_card_ = false;
show_ow_animated_card_ = false;

249
src/app/editor/palette/palette_group_card.cc
View File

@@ -3,8 +3,8 @@
#include <chrono>
#include "absl/strings/str_format.h"
#include "app/gfx/util/palette_manager.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gfx/util/palette_manager.h"
#include "app/gui/core/color.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/layout_helpers.h"
@@ -15,18 +15,15 @@ namespace yaze {
namespace editor {
using namespace yaze::gui;
using gui::DangerButton;
using gui::PrimaryButton;
using gui::SectionHeader;
using gui::ThemedButton;
using gui::ThemedIconButton;
using gui::PrimaryButton;
using gui::DangerButton;
using gui::SectionHeader;
PaletteGroupCard::PaletteGroupCard(const std::string& group_name,
const std::string& display_name,
Rom* rom)
: group_name_(group_name),
display_name_(display_name),
rom_(rom) {
const std::string& display_name, Rom* rom)
: group_name_(group_name), display_name_(display_name), rom_(rom) {
// Note: We can't call GetPaletteGroup() here because it's a pure virtual function
// and the derived class isn't fully constructed yet. Original palettes will be
// loaded on first Draw() call instead.
@@ -46,10 +43,12 @@ void PaletteGroupCard::Draw() {
ImGui::Separator();
// Two-column layout: Grid on left, picker on right
if (ImGui::BeginTable("##PaletteCardLayout", 2,
ImGuiTableFlags_Resizable | ImGuiTableFlags_BordersInnerV)) {
if (ImGui::BeginTable(
"##PaletteCardLayout", 2,
ImGuiTableFlags_Resizable | ImGuiTableFlags_BordersInnerV)) {
ImGui::TableSetupColumn("Grid", ImGuiTableColumnFlags_WidthStretch, 0.6f);
ImGui::TableSetupColumn("Editor", ImGuiTableColumnFlags_WidthStretch, 0.4f);
ImGui::TableSetupColumn("Editor", ImGuiTableColumnFlags_WidthStretch,
0.4f);
ImGui::TableNextRow();
ImGui::TableNextColumn();
@@ -123,7 +122,7 @@ void PaletteGroupCard::DrawToolbar() {
}
}
ImGui::TextColored(ImVec4(1.0f, 0.6f, 0.0f, 1.0f), "%s %zu modified",
ICON_MD_EDIT, modified_count);
ICON_MD_EDIT, modified_count);
}
ImGui::SameLine();
@@ -169,7 +168,8 @@ void PaletteGroupCard::DrawToolbar() {
void PaletteGroupCard::DrawPaletteSelector() {
auto* palette_group = GetPaletteGroup();
if (!palette_group) return;
if (!palette_group)
return;
int num_palettes = palette_group->size();
@@ -177,8 +177,9 @@ void PaletteGroupCard::DrawPaletteSelector() {
ImGui::SameLine();
ImGui::SetNextItemWidth(LayoutHelpers::GetStandardInputWidth());
if (ImGui::BeginCombo("##PaletteSelect",
absl::StrFormat("Palette %d", selected_palette_).c_str())) {
if (ImGui::BeginCombo(
"##PaletteSelect",
absl::StrFormat("Palette %d", selected_palette_).c_str())) {
for (int i = 0; i < num_palettes; i++) {
bool is_selected = (selected_palette_ == i);
bool is_modified = IsPaletteModified(i);
@@ -209,10 +210,12 @@ void PaletteGroupCard::DrawPaletteSelector() {
}
void PaletteGroupCard::DrawColorPicker() {
if (selected_color_ < 0) return;
if (selected_color_ < 0)
return;
auto* palette = GetMutablePalette(selected_palette_);
if (!palette) return;
if (!palette)
return;
SectionHeader("Color Editor");
@@ -223,9 +226,9 @@ void PaletteGroupCard::DrawColorPicker() {
ImVec4 col = ConvertSnesColorToImVec4(editing_color_);
if (ImGui::ColorPicker4("##picker", &col.x,
ImGuiColorEditFlags_NoAlpha |
ImGuiColorEditFlags_PickerHueWheel |
ImGuiColorEditFlags_DisplayRGB |
ImGuiColorEditFlags_DisplayHSV)) {
ImGuiColorEditFlags_PickerHueWheel |
ImGuiColorEditFlags_DisplayRGB |
ImGuiColorEditFlags_DisplayHSV)) {
editing_color_ = ConvertImVec4ToSnesColor(col);
SetColor(selected_palette_, selected_color_, editing_color_);
}
@@ -235,17 +238,18 @@ void PaletteGroupCard::DrawColorPicker() {
ImGui::Text("Current vs Original");
ImGui::ColorButton("##current", col,
ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_NoPicker,
ImVec2(60, 40));
ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_NoPicker,
ImVec2(60, 40));
LayoutHelpers::HelpMarker("Current color being edited");
ImGui::SameLine();
ImVec4 orig_col = ConvertSnesColorToImVec4(original);
if (ImGui::ColorButton("##original", orig_col,
ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_NoPicker,
ImVec2(60, 40))) {
if (ImGui::ColorButton(
"##original", orig_col,
ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_NoPicker,
ImVec2(60, 40))) {
// Click to restore original
editing_color_ = original;
SetColor(selected_palette_, selected_color_, original);
@@ -265,7 +269,8 @@ void PaletteGroupCard::DrawColorPicker() {
}
void PaletteGroupCard::DrawColorInfo() {
if (selected_color_ < 0) return;
if (selected_color_ < 0)
return;
SectionHeader("Color Information");
@@ -284,7 +289,8 @@ void PaletteGroupCard::DrawColorInfo() {
if (show_snes_format_) {
ImGui::Text("SNES BGR555: $%04X", editing_color_.snes());
if (ImGui::IsItemClicked()) {
ImGui::SetClipboardText(absl::StrFormat("$%04X", editing_color_.snes()).c_str());
ImGui::SetClipboardText(
absl::StrFormat("$%04X", editing_color_.snes()).c_str());
}
}
@@ -292,7 +298,8 @@ void PaletteGroupCard::DrawColorInfo() {
if (show_hex_format_) {
ImGui::Text("Hex: #%02X%02X%02X", r, g, b);
if (ImGui::IsItemClicked()) {
ImGui::SetClipboardText(absl::StrFormat("#%02X%02X%02X", r, g, b).c_str());
ImGui::SetClipboardText(
absl::StrFormat("#%02X%02X%02X", r, g, b).c_str());
}
}
@@ -301,7 +308,8 @@ void PaletteGroupCard::DrawColorInfo() {
void PaletteGroupCard::DrawMetadataInfo() {
const auto& metadata = GetMetadata();
if (selected_palette_ >= metadata.palettes.size()) return;
if (selected_palette_ >= metadata.palettes.size())
return;
const auto& pal_meta = metadata.palettes[selected_palette_];
@@ -323,11 +331,11 @@ void PaletteGroupCard::DrawMetadataInfo() {
ImGui::Separator();
// Palette dimensions and color depth
ImGui::Text("Dimensions: %d colors (%dx%d)",
metadata.colors_per_palette,
ImGui::Text("Dimensions: %d colors (%dx%d)", metadata.colors_per_palette,
metadata.colors_per_row,
(metadata.colors_per_palette + metadata.colors_per_row - 1) / metadata.colors_per_row);
(metadata.colors_per_palette + metadata.colors_per_row - 1) /
metadata.colors_per_row);
ImGui::Text("Color Depth: %d BPP (4-bit SNES)", 4);
ImGui::TextDisabled("(16 colors per palette possible)");
@@ -336,7 +344,8 @@ void PaletteGroupCard::DrawMetadataInfo() {
// ROM Address
ImGui::Text("ROM Address: $%06X", pal_meta.rom_address);
if (ImGui::IsItemClicked()) {
ImGui::SetClipboardText(absl::StrFormat("$%06X", pal_meta.rom_address).c_str());
ImGui::SetClipboardText(
absl::StrFormat("$%06X", pal_meta.rom_address).c_str());
}
if (ImGui::IsItemHovered()) {
ImGui::SetTooltip("Click to copy address");
@@ -346,7 +355,8 @@ void PaletteGroupCard::DrawMetadataInfo() {
if (pal_meta.vram_address > 0) {
ImGui::Text("VRAM Address: $%04X", pal_meta.vram_address);
if (ImGui::IsItemClicked()) {
ImGui::SetClipboardText(absl::StrFormat("$%04X", pal_meta.vram_address).c_str());
ImGui::SetClipboardText(
absl::StrFormat("$%04X", pal_meta.vram_address).c_str());
}
if (ImGui::IsItemHovered()) {
ImGui::SetTooltip("Click to copy VRAM address");
@@ -389,10 +399,10 @@ void PaletteGroupCard::DrawBatchOperationsPopup() {
// ========== Palette Operations ==========
void PaletteGroupCard::SetColor(int palette_index, int color_index,
const gfx::SnesColor& new_color) {
const gfx::SnesColor& new_color) {
// Delegate to PaletteManager for centralized tracking and undo/redo
auto status = gfx::PaletteManager::Get().SetColor(group_name_, palette_index,
color_index, new_color);
color_index, new_color);
if (!status.ok()) {
// TODO: Show error notification
return;
@@ -425,7 +435,7 @@ void PaletteGroupCard::ResetPalette(int palette_index) {
void PaletteGroupCard::ResetColor(int palette_index, int color_index) {
// Delegate to PaletteManager for centralized reset operation
gfx::PaletteManager::Get().ResetColor(group_name_, palette_index,
color_index);
color_index);
}
// ========== History Management ==========
@@ -450,14 +460,14 @@ void PaletteGroupCard::ClearHistory() {
bool PaletteGroupCard::IsPaletteModified(int palette_index) const {
// Query PaletteManager for modification status
return gfx::PaletteManager::Get().IsPaletteModified(group_name_,
palette_index);
palette_index);
}
bool PaletteGroupCard::IsColorModified(int palette_index,
int color_index) const {
int color_index) const {
// Query PaletteManager for modification status
return gfx::PaletteManager::Get().IsColorModified(group_name_, palette_index,
color_index);
color_index);
}
bool PaletteGroupCard::HasUnsavedChanges() const {
@@ -486,15 +496,17 @@ gfx::SnesPalette* PaletteGroupCard::GetMutablePalette(int index) {
}
gfx::SnesColor PaletteGroupCard::GetOriginalColor(int palette_index,
int color_index) const {
int color_index) const {
// Get original color from PaletteManager's snapshots
return gfx::PaletteManager::Get().GetColor(group_name_, palette_index,
color_index);
color_index);
}
absl::Status PaletteGroupCard::WriteColorToRom(int palette_index, int color_index,
const gfx::SnesColor& color) {
uint32_t address = gfx::GetPaletteAddress(group_name_, palette_index, color_index);
absl::Status PaletteGroupCard::WriteColorToRom(int palette_index,
int color_index,
const gfx::SnesColor& color) {
uint32_t address =
gfx::GetPaletteAddress(group_name_, palette_index, color_index);
return rom_->WriteColor(address, color);
}
@@ -606,7 +618,8 @@ const gfx::PaletteGroup* OverworldMainPaletteCard::GetPaletteGroup() const {
void OverworldMainPaletteCard::DrawPaletteGrid() {
auto* palette = GetMutablePalette(selected_palette_);
if (!palette) return;
if (!palette)
return;
const float button_size = 32.0f;
const int colors_per_row = GetColorsPerRow();
@@ -618,8 +631,8 @@ void OverworldMainPaletteCard::DrawPaletteGrid() {
ImGui::PushID(i);
if (yaze::gui::PaletteColorButton(absl::StrFormat("##color%d", i).c_str(),
(*palette)[i], is_selected, is_modified,
ImVec2(button_size, button_size))) {
(*palette)[i], is_selected, is_modified,
ImVec2(button_size, button_size))) {
selected_color_ = i;
editing_color_ = (*palette)[i];
}
@@ -654,10 +667,12 @@ PaletteGroupMetadata OverworldAnimatedPaletteCard::InitializeMetadata() {
PaletteMetadata pal;
pal.palette_id = i;
pal.name = anim_names[i];
pal.description = absl::StrFormat("%s animated palette cycle", anim_names[i]);
pal.description =
absl::StrFormat("%s animated palette cycle", anim_names[i]);
pal.rom_address = 0xDE86C + (i * 16);
pal.vram_address = 0;
pal.usage_notes = "These palettes cycle through multiple frames for animation";
pal.usage_notes =
"These palettes cycle through multiple frames for animation";
metadata.palettes.push_back(pal);
}
@@ -669,12 +684,14 @@ gfx::PaletteGroup* OverworldAnimatedPaletteCard::GetPaletteGroup() {
}
const gfx::PaletteGroup* OverworldAnimatedPaletteCard::GetPaletteGroup() const {
return const_cast<Rom*>(rom_)->mutable_palette_group()->get_group("ow_animated");
return const_cast<Rom*>(rom_)->mutable_palette_group()->get_group(
"ow_animated");
}
void OverworldAnimatedPaletteCard::DrawPaletteGrid() {
auto* palette = GetMutablePalette(selected_palette_);
if (!palette) return;
if (!palette)
return;
const float button_size = 32.0f;
const int colors_per_row = GetColorsPerRow();
@@ -686,8 +703,8 @@ void OverworldAnimatedPaletteCard::DrawPaletteGrid() {
ImGui::PushID(i);
if (yaze::gui::PaletteColorButton(absl::StrFormat("##color%d", i).c_str(),
(*palette)[i], is_selected, is_modified,
ImVec2(button_size, button_size))) {
(*palette)[i], is_selected, is_modified,
ImVec2(button_size, button_size))) {
selected_color_ = i;
editing_color_ = (*palette)[i];
}
@@ -717,12 +734,11 @@ PaletteGroupMetadata DungeonMainPaletteCard::InitializeMetadata() {
// Dungeon palettes (0-19)
const char* dungeon_names[] = {
"Sewers", "Hyrule Castle", "Eastern Palace", "Desert Palace",
"Agahnim's Tower", "Swamp Palace", "Palace of Darkness", "Misery Mire",
"Skull Woods", "Ice Palace", "Tower of Hera", "Thieves' Town",
"Turtle Rock", "Ganon's Tower", "Generic 1", "Generic 2",
"Generic 3", "Generic 4", "Generic 5", "Generic 6"
};
"Sewers", "Hyrule Castle", "Eastern Palace", "Desert Palace",
"Agahnim's Tower", "Swamp Palace", "Palace of Darkness", "Misery Mire",
"Skull Woods", "Ice Palace", "Tower of Hera", "Thieves' Town",
"Turtle Rock", "Ganon's Tower", "Generic 1", "Generic 2",
"Generic 3", "Generic 4", "Generic 5", "Generic 6"};
for (int i = 0; i < 20; i++) {
PaletteMetadata pal;
@@ -743,12 +759,14 @@ gfx::PaletteGroup* DungeonMainPaletteCard::GetPaletteGroup() {
}
const gfx::PaletteGroup* DungeonMainPaletteCard::GetPaletteGroup() const {
return const_cast<Rom*>(rom_)->mutable_palette_group()->get_group("dungeon_main");
return const_cast<Rom*>(rom_)->mutable_palette_group()->get_group(
"dungeon_main");
}
void DungeonMainPaletteCard::DrawPaletteGrid() {
auto* palette = GetMutablePalette(selected_palette_);
if (!palette) return;
if (!palette)
return;
const float button_size = 28.0f;
const int colors_per_row = GetColorsPerRow();
@@ -760,8 +778,8 @@ void DungeonMainPaletteCard::DrawPaletteGrid() {
ImGui::PushID(i);
if (yaze::gui::PaletteColorButton(absl::StrFormat("##color%d", i).c_str(),
(*palette)[i], is_selected, is_modified,
ImVec2(button_size, button_size))) {
(*palette)[i], is_selected, is_modified,
ImVec2(button_size, button_size))) {
selected_color_ = i;
editing_color_ = (*palette)[i];
}
@@ -786,24 +804,26 @@ PaletteGroupMetadata SpritePaletteCard::InitializeMetadata() {
PaletteGroupMetadata metadata;
metadata.group_name = "global_sprites";
metadata.display_name = "Global Sprite Palettes";
metadata.colors_per_palette = 60; // 60 colors: 4 rows of 16 colors (with transparent at 0, 16, 32, 48)
metadata.colors_per_row = 16; // Display in 16-color rows
metadata.colors_per_palette =
60; // 60 colors: 4 rows of 16 colors (with transparent at 0, 16, 32, 48)
metadata.colors_per_row = 16; // Display in 16-color rows
// 2 palette sets: Light World and Dark World
const char* sprite_names[] = {
"Global Sprites (Light World)",
"Global Sprites (Dark World)"
};
const char* sprite_names[] = {"Global Sprites (Light World)",
"Global Sprites (Dark World)"};
for (int i = 0; i < 2; i++) {
PaletteMetadata pal;
pal.palette_id = i;
pal.name = sprite_names[i];
pal.description = "60 colors = 4 sprite sub-palettes (rows) with transparent at 0, 16, 32, 48";
pal.description =
"60 colors = 4 sprite sub-palettes (rows) with transparent at 0, 16, "
"32, 48";
pal.rom_address = (i == 0) ? 0xDD218 : 0xDD290; // LW or DW address
pal.vram_address = 0; // Loaded dynamically
pal.usage_notes = "4 sprite sub-palettes of 15 colors + transparent each. "
"Row 0: colors 0-15, Row 1: 16-31, Row 2: 32-47, Row 3: 48-59";
pal.vram_address = 0; // Loaded dynamically
pal.usage_notes =
"4 sprite sub-palettes of 15 colors + transparent each. "
"Row 0: colors 0-15, Row 1: 16-31, Row 2: 32-47, Row 3: 48-59";
metadata.palettes.push_back(pal);
}
@@ -815,12 +835,14 @@ gfx::PaletteGroup* SpritePaletteCard::GetPaletteGroup() {
}
const gfx::PaletteGroup* SpritePaletteCard::GetPaletteGroup() const {
return const_cast<Rom*>(rom_)->mutable_palette_group()->get_group("global_sprites");
return const_cast<Rom*>(rom_)->mutable_palette_group()->get_group(
"global_sprites");
}
void SpritePaletteCard::DrawPaletteGrid() {
auto* palette = GetMutablePalette(selected_palette_);
if (!palette) return;
if (!palette)
return;
const float button_size = 28.0f;
const int colors_per_row = GetColorsPerRow();
@@ -836,8 +858,8 @@ void SpritePaletteCard::DrawPaletteGrid() {
if (is_transparent_slot) {
ImGui::BeginGroup();
if (yaze::gui::PaletteColorButton(absl::StrFormat("##color%d", i).c_str(),
(*palette)[i], is_selected, is_modified,
ImVec2(button_size, button_size))) {
(*palette)[i], is_selected, is_modified,
ImVec2(button_size, button_size))) {
selected_color_ = i;
editing_color_ = (*palette)[i];
}
@@ -847,14 +869,15 @@ void SpritePaletteCard::DrawPaletteGrid() {
ImVec2(pos.x + button_size / 2 - 4, pos.y + button_size / 2 - 8),
IM_COL32(255, 255, 255, 200), "T");
ImGui::EndGroup();
if (ImGui::IsItemHovered()) {
ImGui::SetTooltip("Transparent color slot for sprite sub-palette %d", i / 16);
ImGui::SetTooltip("Transparent color slot for sprite sub-palette %d",
i / 16);
}
} else {
if (yaze::gui::PaletteColorButton(absl::StrFormat("##color%d", i).c_str(),
(*palette)[i], is_selected, is_modified,
ImVec2(button_size, button_size))) {
(*palette)[i], is_selected, is_modified,
ImVec2(button_size, button_size))) {
selected_color_ = i;
editing_color_ = (*palette)[i];
}
@@ -877,8 +900,9 @@ void SpritePaletteCard::DrawCustomPanels() {
const auto& pal_meta = metadata.palettes[selected_palette_];
ImGui::TextWrapped("This sprite palette is loaded to VRAM address $%04X",
pal_meta.vram_address);
ImGui::TextDisabled("VRAM palettes are used by the SNES PPU for sprite rendering");
pal_meta.vram_address);
ImGui::TextDisabled(
"VRAM palettes are used by the SNES PPU for sprite rendering");
}
}
@@ -923,7 +947,8 @@ const gfx::PaletteGroup* EquipmentPaletteCard::GetPaletteGroup() const {
void EquipmentPaletteCard::DrawPaletteGrid() {
auto* palette = GetMutablePalette(selected_palette_);
if (!palette) return;
if (!palette)
return;
const float button_size = 32.0f;
const int colors_per_row = GetColorsPerRow();
@@ -935,8 +960,8 @@ void EquipmentPaletteCard::DrawPaletteGrid() {
ImGui::PushID(i);
if (yaze::gui::PaletteColorButton(absl::StrFormat("##color%d", i).c_str(),
(*palette)[i], is_selected, is_modified,
ImVec2(button_size, button_size))) {
(*palette)[i], is_selected, is_modified,
ImVec2(button_size, button_size))) {
selected_color_ = i;
editing_color_ = (*palette)[i];
}
@@ -983,12 +1008,14 @@ gfx::PaletteGroup* SpritesAux1PaletteCard::GetPaletteGroup() {
}
const gfx::PaletteGroup* SpritesAux1PaletteCard::GetPaletteGroup() const {
return const_cast<Rom*>(rom_)->mutable_palette_group()->get_group("sprites_aux1");
return const_cast<Rom*>(rom_)->mutable_palette_group()->get_group(
"sprites_aux1");
}
void SpritesAux1PaletteCard::DrawPaletteGrid() {
auto* palette = GetMutablePalette(selected_palette_);
if (!palette) return;
if (!palette)
return;
const float button_size = 32.0f;
const int colors_per_row = GetColorsPerRow();
@@ -999,12 +1026,12 @@ void SpritesAux1PaletteCard::DrawPaletteGrid() {
ImGui::PushID(i);
if (yaze::gui::PaletteColorButton(absl::StrFormat("##color%d", i).c_str(),
(*palette)[i], is_selected, is_modified,
ImVec2(button_size, button_size))) {
selected_color_ = i;
editing_color_ = (*palette)[i];
}
if (yaze::gui::PaletteColorButton(absl::StrFormat("##color%d", i).c_str(),
(*palette)[i], is_selected, is_modified,
ImVec2(button_size, button_size))) {
selected_color_ = i;
editing_color_ = (*palette)[i];
}
ImGui::PopID();
@@ -1048,12 +1075,14 @@ gfx::PaletteGroup* SpritesAux2PaletteCard::GetPaletteGroup() {
}
const gfx::PaletteGroup* SpritesAux2PaletteCard::GetPaletteGroup() const {
return const_cast<Rom*>(rom_)->mutable_palette_group()->get_group("sprites_aux2");
return const_cast<Rom*>(rom_)->mutable_palette_group()->get_group(
"sprites_aux2");
}
void SpritesAux2PaletteCard::DrawPaletteGrid() {
auto* palette = GetMutablePalette(selected_palette_);
if (!palette) return;
if (!palette)
return;
const float button_size = 32.0f;
const int colors_per_row = GetColorsPerRow();
@@ -1068,8 +1097,8 @@ void SpritesAux2PaletteCard::DrawPaletteGrid() {
if (i == 0) {
ImGui::BeginGroup();
if (yaze::gui::PaletteColorButton(absl::StrFormat("##color%d", i).c_str(),
(*palette)[i], is_selected, is_modified,
ImVec2(button_size, button_size))) {
(*palette)[i], is_selected, is_modified,
ImVec2(button_size, button_size))) {
selected_color_ = i;
editing_color_ = (*palette)[i];
}
@@ -1081,8 +1110,8 @@ void SpritesAux2PaletteCard::DrawPaletteGrid() {
ImGui::EndGroup();
} else {
if (yaze::gui::PaletteColorButton(absl::StrFormat("##color%d", i).c_str(),
(*palette)[i], is_selected, is_modified,
ImVec2(button_size, button_size))) {
(*palette)[i], is_selected, is_modified,
ImVec2(button_size, button_size))) {
selected_color_ = i;
editing_color_ = (*palette)[i];
}
@@ -1130,12 +1159,14 @@ gfx::PaletteGroup* SpritesAux3PaletteCard::GetPaletteGroup() {
}
const gfx::PaletteGroup* SpritesAux3PaletteCard::GetPaletteGroup() const {
return const_cast<Rom*>(rom_)->mutable_palette_group()->get_group("sprites_aux3");
return const_cast<Rom*>(rom_)->mutable_palette_group()->get_group(
"sprites_aux3");
}
void SpritesAux3PaletteCard::DrawPaletteGrid() {
auto* palette = GetMutablePalette(selected_palette_);
if (!palette) return;
if (!palette)
return;
const float button_size = 32.0f;
const int colors_per_row = GetColorsPerRow();
@@ -1150,8 +1181,8 @@ void SpritesAux3PaletteCard::DrawPaletteGrid() {
if (i == 0) {
ImGui::BeginGroup();
if (yaze::gui::PaletteColorButton(absl::StrFormat("##color%d", i).c_str(),
(*palette)[i], is_selected, is_modified,
ImVec2(button_size, button_size))) {
(*palette)[i], is_selected, is_modified,
ImVec2(button_size, button_size))) {
selected_color_ = i;
editing_color_ = (*palette)[i];
}
@@ -1163,8 +1194,8 @@ void SpritesAux3PaletteCard::DrawPaletteGrid() {
ImGui::EndGroup();
} else {
if (yaze::gui::PaletteColorButton(absl::StrFormat("##color%d", i).c_str(),
(*palette)[i], is_selected, is_modified,
ImVec2(button_size, button_size))) {
(*palette)[i], is_selected, is_modified,
ImVec2(button_size, button_size))) {
selected_color_ = i;
editing_color_ = (*palette)[i];
}

42
src/app/editor/palette/palette_group_card.h
View File

@@ -32,23 +32,23 @@ struct ColorChange {
* @brief Metadata for a single palette in a group
*/
struct PaletteMetadata {
int palette_id; // Palette ID in ROM
std::string name; // Display name (e.g., "Light World Main")
std::string description; // Usage description
uint32_t rom_address; // Base ROM address for this palette
uint32_t vram_address; // VRAM address (for sprite palettes, 0 if N/A)
std::string usage_notes; // Additional usage information
int palette_id; // Palette ID in ROM
std::string name; // Display name (e.g., "Light World Main")
std::string description; // Usage description
uint32_t rom_address; // Base ROM address for this palette
uint32_t vram_address; // VRAM address (for sprite palettes, 0 if N/A)
std::string usage_notes; // Additional usage information
};
/**
* @brief Metadata for an entire palette group
*/
struct PaletteGroupMetadata {
std::string group_name; // Internal group name
std::string display_name; // Display name for UI
std::string group_name; // Internal group name
std::string display_name; // Display name for UI
std::vector<PaletteMetadata> palettes; // Metadata for each palette
int colors_per_palette; // Number of colors per palette (usually 8 or 16)
int colors_per_row; // Colors per row for grid layout
int colors_per_palette; // Number of colors per palette (usually 8 or 16)
int colors_per_row; // Colors per row for grid layout
};
/**
@@ -73,8 +73,7 @@ class PaletteGroupCard {
* @param rom ROM instance for reading/writing palettes
*/
PaletteGroupCard(const std::string& group_name,
const std::string& display_name,
Rom* rom);
const std::string& display_name, Rom* rom);
virtual ~PaletteGroupCard() = default;
@@ -117,7 +116,8 @@ class PaletteGroupCard {
/**
* @brief Set a color value (records change for undo)
*/
void SetColor(int palette_index, int color_index, const gfx::SnesColor& new_color);
void SetColor(int palette_index, int color_index,
const gfx::SnesColor& new_color);
// ========== History Management ==========
@@ -231,7 +231,7 @@ class PaletteGroupCard {
* @brief Write a single color to ROM
*/
absl::Status WriteColorToRom(int palette_index, int color_index,
const gfx::SnesColor& color);
const gfx::SnesColor& color);
/**
* @brief Mark palette as modified
@@ -245,15 +245,15 @@ class PaletteGroupCard {
// ========== Member Variables ==========
std::string group_name_; // Internal name (e.g., "ow_main")
std::string display_name_; // Display name (e.g., "Overworld Main")
Rom* rom_; // ROM instance
bool show_ = false; // Visibility flag
std::string group_name_; // Internal name (e.g., "ow_main")
std::string display_name_; // Display name (e.g., "Overworld Main")
Rom* rom_; // ROM instance
bool show_ = false; // Visibility flag
// Selection state
int selected_palette_ = 0; // Currently selected palette index
int selected_color_ = -1; // Currently selected color (-1 = none)
gfx::SnesColor editing_color_; // Color being edited in picker
int selected_palette_ = 0; // Currently selected palette index
int selected_color_ = -1; // Currently selected color (-1 = none)
gfx::SnesColor editing_color_; // Color being edited in picker
// Settings
bool auto_save_enabled_ = false; // Auto-save to ROM on every change

84
src/app/editor/palette/palette_utility.cc
View File

@@ -15,16 +15,16 @@ bool DrawPaletteJumpButton(const char* label, const std::string& group_name,
int palette_index, PaletteEditor* editor) {
bool clicked = ImGui::SmallButton(
absl::StrFormat("%s %s", ICON_MD_PALETTE, label).c_str());
if (ImGui::IsItemHovered()) {
ImGui::SetTooltip("Jump to palette editor:\n%s - Palette %d",
group_name.c_str(), palette_index);
ImGui::SetTooltip("Jump to palette editor:\n%s - Palette %d",
group_name.c_str(), palette_index);
}
if (clicked && editor) {
editor->JumpToPalette(group_name, palette_index);
}
return clicked;
}
@@ -32,17 +32,17 @@ bool DrawInlineColorEdit(const char* label, gfx::SnesColor* color,
const std::string& group_name, int palette_index,
int color_index, PaletteEditor* editor) {
ImGui::PushID(label);
// Draw color button
ImVec4 col = gui::ConvertSnesColorToImVec4(*color);
bool changed = ImGui::ColorEdit4(label, &col.x,
ImGuiColorEditFlags_NoInputs |
ImGuiColorEditFlags_NoLabel);
bool changed = ImGui::ColorEdit4(
label, &col.x,
ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_NoLabel);
if (changed) {
*color = gui::ConvertImVec4ToSnesColor(col);
}
// Draw jump button
ImGui::SameLine();
ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.0f, 0.0f, 0.0f, 0.0f));
@@ -52,16 +52,16 @@ bool DrawInlineColorEdit(const char* label, gfx::SnesColor* color,
}
}
ImGui::PopStyleColor();
if (ImGui::IsItemHovered()) {
ImGui::BeginTooltip();
ImGui::Text("Jump to Palette Editor");
ImGui::TextDisabled("%s - Palette %d, Color %d",
group_name.c_str(), palette_index, color_index);
ImGui::TextDisabled("%s - Palette %d, Color %d", group_name.c_str(),
palette_index, color_index);
DrawColorInfoTooltip(*color);
ImGui::EndTooltip();
}
ImGui::PopID();
return changed;
}
@@ -70,20 +70,22 @@ bool DrawPaletteIdSelector(const char* label, int* palette_id,
const std::string& group_name,
PaletteEditor* editor) {
ImGui::PushID(label);
// Draw combo box
bool changed = ImGui::InputInt(label, palette_id);
// Clamp to valid range (0-255 typically)
if (*palette_id < 0) *palette_id = 0;
if (*palette_id > 255) *palette_id = 255;
if (*palette_id < 0)
*palette_id = 0;
if (*palette_id > 255)
*palette_id = 255;
// Draw jump button
ImGui::SameLine();
if (DrawPaletteJumpButton("Jump", group_name, *palette_id, editor)) {
// Button clicked, editor will handle jump
}
ImGui::PopID();
return changed;
}
@@ -91,52 +93,49 @@ bool DrawPaletteIdSelector(const char* label, int* palette_id,
void DrawColorInfoTooltip(const gfx::SnesColor& color) {
auto rgb = color.rgb();
ImGui::Separator();
ImGui::Text("RGB: (%d, %d, %d)",
static_cast<int>(rgb.x),
static_cast<int>(rgb.y),
static_cast<int>(rgb.z));
ImGui::Text("RGB: (%d, %d, %d)", static_cast<int>(rgb.x),
static_cast<int>(rgb.y), static_cast<int>(rgb.z));
ImGui::Text("SNES: $%04X", color.snes());
ImGui::Text("Hex: #%02X%02X%02X",
static_cast<int>(rgb.x),
static_cast<int>(rgb.y),
static_cast<int>(rgb.z));
ImGui::Text("Hex: #%02X%02X%02X", static_cast<int>(rgb.x),
static_cast<int>(rgb.y), static_cast<int>(rgb.z));
}
void DrawPalettePreview(const std::string& group_name, int palette_index,
Rom* rom) {
Rom* rom) {
if (!rom || !rom->is_loaded()) {
ImGui::TextDisabled("(ROM not loaded)");
return;
}
auto* group = rom->mutable_palette_group()->get_group(group_name);
if (!group || palette_index >= group->size()) {
ImGui::TextDisabled("(Palette not found)");
return;
}
auto palette = group->palette(palette_index);
// Draw colors in a row
int preview_size = std::min(8, static_cast<int>(palette.size()));
for (int i = 0; i < preview_size; i++) {
if (i > 0) ImGui::SameLine();
if (i > 0)
ImGui::SameLine();
ImGui::PushID(i);
ImVec4 col = gui::ConvertSnesColorToImVec4(palette[i]);
ImGui::ColorButton("##preview", col,
ImGuiColorEditFlags_NoAlpha |
ImGuiColorEditFlags_NoPicker |
ImGuiColorEditFlags_NoTooltip,
ImVec2(16, 16));
ImGui::ColorButton("##preview", col,
ImGuiColorEditFlags_NoAlpha |
ImGuiColorEditFlags_NoPicker |
ImGuiColorEditFlags_NoTooltip,
ImVec2(16, 16));
if (ImGui::IsItemHovered()) {
ImGui::BeginTooltip();
ImGui::Text("Color %d", i);
DrawColorInfoTooltip(palette[i]);
ImGui::EndTooltip();
}
ImGui::PopID();
}
}
@@ -144,4 +143,3 @@ void DrawPalettePreview(const std::string& group_name, int palette_index,
} // namespace palette_utility
} // namespace editor
} // namespace yaze

5
src/app/editor/palette/palette_utility.h
View File

@@ -5,8 +5,8 @@
#include "app/gfx/types/snes_color.h"
#include "app/gui/core/color.h"
#include "imgui/imgui.h"
#include "app/rom.h"
#include "imgui/imgui.h"
namespace yaze {
namespace editor {
@@ -68,7 +68,7 @@ void DrawColorInfoTooltip(const gfx::SnesColor& color);
* @param rom ROM instance to read palette from
*/
void DrawPalettePreview(const std::string& group_name, int palette_index,
class Rom* rom);
class Rom* rom);
} // namespace palette_utility
@@ -76,4 +76,3 @@ void DrawPalettePreview(const std::string& group_name, int palette_index,
} // namespace yaze
#endif // YAZE_APP_EDITOR_PALETTE_UTILITY_H

4
src/app/editor/session_types.cc
View File

@@ -1,7 +1,7 @@
#include "app/editor/session_types.h"
#include "app/editor/editor.h" // For EditorDependencies, needed by ApplyDependencies
#include "app/editor/system/user_settings.h" // For UserSettings forward decl in header
#include "app/editor/editor.h" // For EditorDependencies, needed by ApplyDependencies
#include "app/editor/system/user_settings.h" // For UserSettings forward decl in header
namespace yaze::editor {

2
src/app/editor/session_types.h
View File

@@ -1,7 +1,6 @@
#ifndef YAZE_APP_EDITOR_SESSION_TYPES_H_
#define YAZE_APP_EDITOR_SESSION_TYPES_H_
#include "core/features.h"
#include "app/editor/code/assembly_editor.h"
#include "app/editor/code/memory_editor.h"
#include "app/editor/dungeon/dungeon_editor_v2.h"
@@ -14,6 +13,7 @@
#include "app/editor/sprite/sprite_editor.h"
#include "app/editor/system/settings_editor.h"
#include "app/rom.h"
#include "core/features.h"
#include <string>
#include <vector>

50
src/app/editor/sprite/sprite_editor.cc
View File

@@ -1,15 +1,15 @@
#include "sprite_editor.h"
#include "app/editor/system/editor_card_registry.h"
#include "app/gfx/debug/performance/performance_profiler.h"
#include "app/gui/core/ui_helpers.h"
#include "util/file_util.h"
#include "app/editor/sprite/zsprite.h"
#include "app/gfx/debug/performance/performance_profiler.h"
#include "app/gfx/resource/arena.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/input.h"
#include "zelda3/sprite/sprite.h"
#include "app/gui/core/ui_helpers.h"
#include "util/file_util.h"
#include "util/hex.h"
#include "zelda3/sprite/sprite.h"
namespace yaze {
namespace editor {
@@ -26,23 +26,30 @@ using ImGui::TableSetupColumn;
using ImGui::Text;
void SpriteEditor::Initialize() {
if (!dependencies_.card_registry) return;
if (!dependencies_.card_registry)
return;
auto* card_registry = dependencies_.card_registry;
card_registry->RegisterCard({.card_id = "sprite.vanilla_editor", .display_name = "Vanilla Sprites",
.icon = ICON_MD_SMART_TOY, .category = "Sprite",
.shortcut_hint = "Alt+Shift+1", .priority = 10});
card_registry->RegisterCard({.card_id = "sprite.custom_editor", .display_name = "Custom Sprites",
.icon = ICON_MD_ADD_CIRCLE, .category = "Sprite",
.shortcut_hint = "Alt+Shift+2", .priority = 20});
card_registry->RegisterCard({.card_id = "sprite.vanilla_editor",
.display_name = "Vanilla Sprites",
.icon = ICON_MD_SMART_TOY,
.category = "Sprite",
.shortcut_hint = "Alt+Shift+1",
.priority = 10});
card_registry->RegisterCard({.card_id = "sprite.custom_editor",
.display_name = "Custom Sprites",
.icon = ICON_MD_ADD_CIRCLE,
.category = "Sprite",
.shortcut_hint = "Alt+Shift+2",
.priority = 20});
// Show vanilla editor by default
card_registry->ShowCard("sprite.vanilla_editor");
}
absl::Status SpriteEditor::Load() {
absl::Status SpriteEditor::Load() {
gfx::ScopedTimer timer("SpriteEditor::Load");
return absl::OkStatus();
return absl::OkStatus();
}
absl::Status SpriteEditor::Update() {
@@ -50,7 +57,8 @@ absl::Status SpriteEditor::Update() {
sheets_loaded_ = true;
}
if (!dependencies_.card_registry) return absl::OkStatus();
if (!dependencies_.card_registry)
return absl::OkStatus();
auto* card_registry = dependencies_.card_registry;
static gui::EditorCard vanilla_card("Vanilla Sprites", ICON_MD_SMART_TOY);
@@ -60,7 +68,8 @@ absl::Status SpriteEditor::Update() {
custom_card.SetDefaultSize(800, 600);
// Vanilla Sprites Card - Check visibility flag exists and is true before rendering
bool* vanilla_visible = card_registry->GetVisibilityFlag("sprite.vanilla_editor");
bool* vanilla_visible =
card_registry->GetVisibilityFlag("sprite.vanilla_editor");
if (vanilla_visible && *vanilla_visible) {
if (vanilla_card.Begin(vanilla_visible)) {
DrawVanillaSpriteEditor();
@@ -69,7 +78,8 @@ absl::Status SpriteEditor::Update() {
}
// Custom Sprites Card - Check visibility flag exists and is true before rendering
bool* custom_visible = card_registry->GetVisibilityFlag("sprite.custom_editor");
bool* custom_visible =
card_registry->GetVisibilityFlag("sprite.custom_editor");
if (custom_visible && *custom_visible) {
if (custom_card.Begin(custom_visible)) {
DrawCustomSprites();
@@ -85,7 +95,6 @@ void SpriteEditor::DrawToolset() {
// This method kept for compatibility but sidebar handles card toggles
}
void SpriteEditor::DrawVanillaSpriteEditor() {
if (ImGui::BeginTable("##SpriteCanvasTable", 3, ImGuiTableFlags_Resizable,
ImVec2(0, 0))) {
@@ -212,7 +221,8 @@ void SpriteEditor::DrawCurrentSheets() {
for (int i = 0; i < 8; i++) {
std::string sheet_label = absl::StrFormat("Sheet %d", i);
gui::InputHexByte(sheet_label.c_str(), &current_sheets_[i]);
if (i % 2 == 0) ImGui::SameLine();
if (i % 2 == 0)
ImGui::SameLine();
}
graphics_sheet_canvas_.DrawBackground();

2
src/app/editor/sprite/sprite_editor.h
View File

@@ -7,8 +7,8 @@
#include "absl/status/status.h"
#include "app/editor/editor.h"
#include "app/editor/sprite/zsprite.h"
#include "app/gui/canvas/canvas.h"
#include "app/gui/app/editor_layout.h"
#include "app/gui/canvas/canvas.h"
#include "app/rom.h"
namespace yaze {

50
src/app/editor/system/command_manager.cc
View File

@@ -8,7 +8,6 @@
namespace yaze {
namespace editor {
// When the player presses Space, a popup will appear fixed to the bottom of the
// ImGui window with a list of the available key commands which can be used.
void CommandManager::ShowWhichKey() {
@@ -39,23 +38,23 @@ void CommandManager::ShowWhichKey() {
if (ImGui::BeginTable("CommandsTable", commands_.size(),
ImGuiTableFlags_SizingStretchProp)) {
for (const auto &[shortcut, group] : commands_) {
ImGui::TableNextColumn();
ImGui::TextColored(colors[colorIndex], "%c: %s",
group.main_command.mnemonic,
group.main_command.name.c_str());
colorIndex = (colorIndex + 1) % numColors;
}
for (const auto& [shortcut, group] : commands_) {
ImGui::TableNextColumn();
ImGui::TextColored(colors[colorIndex], "%c: %s",
group.main_command.mnemonic,
group.main_command.name.c_str());
colorIndex = (colorIndex + 1) % numColors;
}
ImGui::EndTable();
}
ImGui::EndPopup();
}
}
void CommandManager::SaveKeybindings(const std::string &filepath) {
void CommandManager::SaveKeybindings(const std::string& filepath) {
std::ofstream out(filepath);
if (out.is_open()) {
for (const auto &[shortcut, group] : commands_) {
for (const auto& [shortcut, group] : commands_) {
out << shortcut << " " << group.main_command.mnemonic << " "
<< group.main_command.name << " " << group.main_command.desc << "\n";
}
@@ -63,7 +62,7 @@ void CommandManager::SaveKeybindings(const std::string &filepath) {
}
}
void CommandManager::LoadKeybindings(const std::string &filepath) {
void CommandManager::LoadKeybindings(const std::string& filepath) {
std::ifstream in(filepath);
if (in.is_open()) {
commands_.clear();
@@ -116,8 +115,8 @@ void CommandManager::ShowWhichKeyHierarchical() {
// Show breadcrumb navigation
if (!current_prefix_.empty()) {
ImGui::TextColored(ImVec4(0.5f, 0.8f, 1.0f, 1.0f),
"Space > %s", current_prefix_.c_str());
ImGui::TextColored(ImVec4(0.5f, 0.8f, 1.0f, 1.0f), "Space > %s",
current_prefix_.c_str());
ImGui::Separator();
} else {
ImGui::TextColored(ImVec4(0.5f, 0.8f, 1.0f, 1.0f), "Space > ...");
@@ -137,14 +136,14 @@ void CommandManager::ShowWhichKeyHierarchical() {
// Show commands based on current navigation level
if (current_prefix_.empty()) {
// Root level - show main groups
if (ImGui::BeginTable("RootCommands", 6, ImGuiTableFlags_SizingStretchProp)) {
if (ImGui::BeginTable("RootCommands", 6,
ImGuiTableFlags_SizingStretchProp)) {
int colorIndex = 0;
for (const auto &[shortcut, group] : commands_) {
for (const auto& [shortcut, group] : commands_) {
ImGui::TableNextColumn();
ImGui::TextColored(colors[colorIndex % 6],
"%c: %s",
group.main_command.mnemonic,
group.main_command.name.c_str());
ImGui::TextColored(colors[colorIndex % 6], "%c: %s",
group.main_command.mnemonic,
group.main_command.name.c_str());
colorIndex++;
}
ImGui::EndTable();
@@ -156,15 +155,13 @@ void CommandManager::ShowWhichKeyHierarchical() {
const auto& group = it->second;
if (!group.subcommands.empty()) {
if (ImGui::BeginTable("Subcommands",
std::min(6, (int)group.subcommands.size()),
ImGuiTableFlags_SizingStretchProp)) {
std::min(6, (int)group.subcommands.size()),
ImGuiTableFlags_SizingStretchProp)) {
int colorIndex = 0;
for (const auto& [key, cmd] : group.subcommands) {
ImGui::TableNextColumn();
ImGui::TextColored(colors[colorIndex % 6],
"%c: %s",
cmd.mnemonic,
cmd.name.c_str());
ImGui::TextColored(colors[colorIndex % 6], "%c: %s", cmd.mnemonic,
cmd.name.c_str());
colorIndex++;
}
ImGui::EndTable();
@@ -184,7 +181,8 @@ void CommandManager::ShowWhichKeyHierarchical() {
// Handle keyboard input for WhichKey navigation
void CommandManager::HandleWhichKeyInput() {
if (!whichkey_active_) return;
if (!whichkey_active_)
return;
// Check for prefix keys (w, l, f, b, s, t, etc.)
for (const auto& [shortcut, group] : commands_) {

37
src/app/editor/system/command_manager.h
View File

@@ -28,8 +28,8 @@ class CommandManager {
char mnemonic;
std::string name;
std::string desc;
CommandInfo(Command command, char mnemonic, const std::string &name,
const std::string &desc)
CommandInfo(Command command, char mnemonic, const std::string& name,
const std::string& desc)
: command(std::move(command)),
mnemonic(mnemonic),
name(name),
@@ -41,30 +41,32 @@ class CommandManager {
struct CommandGroup {
CommandInfo main_command;
std::unordered_map<std::string, CommandInfo> subcommands;
CommandGroup() = default;
CommandGroup(CommandInfo main) : main_command(std::move(main)) {}
};
void RegisterPrefix(const std::string &group_name, const char prefix,
const std::string &name, const std::string &desc) {
void RegisterPrefix(const std::string& group_name, const char prefix,
const std::string& name, const std::string& desc) {
commands_[group_name].main_command = {nullptr, prefix, name, desc};
}
void RegisterSubcommand(const std::string &group_name,
const std::string &shortcut, const char mnemonic,
const std::string &name, const std::string &desc,
void RegisterSubcommand(const std::string& group_name,
const std::string& shortcut, const char mnemonic,
const std::string& name, const std::string& desc,
Command command) {
commands_[group_name].subcommands[shortcut] = {command, mnemonic, name, desc};
commands_[group_name].subcommands[shortcut] = {command, mnemonic, name,
desc};
}
void RegisterCommand(const std::string &shortcut, Command command,
char mnemonic, const std::string &name,
const std::string &desc) {
commands_[shortcut].main_command = {std::move(command), mnemonic, name, desc};
void RegisterCommand(const std::string& shortcut, Command command,
char mnemonic, const std::string& name,
const std::string& desc) {
commands_[shortcut].main_command = {std::move(command), mnemonic, name,
desc};
}
void ExecuteCommand(const std::string &shortcut) {
void ExecuteCommand(const std::string& shortcut) {
if (commands_.find(shortcut) != commands_.end()) {
commands_[shortcut].main_command.command();
}
@@ -76,8 +78,8 @@ class CommandManager {
void ShowWhichKeyHierarchical();
void HandleWhichKeyInput();
void SaveKeybindings(const std::string &filepath);
void LoadKeybindings(const std::string &filepath);
void SaveKeybindings(const std::string& filepath);
void LoadKeybindings(const std::string& filepath);
// Navigation state
bool IsWhichKeyActive() const { return whichkey_active_; }
@@ -88,7 +90,8 @@ class CommandManager {
// WhichKey state
bool whichkey_active_ = false;
std::string current_prefix_; // Current navigation prefix (e.g., "w", "l", "f")
std::string
current_prefix_; // Current navigation prefix (e.g., "w", "l", "f")
float whichkey_timer_ = 0.0f; // Auto-close timer
};

93
src/app/editor/system/command_palette.cc
View File

@@ -7,9 +7,11 @@
namespace yaze {
namespace editor {
void CommandPalette::AddCommand(const std::string& name, const std::string& category,
const std::string& description, const std::string& shortcut,
std::function<void()> callback) {
void CommandPalette::AddCommand(const std::string& name,
const std::string& category,
const std::string& description,
const std::string& shortcut,
std::function<void()> callback) {
CommandEntry entry;
entry.name = name;
entry.category = category;
@@ -23,33 +25,41 @@ void CommandPalette::RecordUsage(const std::string& name) {
auto it = commands_.find(name);
if (it != commands_.end()) {
it->second.usage_count++;
it->second.last_used_ms =
it->second.last_used_ms =
std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::system_clock::now().time_since_epoch()).count();
std::chrono::system_clock::now().time_since_epoch())
.count();
}
}
int CommandPalette::FuzzyScore(const std::string& text, const std::string& query) {
if (query.empty()) return 0;
int CommandPalette::FuzzyScore(const std::string& text,
const std::string& query) {
if (query.empty())
return 0;
int score = 0;
size_t text_idx = 0;
size_t query_idx = 0;
std::string text_lower = text;
std::string query_lower = query;
std::transform(text_lower.begin(), text_lower.end(), text_lower.begin(), ::tolower);
std::transform(query_lower.begin(), query_lower.end(), query_lower.begin(), ::tolower);
std::transform(text_lower.begin(), text_lower.end(), text_lower.begin(),
::tolower);
std::transform(query_lower.begin(), query_lower.end(), query_lower.begin(),
::tolower);
// Exact match bonus
if (text_lower == query_lower) return 1000;
if (text_lower == query_lower)
return 1000;
// Starts with bonus
if (text_lower.find(query_lower) == 0) return 500;
if (text_lower.find(query_lower) == 0)
return 500;
// Contains bonus
if (text_lower.find(query_lower) != std::string::npos) return 250;
if (text_lower.find(query_lower) != std::string::npos)
return 250;
// Fuzzy match - characters in order
while (text_idx < text_lower.length() && query_idx < query_lower.length()) {
if (text_lower[text_idx] == query_lower[query_idx]) {
@@ -58,91 +68,94 @@ int CommandPalette::FuzzyScore(const std::string& text, const std::string& query
}
text_idx++;
}
// Penalty if not all characters matched
if (query_idx != query_lower.length()) return 0;
if (query_idx != query_lower.length())
return 0;
return score;
}
std::vector<CommandEntry> CommandPalette::SearchCommands(const std::string& query) {
std::vector<CommandEntry> CommandPalette::SearchCommands(
const std::string& query) {
std::vector<std::pair<int, CommandEntry>> scored;
for (const auto& [name, entry] : commands_) {
int score = FuzzyScore(entry.name, query);
// Also check category and description
score += FuzzyScore(entry.category, query) / 2;
score += FuzzyScore(entry.description, query) / 4;
// Frecency bonus (frequency + recency)
score += entry.usage_count * 2;
auto now_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::system_clock::now().time_since_epoch()).count();
std::chrono::system_clock::now().time_since_epoch())
.count();
int64_t age_ms = now_ms - entry.last_used_ms;
if (age_ms < 60000) { // Used in last minute
score += 50;
} else if (age_ms < 3600000) { // Last hour
score += 25;
}
if (score > 0) {
scored.push_back({score, entry});
}
}
// Sort by score descending
std::sort(scored.begin(), scored.end(),
std::sort(scored.begin(), scored.end(),
[](const auto& a, const auto& b) { return a.first > b.first; });
std::vector<CommandEntry> results;
for (const auto& [score, entry] : scored) {
results.push_back(entry);
}
return results;
}
std::vector<CommandEntry> CommandPalette::GetRecentCommands(int limit) {
std::vector<CommandEntry> recent;
for (const auto& [name, entry] : commands_) {
if (entry.usage_count > 0) {
recent.push_back(entry);
}
}
std::sort(recent.begin(), recent.end(),
[](const CommandEntry& a, const CommandEntry& b) {
return a.last_used_ms > b.last_used_ms;
});
if (recent.size() > static_cast<size_t>(limit)) {
recent.resize(limit);
}
return recent;
}
std::vector<CommandEntry> CommandPalette::GetFrequentCommands(int limit) {
std::vector<CommandEntry> frequent;
for (const auto& [name, entry] : commands_) {
if (entry.usage_count > 0) {
frequent.push_back(entry);
}
}
std::sort(frequent.begin(), frequent.end(),
[](const CommandEntry& a, const CommandEntry& b) {
return a.usage_count > b.usage_count;
});
if (frequent.size() > static_cast<size_t>(limit)) {
frequent.resize(limit);
}
return frequent;
}

20
src/app/editor/system/command_palette.h
View File

@@ -1,10 +1,10 @@
#ifndef YAZE_APP_EDITOR_SYSTEM_COMMAND_PALETTE_H_
#define YAZE_APP_EDITOR_SYSTEM_COMMAND_PALETTE_H_
#include <string>
#include <vector>
#include <unordered_map>
#include <functional>
#include <string>
#include <unordered_map>
#include <vector>
namespace yaze {
namespace editor {
@@ -24,21 +24,21 @@ class CommandPalette {
void AddCommand(const std::string& name, const std::string& category,
const std::string& description, const std::string& shortcut,
std::function<void()> callback);
void RecordUsage(const std::string& name);
std::vector<CommandEntry> SearchCommands(const std::string& query);
std::vector<CommandEntry> GetRecentCommands(int limit = 10);
std::vector<CommandEntry> GetFrequentCommands(int limit = 10);
void SaveHistory(const std::string& filepath);
void LoadHistory(const std::string& filepath);
private:
std::unordered_map<std::string, CommandEntry> commands_;
int FuzzyScore(const std::string& text, const std::string& query);
};

512
src/app/editor/system/editor_card_registry.cc
View File

File diff suppressed because it is too large Load Diff

230
src/app/editor/system/editor_card_registry.h
View File

@@ -23,16 +23,16 @@ class EditorCard;
* organized by category, and controlled programmatically.
*/
struct CardInfo {
std::string card_id; // Unique identifier (e.g., "dungeon.room_selector")
std::string display_name; // Human-readable name (e.g., "Room Selector")
std::string icon; // Material icon
std::string category; // Category (e.g., "Dungeon", "Graphics", "Palette")
std::string shortcut_hint; // Display hint (e.g., "Ctrl+Shift+R")
bool* visibility_flag; // Pointer to bool controlling visibility
EditorCard* card_instance; // Pointer to actual card (optional)
std::function<void()> on_show; // Callback when card is shown
std::function<void()> on_hide; // Callback when card is hidden
int priority; // Display priority for menus (lower = higher)
std::string card_id; // Unique identifier (e.g., "dungeon.room_selector")
std::string display_name; // Human-readable name (e.g., "Room Selector")
std::string icon; // Material icon
std::string category; // Category (e.g., "Dungeon", "Graphics", "Palette")
std::string shortcut_hint; // Display hint (e.g., "Ctrl+Shift+R")
bool* visibility_flag; // Pointer to bool controlling visibility
EditorCard* card_instance; // Pointer to actual card (optional)
std::function<void()> on_show; // Callback when card is shown
std::function<void()> on_hide; // Callback when card is hidden
int priority; // Display priority for menus (lower = higher)
};
/**
@@ -79,17 +79,17 @@ class EditorCardRegistry {
public:
EditorCardRegistry() = default;
~EditorCardRegistry() = default;
// Non-copyable, non-movable (manages pointers and callbacks)
EditorCardRegistry(const EditorCardRegistry&) = delete;
EditorCardRegistry& operator=(const EditorCardRegistry&) = delete;
EditorCardRegistry(EditorCardRegistry&&) = delete;
EditorCardRegistry& operator=(EditorCardRegistry&&) = delete;
// ============================================================================
// Session Lifecycle Management
// ============================================================================
/**
* @brief Register a new session in the registry
* @param session_id Unique session identifier
@@ -98,7 +98,7 @@ class EditorCardRegistry {
* Must be called before registering cards for a session.
*/
void RegisterSession(size_t session_id);
/**
* @brief Unregister a session and all its cards
* @param session_id Session identifier to remove
@@ -106,7 +106,7 @@ class EditorCardRegistry {
* Automatically unregisters all cards associated with the session.
*/
void UnregisterSession(size_t session_id);
/**
* @brief Set the currently active session
* @param session_id Session to make active
@@ -114,11 +114,11 @@ class EditorCardRegistry {
* Used for determining whether to apply card ID prefixing.
*/
void SetActiveSession(size_t session_id);
// ============================================================================
// Card Registration
// ============================================================================
/**
* @brief Register a card for a specific session
* @param session_id Session this card belongs to
@@ -128,28 +128,25 @@ class EditorCardRegistry {
* automatically applies session prefixing when multiple sessions exist.
*/
void RegisterCard(size_t session_id, const CardInfo& base_info);
/**
* @brief Register a card with inline parameters (convenience method)
*/
void RegisterCard(size_t session_id,
const std::string& card_id,
const std::string& display_name,
const std::string& icon,
const std::string& category,
const std::string& shortcut_hint = "",
int priority = 50,
std::function<void()> on_show = nullptr,
std::function<void()> on_hide = nullptr,
bool visible_by_default = false);
void RegisterCard(size_t session_id, const std::string& card_id,
const std::string& display_name, const std::string& icon,
const std::string& category,
const std::string& shortcut_hint = "", int priority = 50,
std::function<void()> on_show = nullptr,
std::function<void()> on_hide = nullptr,
bool visible_by_default = false);
/**
* @brief Unregister a specific card
* @param session_id Session the card belongs to
* @param base_card_id Unprefixed card ID
*/
void UnregisterCard(size_t session_id, const std::string& base_card_id);
/**
* @brief Unregister all cards with a given prefix
* @param prefix Prefix to match (e.g., "s0" or "s1.dungeon")
@@ -157,16 +154,16 @@ class EditorCardRegistry {
* Useful for cleaning up session cards or category cards.
*/
void UnregisterCardsWithPrefix(const std::string& prefix);
/**
* @brief Remove all registered cards (use with caution)
*/
void ClearAllCards();
// ============================================================================
// Card Control (Programmatic, No GUI)
// ============================================================================
/**
* @brief Show a card programmatically
* @param session_id Session the card belongs to
@@ -174,176 +171,178 @@ class EditorCardRegistry {
* @return true if card was found and shown
*/
bool ShowCard(size_t session_id, const std::string& base_card_id);
/**
* @brief Hide a card programmatically
*/
bool HideCard(size_t session_id, const std::string& base_card_id);
/**
* @brief Toggle a card's visibility
*/
bool ToggleCard(size_t session_id, const std::string& base_card_id);
/**
* @brief Check if a card is currently visible
*/
bool IsCardVisible(size_t session_id, const std::string& base_card_id) const;
/**
* @brief Get visibility flag pointer for a card
* @return Pointer to bool controlling card visibility (for passing to EditorCard::Begin)
*/
bool* GetVisibilityFlag(size_t session_id, const std::string& base_card_id);
// ============================================================================
// Batch Operations
// ============================================================================
/**
* @brief Show all cards in a specific session
*/
void ShowAllCardsInSession(size_t session_id);
/**
* @brief Hide all cards in a specific session
*/
void HideAllCardsInSession(size_t session_id);
/**
* @brief Show all cards in a category for a session
*/
void ShowAllCardsInCategory(size_t session_id, const std::string& category);
/**
* @brief Hide all cards in a category for a session
*/
void HideAllCardsInCategory(size_t session_id, const std::string& category);
/**
* @brief Show only one card, hiding all others in its category
*/
void ShowOnlyCard(size_t session_id, const std::string& base_card_id);
// ============================================================================
// Query Methods
// ============================================================================
/**
* @brief Get all cards registered for a session
* @return Vector of prefixed card IDs
*/
std::vector<std::string> GetCardsInSession(size_t session_id) const;
/**
* @brief Get cards in a specific category for a session
*/
std::vector<CardInfo> GetCardsInCategory(size_t session_id, const std::string& category) const;
std::vector<CardInfo> GetCardsInCategory(size_t session_id,
const std::string& category) const;
/**
* @brief Get all categories for a session
*/
std::vector<std::string> GetAllCategories(size_t session_id) const;
/**
* @brief Get card metadata
* @param session_id Session the card belongs to
* @param base_card_id Unprefixed card ID
*/
const CardInfo* GetCardInfo(size_t session_id, const std::string& base_card_id) const;
const CardInfo* GetCardInfo(size_t session_id,
const std::string& base_card_id) const;
/**
* @brief Get all registered categories across all sessions
*/
std::vector<std::string> GetAllCategories() const;
// ============================================================================
// View Menu Integration
// ============================================================================
/**
* @brief Draw view menu section for a category
*/
void DrawViewMenuSection(size_t session_id, const std::string& category);
/**
* @brief Draw all categories as view menu submenus
*/
void DrawViewMenuAll(size_t session_id);
// ============================================================================
// VSCode-Style Sidebar
// ============================================================================
/**
* @brief Draw sidebar for a category with session filtering
*/
void DrawSidebar(size_t session_id,
const std::string& category,
const std::vector<std::string>& active_categories = {},
std::function<void(const std::string&)> on_category_switch = nullptr,
std::function<void()> on_collapse = nullptr);
void DrawSidebar(
size_t session_id, const std::string& category,
const std::vector<std::string>& active_categories = {},
std::function<void(const std::string&)> on_category_switch = nullptr,
std::function<void()> on_collapse = nullptr);
static constexpr float GetSidebarWidth() { return 48.0f; }
// ============================================================================
// Compact Controls for Menu Bar
// ============================================================================
/**
* @brief Draw compact card control for active editor's cards
*/
void DrawCompactCardControl(size_t session_id, const std::string& category);
/**
* @brief Draw minimal inline card toggles
*/
void DrawInlineCardToggles(size_t session_id, const std::string& category);
// ============================================================================
// Card Browser UI
// ============================================================================
/**
* @brief Draw visual card browser/toggler
*/
void DrawCardBrowser(size_t session_id, bool* p_open);
// ============================================================================
// Workspace Presets
// ============================================================================
struct WorkspacePreset {
std::string name;
std::vector<std::string> visible_cards; // Card IDs
std::string description;
};
void SavePreset(const std::string& name, const std::string& description = "");
bool LoadPreset(const std::string& name);
void DeletePreset(const std::string& name);
std::vector<WorkspacePreset> GetPresets() const;
// ============================================================================
// Quick Actions
// ============================================================================
void ShowAll(size_t session_id);
void HideAll(size_t session_id);
void ResetToDefaults(size_t session_id);
// ============================================================================
// Statistics
// ============================================================================
size_t GetCardCount() const { return cards_.size(); }
size_t GetVisibleCardCount(size_t session_id) const;
size_t GetSessionCount() const { return session_count_; }
// ============================================================================
// Session Prefixing Utilities
// ============================================================================
/**
* @brief Generate session-aware card ID
* @param session_id Session identifier
@@ -355,139 +354,141 @@ class EditorCardRegistry {
* - Multi-session: "dungeon.room_selector" → "s0.dungeon.room_selector"
*/
std::string MakeCardId(size_t session_id, const std::string& base_id) const;
/**
* @brief Check if card IDs should be prefixed
* @return true if session_count > 1
*/
bool ShouldPrefixCards() const { return session_count_ > 1; }
// ============================================================================
// Convenience Methods (for EditorManager direct usage without session_id)
// ============================================================================
/**
* @brief Register card for active session (convenience)
*/
void RegisterCard(const CardInfo& base_info) {
RegisterCard(active_session_, base_info);
}
/**
* @brief Show card in active session (convenience)
*/
bool ShowCard(const std::string& base_card_id) {
return ShowCard(active_session_, base_card_id);
}
/**
* @brief Hide card in active session (convenience)
*/
bool HideCard(const std::string& base_card_id) {
return HideCard(active_session_, base_card_id);
}
/**
* @brief Check if card is visible in active session (convenience)
*/
bool IsCardVisible(const std::string& base_card_id) const {
return IsCardVisible(active_session_, base_card_id);
}
/**
* @brief Hide all cards in category for active session (convenience)
*/
void HideAllCardsInCategory(const std::string& category) {
HideAllCardsInCategory(active_session_, category);
}
/**
* @brief Draw card browser for active session (convenience)
*/
void DrawCardBrowser(bool* p_open) {
DrawCardBrowser(active_session_, p_open);
}
/**
* @brief Get active category (for sidebar)
*/
std::string GetActiveCategory() const { return active_category_; }
/**
* @brief Set active category (for sidebar)
*/
void SetActiveCategory(const std::string& category) { active_category_ = category; }
void SetActiveCategory(const std::string& category) {
active_category_ = category;
}
/**
* @brief Show all cards in category for active session (convenience)
*/
void ShowAllCardsInCategory(const std::string& category) {
ShowAllCardsInCategory(active_session_, category);
}
/**
* @brief Get visibility flag for active session (convenience)
*/
bool* GetVisibilityFlag(const std::string& base_card_id) {
return GetVisibilityFlag(active_session_, base_card_id);
}
/**
* @brief Show all cards for active session (convenience)
*/
void ShowAll() {
ShowAll(active_session_);
}
void ShowAll() { ShowAll(active_session_); }
/**
* @brief Hide all cards for active session (convenience)
*/
void HideAll() {
HideAll(active_session_);
}
void HideAll() { HideAll(active_session_); }
/**
* @brief Draw sidebar for active session (convenience)
*/
void DrawSidebar(const std::string& category,
const std::vector<std::string>& active_categories = {},
std::function<void(const std::string&)> on_category_switch = nullptr,
std::function<void()> on_collapse = nullptr) {
DrawSidebar(active_session_, category, active_categories, on_category_switch, on_collapse);
void DrawSidebar(
const std::string& category,
const std::vector<std::string>& active_categories = {},
std::function<void(const std::string&)> on_category_switch = nullptr,
std::function<void()> on_collapse = nullptr) {
DrawSidebar(active_session_, category, active_categories,
on_category_switch, on_collapse);
}
private:
// Core card storage (prefixed IDs → CardInfo)
std::unordered_map<std::string, CardInfo> cards_;
// Centralized visibility flags for cards without external flags
std::unordered_map<std::string, bool> centralized_visibility_;
// Session tracking
size_t session_count_ = 0;
size_t active_session_ = 0;
// Maps session_id → vector of prefixed card IDs registered for that session
std::unordered_map<size_t, std::vector<std::string>> session_cards_;
// Maps session_id → (base_card_id → prefixed_card_id)
std::unordered_map<size_t, std::unordered_map<std::string, std::string>> session_card_mapping_;
std::unordered_map<size_t, std::unordered_map<std::string, std::string>>
session_card_mapping_;
// Workspace presets
std::unordered_map<std::string, WorkspacePreset> presets_;
// Active category tracking
std::string active_category_;
std::vector<std::string> recent_categories_;
static constexpr size_t kMaxRecentCategories = 5;
// Helper methods
void UpdateSessionCount();
std::string GetPrefixedCardId(size_t session_id, const std::string& base_id) const;
std::string GetPrefixedCardId(size_t session_id,
const std::string& base_id) const;
void UnregisterSessionCards(size_t session_id);
void SavePresetsToFile();
void LoadPresetsFromFile();
// UI drawing helpers (internal)
void DrawCardMenuItem(const CardInfo& info);
void DrawCardInSidebar(const CardInfo& info, bool is_active);
@@ -497,4 +498,3 @@ class EditorCardRegistry {
} // namespace yaze
#endif // YAZE_APP_EDITOR_SYSTEM_EDITOR_CARD_REGISTRY_H_

141
src/app/editor/system/editor_registry.cc
View File

@@ -1,59 +1,58 @@
#include "editor_registry.h"
#include <unordered_set>
#include "absl/strings/str_format.h"
#include "app/editor/editor.h"
#include <unordered_set>
namespace yaze {
namespace editor {
// Static mappings for editor types
const std::unordered_map<EditorType, std::string> EditorRegistry::kEditorCategories = {
{EditorType::kDungeon, "Dungeon"},
{EditorType::kOverworld, "Overworld"},
{EditorType::kGraphics, "Graphics"},
{EditorType::kPalette, "Palette"},
{EditorType::kSprite, "Sprite"},
{EditorType::kScreen, "Screen"},
{EditorType::kMessage, "Message"},
{EditorType::kMusic, "Music"},
{EditorType::kAssembly, "Assembly"},
{EditorType::kEmulator, "Emulator"},
{EditorType::kHex, "Hex"},
{EditorType::kAgent, "Agent"},
{EditorType::kSettings, "System"}
};
const std::unordered_map<EditorType, std::string>
EditorRegistry::kEditorCategories = {{EditorType::kDungeon, "Dungeon"},
{EditorType::kOverworld, "Overworld"},
{EditorType::kGraphics, "Graphics"},
{EditorType::kPalette, "Palette"},
{EditorType::kSprite, "Sprite"},
{EditorType::kScreen, "Screen"},
{EditorType::kMessage, "Message"},
{EditorType::kMusic, "Music"},
{EditorType::kAssembly, "Assembly"},
{EditorType::kEmulator, "Emulator"},
{EditorType::kHex, "Hex"},
{EditorType::kAgent, "Agent"},
{EditorType::kSettings, "System"}};
const std::unordered_map<EditorType, std::string> EditorRegistry::kEditorNames = {
{EditorType::kDungeon, "Dungeon Editor"},
{EditorType::kOverworld, "Overworld Editor"},
{EditorType::kGraphics, "Graphics Editor"},
{EditorType::kPalette, "Palette Editor"},
{EditorType::kSprite, "Sprite Editor"},
{EditorType::kScreen, "Screen Editor"},
{EditorType::kMessage, "Message Editor"},
{EditorType::kMusic, "Music Editor"},
{EditorType::kAssembly, "Assembly Editor"},
{EditorType::kEmulator, "Emulator Editor"},
{EditorType::kHex, "Hex Editor"},
{EditorType::kAgent, "Agent Editor"},
{EditorType::kSettings, "Settings Editor"}
};
const std::unordered_map<EditorType, std::string> EditorRegistry::kEditorNames =
{{EditorType::kDungeon, "Dungeon Editor"},
{EditorType::kOverworld, "Overworld Editor"},
{EditorType::kGraphics, "Graphics Editor"},
{EditorType::kPalette, "Palette Editor"},
{EditorType::kSprite, "Sprite Editor"},
{EditorType::kScreen, "Screen Editor"},
{EditorType::kMessage, "Message Editor"},
{EditorType::kMusic, "Music Editor"},
{EditorType::kAssembly, "Assembly Editor"},
{EditorType::kEmulator, "Emulator Editor"},
{EditorType::kHex, "Hex Editor"},
{EditorType::kAgent, "Agent Editor"},
{EditorType::kSettings, "Settings Editor"}};
const std::unordered_map<EditorType, bool> EditorRegistry::kCardBasedEditors = {
{EditorType::kDungeon, true},
{EditorType::kOverworld, true},
{EditorType::kGraphics, true},
{EditorType::kPalette, true},
{EditorType::kSprite, true},
{EditorType::kScreen, true},
{EditorType::kMessage, true},
{EditorType::kMusic, true},
{EditorType::kAssembly, true},
{EditorType::kEmulator, true},
{EditorType::kHex, true},
{EditorType::kAgent, false}, // Agent: Traditional UI
{EditorType::kSettings, true} // Settings: Now card-based for better organization
{EditorType::kDungeon, true},
{EditorType::kOverworld, true},
{EditorType::kGraphics, true},
{EditorType::kPalette, true},
{EditorType::kSprite, true},
{EditorType::kScreen, true},
{EditorType::kMessage, true},
{EditorType::kMusic, true},
{EditorType::kAssembly, true},
{EditorType::kEmulator, true},
{EditorType::kHex, true},
{EditorType::kAgent, false}, // Agent: Traditional UI
{EditorType::kSettings,
true} // Settings: Now card-based for better organization
};
bool EditorRegistry::IsCardBasedEditor(EditorType type) {
@@ -69,7 +68,8 @@ std::string EditorRegistry::GetEditorCategory(EditorType type) {
return "Unknown";
}
EditorType EditorRegistry::GetEditorTypeFromCategory(const std::string& category) {
EditorType EditorRegistry::GetEditorTypeFromCategory(
const std::string& category) {
for (const auto& [type, cat] : kEditorCategories) {
if (cat == category) {
return type; // Return first match
@@ -98,7 +98,7 @@ void EditorRegistry::JumpToOverworldMap(int map_id) {
void EditorRegistry::SwitchToEditor(EditorType editor_type) {
ValidateEditorType(editor_type);
auto it = registered_editors_.find(editor_type);
if (it != registered_editors_.end() && it->second) {
// Deactivate all other editors
@@ -107,10 +107,11 @@ void EditorRegistry::SwitchToEditor(EditorType editor_type) {
editor->set_active(false);
}
}
// Activate the target editor
it->second->set_active(true);
printf("[EditorRegistry] Switched to %s\n", GetEditorDisplayName(editor_type).c_str());
printf("[EditorRegistry] Switched to %s\n",
GetEditorDisplayName(editor_type).c_str());
}
}
@@ -118,52 +119,56 @@ void EditorRegistry::HideCurrentEditorCards() {
for (auto& [type, editor] : registered_editors_) {
if (editor && IsCardBasedEditor(type)) {
// TODO: Hide cards for this editor
printf("[EditorRegistry] Hiding cards for %s\n", GetEditorDisplayName(type).c_str());
printf("[EditorRegistry] Hiding cards for %s\n",
GetEditorDisplayName(type).c_str());
}
}
}
void EditorRegistry::ShowEditorCards(EditorType editor_type) {
ValidateEditorType(editor_type);
if (IsCardBasedEditor(editor_type)) {
// TODO: Show cards for this editor
printf("[EditorRegistry] Showing cards for %s\n", GetEditorDisplayName(editor_type).c_str());
printf("[EditorRegistry] Showing cards for %s\n",
GetEditorDisplayName(editor_type).c_str());
}
}
void EditorRegistry::ToggleEditorCards(EditorType editor_type) {
ValidateEditorType(editor_type);
if (IsCardBasedEditor(editor_type)) {
// TODO: Toggle cards for this editor
printf("[EditorRegistry] Toggling cards for %s\n", GetEditorDisplayName(editor_type).c_str());
printf("[EditorRegistry] Toggling cards for %s\n",
GetEditorDisplayName(editor_type).c_str());
}
}
std::vector<EditorType> EditorRegistry::GetEditorsInCategory(const std::string& category) const {
std::vector<EditorType> EditorRegistry::GetEditorsInCategory(
const std::string& category) const {
std::vector<EditorType> editors;
for (const auto& [type, cat] : kEditorCategories) {
if (cat == category) {
editors.push_back(type);
}
}
return editors;
}
std::vector<std::string> EditorRegistry::GetAvailableCategories() const {
std::vector<std::string> categories;
std::unordered_set<std::string> seen;
for (const auto& [type, category] : kEditorCategories) {
if (seen.find(category) == seen.end()) {
categories.push_back(category);
seen.insert(category);
}
}
return categories;
}
@@ -177,28 +182,30 @@ std::string EditorRegistry::GetEditorDisplayName(EditorType type) const {
void EditorRegistry::RegisterEditor(EditorType type, Editor* editor) {
ValidateEditorType(type);
if (!editor) {
throw std::invalid_argument("Editor pointer cannot be null");
}
registered_editors_[type] = editor;
printf("[EditorRegistry] Registered %s\n", GetEditorDisplayName(type).c_str());
printf("[EditorRegistry] Registered %s\n",
GetEditorDisplayName(type).c_str());
}
void EditorRegistry::UnregisterEditor(EditorType type) {
ValidateEditorType(type);
auto it = registered_editors_.find(type);
if (it != registered_editors_.end()) {
registered_editors_.erase(it);
printf("[EditorRegistry] Unregistered %s\n", GetEditorDisplayName(type).c_str());
printf("[EditorRegistry] Unregistered %s\n",
GetEditorDisplayName(type).c_str());
}
}
Editor* EditorRegistry::GetEditor(EditorType type) const {
ValidateEditorType(type);
auto it = registered_editors_.find(type);
if (it != registered_editors_.end()) {
return it->second;
@@ -208,7 +215,7 @@ Editor* EditorRegistry::GetEditor(EditorType type) const {
bool EditorRegistry::IsEditorActive(EditorType type) const {
ValidateEditorType(type);
auto it = registered_editors_.find(type);
if (it != registered_editors_.end() && it->second) {
return it->second->active();
@@ -218,7 +225,7 @@ bool EditorRegistry::IsEditorActive(EditorType type) const {
bool EditorRegistry::IsEditorVisible(EditorType type) const {
ValidateEditorType(type);
auto it = registered_editors_.find(type);
if (it != registered_editors_.end() && it->second) {
return it->second->active();
@@ -228,7 +235,7 @@ bool EditorRegistry::IsEditorVisible(EditorType type) const {
void EditorRegistry::SetEditorActive(EditorType type, bool active) {
ValidateEditorType(type);
auto it = registered_editors_.find(type);
if (it != registered_editors_.end() && it->second) {
it->second->set_active(active);

17
src/app/editor/system/editor_registry.h
View File

@@ -29,27 +29,28 @@ class EditorRegistry {
static bool IsCardBasedEditor(EditorType type);
static std::string GetEditorCategory(EditorType type);
static EditorType GetEditorTypeFromCategory(const std::string& category);
// Editor navigation
void JumpToDungeonRoom(int room_id);
void JumpToOverworldMap(int map_id);
void SwitchToEditor(EditorType editor_type);
// Editor card management
void HideCurrentEditorCards();
void ShowEditorCards(EditorType editor_type);
void ToggleEditorCards(EditorType editor_type);
// Editor information
std::vector<EditorType> GetEditorsInCategory(const std::string& category) const;
std::vector<EditorType> GetEditorsInCategory(
const std::string& category) const;
std::vector<std::string> GetAvailableCategories() const;
std::string GetEditorDisplayName(EditorType type) const;
// Editor lifecycle
void RegisterEditor(EditorType type, Editor* editor);
void UnregisterEditor(EditorType type);
Editor* GetEditor(EditorType type) const;
// Editor state queries
bool IsEditorActive(EditorType type) const;
bool IsEditorVisible(EditorType type) const;
@@ -60,10 +61,10 @@ class EditorRegistry {
static const std::unordered_map<EditorType, std::string> kEditorCategories;
static const std::unordered_map<EditorType, std::string> kEditorNames;
static const std::unordered_map<EditorType, bool> kCardBasedEditors;
// Registered editors
std::unordered_map<EditorType, Editor*> registered_editors_;
// Helper methods
bool IsValidEditorType(EditorType type) const;
void ValidateEditorType(EditorType type) const;

492
src/app/editor/system/menu_orchestrator.cc
View File

@@ -1,7 +1,6 @@
#include "menu_orchestrator.h"
#include "absl/strings/str_format.h"
#include "core/features.h"
#include "app/editor/editor.h"
#include "app/editor/editor_manager.h"
#include "app/editor/system/editor_registry.h"
@@ -13,20 +12,17 @@
#include "app/editor/ui/menu_builder.h"
#include "app/gui/core/icons.h"
#include "app/rom.h"
#include "core/features.h"
#include "zelda3/overworld/overworld_map.h"
namespace yaze {
namespace editor {
MenuOrchestrator::MenuOrchestrator(
EditorManager* editor_manager,
MenuBuilder& menu_builder,
RomFileManager& rom_manager,
ProjectManager& project_manager,
EditorRegistry& editor_registry,
SessionCoordinator& session_coordinator,
ToastManager& toast_manager,
PopupManager& popup_manager)
EditorManager* editor_manager, MenuBuilder& menu_builder,
RomFileManager& rom_manager, ProjectManager& project_manager,
EditorRegistry& editor_registry, SessionCoordinator& session_coordinator,
ToastManager& toast_manager, PopupManager& popup_manager)
: editor_manager_(editor_manager),
menu_builder_(menu_builder),
rom_manager_(rom_manager),
@@ -34,12 +30,11 @@ MenuOrchestrator::MenuOrchestrator(
editor_registry_(editor_registry),
session_coordinator_(session_coordinator),
toast_manager_(toast_manager),
popup_manager_(popup_manager) {
}
popup_manager_(popup_manager) {}
void MenuOrchestrator::BuildMainMenu() {
ClearMenu();
// Build all menu sections in order
BuildFileMenu();
BuildEditMenu();
@@ -48,10 +43,10 @@ void MenuOrchestrator::BuildMainMenu() {
BuildDebugMenu(); // Add Debug menu between Tools and Window
BuildWindowMenu();
BuildHelpMenu();
// Draw the constructed menu
menu_builder_.Draw();
menu_needs_refresh_ = false;
}
@@ -64,50 +59,48 @@ void MenuOrchestrator::BuildFileMenu() {
void MenuOrchestrator::AddFileMenuItems() {
// ROM Operations
menu_builder_
.Item("Open ROM", ICON_MD_FILE_OPEN,
[this]() { OnOpenRom(); }, "Ctrl+O")
.Item("Save ROM", ICON_MD_SAVE,
[this]() { OnSaveRom(); }, "Ctrl+S",
[this]() { return CanSaveRom(); })
.Item("Save As...", ICON_MD_SAVE_AS,
[this]() { OnSaveRomAs(); }, nullptr,
[this]() { return CanSaveRom(); })
.Item(
"Open ROM", ICON_MD_FILE_OPEN, [this]() { OnOpenRom(); }, "Ctrl+O")
.Item(
"Save ROM", ICON_MD_SAVE, [this]() { OnSaveRom(); }, "Ctrl+S",
[this]() { return CanSaveRom(); })
.Item(
"Save As...", ICON_MD_SAVE_AS, [this]() { OnSaveRomAs(); }, nullptr,
[this]() { return CanSaveRom(); })
.Separator();
// Project Operations
menu_builder_
.Item("New Project", ICON_MD_CREATE_NEW_FOLDER,
[this]() { OnCreateProject(); })
.Item("Open Project", ICON_MD_FOLDER_OPEN,
[this]() { OnOpenProject(); })
.Item("Save Project", ICON_MD_SAVE,
[this]() { OnSaveProject(); }, nullptr,
[this]() { return CanSaveProject(); })
.Item("Save Project As...", ICON_MD_SAVE_AS,
[this]() { OnSaveProjectAs(); }, nullptr,
[this]() { return CanSaveProject(); })
.Item("Open Project", ICON_MD_FOLDER_OPEN, [this]() { OnOpenProject(); })
.Item(
"Save Project", ICON_MD_SAVE, [this]() { OnSaveProject(); }, nullptr,
[this]() { return CanSaveProject(); })
.Item(
"Save Project As...", ICON_MD_SAVE_AS,
[this]() { OnSaveProjectAs(); }, nullptr,
[this]() { return CanSaveProject(); })
.Separator();
// ROM Information and Validation
menu_builder_
.Item("ROM Information", ICON_MD_INFO,
[this]() { OnShowRomInfo(); }, nullptr,
[this]() { return HasActiveRom(); })
.Item("Create Backup", ICON_MD_BACKUP,
[this]() { OnCreateBackup(); }, nullptr,
[this]() { return HasActiveRom(); })
.Item("Validate ROM", ICON_MD_CHECK_CIRCLE,
[this]() { OnValidateRom(); }, nullptr,
[this]() { return HasActiveRom(); })
.Item(
"ROM Information", ICON_MD_INFO, [this]() { OnShowRomInfo(); },
nullptr, [this]() { return HasActiveRom(); })
.Item(
"Create Backup", ICON_MD_BACKUP, [this]() { OnCreateBackup(); },
nullptr, [this]() { return HasActiveRom(); })
.Item(
"Validate ROM", ICON_MD_CHECK_CIRCLE, [this]() { OnValidateRom(); },
nullptr, [this]() { return HasActiveRom(); })
.Separator();
// Settings and Quit
menu_builder_
.Item("Settings", ICON_MD_SETTINGS,
[this]() { OnShowSettings(); })
.Item("Settings", ICON_MD_SETTINGS, [this]() { OnShowSettings(); })
.Separator()
.Item("Quit", ICON_MD_EXIT_TO_APP,
[this]() { OnQuit(); }, "Ctrl+Q");
.Item("Quit", ICON_MD_EXIT_TO_APP, [this]() { OnQuit(); }, "Ctrl+Q");
}
void MenuOrchestrator::BuildEditMenu() {
@@ -119,34 +112,35 @@ void MenuOrchestrator::BuildEditMenu() {
void MenuOrchestrator::AddEditMenuItems() {
// Undo/Redo operations - delegate to current editor
menu_builder_
.Item("Undo", ICON_MD_UNDO,
[this]() { OnUndo(); }, "Ctrl+Z",
[this]() { return HasCurrentEditor(); })
.Item("Redo", ICON_MD_REDO,
[this]() { OnRedo(); }, "Ctrl+Y",
[this]() { return HasCurrentEditor(); })
.Item(
"Undo", ICON_MD_UNDO, [this]() { OnUndo(); }, "Ctrl+Z",
[this]() { return HasCurrentEditor(); })
.Item(
"Redo", ICON_MD_REDO, [this]() { OnRedo(); }, "Ctrl+Y",
[this]() { return HasCurrentEditor(); })
.Separator();
// Clipboard operations - delegate to current editor
menu_builder_
.Item("Cut", ICON_MD_CONTENT_CUT,
[this]() { OnCut(); }, "Ctrl+X",
[this]() { return HasCurrentEditor(); })
.Item("Copy", ICON_MD_CONTENT_COPY,
[this]() { OnCopy(); }, "Ctrl+C",
[this]() { return HasCurrentEditor(); })
.Item("Paste", ICON_MD_CONTENT_PASTE,
[this]() { OnPaste(); }, "Ctrl+V",
[this]() { return HasCurrentEditor(); })
.Item(
"Cut", ICON_MD_CONTENT_CUT, [this]() { OnCut(); }, "Ctrl+X",
[this]() { return HasCurrentEditor(); })
.Item(
"Copy", ICON_MD_CONTENT_COPY, [this]() { OnCopy(); }, "Ctrl+C",
[this]() { return HasCurrentEditor(); })
.Item(
"Paste", ICON_MD_CONTENT_PASTE, [this]() { OnPaste(); }, "Ctrl+V",
[this]() { return HasCurrentEditor(); })
.Separator();
// Search operations
menu_builder_
.Item("Find", ICON_MD_SEARCH,
[this]() { OnFind(); }, "Ctrl+F",
[this]() { return HasCurrentEditor(); })
.Item("Find in Files", ICON_MD_SEARCH,
[this]() { OnShowGlobalSearch(); }, "Ctrl+Shift+F");
.Item(
"Find", ICON_MD_SEARCH, [this]() { OnFind(); }, "Ctrl+F",
[this]() { return HasCurrentEditor(); })
.Item(
"Find in Files", ICON_MD_SEARCH, [this]() { OnShowGlobalSearch(); },
"Ctrl+Shift+F");
}
void MenuOrchestrator::BuildViewMenu() {
@@ -158,60 +152,76 @@ void MenuOrchestrator::BuildViewMenu() {
void MenuOrchestrator::AddViewMenuItems() {
// Editor Selection
menu_builder_
.Item("Editor Selection", ICON_MD_DASHBOARD,
[this]() { OnShowEditorSelection(); }, "Ctrl+E")
.Item(
"Editor Selection", ICON_MD_DASHBOARD,
[this]() { OnShowEditorSelection(); }, "Ctrl+E")
.Separator();
// Individual Editor Shortcuts
menu_builder_
.Item("Overworld", ICON_MD_MAP,
[this]() { OnSwitchToEditor(EditorType::kOverworld); }, "Ctrl+1")
.Item("Dungeon", ICON_MD_CASTLE,
[this]() { OnSwitchToEditor(EditorType::kDungeon); }, "Ctrl+2")
.Item("Graphics", ICON_MD_IMAGE,
[this]() { OnSwitchToEditor(EditorType::kGraphics); }, "Ctrl+3")
.Item("Sprites", ICON_MD_TOYS,
[this]() { OnSwitchToEditor(EditorType::kSprite); }, "Ctrl+4")
.Item("Messages", ICON_MD_CHAT_BUBBLE,
[this]() { OnSwitchToEditor(EditorType::kMessage); }, "Ctrl+5")
.Item("Music", ICON_MD_MUSIC_NOTE,
[this]() { OnSwitchToEditor(EditorType::kMusic); }, "Ctrl+6")
.Item("Palettes", ICON_MD_PALETTE,
[this]() { OnSwitchToEditor(EditorType::kPalette); }, "Ctrl+7")
.Item("Screens", ICON_MD_TV,
[this]() { OnSwitchToEditor(EditorType::kScreen); }, "Ctrl+8")
.Item("Assembly", ICON_MD_CODE,
[this]() { OnSwitchToEditor(EditorType::kAssembly); }, "Ctrl+9")
.Item("Hex Editor", ICON_MD_DATA_ARRAY,
[this]() { OnShowHexEditor(); }, "Ctrl+0")
.Item(
"Overworld", ICON_MD_MAP,
[this]() { OnSwitchToEditor(EditorType::kOverworld); }, "Ctrl+1")
.Item(
"Dungeon", ICON_MD_CASTLE,
[this]() { OnSwitchToEditor(EditorType::kDungeon); }, "Ctrl+2")
.Item(
"Graphics", ICON_MD_IMAGE,
[this]() { OnSwitchToEditor(EditorType::kGraphics); }, "Ctrl+3")
.Item(
"Sprites", ICON_MD_TOYS,
[this]() { OnSwitchToEditor(EditorType::kSprite); }, "Ctrl+4")
.Item(
"Messages", ICON_MD_CHAT_BUBBLE,
[this]() { OnSwitchToEditor(EditorType::kMessage); }, "Ctrl+5")
.Item(
"Music", ICON_MD_MUSIC_NOTE,
[this]() { OnSwitchToEditor(EditorType::kMusic); }, "Ctrl+6")
.Item(
"Palettes", ICON_MD_PALETTE,
[this]() { OnSwitchToEditor(EditorType::kPalette); }, "Ctrl+7")
.Item(
"Screens", ICON_MD_TV,
[this]() { OnSwitchToEditor(EditorType::kScreen); }, "Ctrl+8")
.Item(
"Assembly", ICON_MD_CODE,
[this]() { OnSwitchToEditor(EditorType::kAssembly); }, "Ctrl+9")
.Item(
"Hex Editor", ICON_MD_DATA_ARRAY, [this]() { OnShowHexEditor(); },
"Ctrl+0")
.Separator();
// Special Editors
#ifdef YAZE_WITH_GRPC
menu_builder_
.Item("AI Agent", ICON_MD_SMART_TOY,
[this]() { OnShowAIAgent(); }, "Ctrl+Shift+A")
.Item("Chat History", ICON_MD_CHAT,
[this]() { OnShowChatHistory(); }, "Ctrl+H")
.Item("Proposal Drawer", ICON_MD_PREVIEW,
[this]() { OnShowProposalDrawer(); }, "Ctrl+Shift+R");
.Item(
"AI Agent", ICON_MD_SMART_TOY, [this]() { OnShowAIAgent(); },
"Ctrl+Shift+A")
.Item(
"Chat History", ICON_MD_CHAT, [this]() { OnShowChatHistory(); },
"Ctrl+H")
.Item(
"Proposal Drawer", ICON_MD_PREVIEW,
[this]() { OnShowProposalDrawer(); }, "Ctrl+Shift+R");
#endif
menu_builder_
.Item("Emulator", ICON_MD_VIDEOGAME_ASSET,
[this]() { OnShowEmulator(); }, "Ctrl+Shift+E")
.Item(
"Emulator", ICON_MD_VIDEOGAME_ASSET, [this]() { OnShowEmulator(); },
"Ctrl+Shift+E")
.Separator();
// Settings and UI
menu_builder_
.Item("Display Settings", ICON_MD_DISPLAY_SETTINGS,
[this]() { OnShowDisplaySettings(); })
.Separator();
// Additional UI Elements
menu_builder_
.Item("Card Browser", ICON_MD_DASHBOARD,
[this]() { OnShowCardBrowser(); }, "Ctrl+Shift+B")
.Item(
"Card Browser", ICON_MD_DASHBOARD, [this]() { OnShowCardBrowser(); },
"Ctrl+Shift+B")
.Item("Welcome Screen", ICON_MD_HOME,
[this]() { OnShowWelcomeScreen(); });
}
@@ -225,22 +235,23 @@ void MenuOrchestrator::BuildToolsMenu() {
void MenuOrchestrator::AddToolsMenuItems() {
// Core Tools - keep these in Tools menu
menu_builder_
.Item("Global Search", ICON_MD_SEARCH,
[this]() { OnShowGlobalSearch(); }, "Ctrl+Shift+F")
.Item("Command Palette", ICON_MD_SEARCH,
[this]() { OnShowCommandPalette(); }, "Ctrl+Shift+P")
.Item(
"Global Search", ICON_MD_SEARCH, [this]() { OnShowGlobalSearch(); },
"Ctrl+Shift+F")
.Item(
"Command Palette", ICON_MD_SEARCH,
[this]() { OnShowCommandPalette(); }, "Ctrl+Shift+P")
.Separator();
// Resource Management
menu_builder_
.Item("Resource Label Manager", ICON_MD_LABEL,
[this]() { OnShowResourceLabelManager(); })
.Separator();
// Collaboration (GRPC builds only)
#ifdef YAZE_WITH_GRPC
menu_builder_
.BeginSubMenu("Collaborate", ICON_MD_PEOPLE)
menu_builder_.BeginSubMenu("Collaborate", ICON_MD_PEOPLE)
.Item("Start Collaboration Session", ICON_MD_PLAY_CIRCLE,
[this]() { OnStartCollaboration(); })
.Item("Join Collaboration Session", ICON_MD_GROUP_ADD,
@@ -260,67 +271,60 @@ void MenuOrchestrator::BuildDebugMenu() {
void MenuOrchestrator::AddDebugMenuItems() {
// Testing section (move from Tools if present)
#ifdef YAZE_ENABLE_TESTING
menu_builder_
.BeginSubMenu("Testing", ICON_MD_SCIENCE)
.Item("Test Dashboard", ICON_MD_DASHBOARD,
[this]() { OnShowTestDashboard(); }, "Ctrl+T")
.Item("Run All Tests", ICON_MD_PLAY_ARROW,
[this]() { OnRunAllTests(); })
.Item("Run Unit Tests", ICON_MD_CHECK_BOX,
[this]() { OnRunUnitTests(); })
menu_builder_.BeginSubMenu("Testing", ICON_MD_SCIENCE)
.Item(
"Test Dashboard", ICON_MD_DASHBOARD,
[this]() { OnShowTestDashboard(); }, "Ctrl+T")
.Item("Run All Tests", ICON_MD_PLAY_ARROW, [this]() { OnRunAllTests(); })
.Item("Run Unit Tests", ICON_MD_CHECK_BOX, [this]() { OnRunUnitTests(); })
.Item("Run Integration Tests", ICON_MD_INTEGRATION_INSTRUCTIONS,
[this]() { OnRunIntegrationTests(); })
.Item("Run E2E Tests", ICON_MD_VISIBILITY,
[this]() { OnRunE2ETests(); })
.Item("Run E2E Tests", ICON_MD_VISIBILITY, [this]() { OnRunE2ETests(); })
.EndMenu()
.Separator();
#endif
// ROM Analysis submenu
menu_builder_
.BeginSubMenu("ROM Analysis", ICON_MD_STORAGE)
.Item("ROM Information", ICON_MD_INFO,
[this]() { OnShowRomInfo(); }, nullptr,
[this]() { return HasActiveRom(); })
.Item("Data Integrity Check", ICON_MD_ANALYTICS,
[this]() { OnRunDataIntegrityCheck(); }, nullptr,
[this]() { return HasActiveRom(); })
.Item("Test Save/Load", ICON_MD_SAVE_ALT,
[this]() { OnTestSaveLoad(); }, nullptr,
[this]() { return HasActiveRom(); })
menu_builder_.BeginSubMenu("ROM Analysis", ICON_MD_STORAGE)
.Item(
"ROM Information", ICON_MD_INFO, [this]() { OnShowRomInfo(); },
nullptr, [this]() { return HasActiveRom(); })
.Item(
"Data Integrity Check", ICON_MD_ANALYTICS,
[this]() { OnRunDataIntegrityCheck(); }, nullptr,
[this]() { return HasActiveRom(); })
.Item(
"Test Save/Load", ICON_MD_SAVE_ALT, [this]() { OnTestSaveLoad(); },
nullptr, [this]() { return HasActiveRom(); })
.EndMenu();
// ZSCustomOverworld submenu
menu_builder_
.BeginSubMenu("ZSCustomOverworld", ICON_MD_CODE)
.Item("Check ROM Version", ICON_MD_INFO,
[this]() { OnCheckRomVersion(); }, nullptr,
[this]() { return HasActiveRom(); })
.Item("Upgrade ROM", ICON_MD_UPGRADE,
[this]() { OnUpgradeRom(); }, nullptr,
[this]() { return HasActiveRom(); })
menu_builder_.BeginSubMenu("ZSCustomOverworld", ICON_MD_CODE)
.Item(
"Check ROM Version", ICON_MD_INFO, [this]() { OnCheckRomVersion(); },
nullptr, [this]() { return HasActiveRom(); })
.Item(
"Upgrade ROM", ICON_MD_UPGRADE, [this]() { OnUpgradeRom(); }, nullptr,
[this]() { return HasActiveRom(); })
.Item("Toggle Custom Loading", ICON_MD_SETTINGS,
[this]() { OnToggleCustomLoading(); })
.EndMenu();
// Asar Integration submenu
menu_builder_
.BeginSubMenu("Asar Integration", ICON_MD_BUILD)
menu_builder_.BeginSubMenu("Asar Integration", ICON_MD_BUILD)
.Item("Asar Status", ICON_MD_INFO,
[this]() { popup_manager_.Show(PopupID::kAsarIntegration); })
.Item("Toggle ASM Patch", ICON_MD_CODE,
[this]() { OnToggleAsarPatch(); }, nullptr,
[this]() { return HasActiveRom(); })
.Item("Load ASM File", ICON_MD_FOLDER_OPEN,
[this]() { OnLoadAsmFile(); })
.Item(
"Toggle ASM Patch", ICON_MD_CODE, [this]() { OnToggleAsarPatch(); },
nullptr, [this]() { return HasActiveRom(); })
.Item("Load ASM File", ICON_MD_FOLDER_OPEN, [this]() { OnLoadAsmFile(); })
.EndMenu();
menu_builder_.Separator();
// Development Tools
menu_builder_
.Item("Memory Editor", ICON_MD_MEMORY,
[this]() { OnShowMemoryEditor(); })
.Item("Memory Editor", ICON_MD_MEMORY, [this]() { OnShowMemoryEditor(); })
.Item("Assembly Editor", ICON_MD_CODE,
[this]() { OnShowAssemblyEditor(); })
.Item("Feature Flags", ICON_MD_FLAG,
@@ -328,19 +332,17 @@ void MenuOrchestrator::AddDebugMenuItems() {
.Separator()
.Item("Performance Dashboard", ICON_MD_SPEED,
[this]() { OnShowPerformanceDashboard(); });
#ifdef YAZE_WITH_GRPC
menu_builder_
.Item("Agent Proposals", ICON_MD_PREVIEW,
[this]() { OnShowProposalDrawer(); });
menu_builder_.Item("Agent Proposals", ICON_MD_PREVIEW,
[this]() { OnShowProposalDrawer(); });
#endif
menu_builder_.Separator();
// ImGui Debug Windows
menu_builder_
.Item("ImGui Demo", ICON_MD_HELP,
[this]() { OnShowImGuiDemo(); })
.Item("ImGui Demo", ICON_MD_HELP, [this]() { OnShowImGuiDemo(); })
.Item("ImGui Metrics", ICON_MD_ANALYTICS,
[this]() { OnShowImGuiMetrics(); });
}
@@ -353,37 +355,41 @@ void MenuOrchestrator::BuildWindowMenu() {
void MenuOrchestrator::AddWindowMenuItems() {
// Sessions Submenu
menu_builder_
.BeginSubMenu("Sessions", ICON_MD_TAB)
.Item("New Session", ICON_MD_ADD,
[this]() { OnCreateNewSession(); }, "Ctrl+Shift+N")
.Item("Duplicate Session", ICON_MD_CONTENT_COPY,
[this]() { OnDuplicateCurrentSession(); }, nullptr,
[this]() { return HasActiveRom(); })
.Item("Close Session", ICON_MD_CLOSE,
[this]() { OnCloseCurrentSession(); }, "Ctrl+Shift+W",
[this]() { return HasMultipleSessions(); })
menu_builder_.BeginSubMenu("Sessions", ICON_MD_TAB)
.Item(
"New Session", ICON_MD_ADD, [this]() { OnCreateNewSession(); },
"Ctrl+Shift+N")
.Item(
"Duplicate Session", ICON_MD_CONTENT_COPY,
[this]() { OnDuplicateCurrentSession(); }, nullptr,
[this]() { return HasActiveRom(); })
.Item(
"Close Session", ICON_MD_CLOSE, [this]() { OnCloseCurrentSession(); },
"Ctrl+Shift+W", [this]() { return HasMultipleSessions(); })
.Separator()
.Item("Session Switcher", ICON_MD_SWITCH_ACCOUNT,
[this]() { OnShowSessionSwitcher(); }, "Ctrl+Tab",
[this]() { return HasMultipleSessions(); })
.Item(
"Session Switcher", ICON_MD_SWITCH_ACCOUNT,
[this]() { OnShowSessionSwitcher(); }, "Ctrl+Tab",
[this]() { return HasMultipleSessions(); })
.Item("Session Manager", ICON_MD_VIEW_LIST,
[this]() { OnShowSessionManager(); })
.EndMenu()
.Separator();
// Layout Management
menu_builder_
.Item("Save Layout", ICON_MD_SAVE,
[this]() { OnSaveWorkspaceLayout(); }, "Ctrl+Shift+S")
.Item("Load Layout", ICON_MD_FOLDER_OPEN,
[this]() { OnLoadWorkspaceLayout(); }, "Ctrl+Shift+O")
.Item(
"Save Layout", ICON_MD_SAVE, [this]() { OnSaveWorkspaceLayout(); },
"Ctrl+Shift+S")
.Item(
"Load Layout", ICON_MD_FOLDER_OPEN,
[this]() { OnLoadWorkspaceLayout(); }, "Ctrl+Shift+O")
.Item("Reset Layout", ICON_MD_RESET_TV,
[this]() { OnResetWorkspaceLayout(); })
.Item("Layout Presets", ICON_MD_BOOKMARK,
[this]() { OnShowLayoutPresets(); })
.Separator();
// Window Visibility
menu_builder_
.Item("Show All Windows", ICON_MD_VISIBILITY,
@@ -391,7 +397,7 @@ void MenuOrchestrator::AddWindowMenuItems() {
.Item("Hide All Windows", ICON_MD_VISIBILITY_OFF,
[this]() { OnHideAllWindows(); })
.Separator();
// Workspace Presets
menu_builder_
.Item("Developer Layout", ICON_MD_DEVELOPER_MODE,
@@ -416,21 +422,18 @@ void MenuOrchestrator::AddHelpMenuItems() {
[this]() { OnShowAsarIntegration(); })
.Item("Build Instructions", ICON_MD_BUILD,
[this]() { OnShowBuildInstructions(); })
.Item("CLI Usage", ICON_MD_TERMINAL,
[this]() { OnShowCLIUsage(); })
.Item("CLI Usage", ICON_MD_TERMINAL, [this]() { OnShowCLIUsage(); })
.Separator()
.Item("Supported Features", ICON_MD_CHECK_CIRCLE,
[this]() { OnShowSupportedFeatures(); })
.Item("What's New", ICON_MD_NEW_RELEASES,
[this]() { OnShowWhatsNew(); })
.Item("What's New", ICON_MD_NEW_RELEASES, [this]() { OnShowWhatsNew(); })
.Separator()
.Item("Troubleshooting", ICON_MD_BUILD_CIRCLE,
[this]() { OnShowTroubleshooting(); })
.Item("Contributing", ICON_MD_VOLUNTEER_ACTIVISM,
[this]() { OnShowContributing(); })
.Separator()
.Item("About", ICON_MD_INFO,
[this]() { OnShowAbout(); }, "F1");
.Item("About", ICON_MD_INFO, [this]() { OnShowAbout(); }, "F1");
}
// Menu state management
@@ -530,8 +533,9 @@ void MenuOrchestrator::OnUndo() {
if (current_editor) {
auto status = current_editor->Undo();
if (!status.ok()) {
toast_manager_.Show(absl::StrFormat("Undo failed: %s", status.message()),
ToastType::kError);
toast_manager_.Show(
absl::StrFormat("Undo failed: %s", status.message()),
ToastType::kError);
}
}
}
@@ -543,8 +547,9 @@ void MenuOrchestrator::OnRedo() {
if (current_editor) {
auto status = current_editor->Redo();
if (!status.ok()) {
toast_manager_.Show(absl::StrFormat("Redo failed: %s", status.message()),
ToastType::kError);
toast_manager_.Show(
absl::StrFormat("Redo failed: %s", status.message()),
ToastType::kError);
}
}
}
@@ -557,7 +562,7 @@ void MenuOrchestrator::OnCut() {
auto status = current_editor->Cut();
if (!status.ok()) {
toast_manager_.Show(absl::StrFormat("Cut failed: %s", status.message()),
ToastType::kError);
ToastType::kError);
}
}
}
@@ -569,8 +574,9 @@ void MenuOrchestrator::OnCopy() {
if (current_editor) {
auto status = current_editor->Copy();
if (!status.ok()) {
toast_manager_.Show(absl::StrFormat("Copy failed: %s", status.message()),
ToastType::kError);
toast_manager_.Show(
absl::StrFormat("Copy failed: %s", status.message()),
ToastType::kError);
}
}
}
@@ -582,8 +588,9 @@ void MenuOrchestrator::OnPaste() {
if (current_editor) {
auto status = current_editor->Paste();
if (!status.ok()) {
toast_manager_.Show(absl::StrFormat("Paste failed: %s", status.message()),
ToastType::kError);
toast_manager_.Show(
absl::StrFormat("Paste failed: %s", status.message()),
ToastType::kError);
}
}
}
@@ -595,8 +602,9 @@ void MenuOrchestrator::OnFind() {
if (current_editor) {
auto status = current_editor->Find();
if (!status.ok()) {
toast_manager_.Show(absl::StrFormat("Find failed: %s", status.message()),
ToastType::kError);
toast_manager_.Show(
absl::StrFormat("Find failed: %s", status.message()),
ToastType::kError);
}
}
}
@@ -977,7 +985,8 @@ std::string MenuOrchestrator::GetCurrentEditorName() const {
}
// Shortcut key management
std::string MenuOrchestrator::GetShortcutForAction(const std::string& action) const {
std::string MenuOrchestrator::GetShortcutForAction(
const std::string& action) const {
// TODO: Implement shortcut mapping
return "";
}
@@ -992,14 +1001,17 @@ void MenuOrchestrator::RegisterGlobalShortcuts() {
void MenuOrchestrator::OnRunDataIntegrityCheck() {
#ifdef YAZE_ENABLE_TESTING
if (!editor_manager_) return;
if (!editor_manager_)
return;
auto* rom = editor_manager_->GetCurrentRom();
if (!rom || !rom->is_loaded()) return;
if (!rom || !rom->is_loaded())
return;
toast_manager_.Show("Running ROM integrity tests...", ToastType::kInfo);
// This would integrate with the test system in master
// For now, just show a placeholder
toast_manager_.Show("Data integrity check completed", ToastType::kSuccess, 3.0f);
toast_manager_.Show("Data integrity check completed", ToastType::kSuccess,
3.0f);
#else
toast_manager_.Show("Testing not enabled in this build", ToastType::kWarning);
#endif
@@ -1007,10 +1019,12 @@ void MenuOrchestrator::OnRunDataIntegrityCheck() {
void MenuOrchestrator::OnTestSaveLoad() {
#ifdef YAZE_ENABLE_TESTING
if (!editor_manager_) return;
if (!editor_manager_)
return;
auto* rom = editor_manager_->GetCurrentRom();
if (!rom || !rom->is_loaded()) return;
if (!rom || !rom->is_loaded())
return;
toast_manager_.Show("Running ROM save/load tests...", ToastType::kInfo);
// This would integrate with the test system in master
toast_manager_.Show("Save/load test completed", ToastType::kSuccess, 3.0f);
@@ -1020,58 +1034,66 @@ void MenuOrchestrator::OnTestSaveLoad() {
}
void MenuOrchestrator::OnCheckRomVersion() {
if (!editor_manager_) return;
if (!editor_manager_)
return;
auto* rom = editor_manager_->GetCurrentRom();
if (!rom || !rom->is_loaded()) return;
if (!rom || !rom->is_loaded())
return;
// Check ZSCustomOverworld version
uint8_t version = (*rom)[zelda3::OverworldCustomASMHasBeenApplied];
std::string version_str = (version == 0xFF)
? "Vanilla"
: absl::StrFormat("v%d", version);
std::string version_str =
(version == 0xFF) ? "Vanilla" : absl::StrFormat("v%d", version);
toast_manager_.Show(
absl::StrFormat("ROM: %s | ZSCustomOverworld: %s",
rom->title().c_str(), version_str.c_str()),
absl::StrFormat("ROM: %s | ZSCustomOverworld: %s", rom->title().c_str(),
version_str.c_str()),
ToastType::kInfo, 5.0f);
}
void MenuOrchestrator::OnUpgradeRom() {
if (!editor_manager_) return;
if (!editor_manager_)
return;
auto* rom = editor_manager_->GetCurrentRom();
if (!rom || !rom->is_loaded()) return;
toast_manager_.Show(
"Use Overworld Editor to upgrade ROM version",
ToastType::kInfo, 4.0f);
if (!rom || !rom->is_loaded())
return;
toast_manager_.Show("Use Overworld Editor to upgrade ROM version",
ToastType::kInfo, 4.0f);
}
void MenuOrchestrator::OnToggleCustomLoading() {
auto& flags = core::FeatureFlags::get();
flags.overworld.kLoadCustomOverworld = !flags.overworld.kLoadCustomOverworld;
toast_manager_.Show(
absl::StrFormat("Custom Overworld Loading: %s",
flags.overworld.kLoadCustomOverworld ? "Enabled" : "Disabled"),
absl::StrFormat(
"Custom Overworld Loading: %s",
flags.overworld.kLoadCustomOverworld ? "Enabled" : "Disabled"),
ToastType::kInfo);
}
void MenuOrchestrator::OnToggleAsarPatch() {
if (!editor_manager_) return;
if (!editor_manager_)
return;
auto* rom = editor_manager_->GetCurrentRom();
if (!rom || !rom->is_loaded()) return;
if (!rom || !rom->is_loaded())
return;
auto& flags = core::FeatureFlags::get();
flags.overworld.kApplyZSCustomOverworldASM = !flags.overworld.kApplyZSCustomOverworldASM;
flags.overworld.kApplyZSCustomOverworldASM =
!flags.overworld.kApplyZSCustomOverworldASM;
toast_manager_.Show(
absl::StrFormat("ZSCustomOverworld ASM Application: %s",
flags.overworld.kApplyZSCustomOverworldASM ? "Enabled" : "Disabled"),
absl::StrFormat(
"ZSCustomOverworld ASM Application: %s",
flags.overworld.kApplyZSCustomOverworldASM ? "Enabled" : "Disabled"),
ToastType::kInfo);
}
void MenuOrchestrator::OnLoadAsmFile() {
toast_manager_.Show("ASM file loading not yet implemented", ToastType::kWarning);
toast_manager_.Show("ASM file loading not yet implemented",
ToastType::kWarning);
}
void MenuOrchestrator::OnShowAssemblyEditor() {

51
src/app/editor/system/menu_orchestrator.h
View File

@@ -39,16 +39,13 @@ class PopupManager;
class MenuOrchestrator {
public:
// Constructor takes references to the managers it coordinates with
MenuOrchestrator(EditorManager* editor_manager,
MenuBuilder& menu_builder,
RomFileManager& rom_manager,
ProjectManager& project_manager,
MenuOrchestrator(EditorManager* editor_manager, MenuBuilder& menu_builder,
RomFileManager& rom_manager, ProjectManager& project_manager,
EditorRegistry& editor_registry,
SessionCoordinator& session_coordinator,
ToastManager& toast_manager,
PopupManager& popup_manager);
ToastManager& toast_manager, PopupManager& popup_manager);
~MenuOrchestrator() = default;
// Non-copyable due to reference members
MenuOrchestrator(const MenuOrchestrator&) = delete;
MenuOrchestrator& operator=(const MenuOrchestrator&) = delete;
@@ -66,7 +63,7 @@ class MenuOrchestrator {
// Menu state management
void ClearMenu();
void RefreshMenu();
// Menu item callbacks (delegated to appropriate managers)
void OnOpenRom();
void OnSaveRom();
@@ -75,7 +72,7 @@ class MenuOrchestrator {
void OnOpenProject();
void OnSaveProject();
void OnSaveProjectAs();
// Edit menu actions (delegate to current editor)
void OnUndo();
void OnRedo();
@@ -83,7 +80,7 @@ class MenuOrchestrator {
void OnCopy();
void OnPaste();
void OnFind();
// Editor-specific menu actions
void OnSwitchToEditor(EditorType editor_type);
void OnShowEditorSelection();
@@ -92,13 +89,13 @@ class MenuOrchestrator {
void OnShowEmulator();
void OnShowCardBrowser();
void OnShowWelcomeScreen();
#ifdef YAZE_WITH_GRPC
void OnShowAIAgent();
void OnShowChatHistory();
void OnShowProposalDrawer();
#endif
// Session management menu actions
void OnCreateNewSession();
void OnDuplicateCurrentSession();
@@ -106,7 +103,7 @@ class MenuOrchestrator {
void OnSwitchToSession(size_t session_index);
void OnShowSessionSwitcher();
void OnShowSessionManager();
// Window management menu actions
void OnShowAllWindows();
void OnHideAllWindows();
@@ -117,7 +114,7 @@ class MenuOrchestrator {
void OnLoadDeveloperLayout();
void OnLoadDesignerLayout();
void OnLoadModderLayout();
// Tool menu actions
void OnShowGlobalSearch();
void OnShowCommandPalette();
@@ -126,26 +123,26 @@ class MenuOrchestrator {
void OnShowImGuiMetrics();
void OnShowMemoryEditor();
void OnShowResourceLabelManager();
// ROM Analysis menu actions
void OnShowRomInfo();
void OnCreateBackup();
void OnValidateRom();
void OnRunDataIntegrityCheck();
void OnTestSaveLoad();
// ZSCustomOverworld menu actions
void OnCheckRomVersion();
void OnUpgradeRom();
void OnToggleCustomLoading();
// Asar Integration menu actions
void OnToggleAsarPatch();
void OnLoadAsmFile();
// Editor launch actions
void OnShowAssemblyEditor();
#ifdef YAZE_ENABLE_TESTING
void OnShowTestDashboard();
void OnRunAllTests();
@@ -153,13 +150,13 @@ class MenuOrchestrator {
void OnRunIntegrationTests();
void OnRunE2ETests();
#endif
#ifdef YAZE_WITH_GRPC
void OnStartCollaboration();
void OnJoinCollaboration();
void OnShowNetworkStatus();
#endif
// Help menu actions
void OnShowAbout();
void OnShowKeyboardShortcuts();
@@ -172,7 +169,7 @@ class MenuOrchestrator {
void OnShowContributing();
void OnShowWhatsNew();
void OnShowSupportedFeatures();
// Additional File menu actions
void OnShowSettings();
void OnQuit();
@@ -187,10 +184,10 @@ class MenuOrchestrator {
SessionCoordinator& session_coordinator_;
ToastManager& toast_manager_;
PopupManager& popup_manager_;
// Menu state
bool menu_needs_refresh_ = false;
// Helper methods for menu construction
void AddFileMenuItems();
void AddEditMenuItems();
@@ -199,7 +196,7 @@ class MenuOrchestrator {
void AddDebugMenuItems();
void AddWindowMenuItems();
void AddHelpMenuItems();
// Menu item validation helpers
bool CanSaveRom() const;
bool CanSaveProject() const;
@@ -207,12 +204,12 @@ class MenuOrchestrator {
bool HasActiveProject() const;
bool HasCurrentEditor() const;
bool HasMultipleSessions() const;
// Menu item text generation
std::string GetRomFilename() const;
std::string GetProjectName() const;
std::string GetCurrentEditorName() const;
// Shortcut key management
std::string GetShortcutForAction(const std::string& action) const;
void RegisterGlobalShortcuts();

Some files were not shown because too many files have changed in this diff Show More