object_geometry.h

Go to the documentation of this file.

#ifndef YAZE_ZELDA3_DUNGEON_GEOMETRY_OBJECT_GEOMETRY_H
#define YAZE_ZELDA3_DUNGEON_GEOMETRY_OBJECT_GEOMETRY_H
 
#include <cstdint>
#include <optional>
#include <tuple>
#include <unordered_map>
#include <vector>
 
#include "absl/status/statusor.h"
#include "zelda3/dungeon/draw_routines/draw_routine_types.h"
#include "zelda3/dungeon/room_object.h"
 
namespace yaze {
namespace zelda3 {
 
class DungeonState;
 
struct SelectionRect {
  int x_tiles = 0;
  int y_tiles = 0;
  int width_tiles = 0;
  int height_tiles = 0;
 
  int width_pixels() const { return width_tiles * 8; }
  int height_pixels() const { return height_tiles * 8; }
};
 
struct GeometryBounds {
  // Full rendered area (bounding box of all drawn tiles)
  int min_x_tiles = 0;
  int min_y_tiles = 0;
  int width_tiles = 0;
  int height_tiles = 0;
 
  // Layer information for BG2 masking
  bool is_bg2_overlay = false;  // True if this object draws to BG2 (Layer 1)
 
  // Optional tighter selection hitbox for non-rectangular shapes
  // If not set, selection uses the full render bounds
  std::optional<SelectionRect> selection_bounds;
 
  int max_x_tiles() const { return min_x_tiles + width_tiles; }
  int max_y_tiles() const { return min_y_tiles + height_tiles; }
  int width_pixels() const { return width_tiles * 8; }
  int height_pixels() const { return height_tiles * 8; }
 
  // Pixel-based accessors for the mask rectangle
  int min_x_pixels() const { return min_x_tiles * 8; }
  int min_y_pixels() const { return min_y_tiles * 8; }
 
  bool RequiresBG1Mask() const { return is_bg2_overlay && width_tiles > 0; }
 
  bool HasTighterSelectionBounds() const {
    return selection_bounds.has_value();
  }
 
  SelectionRect GetSelectionBounds() const {
    if (selection_bounds.has_value()) {
      return *selection_bounds;
    }
    return SelectionRect{min_x_tiles, min_y_tiles, width_tiles, height_tiles};
  }
 
  std::tuple<int, int, int, int> GetBG1MaskRect(int obj_x, int obj_y) const {
    int start_x = (obj_x + min_x_tiles) * 8;
    int start_y = (obj_y + min_y_tiles) * 8;
    return {start_x, start_y, width_pixels(), height_pixels()};
  }
};
 
class ObjectGeometry {
 public:
  static ObjectGeometry& Get();
 
  // Look up routine metadata by routine ID. Returns nullptr on unknown IDs.
  const DrawRoutineInfo* LookupRoutine(int routine_id) const;
 
  // Measure bounds by routine id using the object's size/id bits.
  absl::StatusOr<GeometryBounds> MeasureByRoutineId(
      int routine_id, const RoomObject& object) const;
 
  // Measure bounds by object ID (resolves object_id -> routine_id internally).
  // Results are cached by (routine_id, object_id, size).
  absl::StatusOr<GeometryBounds> MeasureByObjectId(
      const RoomObject& object) const;
 
  // Measure the concrete footprint produced for an explicit runtime state.
  // Unlike MeasureByObjectId(), this does not substitute the largest known
  // stateful footprint and is therefore suitable for draw-trace validation.
  // A null state measures the routine's default branch.
  absl::StatusOr<GeometryBounds> MeasureByObjectIdForState(
      const RoomObject& object, const DungeonState* state) const;
 
  // Clear the measurement cache (e.g., after routine registry changes).
  void ClearCache();
 
  // Measure bounds for a specific routine metadata entry.
  absl::StatusOr<GeometryBounds> MeasureRoutine(const DrawRoutineInfo& routine,
                                                const RoomObject& object) const;
 
  // State-specific counterpart to MeasureRoutine(). This bypasses the
  // editor-selection policy that intentionally measures the largest stable
  // state for objects such as the empty water face.
  absl::StatusOr<GeometryBounds> MeasureRoutineForState(
      const DrawRoutineInfo& routine, const RoomObject& object,
      const DungeonState* state) const;
 
  std::pair<int, int> ResolveAnchor(int16_t object_id, uint8_t size_byte) const;
 
  absl::StatusOr<GeometryBounds> MeasureForLayerCompositing(
      int routine_id, const RoomObject& object) const;
 
  static bool IsLayerOneRoutine(int routine_id);
 
  static bool IsDiagonalCeilingRoutine(int routine_id);
 
  static GeometryBounds ApplySelectionBounds(GeometryBounds render_bounds,
                                             int routine_id);
 
 private:
  ObjectGeometry();
  void BuildRegistry();
 
  // Cache key: combines routine_id, object_id, and size into a single uint64.
  struct CacheKey {
    int routine_id;
    int16_t object_id;
    uint8_t size;
    bool operator==(const CacheKey& o) const {
      return routine_id == o.routine_id && object_id == o.object_id &&
             size == o.size;
    }
  };
  struct CacheKeyHash {
    size_t operator()(const CacheKey& k) const {
      return std::hash<uint64_t>()(
          (static_cast<uint64_t>(k.routine_id) << 32) |
          (static_cast<uint64_t>(static_cast<uint16_t>(k.object_id)) << 8) |
          k.size);
    }
  };
 
  std::vector<DrawRoutineInfo> routines_;
  std::unordered_map<int, DrawRoutineInfo> routine_map_;
  mutable std::unordered_map<CacheKey, GeometryBounds, CacheKeyHash> cache_;
};
 
}  // namespace zelda3
}  // namespace yaze
 
#endif  // YAZE_ZELDA3_DUNGEON_GEOMETRY_OBJECT_GEOMETRY_H