1use crate::{AssetSource, DevicePixels, IsZero, Result, SharedString, Size};
  2use anyhow::anyhow;
  3use resvg::tiny_skia::Pixmap;
  4use std::{
  5    hash::Hash,
  6    sync::{Arc, LazyLock},
  7};
  8
  9/// When rendering SVGs, we render them at twice the size to get a higher-quality result.
 10pub const SMOOTH_SVG_SCALE_FACTOR: f32 = 2.;
 11
 12#[derive(Clone, PartialEq, Hash, Eq)]
 13pub(crate) struct RenderSvgParams {
 14    pub(crate) path: SharedString,
 15    pub(crate) size: Size<DevicePixels>,
 16}
 17
 18#[derive(Clone)]
 19pub struct SvgRenderer {
 20    asset_source: Arc<dyn AssetSource>,
 21    usvg_options: Arc<usvg::Options<'static>>,
 22}
 23
 24pub enum SvgSize {
 25    Size(Size<DevicePixels>),
 26    ScaleFactor(f32),
 27}
 28
 29impl SvgRenderer {
 30    pub fn new(asset_source: Arc<dyn AssetSource>) -> Self {
 31        let font_db = LazyLock::new(|| {
 32            let mut db = usvg::fontdb::Database::new();
 33            db.load_system_fonts();
 34            Arc::new(db)
 35        });
 36        let default_font_resolver = usvg::FontResolver::default_font_selector();
 37        let font_resolver = Box::new(
 38            move |font: &usvg::Font, db: &mut Arc<usvg::fontdb::Database>| {
 39                if db.is_empty() {
 40                    *db = font_db.clone();
 41                }
 42                default_font_resolver(font, db)
 43            },
 44        );
 45        let options = usvg::Options {
 46            font_resolver: usvg::FontResolver {
 47                select_font: font_resolver,
 48                select_fallback: usvg::FontResolver::default_fallback_selector(),
 49            },
 50            ..Default::default()
 51        };
 52        Self {
 53            asset_source,
 54            usvg_options: Arc::new(options),
 55        }
 56    }
 57
 58    pub(crate) fn render(&self, params: &RenderSvgParams) -> Result<Option<Vec<u8>>> {
 59        if params.size.is_zero() {
 60            return Err(anyhow!("can't render at a zero size"));
 61        }
 62
 63        // Load the tree.
 64        let Some(bytes) = self.asset_source.load(&params.path)? else {
 65            return Ok(None);
 66        };
 67
 68        let pixmap = self.render_pixmap(&bytes, SvgSize::Size(params.size))?;
 69
 70        // Convert the pixmap's pixels into an alpha mask.
 71        let alpha_mask = pixmap
 72            .pixels()
 73            .iter()
 74            .map(|p| p.alpha())
 75            .collect::<Vec<_>>();
 76        Ok(Some(alpha_mask))
 77    }
 78
 79    pub fn render_pixmap(&self, bytes: &[u8], size: SvgSize) -> Result<Pixmap, usvg::Error> {
 80        let tree = usvg::Tree::from_data(bytes, &self.usvg_options)?;
 81
 82        let size = match size {
 83            SvgSize::Size(size) => size,
 84            SvgSize::ScaleFactor(scale) => crate::size(
 85                DevicePixels((tree.size().width() * scale) as i32),
 86                DevicePixels((tree.size().height() * scale) as i32),
 87            ),
 88        };
 89
 90        // Render the SVG to a pixmap with the specified width and height.
 91        let mut pixmap = resvg::tiny_skia::Pixmap::new(size.width.into(), size.height.into())
 92            .ok_or(usvg::Error::InvalidSize)?;
 93
 94        let scale = size.width.0 as f32 / tree.size().width();
 95        let transform = resvg::tiny_skia::Transform::from_scale(scale, scale);
 96
 97        resvg::render(&tree, transform, &mut pixmap.as_mut());
 98
 99        Ok(pixmap)
100    }
101}