use crate::color::Color; use serde::{Deserialize, Serialize}; pub const GLYPH_BANK_MAX_PALETTE_COUNT_V1: usize = 64; pub const GLYPH_BANK_COLORS_PER_PALETTE: usize = 16; /// Standard sizes for square tiles. #[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize, Serialize)] pub enum TileSize { /// 8x8 pixels. Size8 = 8, /// 16x16 pixels. Size16 = 16, /// 32x32 pixels. Size32 = 32, } /// A container for graphical assets. /// /// A GlyphBank stores the decoded runtime representation of a glyph-bank asset. /// /// Serialized `assets.pa` payloads keep pixel indices packed as `4bpp` nibbles. /// After decode, the runtime expands them to one `u8` palette index per pixel /// while preserving the same `0..15` logical range. pub struct GlyphBank { /// Dimension of each individual tile in the bank. pub tile_size: TileSize, /// Width of the full bank sheet in pixels. pub width: usize, /// Height of the full bank sheet in pixels. pub height: usize, /// Decoded pixel data stored as one palette index per pixel. /// Serialized payloads are packed; runtime memory is expanded. /// Palette indices are ordinary indices; transparency is resolved through /// the RGBA alpha channel of the palette entry. pub pixel_indices: Vec, /// Runtime-facing v1 palette table. /// /// Palette identity is the direct index in this vector. A resident glyph /// bank carries exactly the palettes materialized from its payload. pub palettes: Vec<[Color; GLYPH_BANK_COLORS_PER_PALETTE]>, } impl GlyphBank { /// Creates an empty glyph bank with one palette. pub fn new(tile_size: TileSize, width: usize, height: usize) -> Self { Self::with_palette_count(tile_size, width, height, 1) } /// Creates an empty glyph bank with the specified resident palette count. pub fn with_palette_count( tile_size: TileSize, width: usize, height: usize, palette_count: usize, ) -> Self { assert!( (1..=GLYPH_BANK_MAX_PALETTE_COUNT_V1).contains(&palette_count), "glyph bank palette_count must be in 1..={}", GLYPH_BANK_MAX_PALETTE_COUNT_V1 ); Self { tile_size, width, height, pixel_indices: vec![0; width * height], palettes: vec![[Color::BLACK; GLYPH_BANK_COLORS_PER_PALETTE]; palette_count], } } /// Returns the number of resident palettes. pub fn palette_count(&self) -> usize { self.palettes.len() } /// Returns true when the palette id is valid for this resident bank. pub fn contains_palette(&self, palette_id: u8) -> bool { (palette_id as usize) < self.palette_count() } /// Returns a mutable palette slot when the palette exists. pub fn palette_mut( &mut self, palette_id: u8, ) -> Option<&mut [Color; GLYPH_BANK_COLORS_PER_PALETTE]> { self.palettes.get_mut(palette_id as usize) } /// Resolves a global tile ID and local pixel coordinates to a palette index. /// tile_id: the tile index in the bank /// local_x, local_y: the pixel position inside the tile (0 to tile_size-1) pub fn get_pixel_index(&self, tile_id: u16, local_x: usize, local_y: usize) -> u8 { let size = self.tile_size as usize; let tiles_per_row = self.width / size; let tile_x = (tile_id as usize % tiles_per_row) * size; let tile_y = (tile_id as usize / tiles_per_row) * size; let pixel_x = tile_x + local_x; let pixel_y = tile_y + local_y; if pixel_x < self.width && pixel_y < self.height { self.pixel_indices[pixel_y * self.width + pixel_x] } else { 0 } } /// Maps a 4-bit index to a real RGBA8888 Color using the specified palette. pub fn resolve_color(&self, palette_id: u8, pixel_index: u8) -> Option { self.palettes .get(palette_id as usize) .and_then(|palette| palette.get(pixel_index as usize)) .copied() } } #[cfg(test)] mod tests { use super::*; #[test] fn new_glyph_bank_uses_single_resident_palette() { let bank = GlyphBank::new(TileSize::Size8, 8, 8); assert_eq!(bank.palette_count(), 1); assert!(bank.contains_palette(0)); assert!(!bank.contains_palette(1)); } #[test] fn glyph_bank_can_materialize_v1_max_palette_count() { let bank = GlyphBank::with_palette_count(TileSize::Size8, 8, 8, GLYPH_BANK_MAX_PALETTE_COUNT_V1); assert_eq!(bank.palette_count(), GLYPH_BANK_MAX_PALETTE_COUNT_V1); assert!(bank.contains_palette((GLYPH_BANK_MAX_PALETTE_COUNT_V1 - 1) as u8)); } #[test] fn invalid_palette_lookup_is_distinct_from_transparent_color() { let mut bank = GlyphBank::new(TileSize::Size8, 8, 8); bank.palette_mut(0).unwrap()[1] = Color::TRANSPARENT; assert_eq!(bank.resolve_color(0, 1), Some(Color::TRANSPARENT)); assert_eq!(bank.resolve_color(1, 1), None); } #[test] #[should_panic(expected = "glyph bank palette_count must be in 1..=64")] fn glyph_bank_rejects_zero_resident_palettes() { let _ = GlyphBank::with_palette_count(TileSize::Size8, 8, 8, 0); } }