Implement new clipping

Author: LaurenzV

sparse_strips/vello_common/src/clip.rs

@@ -62,6 +62,7 @@ extern crate alloc;
 extern crate std;
 
 pub mod blurred_rounded_rect;
+pub mod clip;
 pub mod coarse;
 #[cfg(feature = "text")]
 pub mod colr;

sparse_strips/vello_common/src/lib.rs

@@ -11,7 +11,7 @@ use alloc::vec::Vec;
 use fearless_simd::*;
 
 /// A strip.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct Strip {
     /// The x coordinate of the strip, in user coordinates.
     pub x: u16,
@@ -44,7 +44,12 @@ impl Strip {
         }
     }
 
-    /// Returns the y coordinate of the strip, in strip units.
+    /// Return whether the strip is a sentinel strip.
+    pub fn is_sentinel(&self) -> bool {
+        self.x == u16::MAX
+    }
+
+    /// Return the y coordinate of the strip, in strip units.
     pub fn strip_y(&self) -> u16 {
         self.y / Tile::HEIGHT
     }

sparse_strips/vello_common/src/strip.rs

@@ -3,6 +3,7 @@
 
 //! Abstraction for generating strips from paths.
 
+use crate::clip::{PathDataRef, intersect};
 use crate::fearless_simd::Level;
 use crate::flatten::{FlattenCtx, Line};
 use crate::kurbo::{Affine, PathEl, Stroke};
@@ -14,7 +15,7 @@ use alloc::vec::Vec;
 use peniko::kurbo::StrokeCtx;
 
 /// A storage for storing strip-related data.
-#[derive(Debug, Default)]
+#[derive(Debug, Default, PartialEq, Eq)]
 pub struct StripStorage {
     /// The strips in the storage.
     pub strips: Vec<Strip>,
@@ -49,15 +50,22 @@ impl StripStorage {
     pub fn is_empty(&self) -> bool {
         self.strips.is_empty() && self.alphas.is_empty()
     }
+
+    /// Extend the current strip storage with the data from another storage.
+    pub fn extend(&mut self, other: &Self) {
+        self.strips.extend(&other.strips);
+        self.alphas.extend(&other.alphas);
+    }
 }
 
 /// An object for easily generating strips for a filled/stroked path.
 #[derive(Debug)]
 pub struct StripGenerator {
-    level: Level,
+    pub(crate) level: Level,
     line_buf: Vec<Line>,
     flatten_ctx: FlattenCtx,
     stroke_ctx: StrokeCtx,
+    temp_storage: StripStorage,
     tiles: Tiles,
     width: u16,
     height: u16,
@@ -72,6 +80,7 @@ impl StripGenerator {
             tiles: Tiles::new(level),
             flatten_ctx: FlattenCtx::default(),
             stroke_ctx: StrokeCtx::default(),
+            temp_storage: StripStorage::default(),
             width,
             height,
         }
@@ -85,6 +94,7 @@ impl StripGenerator {
         transform: Affine,
         aliasing_threshold: Option<u8>,
         strip_storage: &mut StripStorage,
+        clip_path: Option<PathDataRef<'_>>,
     ) {
         flatten::fill(
             self.level,
@@ -93,7 +103,8 @@ impl StripGenerator {
             &mut self.line_buf,
             &mut self.flatten_ctx,
         );
-        self.make_strips(strip_storage, fill_rule, aliasing_threshold);
+
+        self.generate_with_clip(aliasing_threshold, strip_storage, fill_rule, clip_path);
     }
 
     /// Generate the strips for a stroked path.
@@ -104,6 +115,7 @@ impl StripGenerator {
         transform: Affine,
         aliasing_threshold: Option<u8>,
         strip_storage: &mut StripStorage,
+        clip_path: Option<PathDataRef<'_>>,
     ) {
         flatten::stroke(
             self.level,
@@ -114,34 +126,64 @@ impl StripGenerator {
             &mut self.flatten_ctx,
             &mut self.stroke_ctx,
         );
-        self.make_strips(strip_storage, Fill::NonZero, aliasing_threshold);
+        self.generate_with_clip(aliasing_threshold, strip_storage, Fill::NonZero, clip_path);
+    }
+
+    fn generate_with_clip(
+        &mut self,
+        aliasing_threshold: Option<u8>,
+        strip_storage: &mut StripStorage,
+        fill_rule: Fill,
+        clip_path: Option<PathDataRef<'_>>,
+    ) {
+        if strip_storage.generation_mode == GenerationMode::Replace {
+            strip_storage.strips.clear();
+        }
+
+        if let Some(clip_path) = clip_path {
+            self.make_strips(strip_storage, fill_rule, aliasing_threshold, true);
+            let path_data = PathDataRef {
+                strips: &self.temp_storage.strips,
+                alphas: &self.temp_storage.alphas,
+            };
+
+            intersect(self.level, clip_path, path_data, strip_storage);
+        } else {
+            self.make_strips(strip_storage, fill_rule, aliasing_threshold, false);
+        }
     }
 
     /// Reset the strip generator.
     pub fn reset(&mut self) {
         self.line_buf.clear();
         self.tiles.reset();
+        self.temp_storage.clear();
     }
 
     fn make_strips(
         &mut self,
         strip_storage: &mut StripStorage,
         fill_rule: Fill,
         aliasing_threshold: Option<u8>,
+        temp: bool,
     ) {
         self.tiles
             .make_tiles(&self.line_buf, self.width, self.height);
         self.tiles.sort_tiles();
 
-        if strip_storage.generation_mode == GenerationMode::Replace {
-            strip_storage.strips.clear();
-        }
+        let storage = if temp {
+            self.temp_storage.clear();
+
+            &mut self.temp_storage
+        } else {
+            strip_storage
+        };
 
         strip::render(
             self.level,
             &self.tiles,
-            &mut strip_storage.strips,
-            &mut strip_storage.alphas,
+            &mut storage.strips,
+            &mut storage.alphas,
             fill_rule,
             aliasing_threshold,
             &self.line_buf,
@@ -168,6 +210,7 @@ mod tests {
             Affine::IDENTITY,
             None,
             &mut storage,
+            None,
         );
 
         assert!(!generator.line_buf.is_empty());

sparse_strips/vello_common/src/strip_generator.rs

@@ -3,7 +3,7 @@
 
 //! Utility functions.
 
-use fearless_simd::{Simd, f32x16, u8x16};
+use fearless_simd::{Simd, SimdBase, f32x16, u8x16, u8x32, u16x16, u16x32};
 
 /// Convert f32x16 to u8x16.
 #[inline(always)]
@@ -19,3 +19,39 @@ pub fn f32_to_u8<S: Simd>(val: f32x16<S>) -> u8x16<S> {
     let uzp2 = simd.unzip_low_u8x16(p3, p4);
     simd.unzip_low_u8x16(uzp1, uzp2)
 }
+
+/// A trait for implementing a fast approximal division by 255 for integers.
+pub trait Div255Ext {
+    /// Divide by 255.
+    fn div_255(self) -> Self;
+}
+
+impl<S: Simd> Div255Ext for u16x32<S> {
+    #[inline(always)]
+    fn div_255(self) -> Self {
+        let p1 = Self::splat(self.simd, 255);
+        let p2 = self + p1;
+        p2.shr(8)
+    }
+}
+
+impl<S: Simd> Div255Ext for u16x16<S> {
+    #[inline(always)]
+    fn div_255(self) -> Self {
+        let p1 = Self::splat(self.simd, 255);
+        let p2 = self + p1;
+        p2.shr(8)
+    }
+}
+
+/// Perform a normalized multiplication for u8x32.
+#[inline(always)]
+pub fn normalized_mul_u8x32<S: Simd>(a: u8x32<S>, b: u8x32<S>) -> u16x32<S> {
+    (S::widen_u8x32(a.simd, a) * S::widen_u8x32(b.simd, b)).div_255()
+}
+
+/// Perform a normalized multiplication for u8x16.
+#[inline(always)]
+pub fn normalized_mul_u8x16<S: Simd>(a: u8x16<S>, b: u8x16<S>) -> u16x16<S> {
+    (S::widen_u8x16(a.simd, a) * S::widen_u8x16(b.simd, b)).div_255()
+}

sparse_strips/vello_common/src/util.rs

@@ -35,6 +35,14 @@ pub(crate) trait Dispatcher: Debug + Send + Sync {
         paint: Paint,
         aliasing_threshold: Option<u8>,
     );
+    fn push_clip_path(
+        &mut self,
+        path: &BezPath,
+        fill_rule: Fill,
+        transform: Affine,
+        aliasing_threshold: Option<u8>,
+    );
+    fn pop_clip_path(&mut self);
     fn push_layer(
         &mut self,
         clip_path: Option<&BezPath>,

sparse_strips/vello_cpu/src/dispatch/mod.rs

@@ -21,6 +21,7 @@ use std::ops::Range;
 use std::sync::atomic::{AtomicBool, AtomicU8, Ordering};
 use std::sync::{Barrier, Mutex};
 use thread_local::ThreadLocal;
+use vello_common::clip::ClipContext;
 use vello_common::coarse::{Cmd, MODE_CPU, Wide};
 use vello_common::encode::EncodedPaint;
 use vello_common::fearless_simd::{Level, Simd, simd_dispatch};
@@ -49,6 +50,7 @@ type CoarseTaskReceiver = ordered_channel::Receiver<CoarseTask>;
 pub(crate) struct MultiThreadedDispatcher {
     /// The wide tile container.
     wide: Wide,
+    clip_context: ClipContext,
     /// The thread pool that is used for dispatching tasks.
     thread_pool: ThreadPool,
     allocation_group: AllocationGroup,
@@ -141,6 +143,7 @@ impl MultiThreadedDispatcher {
             task_idx,
             flushed,
             workers,
+            clip_context: ClipContext::new(),
             task_sender: None,
             coarse_task_receiver: None,
             strip_generator: StripGenerator::new(width, height, level),
@@ -248,8 +251,13 @@ impl MultiThreadedDispatcher {
         let allocation_group =
             std::mem::replace(&mut self.allocation_group, self.allocations.get());
         let task_sender = self.task_sender.as_mut().unwrap();
+        let clip_path = self.clip_context.get().map(|c| OwnedClip {
+            strips: c.strips.into(),
+            alphas: c.alphas.into(),
+        });
         let task = RenderTask {
             idx: task_idx,
+            clip_path,
             allocation_group,
         };
         task_sender.send(task).unwrap();
@@ -453,6 +461,7 @@ impl Dispatcher for MultiThreadedDispatcher {
 
     fn reset(&mut self) {
         self.wide.reset();
+        self.clip_context.reset();
         self.allocation_group.clear();
         self.batch_cost = 0.0;
         self.task_idx = 0;
@@ -544,6 +553,28 @@ impl Dispatcher for MultiThreadedDispatcher {
     fn strip_storage_mut(&mut self) -> &mut StripStorage {
         &mut self.strip_storage
     }
+
+    fn push_clip_path(
+        &mut self,
+        path: &BezPath,
+        fill_rule: Fill,
+        transform: Affine,
+        aliasing_threshold: Option<u8>,
+    ) {
+        self.flush_tasks();
+        self.clip_context.push_clip(
+            path,
+            &mut self.strip_generator,
+            fill_rule,
+            transform,
+            aliasing_threshold,
+        );
+    }
+
+    fn pop_clip_path(&mut self) {
+        self.flush_tasks();
+        self.clip_context.pop_clip();
+    }
 }
 
 simd_dispatch!(
@@ -596,6 +627,12 @@ impl Debug for MultiThreadedDispatcher {
     }
 }
 
+#[derive(Debug)]
+pub(crate) struct OwnedClip {
+    strips: Box<[Strip]>,
+    alphas: Box<[u8]>,
+}
+
 /// A structure that allows storing and fetching existing allocations.
 struct AllocationManager<T> {
     entries: Vec<Vec<T>>,
@@ -685,6 +722,7 @@ impl AllocationGroup {
 #[derive(Debug)]
 pub(crate) struct RenderTask {
     pub(crate) idx: u32,
+    pub(crate) clip_path: Option<OwnedClip>,
     pub(crate) allocation_group: AllocationGroup,
 }
 

sparse_strips/vello_cpu/src/dispatch/multi_threaded.rs

@@ -6,6 +6,7 @@ use crate::dispatch::multi_threaded::{
     CoarseTask, CoarseTaskSender, CoarseTaskType, RenderTask, RenderTaskType,
 };
 use std::vec::Vec;
+use vello_common::clip::PathDataRef;
 use vello_common::strip_generator::{GenerationMode, StripGenerator, StripStorage};
 
 #[derive(Debug)]
@@ -49,6 +50,10 @@ impl Worker {
         self.strip_storage
             .set_generation_mode(GenerationMode::Append);
         let task_idx = render_task.idx;
+        let path_clip = render_task.clip_path.as_ref().map(|c| PathDataRef {
+            strips: c.strips.as_ref(),
+            alphas: c.alphas.as_ref(),
+        });
 
         for task in render_task
             .allocation_group
@@ -73,6 +78,7 @@ impl Worker {
                         transform,
                         aliasing_threshold,
                         &mut self.strip_storage,
+                        path_clip,
                     );
                     let end = self.strip_storage.strips.len() as u32;
 
@@ -104,6 +110,7 @@ impl Worker {
                         transform,
                         aliasing_threshold,
                         &mut self.strip_storage,
+                        path_clip,
                     );
                     let end = self.strip_storage.strips.len() as u32;
 
@@ -137,6 +144,7 @@ impl Worker {
                             transform,
                             aliasing_threshold,
                             &mut self.strip_storage,
+                            path_clip,
                         );
 
                         let end = self.strip_storage.strips.len() as u32;