- Introduced advanced room properties UI in the Dungeon Editor, allowing users to set effects and tags for rooms through dropdown menus.
- Updated the rendering logic to visualize room layouts, including walls, floors, pits, water, and doors, with appropriate color coding for clarity.
- Improved texture management by processing texture updates immediately to ensure objects appear correctly in the editor.
- Organized ROM address constants into a new header file for better maintainability and clarity in the codebase.
- Refactored existing code to utilize the new constants, ensuring a cleaner and more consistent naming convention.
- Introduced a new Debug Controls card in the Dungeon Editor V2, allowing runtime control over debug logging and log levels.
- Implemented UI elements for enabling/disabling debug logs, selecting log levels, and managing room rendering and texture processing.
- Updated the DungeonEditorV2 class to include visibility management for the Debug Controls card and integrated it into the control panel.
- Enhanced logging functionality in the LogManager to support runtime adjustments for debug logging.
- Deleted outdated DUNGEON_EDITOR_COMPLETE_GUIDE.md and DUNGEON_EDITOR_GUIDE.md files to streamline documentation.
- Introduced a new F2-dungeon-editor-v2-guide.md that consolidates features, architecture, and usage instructions for the Dungeon Editor V2.
- Documented recent refactoring efforts, including critical bug fixes and architectural improvements.
- Enhanced the guide with structured sections for quick start, testing, and troubleshooting, reflecting the current production-ready status of the Dungeon Editor.
- Updated related source files to support new documentation structure and features.
- Added TextureAtlas class to manage multiple textures packed into a single large texture, improving rendering performance and reducing GPU state changes.
- Implemented methods for allocating regions, packing bitmaps, and drawing regions from the atlas.
- Removed the DrawDungeonTabView function from DungeonCanvasViewer as it is no longer needed with the new EditorCard system.
- Updated CMake configuration to include texture_atlas.cc in the build process.
- Refactored Room class to eliminate dependency on Arena graphics sheets, transitioning to per-room graphics for rendering.
- Introduced a new DUNGEON_EDITOR_COMPLETE_GUIDE.md that details the features, architecture, and usage of the Dungeon Editor.
- Documented critical bug fixes, including segfaults and loading order issues, along with their resolutions.
- Enhanced the guide with a structured overview, quick start instructions, and troubleshooting tips for users.
- Updated the architecture section to reflect the new card-based system and self-contained room management.
- Included detailed testing commands and expected outputs to assist developers in verifying functionality.
- Deleted the old D1-dungeon-editor-guide.md and F1-dungeon-editor-guide.md files to streamline documentation.
- Introduced a new DUNGEON_EDITOR_GUIDE.md that consolidates features, architecture, and usage instructions for the Dungeon Editor.
- Updated the development guide to include new naming conventions and clarified rendering processes.
- Enhanced the overall structure and content of the documentation to reflect the current production-ready status of the Dungeon Editor.
- Replaced the deprecated DungeonEditor with DungeonEditorV2, implementing a card-based architecture for improved UI management.
- Updated CMakeLists.txt to reflect changes in source file organization, including renaming dungeon_editor files to their V2 counterparts.
- Refactored DungeonCanvasViewer to support per-room layer visibility settings and updated related methods for rendering and layer management.
- Enhanced testing framework to accommodate the new DungeonEditorV2 structure, including updates to smoke tests and integration tests.
- Removed legacy dungeon_editor files to streamline the codebase and prevent confusion with the new implementation.
- Indented the inclusion of the net library in CMake for better readability.
- Updated room ID validation in DungeonEditorV2 to use a constant value for room limits.
- Enhanced the LoadDoors, LoadTorches, LoadBlocks, and LoadPits methods in the Room class to include detailed logging and improved data handling from ROM, preparing for future implementations of door, torch, block, and pit loading.
- Added a new document, E5-debugging-guide.md, providing comprehensive strategies for debugging and testing the `yaze` application, including logging practices and testing frameworks.
- Updated E2-development-guide.md to include a new section on debugging and testing, detailing quick debugging methods using command-line flags for specific editors and UI cards.
- Enhanced the main application to support command-line flags for opening specific editors and cards on startup, improving the developer experience.
- Refactored the Controller class to handle startup editor and card initialization based on command-line inputs.
- Implemented controls for toggling visibility of background layers BG1 and BG2 in the DungeonCanvasViewer.
- Added a dropdown for selecting the type of BG2 layer, allowing for different rendering effects (Normal, Translucent, Addition, Dark, Off).
- Updated rendering logic to respect visibility settings and apply the selected alpha values for BG2 layer rendering.
- Enhanced debug logging to provide detailed information about bitmap states and rendering processes for both background layers.
- Deleted the ManualObjectRenderer and DungeonRenderer classes to streamline the codebase and reduce redundancy.
- Updated DungeonCanvasViewer and DungeonEditorV2 to remove references to the deleted renderers, ensuring proper functionality without them.
- Enhanced the rendering logic in DungeonCanvasViewer to directly handle object rendering and background layers, improving performance and maintainability.
- Added debug logging to track rendering processes and ensure proper graphics loading.
- Introduced new shortcut categories for graphics, screen, and sprite editors, improving accessibility and organization.
- Updated DungeonEditorV2 and other editor classes to register cards with the EditorCardManager, allowing for better control and visibility management.
- Refactored shortcut registration for dungeon, graphics, screen, and sprite editors, ensuring consistent user experience across the application.
- Improved initialization processes to handle dynamic card visibility and shortcuts effectively.
- Added EditorCardManager to handle registration, visibility, and management of editor cards.
- Integrated card shortcuts and dynamic menu sections for improved user experience in the dungeon editor.
- Registered multiple dungeon-related cards with associated shortcuts for quick access.
- Enhanced DungeonEditorV2 to utilize the new card management system, allowing independent control of editor cards.
- Updated UI components to support card-based editors, improving layout and usability.
- Introduced ManualObjectRenderer class to facilitate manual rendering of dungeon objects for debugging purposes.
- Integrated manual renderer initialization in DungeonEditorV2, allowing for testing and debugging of object rendering.
- Added methods for rendering simple blocks, test patterns, and debugging graphics sheets.
- Updated dungeon_editor_v2.cc and dungeon_editor_v2.h to include the new manual renderer functionality.
- Updated DungeonCanvasViewer and DungeonEditor to render room objects as primitives temporarily for debugging purposes.
- Enhanced object interaction with new context menu options for deleting, copying, and pasting selected objects.
- Implemented drag-and-drop functionality for moving selected objects within the dungeon.
- Added texture processing for background layers and deferred texture commands to optimize rendering performance.
- Refactored code for clarity and maintainability, ensuring better handling of object interactions and rendering logic.
- Added new UI components for the emulator, including dedicated panels for CPU and APU debugging, improving user interaction and debugging capabilities.
- Implemented a caching mechanism for rendered objects in the DungeonCanvasViewer to optimize performance and reduce rendering time.
- Updated the CMake configuration to include new UI source files, ensuring proper organization and build management.
- Enhanced the theme manager with improved color definitions for better visibility and consistency across the UI.
- Refactored the emulator interface to delegate rendering tasks to the UI layer, streamlining the codebase and improving maintainability.
- Updated the testing guide to clarify the testing framework's organization and execution methods, improving user understanding.
- Refactored CMakeLists to include new platform-specific files, ensuring proper integration of the rendering backend.
- Modified main application files to utilize the new IRenderer interface, enhancing flexibility in rendering operations.
- Implemented deferred texture management in various components, allowing for more efficient graphics handling and improved performance.
- Introduced new methods for texture creation and updates, streamlining the rendering process across the application.
- Enhanced logging and error handling in the rendering pipeline to facilitate better debugging and diagnostics.
- Introduced ObjectEditorCard to consolidate object selection, emulator preview, and interaction controls into a single interface.
- Updated DungeonCanvasViewer to support object interaction context and handle mouse input for object selection and placement.
- Enhanced DungeonEditorV2 with new room graphics card for visualizing room graphics and improved layout for better user experience.
- Refactored existing components to accommodate the new unified editor, streamlining the workflow for managing dungeon objects.
- Added JumpToDungeonRoom and JumpToOverworldMap methods to facilitate quick navigation between dungeon and overworld editors.
- Introduced SwitchToEditor method to manage editor tab activation based on the selected editor type.
- Enhanced DungeonEditorV2 with room and entrance selection capabilities, improving user experience and workflow efficiency.
- Updated header files to declare new methods and ensure proper integration within the editor management system.
- Added critical logging for graphics buffer management in LoadAllGraphicsData to prevent data corruption during ROM loads.
- Updated logging levels from INFO to DEBUG across various components for consistency and to reduce log verbosity.
- Refactored texture creation and palette application logic to allow editors to manage their own rendering, improving flexibility and user experience.
- Improved background buffer handling to ensure fresh bitmap creation only when necessary, optimizing performance.
- Enhanced debugging output for canvas and performance tracking, aiding in better diagnostics during development.
- Introduced a new PaletteEditorWidget for visual editing of dungeon palettes, allowing users to select and modify colors.
- Integrated palette editor into DungeonEditorV2, enabling real-time updates and re-rendering of rooms upon palette changes.
- Enhanced GUI layout to include a dedicated palette editor card, improving user experience and accessibility.
- Implemented callback functionality to notify when palette changes occur, ensuring seamless integration with room rendering.
- Updated DungeonCanvasViewer to check and render room-specific graphics, improving rendering efficiency.
- Enhanced LoadAndRenderRoomGraphics to include detailed logging for better debugging.
- Refactored room rendering methods to utilize individual background buffers instead of global arena buffers, ensuring accurate graphics representation.
- Improved room diagnostic functionality to verify background buffer states specific to each room.
- Added critical checks and logging in BackgroundBuffer to ensure proper tile rendering and bitmap management.
- Added DungeonObjectEmulatorPreview for rendering dungeon objects using the SNES emulator, allowing real-time visualization of object graphics.
- Implemented ObjectDrawer class to handle drawing of various object types to background buffers, utilizing game-specific patterns.
- Updated DungeonCanvasViewer to integrate object rendering and improve background layer management.
- Enhanced DungeonEditorV2 to support the new emulator preview, providing a more interactive editing experience.
- Improved error handling and logging for better debugging during object rendering operations.
- Added a helper method, MakeCardTitle, to generate session-aware titles for editor cards based on the current session context.
- Updated various editor files to utilize the new MakeCardTitle method, ensuring consistent card naming across multiple sessions.
- Refactored card initialization in AssemblyEditor, GraphicsEditor, DungeonEditorV2, OverworldEditor, and SpriteEditor to support dynamic session titles, enhancing user experience and clarity.
- Removed PushID and PopID calls in EditorManager to prevent ID stack corruption, relying on window titles for uniqueness.
- Updated ImGui window size and position settings to use FirstUseEver for maximizing on first open, enhancing user experience.
- Replaced AgentUI::PopPanelStyle with ImGui::PopStyleColor in multiple locations for consistency in style management.
- Ensured all EditorCard instances consistently call End after Begin, improving code clarity and preventing potential rendering issues.
- Introduced a new language definition for the 65816 assembly language, improving syntax highlighting and code editing capabilities.
- Updated the AssemblyEditor to utilize the new language definition and integrated a toolset for file management actions, enhancing user experience.
- Refactored the file handling logic to support dynamic file opening and saving, ensuring better resource management within the editor.
- Removed deprecated tab view code, transitioning to a more modular card-based layout for active files, improving UI responsiveness and organization.
- Added InitializeForTesting method in Rom class to facilitate testing setup.
- Updated DungeonCanvasViewer to adjust object and sprite sizes from 16x16 to 8x8, improving rendering accuracy.
- Modified rendering logic for various dungeon objects (chests, doors, walls, pots) to reflect new size calculations.
- Adjusted object position calculations in ObjectRenderer to align with the new size metrics, ensuring consistent rendering across the application.
- Updated integration tests to verify the new initialization method for ROM objects.
- Introduced lazy loading for room data to optimize performance and reduce initial load times.
- Updated DungeonEditor and DungeonRoomLoader to handle room graphics rendering directly from room objects.
- Refactored methods to accept room references instead of IDs for better clarity and type safety.
- Enhanced tab management in the DungeonEditor UI for improved user experience.
- Added DungeonEditorV2 to streamline dungeon editing by delegating tasks to specialized components.
- Implemented comprehensive integration tests to validate functionality and ensure proper ROM handling.
- Achieved 100% pass rate for all integration tests, enhancing reliability and performance of the editor.
- Updated test suite to include tests for the new editor, ensuring robust coverage and error handling.
- Deleted the PerformanceMonitor implementation and header files as functionality has been fully integrated into gfx::PerformanceProfiler.
- Updated all relevant source files to replace PerformanceMonitor and ScopedTimer with their gfx counterparts, ensuring consistent performance monitoring across the application.
- Refactored the LoadAllRooms method to utilize multithreading for improved performance during dungeon room loading.
- Introduced thread-safe data structures and a task-based approach to process room loading in parallel, optimizing resource usage.
- Added performance logging to track the number of threads and rooms processed, enhancing monitoring capabilities.
- Ensured thread safety when collecting results for room sizes and palettes, maintaining data integrity.
- Added performance monitoring capabilities using ScopedTimer in the DungeonEditor, PaletteEditor, ScreenEditor, MessageEditor, MusicEditor, SpriteEditor, and SettingsEditor classes to track loading times.
- Enhanced the Load methods in each editor to include timing for critical operations, improving performance analysis and optimization.
- Removed unnecessary debug output in the Sprite class to clean up the codebase.
- Updated CMakeLists.txt to silence C++23 deprecation warnings and added definitions for intrinsic int128 support.
- Modified GitHub Actions workflow to handle missing asset directories gracefully and ensure correct versioning in Info.plist.
- Refactored string handling in multiple source files to use std::memcpy for safer string copying, preventing potential buffer overflows.
- Improved font loading logic and ensured consistent handling of theme properties in the editor.
- Added 'absl::numeric' to the AdditionalLibraryDirectories in yaze.vcxproj for enhanced functionality.
- Refactored string handling in multiple source files to use std::strncpy for safer string copying and prevent buffer overflows.
- Cleaned up unnecessary whitespace and improved code readability across various files.
- Removed the homepage display logic and replaced it with a welcome screen that appears when no ROM is loaded or no active editors are present.
- Enhanced session management by iterating through all sessions to check for active editors, allowing for better multi-session docking.
- Introduced new methods for generating unique editor titles based on session context and added feature flags for per-session configurations.
- Added safeguards for ROM loading state checks in editor methods to prevent operations on unloaded ROMs.
- Introduced new rendering methods for various object types including stairs, chests, doors, walls, pots, and sprites, improving visual representation in the dungeon canvas.
- Updated the DrawDungeonCanvas method to streamline object rendering and enhance graphics handling.
- Added detailed layer information overlay to provide context on room objects and sprites.
- Implemented object dimension calculations for walls to ensure accurate rendering based on size properties.
- Improved fallback rendering for objects without valid graphics, enhancing user experience during object placement and editing.
- Integrated new components: DungeonToolset, DungeonObjectInteraction, DungeonRenderer, DungeonRoomLoader, and DungeonUsageTracker to streamline dungeon editing functionalities.
- Updated DungeonEditor to utilize the new components for room loading, object interaction, and rendering, improving code organization and maintainability.
- Enhanced object selection and placement features, including drag-and-drop functionality and improved UI interactions.
- Removed legacy methods and refactored existing code to delegate responsibilities to the new components, ensuring a cleaner architecture.
- Added support for usage tracking of blocksets, spritesets, and palettes across dungeon rooms, providing insights for optimization.
- Added methods for object selection rectangle handling, including CheckForObjectSelection, DrawObjectSelectRect, and SelectObjectsInRect.
- Enhanced DungeonEditor to support right-click drag selection for multiple objects, improving user interaction and object management.
- Updated the UI in DungeonObjectSelector to optimize object previews and improve layout for better visibility.
- Refactored various sections of DungeonEditor for code clarity and consistency, including adjustments to object rendering and selection processes.
- Deleted the `dungeon-integration-tests.md` file, which contained comprehensive integration tests for the dungeon object rendering system.
- Added `dungeon-object-system.md`, detailing the architecture, object types, placement processes, rendering pipeline, and user interface components of the YAZE Dungeon Object System.
- Enhanced the DungeonEditor and DungeonObjectSelector with improved UI methods and object selection callbacks for better user interaction and object management.
- Replaced vertical separators with standard separators in the EditorManager's menu bar for consistency.
- Introduced a new room selection callback mechanism in DungeonRoomSelector to facilitate room selection events.
- Enhanced DungeonEditor with drag-and-select functionality for object placement, improving user interaction.
- Added an object browser in DungeonObjectSelector for better object management and preview capabilities.
- Streamlined object rendering and selection processes, ensuring a more intuitive editing experience.
- Introduced a detailed design plan document for the Yaze Dungeon Editor, outlining the current architecture, main components, and core systems.
- Documented identified issues and applied fixes, including crash prevention and UI simplification, along with a roadmap for future development phases.
- Enhanced clarity on the implementation guidelines, testing strategies, and performance considerations to support ongoing development efforts.
- Established a structured approach for new developers to understand the codebase and contribute effectively to the project.
- Introduced new classes for DungeonRoomSelector and DungeonObjectSelector to enhance room and object management within the dungeon editor.
- Implemented UI components for selecting rooms and entrances, allowing users to easily navigate and manage dungeon layouts.
- Added functionality for rendering room graphics and object previews, improving the visual editing experience.
- Updated the DungeonEditor class to integrate the new selectors, streamlining the overall editing workflow.
- Enhanced error handling and validation in room and object management processes to ensure robust functionality.
- Refactored the DungeonEditor class to include new methods for loading and rendering room graphics, improving the overall graphics management system.
- Introduced LoadAndRenderRoomGraphics and ReloadAllRoomGraphics methods to streamline the loading process for room graphics.
- Updated the UI to provide buttons for loading room graphics and reloading all graphics, enhancing user interaction.
- Improved background rendering logic by adding RenderRoomBackgroundLayers, ensuring proper layering of graphics.
- Adjusted data types in UI text displays for better accuracy and consistency in rendering information.
- Introduced a new documentation file detailing the Yaze Dungeon Editor, covering its architecture, core components, coordinate system, object rendering system, user interface, and integration with ZScream.
- Included sections on usage examples, testing and validation strategies, and future enhancements to provide a complete overview of the editor's capabilities.
- Removed the outdated dungeon object rendering refactor documentation to streamline resources and focus on the comprehensive guide.
- Enhanced clarity and organization of the documentation to support both novice and expert users in effectively utilizing the dungeon editing tools.
- Introduced a new DungeonEditorSystem to streamline dungeon editing functionalities, including room properties management and object editing.
- Enhanced the DungeonEditor class to initialize the new editor system and manage room properties effectively.
- Added comprehensive object editing capabilities with a dedicated DungeonObjectEditor, supporting object insertion, deletion, and real-time preview.
- Implemented improved UI components for editing dungeon settings, including integrated editing panels for various object types.
- Enhanced error handling and validation throughout the dungeon editing process to ensure robust functionality.
- Updated integration tests to cover new features and validate the overall performance of the dungeon editing system.
- Introduced new object rendering features in DungeonEditor, allowing for improved visualization of dungeon objects with options to show outlines, render objects, and display object information.
- Implemented a caching mechanism for rendered objects to optimize performance.
- Added functionality to load and manage room layouts, including walls, floors, and other structural elements, enhancing the overall editing experience.
- Refactored object handling in Room and RoomObject classes to support new rendering logic and ensure compatibility with the updated layout system.
- Introduced ObjectParser for efficient parsing of object data directly from ROM, improving reliability and performance in object rendering.
