usage_preview.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_GRAPHICS_USAGE_PREVIEW_H
#define YAZE_APP_EDITOR_GRAPHICS_USAGE_PREVIEW_H
 
#include <array>
#include <cstdint>
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <vector>
 
#include "absl/status/status.h"
#include "app/editor/graphics/graphics_edit_context.h"
#include "app/editor/graphics/graphics_preview_image.h"
#include "app/editor/sprite/zsprite.h"
#include "app/gfx/core/bitmap.h"
#include "app/gfx/types/snes_tile.h"
#include "rom/rom.h"
#include "zelda3/dungeon/room.h"
#include "zelda3/game_data.h"
#include "zelda3/gfx_sheet_inventory.h"
#include "zelda3/overworld/overworld_map.h"
 
namespace yaze::zelda3 {
class Overworld;
}
 
namespace yaze::editor::usage_preview {
 
constexpr size_t kSheetBytes = 4096;  // 128x32 8bpp sheet
 
using SheetPixels = std::map<uint16_t, std::vector<uint8_t>>;
 
[[deprecated("Use SnapshotSessionSheets; Arena is a display cache")]]
SheetPixels SnapshotArenaSheets(const std::set<uint16_t>& ids,
                                const zelda3::GameData* game_data);
 
// Preferred preview source: this ROM session's authoritative raw pixels.
// Independent of whichever session currently occupies the global Arena.
SheetPixels SnapshotSessionSheets(const std::set<uint16_t>& ids,
                                  const zelda3::GameData* game_data);
 
PreviewImage SnapshotBitmap(const gfx::Bitmap& bitmap);
 
// ---------------------------------------------------------------------------
// Room context
// ---------------------------------------------------------------------------
 
std::map<int, std::array<uint8_t, 16>> CollectRoomSheetBlocks(
    Rom* rom, zelda3::GameData* game_data,
    const std::map<int, zelda3::RoomGfxInfo>& rooms);
 
std::vector<int> RoomsUsingSheet(
    const std::map<int, std::array<uint8_t, 16>>& room_blocks, uint16_t sheet,
    bool include_sprites);
 
// Ephemeral pointers, resolved by the owning session before each view update.
struct LiveRoomContext {
  zelda3::Room* room = nullptr;
  std::string provenance;
  bool current = false;
  int entrance_slot = -1;
};
using LiveRoomContexts = std::map<int, LiveRoomContext>;
using LiveRoomProvider = std::function<LiveRoomContexts()>;
using LiveOverworldProvider = std::function<zelda3::Overworld*()>;
std::string RoomContextLabel(const LiveRoomContext* live);
 
struct RoomTileReference {
  size_t object_index = 0;
  uint16_t object_id = 0;
  uint16_t tile_word = 0;
  uint16_t sheet = 0;
  int slot = 0;
  // Loader-owned source addresses, not displayed palette-row identity.
  std::array<std::optional<zelda3::PaletteColorAddress>, 8> palette_colors{};
};
 
struct SourceObjectUse {
  size_t object_index = 0;
  uint16_t object_id = 0;
  bool shares_pixels = false;
  bool shares_palette = false;
  std::vector<RoomTileReference> references;
};
 
// Potential consumers of the selected source. Pixel identity is sheet + local
// tile; palette identity is the loader-owned group/index/color address. A match
// does not promise a visible change (raw indices and occlusion also matter).
std::vector<SourceObjectUse> FindSourceObjectUses(
    const std::vector<RoomTileReference>& references,
    const std::vector<GraphicsEditTarget>& targets,
    const zelda3::GameData* owner);
 
class RoomUsagePreview {
 public:
  absl::Status Render(Rom* rom, zelda3::GameData* game_data, int room_id,
                      const SheetPixels& sheets, bool objects_only,
                      zelda3::Room* live_room = nullptr);
 
  const std::vector<RoomTileReference>& tile_references() const {
    return tile_references_;
  }
  size_t unknown_objects() const { return unknown_objects_; }
 
  int room_id() const { return room_id_; }
  const gfx::Bitmap& bitmap() const { return composite_; }
  gfx::Bitmap& mutable_bitmap() { return composite_; }
  PreviewImage Snapshot() const { return SnapshotBitmap(composite_); }
 
  std::array<uint8_t, 16> blocks() const;
  std::vector<SDL_Rect> ObjectRectsUsingSheet(uint16_t sheet) const;
  std::vector<SDL_Rect> ObjectRectsForObject(size_t index) const;
  // Explicit loaded-room scan; never loads another room from ROM or creates a
  // composite image. Rendering caches may refresh, authoring state is retained.
  absl::Status TraceLoadedRoom(Rom* rom, zelda3::GameData* game_data,
                               zelda3::Room* room);
  void Reset();
 
 private:
  void CaptureUsage(const zelda3::Room& room);
  std::unique_ptr<zelda3::Room> room_;
  std::array<uint8_t, 16> blocks_{};
  std::vector<RoomTileReference> tile_references_;
  std::map<size_t, SDL_Rect> object_rects_;
  size_t unknown_objects_ = 0;
  int room_id_ = -1;
  gfx::Bitmap composite_;
};
 
struct LoadedRoomSourceUses {
  int room_id = -1;
  std::vector<SourceObjectUse> objects;
  size_t unknown_objects = 0;
  std::string error;
};
 
std::vector<LoadedRoomSourceUses> FindLoadedRoomSourceUses(
    Rom* rom, zelda3::GameData* game_data, const LiveRoomContexts& rooms,
    const std::vector<GraphicsEditTarget>& targets);
 
// ---------------------------------------------------------------------------
// Sprite context
// ---------------------------------------------------------------------------
 
class SpriteUsagePreview {
 public:
  absl::Status Configure(Rom* rom, zelda3::GameData* game_data, int spriteset,
                         int palette_room, std::string hack_name = {});
 
  void SetVanillaSprite(uint8_t sprite_id);
  void SetZsm(const zsprite::ZSprite& zsm, int animation);
  bool has_zsm() const { return zsm_.has_value(); }
 
  int frame_count() const;
  int frame() const { return frame_; }
  void SetFrame(int frame);
  bool Advance(float seconds);
 
  PreviewImage RenderFrame(const SheetPixels& sheets) const;
 
  const std::array<uint8_t, 8>& slots() const { return slots_; }
  bool UsesSheet(uint16_t sheet) const;
 
 private:
  std::vector<uint8_t> SheetOrRom(const SheetPixels& sheets,
                                  uint16_t sheet) const;
 
  Rom* rom_ = nullptr;
  zelda3::GameData* game_data_ = nullptr;
  std::array<uint8_t, 8> slots_{};
  std::array<SDL_Color, 256> colors_{};
  std::string hack_name_;
  uint8_t sprite_id_ = 0;
  std::optional<zsprite::ZSprite> zsm_;
  int animation_ = 0;
  int frame_ = 0;
  float remainder_ = 0.0f;
};
 
// ---------------------------------------------------------------------------
// Tile16 context
// ---------------------------------------------------------------------------
 
class Tile16UsagePreview {
 public:
  absl::Status Configure(Rom* rom, zelda3::GameData* game_data, int area);
 
  // Copies the selected live map and unsaved Tile16 definitions. The renderer
  // owns its copies, so preview overrides never mutate the source editor.
  absl::Status ConfigureFromLive(const zelda3::OverworldMap& map,
                                 const std::vector<gfx::Tile16>& definitions,
                                 const zelda3::GameData* owner);
 
  std::vector<int> Tile16sUsingTile(uint16_t sheet, int tile_index) const;
 
  PreviewImage Render(const SheetPixels& sheets,
                      const std::vector<int>& tile16s, uint16_t sheet,
                      int tile_index,
                      std::vector<SDL_Rect>* highlights = nullptr);
 
  int area() const { return area_; }
 
 private:
  std::vector<int> TileIdsFor(uint16_t sheet, int tile_index) const;
 
  Rom* rom_ = nullptr;
  zelda3::GameData* game_data_ = nullptr;
  int area_ = -1;
  std::unique_ptr<zelda3::OverworldMap> map_;
  std::vector<gfx::Tile16> tiles16_;
};
 
}  // namespace yaze::editor::usage_preview
 
#endif  // YAZE_APP_EDITOR_GRAPHICS_USAGE_PREVIEW_H