object_drawer.h

Go to the documentation of this file.

#ifndef YAZE_APP_ZELDA3_DUNGEON_OBJECT_DRAWER_H
#define YAZE_APP_ZELDA3_DUNGEON_OBJECT_DRAWER_H
 
#include <functional>
#include <unordered_map>
#include <vector>
 
#include "absl/status/status.h"
#include "app/gfx/render/background_buffer.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gfx/types/snes_tile.h"
#include "rom/rom.h"
#include "zelda3/dungeon/custom_object.h"
#include "zelda3/dungeon/door_position.h"
#include "zelda3/dungeon/door_types.h"
#include "zelda3/dungeon/dungeon_state.h"
#include "zelda3/dungeon/room_object.h"
 
namespace yaze {
namespace zelda3 {
 
class ObjectDrawer {
 public:
  explicit ObjectDrawer(
      Rom* rom, int room_id, const uint8_t* room_gfx_buffer = nullptr,
      const CustomObjectRenderSnapshot* custom_objects = nullptr);
 
  absl::Status DrawObject(const RoomObject& object, gfx::BackgroundBuffer& bg1,
                          gfx::BackgroundBuffer& bg2,
                          const gfx::PaletteGroup& palette_group,
                          const DungeonState* state = nullptr,
                          gfx::BackgroundBuffer* layout_bg1 = nullptr,
                          gfx::BackgroundBuffer* layout_bg2 = nullptr);
 
  // USDASM RoomDraw_BG2MaskFull (type-3 0xFF3): fills the object's whole
  // layer with the tilemap erase word $01EC.
  absl::Status DrawLayerMaskFull(const RoomObject& object,
                                 gfx::BackgroundBuffer& target_bg,
                                 RoomObject::LayerType layer);
  // USDASM RoomDraw_LampCones (type-3 0xFAA): four fixed 12x12 blocks on BG2,
  // independent of the object's position, size and list.
  absl::Status DrawLampCones(const RoomObject& object,
                             gfx::BackgroundBuffer& bg2);
 
  // USDASM RoomDraw_AgahnimsWindows (type-3 0xFAE): fixed stores relative to
  // the object's tilemap offset, then a priority-only pass.
  absl::Status DrawAgahnimsWindows(const RoomObject& object,
                                   gfx::BackgroundBuffer& bg1,
                                   gfx::BackgroundBuffer& bg2,
                                   gfx::BackgroundBuffer* layout_bg1,
                                   gfx::BackgroundBuffer* layout_bg2);
 
  // USDASM RoomDraw_SomeBigDecors (Kholdstare 0xF95, Trinexx 0xFF2 shells):
  // a 10x8 row-major block on the object's layer from ROM offset data_pc.
  absl::Status DrawBigDecor10x8(const RoomObject& object,
                                gfx::BackgroundBuffer& target_bg,
                                RoomObject::LayerType layer, int data_pc);
  // USDASM RoomDraw_VitreousGooGraphics (0xFE2): 22x11 column-major on BG2
  // plus a 3x2 block.
  absl::Status DrawVitreousGoo(const RoomObject& object,
                               gfx::BackgroundBuffer& bg2);
 
  // USDASM RoomTag_ChestHoles0 (tag 0x22) / RoomTag_ChestHoles8 (tag 0x3B):
  // once chest 0 is open, Underworld_ApplyRoomOverlay draws that overlay's
  // pits onto BG1 ($7E2000). Draws nothing for other tags or a closed chest.
  void DrawChestHoleOverlay(int tag1, int tag2, const DungeonState* state,
                            gfx::BackgroundBuffer& bg1);
 
  struct DoorDef {
    DoorType type;
    DoorDirection direction;
    uint8_t position;
 
    // Helper to get visible render coordinates using DoorPositionManager.
    std::pair<int, int> GetTileCoords() const {
      return DoorPositionManager::PositionToRenderTileCoords(position,
                                                             direction);
    }
 
    // Helper to get door dimensions
    DoorDimensions GetDimensions() const {
      return GetDoorDimensions(direction);
    }
  };
 
  // Reset the chest-only and shared chest/big-key-lock room-event indexes.
  void ResetChestIndex() {
    current_chest_index_ = 0;
    current_room_event_index_ = 0;
  }
  void SetBG1RevealMaskSource(gfx::BG1RevealMaskSource source) {
    bg1_reveal_mask_source_ = source;
  }
  // Room objects 0xC4/0xDB copy the active Floor 1/Floor 2 pattern rather than
  // reading a normal object tile payload.
  // Room header tag2 ($AF), read by state-dependent routines such as
  // RoomDraw_EmptyWaterFace. -1 (default) means no room context.
  void SetRoomTag2(int tag2) { room_tag2_ = tag2; }
 
  void SetRoomFloorGraphics(uint8_t floor1, uint8_t floor2) {
    floor1_graphics_ = floor1 & 0x0F;
    floor2_graphics_ = floor2 & 0x0F;
    has_room_floor_graphics_ = true;
  }
 
  void DrawDoor(const DoorDef& door, int door_index, gfx::BackgroundBuffer& bg1,
                gfx::BackgroundBuffer& bg2, const DungeonState* state = nullptr,
                gfx::BackgroundBuffer* layout_bg1 = nullptr,
                gfx::BackgroundBuffer* layout_bg2 = nullptr);
 
  void DrawPotItem(uint8_t item_id, int x, int y, gfx::BackgroundBuffer& bg);
 
  absl::Status DrawObjectList(const std::vector<RoomObject>& objects,
                              gfx::BackgroundBuffer& bg1,
                              gfx::BackgroundBuffer& bg2,
                              const gfx::PaletteGroup& palette_group,
                              const DungeonState* state = nullptr,
                              gfx::BackgroundBuffer* layout_bg1 = nullptr,
                              bool reset_room_event_indices = true,
                              gfx::BackgroundBuffer* layout_bg2 = nullptr);
 
  int GetDrawRoutineId(int16_t object_id) const;
 
  int GetDrawRoutineCount() const {
    return static_cast<int>(draw_routines_.size());
  }
 
  void InitializeDrawRoutines();
 
  void DrawTileToBitmap(gfx::Bitmap& bitmap, const gfx::TileInfo& tile_info,
                        int pixel_x, int pixel_y, const uint8_t* tiledata);
 
  absl::Status DrawRoomDrawObjectData2x2(uint16_t object_id, int tile_x,
                                         int tile_y,
                                         RoomObject::LayerType layer,
                                         uint16_t room_draw_object_data_offset,
                                         gfx::BackgroundBuffer& bg1,
                                         gfx::BackgroundBuffer& bg2);
 
  std::pair<int, int> CalculateObjectDimensions(const RoomObject& object);
 
  struct TileTrace {
    uint16_t object_id = 0;
    uint8_t size = 0;
    uint8_t layer = 0;
    int16_t x_tile = 0;
    int16_t y_tile = 0;
    uint16_t tile_id = 0;
    uint8_t flags = 0;
  };
 
  void SetTraceCollector(std::vector<TileTrace>* collector,
                         bool trace_only = false);
  void ClearTraceCollector();
  bool TraceOnly() const { return trace_only_; }
 
 protected:
  // Draw routine function type
  using DrawRoutine = std::function<void(
      ObjectDrawer*, const RoomObject&, gfx::BackgroundBuffer&,
      std::span<const gfx::TileInfo>, const DungeonState*)>;
 
  // Core draw routines (based on ZScream's subtype1_routines table)
  void DrawChest(const RoomObject& obj, gfx::BackgroundBuffer& bg,
                 std::span<const gfx::TileInfo> tiles,
                 const DungeonState* state = nullptr);
  void DrawBigChest(const RoomObject& obj, gfx::BackgroundBuffer& bg,
                    std::span<const gfx::TileInfo> tiles,
                    const DungeonState* state = nullptr);
  void DrawBigKeyLock(const RoomObject& obj, gfx::BackgroundBuffer& bg,
                      std::span<const gfx::TileInfo> tiles,
                      const DungeonState* state = nullptr);
 
  void DrawNothing(const RoomObject& obj, gfx::BackgroundBuffer& bg,
                   std::span<const gfx::TileInfo> tiles,
                   const DungeonState* state = nullptr);
  void CustomDraw(const RoomObject& obj, gfx::BackgroundBuffer& bg,
                  std::span<const gfx::TileInfo> tiles,
                  const DungeonState* state = nullptr);
  void DrawRightwards4x4_1to16(const RoomObject& obj, gfx::BackgroundBuffer& bg,
                               std::span<const gfx::TileInfo> tiles,
                               const DungeonState* state = nullptr);
  void DrawRightwardsDecor4x3spaced4_1to16(const RoomObject& obj,
                                           gfx::BackgroundBuffer& bg,
                                           std::span<const gfx::TileInfo> tiles,
                                           const DungeonState* state = nullptr);
 
  // Type 3 / Special Routines
  void DrawLargeCanvasObject(const RoomObject& obj, gfx::BackgroundBuffer& bg,
                             std::span<const gfx::TileInfo> tiles, int width,
                             int height);
 
  // Custom Object Routine
  void DrawCustomObject(const RoomObject& obj, gfx::BackgroundBuffer& bg,
                        std::span<const gfx::TileInfo> tiles,
                        const DungeonState* state = nullptr);
  void DrawMissingCustomObjectPlaceholder(gfx::BackgroundBuffer& bg, int tile_x,
                                          int tile_y);
 
  // Utility methods
  // Execute a DrawRoutineRegistry routine (pure DrawContext function) but render
  // via ObjectDrawer::WriteTile8 so output hits the bitmap-backed buffers used
  // by RoomLayerManager compositing.
  void DrawUsingRegistryRoutine(int routine_id, const RoomObject& obj,
                                gfx::BackgroundBuffer& bg,
                                std::span<const gfx::TileInfo> tiles,
                                const DungeonState* state);
  void WriteTile8(gfx::BackgroundBuffer& bg, int tile_x, int tile_y,
                  const gfx::TileInfo& tile_info);
  bool IsValidTilePosition(int tile_x, int tile_y) const;
 
  // Check if a draw routine should render to both BG1 and BG2
  // Uses metadata instead of hardcoded routine IDs
  static bool RoutineDrawsToBothBGs(int routine_id);
 
  // Record a deferred BG1 reveal instead of mutating the raw BG1 pixels.
  void MarkBg1RectRevealed(gfx::BackgroundBuffer& bg1, int start_px,
                           int start_py, int pixel_width, int pixel_height);
  void MarkBg1OpaqueTilePixelsRevealed(gfx::BackgroundBuffer& bg1,
                                       const gfx::TileInfo& tile_info,
                                       int pixel_x, int pixel_y,
                                       const uint8_t* tiledata);
  static bool RequiresRectangularBg1Mask(const RoomObject& object);
 
  // Door indicator fallback when graphics unavailable
  void DrawDoorIndicator(gfx::BackgroundBuffer& bg, int tile_x, int tile_y,
                         int width, int height, DoorType type,
                         DoorDirection direction);
 
  // Draw routine function array (indexed by routine ID from DrawRoutineRegistry)
  std::vector<DrawRoutine> draw_routines_;
  bool routines_initialized_ = false;
 
  struct TraceContext {
    uint16_t object_id = 0;
    uint8_t size = 0;
    uint8_t layer = 0;
  };
 
  void SetTraceContext(const RoomObject& object, RoomObject::LayerType layer);
  void PushTrace(int tile_x, int tile_y, const gfx::TileInfo& tile_info);
  static void TraceHookThunk(gfx::BackgroundBuffer* bg, int tile_x, int tile_y,
                             const gfx::TileInfo& tile_info, void* user_data);
 
  TraceContext trace_context_{};
  std::vector<TileTrace>* trace_collector_ = nullptr;
  bool trace_only_ = false;
 
  // Optional job-owned snapshot; caller keeps it alive through drawing.
  const CustomObjectRenderSnapshot* custom_objects_ = nullptr;
  Rom* rom_;
  int room_id_;
  mutable int current_chest_index_ = 0;
  mutable int current_room_event_index_ = 0;
  bool has_room_floor_graphics_ = false;
  int room_tag2_ = -1;
  uint8_t floor1_graphics_ = 0;
  uint8_t floor2_graphics_ = 0;
  gfx::BackgroundBuffer* registry_secondary_bg_ = nullptr;
  // Object BG2 buffer: receives upper-tilemap writes past row 63.
  gfx::BackgroundBuffer* registry_bg2_ = nullptr;
  const gfx::BackgroundBuffer* registry_primary_layout_bg_ = nullptr;
  RoomObject::LayerType registry_primary_layer_ = RoomObject::LayerType::BG1;
  RoomObject::LayerType registry_secondary_layer_ = RoomObject::LayerType::BG2;
  gfx::BackgroundBuffer* active_object_bg1_mask_ = nullptr;
  gfx::BackgroundBuffer* active_layout_bg1_mask_ = nullptr;
  gfx::BackgroundBuffer* active_mask_source_bg_ = nullptr;
  gfx::BG1RevealMaskSource bg1_reveal_mask_source_ =
      gfx::BG1RevealMaskSource::kBG2Objects;
  const uint8_t*
      room_gfx_buffer_;  // Room-specific graphics buffer (current_gfx16_)
 
  // Canvas dimensions in tiles (64x64 = 512x512 pixels)
  static constexpr int kMaxTilesX = 64;
  static constexpr int kMaxTilesY = 64;
};
 
}  // namespace zelda3
}  // namespace yaze
 
#endif  // YAZE_APP_ZELDA3_DUNGEON_OBJECT_DRAWER_H