380 lines
12 KiB
Rust
380 lines
12 KiB
Rust
//! Palette-indexed rendering. Filters copy colors, never blend palette entries.
|
|
use crate::assets::{Sprite, TRANSPARENT};
|
|
use anyhow::{Result, ensure};
|
|
use sha2::{Digest, Sha256};
|
|
use std::{collections::BTreeMap, fs, path::PathBuf};
|
|
|
|
pub fn upscale(sprite: &Sprite, factor: usize) -> Result<Sprite> {
|
|
ensure!(
|
|
matches!(factor, 1 | 2 | 3 | 4),
|
|
"scale must be 1, 2, 3 or 4"
|
|
);
|
|
ensure!(
|
|
sprite.width > 0
|
|
&& sprite.height > 0
|
|
&& sprite.pixels.len() == sprite.width * sprite.height,
|
|
"invalid indexed image"
|
|
);
|
|
ensure!(
|
|
sprite.width as u64 * sprite.height as u64 * (factor * factor) as u64 <= 16_777_216,
|
|
"derived image exceeds pixel limit"
|
|
);
|
|
if factor == 1 {
|
|
return Ok(sprite.clone());
|
|
}
|
|
if factor == 4 {
|
|
return upscale(&upscale(sprite, 2)?, 2);
|
|
}
|
|
let mut out = Sprite::blank(sprite.width * factor, sprite.height * factor);
|
|
for y in 0..sprite.height {
|
|
for x in 0..sprite.width {
|
|
let sample = |dx: isize, dy: isize| {
|
|
sprite.pixels[(y as isize + dy).clamp(0, sprite.height as isize - 1) as usize
|
|
* sprite.width
|
|
+ (x as isize + dx).clamp(0, sprite.width as isize - 1) as usize]
|
|
};
|
|
let [a, b, c, d, e, f, g, h, i] = [
|
|
sample(-1, -1),
|
|
sample(0, -1),
|
|
sample(1, -1),
|
|
sample(-1, 0),
|
|
sample(0, 0),
|
|
sample(1, 0),
|
|
sample(-1, 1),
|
|
sample(0, 1),
|
|
sample(1, 1),
|
|
];
|
|
let p = if factor == 2 {
|
|
if b != h && d != f {
|
|
[
|
|
if d == b { d } else { e },
|
|
if b == f { f } else { e },
|
|
if d == h { d } else { e },
|
|
if h == f { f } else { e },
|
|
e,
|
|
e,
|
|
e,
|
|
e,
|
|
e,
|
|
]
|
|
} else {
|
|
[e; 9]
|
|
}
|
|
} else if b != h && d != f {
|
|
[
|
|
if d == b { d } else { e },
|
|
if (d == b && e != c) || (b == f && e != a) {
|
|
b
|
|
} else {
|
|
e
|
|
},
|
|
if b == f { f } else { e },
|
|
if (d == b && e != g) || (d == h && e != a) {
|
|
d
|
|
} else {
|
|
e
|
|
},
|
|
e,
|
|
if (b == f && e != i) || (h == f && e != c) {
|
|
f
|
|
} else {
|
|
e
|
|
},
|
|
if d == h { d } else { e },
|
|
if (d == h && e != i) || (h == f && e != g) {
|
|
h
|
|
} else {
|
|
e
|
|
},
|
|
if h == f { f } else { e },
|
|
]
|
|
} else {
|
|
[e; 9]
|
|
};
|
|
for dy in 0..factor {
|
|
for dx in 0..factor {
|
|
out.pixels[(y * factor + dy) * out.width + x * factor + dx] =
|
|
p[dy * factor + dx];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Ok(out)
|
|
}
|
|
pub fn nearest(sprite: &Sprite, factor: usize) -> Sprite {
|
|
let mut out = Sprite::blank(sprite.width * factor, sprite.height * factor);
|
|
for y in 0..out.height {
|
|
for x in 0..out.width {
|
|
out.pixels[y * out.width + x] = sprite.pixels[(y / factor) * sprite.width + x / factor];
|
|
}
|
|
}
|
|
out
|
|
}
|
|
pub struct SpriteCache {
|
|
memory: BTreeMap<String, Sprite>,
|
|
root: Option<PathBuf>,
|
|
}
|
|
impl SpriteCache {
|
|
pub fn new(root: Option<PathBuf>) -> Self {
|
|
Self {
|
|
memory: BTreeMap::new(),
|
|
root,
|
|
}
|
|
}
|
|
pub fn get(&mut self, sprite: &Sprite, factor: usize, pixelated: bool) -> Result<&Sprite> {
|
|
let mut hash = Sha256::new();
|
|
hash.update(b"raptor-scale-v1");
|
|
hash.update(sprite.width.to_le_bytes());
|
|
hash.update(sprite.height.to_le_bytes());
|
|
hash.update([factor as u8, pixelated as u8]);
|
|
for p in &sprite.pixels {
|
|
hash.update(p.to_le_bytes());
|
|
}
|
|
let key = format!("{:x}", hash.finalize());
|
|
if !self.memory.contains_key(&key) {
|
|
let saved = self
|
|
.root
|
|
.as_ref()
|
|
.and_then(|r| fs::read(r.join(format!("{key}.json"))).ok())
|
|
.and_then(|b| serde_json::from_slice::<Sprite>(&b).ok())
|
|
.filter(|s| {
|
|
s.width == sprite.width * factor
|
|
&& s.height == sprite.height * factor
|
|
&& s.pixels.len() == s.width * s.height
|
|
&& s.pixels.iter().all(|p| *p <= TRANSPARENT)
|
|
});
|
|
let scaled = if let Some(s) = saved {
|
|
s
|
|
} else if pixelated {
|
|
nearest(sprite, factor)
|
|
} else {
|
|
upscale(sprite, factor)?
|
|
};
|
|
if let Some(root) = &self.root {
|
|
fs::create_dir_all(root)?;
|
|
if !root.join(format!("{key}.json")).exists() {
|
|
crate::persistence::atomic_write(
|
|
&root.join(format!("{key}.json")),
|
|
&serde_json::to_vec(&scaled)?,
|
|
)?;
|
|
}
|
|
}
|
|
if self
|
|
.memory
|
|
.values()
|
|
.map(|s| s.pixels.len() * 2)
|
|
.sum::<usize>()
|
|
+ scaled.pixels.len() * 2
|
|
> 128 * 1024 * 1024
|
|
{
|
|
self.memory.clear();
|
|
}
|
|
self.memory.insert(key.clone(), scaled);
|
|
}
|
|
Ok(&self.memory[&key])
|
|
}
|
|
}
|
|
pub struct Canvas {
|
|
pub image: Sprite,
|
|
pub scale: usize,
|
|
}
|
|
impl Canvas {
|
|
pub fn new(scale: usize) -> Self {
|
|
Self {
|
|
image: Sprite {
|
|
width: 320 * scale,
|
|
height: 200 * scale,
|
|
pixels: vec![0; 320 * 200 * scale * scale],
|
|
},
|
|
scale,
|
|
}
|
|
}
|
|
pub fn clear(&mut self, color: u16) {
|
|
self.image.pixels.fill(color)
|
|
}
|
|
pub fn blit(&mut self, sprite: &Sprite, x: i32, y: i32) {
|
|
for sy in 0..sprite.height {
|
|
let yy = y + sy as i32;
|
|
if yy < 0 || yy >= self.image.height as i32 {
|
|
continue;
|
|
}
|
|
for sx in 0..sprite.width {
|
|
let xx = x + sx as i32;
|
|
if xx < 0 || xx >= self.image.width as i32 {
|
|
continue;
|
|
}
|
|
let c = sprite.pixels[sy * sprite.width + sx];
|
|
if c != TRANSPARENT {
|
|
self.image.pixels[yy as usize * self.image.width + xx as usize] = c;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
pub fn rect(&mut self, x: i32, y: i32, w: i32, h: i32, color: u16) {
|
|
let s = self.scale as i32;
|
|
for yy in (y * s).max(0)..((y + h) * s).min(self.image.height as i32) {
|
|
for xx in (x * s).max(0)..((x + w) * s).min(self.image.width as i32) {
|
|
self.image.pixels[yy as usize * self.image.width + xx as usize] = color;
|
|
}
|
|
}
|
|
}
|
|
pub fn shade(&mut self, mask: &Sprite, x: i32, y: i32, table: &[u8; 256]) {
|
|
for sy in 0..mask.height {
|
|
let yy = y + sy as i32;
|
|
if yy < 0 || yy >= self.image.height as i32 {
|
|
continue;
|
|
}
|
|
for sx in 0..mask.width {
|
|
let xx = x + sx as i32;
|
|
if xx < 0
|
|
|| xx >= self.image.width as i32
|
|
|| mask.pixels[sy * mask.width + sx] == TRANSPARENT
|
|
{
|
|
continue;
|
|
}
|
|
let p = &mut self.image.pixels[yy as usize * self.image.width + xx as usize];
|
|
if *p < 256 {
|
|
*p = table[*p as usize] as u16;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
pub fn rgba(&self, palette: &[[u8; 3]; 256], scanlines: bool) -> Vec<u8> {
|
|
let mut out = vec![0; self.image.pixels.len() * 4];
|
|
for (i, p) in self.image.pixels.iter().enumerate() {
|
|
let color = palette[(*p).min(255) as usize];
|
|
let dark = scanlines && (i / self.image.width) % (self.scale * 3) == self.scale * 2;
|
|
for j in 0..3 {
|
|
out[i * 4 + j] = if dark { color[j] / 2 } else { color[j] };
|
|
}
|
|
out[i * 4 + 3] = 255;
|
|
}
|
|
out
|
|
}
|
|
}
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
#[test]
|
|
fn uniform_image_unchanged() {
|
|
let s = Sprite {
|
|
width: 2,
|
|
height: 2,
|
|
pixels: vec![9; 4],
|
|
};
|
|
for n in [2, 3, 4] {
|
|
assert!(upscale(&s, n).unwrap().pixels.iter().all(|p| *p == 9));
|
|
}
|
|
}
|
|
#[test]
|
|
fn scale_four_is_two_passes() {
|
|
let s = Sprite {
|
|
width: 3,
|
|
height: 3,
|
|
pixels: vec![0, 1, 0, 1, 1, 0, 0, 0, TRANSPARENT],
|
|
};
|
|
assert_eq!(
|
|
upscale(&s, 4).unwrap(),
|
|
upscale(&upscale(&s, 2).unwrap(), 2).unwrap()
|
|
);
|
|
}
|
|
#[test]
|
|
fn scale_three_guard_preserves_cross() {
|
|
let s = Sprite {
|
|
width: 3,
|
|
height: 3,
|
|
pixels: vec![1, 2, 3, 4, 5, 4, 6, 2, 7],
|
|
};
|
|
let out = upscale(&s, 3).unwrap();
|
|
for y in 3..6 {
|
|
for x in 3..6 {
|
|
assert_eq!(out.pixels[y * 9 + x], 5)
|
|
}
|
|
}
|
|
}
|
|
#[test]
|
|
fn clipped_transparency() {
|
|
let mut c = Canvas::new(1);
|
|
c.clear(3);
|
|
c.blit(
|
|
&Sprite {
|
|
width: 2,
|
|
height: 1,
|
|
pixels: vec![8, TRANSPARENT],
|
|
},
|
|
-1,
|
|
0,
|
|
);
|
|
assert_eq!(c.image.pixels[0], 3);
|
|
}
|
|
}
|
|
|
|
pub struct BitmapFont {
|
|
height: usize,
|
|
glyphs: Vec<Option<Sprite>>,
|
|
widths: Vec<usize>,
|
|
}
|
|
impl BitmapFont {
|
|
pub fn decode(bytes: &[u8]) -> Result<Self> {
|
|
let height = crate::assets::i32_at(bytes, 0)?;
|
|
ensure!(
|
|
(1..=64).contains(&height) && bytes.len() >= 772,
|
|
"invalid bitmap font"
|
|
);
|
|
let mut glyphs = Vec::new();
|
|
let mut widths = Vec::new();
|
|
for ch in 0..256 {
|
|
let offset = crate::assets::i16_at(bytes, 4 + ch * 2)?;
|
|
let width = bytes[516 + ch] as usize;
|
|
widths.push(width);
|
|
if offset < 0 || width == 0 {
|
|
glyphs.push(None);
|
|
continue;
|
|
}
|
|
let start = 772 + offset as usize;
|
|
let len = width * height as usize;
|
|
let data = bytes
|
|
.get(start..start + len)
|
|
.ok_or_else(|| anyhow::anyhow!("truncated font glyph {ch}"))?;
|
|
glyphs.push(Some(Sprite {
|
|
width,
|
|
height: height as usize,
|
|
pixels: data
|
|
.iter()
|
|
.map(|v| if *v == 0 { TRANSPARENT } else { *v as u16 })
|
|
.collect(),
|
|
}));
|
|
}
|
|
Ok(Self {
|
|
height: height as usize,
|
|
glyphs,
|
|
widths,
|
|
})
|
|
}
|
|
pub fn text(&self, canvas: &mut Canvas, x: i32, y: i32, text: &str, color: u16) {
|
|
let mut cursor = x;
|
|
for ch in text.bytes() {
|
|
if let Some(g) = &self.glyphs[ch as usize] {
|
|
let mut glyph = g.clone();
|
|
for p in &mut glyph.pixels {
|
|
if *p != TRANSPARENT {
|
|
*p = (*p + color.saturating_sub(1)).min(255);
|
|
}
|
|
}
|
|
canvas.blit(
|
|
&nearest(&glyph, canvas.scale),
|
|
cursor * canvas.scale as i32,
|
|
y * canvas.scale as i32,
|
|
);
|
|
}
|
|
cursor += self.widths[ch as usize] as i32 + 1;
|
|
if cursor > 314 {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
pub fn height(&self) -> usize {
|
|
self.height
|
|
}
|
|
}
|