gpui/
svg_renderer.rs

1use crate::{
2    AssetSource, DevicePixels, IsZero, RenderImage, Result, SharedString, Size,
3    swap_rgba_pa_to_bgra,
4};
5use image::Frame;
6use resvg::tiny_skia::Pixmap;
7use smallvec::SmallVec;
8use std::{
9    hash::Hash,
10    sync::{Arc, LazyLock},
11};
12
13/// When rendering SVGs, we render them at twice the size to get a higher-quality result.
14pub const SMOOTH_SVG_SCALE_FACTOR: f32 = 2.;
15
16#[derive(Clone, PartialEq, Hash, Eq)]
17pub(crate) struct RenderSvgParams {
18    pub(crate) path: SharedString,
19    pub(crate) size: Size<DevicePixels>,
20}
21
22#[derive(Clone)]
23/// A struct holding everything necessary to render SVGs.
24pub struct SvgRenderer {
25    asset_source: Arc<dyn AssetSource>,
26    usvg_options: Arc<usvg::Options<'static>>,
27}
28
29/// The size in which to render the SVG.
30pub enum SvgSize {
31    /// An absolute size in device pixels.
32    Size(Size<DevicePixels>),
33    /// A scaling factor to apply to the size provided by the SVG.
34    ScaleFactor(f32),
35}
36
37impl SvgRenderer {
38    /// Creates a new SVG renderer with the provided asset source.
39    pub fn new(asset_source: Arc<dyn AssetSource>) -> Self {
40        static FONT_DB: LazyLock<Arc<usvg::fontdb::Database>> = LazyLock::new(|| {
41            let mut db = usvg::fontdb::Database::new();
42            db.load_system_fonts();
43            Arc::new(db)
44        });
45        let default_font_resolver = usvg::FontResolver::default_font_selector();
46        let font_resolver = Box::new(
47            move |font: &usvg::Font, db: &mut Arc<usvg::fontdb::Database>| {
48                if db.is_empty() {
49                    *db = FONT_DB.clone();
50                }
51                default_font_resolver(font, db)
52            },
53        );
54        let options = usvg::Options {
55            font_resolver: usvg::FontResolver {
56                select_font: font_resolver,
57                select_fallback: usvg::FontResolver::default_fallback_selector(),
58            },
59            ..Default::default()
60        };
61        Self {
62            asset_source,
63            usvg_options: Arc::new(options),
64        }
65    }
66
67    /// Renders the given bytes into an image buffer.
68    pub fn render_single_frame(
69        &self,
70        bytes: &[u8],
71        scale_factor: f32,
72        to_brga: bool,
73    ) -> Result<Arc<RenderImage>, usvg::Error> {
74        self.render_pixmap(
75            bytes,
76            SvgSize::ScaleFactor(scale_factor * SMOOTH_SVG_SCALE_FACTOR),
77        )
78        .map(|pixmap| {
79            let mut buffer =
80                image::ImageBuffer::from_raw(pixmap.width(), pixmap.height(), pixmap.take())
81                    .unwrap();
82
83            if to_brga {
84                for pixel in buffer.chunks_exact_mut(4) {
85                    swap_rgba_pa_to_bgra(pixel);
86                }
87            }
88
89            let mut image = RenderImage::new(SmallVec::from_const([Frame::new(buffer)]));
90            image.scale_factor = SMOOTH_SVG_SCALE_FACTOR;
91            Arc::new(image)
92        })
93    }
94
95    pub(crate) fn render_alpha_mask(
96        &self,
97        params: &RenderSvgParams,
98        bytes: Option<&[u8]>,
99    ) -> Result<Option<(Size<DevicePixels>, Vec<u8>)>> {
100        anyhow::ensure!(!params.size.is_zero(), "can't render at a zero size");
101
102        let render_pixmap = |bytes| {
103            let pixmap = self.render_pixmap(bytes, SvgSize::Size(params.size))?;
104
105            // Convert the pixmap's pixels into an alpha mask.
106            let size = Size::new(
107                DevicePixels(pixmap.width() as i32),
108                DevicePixels(pixmap.height() as i32),
109            );
110            let alpha_mask = pixmap
111                .pixels()
112                .iter()
113                .map(|p| p.alpha())
114                .collect::<Vec<_>>();
115
116            Ok(Some((size, alpha_mask)))
117        };
118
119        if let Some(bytes) = bytes {
120            render_pixmap(bytes)
121        } else if let Some(bytes) = self.asset_source.load(&params.path)? {
122            render_pixmap(&bytes)
123        } else {
124            Ok(None)
125        }
126    }
127
128    fn render_pixmap(&self, bytes: &[u8], size: SvgSize) -> Result<Pixmap, usvg::Error> {
129        let tree = usvg::Tree::from_data(bytes, &self.usvg_options)?;
130        let svg_size = tree.size();
131        let scale = match size {
132            SvgSize::Size(size) => size.width.0 as f32 / svg_size.width(),
133            SvgSize::ScaleFactor(scale) => scale,
134        };
135
136        // Render the SVG to a pixmap with the specified width and height.
137        let mut pixmap = resvg::tiny_skia::Pixmap::new(
138            (svg_size.width() * scale) as u32,
139            (svg_size.height() * scale) as u32,
140        )
141        .ok_or(usvg::Error::InvalidSize)?;
142
143        let transform = resvg::tiny_skia::Transform::from_scale(scale, scale);
144
145        resvg::render(&tree, transform, &mut pixmap.as_mut());
146
147        Ok(pixmap)
148    }
149}
gpui/svg_renderer.rs

gpui/
svg_renderer.rs
