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);
 
  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);
 
  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 SetAllowTrackCornerAliases(bool allow) {
    allow_track_corner_aliases_ = allow;
  }
  void SetBG1RevealMaskSource(gfx::BG1RevealMaskSource source) {
    bg1_reveal_mask_source_ = source;
  }
 
  void DrawDoor(const DoorDef& door, int door_index, gfx::BackgroundBuffer& bg1,
                gfx::BackgroundBuffer& bg2,
                const DungeonState* state = 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);
 
  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;
 
  Rom* rom_;
  int room_id_;
  mutable int current_chest_index_ = 0;
  mutable int current_room_event_index_ = 0;
  bool allow_track_corner_aliases_ = true;
  gfx::BackgroundBuffer* registry_secondary_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