gfx_sheet_png.h

Go to the documentation of this file.

#ifndef YAZE_ZELDA3_GFX_SHEET_PNG_H
#define YAZE_ZELDA3_GFX_SHEET_PNG_H
 
#include <array>
#include <cstdint>
#include <utility>
#include <vector>
 
#include "absl/status/statusor.h"
#include "rom/rom.h"
#include "util/indexed_png.h"
#include "zelda3/dungeon/room_default_entrance.h"
 
namespace yaze::zelda3 {
 
struct GameData;
 
using SheetColor = std::array<uint8_t, 3>;
using SheetPalette = std::array<SheetColor, 8>;
 
SheetPalette GrayscaleSheetPalette();
 
absl::StatusOr<SheetPalette> RoomBackgroundSheetPalette(Rom& rom,
                                                        GameData& data,
                                                        int room, int row);
 
bool IsHighHalfSpriteSheet(int sheet);
 
absl::StatusOr<SheetPalette> RoomSpriteSheetPalette(Rom& rom, GameData& data,
                                                    int room, int row,
                                                    bool high_half = false);
 
absl::StatusOr<std::vector<uint8_t>> ExportSheetDiffPng(
    const std::vector<uint8_t>& before_3bpp,
    const std::vector<uint8_t>& after_3bpp, const SheetPalette& palette);
 
absl::StatusOr<std::vector<uint8_t>> ExportSheetBlocksPng(
    const std::vector<uint8_t>& snes_3bpp, const SheetPalette& palette,
    int first_block = 0, int block_count = 16);
 
struct SheetImportResult {
  std::vector<uint8_t> snes_3bpp;   // the edited sheet (0x600 bytes)
  std::vector<int> changed_blocks;  // 16x16 blocks 0-15
  std::vector<int> changed_tiles;   // 8x8 tiles 0-63
  std::vector<std::pair<int, int>> changed_ranges;  // [begin, end) in sheet
};
 
absl::StatusOr<SheetImportResult> ImportSheetBlocksPng(
    const std::vector<uint8_t>& snes_3bpp, const util::PngImage& png,
    int first_block, const SheetPalette& palette);
 
// ---------------------------------------------------------------------------
// Dungeon room background sets
// ---------------------------------------------------------------------------
 
struct RoomBackgroundSet {
  int room = 0;
  uint8_t header_blockset = 0;  // room blockset ($0AA2)
  uint8_t main_blockset = 0;    // main blockset ($0AA1)
  std::array<uint8_t, 8> sheets{};
  std::array<bool, 8> from_room_blockset{};
};
 
RoomBackgroundSet ResolveRoomBackgroundSet(const GameData& data, int room,
                                           uint8_t header_blockset);
 
// Read-only palette context for one 3bpp background sheet as loaded through
// the room's default entrance. Inferred defaults are recorded, not treated
// as proof of the entrance used during gameplay. Slot 7's animation overlay
// is not baked into the exported source sheet.
struct RoomSheetPaletteContext {
  RoomBackgroundSet background;
  RoomMainBlocksetResolution main;
  RoomDefaultEntrance entrance;
  int slot = 0;
  int row = 0;
  int palette_offset = 0;
  std::array<uint8_t, 8> cgram_indices{};
  SheetPalette colors{};
};
 
absl::StatusOr<RoomSheetPaletteContext> ResolveRoomSheetPalette(
    Rom& rom, GameData& data, int room, int slot, int row);
 
std::vector<RoomBackgroundSet> ResolveAllRoomBackgroundSets(
    const Rom& rom, const GameData& data);
 
absl::StatusOr<std::vector<uint8_t>> ExportRoomBackgroundPng(
    const Rom& rom, const RoomBackgroundSet& set, const SheetPalette& palette);
 
struct RoomSheetImport {
  uint16_t sheet = 0;
  std::vector<int> slots;  // slots showing this sheet
  SheetImportResult result;
};
 
absl::StatusOr<std::vector<RoomSheetImport>> ImportRoomBackgroundPng(
    const Rom& rom, const RoomBackgroundSet& set, const util::PngImage& png,
    const SheetPalette& palette);
 
}  // namespace yaze::zelda3
 
#endif  // YAZE_ZELDA3_GFX_SHEET_PNG_H