- Improved handling of single and double clicks for tile selection and editing in OverworldEditor, allowing for more intuitive user interactions.
- Added logging for tile selection actions to aid debugging and user feedback.
- Updated Tile16Editor to ensure proper synchronization with the overworld editor during tile changes, enhancing workflow reliability.
- Implemented critical fixes in Canvas to prevent ImGui assertions by ensuring minimum canvas size during rendering.
- Updated Tile16Editor to regenerate blockset atlas directly from ROM data, bypassing problematic tile cache.
- Enhanced clipboard functionality to extract tile data directly from the atlas, improving reliability.
- Refactored Arena class shutdown process to ensure safe cleanup of resources, preventing double-free issues.
- Optimized Canvas rendering logic to utilize pre-calculated values for improved performance with large selections.
- Added RefreshMultiAreaMapsSafely method to handle large, wide, and tall area maps without recursion, preventing segmentation faults.
- Updated tile application logic to directly use the currently selected tile, enhancing stability during rectangle selections.
- Improved logging for tile updates and error handling, ensuring better debugging and user feedback.
- Cleared selection state after applying changes to maintain a clean editor state.
- Added logging for rectangle selection and tile processing to aid debugging.
- Implemented bounds checks during tile selection to prevent crashes.
- Disabled sibling refresh for large maps to avoid infinite recursion, addressing segmentation faults.
- Updated comments for clarity and future implementation considerations.
- Removed pre-rendering of tiles to avoid issues with tile cache.
- Updated tile drawing logic to directly use the atlas texture, enhancing stability and performance.
- Added bounds checks and UV coordinate calculations for improved rendering accuracy.
- Integrated performance profiling using ScopedTimer in GraphicsEditor and ScreenEditor for better timing insights.
- Implemented batch texture updates in GraphicsEditor and ScreenEditor to reduce individual texture update calls, improving rendering efficiency.
- Enhanced tile rendering in ScreenEditor with pre-allocated vectors for batch operations, optimizing drawing performance.
- Added safety checks and validation in various components to prevent crashes and ensure data integrity during rendering operations.
- Updated Bitmap and Arena classes to support improved texture management and synchronization, enhancing overall graphics performance.
- Introduced the AtlasRenderer class for efficient texture management and batch rendering, significantly reducing draw calls.
- Added RenderTilesBatch function in Tilemap for rendering multiple tiles in a single operation, enhancing performance.
- Implemented memory management features including automatic atlas defragmentation and UV coordinate mapping.
- Integrated performance monitoring dashboard to track atlas statistics and rendering efficiency.
- Developed a benchmarking suite to validate performance improvements and ensure accuracy in rendering speed.
- Enhanced existing graphics components to utilize the new atlas rendering system, improving overall responsiveness in the YAZE editor.
- Removed conditional linking of yaze_c library for extract_vanilla_values, clarifying that it operates as a standalone utility.
- Updated comments to reflect the core ROM functionality requirements for the utility, enhancing code clarity.
- Added RenderBitmap and GetUVCoordinates methods to AtlasRenderer for improved bitmap rendering capabilities.
- Introduced RenderTilesBatch function in Tilemap for batch rendering of tiles using atlas, reducing draw calls and enhancing performance.
- Updated Clear method in AtlasRenderer to properly clean up SDL textures.
- Enhanced performance monitoring in PerformanceDashboard to include atlas renderer statistics.
- Added unit tests to benchmark atlas rendering performance, confirming efficiency improvements over individual rendering.
- Deleted clipboard-related files (clipboard.cc, clipboard.h, clipboard.mm) to streamline the codebase.
- Added a performance dashboard in the EditorManager to monitor performance metrics and improve user experience.
- Integrated performance monitoring capabilities across various editors, allowing for detailed timing of critical operations.
- Updated the graphics system with batch processing for texture updates, significantly improving rendering performance.
- Introduced a memory pool allocator for efficient memory management during graphics operations.
- Introduced a new PerformanceProfiler class for detailed timing and performance measurement across graphics operations.
- Implemented a smart tile cache with LRU eviction in the TileCache structure to optimize memory usage and improve tile rendering efficiency.
- Updated various graphics components to utilize the new caching system, reducing redundant texture updates and enhancing overall performance.
- Added dirty region tracking in Bitmap for efficient texture updates, minimizing the area that needs to be refreshed during rendering.
- Enhanced existing methods to leverage performance monitoring, providing insights into operation durations and potential bottlenecks.
- Introduced a detailed comparison document highlighting the functional equivalence between ZScream (C#) and YAZE (C++) overworld loading logic.
- Verified key areas such as tile loading, expansion detection, map decompression, and coordinate calculations, confirming consistent behavior across both implementations.
- Documented differences and improvements in YAZE, including enhanced error handling and memory management.
- Provided validation results from integration tests ensuring data integrity and compatibility with existing ROMs.
- Implemented on-demand refresh for overworld maps, optimizing updates based on visibility and modifications.
- Introduced a new method to ensure textures are loaded before drawing, improving user experience with loading indicators.
- Increased the number of textures processed per frame for faster loading times, enhancing performance during map transitions.
- Updated the release workflow to enable additional testing configurations for YAZE builds.
- Introduced a new feature flag for performance monitoring in the FeatureFlags class, allowing users to enable or disable monitoring.
- Updated the ScopedTimer class to respect the performance monitoring flag, ensuring that timing operations are no-ops when monitoring is disabled.
- Enhanced the PerformanceMonitor class with methods to set and check the enabled state of performance monitoring, improving flexibility for production builds.
- 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.
- Introduced PerformanceMonitor and ScopedTimer classes for tracking operation durations, enhancing performance analysis during ROM loading and rendering.
- Integrated performance monitoring into the OverworldEditor and Overworld classes, allowing for detailed timing of critical operations.
- Implemented deferred texture creation strategies to optimize loading times and reduce main thread blocking.
- Updated relevant methods to utilize performance monitoring, providing insights into loading efficiency and potential bottlenecks.
- Introduced steps to prepare a download cache for vcpkg on both Windows and macOS, improving build efficiency and reducing download times.
- Ensured that the cache directories are created conditionally based on the operating system, maintaining compatibility across platforms.
- Updated the concurrency group in the release workflow to include the event name for better tracking.
- Split macOS builds into separate jobs for arm64 and x86_64 architectures, improving clarity and organization.
- Added a new job to merge macOS slices into a universal binary, streamlining the packaging process.
- Refined the installation steps for macOS dependencies and vcpkg setup for consistency across architectures.
- Improved artifact upload steps to include staged outputs and ensure proper retention.
- Introduced a detailed documentation guide for testing the YAZE overworld implementation, covering unit tests, integration tests, end-to-end tests, and golden data validation.
- Added a new script to orchestrate the complete testing workflow, including building the golden data extractor, running tests, and generating reports.
- Implemented new test files for end-to-end testing and integration testing, ensuring compatibility with ZScream logic and validating overworld data integrity.
- Enhanced the Overworld class with additional methods for expanded tile and entrance handling, improving test coverage and functionality.
- Updated the concurrency group in the release workflow to use a more consistent reference for tags.
- Enhanced the release notes generation logic for clarity and consistency.
- Improved logging in Tile16Editor to provide better insights during bitmap updates and error handling.
- Refactored the UpdateBlocksetBitmap method to ensure proper handling of active bitmaps and pixel copying, enhancing the editor's responsiveness.
- Simplified the logic for creating release notes by replacing heredoc syntax with echo commands for better readability.
- Ensured consistent formatting of release notes with clear headers and references to the changelog.
- Changed the storage of current tile16 data from a static variable to an instance variable for better persistence.
- Added a new method to update the blockset bitmap displayed in the editor, ensuring it reflects the current tile16 data.
- Enhanced the DrawToCurrentTile16 method to include updates to the blockset bitmap after drawing.
- Updated the CMake configuration for the tile edit table to ensure proper initialization.
- Added concurrency control to the release workflow to manage simultaneous runs.
- Improved permissions settings for actions and contents.
- Refactored tag validation logic to streamline the process and ensure semantic versioning compliance.
- Updated job names for clarity and consistency.
- Integrated caching for ccache to speed up builds on Linux and macOS.
- Enhanced packaging steps for Windows, macOS, and Linux, ensuring proper artifact handling and uploads.
- Improved error handling and output messages for better debugging and user experience.
- Updated the CMake configuration in `release.yml` to enable the building of tests by setting `YAZE_BUILD_TESTS` to ON.
- This change allows for the inclusion of test frameworks in the build, enhancing the testing capabilities of the project.
- Added preprocessor directives to include testing-related headers and initialize test suites only when YAZE_ENABLE_TESTING is defined.
- This change enhances the modularity of the code by allowing for optional testing features based on the build configuration.
- Removed the custom target for copying assets and integrated post-build commands directly into the yaze target.
- Updated commands to create necessary directories and copy asset files (fonts, themes, layouts, libraries) to the output directory, streamlining the build process for Windows and Linux.
- Updated `CMakeLists.txt` to configure asset deployment for macOS, Windows, and Linux, ensuring proper handling of resource files based on the target platform.
- Added custom build steps in `app.cmake` to copy asset files (fonts, themes, layouts, libraries) to the output directory for Windows and Linux builds, improving the build process and asset accessibility.
- Organized asset files into source groups for better project structure and clarity.
- Updated the `SetupTestEnvironment` function in `yaze_test.cc` to replace `setenv` with `SDL_setenv` for setting environment variables, enhancing cross-platform compatibility for test configurations.
- Changed the vcpkg Git commit ID to a specific version for consistency in builds.
- Refactored the CMake configuration steps to use PowerShell syntax, enhancing readability and maintainability.
- Improved the packaging process for Windows, macOS, and Linux by utilizing PowerShell commands and ensuring proper handling of binaries, assets, and documentation.
- Added checks for the existence of required files and directories, providing clearer error messages and improving the robustness of the workflow.
- Deleted `YAZE.sln`, `YAZE.vcxproj`, and `YAZE.vcxproj.filters` to streamline the project structure and transition to a CMake-based build system.
- This change enhances maintainability and simplifies the build process by relying solely on CMake for project configuration and management.
- Updated `CMakeLists.txt` to improve vcpkg integration by adding checks for the existence of the toolchain file and providing warnings if it is not found.
- Introduced new CMake presets for Windows ARM64 configurations (debug, release, and development) in `CMakePresets.json`, ensuring proper setup for ARM64 architecture.
- Modified `setup-vcpkg-windows.ps1` to auto-detect ARM64 architecture, enhancing the setup script's usability for different environments.
- Updated `CMakeLists.txt` to improve the generation and inclusion of `yaze_config.h` by specifying source and binary directories.
- Added include directories in various CMake files to ensure proper access to generated headers, enhancing build reliability and maintainability.
- Set properties for the generated header to improve IDE integration and organization within the project structure.
- Updated `YAZE.vcxproj` to include multiple additional library directories and dependencies for various build configurations (Debug and Release) across multiple platforms (Win32, x64, ARM64).
- This enhancement improves the project's build configuration by ensuring all necessary libraries are linked, facilitating better integration of external components and improving overall build reliability.
- Introduced a pre-build event in `YAZE.vcxproj` to automatically create the `yaze_config.h` file, defining versioning macros for the project.
- This change enhances the build process by ensuring the configuration header is generated in the appropriate build directory, improving maintainability and version tracking.
- Introduced a custom build step in `YAZE.vcxproj` to generate the `yaze_config.h` file, defining versioning macros for different build configurations (Debug and Release) across multiple platforms (Win32, x64, ARM64).
- This enhancement streamlines the build process by automating the creation of configuration headers, improving maintainability and version tracking.
- Updated `YAZE.vcxproj` to include multiple source and library directories in the `AdditionalIncludeDirectories` section, enhancing the project's build configuration and improving code accessibility for IntelliSense.
- This change supports better organization of project files and facilitates easier integration of external libraries and modules.
- Modified build and configure targets in `YAZE.vcxproj` to use platform-specific build directories, enhancing compatibility with multiple architectures.
- Added comprehensive source and header file inclusions for Visual Studio IntelliSense, improving development experience and code navigation.
- Included resource, image, and content files in the project structure, ensuring all necessary assets are accounted for in the build process.
- Renamed the main project from "YAZE" to "YAZE_CMake" in the solution file for clarity.
- Updated project configurations to ensure proper handling of Debug and Release builds for x86 and x64 platforms.
- Introduced a new CMake-based build target in `YAZE.vcxproj`, streamlining the build process and improving compatibility with CMake.
- Cleaned up unnecessary import groups and added comments for better maintainability.
- Updated the `builtin-baseline` in `vcpkg.json` to `4bee3f5aae7aefbc129ca81c33d6a062b02fcf3b`, ensuring accurate dependency management.
- Modified the GitHub Actions workflow to reflect the new `vcpkgGitCommitId`, enhancing the reliability of the build process.
- Added a custom command to generate the Windows resource file `yaze.res` from `yaze.rc` and `yaze.ico`, ensuring proper resource management for x64 builds.
- Introduced a custom target to ensure the resource file is built before linking, improving the build process for Windows targets.
- Changed the `builtin-baseline` in `vcpkg.json` to a specific commit ID `d18b2e4129c1ff667b1e660528d6d2678f38c6fc`, ensuring precise dependency management.
- Updated the GitHub Actions workflow to reflect the new `vcpkgGitCommitId`, enhancing the reliability of the build process.
- Added `<cstdlib>` header to `yaze_test.cc`, enabling the use of standard library functions.
- This change enhances the functionality of the test suite by allowing for additional features from the C++ standard library.
- Added conditional linking of the Windows resource file for x64 architecture in `CMakeLists.txt`, improving build specificity for Windows targets.
- This change ensures that the resource file is only linked when building for 64-bit Windows, enhancing the project's compatibility and build process.
- Set the `builtin-baseline` in `vcpkg.json` to `2024.12.18`, ensuring compatibility with the latest dependencies.
- Updated the GitHub Actions workflow to include the new `vcpkgGitCommitId`, improving the build process reliability.
