| // Copyright 2023 Google LLC |
| // |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| use crate::ffi; |
| use { |
| peniko::{ |
| kurbo::{Affine, Cap, Join, PathEl, Point, Stroke}, |
| Brush, Color, Fill, Mix, |
| }, |
| std::pin::Pin, |
| vello_encoding::{ |
| BumpEstimator, Encoding as VelloEncoding, PathEncoder, RenderConfig, Transform, |
| }, |
| }; |
| |
| pub(crate) struct Encoding { |
| encoding: VelloEncoding, |
| estimator: BumpEstimator, |
| } |
| |
| pub(crate) fn new_encoding() -> Box<Encoding> { |
| Box::new(Encoding::new()) |
| } |
| |
| impl Encoding { |
| fn new() -> Encoding { |
| // An encoding blob that doesn't represent a scene fragment (i.e. a reused blob that is |
| // appended to a root encoding), then we need to initialize the transform and linewidth |
| // streams with first entries (an identity transform and -1 linewidth value). Resetting |
| // the encoding as non-fragment achieves this. |
| let mut encoding = VelloEncoding::new(); |
| encoding.reset(); |
| Encoding { encoding, estimator: BumpEstimator::new(), } |
| } |
| |
| pub fn is_empty(&self) -> bool { |
| self.encoding.is_empty() |
| } |
| |
| pub fn reset(&mut self) { |
| self.encoding.reset(); |
| self.estimator.reset(); |
| } |
| |
| pub fn fill( |
| &mut self, |
| style: ffi::Fill, |
| transform: ffi::Affine, |
| brush: &ffi::Brush, |
| path_iter: Pin<&mut ffi::PathIterator>, |
| ) { |
| let t = Transform::from_kurbo(&transform.into()); |
| self.encoding.encode_transform(t); |
| self.encoding.encode_fill_style(style.into()); |
| if self.encode_path(path_iter, &t, None) { |
| self.encoding.encode_brush(&Brush::from(brush), 1.0) |
| } |
| } |
| |
| pub fn stroke( |
| &mut self, |
| style: &ffi::Stroke, |
| transform: ffi::Affine, |
| brush: &ffi::Brush, |
| path_iter: Pin<&mut ffi::PathIterator>, |
| ) { |
| let t = Transform::from_kurbo(&transform.into()); |
| self.encoding.encode_transform(t); |
| |
| // TODO: process any dash pattern here using kurbo's dash expander unless Graphite |
| // handles dashing already. |
| let stroke = style.into(); |
| self.encoding.encode_stroke_style(&stroke); |
| if self.encode_path(path_iter, &t, Some(&stroke)) { |
| self.encoding.encode_brush(&Brush::from(brush), 1.0); |
| } |
| } |
| |
| pub fn begin_clip(&mut self, transform: ffi::Affine, path_iter: Pin<&mut ffi::PathIterator>) { |
| let t = Transform::from_kurbo(&transform.into()); |
| self.encoding.encode_transform(t); |
| self.encoding.encode_fill_style(Fill::NonZero); |
| self.encode_path(path_iter, &t, None); |
| self.encoding.encode_begin_clip(Mix::Clip.into(), /*alpha=*/ 1.0); |
| } |
| |
| pub fn end_clip(&mut self) { |
| self.encoding.encode_end_clip(); |
| } |
| |
| pub fn append(&mut self, other: &Encoding) { |
| self.encoding.append(&other.encoding, &None); |
| self.estimator.append(&other.estimator, None); |
| } |
| |
| pub fn prepare_render( |
| &self, |
| width: u32, |
| height: u32, |
| background: &ffi::Color, |
| ) -> Box<RenderConfiguration> { |
| let mut packed_scene = Vec::new(); |
| let layout = vello_encoding::resolve_solid_paths_only(&self.encoding, &mut packed_scene); |
| let mut config = RenderConfig::new(&layout, width, height, &background.into()); |
| |
| let bump_estimate = self.estimator.tally(None); |
| //println!("bump: {bump_estimate}"); |
| config.buffer_sizes.bin_data = bump_estimate.binning; |
| config.buffer_sizes.seg_counts = bump_estimate.seg_counts; |
| config.buffer_sizes.segments = bump_estimate.segments; |
| config.buffer_sizes.lines = bump_estimate.lines; |
| config.gpu.binning_size = bump_estimate.binning.len(); |
| config.gpu.seg_counts_size = bump_estimate.seg_counts.len(); |
| config.gpu.segments_size = bump_estimate.segments.len(); |
| config.gpu.lines_size = bump_estimate.lines.len(); |
| |
| Box::new(RenderConfiguration { |
| packed_scene, |
| config, |
| }) |
| } |
| |
| fn encode_path( |
| &mut self, |
| iter: Pin<&mut ffi::PathIterator>, |
| transform: &Transform, |
| stroke: Option<&Stroke>, |
| ) -> bool { |
| let mut encoder = self.encoding.encode_path(/*is_fill=*/ stroke.is_none()); |
| |
| // Wrap the input iterator inside a custom iterator, so that the path gets |
| // encoded as the estimator runs through it. |
| let path = IterablePathEncoder { iter, encoder: &mut encoder }; |
| self.estimator.count_path(path, transform, stroke); |
| encoder.finish(/*insert_path_marker=*/ true) != 0 |
| } |
| } |
| |
| // This is path element iterator that encodes path elements as it gets polled. |
| struct IterablePathEncoder<'a, 'b> { |
| iter: Pin<&'a mut ffi::PathIterator>, |
| encoder: &'a mut PathEncoder<'b>, |
| } |
| |
| impl Iterator for IterablePathEncoder<'_, '_> { |
| type Item = PathEl; |
| |
| fn next(&mut self) -> Option<Self::Item> { |
| let mut path_el = ffi::PathElement::default(); |
| if !unsafe { self.iter.as_mut().next_element(&mut path_el) } { |
| return None; |
| } |
| Some(match path_el.verb { |
| ffi::PathVerb::MoveTo => { |
| let p = &path_el.points[0]; |
| self.encoder.move_to(p.x, p.y); |
| PathEl::MoveTo(p.into()) |
| } |
| ffi::PathVerb::LineTo => { |
| let p = &path_el.points[1]; |
| self.encoder.line_to(p.x, p.y); |
| PathEl::LineTo(p.into()) |
| } |
| ffi::PathVerb::QuadTo => { |
| let p0 = &path_el.points[1]; |
| let p1 = &path_el.points[2]; |
| self.encoder.quad_to(p0.x, p0.y, p1.x, p1.y); |
| PathEl::QuadTo(p0.into(), p1.into()) |
| } |
| ffi::PathVerb::CurveTo => { |
| let p0 = &path_el.points[1]; |
| let p1 = &path_el.points[2]; |
| let p2 = &path_el.points[3]; |
| self.encoder.cubic_to(p0.x, p0.y, p1.x, p1.y, p2.x, p2.y); |
| PathEl::CurveTo(p0.into(), p1.into(), p2.into()) |
| } |
| ffi::PathVerb::Close => { |
| self.encoder.close(); |
| PathEl::ClosePath |
| } |
| _ => panic!("invalid path verb"), |
| }) |
| } |
| } |
| |
| pub(crate) struct RenderConfiguration { |
| packed_scene: Vec<u8>, |
| config: RenderConfig, |
| } |
| |
| impl RenderConfiguration { |
| pub fn config_uniform_buffer_size(self: &RenderConfiguration) -> usize { |
| std::mem::size_of::<vello_encoding::ConfigUniform>() |
| } |
| |
| pub fn scene_buffer_size(self: &RenderConfiguration) -> usize { |
| self.packed_scene.len() |
| } |
| |
| pub fn write_config_uniform_buffer(self: &RenderConfiguration, out_buffer: &mut [u8]) -> bool { |
| let bytes = bytemuck::bytes_of(&self.config.gpu); |
| if out_buffer.len() < bytes.len() { |
| return false; |
| } |
| out_buffer.copy_from_slice(bytes); |
| true |
| } |
| |
| pub fn write_scene_buffer(self: &RenderConfiguration, out_buffer: &mut [u8]) -> bool { |
| if out_buffer.len() < self.packed_scene.len() { |
| return false; |
| } |
| out_buffer.copy_from_slice(&self.packed_scene); |
| true |
| } |
| |
| pub fn workgroup_counts(self: &RenderConfiguration) -> ffi::DispatchInfo { |
| (&self.config.workgroup_counts).into() |
| } |
| |
| pub fn buffer_sizes(self: &RenderConfiguration) -> ffi::BufferSizes { |
| (&self.config.buffer_sizes).into() |
| } |
| } |
| |
| impl Iterator for Pin<&mut ffi::PathIterator> { |
| type Item = PathEl; |
| |
| fn next(&mut self) -> Option<PathEl> { |
| let mut path_el = ffi::PathElement::default(); |
| if !unsafe { self.as_mut().next_element(&mut path_el) } { |
| return None; |
| } |
| Some(match path_el.verb { |
| ffi::PathVerb::MoveTo => { |
| let p = &path_el.points[0]; |
| PathEl::MoveTo(p.into()) |
| } |
| ffi::PathVerb::LineTo => { |
| let p = &path_el.points[1]; |
| PathEl::LineTo(p.into()) |
| } |
| ffi::PathVerb::QuadTo => { |
| let p0 = &path_el.points[1]; |
| let p1 = &path_el.points[2]; |
| PathEl::QuadTo(p0.into(), p1.into()) |
| } |
| ffi::PathVerb::CurveTo => { |
| let p0 = &path_el.points[1]; |
| let p1 = &path_el.points[2]; |
| let p2 = &path_el.points[3]; |
| PathEl::CurveTo(p0.into(), p1.into(), p2.into()) |
| } |
| ffi::PathVerb::Close => PathEl::ClosePath, |
| _ => panic!("invalid path verb"), |
| }) |
| } |
| } |
| |
| impl From<&ffi::Point> for Point { |
| fn from(src: &ffi::Point) -> Self { |
| Self::new(src.x.into(), src.y.into()) |
| } |
| } |
| |
| impl Default for ffi::PathVerb { |
| fn default() -> Self { |
| Self::MoveTo |
| } |
| } |
| |
| impl From<ffi::Affine> for Affine { |
| fn from(src: ffi::Affine) -> Self { |
| Self::new([ |
| src.matrix[0] as f64, |
| src.matrix[1] as f64, |
| src.matrix[2] as f64, |
| src.matrix[3] as f64, |
| src.matrix[4] as f64, |
| src.matrix[5] as f64, |
| ]) |
| } |
| } |
| |
| impl From<&ffi::Color> for Color { |
| fn from(src: &ffi::Color) -> Self { |
| Self { |
| r: src.r, |
| g: src.g, |
| b: src.b, |
| a: src.a, |
| } |
| } |
| } |
| |
| impl From<&ffi::Brush> for Brush { |
| fn from(src: &ffi::Brush) -> Self { |
| match src.kind { |
| ffi::BrushKind::Solid => Brush::Solid(Color::from(&src.data.solid)), |
| _ => panic!("invalid brush kind"), |
| } |
| } |
| } |
| |
| impl From<ffi::Fill> for Fill { |
| fn from(src: ffi::Fill) -> Self { |
| match src { |
| ffi::Fill::NonZero => Self::NonZero, |
| ffi::Fill::EvenOdd => Self::EvenOdd, |
| _ => panic!("invalid fill type"), |
| } |
| } |
| } |
| |
| impl From<&ffi::Stroke> for Stroke { |
| fn from(src: &ffi::Stroke) -> Self { |
| let cap = match src.cap { |
| ffi::CapStyle::Butt => Cap::Butt, |
| ffi::CapStyle::Square => Cap::Square, |
| ffi::CapStyle::Round => Cap::Round, |
| _ => panic!("invalid cap style"), |
| }; |
| Self { |
| width: src.width as f64, |
| join: match src.join { |
| ffi::JoinStyle::Bevel => Join::Bevel, |
| ffi::JoinStyle::Miter => Join::Miter, |
| ffi::JoinStyle::Round => Join::Round, |
| _ => panic!("invalid join style"), |
| }, |
| miter_limit: src.miter_limit as f64, |
| start_cap: cap, |
| end_cap: cap, |
| // Skia expands a dash effect by transforming the encoded path, so don't need to handle |
| // that here. |
| dash_pattern: Default::default(), |
| dash_offset: 0., |
| } |
| } |
| } |
| |
| impl From<&vello_encoding::WorkgroupSize> for ffi::WorkgroupSize { |
| fn from(src: &vello_encoding::WorkgroupSize) -> Self { |
| Self { |
| x: src.0, |
| y: src.1, |
| z: src.2, |
| } |
| } |
| } |
| |
| impl From<&vello_encoding::WorkgroupCounts> for ffi::DispatchInfo { |
| fn from(src: &vello_encoding::WorkgroupCounts) -> Self { |
| Self { |
| use_large_path_scan: src.use_large_path_scan, |
| path_reduce: (&src.path_reduce).into(), |
| path_reduce2: (&src.path_reduce2).into(), |
| path_scan1: (&src.path_scan1).into(), |
| path_scan: (&src.path_scan).into(), |
| bbox_clear: (&src.bbox_clear).into(), |
| flatten: (&src.flatten).into(), |
| draw_reduce: (&src.draw_reduce).into(), |
| draw_leaf: (&src.draw_leaf).into(), |
| clip_reduce: (&src.clip_reduce).into(), |
| clip_leaf: (&src.clip_leaf).into(), |
| binning: (&src.binning).into(), |
| tile_alloc: (&src.tile_alloc).into(), |
| path_count_setup: (&src.path_count_setup).into(), |
| backdrop: (&src.backdrop).into(), |
| coarse: (&src.coarse).into(), |
| path_tiling_setup: (&src.path_tiling_setup).into(), |
| fine: (&src.fine).into(), |
| } |
| } |
| } |
| |
| impl From<&vello_encoding::BufferSizes> for ffi::BufferSizes { |
| fn from(src: &vello_encoding::BufferSizes) -> Self { |
| Self { |
| path_reduced: src.path_reduced.size_in_bytes(), |
| path_reduced2: src.path_reduced2.size_in_bytes(), |
| path_reduced_scan: src.path_reduced_scan.size_in_bytes(), |
| path_monoids: src.path_monoids.size_in_bytes(), |
| path_bboxes: src.path_bboxes.size_in_bytes(), |
| draw_reduced: src.draw_reduced.size_in_bytes(), |
| draw_monoids: src.draw_monoids.size_in_bytes(), |
| info: src.info.size_in_bytes(), |
| clip_inps: src.clip_inps.size_in_bytes(), |
| clip_els: src.clip_els.size_in_bytes(), |
| clip_bics: src.clip_bics.size_in_bytes(), |
| clip_bboxes: src.clip_bboxes.size_in_bytes(), |
| draw_bboxes: src.draw_bboxes.size_in_bytes(), |
| bump_alloc: src.bump_alloc.size_in_bytes(), |
| indirect_count: src.indirect_count.size_in_bytes(), |
| bin_headers: src.bin_headers.size_in_bytes(), |
| paths: src.paths.size_in_bytes(), |
| lines: src.lines.size_in_bytes(), |
| bin_data: src.bin_data.size_in_bytes(), |
| tiles: src.tiles.size_in_bytes(), |
| seg_counts: src.seg_counts.size_in_bytes(), |
| segments: src.segments.size_in_bytes(), |
| ptcl: src.ptcl.size_in_bytes(), |
| } |
| } |
| } |
