156 lines
5.2 KiB
Rust
156 lines
5.2 KiB
Rust
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<u8>,
|
|
/// 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<Color> {
|
|
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);
|
|
}
|
|
}
|