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 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)
 
  // 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 (*)(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 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