canvas_rendering.cc

Go to the documentation of this file.

#include "canvas_rendering.h"
 
#include <algorithm>
#include <cmath>
 
#include "app/gui/canvas/canvas_utils.h"
#include "app/gui/core/theme_manager.h"
#include "util/log.h"
 
namespace yaze {
namespace gui {
 
namespace {
 
// Diagnostic for the silent guard inside RenderBitmapOnCanvas. The renderer
// drops a draw when the bitmap has no SDL texture (typical for a first-frame
// composite whose CREATE command is queued but not yet processed). Without
// this log the symptom is a blank canvas with no breadcrumb. The metadata
// purpose tag pinned in slice 3 is what makes this log actionable: the call
// site already declared what the bitmap IS, so the log can name it.
inline const char* PurposeLabel(gfx::Bitmap::BitmapPurpose purpose) {
  switch (purpose) {
    case gfx::Bitmap::BitmapPurpose::kPreview:
      return "preview";
    case gfx::Bitmap::BitmapPurpose::kEditable:
      return "editable";
    case gfx::Bitmap::BitmapPurpose::kSelectionSource:
      return "selection-source";
    case gfx::Bitmap::BitmapPurpose::kCompositeOutput:
      return "composite-output";
    default:
      return "unspecified";
  }
}
 
inline void LogBitmapDropIfDebug(const gfx::Bitmap& bitmap, const char* site) {
  LOG_DEBUG("CanvasRender",
            "Skipped %s: bitmap purpose=%s active=%d size=%dx%d (no texture)",
            site, PurposeLabel(bitmap.metadata().purpose), bitmap.is_active(),
            bitmap.width(), bitmap.height());
}
 
}  // namespace
 
void RenderCanvasBackground(ImDrawList* draw_list,
                            const CanvasGeometry& geometry) {
  const auto& theme = ThemeManager::Get().GetCurrentTheme();
 
  // Draw primary background color from theme
  draw_list->AddRectFilled(
      geometry.canvas_p0, geometry.canvas_p1,
      ImGui::GetColorU32(ConvertColorToImVec4(theme.editor_background)));
 
  // Add a subtle pattern to the background (e.g., very faint dots)
  if (theme.enable_glow_effects) {
    const float dot_spacing = 32.0f;
    const uint32_t dot_color =
        ImGui::GetColorU32(ConvertColorToImVec4(theme.editor_grid));
 
    for (float x =
             geometry.canvas_p0.x + fmodf(geometry.scrolling.x, dot_spacing);
         x < geometry.canvas_p1.x; x += dot_spacing) {
      for (float y =
               geometry.canvas_p0.y + fmodf(geometry.scrolling.y, dot_spacing);
           y < geometry.canvas_p1.y; y += dot_spacing) {
        draw_list->AddCircleFilled(ImVec2(x, y), 1.0f, dot_color);
      }
    }
  }
 
  // Draw theme-aware border
  draw_list->AddRect(
      geometry.canvas_p0, geometry.canvas_p1,
      ImGui::GetColorU32(ConvertColorToImVec4(theme.border)), 0.0f, 0,
      theme.window_border_size > 0 ? theme.window_border_size : 1.0f);
}
 
void RenderCanvasGrid(ImDrawList* draw_list, const CanvasGeometry& geometry,
                      const CanvasConfig& config, int highlight_tile_id) {
  if (!config.enable_grid) {
    return;
  }
 
  // Create render context for utility functions (extracted from
  // Canvas::DrawGrid)
  CanvasUtils::CanvasRenderContext ctx = {
      .draw_list = draw_list,
      .canvas_p0 = geometry.canvas_p0,
      .canvas_p1 = geometry.canvas_p1,
      .scrolling = geometry.scrolling,
      .global_scale = config.global_scale,
      .enable_grid = config.enable_grid,
      .enable_hex_labels = config.enable_hex_labels,
      .grid_step = config.grid_step};
 
  // Use high-level utility function
  CanvasUtils::DrawCanvasGrid(ctx, highlight_tile_id);
}
 
void RenderCanvasOverlay(ImDrawList* draw_list, const CanvasGeometry& geometry,
                         const CanvasConfig& config,
                         const ImVector<ImVec2>& points,
                         const ImVector<ImVec2>& selected_points) {
  // Create render context for utility functions (extracted from
  // Canvas::DrawOverlay)
  CanvasUtils::CanvasRenderContext ctx = {
      .draw_list = draw_list,
      .canvas_p0 = geometry.canvas_p0,
      .canvas_p1 = geometry.canvas_p1,
      .scrolling = geometry.scrolling,
      .global_scale = config.global_scale,
      .enable_grid = config.enable_grid,
      .enable_hex_labels = config.enable_hex_labels,
      .grid_step = config.grid_step};
 
  // Use high-level utility function
  CanvasUtils::DrawCanvasOverlay(ctx, points, selected_points);
}
 
void RenderCanvasLabels(ImDrawList* draw_list, const CanvasGeometry& geometry,
                        const CanvasConfig& config,
                        const ImVector<ImVector<std::string>>& labels,
                        int current_labels, int tile_id_offset) {
  if (!config.enable_custom_labels || current_labels >= labels.size()) {
    return;
  }
 
  // Push clip rect to prevent drawing outside canvas
  draw_list->PushClipRect(geometry.canvas_p0, geometry.canvas_p1, true);
 
  // Create render context for utility functions
  CanvasUtils::CanvasRenderContext ctx = {
      .draw_list = draw_list,
      .canvas_p0 = geometry.canvas_p0,
      .canvas_p1 = geometry.canvas_p1,
      .scrolling = geometry.scrolling,
      .global_scale = config.global_scale,
      .enable_grid = config.enable_grid,
      .enable_hex_labels = config.enable_hex_labels,
      .grid_step = config.grid_step};
 
  // Use high-level utility function (extracted from Canvas::DrawInfoGrid)
  CanvasUtils::DrawCanvasLabels(ctx, labels, current_labels, tile_id_offset);
 
  draw_list->PopClipRect();
}
 
void RenderBitmapOnCanvas(ImDrawList* draw_list, const CanvasGeometry& geometry,
                          gfx::Bitmap& bitmap, int /*border_offset*/,
                          float scale) {
  if (!bitmap.is_active() || !bitmap.texture()) {
    LogBitmapDropIfDebug(bitmap, "RenderBitmapOnCanvas(border)");
    return;
  }
 
  // Extracted from Canvas::DrawBitmap (border offset variant)
  draw_list->AddImage((ImTextureID)(intptr_t)bitmap.texture(),
                      ImVec2(geometry.canvas_p0.x, geometry.canvas_p0.y),
                      ImVec2(geometry.canvas_p0.x + (bitmap.width() * scale),
                             geometry.canvas_p0.y + (bitmap.height() * scale)));
  // NOTE: Canvas border is drawn once by RenderCanvasBackground().
  // Do NOT draw border here - this function is called per-bitmap, which would
  // cause N stacked border rectangles (e.g., 64 in overworld editor).
}
 
void RenderBitmapOnCanvas(ImDrawList* draw_list, const CanvasGeometry& geometry,
                          gfx::Bitmap& bitmap, int x_offset, int y_offset,
                          float scale, int alpha) {
  if (!bitmap.is_active() || !bitmap.texture()) {
    LogBitmapDropIfDebug(bitmap, "RenderBitmapOnCanvas(offset)");
    return;
  }
 
  // Calculate the actual rendered size including scale and offsets
  // CRITICAL: Use scale parameter (NOT global_scale_) for per-bitmap scaling
  // Extracted from Canvas::DrawBitmap (x/y offset variant)
  ImVec2 rendered_size(bitmap.width() * scale, bitmap.height() * scale);
 
  // CRITICAL FIX: Draw bitmap WITHOUT additional global_scale multiplication
  // The scale parameter already contains the correct scale factor
  // The scrolling should NOT be scaled - it's already in screen space
  draw_list->AddImage(
      (ImTextureID)(intptr_t)bitmap.texture(),
      ImVec2(geometry.canvas_p0.x + x_offset + geometry.scrolling.x,
             geometry.canvas_p0.y + y_offset + geometry.scrolling.y),
      ImVec2(geometry.canvas_p0.x + x_offset + geometry.scrolling.x +
                 rendered_size.x,
             geometry.canvas_p0.y + y_offset + geometry.scrolling.y +
                 rendered_size.y),
      ImVec2(0, 0), ImVec2(1, 1), IM_COL32(255, 255, 255, alpha));
}
 
void RenderBitmapOnCanvas(ImDrawList* draw_list, const CanvasGeometry& geometry,
                          gfx::Bitmap& bitmap, ImVec2 dest_pos,
                          ImVec2 dest_size, ImVec2 src_pos, ImVec2 src_size) {
  if (!bitmap.is_active() || !bitmap.texture()) {
    LogBitmapDropIfDebug(bitmap, "RenderBitmapOnCanvas(custom-uv)");
    return;
  }
 
  // Extracted from Canvas::DrawBitmap (custom source/dest regions variant)
  draw_list->AddImage(
      (ImTextureID)(intptr_t)bitmap.texture(),
      ImVec2(geometry.canvas_p0.x + dest_pos.x,
             geometry.canvas_p0.y + dest_pos.y),
      ImVec2(geometry.canvas_p0.x + dest_pos.x + dest_size.x,
             geometry.canvas_p0.y + dest_pos.y + dest_size.y),
      ImVec2(src_pos.x / bitmap.width(), src_pos.y / bitmap.height()),
      ImVec2((src_pos.x + src_size.x) / bitmap.width(),
             (src_pos.y + src_size.y) / bitmap.height()));
}
 
void RenderBitmapGroup(ImDrawList* draw_list, const CanvasGeometry& geometry,
                       std::vector<int>& group, gfx::Tilemap& tilemap,
                       int tile_size, float scale, int local_map_size,
                       ImVec2 total_map_size) {
  // Extracted from Canvas::DrawBitmapGroup (lines 1148-1264)
  // This is used for multi-tile selection preview in overworld editor
 
  if (group.empty()) {
    return;
  }
 
  // OPTIMIZATION: Use optimized rendering for large groups to improve
  // performance
  bool use_optimized_rendering = group.size() > 128;
 
  // Pre-calculate common values to avoid repeated computation
  const float tile_scale = tile_size * scale;
  const int atlas_tiles_per_row = tilemap.atlas.width() / tilemap.tile_size.x;
 
  // Get selected points (note: this assumes selected_points are available in
  // context) For now, we'll just render tiles at their grid positions The full
  // implementation would need the selected_points passed in
 
  int i = 0;
  for (const auto tile_id : group) {
    // Calculate grid position for this tile
    int tiles_per_row = 32;  // Default for standard maps
    int x = i % tiles_per_row;
    int y = i / tiles_per_row;
 
    int tile_pos_x = x * tile_size * scale;
    int tile_pos_y = y * tile_size * scale;
 
    // Check if tile_id is within the range
    auto tilemap_size = tilemap.map_size.x;
    if (tile_id >= 0 && tile_id < tilemap_size) {
      if (tilemap.atlas.is_active() && tilemap.atlas.texture() &&
          atlas_tiles_per_row > 0) {
        int atlas_tile_x =
            (tile_id % atlas_tiles_per_row) * tilemap.tile_size.x;
        int atlas_tile_y =
            (tile_id / atlas_tiles_per_row) * tilemap.tile_size.y;
 
        // Simple bounds check
        if (atlas_tile_x >= 0 && atlas_tile_x < tilemap.atlas.width() &&
            atlas_tile_y >= 0 && atlas_tile_y < tilemap.atlas.height()) {
          // Calculate UV coordinates once for efficiency
          const float atlas_width = static_cast<float>(tilemap.atlas.width());
          const float atlas_height = static_cast<float>(tilemap.atlas.height());
          ImVec2 uv0 =
              ImVec2(atlas_tile_x / atlas_width, atlas_tile_y / atlas_height);
          ImVec2 uv1 =
              ImVec2((atlas_tile_x + tilemap.tile_size.x) / atlas_width,
                     (atlas_tile_y + tilemap.tile_size.y) / atlas_height);
 
          // Calculate screen positions
          float screen_x =
              geometry.canvas_p0.x + geometry.scrolling.x + tile_pos_x;
          float screen_y =
              geometry.canvas_p0.y + geometry.scrolling.y + tile_pos_y;
          float screen_w = tilemap.tile_size.x * scale;
          float screen_h = tilemap.tile_size.y * scale;
 
          // Use higher alpha for large selections to make them more visible
          uint32_t alpha_color = use_optimized_rendering
                                     ? IM_COL32(255, 255, 255, 200)
                                     : IM_COL32(255, 255, 255, 150);
 
          // Draw from atlas texture with optimized parameters
          draw_list->AddImage((ImTextureID)(intptr_t)tilemap.atlas.texture(),
                              ImVec2(screen_x, screen_y),
                              ImVec2(screen_x + screen_w, screen_y + screen_h),
                              uv0, uv1, alpha_color);
        }
      }
    }
    i++;
  }
}
 
}  // namespace gui
}  // namespace yaze