use bilge::prelude::*;
use binrw::{BinRead, BinReaderExt, Endian};
use crate::error::{Error, Result};
use crate::graphics::{bgr555_to_rgba, Rgba};
pub const TILE_SIZE: usize = 32;
pub const METATILE_LAYER_COUNT: usize = 8;
pub const PALETTE_COLORS: usize = 16;
pub const PALETTE_COUNT: usize = 16;
#[derive(Debug, Clone, BinRead)]
#[br(little)]
pub struct MapLayout {
pub width: i32,
pub height: i32,
pub border_ptr: u32,
pub map_ptr: u32,
pub primary_tileset_ptr: u32,
pub secondary_tileset_ptr: u32,
}
#[derive(Debug, Clone, BinRead)]
#[br(little)]
pub struct TilesetHeader {
pub is_compressed: u8,
pub is_secondary: u8,
#[br(pad_size_to = 2)]
pub _padding: (),
pub tiles_ptr: u32,
pub palettes_ptr: u32,
pub metatiles_ptr: u32,
pub metatile_attributes_ptr: u32,
pub callback_ptr: u32,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TileData {
bytes: Vec<u8>,
}
impl TileData {
#[must_use]
pub fn from_bytes(bytes: Vec<u8>) -> Self {
let len = (bytes.len() / TILE_SIZE) * TILE_SIZE;
let mut bytes = bytes;
bytes.truncate(len);
Self { bytes }
}
#[must_use]
pub fn tile_count(&self) -> usize {
self.bytes.len() / TILE_SIZE
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.bytes.is_empty()
}
#[must_use]
pub fn tile(&self, index: usize) -> Option<&[u8]> {
let start = index * TILE_SIZE;
let end = start + TILE_SIZE;
self.bytes.get(start..end)
}
#[must_use]
pub fn as_bytes(&self) -> &[u8] {
&self.bytes
}
pub fn iter(&self) -> impl Iterator<Item = &[u8]> {
self.bytes.chunks_exact(TILE_SIZE)
}
}
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct Palette(pub [Rgba; PALETTE_COLORS]);
impl Default for Palette {
fn default() -> Self {
Self([Rgba::TRANSPARENT; PALETTE_COLORS])
}
}
impl Palette {
pub fn from_bgr555(bytes: &[u8]) -> Result<Self> {
if bytes.len() < PALETTE_COLORS * 2 {
return Err(Error::OutOfRange {
offset: 0,
size: bytes.len() as u32,
});
}
let mut colors = [Rgba::TRANSPARENT; PALETTE_COLORS];
for (i, color) in colors.iter_mut().enumerate() {
let lo = u16::from(bytes[i * 2]);
let hi = u16::from(bytes[i * 2 + 1]);
*color = bgr555_to_rgba((hi << 8) | lo);
}
Ok(Self(colors))
}
#[must_use]
pub fn as_array(&self) -> &[Rgba; PALETTE_COLORS] {
&self.0
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct PaletteData {
palettes: Vec<Palette>,
}
impl PaletteData {
pub fn from_bgr555(bytes: &[u8]) -> Result<Self> {
let count = (bytes.len() / (PALETTE_COLORS * 2)).min(PALETTE_COUNT);
let mut palettes = Vec::with_capacity(count);
for i in 0..count {
let start = i * PALETTE_COLORS * 2;
let end = start + PALETTE_COLORS * 2;
palettes.push(Palette::from_bgr555(&bytes[start..end])?);
}
Ok(Self { palettes })
}
#[must_use]
pub fn len(&self) -> usize {
self.palettes.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.palettes.is_empty()
}
#[must_use]
pub fn get(&self, index: usize) -> Option<&Palette> {
self.palettes.get(index)
}
pub fn iter(&self) -> impl Iterator<Item = &Palette> {
self.palettes.iter()
}
}
#[bitsize(16)]
#[derive(FromBits, Copy, Clone, PartialEq, Eq)]
pub struct MetatileLayerBits {
pub tile_index: u10,
pub h_flip: bool,
pub v_flip: bool,
pub palette_index: u4,
}
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct MetatileLayer {
pub tile_index: u16,
pub h_flip: bool,
pub v_flip: bool,
pub palette_index: u8,
}
impl MetatileLayer {
#[must_use]
pub fn from_bits(raw: u16) -> Self {
let bits = MetatileLayerBits::from(raw);
Self {
tile_index: bits.tile_index().value(),
h_flip: bits.h_flip(),
v_flip: bits.v_flip(),
palette_index: bits.palette_index().value(),
}
}
#[must_use]
pub fn to_bits(self) -> u16 {
let bits = MetatileLayerBits::new(
u10::new(self.tile_index),
self.h_flip,
self.v_flip,
u4::new(self.palette_index),
);
u16::from(bits)
}
}
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct Metatile {
pub layers: [MetatileLayer; METATILE_LAYER_COUNT],
}
impl Metatile {
#[must_use]
pub fn from_bytes(bytes: &[u8]) -> Self {
let mut layers = [MetatileLayer {
tile_index: 0,
h_flip: false,
v_flip: false,
palette_index: 0,
}; METATILE_LAYER_COUNT];
for (i, layer) in layers.iter_mut().enumerate() {
let lo = u16::from(bytes.get(i * 2).copied().unwrap_or(0));
let hi = u16::from(bytes.get(i * 2 + 1).copied().unwrap_or(0));
*layer = MetatileLayer::from_bits((hi << 8) | lo);
}
Self { layers }
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MetatileData {
metatiles: Vec<Metatile>,
}
impl MetatileData {
#[must_use]
pub fn from_packed(bytes: &[u8]) -> Self {
let count = bytes.len() / (METATILE_LAYER_COUNT * 2);
let mut metatiles = Vec::with_capacity(count);
for i in 0..count {
let start = i * METATILE_LAYER_COUNT * 2;
let end = start + METATILE_LAYER_COUNT * 2;
metatiles.push(Metatile::from_bytes(&bytes[start..end]));
}
Self { metatiles }
}
#[must_use]
pub fn len(&self) -> usize {
self.metatiles.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.metatiles.is_empty()
}
#[must_use]
pub fn get(&self, index: usize) -> Option<&Metatile> {
self.metatiles.get(index)
}
pub fn iter(&self) -> impl Iterator<Item = &Metatile> {
self.metatiles.iter()
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct Tileset {
pub name: String,
pub is_primary: bool,
pub tile_count: u16,
#[serde(skip)]
pub tiles: TileData,
#[serde(skip)]
pub palettes: PaletteData,
#[serde(skip)]
pub metatiles: MetatileData,
}
pub fn read_struct_at<T>(rom: &crate::Rom, address: u32) -> Result<T>
where
for<'a> T: BinRead<Args<'a> = ()>,
{
let offset = rom.offset_of(address)?;
let mut cursor = std::io::Cursor::new(rom.bytes());
use std::io::Seek;
cursor.seek(std::io::SeekFrom::Start(offset as u64))?;
let endian = Endian::Little;
let value: T = cursor.read_type(endian)?;
Ok(value)
}
pub fn read_ptr_table(rom: &crate::Rom, address: u32, count: usize) -> Result<Vec<u32>> {
let total = count.checked_mul(4).ok_or(Error::OutOfRange {
offset: address,
size: 0,
})?;
let offset = rom.offset_of(address)?;
if offset + total > rom.bytes().len() {
return Err(Error::OutOfRange {
offset: address,
size: rom.bytes().len() as u32,
});
}
let mut out = Vec::with_capacity(count);
for i in 0..count {
let pos = offset + i * 4;
let b = &rom.bytes()[pos..pos + 4];
let v = u32::from_le_bytes([b[0], b[1], b[2], b[3]]);
out.push(v);
}
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn metatile_layer_roundtrip() {
let layer = MetatileLayer {
tile_index: 0x123,
h_flip: true,
v_flip: false,
palette_index: 7,
};
let raw = layer.to_bits();
let decoded = MetatileLayer::from_bits(raw);
assert_eq!(decoded, layer);
}
#[test]
fn metatile_layer_bit_layout() {
let bits = MetatileLayer::from_bits(0x4B12);
assert_eq!(bits.tile_index, 0x312);
assert!(!bits.h_flip);
assert!(bits.v_flip);
assert_eq!(bits.palette_index, 4);
}
#[test]
fn metatile_from_bytes() {
let bytes = [0u8; 16];
let m = Metatile::from_bytes(&bytes);
assert_eq!(m.layers.len(), 8);
}
#[test]
fn palette_from_bgr555_pure_red() {
let mut buf = vec![0u8; 32];
buf[0] = 0x1F;
buf[1] = 0x00;
let palette = Palette::from_bgr555(&buf).unwrap();
assert_eq!(palette.0[0], Rgba(248, 0, 0, 255));
}
#[test]
fn palette_data_from_bgr555_16_palettes() {
let bytes = vec![0u8; 16 * 16 * 2];
let data = PaletteData::from_bgr555(&bytes).unwrap();
assert_eq!(data.len(), 16);
}
#[test]
fn tile_data_round_trip() {
let bytes: Vec<u8> = (0..64).collect();
let data = TileData::from_bytes(bytes);
assert_eq!(data.tile_count(), 2);
assert_eq!(data.tile(0).unwrap().len(), 32);
}
#[test]
fn tile_data_drops_partial_tile() {
let bytes: Vec<u8> = (0..40).collect();
let data = TileData::from_bytes(bytes);
assert_eq!(data.tile_count(), 1);
}
}