tile_painting_manager.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_OVERWORLD_PAINTING_TILE_PAINTING_MANAGER_H
#define YAZE_APP_EDITOR_OVERWORLD_PAINTING_TILE_PAINTING_MANAGER_H
 
#include <array>
#include <functional>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "app/editor/overworld/painting/tile_brush.h"
#include "app/editor/overworld/ui/ui_constants.h"
#include "app/gfx/core/bitmap.h"
#include "app/gfx/render/tilemap.h"
#include "app/gui/canvas/canvas.h"
#include "imgui/imgui.h"
#include "rom/rom.h"
#include "zelda3/overworld/overworld.h"
 
namespace yaze {
namespace editor {
 
class Tile16Editor;
 
struct TilePaintingDependencies {
  gui::Canvas* ow_map_canvas = nullptr;
  zelda3::Overworld* overworld = nullptr;
  std::array<gfx::Bitmap, zelda3::kExpandedMapCount>* maps_bmp = nullptr;
  gfx::Tilemap* tile16_blockset = nullptr;
  int* current_tile16 = nullptr;
  std::vector<int>* selected_tile16_ids = nullptr;
  int* current_map = nullptr;
  int* current_world = nullptr;
  EditingMode* current_mode = nullptr;
  Rom* rom = nullptr;
  Tile16Editor* tile16_editor = nullptr;
};
 
struct TilePaintingCallbacks {
  std::function<void(int map_id, int world, int x, int y, int old_tile_id)>
      create_undo_point;
  std::function<void()> finalize_paint_operation;
  std::function<void(int map_index)> refresh_overworld_map_on_demand;
  std::function<void()> scroll_blockset_to_current_tile;
  std::function<void(int tile_id)> request_tile16_selection;
  std::function<void(int map_id)> select_map_for_editing;
  // Optional project terrain adapter. Coordinates are world Tile16 cells;
  // project destinations never enter the legacy ROM/bitmap write path.
  std::function<bool(int world, int x, int y)> is_project_tile;
  std::function<absl::StatusOr<uint16_t>(int world, int x, int y)>
      read_project_tile;
  std::function<absl::Status(const TileBrush&, int x, int y, int width,
                             int height, bool finalize)>
      paint_project_pattern;
  std::function<void()> finalize_project_paint;
  std::function<const gfx::Bitmap*(int map_id)> project_tile_atlas;
  std::function<int(int world)> allocated_rows;
};
 
struct GuardedTileCell {
  int x = 0;
  int y = 0;
  uint16_t expected = 0;
  uint16_t proposed = 0;
};
 
class TilePaintingManager {
 public:
  TilePaintingManager(const TilePaintingDependencies& deps,
                      const TilePaintingCallbacks& callbacks);
 
  void CheckForOverworldEdits();
 
  void SuspendCanvasGestures();
 
  void CheckForSelectRectangle();
 
  const TileBrush* selection_brush() const;
  void SetSelectionBrush(TileBrush brush);
  void ClearSelectionBrush();
 
  absl::Status PasteBrush(const TileBrush& brush);
  absl::Status PlaceBrushAt(const TileBrush& brush, int x, int y) {
    FinalizePendingPaint();
    return PaintPattern(brush, {x, y}, brush.width, brush.height);
  }
 
  absl::StatusOr<int> ApplyGuardedCells(
      int map_id, const std::vector<GuardedTileCell>& cells);
 
  void RenderUpdatedMapBitmap(const ImVec2& click_position,
                              const std::vector<uint8_t>& tile_data);
 
  bool PickTile16FromHoveredCanvas();
 
  void ToggleBrushTool();
 
  void ActivateFillTool();
 
  const gfx::Bitmap& map_brush_preview(int map_id) const {
    return map_brush_previews_.at(map_id);
  }
 
 private:
  struct TilePosition {
    int x;
    int y;
  };
  using ChangedMaps = std::array<bool, zelda3::kNumOverworldMaps>;
 
  TilePosition HoveredTile() const;
  int AllocatedRowsForWorld(int world) const;
  bool IsValidMapGridPosition(int world, int map_x, int map_y) const;
  bool IsProjectTile(TilePosition position) const;
  absl::StatusOr<uint16_t> ReadTile(TilePosition position) const;
  bool IsValidTile(TilePosition position) const;
  void FinalizePendingPaint();
  std::vector<std::vector<uint16_t>>& WorldTiles() const;
  void CaptureSelection();
  // Draws `brush` at `anchor` with each destination map's own graphics and
  // palette. `mark_selection` also moves the canvas selection rectangle.
  void DrawBrushPreview(const TileBrush& brush, TilePosition anchor,
                        bool mark_selection, int alpha);
  // Pixels of `tile_id` as `map_id` draws it (its own tile16 blockset);
  // falls back to the shared blockset when that map has none built.
  std::vector<uint8_t> Tile16PixelsForMap(int map_id, int tile_id) const;
  absl::Status PaintPattern(const TileBrush& brush, TilePosition anchor,
                            int width, int height, bool finalize = true);
  bool PaintTile(TilePosition position, int tile_id, ChangedMaps& changed_maps);
  void RefreshChangedMaps(const ChangedMaps& changed_maps);
  void RenderMapTile(int map_id, TilePosition position,
                     const std::vector<uint8_t>& tile_data);
 
  TilePaintingDependencies deps_;
  TilePaintingCallbacks callbacks_;
  bool paint_gesture_owned_ = false;
  bool single_paint_pending_ = false;
  bool project_paint_pending_ = false;
  bool gesture_project_ = false;
  int gesture_world_ = 0;
  EditingMode gesture_mode_ = EditingMode::DRAW_TILE;
  bool selection_gesture_owned_ = false;
  bool external_brush_active_ = false;
  TileBrush brush_;
  std::array<gfx::Bitmap, zelda3::kNumOverworldMaps> map_brush_previews_;
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_OVERWORLD_PAINTING_TILE_PAINTING_MANAGER_H