object_geometry.cc

Go to the documentation of this file.

#include "zelda3/dungeon/geometry/object_geometry.h"
 
#include <algorithm>
#include <limits>
 
#include "absl/status/status.h"
#include "absl/strings/str_format.h"
#include "app/gfx/render/background_buffer.h"
#include "app/gfx/types/snes_tile.h"
#include "zelda3/dungeon/custom_object.h"
#include "zelda3/dungeon/draw_routines/draw_routine_registry.h"
#include "zelda3/dungeon/dungeon_state.h"
#include "zelda3/dungeon/moving_wall_semantics.h"
 
namespace yaze {
namespace zelda3 {
 
namespace {
 
constexpr int kDummyTileCount = 512;
 
struct AnchorPos {
  int x = 0;
  int y = 0;
};
 
class MeasurementDungeonState final : public DungeonState {
 public:
  explicit MeasurementDungeonState(bool water_face_active)
      : water_face_active_(water_face_active) {}
 
  bool IsChestOpen(int /*room_id*/, int /*chest_index*/) const override {
    return false;
  }
  bool IsBigChestOpen() const override { return false; }
  bool IsDoorOpen(int /*room_id*/, int /*door_index*/) const override {
    return false;
  }
  bool IsDoorSwitchActive(int /*room_id*/) const override { return false; }
  bool IsWaterFaceActive(int /*room_id*/) const override {
    return water_face_active_;
  }
  bool IsDamFloodgateOpen(int /*room_id*/) const override { return false; }
  bool IsWallMoved(int /*room_id*/) const override { return false; }
  bool IsFloorBombable(int /*room_id*/) const override { return false; }
  bool IsRupeeFloorCleared(int /*room_id*/) const override { return false; }
  bool IsCrystalSwitchBlue() const override { return true; }
 
 private:
  bool water_face_active_ = false;
};
 
const DungeonState* SelectMeasurementState(const DrawRoutineInfo& routine) {
  // Geometry drives selection and hit-testing, so routines with a stable
  // stateful expansion should replay their largest footprint here.
  static const MeasurementDungeonState kActiveWaterFaceState(
      /*water_face_active=*/true);
 
  if (routine.id == DrawRoutineIds::kEmptyWaterFace) {
    return &kActiveWaterFaceState;
  }
  return nullptr;
}
 
std::vector<gfx::TileInfo> MakeDummyTiles() {
  std::vector<gfx::TileInfo> tiles;
  tiles.reserve(kDummyTileCount);
  for (int i = 0; i < kDummyTileCount; ++i) {
    // Non-zero tile IDs so writes are detectable in the buffer
    tiles.push_back(gfx::TileInfo(static_cast<uint16_t>(i + 1), 0,
                                  /*v=*/false, /*h=*/false, /*o=*/false));
  }
  return tiles;
}
 
// Choose an anchor (x, y) that avoids buffer clipping for routines that draw
// leftward or upward from the object origin. Without enough headroom, the
// off-screen replay in MeasureRoutine loses rows/columns that the real draw
// routine would have emitted, producing undersized bounds.
AnchorPos ChooseAnchor(const DrawRoutineInfo& routine,
                       const RoomObject& object) {
  AnchorPos anchor;
  const int size_nibble = object.size_ & 0x0F;
 
  // Acute diagonals (ids 5, 17) move upward by (y - s) per step.
  if (routine.category == DrawRoutineInfo::Category::Diagonal &&
      (routine.id == 5 || routine.id == 17)) {
    const int count = size_nibble + 6;
    const int max_anchor =
        DrawContext::kMaxTilesY - 5;  // 4 rows headroom below
    anchor.y = std::clamp(count - 1, 0, std::max(0, max_anchor));
    return anchor;
  }
 
  // Only the bottom-right diagonal ceiling (78) walks upward from the encoded
  // origin. Give that replay enough Y headroom so geometry is not clipped.
  if (routine.category == DrawRoutineInfo::Category::Corner &&
      routine.id >= 75 && routine.id <= 78) {
    const int side = size_nibble + 4;
    if (routine.id == 78) {
      anchor.y = std::clamp(side - 1, 0, DrawContext::kMaxTilesY - 1);
    }
    return anchor;
  }
 
  // The west-moving wall (0xCD) grows 8/16/24/32 fill columns left from its
  // three-column platform anchor. Preserve that left extent during replay.
  if (routine.id == DrawRoutineIds::kMovingWallWest) {
    anchor.x = moving_wall::ObjectCountForSize(object.size_);
    return anchor;
  }
 
  // Default: top-left of canvas.
  return anchor;
}
 
}  // namespace
 
ObjectGeometry& ObjectGeometry::Get() {
  static ObjectGeometry instance;
  return instance;
}
 
ObjectGeometry::ObjectGeometry() {
  BuildRegistry();
}
 
void ObjectGeometry::BuildRegistry() {
  routines_.clear();
  routine_map_.clear();
 
  // Use the unified DrawRoutineRegistry to ensure consistent routine IDs
  // between ObjectGeometry and ObjectDrawer
  const auto& registry = DrawRoutineRegistry::Get();
  routines_ = registry.GetAllRoutines();
 
  for (const auto& info : routines_) {
    routine_map_[info.id] = info;
  }
}
 
const DrawRoutineInfo* ObjectGeometry::LookupRoutine(int routine_id) const {
  auto it = routine_map_.find(routine_id);
  if (it == routine_map_.end()) {
    return nullptr;
  }
  return &it->second;
}
 
absl::StatusOr<GeometryBounds> ObjectGeometry::MeasureByRoutineId(
    int routine_id, const RoomObject& object) const {
  const DrawRoutineInfo* info = LookupRoutine(routine_id);
  if (info == nullptr) {
    return absl::InvalidArgumentError(
        absl::StrFormat("Unknown routine id %d", routine_id));
  }
  return MeasureRoutine(*info, object);
}
 
std::pair<int, int> ObjectGeometry::ResolveAnchor(int16_t object_id,
                                                  uint8_t size_byte) const {
  const int routine_id =
      DrawRoutineRegistry::Get().GetRoutineIdForObject(object_id);
  if (routine_id < 0) {
    return {0, 0};
  }
  const DrawRoutineInfo* info = LookupRoutine(routine_id);
  if (info == nullptr) {
    return {0, 0};
  }
  RoomObject probe(object_id, 0, 0, size_byte, 0);
  AnchorPos anchor = ChooseAnchor(*info, probe);
  return {anchor.x, anchor.y};
}
 
absl::StatusOr<GeometryBounds> ObjectGeometry::MeasureRoutine(
    const DrawRoutineInfo& routine, const RoomObject& object) const {
  return MeasureRoutineForState(routine, object,
                                SelectMeasurementState(routine));
}
 
absl::StatusOr<GeometryBounds> ObjectGeometry::MeasureRoutineForState(
    const DrawRoutineInfo& routine, const RoomObject& object,
    const DungeonState* state) const {
  // Anchor object so routines that move upward or leftward stay within bounds.
  RoomObject adjusted = object;
  const AnchorPos anchor = ChooseAnchor(routine, object);
  adjusted.x_ = anchor.x;
  adjusted.y_ = anchor.y;
 
  // Allocate a dummy tile list large enough for every routine. Chest geometry
  // is payload-sensitive: the canonical subtype-3 small-chest objects
  // (0xF99/0xF9A) use routine 39 with four tiles, while a 16+ tile span makes
  // that routine take its 4x4 subtype-1 chest path. Big chests use their own
  // routine (114), so constrain only those two small-chest object IDs to the
  // routine's declared minimum payload.
  static const std::vector<gfx::TileInfo> kTiles = MakeDummyTiles();
  const uint16_t object_id = static_cast<uint16_t>(object.id_);
  const bool is_small_chest = routine.id == DrawRoutineIds::kChest &&
                              (object_id == 0x0F99 || object_id == 0x0F9A);
  const size_t measurement_tile_count =
      is_small_chest ? static_cast<size_t>(routine.min_tiles) : kTiles.size();
 
  gfx::BackgroundBuffer bg(DrawContext::kMaxTilesX * 8,
                           DrawContext::kMaxTilesY * 8);
 
  DrawContext ctx{
      .target_bg = bg,
      .object = adjusted,
      .tiles =
          std::span<const gfx::TileInfo>(kTiles.data(), measurement_tile_count),
      .state = state,
      .rom = nullptr,
      .room_id = 0,
      .room_gfx_buffer = nullptr,
      .secondary_bg = nullptr,
  };
 
  // Execute the routine to mark tiles in the buffer.
  routine.function(ctx);
 
  // Scan buffer for written tiles.
  const int tiles_w = DrawContext::kMaxTilesX;
  const int tiles_h = DrawContext::kMaxTilesY;
 
  int min_x = std::numeric_limits<int>::max();
  int min_y = std::numeric_limits<int>::max();
  int max_x = std::numeric_limits<int>::min();
  int max_y = std::numeric_limits<int>::min();
 
  for (int y = 0; y < tiles_h; ++y) {
    for (int x = 0; x < tiles_w; ++x) {
      if (bg.GetTileAt(x, y) == 0)
        continue;
      min_x = std::min(min_x, x);
      min_y = std::min(min_y, y);
      max_x = std::max(max_x, x);
      max_y = std::max(max_y, y);
    }
  }
 
  // Handle routines that intentionally draw nothing.
  if (max_x == std::numeric_limits<int>::min()) {
    return GeometryBounds{};
  }
 
  GeometryBounds bounds;
  bounds.min_x_tiles = min_x - anchor.x;
  bounds.min_y_tiles = min_y - anchor.y;
  bounds.width_tiles = (max_x - min_x) + 1;
  bounds.height_tiles = (max_y - min_y) + 1;
  bounds.is_bg2_overlay = false;  // Default, set by MeasureForLayerCompositing
  return bounds;
}
 
absl::StatusOr<GeometryBounds> ObjectGeometry::MeasureByObjectId(
    const RoomObject& object) const {
  int routine_id = DrawRoutineRegistry::Get().GetRoutineIdForObject(object.id_);
  if (routine_id < 0) {
    return absl::NotFoundError(
        absl::StrFormat("No routine mapping for object 0x%03X", object.id_));
  }
 
  // Check cache
  CacheKey key{routine_id, object.id_, object.size_,
               CustomObjectManager::Get().asset_generation()};
  auto cache_it = cache_.find(key);
  if (cache_it != cache_.end()) {
    return cache_it->second;
  }
 
  // Measure and cache
  auto result = MeasureByRoutineId(routine_id, object);
  if (result.ok()) {
    cache_[key] = *result;
  }
  return result;
}
 
absl::StatusOr<GeometryBounds> ObjectGeometry::MeasureByObjectIdForState(
    const RoomObject& object, const DungeonState* state) const {
  const int routine_id =
      DrawRoutineRegistry::Get().GetRoutineIdForObject(object.id_);
  if (routine_id < 0) {
    return absl::NotFoundError(
        absl::StrFormat("No routine mapping for object 0x%03X", object.id_));
  }
 
  const DrawRoutineInfo* routine = LookupRoutine(routine_id);
  if (routine == nullptr) {
    return absl::InvalidArgumentError(
        absl::StrFormat("Unknown routine id %d", routine_id));
  }
 
  return MeasureRoutineForState(*routine, object, state);
}
 
void ObjectGeometry::ClearCache() {
  cache_.clear();
}
 
absl::StatusOr<GeometryBounds> ObjectGeometry::MeasureForLayerCompositing(
    int routine_id, const RoomObject& object) const {
  auto result = MeasureByRoutineId(routine_id, object);
  if (!result.ok()) {
    return result;
  }
 
  GeometryBounds bounds = *result;
 
  // Mark as BG2 overlay if the object's layer indicates Layer 1 (BG2)
  // Layer 1 objects write to the lower tilemap (BG2) and need BG1 transparency
  bounds.is_bg2_overlay = (object.layer_ == RoomObject::LayerType::BG2);
 
  return bounds;
}
 
bool ObjectGeometry::IsLayerOneRoutine(int routine_id) {
  // Layer 1 routines are those that explicitly draw to BG2 only.
  // Most objects draw to the current layer pointer; this list is for
  // routines that have special BG2-only behavior.
  //
  // From ASM analysis:
  // - Objects decoded with $BF == $4000 (lower_layer) are Layer 1/BG2
  // - The routine itself doesn't determine the layer; the object's position
  //   in the room data determines which layer pointer it uses
  //
  // This method is primarily for documentation; actual layer determination
  // comes from the object's layer_ field set during room loading.
  (void)
      routine_id;  // Currently unused - layer determined by object, not routine
  return false;
}
 
}  // namespace zelda3
}  // namespace yaze