From 73cee1842a9638aaeef4a456548a853033e8f29e Mon Sep 17 00:00:00 2001
From: Nixon <voxell.technologies@gmail.com>
Date: Fri, 27 Oct 2023 23:44:55 +0800
Subject: [PATCH 1/9] exp: cubic curve animation

---
 examples/with_bevy/src/main.rs | 124 +++++++++++++++++++++++----------
 1 file changed, 87 insertions(+), 37 deletions(-)

diff --git a/examples/with_bevy/src/main.rs b/examples/with_bevy/src/main.rs
index eb88c4872..61b3f1519 100644
--- a/examples/with_bevy/src/main.rs
+++ b/examples/with_bevy/src/main.rs
@@ -1,5 +1,5 @@
 use bevy::render::{Render, RenderSet};
-use vello::kurbo::{Affine, Point, Rect};
+use vello::kurbo::{Affine, BezPath, PathEl, Point, Rect};
 use vello::peniko::{Color, Fill, Gradient, Stroke};
 use vello::{Renderer, RendererOptions, Scene, SceneBuilder, SceneFragment};
 
@@ -16,6 +16,18 @@ use bevy::{
     },
 };
 
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_plugin(VelloPlugin)
+        .add_systems(Startup, setup)
+        .add_systems(Update, bevy::window::close_on_esc)
+        // .add_systems(Update, cube_rotator_system)
+        .add_plugin(ExtractComponentPlugin::<VelloScene>::default())
+        .add_systems(Update, render_fragment)
+        .run()
+}
+
 #[derive(Resource)]
 struct VelloRenderer(Renderer);
 
@@ -38,7 +50,9 @@ struct VelloPlugin;
 
 impl Plugin for VelloPlugin {
     fn build(&self, app: &mut App) {
-        let Ok(render_app) = app.get_sub_app_mut(RenderApp) else { return };
+        let Ok(render_app) = app.get_sub_app_mut(RenderApp) else {
+            return;
+        };
         render_app.init_resource::<VelloRenderer>();
         // This should probably use the render graph, but working out the dependencies there is awkward
         render_app.add_systems(Render, render_scenes.in_set(RenderSet::Render));
@@ -53,37 +67,33 @@ fn render_scenes(
     queue: Res<RenderQueue>,
 ) {
     for scene in &mut scenes {
-        let gpu_image = gpu_images.get(&scene.1).unwrap();
+        let Some(gpu_image) = gpu_images.get(&scene.1) else {
+            continue;
+        };
+
         let params = vello::RenderParams {
-            base_color: vello::peniko::Color::AQUAMARINE,
+            base_color: vello::peniko::Color::TRANSPARENT,
             width: gpu_image.size.x as u32,
             height: gpu_image.size.y as u32,
         };
         renderer
             .0
             .render_to_texture(
+                // WGPU
                 device.wgpu_device(),
+                // WGPU
                 &*queue,
+                // Vello
                 &scene.0,
+                // WGPU
                 &gpu_image.texture_view,
+                // Vello
                 &params,
             )
             .unwrap();
     }
 }
 
-fn main() {
-    App::new()
-        .add_plugins(DefaultPlugins)
-        .add_plugin(VelloPlugin)
-        .add_systems(Startup, setup)
-        .add_systems(Update, bevy::window::close_on_esc)
-        .add_systems(Update, cube_rotator_system)
-        .add_plugin(ExtractComponentPlugin::<VelloScene>::default())
-        .add_systems(Update, render_fragment)
-        .run()
-}
-
 // Marks the main pass cube, to which the texture is applied.
 #[derive(Component)]
 struct MainPassCube;
@@ -198,36 +208,76 @@ fn cube_rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<Ma
     }
 }
 
-fn render_fragment(mut fragment: Query<&mut VelloFragment>, mut frame: Local<usize>) {
+fn render_fragment(mut fragment: Query<&mut VelloFragment>, mut time: Res<Time>) {
     let mut fragment = fragment.single_mut();
     let mut builder = SceneBuilder::for_fragment(&mut fragment.0);
-    render_brush_transform(&mut builder, *frame);
-    *frame += 1;
+    render_brush_transform(&mut builder, time.elapsed_seconds_f64());
+    // *time += 1;
 }
 
-fn render_brush_transform(sb: &mut SceneBuilder, i: usize) {
-    let th = (std::f64::consts::PI / 180.0) * (i as f64);
-    let linear = Gradient::new_linear((0.0, 0.0), (0.0, 200.0)).with_stops([
-        Color::RED,
-        Color::GREEN,
-        Color::BLUE,
-    ]);
+fn render_brush_transform(sb: &mut SceneBuilder, time: f64) {
+    // let th = (std::f64::consts::PI / 180.0) * (i as f64);
+    // let linear = Gradient::new_linear((0.0, 0.0), (0.0, 200.0)).with_stops([
+    //     Color::RED,
+    //     Color::GREEN,
+    //     Color::BLUE,
+    // ]);
+
+    let fill_color = Color::CHARTREUSE;
+    let stroke_color = Color::ORCHID;
+
+    let start_point: Point = Point::default();
+
+    let origin_curve: PathEl = PathEl::CurveTo(
+        Point::new(0.0, 100.0),
+        Point::new(100.0, 0.0),
+        Point::new(100.0, 100.0),
+    );
+
+    let percent: f64 = time.sin().mul_add(0.5, 0.5);
+    let new_curve: PathEl;
+
+    match origin_curve {
+        PathEl::CurveTo(b, c, d) => {
+            let ab = Point::lerp(start_point, b, percent);
+            let bc = Point::lerp(b, c, percent);
+            let cd = Point::lerp(c, d, percent);
+
+            let abc = Point::lerp(ab, bc, percent);
+            let bcd = Point::lerp(bc, cd, percent);
+
+            let abcd = Point::lerp(abc, bcd, percent);
+
+            new_curve = PathEl::CurveTo(ab, abc, abcd);
+        }
+        _ => {
+            return;
+        }
+    }
+
+    let path = BezPath::from_vec(vec![PathEl::MoveTo(start_point), new_curve]);
+
     sb.fill(
         Fill::NonZero,
-        Affine::translate((106.0, 106.0)),
-        &linear,
-        Some(around_center(Affine::rotate(th), Point::new(150.0, 150.0))),
+        Affine::IDENTITY,
+        &fill_color,
+        // &linear,
+        None,
+        // Some(around_center(Affine::rotate(th), Point::new(150.0, 150.0))),
         &Rect::from_origin_size(Point::default(), (300.0, 300.0)),
     );
     sb.stroke(
-        &Stroke::new(106.0),
-        Affine::IDENTITY,
-        &linear,
-        Some(around_center(
-            Affine::rotate(th + std::f64::consts::PI / 2.),
-            Point::new(176.5, 176.5),
-        )),
-        &Rect::from_origin_size(Point::new(53.0, 53.0), (406.0, 406.0)),
+        &Stroke::new(10.0),
+        Affine::translate((106.0, 106.0)),
+        &stroke_color,
+        // &linear,
+        None,
+        // Some(around_center(
+        //     Affine::rotate(th + std::f64::consts::PI / 2.),
+        //     Point::new(176.5, 176.5),
+        // )),
+        // &Rect::from_origin_size(Point::new(53.0, 53.0), (406.0, 406.0)),
+        &path,
     );
 }
 

From 924d04779a0b125d7518310898c24368341639d0 Mon Sep 17 00:00:00 2001
From: Nixon <voxell.technologies@gmail.com>
Date: Sat, 28 Oct 2023 11:47:34 +0800
Subject: [PATCH 2/9] feat: add interpolate pathel func

---
 examples/with_bevy/src/main.rs    | 51 +++++++++++++++++++++++++--
 integrations/vello_svg/src/lib.rs | 58 +++++++++++++++++++++++++++++++
 2 files changed, 106 insertions(+), 3 deletions(-)

diff --git a/examples/with_bevy/src/main.rs b/examples/with_bevy/src/main.rs
index 61b3f1519..be5471ecf 100644
--- a/examples/with_bevy/src/main.rs
+++ b/examples/with_bevy/src/main.rs
@@ -1,6 +1,7 @@
 use bevy::render::{Render, RenderSet};
-use vello::kurbo::{Affine, BezPath, PathEl, Point, Rect};
-use vello::peniko::{Color, Fill, Gradient, Stroke};
+use vello::fello::raw::tables::glyf::ToPathError;
+use vello::kurbo::{Affine, BezPath, PathEl, Point, Rect, Shape};
+use vello::peniko::{Color, Fill, Gradient, Join, Stroke};
 use vello::{Renderer, RendererOptions, Scene, SceneBuilder, SceneFragment};
 
 use bevy::{
@@ -277,10 +278,54 @@ fn render_brush_transform(sb: &mut SceneBuilder, time: f64) {
         //     Point::new(176.5, 176.5),
         // )),
         // &Rect::from_origin_size(Point::new(53.0, 53.0), (406.0, 406.0)),
-        &path,
+        &path.elements(),
     );
 }
 
 fn around_center(xform: Affine, center: Point) -> Affine {
     Affine::translate(center.to_vec2()) * xform * Affine::translate(-center.to_vec2())
 }
+
+// TODO
+pub fn interpolate_bezpath(path: BezPath, t: f64) {}
+
+pub fn interpolate_pathel(path0: PathEl, path1: PathEl, t: f64) -> Option<PathEl> {
+    let a: Point;
+    match path0 {
+        PathEl::MoveTo(p) => a = p,
+        PathEl::LineTo(p) => a = p,
+        PathEl::QuadTo(_, p) => a = p,
+        PathEl::CurveTo(_, _, p) => a = p,
+        PathEl::ClosePath => return None,
+    }
+
+    let path: PathEl;
+
+    match path1 {
+        PathEl::MoveTo(_) => return None,
+        PathEl::LineTo(b) => path = PathEl::LineTo(Point::lerp(a, b, t)),
+        PathEl::QuadTo(b, c) => {
+            let ab: Point = Point::lerp(a, b, t);
+            let bc: Point = Point::lerp(b, c, t);
+
+            let abc: Point = Point::lerp(ab, bc, t);
+
+            path = PathEl::QuadTo(ab, abc);
+        }
+        PathEl::CurveTo(b, c, d) => {
+            let ab = Point::lerp(a, b, t);
+            let bc = Point::lerp(b, c, t);
+            let cd = Point::lerp(c, d, t);
+
+            let abc = Point::lerp(ab, bc, t);
+            let bcd = Point::lerp(bc, cd, t);
+
+            let abcd = Point::lerp(abc, bcd, t);
+
+            path = PathEl::CurveTo(ab, abc, abcd);
+        }
+        PathEl::ClosePath => return None,
+    }
+
+    Some(path)
+}
diff --git a/integrations/vello_svg/src/lib.rs b/integrations/vello_svg/src/lib.rs
index 894f812d9..74742831d 100644
--- a/integrations/vello_svg/src/lib.rs
+++ b/integrations/vello_svg/src/lib.rs
@@ -146,6 +146,64 @@ pub fn render_tree_with<F: FnMut(&mut SceneBuilder, &usvg::Node) -> Result<(), E
     Ok(())
 }
 
+pub fn tree_to_bezpath(svg: &usvg::Tree) {
+    for elt in svg.root.descendants() {
+        let transform = {
+            let usvg::Transform { a, b, c, d, e, f } = elt.abs_transform();
+            Affine::new([a, b, c, d, e, f])
+        };
+        match &*elt.borrow() {
+            usvg::NodeKind::Group(_) => {}
+            usvg::NodeKind::Path(path) => {
+                let mut local_path = BezPath::new();
+                // The semantics of SVG paths don't line up with `BezPath`; we must manually track initial points
+                let mut just_closed = false;
+                let mut most_recent_initial = (0., 0.);
+                for elt in path.data.segments() {
+                    match elt {
+                        usvg::PathSegment::MoveTo { x, y } => {
+                            if std::mem::take(&mut just_closed) {
+                                local_path.move_to(most_recent_initial);
+                            }
+                            most_recent_initial = (x, y);
+                            local_path.move_to(most_recent_initial)
+                        }
+                        usvg::PathSegment::LineTo { x, y } => {
+                            if std::mem::take(&mut just_closed) {
+                                local_path.move_to(most_recent_initial);
+                            }
+                            local_path.line_to((x, y))
+                        }
+                        usvg::PathSegment::CurveTo {
+                            x1,
+                            y1,
+                            x2,
+                            y2,
+                            x,
+                            y,
+                        } => {
+                            if std::mem::take(&mut just_closed) {
+                                local_path.move_to(most_recent_initial);
+                            }
+                            local_path.curve_to((x1, y1), (x2, y2), (x, y))
+                        }
+                        usvg::PathSegment::ClosePath => {
+                            just_closed = true;
+                            local_path.close_path()
+                        }
+                    }
+                }
+            }
+            usvg::NodeKind::Image(_) => {
+                // on_err(sb, &elt)?;
+            }
+            usvg::NodeKind::Text(_) => {
+                // on_err(sb, &elt)?;
+            }
+        }
+    }
+}
+
 /// Error handler function for [`render_tree_with`] which draws a transparent red box
 /// instead of unsupported SVG features
 pub fn default_error_handler(sb: &mut SceneBuilder, node: &usvg::Node) -> Result<(), Infallible> {

From 4fa284abf0db502b0a161dc1585f501e687e71bd Mon Sep 17 00:00:00 2001
From: Nixon <voxell.technologies@gmail.com>
Date: Sat, 28 Oct 2023 14:31:52 +0800
Subject: [PATCH 3/9] feat: bevy example working with latest bevy main branch
 commit

---
 Cargo.toml                     |  2 +-
 examples/with_bevy/Cargo.toml  |  2 +-
 examples/with_bevy/src/main.rs | 13 +++++++++----
 src/wgpu_engine.rs             |  2 ++
 4 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index ba4c92124..0150c4ae2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,7 +9,7 @@ members = [
 
     "examples/headless",
     "examples/with_winit",
-    # "examples/with_bevy", # Disable for now until bevy is using wgpu 0.17
+    "examples/with_bevy", # Disable for now until bevy is using wgpu 0.17
     "examples/run_wasm",
     "examples/scenes",
 ]
diff --git a/examples/with_bevy/Cargo.toml b/examples/with_bevy/Cargo.toml
index 1257adc9e..4b4a37d71 100644
--- a/examples/with_bevy/Cargo.toml
+++ b/examples/with_bevy/Cargo.toml
@@ -10,5 +10,5 @@ repository.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy = "0.11"
+bevy = { git = "https://github.com/bevyengine/bevy" }
 vello = { path = "../../" }
diff --git a/examples/with_bevy/src/main.rs b/examples/with_bevy/src/main.rs
index 39d50d59f..5f9bd40a9 100644
--- a/examples/with_bevy/src/main.rs
+++ b/examples/with_bevy/src/main.rs
@@ -1,6 +1,6 @@
 use bevy::render::{Render, RenderSet};
-use vello::kurbo::{Affine, Point, Rect};
-use vello::peniko::{Color, Fill, Gradient, Stroke};
+use vello::kurbo::{Affine, Point, Rect, Stroke};
+use vello::peniko::{Color, Fill, Gradient};
 use vello::{Renderer, RendererOptions, Scene, SceneBuilder, SceneFragment};
 
 use bevy::{
@@ -30,6 +30,7 @@ impl FromWorld for VelloRenderer {
                 &RendererOptions {
                     surface_format: None,
                     timestamp_period: queue.0.get_timestamp_period(),
+                    use_cpu: false,
                 },
             )
             .unwrap(),
@@ -41,13 +42,17 @@ struct VelloPlugin;
 
 impl Plugin for VelloPlugin {
     fn build(&self, app: &mut App) {
-        let Ok(render_app) = app.get_sub_app_mut(RenderApp) else { return };
+        let Ok(render_app) = app.get_sub_app_mut(RenderApp) else {
+            return;
+        };
         // This should probably use the render graph, but working out the dependencies there is awkward
         render_app.add_systems(Render, render_scenes.in_set(RenderSet::Render));
     }
 
     fn finish(&self, app: &mut App) {
-        let Ok(render_app) = app.get_sub_app_mut(RenderApp) else { return };
+        let Ok(render_app) = app.get_sub_app_mut(RenderApp) else {
+            return;
+        };
         render_app.init_resource::<VelloRenderer>();
     }
 }
diff --git a/src/wgpu_engine.rs b/src/wgpu_engine.rs
index c5359c1bb..03c76b595 100644
--- a/src/wgpu_engine.rs
+++ b/src/wgpu_engine.rs
@@ -52,6 +52,8 @@ struct BindMapBuffer {
     label: &'static str,
 }
 
+unsafe impl Sync for BindMapBuffer {}
+
 #[derive(Default)]
 struct BindMap {
     buf_map: HashMap<Id, BindMapBuffer>,

From 42be8f33a13e084c8ba14f2ca76f3180ef4e93a5 Mon Sep 17 00:00:00 2001
From: Nixon <voxell.technologies@gmail.com>
Date: Sat, 28 Oct 2023 14:35:23 +0800
Subject: [PATCH 4/9] chore: use a fix git rev for stability reasons

---
 examples/with_bevy/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/with_bevy/Cargo.toml b/examples/with_bevy/Cargo.toml
index 4b4a37d71..29317a371 100644
--- a/examples/with_bevy/Cargo.toml
+++ b/examples/with_bevy/Cargo.toml
@@ -10,5 +10,5 @@ repository.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy = { git = "https://github.com/bevyengine/bevy" }
+bevy = { git = "https://github.com/bevyengine/bevy", rev = "7ca0a307f6d6277168a5e77f3b15fbeefbaf478e" }
 vello = { path = "../../" }

From 0db428cca9c03fdb21171e1c2f575de518382d4e Mon Sep 17 00:00:00 2001
From: Nixon <voxell.technologies@gmail.com>
Date: Sat, 28 Oct 2023 14:40:51 +0800
Subject: [PATCH 5/9] chore: add comment to caution potential breaking changes

---
 src/wgpu_engine.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/wgpu_engine.rs b/src/wgpu_engine.rs
index 03c76b595..00fa3271b 100644
--- a/src/wgpu_engine.rs
+++ b/src/wgpu_engine.rs
@@ -52,6 +52,7 @@ struct BindMapBuffer {
     label: &'static str,
 }
 
+// Prevent Bevy from complaining when used as a resource
 unsafe impl Sync for BindMapBuffer {}
 
 #[derive(Default)]

From 11be20c345211d0599cd1bde6e6bf4108fc67eb0 Mon Sep 17 00:00:00 2001
From: Nixon <voxell.technologies@gmail.com>
Date: Sun, 29 Oct 2023 11:43:41 +0800
Subject: [PATCH 6/9] feat: remove tree_to_bezpath function

---
 integrations/vello_svg/src/lib.rs | 58 -------------------------------
 1 file changed, 58 deletions(-)

diff --git a/integrations/vello_svg/src/lib.rs b/integrations/vello_svg/src/lib.rs
index cf243adc9..2aa3a87d5 100644
--- a/integrations/vello_svg/src/lib.rs
+++ b/integrations/vello_svg/src/lib.rs
@@ -155,64 +155,6 @@ pub fn render_tree_with<F: FnMut(&mut SceneBuilder, &usvg::Node) -> Result<(), E
     Ok(())
 }
 
-pub fn tree_to_bezpath(svg: &usvg::Tree) {
-    for elt in svg.root.descendants() {
-        let transform = {
-            let usvg::Transform { a, b, c, d, e, f } = elt.abs_transform();
-            Affine::new([a, b, c, d, e, f])
-        };
-        match &*elt.borrow() {
-            usvg::NodeKind::Group(_) => {}
-            usvg::NodeKind::Path(path) => {
-                let mut local_path = BezPath::new();
-                // The semantics of SVG paths don't line up with `BezPath`; we must manually track initial points
-                let mut just_closed = false;
-                let mut most_recent_initial = (0., 0.);
-                for elt in path.data.segments() {
-                    match elt {
-                        usvg::PathSegment::MoveTo { x, y } => {
-                            if std::mem::take(&mut just_closed) {
-                                local_path.move_to(most_recent_initial);
-                            }
-                            most_recent_initial = (x, y);
-                            local_path.move_to(most_recent_initial)
-                        }
-                        usvg::PathSegment::LineTo { x, y } => {
-                            if std::mem::take(&mut just_closed) {
-                                local_path.move_to(most_recent_initial);
-                            }
-                            local_path.line_to((x, y))
-                        }
-                        usvg::PathSegment::CurveTo {
-                            x1,
-                            y1,
-                            x2,
-                            y2,
-                            x,
-                            y,
-                        } => {
-                            if std::mem::take(&mut just_closed) {
-                                local_path.move_to(most_recent_initial);
-                            }
-                            local_path.curve_to((x1, y1), (x2, y2), (x, y))
-                        }
-                        usvg::PathSegment::ClosePath => {
-                            just_closed = true;
-                            local_path.close_path()
-                        }
-                    }
-                }
-            }
-            usvg::NodeKind::Image(_) => {
-                // on_err(sb, &elt)?;
-            }
-            usvg::NodeKind::Text(_) => {
-                // on_err(sb, &elt)?;
-            }
-        }
-    }
-}
-
 /// Error handler function for [`render_tree_with`] which draws a transparent red box
 /// instead of unsupported SVG features
 pub fn default_error_handler(sb: &mut SceneBuilder, node: &usvg::Node) -> Result<(), Infallible> {

From 8ff303de6b8eb8df4573cda04f205dfb269bb594 Mon Sep 17 00:00:00 2001
From: Nixon <voxell.technologies@gmail.com>
Date: Sun, 5 Nov 2023 13:20:15 +0800
Subject: [PATCH 7/9] feat: reenable with_bevy package demo as bevy 0.12 now
 supports wgpu 0.17, update with_bevy demo to support bevy 0.12

---
 Cargo.toml                     |  2 +-
 examples/with_bevy/Cargo.toml  |  2 +-
 examples/with_bevy/src/main.rs | 17 ++++++++++++-----
 src/wgpu_engine.rs             |  3 ---
 4 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 0150c4ae2..ed84f934b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,7 +9,7 @@ members = [
 
     "examples/headless",
     "examples/with_winit",
-    "examples/with_bevy", # Disable for now until bevy is using wgpu 0.17
+    "examples/with_bevy",
     "examples/run_wasm",
     "examples/scenes",
 ]
diff --git a/examples/with_bevy/Cargo.toml b/examples/with_bevy/Cargo.toml
index 29317a371..df668cae9 100644
--- a/examples/with_bevy/Cargo.toml
+++ b/examples/with_bevy/Cargo.toml
@@ -10,5 +10,5 @@ repository.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy = { git = "https://github.com/bevyengine/bevy", rev = "7ca0a307f6d6277168a5e77f3b15fbeefbaf478e" }
+bevy = "0.12"
 vello = { path = "../../" }
diff --git a/examples/with_bevy/src/main.rs b/examples/with_bevy/src/main.rs
index 9ddf875c7..dfd370c37 100644
--- a/examples/with_bevy/src/main.rs
+++ b/examples/with_bevy/src/main.rs
@@ -1,6 +1,6 @@
 use bevy::render::{Render, RenderSet};
-use vello::kurbo::{Affine, Point, Rect};
-use vello::peniko::{Color, Fill, Gradient, Stroke};
+use vello::kurbo::{Affine, Point, Rect, Stroke};
+use vello::peniko::{Color, Fill, Gradient};
 use vello::{Renderer, RendererOptions, Scene, SceneBuilder, SceneFragment};
 
 use bevy::{
@@ -19,6 +19,8 @@ use bevy::{
 #[derive(Resource)]
 struct VelloRenderer(Renderer);
 
+unsafe impl Sync for VelloRenderer {}
+
 impl FromWorld for VelloRenderer {
     fn from_world(world: &mut World) -> Self {
         let device = world.resource::<RenderDevice>();
@@ -27,10 +29,11 @@ impl FromWorld for VelloRenderer {
         VelloRenderer(
             Renderer::new(
                 device.wgpu_device(),
-                &RendererOptions {
+                RendererOptions {
                     surface_format: None,
                     timestamp_period: queue.0.get_timestamp_period(),
                     antialiasing_support: vello::AaSupport::area_only(),
+                    use_cpu: false,
                 },
             )
             .unwrap(),
@@ -42,13 +45,17 @@ struct VelloPlugin;
 
 impl Plugin for VelloPlugin {
     fn build(&self, app: &mut App) {
-        let Ok(render_app) = app.get_sub_app_mut(RenderApp) else { return };
+        let Ok(render_app) = app.get_sub_app_mut(RenderApp) else {
+            return;
+        };
         // This should probably use the render graph, but working out the dependencies there is awkward
         render_app.add_systems(Render, render_scenes.in_set(RenderSet::Render));
     }
 
     fn finish(&self, app: &mut App) {
-        let Ok(render_app) = app.get_sub_app_mut(RenderApp) else { return };
+        let Ok(render_app) = app.get_sub_app_mut(RenderApp) else {
+            return;
+        };
         render_app.init_resource::<VelloRenderer>();
     }
 }
diff --git a/src/wgpu_engine.rs b/src/wgpu_engine.rs
index 4266ef269..101535211 100644
--- a/src/wgpu_engine.rs
+++ b/src/wgpu_engine.rs
@@ -85,9 +85,6 @@ struct BindMapBuffer {
     label: &'static str,
 }
 
-// Prevent Bevy from complaining when used as a resource
-unsafe impl Sync for BindMapBuffer {}
-
 #[derive(Default)]
 struct BindMap {
     buf_map: HashMap<Id, BindMapBuffer>,

From 3e94a2e5762506ae2e95457c0864f376cdb896a8 Mon Sep 17 00:00:00 2001
From: Nixon <voxell.technologies@gmail.com>
Date: Sun, 5 Nov 2023 21:28:12 +0800
Subject: [PATCH 8/9] chore: reduce features of bevy to the minimum required
 set

---
 examples/with_bevy/Cargo.toml | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/examples/with_bevy/Cargo.toml b/examples/with_bevy/Cargo.toml
index df668cae9..91b3e64f5 100644
--- a/examples/with_bevy/Cargo.toml
+++ b/examples/with_bevy/Cargo.toml
@@ -10,5 +10,14 @@ repository.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy = "0.12"
+bevy = { version = "0.12", features = [
+    "bevy_winit",
+    "bevy_core_pipeline",
+    "bevy_pbr",
+    "bevy_render",
+    "multi-threaded",
+    "x11",
+    "tonemapping_luts",
+  ], default-features = false }
+
 vello = { path = "../../" }

From cb56730235b546aca6aa311d29f11f934c9851eb Mon Sep 17 00:00:00 2001
From: Nixon <voxell.technologies@gmail.com>
Date: Mon, 6 Nov 2023 00:04:05 +0800
Subject: [PATCH 9/9] feat: use SyncCell

---
 examples/with_bevy/src/main.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/examples/with_bevy/src/main.rs b/examples/with_bevy/src/main.rs
index dfd370c37..4180c687a 100644
--- a/examples/with_bevy/src/main.rs
+++ b/examples/with_bevy/src/main.rs
@@ -1,4 +1,5 @@
 use bevy::render::{Render, RenderSet};
+use bevy::utils::synccell::SyncCell;
 use vello::kurbo::{Affine, Point, Rect, Stroke};
 use vello::peniko::{Color, Fill, Gradient};
 use vello::{Renderer, RendererOptions, Scene, SceneBuilder, SceneFragment};
@@ -17,16 +18,14 @@ use bevy::{
 };
 
 #[derive(Resource)]
-struct VelloRenderer(Renderer);
-
-unsafe impl Sync for VelloRenderer {}
+struct VelloRenderer(SyncCell<Renderer>);
 
 impl FromWorld for VelloRenderer {
     fn from_world(world: &mut World) -> Self {
         let device = world.resource::<RenderDevice>();
         let queue = world.resource::<RenderQueue>();
 
-        VelloRenderer(
+        VelloRenderer(SyncCell::new(
             Renderer::new(
                 device.wgpu_device(),
                 RendererOptions {
@@ -37,7 +36,7 @@ impl FromWorld for VelloRenderer {
                 },
             )
             .unwrap(),
-        )
+        ))
     }
 }
 
@@ -77,6 +76,7 @@ fn render_scenes(
         };
         renderer
             .0
+            .get()
             .render_to_texture(
                 device.wgpu_device(),
                 &queue,