draw_routine_types.h

Go to the documentation of this file.

#ifndef YAZE_ZELDA3_DUNGEON_DRAW_ROUTINES_DRAW_ROUTINE_TYPES_H
#define YAZE_ZELDA3_DUNGEON_DRAW_ROUTINES_DRAW_ROUTINE_TYPES_H
 
#include <cstdint>
#include <functional>
#include <initializer_list>
#include <span>
#include <string>
 
#include "app/gfx/render/background_buffer.h"
#include "app/gfx/types/snes_tile.h"
#include "rom/rom.h"
 
namespace yaze {
namespace zelda3 {
 
// Forward declarations
class CustomObjectRenderSnapshot;
class DungeonState;
struct RoomObject;
 
struct DrawContext {
  gfx::BackgroundBuffer& target_bg;      // Primary buffer to draw to
  const RoomObject& object;              // Object being drawn
  std::span<const gfx::TileInfo> tiles;  // Tile data for the object
  const DungeonState* state;             // Dungeon state (chest states, etc.)
  Rom* rom;                              // ROM for additional data lookup
  int room_id;                           // Current room ID
  const uint8_t* room_gfx_buffer;        // Room-specific graphics buffer
  gfx::BackgroundBuffer*
      secondary_bg;  // Secondary BG for dual-layer routines (nullable)
  const gfx::BackgroundBuffer* target_layout_bg =
      nullptr;         // Matching layout owner for logical tilemap reads
  int room_tag2 = -1;  // Room header tag2 ($AF); -1 when not drawing a room
 
  const CustomObjectRenderSnapshot* custom_objects = nullptr;
 
  // Canvas dimensions
  static constexpr int kMaxTilesX = 64;
  static constexpr int kMaxTilesY = 64;
 
  // Helper to check if dual-BG drawing is available
  bool HasSecondaryBG() const { return secondary_bg != nullptr; }
};
 
using DrawRoutineFn = std::function<void(const DrawContext& ctx)>;
 
struct DrawRoutineInfo {
  int id;                  // Routine ID (0-39)
  std::string name;        // Human-readable name
  DrawRoutineFn function;  // The actual draw function
  bool draws_to_both_bgs;  // If true, draws to BG1 and BG2
  int base_width;          // Base width in tiles (0 = variable)
  int base_height;         // Base height in tiles (0 = variable)
 
  // Minimum number of tiles required for this routine to render correctly.
  // When > 0, ObjectDrawer::DrawObject will skip the routine if the object's
  // tile payload is smaller, preventing out-of-bounds access in fixed-size
  // draw patterns. Routines with variable tile counts should leave this at 0.
  int min_tiles = 0;
 
  // Category for organization
  enum class Category {
    Special,     // Chest, Nothing, Custom, DoorSwitcher
    Rightwards,  // Horizontal extension patterns
    Downwards,   // Vertical extension patterns
    Diagonal,    // Diagonal patterns
    Corner       // Corner and special shape patterns
  };
  Category category;
};
 
namespace DrawRoutineUtils {
 
using TraceHookFn = void (*)(gfx::BackgroundBuffer* bg, int tile_x, int tile_y,
                             const gfx::TileInfo& tile_info, void* user_data);
 
// Optional trace hook for validation/testing (used by ObjectDrawer).
void SetTraceHook(TraceHookFn hook, void* user_data, bool trace_only);
void ClearTraceHook();
 
inline uint16_t TileIdAt(const gfx::BackgroundBuffer& bg, int tile_x,
                         int tile_y) {
  return bg.GetTileAt(tile_x, tile_y) & 0x03FF;
}
 
inline bool ExistingTileMatchesAny(const gfx::BackgroundBuffer& bg, int tile_x,
                                   int tile_y,
                                   std::initializer_list<uint16_t> tile_ids) {
  const uint16_t existing_tile_id = TileIdAt(bg, tile_x, tile_y);
  for (const uint16_t tile_id : tile_ids) {
    if (existing_tile_id == tile_id) {
      return true;
    }
  }
  return false;
}
 
inline bool TileHasObjectCoverage(const gfx::BackgroundBuffer& bg, int tile_x,
                                  int tile_y) {
  const auto& coverage = bg.coverage_data();
  const auto& bitmap = bg.bitmap();
  if (coverage.empty() || bitmap.width() <= 0 || bitmap.height() <= 0) {
    return false;
  }
 
  const int start_x = tile_x * 8;
  const int start_y = tile_y * 8;
  if (start_x < 0 || start_y < 0 || start_x >= bitmap.width() ||
      start_y >= bitmap.height()) {
    return false;
  }
 
  // ObjectDrawer marks the full 8x8 footprint even when a tile is visually
  // transparent. Checking one pixel is therefore enough to establish which
  // split buffer owns the effective SNES tilemap entry.
  const size_t index = static_cast<size_t>(start_y * bitmap.width() + start_x);
  return index < coverage.size() && coverage[index] != 0;
}
 
inline bool ExistingTileMatchesAny(const DrawContext& ctx, int tile_x,
                                   int tile_y,
                                   std::initializer_list<uint16_t> tile_ids) {
  const gfx::BackgroundBuffer* effective_owner = &ctx.target_bg;
  if (!TileHasObjectCoverage(ctx.target_bg, tile_x, tile_y) &&
      ctx.target_layout_bg != nullptr) {
    effective_owner = ctx.target_layout_bg;
  }
  return ExistingTileMatchesAny(*effective_owner, tile_x, tile_y, tile_ids);
}
 
inline bool IsValidTilePosition(int tile_x, int tile_y) {
  return tile_x >= 0 && tile_x < DrawContext::kMaxTilesX && tile_y >= 0 &&
         tile_y < DrawContext::kMaxTilesY;
}
 
void WriteTile8(gfx::BackgroundBuffer& bg, int tile_x, int tile_y,
                const gfx::TileInfo& tile_info);
 
void DrawBlock2x2(gfx::BackgroundBuffer& bg, int tile_x, int tile_y,
                  std::span<const gfx::TileInfo> tiles, int offset = 0);
 
void DrawBlock2x4(gfx::BackgroundBuffer& bg, int tile_x, int tile_y,
                  std::span<const gfx::TileInfo> tiles, int offset = 0);
 
void DrawBlock4x2(gfx::BackgroundBuffer& bg, int tile_x, int tile_y,
                  std::span<const gfx::TileInfo> tiles, int offset = 0);
 
void DrawBlock4x4(gfx::BackgroundBuffer& bg, int tile_x, int tile_y,
                  std::span<const gfx::TileInfo> tiles, int offset = 0);
 
}  // namespace DrawRoutineUtils
 
}  // namespace zelda3
}  // namespace yaze
 
#endif  // YAZE_ZELDA3_DUNGEON_DRAW_ROUTINES_DRAW_ROUTINE_TYPES_H