6c331f1fd0
- 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.
584 lines
20 KiB
C++
584 lines
20 KiB
C++
#ifndef YAZE_GUI_CANVAS_H
|
|
#define YAZE_GUI_CANVAS_H
|
|
|
|
#include "app/gfx/tilemap.h"
|
|
#define IMGUI_DEFINE_MATH_OPERATORS
|
|
|
|
#include <cstdint>
|
|
#include <string>
|
|
#include <functional>
|
|
#include <memory>
|
|
|
|
#include "app/gfx/bitmap.h"
|
|
#include "app/rom.h"
|
|
#include "app/gui/canvas_utils.h"
|
|
#include "app/gui/widgets/palette_widget.h"
|
|
#include "app/gfx/bpp_format_manager.h"
|
|
#include "app/gui/bpp_format_ui.h"
|
|
#include "app/gui/canvas/canvas_modals.h"
|
|
#include "app/gui/canvas/canvas_context_menu.h"
|
|
#include "app/gui/canvas/canvas_usage_tracker.h"
|
|
#include "app/gui/canvas/canvas_performance_integration.h"
|
|
#include "app/gui/canvas/canvas_interaction_handler.h"
|
|
#include "imgui/imgui.h"
|
|
|
|
namespace yaze {
|
|
|
|
/**
|
|
* @namespace yaze::gui
|
|
* @brief Graphical User Interface (GUI) components for the application.
|
|
*/
|
|
namespace gui {
|
|
|
|
// Forward declaration (full include would cause circular dependency)
|
|
class CanvasAutomationAPI;
|
|
|
|
using gfx::Bitmap;
|
|
using gfx::BitmapTable;
|
|
|
|
enum class CanvasType { kTile, kBlock, kMap };
|
|
enum class CanvasMode { kPaint, kSelect };
|
|
enum class CanvasGridSize { k8x8, k16x16, k32x32, k64x64 };
|
|
|
|
/**
|
|
* @class Canvas
|
|
* @brief Modern, robust canvas for drawing and manipulating graphics.
|
|
*
|
|
* Following ImGui design patterns, this Canvas class provides:
|
|
* - Modular configuration through CanvasConfig
|
|
* - Separate selection state management
|
|
* - Enhanced palette management integration
|
|
* - Performance-optimized rendering
|
|
* - Comprehensive context menu system
|
|
*/
|
|
class Canvas {
|
|
public:
|
|
// Default constructor
|
|
Canvas();
|
|
~Canvas();
|
|
|
|
// Legacy constructors (renderer is optional for backward compatibility)
|
|
explicit Canvas(const std::string& id);
|
|
explicit Canvas(const std::string& id, ImVec2 canvas_size);
|
|
explicit Canvas(const std::string& id, ImVec2 canvas_size, CanvasGridSize grid_size);
|
|
explicit Canvas(const std::string& id, ImVec2 canvas_size, CanvasGridSize grid_size, float global_scale);
|
|
|
|
// New constructors with renderer support (for migration to IRenderer pattern)
|
|
explicit Canvas(gfx::IRenderer* renderer);
|
|
explicit Canvas(gfx::IRenderer* renderer, const std::string& id);
|
|
explicit Canvas(gfx::IRenderer* renderer, const std::string& id, ImVec2 canvas_size);
|
|
explicit Canvas(gfx::IRenderer* renderer, const std::string& id, ImVec2 canvas_size, CanvasGridSize grid_size);
|
|
explicit Canvas(gfx::IRenderer* renderer, const std::string& id, ImVec2 canvas_size, CanvasGridSize grid_size, float global_scale);
|
|
|
|
// Set renderer after construction (for late initialization)
|
|
void SetRenderer(gfx::IRenderer* renderer) { renderer_ = renderer; }
|
|
gfx::IRenderer* renderer() const { return renderer_; }
|
|
|
|
void SetGridSize(CanvasGridSize grid_size) {
|
|
switch (grid_size) {
|
|
case CanvasGridSize::k8x8:
|
|
config_.grid_step = 8.0f;
|
|
break;
|
|
case CanvasGridSize::k16x16:
|
|
config_.grid_step = 16.0f;
|
|
break;
|
|
case CanvasGridSize::k32x32:
|
|
config_.grid_step = 32.0f;
|
|
break;
|
|
case CanvasGridSize::k64x64:
|
|
config_.grid_step = 64.0f;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Legacy compatibility
|
|
void SetCanvasGridSize(CanvasGridSize grid_size) { SetGridSize(grid_size); }
|
|
|
|
CanvasGridSize grid_size() const {
|
|
if (config_.grid_step == 8.0f) return CanvasGridSize::k8x8;
|
|
if (config_.grid_step == 16.0f) return CanvasGridSize::k16x16;
|
|
if (config_.grid_step == 32.0f) return CanvasGridSize::k32x32;
|
|
if (config_.grid_step == 64.0f) return CanvasGridSize::k64x64;
|
|
return CanvasGridSize::k16x16; // Default
|
|
}
|
|
|
|
void UpdateColorPainter(gfx::IRenderer* renderer, gfx::Bitmap &bitmap, const ImVec4 &color,
|
|
const std::function<void()> &event, int tile_size,
|
|
float scale = 1.0f);
|
|
|
|
void UpdateInfoGrid(ImVec2 bg_size, float grid_size = 64.0f,
|
|
int label_id = 0);
|
|
|
|
// ==================== Modern ImGui-Style Interface ====================
|
|
|
|
/**
|
|
* @brief Begin canvas rendering (ImGui-style)
|
|
*
|
|
* Modern alternative to DrawBackground(). Handles:
|
|
* - Background and border rendering
|
|
* - Size calculation
|
|
* - Scroll/drag setup
|
|
* - Context menu
|
|
*
|
|
* Usage:
|
|
* ```cpp
|
|
* canvas.Begin();
|
|
* canvas.DrawBitmap(bitmap);
|
|
* if (canvas.DrawTilePainter(tile, 16)) { ... }
|
|
* canvas.End(); // Draws grid and overlay
|
|
* ```
|
|
*/
|
|
void Begin(ImVec2 canvas_size = ImVec2(0, 0));
|
|
|
|
/**
|
|
* @brief End canvas rendering (ImGui-style)
|
|
*
|
|
* Modern alternative to manual DrawGrid() + DrawOverlay().
|
|
* Automatically draws grid and overlay if enabled.
|
|
*/
|
|
void End();
|
|
|
|
// ==================== Legacy Interface (Backward Compatible) ====================
|
|
|
|
// Background for the Canvas represents region without any content drawn to
|
|
// it, but can be controlled by the user.
|
|
void DrawBackground(ImVec2 canvas_size = ImVec2(0, 0));
|
|
|
|
// Context Menu refers to what happens when the right mouse button is pressed
|
|
// This routine also handles the scrolling for the canvas.
|
|
void DrawContextMenu();
|
|
|
|
// Context menu system for consumers to add their own menu elements
|
|
struct ContextMenuItem {
|
|
std::string label;
|
|
std::string shortcut;
|
|
std::function<void()> callback;
|
|
std::function<bool()> enabled_condition = []() { return true; };
|
|
std::vector<ContextMenuItem> subitems;
|
|
|
|
// Helper constructor for simple items
|
|
ContextMenuItem() = default;
|
|
ContextMenuItem(const std::string& lbl, std::function<void()> cb,
|
|
const std::string& sc = "")
|
|
: label(lbl), shortcut(sc), callback(std::move(cb)) {}
|
|
|
|
// Helper to create disabled item
|
|
static ContextMenuItem Disabled(const std::string& lbl) {
|
|
ContextMenuItem item;
|
|
item.label = lbl;
|
|
item.enabled_condition = []() { return false; };
|
|
return item;
|
|
}
|
|
|
|
// Helper to create conditional item
|
|
static ContextMenuItem Conditional(const std::string& lbl, std::function<void()> cb,
|
|
std::function<bool()> condition) {
|
|
ContextMenuItem item;
|
|
item.label = lbl;
|
|
item.callback = std::move(cb);
|
|
item.enabled_condition = std::move(condition);
|
|
return item;
|
|
}
|
|
};
|
|
|
|
// BPP format UI components
|
|
std::unique_ptr<gui::BppFormatUI> bpp_format_ui_;
|
|
std::unique_ptr<gui::BppConversionDialog> bpp_conversion_dialog_;
|
|
std::unique_ptr<gui::BppComparisonTool> bpp_comparison_tool_;
|
|
|
|
// Enhanced canvas components
|
|
std::unique_ptr<canvas::CanvasModals> modals_;
|
|
std::unique_ptr<canvas::CanvasContextMenu> context_menu_;
|
|
std::shared_ptr<canvas::CanvasUsageTracker> usage_tracker_;
|
|
std::shared_ptr<canvas::CanvasPerformanceIntegration> performance_integration_;
|
|
canvas::CanvasInteractionHandler interaction_handler_;
|
|
|
|
void AddContextMenuItem(const ContextMenuItem& item);
|
|
void ClearContextMenuItems();
|
|
void SetContextMenuEnabled(bool enabled) { context_menu_enabled_ = enabled; }
|
|
|
|
// Enhanced view and edit operations
|
|
void ShowAdvancedCanvasProperties();
|
|
void ShowScalingControls();
|
|
void SetZoomToFit(const gfx::Bitmap& bitmap);
|
|
void ResetView();
|
|
void ApplyConfigSnapshot(const canvas::CanvasConfig& snapshot);
|
|
void ApplyScaleSnapshot(const canvas::CanvasConfig& snapshot);
|
|
|
|
// Modular component access
|
|
CanvasConfig& GetConfig() { return config_; }
|
|
const CanvasConfig& GetConfig() const { return config_; }
|
|
CanvasSelection& GetSelection() { return selection_; }
|
|
const CanvasSelection& GetSelection() const { return selection_; }
|
|
|
|
// Enhanced palette management
|
|
void InitializePaletteEditor(Rom* rom);
|
|
void ShowPaletteEditor();
|
|
void ShowColorAnalysis();
|
|
bool ApplyROMPalette(int group_index, int palette_index);
|
|
|
|
// BPP format management
|
|
void ShowBppFormatSelector();
|
|
void ShowBppAnalysis();
|
|
void ShowBppConversionDialog();
|
|
bool ConvertBitmapFormat(gfx::BppFormat target_format);
|
|
gfx::BppFormat GetCurrentBppFormat() const;
|
|
|
|
// Enhanced canvas management
|
|
void InitializeEnhancedComponents();
|
|
void SetUsageMode(canvas::CanvasUsage usage);
|
|
canvas::CanvasUsage GetUsageMode() const;
|
|
void RecordCanvasOperation(const std::string& operation_name, double time_ms);
|
|
void ShowPerformanceUI();
|
|
void ShowUsageReport();
|
|
|
|
// Interaction handler access
|
|
canvas::CanvasInteractionHandler& GetInteractionHandler() { return interaction_handler_; }
|
|
const canvas::CanvasInteractionHandler& GetInteractionHandler() const { return interaction_handler_; }
|
|
|
|
// Automation API access (Phase 4A)
|
|
CanvasAutomationAPI* GetAutomationAPI();
|
|
|
|
// Initialization and cleanup
|
|
void InitializeDefaults();
|
|
void Cleanup();
|
|
|
|
// Size reporting for ImGui table integration
|
|
ImVec2 GetMinimumSize() const;
|
|
ImVec2 GetPreferredSize() const;
|
|
ImVec2 GetCurrentSize() const { return config_.canvas_size; }
|
|
void SetAutoResize(bool auto_resize) { config_.auto_resize = auto_resize; }
|
|
bool IsAutoResize() const { return config_.auto_resize; }
|
|
|
|
// Table integration helpers
|
|
void ReserveTableSpace(const std::string& label = "");
|
|
bool BeginTableCanvas(const std::string& label = "");
|
|
void EndTableCanvas();
|
|
|
|
// Improved interaction detection
|
|
bool HasValidSelection() const;
|
|
bool WasClicked(ImGuiMouseButton button = ImGuiMouseButton_Left) const;
|
|
bool WasDoubleClicked(ImGuiMouseButton button = ImGuiMouseButton_Left) const;
|
|
ImVec2 GetLastClickPosition() const;
|
|
|
|
// Tile painter methods
|
|
bool DrawTilePainter(const Bitmap &bitmap, int size, float scale = 1.0f);
|
|
bool DrawSolidTilePainter(const ImVec4 &color, int size);
|
|
void DrawTileOnBitmap(int tile_size, gfx::Bitmap *bitmap, ImVec4 color);
|
|
|
|
void DrawOutline(int x, int y, int w, int h);
|
|
void DrawOutlineWithColor(int x, int y, int w, int h, ImVec4 color);
|
|
void DrawOutlineWithColor(int x, int y, int w, int h, uint32_t color);
|
|
|
|
void DrawRect(int x, int y, int w, int h, ImVec4 color);
|
|
|
|
void DrawText(std::string text, int x, int y);
|
|
void DrawGridLines(float grid_step);
|
|
|
|
void DrawInfoGrid(float grid_step = 64.0f, int tile_id_offset = 8,
|
|
int label_id = 0);
|
|
|
|
void DrawLayeredElements();
|
|
|
|
int GetTileIdFromMousePos() {
|
|
float x = mouse_pos_in_canvas_.x;
|
|
float y = mouse_pos_in_canvas_.y;
|
|
int num_columns = (canvas_sz_.x / global_scale_) / custom_step_;
|
|
int num_rows = (canvas_sz_.y / global_scale_) / custom_step_;
|
|
int tile_id = (x / custom_step_) + (y / custom_step_) * num_columns;
|
|
tile_id = tile_id / global_scale_;
|
|
if (tile_id >= num_columns * num_rows) {
|
|
tile_id = -1; // Invalid tile ID
|
|
}
|
|
return tile_id;
|
|
}
|
|
void DrawCustomHighlight(float grid_step);
|
|
bool IsMouseHovering() const { return is_hovered_; }
|
|
void ZoomIn() { global_scale_ += 0.25f; }
|
|
void ZoomOut() { global_scale_ -= 0.25f; }
|
|
|
|
// Points accessors - points_ is maintained separately for custom overlay drawing
|
|
const ImVector<ImVec2>& points() const { return points_; }
|
|
ImVector<ImVec2>* mutable_points() { return &points_; }
|
|
auto push_back(ImVec2 pos) { points_.push_back(pos); }
|
|
auto draw_list() const { return draw_list_; }
|
|
auto zero_point() const { return canvas_p0_; }
|
|
auto scrolling() const { return scrolling_; }
|
|
void set_scrolling(ImVec2 scroll) { scrolling_ = scroll; }
|
|
auto drawn_tile_position() const { return drawn_tile_pos_; }
|
|
auto canvas_size() const { return canvas_sz_; }
|
|
void set_global_scale(float scale) { global_scale_ = scale; }
|
|
void set_draggable(bool draggable) { draggable_ = draggable; }
|
|
|
|
// Modern accessors using modular structure
|
|
bool IsSelectRectActive() const { return select_rect_active_; }
|
|
const std::vector<ImVec2>& GetSelectedTiles() const { return selected_tiles_; }
|
|
ImVec2 GetSelectedTilePos() const { return selected_tile_pos_; }
|
|
void SetSelectedTilePos(ImVec2 pos) { selected_tile_pos_ = pos; }
|
|
|
|
// Configuration accessors
|
|
void SetCanvasSize(ImVec2 canvas_size) {
|
|
config_.canvas_size = canvas_size;
|
|
config_.custom_canvas_size = true;
|
|
}
|
|
float GetGlobalScale() const { return config_.global_scale; }
|
|
void SetGlobalScale(float scale) { config_.global_scale = scale; }
|
|
bool* GetCustomLabelsEnabled() { return &config_.enable_custom_labels; }
|
|
float GetGridStep() const { return config_.grid_step; }
|
|
|
|
// Rectangle selection boundary control (prevents wrapping in large maps)
|
|
void SetClampRectToLocalMaps(bool clamp) { config_.clamp_rect_to_local_maps = clamp; }
|
|
bool GetClampRectToLocalMaps() const { return config_.clamp_rect_to_local_maps; }
|
|
float GetCanvasWidth() const { return config_.canvas_size.x; }
|
|
float GetCanvasHeight() const { return config_.canvas_size.y; }
|
|
|
|
// Legacy compatibility accessors
|
|
auto select_rect_active() const { return select_rect_active_; }
|
|
auto selected_tiles() const { return selected_tiles_; }
|
|
auto selected_tile_pos() const { return selected_tile_pos_; }
|
|
void set_selected_tile_pos(ImVec2 pos) { selected_tile_pos_ = pos; }
|
|
auto global_scale() const { return config_.global_scale; }
|
|
auto custom_labels_enabled() { return &config_.enable_custom_labels; }
|
|
auto custom_step() const { return config_.grid_step; }
|
|
auto width() const { return config_.canvas_size.x; }
|
|
auto height() const { return config_.canvas_size.y; }
|
|
|
|
// Public accessors for methods that need to be accessed externally
|
|
auto canvas_id() const { return canvas_id_; }
|
|
|
|
// Public methods for drawing operations
|
|
void DrawBitmap(Bitmap &bitmap, int border_offset, float scale);
|
|
void DrawBitmap(Bitmap &bitmap, int x_offset, int y_offset, float scale = 1.0f, int alpha = 255);
|
|
void DrawBitmap(Bitmap &bitmap, ImVec2 dest_pos, ImVec2 dest_size, ImVec2 src_pos, ImVec2 src_size);
|
|
void DrawBitmapTable(const BitmapTable &gfx_bin);
|
|
/**
|
|
* @brief Draw group of bitmaps for multi-tile selection preview
|
|
* @param group Vector of tile IDs to draw
|
|
* @param tilemap Tilemap containing the tiles
|
|
* @param tile_size Size of each tile (default 16)
|
|
* @param scale Rendering scale (default 1.0)
|
|
* @param local_map_size Size of local map in pixels (default 512 for standard maps)
|
|
* @param total_map_size Total map size for boundary clamping (default 4096x4096)
|
|
*/
|
|
void DrawBitmapGroup(std::vector<int> &group, gfx::Tilemap &tilemap,
|
|
int tile_size, float scale = 1.0f,
|
|
int local_map_size = 0x200,
|
|
ImVec2 total_map_size = ImVec2(0x1000, 0x1000));
|
|
bool DrawTilemapPainter(gfx::Tilemap &tilemap, int current_tile);
|
|
void DrawSelectRect(int current_map, int tile_size = 0x10, float scale = 1.0f);
|
|
bool DrawTileSelector(int size, int size_y = 0);
|
|
void DrawGrid(float grid_step = 64.0f, int tile_id_offset = 8);
|
|
void DrawOverlay();
|
|
auto labels(int i) {
|
|
if (i >= labels_.size()) {
|
|
labels_.push_back(ImVector<std::string>());
|
|
}
|
|
return labels_[i];
|
|
}
|
|
auto mutable_labels(int i) {
|
|
if (i >= labels_.size()) {
|
|
int x = i;
|
|
while (x >= labels_.size()) {
|
|
labels_.push_back(ImVector<std::string>());
|
|
x--;
|
|
}
|
|
labels_.push_back(ImVector<std::string>());
|
|
}
|
|
return &labels_[i];
|
|
}
|
|
|
|
auto set_current_labels(int i) { current_labels_ = i; }
|
|
auto set_highlight_tile_id(int i) { highlight_tile_id = i; }
|
|
|
|
auto mutable_selected_tiles() { return &selected_tiles_; }
|
|
auto mutable_selected_points() { return &selected_points_; }
|
|
auto selected_points() const { return selected_points_; }
|
|
|
|
auto hover_mouse_pos() const { return mouse_pos_in_canvas_; }
|
|
|
|
void set_rom(Rom *rom) { rom_ = rom; }
|
|
Rom *rom() const { return rom_; }
|
|
|
|
private:
|
|
void DrawContextMenuItem(const ContextMenuItem& item);
|
|
|
|
// Modular configuration and state
|
|
gfx::IRenderer* renderer_ = nullptr;
|
|
CanvasConfig config_;
|
|
CanvasSelection selection_;
|
|
std::unique_ptr<PaletteWidget> palette_editor_;
|
|
|
|
// Automation API (lazy-initialized on first access)
|
|
std::unique_ptr<CanvasAutomationAPI> automation_api_;
|
|
|
|
// Core canvas state
|
|
bool is_hovered_ = false;
|
|
bool refresh_graphics_ = false;
|
|
|
|
// Context menu system
|
|
std::vector<ContextMenuItem> context_menu_items_;
|
|
bool context_menu_enabled_ = true;
|
|
|
|
// Legacy members (to be gradually replaced)
|
|
int current_labels_ = 0;
|
|
int highlight_tile_id = -1;
|
|
uint16_t edit_palette_index_ = 0;
|
|
uint64_t edit_palette_group_name_index_ = 0;
|
|
uint64_t edit_palette_sub_index_ = 0;
|
|
|
|
// Core canvas state
|
|
Bitmap *bitmap_ = nullptr;
|
|
Rom *rom_ = nullptr;
|
|
ImDrawList *draw_list_ = nullptr;
|
|
|
|
// Canvas geometry and interaction state
|
|
ImVec2 scrolling_;
|
|
ImVec2 canvas_sz_;
|
|
ImVec2 canvas_p0_;
|
|
ImVec2 canvas_p1_;
|
|
ImVec2 drawn_tile_pos_;
|
|
ImVec2 mouse_pos_in_canvas_;
|
|
|
|
// Drawing and labeling
|
|
// NOTE: points_ synchronized from interaction_handler_ for backward compatibility
|
|
ImVector<ImVec2> points_;
|
|
ImVector<ImVector<std::string>> labels_;
|
|
|
|
// Identification
|
|
std::string canvas_id_ = "Canvas";
|
|
std::string context_id_ = "CanvasContext";
|
|
|
|
// Legacy compatibility (gradually being replaced by selection_)
|
|
std::vector<ImVec2> selected_tiles_;
|
|
ImVector<ImVec2> selected_points_;
|
|
ImVec2 selected_tile_pos_ = ImVec2(-1, -1);
|
|
bool select_rect_active_ = false;
|
|
float custom_step_ = 32.0f;
|
|
float global_scale_ = 1.0f;
|
|
bool enable_grid_ = true;
|
|
bool enable_hex_tile_labels_ = false;
|
|
bool enable_custom_labels_ = false;
|
|
bool enable_context_menu_ = true;
|
|
bool custom_canvas_size_ = false;
|
|
bool draggable_ = false;
|
|
};
|
|
|
|
void BeginCanvas(Canvas &canvas, ImVec2 child_size = ImVec2(0, 0));
|
|
void EndCanvas(Canvas &canvas);
|
|
|
|
void GraphicsBinCanvasPipeline(int width, int height, int tile_size,
|
|
int num_sheets_to_load, int canvas_id,
|
|
bool is_loaded, BitmapTable &graphics_bin);
|
|
|
|
void BitmapCanvasPipeline(gui::Canvas &canvas, gfx::Bitmap &bitmap, int width,
|
|
int height, int tile_size, bool is_loaded,
|
|
bool scrollbar, int canvas_id);
|
|
|
|
// Table-optimized canvas pipeline with automatic sizing
|
|
void TableCanvasPipeline(gui::Canvas &canvas, gfx::Bitmap &bitmap,
|
|
const std::string& label = "", bool auto_resize = true);
|
|
|
|
/**
|
|
* @class ScopedCanvas
|
|
* @brief RAII wrapper for Canvas (ImGui-style)
|
|
*
|
|
* Automatically calls Begin() on construction and End() on destruction,
|
|
* preventing forgotten End() calls and ensuring proper cleanup.
|
|
*
|
|
* Usage:
|
|
* ```cpp
|
|
* {
|
|
* gui::ScopedCanvas canvas("MyCanvas", ImVec2(512, 512));
|
|
* canvas->DrawBitmap(bitmap);
|
|
* if (canvas->DrawTilePainter(tile, 16)) {
|
|
* HandlePaint(canvas->drawn_tile_position());
|
|
* }
|
|
* } // Automatic End() and cleanup
|
|
* ```
|
|
*
|
|
* Or wrap existing canvas:
|
|
* ```cpp
|
|
* Canvas my_canvas("Editor");
|
|
* {
|
|
* ScopedCanvas scoped(my_canvas);
|
|
* scoped->DrawBitmap(bitmap);
|
|
* } // Automatic End()
|
|
* ```
|
|
*/
|
|
class ScopedCanvas {
|
|
public:
|
|
/**
|
|
* @brief Construct and begin a new canvas (legacy constructor without renderer)
|
|
*/
|
|
explicit ScopedCanvas(const std::string& id, ImVec2 canvas_size = ImVec2(0, 0))
|
|
: canvas_(new Canvas(id, canvas_size)), owned_(true), active_(true) {
|
|
canvas_->Begin();
|
|
}
|
|
|
|
/**
|
|
* @brief Construct and begin a new canvas (with optional renderer)
|
|
*/
|
|
explicit ScopedCanvas(gfx::IRenderer* renderer, const std::string& id, ImVec2 canvas_size = ImVec2(0, 0))
|
|
: canvas_(new Canvas(renderer, id, canvas_size)), owned_(true), active_(true) {
|
|
canvas_->Begin();
|
|
}
|
|
|
|
/**
|
|
* @brief Wrap existing canvas with RAII
|
|
*/
|
|
explicit ScopedCanvas(Canvas& canvas)
|
|
: canvas_(&canvas), owned_(false), active_(true) {
|
|
canvas_->Begin();
|
|
}
|
|
|
|
/**
|
|
* @brief Destructor automatically calls End()
|
|
*/
|
|
~ScopedCanvas() {
|
|
if (active_ && canvas_) {
|
|
canvas_->End();
|
|
}
|
|
if (owned_) {
|
|
delete canvas_;
|
|
}
|
|
}
|
|
|
|
// No copy, move only
|
|
ScopedCanvas(const ScopedCanvas&) = delete;
|
|
ScopedCanvas& operator=(const ScopedCanvas&) = delete;
|
|
|
|
ScopedCanvas(ScopedCanvas&& other) noexcept
|
|
: canvas_(other.canvas_), owned_(other.owned_), active_(other.active_) {
|
|
other.active_ = false;
|
|
other.canvas_ = nullptr;
|
|
}
|
|
|
|
/**
|
|
* @brief Arrow operator for clean syntax: scoped->DrawBitmap(...)
|
|
*/
|
|
Canvas* operator->() { return canvas_; }
|
|
const Canvas* operator->() const { return canvas_; }
|
|
|
|
/**
|
|
* @brief Dereference operator for direct access: (*scoped).DrawBitmap(...)
|
|
*/
|
|
Canvas& operator*() { return *canvas_; }
|
|
const Canvas& operator*() const { return *canvas_; }
|
|
|
|
/**
|
|
* @brief Get underlying canvas
|
|
*/
|
|
Canvas* get() { return canvas_; }
|
|
const Canvas* get() const { return canvas_; }
|
|
|
|
private:
|
|
Canvas* canvas_;
|
|
bool owned_;
|
|
bool active_;
|
|
};
|
|
|
|
} // namespace gui
|
|
} // namespace yaze
|
|
|
|
#endif
|