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