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 <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 {
 
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 for a specific routine metadata entry.
  absl::StatusOr<GeometryBounds> MeasureRoutine(
      const DrawRoutineInfo& routine, const RoomObject& object) 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();
 
  std::vector<DrawRoutineInfo> routines_;
  std::unordered_map<int, DrawRoutineInfo> routine_map_;
};
 
}  // namespace zelda3
}  // namespace yaze
 
#endif  // YAZE_ZELDA3_DUNGEON_GEOMETRY_OBJECT_GEOMETRY_H