zspr_loader.h

Go to the documentation of this file.

#ifndef YAZE_APP_GFX_ZSPR_LOADER_H
#define YAZE_APP_GFX_ZSPR_LOADER_H
 
#include <array>
#include <cstdint>
#include <string>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
 
namespace yaze {
 
class Rom;
 
namespace gfx {
 
struct ZsprMetadata {
  std::string display_name;
  std::string author;
  std::string author_rom_name;
  uint8_t version = 0;
  uint16_t sprite_type = 0;  // 0 = Link, 1 = Other
};
 
struct ZsprData {
  ZsprMetadata metadata;
  std::vector<uint8_t> sprite_data;   // 28672 bytes (14 sheets × 2048 bytes)
  std::vector<uint8_t> palette_data;  // 120 bytes
  std::array<uint16_t, 2> glove_colors = {0, 0};
 
  // Convenience accessors
  bool is_link_sprite() const { return metadata.sprite_type == 0; }
  size_t tile_count() const { return sprite_data.size() / 32; }  // 32 bytes per 4BPP tile
};
 
class ZsprLoader {
 public:
  static constexpr uint32_t kZsprMagic = 0x5250535A;  // "ZSPR" little-endian
  static constexpr size_t kExpectedSpriteDataSize = 28672;  // 896 tiles × 32 bytes
  static constexpr size_t kExpectedPaletteDataSize = 120;   // 15 × 4 × 2 bytes
  static constexpr size_t kTilesPerSheet = 64;              // 8×8 tiles per sheet
  static constexpr size_t kBytesPerTile = 32;               // 4BPP 8×8 tile
  static constexpr size_t kLinkSheetCount = 14;
 
  static absl::StatusOr<ZsprData> LoadFromFile(const std::string& path);
 
  static absl::StatusOr<ZsprData> LoadFromData(const std::vector<uint8_t>& data);
 
  static absl::Status ApplyToRom(Rom& rom, const ZsprData& zspr);
 
  static absl::Status ApplyPaletteToRom(Rom& rom, const ZsprData& zspr);
 
 private:
  static bool ValidateChecksum(const std::vector<uint8_t>& data,
                               uint32_t expected_checksum);
 
  static uint32_t CalculateAdler32(const uint8_t* data, size_t length);
 
  static std::string ReadNullTerminatedString(const uint8_t* data,
                                              size_t max_length,
                                              size_t& bytes_read);
 
  static uint16_t ReadU16LE(const uint8_t* data);
 
  static uint32_t ReadU32LE(const uint8_t* data);
};
 
}  // namespace gfx
}  // namespace yaze
 
#endif  // YAZE_APP_GFX_ZSPR_LOADER_H