Add kurbo conversions to scene API

piet-scene/Cargo.toml

@@ -7,5 +7,5 @@ edition = "2021"
 [dependencies]
 bytemuck = { version = "1.7.2", features = ["derive"] }
 smallvec = "1.8.0"
-pinot = "0.1.5"
-moscato = "0.1.2"
+moscato = { git = "https://github.com/dfrg/pinot" }
+kurbo = { version = "0.8.3", optional = true }

piet-scene/src/glyph/mod.rs

@@ -14,7 +14,7 @@
 //
 // Also licensed under MIT license, at your choice.
 
-pub use pinot;
+pub use moscato::pinot;
 
 use crate::brush::{Brush, Color};
 use crate::geometry::Affine;

piet-scene/src/lib.rs

@@ -20,3 +20,96 @@ pub mod glyph;
 pub mod path;
 pub mod resource;
 pub mod scene;
+
+/// Implement conversions to and from Kurbo types when the `kurbo` feature is
+/// enabled.
+#[cfg(feature = "kurbo")]
+mod kurbo_conv {
+    use super::geometry::{Affine, Point, Rect};
+    use super::path::Element;
+
+    impl From<kurbo::Point> for Point {
+        fn from(p: kurbo::Point) -> Self {
+            Self::new(p.x as f32, p.y as f32)
+        }
+    }
+
+    impl From<Point> for kurbo::Point {
+        fn from(p: Point) -> kurbo::Point {
+            Self::new(p.x as f64, p.y as f64)
+        }
+    }
+
+    impl From<kurbo::Affine> for Affine {
+        fn from(a: kurbo::Affine) -> Self {
+            let c = a.as_coeffs();
+            Self {
+                xx: c[0] as f32,
+                yx: c[1] as f32,
+                xy: c[2] as f32,
+                yy: c[3] as f32,
+                dx: c[4] as f32,
+                dy: c[5] as f32,
+            }
+        }
+    }
+
+    impl From<Affine> for kurbo::Affine {
+        fn from(a: Affine) -> Self {
+            Self::new([
+                a.xx as f64,
+                a.yx as f64,
+                a.yx as f64,
+                a.yy as f64,
+                a.dx as f64,
+                a.dy as f64,
+            ])
+        }
+    }
+
+    impl From<kurbo::Rect> for Rect {
+        fn from(r: kurbo::Rect) -> Self {
+            Self {
+                min: Point::new(r.x0 as f32, r.y0 as f32),
+                max: Point::new(r.x1 as f32, r.y1 as f32),
+            }
+        }
+    }
+
+    impl From<Rect> for kurbo::Rect {
+        fn from(r: Rect) -> Self {
+            Self {
+                x0: r.min.x as f64,
+                y0: r.min.y as f64,
+                x1: r.max.x as f64,
+                y1: r.max.y as f64,
+            }
+        }
+    }
+
+    impl From<kurbo::PathEl> for Element {
+        fn from(e: kurbo::PathEl) -> Self {
+            use kurbo::PathEl::*;
+            match e {
+                MoveTo(p0) => Self::MoveTo(p0.into()),
+                LineTo(p0) => Self::LineTo(p0.into()),
+                QuadTo(p0, p1) => Self::QuadTo(p0.into(), p1.into()),
+                CurveTo(p0, p1, p2) => Self::CurveTo(p0.into(), p1.into(), p2.into()),
+                ClosePath => Self::Close,
+            }
+        }
+    }
+
+    impl From<Element> for kurbo::PathEl {
+        fn from(e: Element) -> Self {
+            use Element::*;
+            match e {
+                MoveTo(p0) => Self::MoveTo(p0.into()),
+                LineTo(p0) => Self::LineTo(p0.into()),
+                QuadTo(p0, p1) => Self::QuadTo(p0.into(), p1.into()),
+                CurveTo(p0, p1, p2) => Self::CurveTo(p0.into(), p1.into(), p2.into()),
+                Close => Self::ClosePath,
+            }
+        }
+    }
+}

piet-scene/src/scene/blend.rs

@@ -53,8 +53,7 @@ pub enum Compose {
     DestAtop = 10,
     Xor = 11,
     Plus = 12,
-    PlusDarker = 13,
-    PlusLighter = 14,
+    PlusLighter = 13,
 }
 
 /// Blend mode consisting of mixing and composition functions.

piet-scene/src/scene/builder.rs

@@ -24,8 +24,8 @@ use core::borrow::Borrow;
 const MAX_BLEND_STACK: usize = 256;
 
 /// Creates a new builder for constructing a scene.
-pub fn build_scene<'a>(scene: &'a mut Scene, resources: &'a mut ResourceContext) -> Builder<'a> {
-    Builder::new(&mut scene.data, ResourceData::Scene(resources))
+pub fn build_scene<'a>(scene: &'a mut Scene, rcx: &'a mut ResourceContext) -> Builder<'a> {
+    Builder::new(&mut scene.data, ResourceData::Scene(rcx))
 }
 
 /// Creates a new builder for construction a scene fragment.
@@ -62,7 +62,8 @@ impl<'a> Builder<'a> {
     }
 
     /// Pushes a transform matrix onto the stack.
-    pub fn push_transform(&mut self, transform: Affine) {
+    pub fn push_transform(&mut self, transform: impl Into<Affine>) {
+        let transform = transform.into();
         self.transform(transform);
         self.transforms.push(transform);
     }

piet-scene/src/scene/mod.rs

@@ -23,11 +23,13 @@ pub use builder::{build_fragment, build_scene, Builder};
 pub use style::*;
 
 use super::brush::*;
-use super::geometry::{Affine, Point, Rect};
+use super::geometry::{Affine, Point};
 use super::path::Element;
+use super::resource::ResourceContext;
 
 use core::ops::Range;
 
+/// Raw data streams describing an encoded scene.
 #[derive(Default)]
 pub struct SceneData {
     pub transform_stream: Vec<Affine>,
@@ -83,6 +85,13 @@ pub struct Scene {
 }
 
 impl Scene {
+    /// Creates a new builder for filling the scene. Any current content in
+    /// the scene is cleared.
+    pub fn build<'a>(&'a mut self, rcx: &'a mut ResourceContext) -> Builder<'a> {
+        build_scene(self, rcx)
+    }
+
+    /// Returns the raw encoded scene data streams.
     pub fn data(&self) -> &SceneData {
         &self.data
     }
@@ -96,9 +105,17 @@ pub struct Fragment {
 }
 
 impl Fragment {
+    /// Returns the underlying stream of points that defined all encoded path
+    /// segments.
     pub fn points(&self) -> &[Point] {
         bytemuck::cast_slice(&self.data.pathseg_stream)
     }
+
+    /// Creates a new builder for filling the fragment. Any current content in
+    /// the fragment is cleared.
+    pub fn build<'a>(&'a mut self) -> Builder<'a> {
+        build_fragment(self)
+    }
 }
 
 #[derive(Default)]