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 "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;
};
 
class TilePaintingManager {
 public:
  TilePaintingManager(const TilePaintingDependencies& deps,
                      const TilePaintingCallbacks& callbacks);
 
  void CheckForOverworldEdits();
 
  void CheckForSelectRectangle();
 
  const TileBrush* selection_brush() const;
 
  absl::Status PasteBrush(const TileBrush& brush);
 
  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;
  bool IsValidTile(TilePosition position) const;
  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;
  void PaintPattern(const TileBrush& brush, TilePosition anchor, int width,
                    int height, bool finalize = true);
  bool PaintTile(TilePosition position, int tile_id, 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 selection_gesture_owned_ = 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