use std::path::Path;
use crate::error::{Error, Result};
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct Rgba(pub u8, pub u8, pub u8, pub u8);
impl Rgba {
pub const TRANSPARENT: Self = Self(0, 0, 0, 0);
pub const BLACK: Self = Self(0, 0, 0, 255);
pub const WHITE: Self = Self(255, 255, 255, 255);
}
#[must_use]
pub const fn bgr555_to_rgba(c: u16) -> Rgba {
let r5 = c & 0x1F;
let g5 = (c >> 5) & 0x1F;
let b5 = (c >> 10) & 0x1F;
Rgba(expand_5_to_8(r5), expand_5_to_8(g5), expand_5_to_8(b5), 255)
}
const fn expand_5_to_8(v: u16) -> u8 {
((v << 3) | (v >> 2)) as u8
}
#[must_use]
pub fn decode_tile_4bpp(data: &[u8]) -> [u8; 64] {
let mut out = [0u8; 64];
for (i, byte) in data.iter().take(32).enumerate() {
out[i * 2] = byte & 0x0F;
out[i * 2 + 1] = byte >> 4;
}
out
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RgbaImage {
width: u32,
height: u32,
pixels: Vec<u8>,
}
impl RgbaImage {
#[must_use]
pub fn new(width: u32, height: u32) -> Self {
Self {
width,
height,
pixels: vec![0; width as usize * height as usize * 4],
}
}
pub fn from_rgba(width: u32, height: u32, pixels: Vec<u8>) -> Result<Self> {
let expected = width as usize * height as usize * 4;
if pixels.len() != expected {
return Err(Error::Io {
path: std::path::PathBuf::from("<rgba buffer>"),
source: std::io::Error::new(
std::io::ErrorKind::InvalidData,
format!(
"pixel buffer length {} does not match width*height*4 = {expected}",
pixels.len()
),
),
});
}
Ok(Self {
width,
height,
pixels,
})
}
#[must_use]
pub const fn width(&self) -> u32 {
self.width
}
#[must_use]
pub const fn height(&self) -> u32 {
self.height
}
#[must_use]
pub fn as_bytes(&self) -> &[u8] {
&self.pixels
}
#[must_use]
pub fn pixel(&self, x: u32, y: u32) -> Option<Rgba> {
if x >= self.width || y >= self.height {
return None;
}
let idx = ((y * self.width + x) * 4) as usize;
Some(Rgba(
self.pixels[idx],
self.pixels[idx + 1],
self.pixels[idx + 2],
self.pixels[idx + 3],
))
}
pub fn set_pixel(&mut self, x: u32, y: u32, px: Rgba) {
if x >= self.width || y >= self.height {
return;
}
let idx = ((y * self.width + x) * 4) as usize;
self.pixels[idx] = px.0;
self.pixels[idx + 1] = px.1;
self.pixels[idx + 2] = px.2;
self.pixels[idx + 3] = px.3;
}
pub fn blit(&mut self, src: &RgbaImage, dst: (u32, u32)) {
blit_inner(self, src, dst, false);
}
pub fn alpha_blit(&mut self, src: &RgbaImage, dst: (u32, u32)) {
blit_inner(self, src, dst, true);
}
pub fn write_png(&self, writer: impl std::io::Write) -> Result<()> {
let mut encoder = png::Encoder::new(writer, self.width, self.height);
encoder.set_color(png::ColorType::Rgba);
encoder.set_depth(png::BitDepth::Eight);
use png::FilterType;
encoder.set_filter(FilterType::NoFilter);
let mut png_writer = encoder.write_header()?;
png_writer.write_image_data(&self.pixels)?;
png_writer.finish()?;
Ok(())
}
pub fn save_png(&self, path: impl AsRef<Path>) -> Result<()> {
let path = path.as_ref();
let file = std::fs::File::create(path).map_err(|source| Error::Io {
path: path.to_path_buf(),
source,
})?;
self.write_png(file)
}
}
fn blit_inner(dst: &mut RgbaImage, src: &RgbaImage, (dest_x, dest_y): (u32, u32), alpha: bool) {
let sw = src.width;
let sh = src.height;
for sy in 0..sh {
let abs_y = dest_y + sy;
if abs_y >= dst.height {
break;
}
for sx in 0..sw {
let abs_x = dest_x + sx;
if abs_x >= dst.width {
break;
}
let s_idx = ((sy * sw + sx) * 4) as usize;
let d_idx = ((abs_y * dst.width + abs_x) * 4) as usize;
if alpha {
let sa = u32::from(src.pixels[s_idx + 3]);
if sa == 0 {
continue;
}
if sa == 255 {
dst.pixels[d_idx..d_idx + 4].copy_from_slice(&src.pixels[s_idx..s_idx + 4]);
} else {
let da = u32::from(dst.pixels[d_idx + 3]);
let inv = 255 - sa;
let sr = u32::from(src.pixels[s_idx]);
let sg = u32::from(src.pixels[s_idx + 1]);
let sb = u32::from(src.pixels[s_idx + 2]);
let dr = u32::from(dst.pixels[d_idx]);
let dg = u32::from(dst.pixels[d_idx + 1]);
let db = u32::from(dst.pixels[d_idx + 2]);
let out_a = sa + da * inv / 255;
let denom = out_a.max(1);
dst.pixels[d_idx] = ((sr * sa + dr * da * inv / 255) / denom) as u8;
dst.pixels[d_idx + 1] = ((sg * sa + dg * da * inv / 255) / denom) as u8;
dst.pixels[d_idx + 2] = ((sb * sa + db * da * inv / 255) / denom) as u8;
dst.pixels[d_idx + 3] = out_a as u8;
}
} else {
dst.pixels[d_idx..d_idx + 4].copy_from_slice(&src.pixels[s_idx..s_idx + 4]);
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn bgr555_black_is_rgba_black() {
assert_eq!(bgr555_to_rgba(0x0000), Rgba::BLACK);
}
#[test]
fn bgr555_white_is_rgba_white() {
assert_eq!(bgr555_to_rgba(0x7FFF), Rgba(255, 255, 255, 255));
}
#[test]
fn bgr555_pure_red() {
assert_eq!(bgr555_to_rgba(0x001F), Rgba(255, 0, 0, 255));
}
#[test]
fn bgr555_pure_green() {
assert_eq!(bgr555_to_rgba(0x03E0), Rgba(0, 255, 0, 255));
}
#[test]
fn bgr555_pure_blue() {
assert_eq!(bgr555_to_rgba(0x7C00), Rgba(0, 0, 255, 255));
}
#[test]
fn decode_tile_4bpp_byte_order() {
let data = [0x12u8; 32];
let decoded = decode_tile_4bpp(&data);
assert_eq!(decoded[0], 2);
assert_eq!(decoded[1], 1);
assert_eq!(decoded[2], 2);
assert_eq!(decoded[3], 1);
assert_eq!(decoded.len(), 64);
}
#[test]
fn rgba_image_new_is_zero_size() {
let img = RgbaImage::new(2, 2);
assert_eq!(img.width(), 2);
assert_eq!(img.height(), 2);
assert_eq!(img.as_bytes().len(), 16);
assert_eq!(img.pixel(0, 0), Some(Rgba::TRANSPARENT));
}
#[test]
fn rgba_image_set_and_get_pixel() {
let mut img = RgbaImage::new(4, 4);
img.set_pixel(2, 3, Rgba(10, 20, 30, 40));
assert_eq!(img.pixel(2, 3), Some(Rgba(10, 20, 30, 40)));
assert_eq!(img.pixel(0, 0), Some(Rgba::TRANSPARENT));
}
#[test]
fn rgba_image_pixel_out_of_bounds() {
let img = RgbaImage::new(2, 2);
assert_eq!(img.pixel(2, 0), None);
assert_eq!(img.pixel(0, 2), None);
}
#[test]
fn rgba_image_blit_replaces() {
let mut dst = RgbaImage::new(4, 4);
let mut src = RgbaImage::new(2, 2);
src.set_pixel(0, 0, Rgba::WHITE);
src.set_pixel(1, 1, Rgba::BLACK);
dst.blit(&src, (1, 1));
assert_eq!(dst.pixel(1, 1), Some(Rgba::WHITE));
assert_eq!(dst.pixel(2, 2), Some(Rgba::BLACK));
assert_eq!(dst.pixel(0, 0), Some(Rgba::TRANSPARENT));
}
#[test]
fn rgba_image_alpha_blit_skips_zero_alpha() {
let mut dst = RgbaImage::new(2, 2);
dst.set_pixel(0, 0, Rgba::WHITE);
let mut src = RgbaImage::new(1, 1);
src.set_pixel(0, 0, Rgba::TRANSPARENT);
dst.alpha_blit(&src, (0, 0));
assert_eq!(dst.pixel(0, 0), Some(Rgba::WHITE));
}
#[test]
fn rgba_image_alpha_blit_blends_opaque() {
let mut dst = RgbaImage::new(2, 2);
dst.set_pixel(0, 0, Rgba(50, 60, 70, 200));
let mut src = RgbaImage::new(1, 1);
src.set_pixel(0, 0, Rgba(200, 100, 50, 100));
dst.alpha_blit(&src, (0, 0));
let px = dst.pixel(0, 0).unwrap();
assert_ne!(px, Rgba(50, 60, 70, 200));
}
}