use crate::core::svg; use crate::core::{Color, Size}; use crate::image::atlas::{self, Atlas}; use resvg::tiny_skia; use resvg::usvg; use std::collections::{HashMap, HashSet}; use std::fs; /// Entry in cache corresponding to an svg handle pub enum Svg { /// Parsed svg Loaded(usvg::Tree), /// Svg not found or failed to parse NotFound, } impl Svg { /// Viewport width and height pub fn viewport_dimensions(&self) -> Size { match self { Svg::Loaded(tree) => { let size = tree.size; Size::new(size.width() as u32, size.height() as u32) } Svg::NotFound => Size::new(1, 1), } } } /// Caches svg vector and raster data #[derive(Debug, Default)] pub struct Cache { svgs: HashMap, rasterized: HashMap<(u64, u32, u32, ColorFilter), atlas::Entry>, svg_hits: HashSet, rasterized_hits: HashSet<(u64, u32, u32, ColorFilter)>, } type ColorFilter = Option<[u8; 4]>; impl Cache { /// Load svg pub fn load(&mut self, handle: &svg::Handle) -> &Svg { use usvg::TreeParsing; if self.svgs.contains_key(&handle.id()) { return self.svgs.get(&handle.id()).unwrap(); } let svg = match handle.data() { svg::Data::Path(path) => { let tree = fs::read_to_string(path).ok().and_then(|contents| { usvg::Tree::from_str(&contents, &usvg::Options::default()) .ok() }); tree.map(Svg::Loaded).unwrap_or(Svg::NotFound) } svg::Data::Bytes(bytes) => { match usvg::Tree::from_data(bytes, &usvg::Options::default()) { Ok(tree) => Svg::Loaded(tree), Err(_) => Svg::NotFound, } } }; let _ = self.svgs.insert(handle.id(), svg); self.svgs.get(&handle.id()).unwrap() } /// Load svg and upload raster data pub fn upload( &mut self, device: &wgpu::Device, queue: &wgpu::Queue, encoder: &mut wgpu::CommandEncoder, handle: &svg::Handle, color: Option, [width, height]: [f32; 2], scale: f32, atlas: &mut Atlas, ) -> Option<&atlas::Entry> { let id = handle.id(); let (width, height) = ( (scale * width).ceil() as u32, (scale * height).ceil() as u32, ); let color = color.map(Color::into_rgba8); let key = (id, width, height, color); // TODO: Optimize! // We currently rerasterize the SVG when its size changes. This is slow // as heck. A GPU rasterizer like `pathfinder` may perform better. // It would be cool to be able to smooth resize the `svg` example. if self.rasterized.contains_key(&key) { let _ = self.svg_hits.insert(id); let _ = self.rasterized_hits.insert(key); return self.rasterized.get(&key); } match self.load(handle) { Svg::Loaded(tree) => { if width == 0 || height == 0 { return None; } // TODO: Optimize! // We currently rerasterize the SVG when its size changes. This is slow // as heck. A GPU rasterizer like `pathfinder` may perform better. // It would be cool to be able to smooth resize the `svg` example. let mut img = tiny_skia::Pixmap::new(width, height)?; resvg::render( tree, if width > height { resvg::FitTo::Width(width) } else { resvg::FitTo::Height(height) }, tiny_skia::Transform::default(), img.as_mut(), )?; let mut rgba = img.take(); if let Some(color) = color { rgba.chunks_exact_mut(4).for_each(|rgba| { if rgba[3] > 0 { rgba[0] = color[0]; rgba[1] = color[1]; rgba[2] = color[2]; } }); } let allocation = atlas .upload(device, queue, encoder, width, height, &rgba)?; log::debug!("allocating {} {}x{}", id, width, height); let _ = self.svg_hits.insert(id); let _ = self.rasterized_hits.insert(key); let _ = self.rasterized.insert(key, allocation); self.rasterized.get(&key) } Svg::NotFound => None, } } /// Load svg and upload raster data pub fn trim(&mut self, atlas: &mut Atlas) { let svg_hits = &self.svg_hits; let rasterized_hits = &self.rasterized_hits; self.svgs.retain(|k, _| svg_hits.contains(k)); self.rasterized.retain(|k, entry| { let retain = rasterized_hits.contains(k); if !retain { atlas.remove(entry); } retain }); self.svg_hits.clear(); self.rasterized_hits.clear(); } } impl std::fmt::Debug for Svg { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Svg::Loaded(_) => write!(f, "Svg::Loaded"), Svg::NotFound => write!(f, "Svg::NotFound"), } } }