gfx_sheet_storage.h

Go to the documentation of this file.

#ifndef YAZE_ZELDA3_GFX_SHEET_STORAGE_H
#define YAZE_ZELDA3_GFX_SHEET_STORAGE_H
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <map>
#include <set>
#include <string>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "rom/rom.h"
 
namespace yaze::zelda3 {
 
constexpr size_t kGfxSheetCount = 223;
constexpr size_t kGfxSheet3bppBytes = 0x600;
constexpr size_t kGfxSheet2bppBytes = 0x800;
 
enum class GfxSheetStorageKind {
  kCompressed3bpp,
  kRaw3bpp,
  kCompressed2bpp,
};
 
GfxSheetStorageKind GetGfxSheetStorageKind(uint16_t sheet_id);
const char* GfxSheetStorageKindName(GfxSheetStorageKind kind);
 
struct GfxSheetPointerTables {
  uint32_t bank = 0x4F80;
  uint32_t high = 0x505F;
  uint32_t low = 0x513E;
};
 
bool UsesJapaneseGfxSheetTables(const Rom& rom);
 
struct GfxSheetPcRange {
  uint32_t begin = 0;
  uint32_t end = 0;
};
 
struct GfxSheetExtent {
  uint16_t sheet_id = 0;
  GfxSheetStorageKind kind = GfxSheetStorageKind::kCompressed3bpp;
  uint32_t pc = 0;
  // Bytes the sheet occupies at pc (compressed size including the 0xFF
  // terminator, or 0x600 for raw sheets).
  size_t stored_size = 0;
  // Bytes the sheet expands to.
  size_t decoded_size = 0;
};
 
absl::StatusOr<uint32_t> ReadGfxSheetPc(
    const Rom& rom, uint16_t sheet_id,
    const GfxSheetPointerTables& tables = {});
 
absl::StatusOr<GfxSheetExtent> ReadGfxSheetExtent(
    const Rom& rom, uint16_t sheet_id,
    const GfxSheetPointerTables& tables = {});
 
absl::StatusOr<std::vector<uint8_t>> ReadGfxSheetData(
    const Rom& rom, uint16_t sheet_id,
    const GfxSheetPointerTables& tables = {});
 
constexpr int kGfxSheetBlockCount = 16;
 
std::array<int, 4> GfxSheetBlockTiles(int block);
 
bool IsGfxSheetBlockEmpty(const std::vector<uint8_t>& data, int block,
                          int bpp = 3);
 
struct GfxSheetWritePolicy {
  // Free space a sheet may move to when its new stream no longer fits.
  // Bytes in these ranges that no sheet pointer references are free.
  // Empty means relocation is refused.
  std::vector<GfxSheetPcRange> allocation_regions;
  // Sheets that must never be written.
  std::set<uint16_t> reserved_sheets;
  // 16x16 blocks (0-15) per sheet whose pixels must not change.
  std::map<uint16_t, std::vector<uint16_t>> reserved_blocks;
  // Returns an error when [begin, end) must not be written (for example a
  // hack-manifest protected region). Unset means no extra check.
  std::function<absl::Status(uint32_t begin, uint32_t end)> check_write;
};
 
enum class GfxSheetPlacement { kInPlace, kRelocated };
 
struct GfxSheetWriteResult {
  uint16_t sheet_id = 0;
  GfxSheetPlacement placement = GfxSheetPlacement::kInPlace;
  uint32_t old_pc = 0;
  uint32_t new_pc = 0;
  // 0 when the old stream could not be measured.
  size_t old_stored_size = 0;
  size_t new_stored_size = 0;
};
 
absl::StatusOr<GfxSheetWriteResult> WriteGfxSheet(
    Rom& rom, uint16_t sheet_id, const std::vector<uint8_t>& snes_3bpp,
    const GfxSheetWritePolicy& policy,
    const GfxSheetPointerTables& tables = {});
 
}  // namespace yaze::zelda3
 
#endif  // YAZE_ZELDA3_GFX_SHEET_STORAGE_H