//! Load Texture (Effect › Distort › Glass): a surface made from an image the user loads. //! //! The effect keeps the image's gray levels in its parameters ([`TEXTURE_IMAGE`]: a grayscale PNG, //! base64), so the document saves the texture with the effect, and copies of the effect carry it. //! Each pixel's gray is the surface's height there: white stands [`RELIEF`] above black. The image //! lies one pixel per point at 100 %, centered on the object's center and repeated in both //! directions. use std::sync::atomic::{AtomicUsize, Ordering}; use std::sync::{Arc, Mutex, PoisonError}; use vectorcraft_geom::Point; use super::texture::luma; /// The effect parameter that holds a loaded texture: its gray levels as a grayscale PNG, base64. pub const TEXTURE_IMAGE: &str = "textureImage"; /// The Texture menu's value for the loaded texture. pub const LOADED: &str = "loaded"; /// How far (points) a loaded texture's white stands above its black: a black pixel beside a white /// one gives a slope of about 1, the most the built-in surfaces have. const RELIEF: f64 = 1.0; /// How many decoded textures [`texture`] keeps. const KEEP: usize = 4; /// Most bytes of gray levels the loaded textures alive at once may hold, wherever they are kept /// (the effects of every drawing hold theirs): a texture that would pass it isn't decoded. Each /// one is decoded within [`vectorcraft_doc::MAX_RASTER_ALLOC`], but a document's many Glass /// effects each kept their own. const MAX_LIVE: usize = 512 << 20; /// Bytes of gray levels the [`LoadedTexture`]s alive hold ([`MAX_LIVE`]). static LIVE: AtomicUsize = AtomicUsize::new(0); /// A loaded texture: `width` × `height` gray levels, row by row from the top. #[derive(Debug, PartialEq, Eq)] pub struct LoadedTexture { width: u32, height: u32, gray: Vec, } impl Drop for LoadedTexture { fn drop(&mut self) { LIVE.fetch_sub(self.gray.len(), Ordering::Relaxed); } } impl LoadedTexture { /// A texture of `gray`, counted in [`LIVE`]. fn new(width: u32, height: u32, gray: Vec) -> Self { LIVE.fetch_add(gray.len(), Ordering::Relaxed); Self { width, height, gray } } /// The texture of `width` × `height` straight (not premultiplied) RGBA pixels: each pixel's /// luma over middle gray, as much as its alpha covers it (a transparent pixel is middle gray). /// `None` when the image is empty or `rgba` doesn't hold exactly that many pixels. pub fn from_rgba(width: u32, height: u32, rgba: &[u8]) -> Option { let n = (width as usize).checked_mul(height as usize).filter(|n| *n > 0)?; let (px, rest) = rgba.as_chunks::<4>(); if px.len() != n || !rest.is_empty() { return None; } let gray = px .iter() .map(|p| { let a = f32::from(p[3]) / 255.0; let l = luma([p[0], p[1], p[2]].map(|v| f32::from(v) / 255.0)); ((a * l + (1.0 - a) * 0.5) * 255.0).round().clamp(0.0, 255.0) as u8 }) .collect(); Some(Self::new(width, height, gray)) } /// The size in pixels. pub fn size(&self) -> (u32, u32) { (self.width, self.height) } /// Its [`TEXTURE_IMAGE`] value: the gray levels as a grayscale PNG, base64; `None` when the /// PNG can't be written. pub fn to_stored(&self) -> Option { let img = craft_image_codecs::Image::from_raw( self.width, self.height, craft_image_codecs::ChannelLayout::Gray, craft_image_codecs::SampleType::U8, self.gray.clone(), ) .ok()?; let png = craft_image_codecs::encode(&img, craft_image_codecs::Format::Png, &craft_image_codecs::EncodeOptions::default()).ok()?; Some(base64_encode(&png)) } /// The texture of a PNG's gray levels, decoded within [`vectorcraft_doc::MAX_RASTER_ALLOC`]; /// `None` when `png` isn't a PNG or holds no pixels. /// `None` too when its gray levels would take the live textures past [`MAX_LIVE`]. fn from_png(png: &[u8]) -> Option { let (w, h) = Self::png_ihdr_size(png)?; let gray = (w as usize).checked_mul(h as usize)?; if LIVE.load(Ordering::Relaxed).saturating_add(gray) > MAX_LIVE { return None; } let mut opts = craft_image_codecs::DecodeOptions::default(); opts.limits.max_alloc = vectorcraft_doc::MAX_RASTER_ALLOC; // The codec default caps each side at 2^18; a stored texture can be longer than that and // still fit the live and allocation budgets. opts.limits.max_width = u32::MAX; opts.limits.max_height = u32::MAX; let img = craft_image_codecs::decode_as_with(craft_image_codecs::Format::Png, png, &opts).ok()?; let (width, height) = img.dimensions(); if width == 0 || height == 0 { return None; } use craft_image_codecs::{ChannelLayout as L, SampleType as S}; let luma = match (img.layout(), img.sample_type()) { (L::Gray, S::U8) => img.into_data(), _ => image::RgbaImage::from_raw(width, height, img.to_rgba8()).map(image::DynamicImage::ImageRgba8)?.into_luma8().into_raw(), }; Some(Self::new(width, height, luma)) } /// Read `(width, height)` from a PNG's IHDR chunk without decoding pixels. fn png_ihdr_size(png: &[u8]) -> Option<(u32, u32)> { if png.len() < 24 || &png[..8] != b"\x89PNG\r\n\x1a\n" || &png[12..16] != b"IHDR" { return None; } let w = u32::from_be_bytes(png[16..20].try_into().ok()?); let h = u32::from_be_bytes(png[20..24].try_into().ok()?); Some((w, h)) } /// The surface's height (points) at `p` (points at 100 %, from the object's center): the gray /// levels around it interpolated, 0 for black and [`RELIEF`] for white. pub(super) fn height(&self, p: Point) -> f64 { let (w, h) = (f64::from(self.width), f64::from(self.height)); // Pixel centers lie at whole coordinates, and the image's center lies at the origin. let (x, y) = (p.x + 0.5 * w - 0.5, p.y + 0.5 * h - 0.5); let (x0, y0) = (x.floor(), y.floor()); let (fx, fy) = (x - x0, y - y0); let at = |i: f64, j: f64| { let (i, j) = (i.rem_euclid(w) as usize, j.rem_euclid(h) as usize); self.gray.get(j * self.width as usize + i).map_or(0.5, |g| f64::from(*g) / 255.0) }; let top = at(x0, y0) + (at(x0 + 1.0, y0) - at(x0, y0)) * fx; let bottom = at(x0, y0 + 1.0) + (at(x0 + 1.0, y0 + 1.0) - at(x0, y0 + 1.0)) * fx; RELIEF * (top + (bottom - top) * fy) } } /// The textures [`texture`] decoded last, with their PNG, the newest last. static DECODED: Mutex, Arc)>> = Mutex::new(Vec::new()); /// The texture a [`TEXTURE_IMAGE`] value holds; `None` when it isn't base64 of a PNG. The last /// [`KEEP`] textures decoded are kept for the next call, found by their PNG: values that differ /// only in how the base64 is spaced share one. pub fn texture(stored: &str) -> Option> { let png = base64_decode(stored)?; let mut decoded = DECODED.lock().unwrap_or_else(PoisonError::into_inner); if let Some(i) = decoded.iter().position(|(p, _)| *p == png) { let entry = decoded.remove(i); let t = entry.1.clone(); decoded.push(entry); return Some(t); } let t = Arc::new(LoadedTexture::from_png(&png)?); if decoded.len() >= KEEP { decoded.remove(0); } decoded.push((png, t.clone())); Some(t) } const B64: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; /// Standard base64 (RFC 4648, with padding), written as `vectorcraft_format::base64_encode` /// writes it. fn base64_encode(data: &[u8]) -> String { let mut out = String::with_capacity(data.len().div_ceil(3) * 4); for c in data.chunks(3) { let n = (c[0] as u32) << 16 | (*c.get(1).unwrap_or(&0) as u32) << 8 | *c.get(2).unwrap_or(&0) as u32; out.push(B64[(n >> 18) as usize & 63] as char); out.push(B64[(n >> 12) as usize & 63] as char); out.push(if c.len() > 1 { B64[(n >> 6) as usize & 63] as char } else { '=' }); out.push(if c.len() > 2 { B64[n as usize & 63] as char } else { '=' }); } out } /// Standard base64 (RFC 4648, with padding; whitespace skipped), read as /// `vectorcraft_format::base64_decode` reads it; `None` when it isn't base64. fn base64_decode(s: &str) -> Option> { let val = |c: u8| B64.iter().position(|&b| b == c).map(|p| p as u32); let clean: Vec = s.bytes().filter(|b| !b.is_ascii_whitespace()).collect(); if !clean.len().is_multiple_of(4) { return None; } let mut out = Vec::with_capacity(clean.len() / 4 * 3); for c in clean.chunks(4) { let mut n = 0u32; let mut pad = 0; for &b in c { n <<= 6; if b == b'=' { pad += 1; } else { n |= val(b)?; } } out.push((n >> 16) as u8); if pad < 2 { out.push((n >> 8) as u8); } if pad < 1 { out.push(n as u8); } } Some(out) }