use std::sync::Arc;
use crate::common::{DEFAULT_TOLERANCE, ImageCache, LayerKind, supports_glyph_caching};
use anyrender::{
AntiAliasing, Filter, MaskMode, NormalizedCoord, Paint, PaintRef, PaintScene, RenderContext,
ResourceId,
};
use glifo::FontEmbolden;
use kurbo::{Affine, Diagonal2, Rect, Shape, Stroke};
use peniko::{BlendMode, Color, Compose, Fill, FontData, ImageBrush, ImageData, Mix, StyleRef};
use rustc_hash::FxHashSet;
use vello_common::{
TextureId,
paint::{ImageSource, PaintType, TextureRegion},
};
use vello_gpu::{Resources, TextureBindings};
use wgpu::{
Device, Extent3d, Origin3d, Queue, TexelCopyBufferLayout, TexelCopyTextureInfo, Texture,
TextureAspect, TextureDescriptor, TextureDimension, TextureFormat, TextureUsages, TextureView,
TextureViewDescriptor,
};
use wgpu_context::DeviceHandle;
#[derive(Clone, Copy)]
pub(crate) struct GlyphOriginSnap {
scale_x: f64,
offset_x: f64,
positions_per_px: f64,
round_x: f64,
snap_y: Option<(f64, f64)>,
lift_y: f64,
}
impl GlyphOriginSnap {
pub(crate) fn new(transform: Affine, font_size: f32, embolden: kurbo::Vec2) -> Option<Self> {
if cfg!(any(target_os = "macos", target_os = "ios")) {
Self::core_graphics(transform, font_size, embolden)
} else {
Self::skia(transform)
}
}
fn skia(transform: Affine) -> Option<Self> {
let [a, b, c, _, e, _] = transform.as_coeffs();
if b != 0.0 || c != 0.0 || a <= 0.0 {
return None;
}
Some(Self {
scale_x: a,
offset_x: e,
positions_per_px: 4.0,
round_x: 0.5,
snap_y: None,
lift_y: 0.0,
})
}
fn core_graphics(transform: Affine, font_size: f32, embolden: kurbo::Vec2) -> Option<Self> {
let [a, b, c, d, e, f] = transform.as_coeffs();
let ppem = font_size as f64 * d.abs();
if b != 0.0 || c != 0.0 || a <= 0.0 || !ppem.is_finite() || ppem <= 0.0 {
return None;
}
Some(Self {
scale_x: a,
offset_x: e,
positions_per_px: (100.0 / (3.0 * ppem)).ceil().min(5.0),
round_x: 0.0,
snap_y: Some((d, f)),
lift_y: embolden.y * d.signum(),
})
}
pub(crate) fn x(self, x: f32) -> f32 {
let device_x = self.scale_x * x as f64 + self.offset_x;
let snapped =
(device_x * self.positions_per_px + self.round_x).floor() / self.positions_per_px;
((snapped - self.offset_x) / self.scale_x) as f32
}
pub(crate) fn y(self, y: f32) -> f32 {
let mut y = y as f64;
if let Some((scale_y, offset_y)) = self.snap_y {
let snapped = (scale_y * y + offset_y - 1.0 / 1024.0).ceil();
y = (snapped - offset_y) / scale_y;
}
(y - self.lift_y) as f32
}
}
fn anyrender_paint_to_vello_gpu_paint<'a>(
paint: PaintRef<'a>,
image_manager: &mut ImageManager<'_>,
) -> PaintType {
let texture_bindings = &*image_manager.texture_bindings;
match paint {
Paint::Solid(alpha_color) => PaintType::Solid(alpha_color),
Paint::Gradient(gradient) => PaintType::Gradient(gradient.clone()),
Paint::Image(image_brush) => {
let Some((texture_id, may_have_transparency)) =
image_manager.upload_image(image_brush.image)
else {
return PaintType::Solid(Color::TRANSPARENT);
};
PaintType::Image(ImageBrush {
image: ImageSource::external_texture(
texture_id,
TextureRegion::Full,
may_have_transparency,
),
sampler: image_brush.sampler,
})
}
Paint::Resource(brush) if texture_bindings.contains(brush.image) => {
PaintType::Image(ImageBrush {
image: ImageSource::external_texture(
TextureId(brush.image.into_ffi()),
TextureRegion::Full,
true,
),
sampler: brush.sampler,
})
}
Paint::Resource(_) => PaintType::Solid(peniko::color::palette::css::TRANSPARENT),
Paint::Custom(_) => PaintType::Solid(peniko::color::palette::css::TRANSPARENT),
Paint::Pattern(_) => PaintType::Solid(peniko::color::palette::css::TRANSPARENT),
}
}
#[derive(Debug, Default)]
pub struct ExternalTextures {
bindings: TextureBindings,
ids: FxHashSet<ResourceId>,
}
impl ExternalTextures {
pub fn insert(&mut self, id: ResourceId, view: TextureView) {
self.ids.insert(id);
self.bindings.insert(TextureId(id.into_ffi()), view);
}
pub fn remove(&mut self, id: ResourceId) {
if self.ids.remove(&id) {
self.bindings.remove(TextureId(id.into_ffi()));
}
}
pub fn contains(&self, id: ResourceId) -> bool {
self.ids.contains(&id)
}
pub fn bindings(&self) -> &TextureBindings {
&self.bindings
}
}
pub struct ImageManager<'a> {
pub(crate) resources: &'a mut Resources,
pub(crate) device: &'a Device,
pub(crate) queue: &'a Queue,
pub(crate) cache: &'a mut ImageCache,
pub(crate) texture_bindings: &'a mut ExternalTextures,
}
impl<'a> ImageManager<'a> {
pub fn new(
resources: &'a mut Resources,
device: &'a Device,
queue: &'a Queue,
cache: &'a mut ImageCache,
texture_bindings: &'a mut ExternalTextures,
) -> Self {
Self {
resources,
device,
queue,
cache,
texture_bindings,
}
}
pub(crate) fn upload_image(&mut self, image: &ImageData) -> Option<(TextureId, bool)> {
if !self.cache.fits(image.width, image.height) {
return None;
}
let peniko_id = image.data.id();
if let Some(cached) = self.cache.get(peniko_id) {
return Some(cached);
};
let ImageSource::Pixmap(pixmap) = ImageSource::from_peniko_image_data(image) else {
unreachable!(); };
let may_have_transparency = pixmap.may_have_transparency();
let texture = self.device.create_texture(&TextureDescriptor {
label: Some("AnyRender uploaded image"),
size: Extent3d {
width: u32::from(pixmap.width()),
height: u32::from(pixmap.height()),
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: TextureDimension::D2,
format: TextureFormat::Rgba8Unorm,
usage: TextureUsages::TEXTURE_BINDING | TextureUsages::COPY_DST,
view_formats: &[],
});
self.queue.write_texture(
TexelCopyTextureInfo {
texture: &texture,
mip_level: 0,
origin: Origin3d::ZERO,
aspect: TextureAspect::All,
},
pixmap.data_as_u8_slice(),
TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(4 * u32::from(pixmap.width())),
rows_per_image: Some(u32::from(pixmap.height())),
},
Extent3d {
width: u32::from(pixmap.width()),
height: u32::from(pixmap.height()),
depth_or_array_layers: 1,
},
);
let resource_id = ResourceId::new();
self.texture_bindings.insert(
resource_id,
texture.create_view(&TextureViewDescriptor::default()),
);
let texture_id = TextureId(resource_id.into_ffi());
self.cache.insert(
&image.data,
texture_id,
may_have_transparency,
image.width,
image.height,
);
Some((texture_id, may_have_transparency))
}
pub fn finish_frame(&mut self) {
for id in self.cache.finish_frame() {
self.texture_bindings.remove(ResourceId::from_ffi(id.0));
}
}
}
pub struct VelloGpuScenePainter<'s> {
pub(crate) scene: &'s mut vello_gpu::Scene,
pub(crate) layer_stack: Vec<LayerKind>,
pub(crate) image_manager: ImageManager<'s>,
pub(crate) device_handle: &'s DeviceHandle,
pub(crate) glyph_caching: bool,
}
impl VelloGpuScenePainter<'_> {
fn cull_rect(&self) -> Option<Rect> {
Some(Rect::new(
0.0,
0.0,
f64::from(self.scene.width()),
f64::from(self.scene.height()),
))
}
pub fn new<'s>(
scene: &'s mut vello_gpu::Scene,
image_manager: ImageManager<'s>,
device_handle: &'s DeviceHandle,
) -> VelloGpuScenePainter<'s> {
VelloGpuScenePainter {
scene,
layer_stack: Vec::with_capacity(16),
image_manager,
device_handle,
glyph_caching: false,
}
}
pub fn with_glyph_caching(mut self, enabled: bool) -> Self {
self.glyph_caching = enabled;
self
}
fn convert_paint(&mut self, paint: PaintRef<'_>) -> PaintType {
anyrender_paint_to_vello_gpu_paint(paint, &mut self.image_manager)
}
}
impl RenderContext for VelloGpuScenePainter<'_> {
fn try_register_custom_resource(
&mut self,
resource: Box<dyn std::any::Any>,
) -> Result<ResourceId, anyrender::RegisterResourceError> {
match resource.downcast::<Texture>() {
Ok(texture) => {
let id = ResourceId::new();
let texture_view = texture.create_view(&TextureViewDescriptor::default());
self.image_manager.texture_bindings.insert(id, texture_view);
Ok(id)
}
Err(resource) => {
if let Ok(texture_view) = resource.downcast::<TextureView>() {
let id = ResourceId::new();
self.image_manager
.texture_bindings
.insert(id, *texture_view);
Ok(id)
}
else {
Err(anyrender::RegisterResourceErrorKind::UnsupportedResourceKind.into())
}
}
}
}
fn unregister_resource(&mut self, resource_id: ResourceId) {
self.image_manager.texture_bindings.remove(resource_id);
}
fn renderer_specific_context(&self) -> Option<Box<dyn std::any::Any>> {
Some(Box::new(self.device_handle.clone()) as _)
}
}
impl PaintScene for VelloGpuScenePainter<'_> {
fn reset(&mut self) {
self.scene.reset();
}
fn push_layer(
&mut self,
fill: Fill,
blend: impl Into<BlendMode>,
alpha: f32,
transform: Affine,
clip: &impl Shape,
filter: Option<Arc<Filter>>,
_backdrop_filter: Option<Arc<Filter>>,
) {
let (filter, region) = match filter.as_deref().and_then(crate::common::convert_filter) {
Some(converted) => (
Some(converted),
filter.and_then(|f| Some(f.nodes().first()?.region)),
),
None => (None, None),
};
self.scene.set_transform(transform);
if let Some(region) = ®ion {
self.scene.push_clip_rect(region);
}
self.scene.set_fill_rule(fill);
if let Some(rect) = clip.as_rect() {
self.scene.push_clip_rect(&rect);
} else {
self.scene
.push_clip_path(&clip.into_path(DEFAULT_TOLERANCE));
}
self.scene
.push_layer(None, Some(blend.into()), Some(alpha), None, filter);
match ®ion {
Some(region) => {
self.scene.push_clip_rect(region);
self.layer_stack.push(LayerKind::FilterRegionLayer);
}
None => self.layer_stack.push(LayerKind::Layer),
}
}
fn push_mask_layer(
&mut self,
fill: Fill,
_mode: MaskMode,
transform: Affine,
clip: &impl Shape,
) {
let blend = BlendMode::new(Mix::Normal, Compose::DestIn);
let everything = Rect::new(-1e6, -1e6, 1e6, 1e6);
self.push_layer(
Fill::NonZero,
blend,
1.0,
Affine::IDENTITY,
&everything,
None,
None,
);
self.fill(
fill,
transform,
Color::BLACK,
None,
clip,
AntiAliasing::Enabled,
);
self.pop_layer();
self.push_layer(fill, blend, 1.0, transform, clip, None, None);
}
fn push_clip_layer(&mut self, fill: Fill, transform: Affine, clip: &impl Shape) {
self.scene.set_transform(transform);
self.scene.set_fill_rule(fill);
self.layer_stack.push(LayerKind::Clip);
if let Some(rect) = clip.as_rect() {
self.scene.push_clip_rect(&rect);
} else {
self.scene
.push_clip_path(&clip.into_path(DEFAULT_TOLERANCE));
}
}
fn pop_layer(&mut self) {
if let Some(kind) = self.layer_stack.pop() {
match kind {
LayerKind::Layer => {
self.scene.pop_layer();
self.scene.pop_clip();
}
LayerKind::Clip => self.scene.pop_clip(),
LayerKind::FilterRegionLayer => {
self.scene.pop_clip();
self.scene.pop_layer();
self.scene.pop_clip();
self.scene.pop_clip();
}
}
}
}
fn stroke<'a>(
&mut self,
style: &Stroke,
transform: Affine,
paint: impl Into<PaintRef<'a>>,
brush_transform: Option<Affine>,
shape: &impl Shape,
anti_aliasing: AntiAliasing,
) {
let paint: anyrender::PaintRef<'a> = paint.into();
if let anyrender::Paint::Pattern(pattern) = paint {
let cull_rect = self.cull_rect();
anyrender::stroke_pattern_tiles(
self,
pattern,
style,
transform,
brush_transform,
shape,
cull_rect,
);
return;
}
self.scene.set_transform(transform);
self.scene.set_stroke(style.clone());
self.scene
.set_aliasing_threshold((!anti_aliasing.is_enabled()).then_some(127));
let paint = self.convert_paint(paint);
self.scene.set_paint(paint);
self.scene
.set_paint_transform(brush_transform.unwrap_or(Affine::IDENTITY));
self.scene.stroke_path(&shape.into_path(DEFAULT_TOLERANCE));
self.scene.set_aliasing_threshold(None);
}
fn fill<'a>(
&mut self,
style: Fill,
transform: Affine,
paint: impl Into<PaintRef<'a>>,
brush_transform: Option<Affine>,
shape: &impl Shape,
anti_aliasing: AntiAliasing,
) {
let paint: anyrender::PaintRef<'a> = paint.into();
if let anyrender::Paint::Pattern(pattern) = paint {
let cull_rect = self.cull_rect();
anyrender::fill_pattern_tiles(
self,
pattern,
style,
transform,
brush_transform,
shape,
cull_rect,
);
return;
}
self.scene.set_transform(transform);
self.scene.set_fill_rule(style);
self.scene
.set_aliasing_threshold((!anti_aliasing.is_enabled()).then_some(127));
let paint = self.convert_paint(paint);
self.scene.set_paint(paint);
self.scene
.set_paint_transform(brush_transform.unwrap_or(Affine::IDENTITY));
if let Some(rect) = shape.as_rect() {
self.scene.fill_rect(&rect);
} else {
self.scene.fill_path(&shape.into_path(DEFAULT_TOLERANCE));
}
self.scene.set_aliasing_threshold(None);
}
fn draw_glyphs<'a, 's: 'a>(
&'a mut self,
font: &'a FontData,
font_size: f32,
hint: bool,
normalized_coords: &'a [NormalizedCoord],
embolden: kurbo::Vec2,
style: impl Into<StyleRef<'a>>,
paint: impl Into<PaintRef<'a>>,
brush_alpha: f32,
transform: Affine,
glyph_transform: Option<Affine>,
glyphs: impl Iterator<Item = anyrender::Glyph> + Clone,
anti_aliasing: AntiAliasing,
) {
let paint: PaintRef<'a> = paint.into();
if let anyrender::Paint::Pattern(pattern) = paint {
let cull_rect = self.cull_rect();
anyrender::draw_glyphs_pattern_tiles(
self,
pattern,
font,
font_size,
hint,
normalized_coords,
embolden,
style,
brush_alpha,
transform,
glyph_transform,
glyphs,
cull_rect,
);
return;
}
let paint = self.convert_paint(paint);
self.scene.set_paint(paint);
self.scene.reset_paint_transform();
self.scene.set_transform(transform);
self.scene
.set_aliasing_threshold((!anti_aliasing.is_enabled()).then_some(127));
let glyph_caching = anti_aliasing.is_enabled()
&& self.glyph_caching
&& supports_glyph_caching(transform, glyph_transform);
let snap = GlyphOriginSnap::new(transform, font_size, embolden);
let style: StyleRef<'a> = style.into();
match style {
StyleRef::Fill(fill) => {
self.scene.set_fill_rule(fill);
let _ = self
.scene
.glyph_run(self.image_manager.resources, font)
.atlas_cache(glyph_caching)
.font_size(font_size)
.hint(hint)
.normalized_coords(normalized_coords)
.font_embolden(FontEmbolden::new(Diagonal2::new(embolden.x, embolden.y)))
.glyph_transform(glyph_transform.unwrap_or_default())
.fill_glyphs(glyphs.map(|g| glifo::Glyph {
id: g.id,
x: snap.map_or(g.x, |snap| snap.x(g.x)),
y: snap.map_or(g.y, |snap| snap.y(g.y)),
}));
}
StyleRef::Stroke(stroke) => {
self.scene.set_stroke(stroke.clone());
let _ = self
.scene
.glyph_run(self.image_manager.resources, font)
.atlas_cache(glyph_caching)
.font_size(font_size)
.hint(hint)
.normalized_coords(normalized_coords)
.glyph_transform(glyph_transform.unwrap_or_default())
.stroke_glyphs(glyphs.map(|g| glifo::Glyph {
id: g.id,
x: snap.map_or(g.x, |snap| snap.x(g.x)),
y: snap.map_or(g.y, |snap| snap.y(g.y)),
}));
}
}
self.scene.set_aliasing_threshold(None);
}
fn draw_box_shadow(
&mut self,
transform: Affine,
box_shape: &anyrender::NonUniformRoundedRect,
offset: kurbo::Vec2,
spread: f64,
std_dev: f64,
color: Color,
kind: anyrender::BoxShadowKind,
) {
let geometry = anyrender::BoxShadowGeometry::new(box_shape, offset, spread, std_dev, kind);
self.scene.set_transform(transform);
self.scene.set_paint(PaintType::Solid(color));
self.scene.reset_paint_transform();
self.scene.set_fill_rule(Fill::NonZero);
if geometry.std_dev == 0.0 {
let clip = geometry.needs_clip();
if clip {
self.scene.push_clip_path(&geometry.area);
}
self.scene.fill_path(&geometry.unblurred_path());
if clip {
self.scene.pop_clip();
}
return;
}
self.scene.fill_blurred_rounded_rect_in(
&geometry.area,
&geometry.shadow.rect,
geometry.shadow.average_radius() as f32,
geometry.std_dev as f32,
geometry.is_inset(),
);
}
}
#[cfg(test)]
mod glyph_origin_snap_tests {
use super::GlyphOriginSnap;
use kurbo::Affine;
fn snapped_device_x(transform: Affine, font_size: f32, x: f32) -> f64 {
let snap = GlyphOriginSnap::core_graphics(transform, font_size, kurbo::Vec2::ZERO).unwrap();
transform.as_coeffs()[0] * snap.x(x) as f64 + transform.as_coeffs()[4]
}
#[test]
fn grid_depends_on_device_ppem() {
for (ppem, step) in [
(8.0, 0.2),
(11.0, 0.25),
(12.0, 1.0 / 3.0),
(16.0, 1.0 / 3.0),
(17.0, 0.5),
(33.0, 0.5),
(34.0, 1.0),
(72.0, 1.0),
] {
let snap =
GlyphOriginSnap::core_graphics(Affine::IDENTITY, ppem, kurbo::Vec2::ZERO).unwrap();
assert_eq!(snap.positions_per_px, (1.0f64 / step).round(), "{ppem}ppem");
}
}
#[test]
fn floors_device_x() {
assert_eq!(snapped_device_x(Affine::IDENTITY, 11.0, 10.7), 10.5);
assert_eq!(snapped_device_x(Affine::IDENTITY, 16.0, 10.3), 10.0);
assert_eq!(snapped_device_x(Affine::IDENTITY, 40.0, 10.9), 10.0);
let transform = Affine::translate((3.0, 0.0)) * Affine::scale(2.0);
assert!((snapped_device_x(transform, 8.0, 5.2) - 13.333333).abs() < 1e-4);
}
#[test]
fn rounds_device_x_to_quarter_px_for_skia() {
let device_x = |transform: Affine, x: f32| {
let snap = GlyphOriginSnap::skia(transform).unwrap();
transform.as_coeffs()[0] * snap.x(x) as f64 + transform.as_coeffs()[4]
};
assert_eq!(device_x(Affine::IDENTITY, 10.1), 10.0);
assert_eq!(device_x(Affine::IDENTITY, 10.2), 10.25);
assert_eq!(device_x(Affine::IDENTITY, 10.9), 11.0);
let transform = Affine::translate((3.0, 0.0)) * Affine::scale(2.0);
assert_eq!(device_x(transform, 5.2), 13.5);
assert!(GlyphOriginSnap::skia(Affine::rotate(0.5)).is_none());
}
#[test]
fn snaps_device_y_down_to_whole_px() {
let device_y = |transform: Affine, y: f32| {
let snap = GlyphOriginSnap::core_graphics(transform, 16.0, kurbo::Vec2::ZERO).unwrap();
transform.as_coeffs()[3] * snap.y(y) as f64 + transform.as_coeffs()[5]
};
assert_eq!(device_y(Affine::IDENTITY, 10.0), 10.0);
assert_eq!(device_y(Affine::IDENTITY, 10.0005), 10.0);
assert_eq!(device_y(Affine::IDENTITY, 10.1), 11.0);
assert_eq!(device_y(Affine::IDENTITY, 10.9), 11.0);
assert!((device_y(Affine::scale(1.5), 7.0) - 11.0).abs() < 1e-6);
let transform = Affine::translate((0.0, 0.25)) * Affine::scale(2.0);
assert!((device_y(transform, 5.0) - 11.0).abs() < 1e-6);
let snap = GlyphOriginSnap::skia(Affine::IDENTITY).unwrap();
assert_eq!(snap.y(10.3), 10.3);
}
#[test]
fn raises_emboldened_glyphs_by_vertical_embolden() {
let embolden = kurbo::Vec2::new(0.1, 0.3);
let snap = GlyphOriginSnap::core_graphics(Affine::IDENTITY, 16.0, embolden).unwrap();
assert!((snap.y(10.0) - 9.7).abs() < 1e-6);
let snap = GlyphOriginSnap::core_graphics(Affine::scale(2.0), 8.0, embolden).unwrap();
assert!((snap.y(10.0) - 9.7).abs() < 1e-6);
let snap = GlyphOriginSnap::core_graphics(Affine::IDENTITY, 16.0, kurbo::Vec2::ZERO);
assert_eq!(snap.unwrap().y(10.0), 10.0);
}
#[test]
fn skips_rotated_runs() {
assert!(
GlyphOriginSnap::core_graphics(Affine::rotate(0.3), 16.0, kurbo::Vec2::ZERO).is_none()
);
}
}