From 7c28ad65a6837f66895b6875428ac244c0c6dd77 Mon Sep 17 00:00:00 2001
From: "Spencer C. Imbleau" <spencer@imbleau.com>
Date: Sun, 4 Aug 2024 12:21:01 -0400
Subject: [PATCH 1/8] refactor: cleanup

---
 CHANGELOG.md                       |  2 +
 examples/cube3d/src/main.rs        | 20 +++++++--
 examples/render_layers/src/main.rs | 48 ++++++----------------
 src/lib.rs                         | 18 +--------
 src/plugin.rs                      | 49 +++++++++++++++++-----
 src/render/mod.rs                  | 39 ++++++++++++++++--
 src/render/plugin.rs               | 65 +++++++++++++++---------------
 src/render/systems.rs              | 37 ++++++-----------
 8 files changed, 150 insertions(+), 128 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 48b02c8..e8a9dff 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,6 +15,7 @@ Subheadings to categorize changes are `added, changed, deprecated, removed, fixe
 - There is now a `default_font` feature that uses the same `FiraMono-subset.ttf` font used in the bevy/default_font feature.
 - There is now a `render_layers` example.
 - There is now a `cube_3d` example.
+- Added `VelloRenderer::from_device` to create a renderer manually.
 
 ### Changed
 
@@ -32,6 +33,7 @@ Subheadings to categorize changes are `added, changed, deprecated, removed, fixe
 ### Removed
 
 - Removed `ZFunction`s from the render pipeline. Now ordering is based solely on the `Transform`'s z component. If you dependeded on this behavior, you'll need to adjust the transform Z in a system prior to render.
+- Removed `VelloCanvasMaterial` from prelude, as it's not typically meant to be used under normal circumstances and could be a common footgun.
 
 ### Fixed
 
diff --git a/examples/cube3d/src/main.rs b/examples/cube3d/src/main.rs
index 11cf294..fceccb4 100644
--- a/examples/cube3d/src/main.rs
+++ b/examples/cube3d/src/main.rs
@@ -11,7 +11,11 @@ use bevy::{
         Render, RenderApp, RenderSet,
     },
 };
-use bevy_vello::{prelude::*, render::VelloRenderer, VelloPlugin};
+use bevy_vello::{
+    prelude::*,
+    render::{VelloRenderPlugin, VelloRenderer},
+    VelloPlugin,
+};
 
 #[derive(Component)]
 pub struct VelloTarget(Handle<Image>);
@@ -33,7 +37,7 @@ fn main() {
     let mut app = App::new();
 
     app.add_plugins(DefaultPlugins)
-        .add_plugins(VelloPlugin::default())
+        .add_plugins(VelloRenderPlugin::default())
         .add_systems(Startup, setup)
         .add_systems(Update, cube_rotator_system)
         .add_plugins(ExtractComponentPlugin::<VelloTarget>::default());
@@ -122,8 +126,16 @@ fn render_texture(
     queue: Res<RenderQueue>,
     time: Res<Time>,
 ) {
-    let renderer =
-        vello_renderer.get_or_insert_with(|| VelloRenderer::from_device(device.wgpu_device()));
+    let renderer = vello_renderer.get_or_insert_with(|| {
+        VelloRenderer::from_device(
+            device.wgpu_device(),
+            &VelloRenderSettings {
+                use_cpu: false,
+                antialiasing: vello::AaConfig::Msaa8,
+                ..default()
+            },
+        )
+    });
     let target = target.single();
 
     let mut scene = VelloScene::default();
diff --git a/examples/render_layers/src/main.rs b/examples/render_layers/src/main.rs
index 84a328a..94f095d 100644
--- a/examples/render_layers/src/main.rs
+++ b/examples/render_layers/src/main.rs
@@ -6,16 +6,11 @@ use bevy_vello::{prelude::*, VelloPlugin};
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_plugins(VelloPlugin::default())
-        .add_systems(
-            Startup,
-            (
-                setup_canvas,
-                setup_gizmos,
-                setup_animation,
-                setup_background,
-            ),
-        )
+        .add_plugins(VelloPlugin {
+            canvas_render_layers: RenderLayers::layer(1).with(2),
+            ..default()
+        })
+        .add_systems(Startup, (setup_gizmos, setup_scene))
         .add_systems(Update, (animation, background, run_gizmos))
         .run();
 }
@@ -28,11 +23,6 @@ struct AnimationScene;
 #[derive(Component)]
 struct BackgroundScene;
 
-fn setup_canvas(mut settings: ResMut<VelloRenderSettings>) {
-    // There's only 1 Vello canvas, so as long as you use a layer that has a camera, you're good!
-    settings.canvas_render_layers = RenderLayers::layer(3); // the gizmo camera layer
-}
-
 fn setup_gizmos(mut commands: Commands, mut config_store: ResMut<GizmoConfigStore>) {
     // This camera can only see Gizmos.
     commands.spawn((
@@ -50,42 +40,28 @@ fn setup_gizmos(mut commands: Commands, mut config_store: ResMut<GizmoConfigStor
     config.render_layers = RenderLayers::layer(3);
 }
 
-fn setup_animation(mut commands: Commands) {
+fn setup_scene(mut commands: Commands) {
     commands.spawn((
         Camera2dBundle {
             camera: Camera {
-                // This camera will render AFTER the blue background camera!
-                order: 0,
+                // This camera will render first.
+                order: -1,
                 ..default()
             },
             ..default()
         },
-        RenderLayers::layer(2),
+        RenderLayers::layer(1).with(2),
     ));
 
     commands.spawn((
         VelloSceneBundle::default(),
-        AnimationScene,
-        RenderLayers::layer(2),
-    ));
-}
-
-fn setup_background(mut commands: Commands) {
-    commands.spawn((
-        Camera2dBundle {
-            camera: Camera {
-                // Render first
-                order: -1,
-                ..default()
-            },
-            ..default()
-        },
+        BackgroundScene,
         RenderLayers::layer(1),
     ));
     commands.spawn((
         VelloSceneBundle::default(),
-        BackgroundScene,
-        RenderLayers::layer(1),
+        AnimationScene,
+        RenderLayers::layer(2),
     ));
 }
 
diff --git a/src/lib.rs b/src/lib.rs
index 8c01e21..e040d14 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -24,7 +24,7 @@ pub mod prelude {
     pub use crate::{
         debug::DebugVisualizations,
         integrations::{VectorFile, VelloAsset, VelloAssetAnchor},
-        render::{VelloCanvasMaterial, VelloRenderSettings},
+        render::{VelloCanvasSettings, VelloRenderSettings},
         text::{VelloFont, VelloTextAnchor, VelloTextSection, VelloTextStyle},
         CoordinateSpace, VelloAssetBundle, VelloScene, VelloSceneBundle, VelloTextBundle,
     };
@@ -113,23 +113,9 @@ pub struct VelloTextBundle {
 }
 
 /// A simple newtype component wrapper for [`vello::Scene`] for rendering.
-#[derive(Component, Default, Clone)]
+#[derive(Component, Default, Clone, Deref, DerefMut)]
 pub struct VelloScene(vello::Scene);
 
-impl std::ops::Deref for VelloScene {
-    type Target = vello::Scene;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl std::ops::DerefMut for VelloScene {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
-
 impl VelloScene {
     pub fn new() -> Self {
         Self::default()
diff --git a/src/plugin.rs b/src/plugin.rs
index 81b08b1..3f012dc 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -1,24 +1,51 @@
 use crate::{
-    debug::DebugVisualizationsPlugin, render::VelloRenderPlugin, text::VelloFontLoader, VelloAsset,
-    VelloFont, VelloRenderSettings,
+    debug::DebugVisualizationsPlugin,
+    render::{VelloCanvasSettings, VelloRenderPlugin},
+    text::VelloFontLoader,
+    VelloAsset, VelloFont, VelloRenderSettings,
 };
 use bevy::{asset::load_internal_binary_asset, prelude::*, render::view::RenderLayers};
+use vello::AaConfig;
 
-#[derive(Resource, Default, Debug)]
+#[derive(Clone)]
 pub struct VelloPlugin {
+    /// The render layers that will be used for the Vello canvas mesh.
     pub canvas_render_layers: RenderLayers,
+
+    /// Use CPU instead of GPU
+    pub use_cpu: bool,
+
+    /// Which antialiasing strategy to use
+    pub antialiasing: AaConfig,
+}
+
+impl Default for VelloPlugin {
+    fn default() -> Self {
+        let default_canvas_settings = VelloCanvasSettings::default();
+        let default_render_settings = VelloRenderSettings::default();
+        Self {
+            canvas_render_layers: default_canvas_settings.render_layers,
+            use_cpu: default_render_settings.use_cpu,
+            antialiasing: default_render_settings.antialiasing,
+        }
+    }
 }
 
 impl Plugin for VelloPlugin {
     fn build(&self, app: &mut App) {
-        app.add_plugins(VelloRenderPlugin)
-            .insert_resource(VelloRenderSettings {
-                canvas_render_layers: self.canvas_render_layers.clone(),
-            })
-            .add_plugins(DebugVisualizationsPlugin)
-            .init_asset::<VelloAsset>()
-            .init_asset::<VelloFont>()
-            .init_asset_loader::<VelloFontLoader>();
+        app.add_plugins(VelloRenderPlugin {
+            canvas_settings: VelloCanvasSettings {
+                render_layers: self.canvas_render_layers.clone(),
+            },
+            render_settings: VelloRenderSettings {
+                use_cpu: self.use_cpu,
+                antialiasing: self.antialiasing,
+            },
+        })
+        .add_plugins(DebugVisualizationsPlugin)
+        .init_asset::<VelloAsset>()
+        .init_asset::<VelloFont>()
+        .init_asset_loader::<VelloFontLoader>();
         #[cfg(feature = "svg")]
         app.add_plugins(crate::integrations::svg::SvgIntegrationPlugin);
         #[cfg(feature = "lottie")]
diff --git a/src/render/mod.rs b/src/render/mod.rs
index a4d7b9b..74230e6 100644
--- a/src/render/mod.rs
+++ b/src/render/mod.rs
@@ -8,9 +8,11 @@ use bevy::{
             AsBindGroup, RenderPipelineDescriptor, ShaderRef, SpecializedMeshPipelineError,
             VertexBufferLayout, VertexFormat, VertexStepMode,
         },
+        view::RenderLayers,
     },
     sprite::{Material2d, Material2dKey},
 };
+use vello::{AaConfig, AaSupport};
 
 mod extract;
 mod plugin;
@@ -18,7 +20,6 @@ mod prepare;
 mod systems;
 
 pub use plugin::VelloRenderPlugin;
-pub use plugin::VelloRenderSettings;
 
 /// A handle to the screen space render target shader.
 pub const SSRT_SHADER_HANDLE: Handle<Shader> = Handle::weak_from_u128(2314894693238056781);
@@ -64,13 +65,17 @@ impl Material2d for VelloCanvasMaterial {
 pub struct VelloRenderer(vello::Renderer);
 
 impl VelloRenderer {
-    pub fn from_device(device: &vello::wgpu::Device) -> Self {
+    pub fn from_device(device: &vello::wgpu::Device, settings: &VelloRenderSettings) -> Self {
         let renderer = vello::Renderer::new(
             device,
             vello::RendererOptions {
                 surface_format: None,
-                use_cpu: false,
-                antialiasing_support: vello::AaSupport::area_only(),
+                use_cpu: settings.use_cpu,
+                antialiasing_support: AaSupport {
+                    area: settings.antialiasing == AaConfig::Area,
+                    msaa8: settings.antialiasing == AaConfig::Msaa8,
+                    msaa16: settings.antialiasing == AaConfig::Msaa16,
+                },
                 num_init_threads: None,
             },
         )
@@ -83,3 +88,29 @@ impl VelloRenderer {
 #[derive(Resource, Deref, DerefMut, Default)]
 #[cfg(feature = "lottie")]
 pub struct VelatoRenderer(velato::Renderer);
+
+/// Render settings for Vello.
+#[derive(Resource, Clone)]
+pub struct VelloRenderSettings {
+    /// Use CPU instead of GPU
+    pub use_cpu: bool,
+
+    /// Which antialiasing strategy to use
+    pub antialiasing: AaConfig,
+}
+
+impl Default for VelloRenderSettings {
+    fn default() -> Self {
+        Self {
+            use_cpu: false,
+            antialiasing: AaConfig::Area,
+        }
+    }
+}
+
+/// Canvas settings for Vello.
+#[derive(Resource, Clone, Debug, Default, PartialEq)]
+pub struct VelloCanvasSettings {
+    /// The render layers that will be used for the Vello canvas mesh.
+    pub render_layers: RenderLayers,
+}
diff --git a/src/render/plugin.rs b/src/render/plugin.rs
index 5369e2b..1989f9f 100644
--- a/src/render/plugin.rs
+++ b/src/render/plugin.rs
@@ -1,9 +1,9 @@
 use super::{
     extract::{self, ExtractedPixelScale, SSRenderTarget},
-    prepare, systems,
+    prepare, systems, VelloCanvasSettings, VelloRenderSettings,
 };
 use crate::{
-    render::SSRT_SHADER_HANDLE, VelloAsset, VelloCanvasMaterial, VelloFont, VelloScene,
+    render::VelloCanvasMaterial, render::SSRT_SHADER_HANDLE, VelloAsset, VelloFont, VelloScene,
     VelloTextSection,
 };
 use bevy::{
@@ -13,18 +13,19 @@ use bevy::{
         extract_component::ExtractComponentPlugin,
         render_asset::RenderAssetPlugin,
         renderer::RenderDevice,
-        view::{check_visibility, RenderLayers, VisibilitySystems},
+        view::{check_visibility, VisibilitySystems},
         Render, RenderApp, RenderSet,
     },
     sprite::Material2dPlugin,
 };
 
-pub struct VelloRenderPlugin;
+#[derive(Default)]
+pub struct VelloRenderPlugin {
+    /// Settings used for the canvas
+    pub canvas_settings: VelloCanvasSettings,
 
-#[derive(Resource, Default, Clone, Debug)]
-pub struct VelloRenderSettings {
-    /// The render layer that will be used for the vello canvas mesh.
-    pub canvas_render_layers: RenderLayers,
+    /// Settings used for rendering with Vello
+    pub render_settings: VelloRenderSettings,
 }
 
 impl Plugin for VelloRenderPlugin {
@@ -48,6 +49,7 @@ impl Plugin for VelloRenderPlugin {
             .add_systems(ExtractSchedule, extract::extract_lottie_assets);
 
         render_app
+            .insert_resource(self.render_settings.clone())
             .insert_resource(ExtractedPixelScale(1.0))
             .add_systems(
                 ExtractSchedule,
@@ -73,30 +75,27 @@ impl Plugin for VelloRenderPlugin {
                     .run_if(resource_exists::<RenderDevice>),
             );
 
-        app.add_plugins((
-            Material2dPlugin::<VelloCanvasMaterial>::default(),
-            ExtractComponentPlugin::<SSRenderTarget>::default(),
-            RenderAssetPlugin::<VelloFont>::default(),
-        ))
-        .add_systems(Startup, systems::setup_ss_rendertarget)
-        .add_systems(
-            Update,
-            (
-                systems::resize_rendertargets,
-                systems::hide_when_empty,
-                systems::settings_change_detection,
-            ),
-        )
-        .add_systems(
-            PostUpdate,
-            check_visibility::<
-                Or<(
-                    With<VelloScene>,
-                    With<Handle<VelloAsset>>,
-                    With<VelloTextSection>,
-                )>,
-            >
-                .in_set(VisibilitySystems::CheckVisibility),
-        );
+        app.insert_resource(self.canvas_settings.clone())
+            .add_plugins((
+                Material2dPlugin::<VelloCanvasMaterial>::default(),
+                ExtractComponentPlugin::<SSRenderTarget>::default(),
+                RenderAssetPlugin::<VelloFont>::default(),
+            ))
+            .add_systems(Startup, systems::setup_ss_rendertarget)
+            .add_systems(
+                Update,
+                (systems::resize_rendertargets, systems::hide_when_empty),
+            )
+            .add_systems(
+                PostUpdate,
+                check_visibility::<
+                    Or<(
+                        With<VelloScene>,
+                        With<Handle<VelloAsset>>,
+                        With<VelloTextSection>,
+                    )>,
+                >
+                    .in_set(VisibilitySystems::CheckVisibility),
+            );
     }
 }
diff --git a/src/render/systems.rs b/src/render/systems.rs
index b260e12..a266189 100644
--- a/src/render/systems.rs
+++ b/src/render/systems.rs
@@ -1,12 +1,11 @@
 use super::{
     extract::{ExtractedRenderAsset, ExtractedRenderText, SSRenderTarget},
-    plugin::VelloRenderSettings,
     prepare::PreparedAffine,
-    VelloRenderer,
+    VelloCanvasMaterial, VelloCanvasSettings, VelloRenderSettings, VelloRenderer,
 };
 use crate::{
-    render::extract::ExtractedRenderScene, CoordinateSpace, VelloAsset, VelloCanvasMaterial,
-    VelloFont, VelloScene, VelloTextSection,
+    render::extract::ExtractedRenderScene, CoordinateSpace, VelloAsset, VelloFont, VelloScene,
+    VelloTextSection,
 };
 use bevy::{
     prelude::*,
@@ -70,10 +69,16 @@ pub fn render_frame(
     device: Res<RenderDevice>,
     queue: Res<RenderQueue>,
     mut vello_renderer: Local<Option<VelloRenderer>>,
+    settings: Res<VelloRenderSettings>,
     #[cfg(feature = "lottie")] mut velato_renderer: ResMut<super::VelatoRenderer>,
 ) {
-    let renderer =
-        vello_renderer.get_or_insert_with(|| VelloRenderer::from_device(device.wgpu_device()));
+    let renderer = if settings.is_changed() {
+        vello_renderer.insert(VelloRenderer::from_device(device.wgpu_device(), &settings))
+    } else {
+        vello_renderer
+            .get_or_insert_with(|| VelloRenderer::from_device(device.wgpu_device(), &settings))
+    };
+
     let Ok(SSRenderTarget(render_target_image)) = ss_render_target.get_single() else {
         error!("No render target");
         return;
@@ -283,7 +288,7 @@ pub fn setup_ss_rendertarget(
     mut custom_materials: ResMut<Assets<VelloCanvasMaterial>>,
     windows: Query<&Window>,
     mut render_target_mesh_handle: Local<Option<Handle<Mesh>>>,
-    settings: Res<VelloRenderSettings>,
+    settings: Res<VelloCanvasSettings>,
 ) {
     let Ok(window) = windows.get_single() else {
         return;
@@ -327,23 +332,7 @@ pub fn setup_ss_rendertarget(
         })
         .insert(NoFrustumCulling)
         .insert(render_target)
-        .insert(settings.canvas_render_layers.clone());
-}
-
-/// Listen for settings changes that a developer could make.
-pub fn settings_change_detection(
-    mut commands: Commands,
-    mut query_render_target: Query<Entity, With<SSRenderTarget>>,
-    settings: Res<VelloRenderSettings>,
-) {
-    if let Ok(entity) = query_render_target.get_single_mut() {
-        if settings.is_changed() {
-            // Replace the canvas render layers
-            commands
-                .entity(entity)
-                .insert(settings.canvas_render_layers.clone());
-        }
-    }
+        .insert(settings.render_layers.clone());
 }
 
 /// Hide the render target canvas if there is nothing to render

From 23b35988f5e8a357657790414ba6aedd4f9e87b0 Mon Sep 17 00:00:00 2001
From: "Spencer C. Imbleau" <spencer@imbleau.com>
Date: Sun, 4 Aug 2024 13:24:02 -0400
Subject: [PATCH 2/8] feat: `VelloRenderer` is now a resource

---
 CHANGELOG.md                |  9 +++++---
 examples/cube3d/src/main.rs | 29 +++++++++--------------
 src/render/mod.rs           | 46 ++++++++++++++++++++++++++++++-------
 src/render/plugin.rs        | 11 +++++++--
 src/render/systems.rs       | 16 +++++--------
 5 files changed, 70 insertions(+), 41 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e8a9dff..9ccb586 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,11 +15,13 @@ Subheadings to categorize changes are `added, changed, deprecated, removed, fixe
 - There is now a `default_font` feature that uses the same `FiraMono-subset.ttf` font used in the bevy/default_font feature.
 - There is now a `render_layers` example.
 - There is now a `cube_3d` example.
-- Added `VelloRenderer::from_device` to create a renderer manually.
+- You may now choose the render layers for the Vello canvas. This can be configured through the `VelloPlugin`.
+- You may now choose to use CPU rendering with Vello and configure anti-aliasing. This can be configured through the `VelloPlugin`.
 
 ### Changed
 
 - `VelloPlugin` now has configuration. To retain previous behavior, use `VelloPlugin::default()`.
+- `VelloRenderer` is now a resource.
 - The font API has changed significantly. Please visit `examples/text` for further usage. This is to prepare for additional text features such as linebreak behavior, bounded text, and text justification.
   - `VelloText` has been renamed to `VelloTextSection`.
   - `VelloText.content` has been renamed to `VelloText.value`.
@@ -28,12 +30,13 @@ Subheadings to categorize changes are `added, changed, deprecated, removed, fixe
 - The field `VelloAssetBundle.vector` was renamed to `VelloAssetBundle.asset`.
 - Renamed `VelloAssetAlignment` to `VelloAssetAnchor`. Fields were renamed `alignment` were renamed to `asset_anchor`.
 - Renamed `VelloTextAlignment` to `VelloTextAnchor`. Fields were renamed `alignment` were renamed to `text_anchor`.
-- The `SSRenderTarget` (fullscreen quad that renders your frame) no longer renders at a zepth of `-0.001`. This was a legacy hack used to ensure Gizmos rendered on-top.
+- The `SSRenderTarget` (fullscreen quad that renders your frame) no longer renders at a zepth of `-0.001`. This was a legacy hack used to ensure Gizmos rendered on-top. `RenderLayers` should be used now (there's an example).
 
 ### Removed
 
 - Removed `ZFunction`s from the render pipeline. Now ordering is based solely on the `Transform`'s z component. If you dependeded on this behavior, you'll need to adjust the transform Z in a system prior to render.
-- Removed `VelloCanvasMaterial` from prelude, as it's not typically meant to be used under normal circumstances and could be a common footgun.
+- `VelloRenderPlugin` is now private, as it is not helpful for downstream developers to add manually.
+- Removed `VelloCanvasMaterial` from prelude, as it is not typical to use.
 
 ### Fixed
 
diff --git a/examples/cube3d/src/main.rs b/examples/cube3d/src/main.rs
index fceccb4..60ad858 100644
--- a/examples/cube3d/src/main.rs
+++ b/examples/cube3d/src/main.rs
@@ -11,11 +11,7 @@ use bevy::{
         Render, RenderApp, RenderSet,
     },
 };
-use bevy_vello::{
-    prelude::*,
-    render::{VelloRenderPlugin, VelloRenderer},
-    VelloPlugin,
-};
+use bevy_vello::{prelude::*, render::VelloRenderer, VelloPlugin};
 
 #[derive(Component)]
 pub struct VelloTarget(Handle<Image>);
@@ -37,7 +33,11 @@ fn main() {
     let mut app = App::new();
 
     app.add_plugins(DefaultPlugins)
-        .add_plugins(VelloRenderPlugin::default())
+        .add_plugins(VelloPlugin {
+            use_cpu: false,
+            antialiasing: vello::AaConfig::Msaa8,
+            ..default()
+        })
         .add_systems(Startup, setup)
         .add_systems(Update, cube_rotator_system)
         .add_plugins(ExtractComponentPlugin::<VelloTarget>::default());
@@ -119,23 +119,14 @@ fn setup(
 }
 
 fn render_texture(
-    mut vello_renderer: Local<Option<VelloRenderer>>,
+    renderer: Res<VelloRenderer>,
+    render_settings: Res<VelloRenderSettings>,
     target: Query<&VelloTarget>,
     device: Res<RenderDevice>,
     gpu_images: Res<RenderAssets<GpuImage>>,
     queue: Res<RenderQueue>,
     time: Res<Time>,
 ) {
-    let renderer = vello_renderer.get_or_insert_with(|| {
-        VelloRenderer::from_device(
-            device.wgpu_device(),
-            &VelloRenderSettings {
-                use_cpu: false,
-                antialiasing: vello::AaConfig::Msaa8,
-                ..default()
-            },
-        )
-    });
     let target = target.single();
 
     let mut scene = VelloScene::default();
@@ -159,9 +150,11 @@ fn render_texture(
         base_color: vello::peniko::Color::WHITE,
         width: gpu_image.size.x,
         height: gpu_image.size.y,
-        antialiasing_method: vello::AaConfig::Area,
+        antialiasing_method: render_settings.antialiasing,
     };
     renderer
+        .lock()
+        .unwrap()
         .render_to_texture(
             device.wgpu_device(),
             &queue,
diff --git a/src/render/mod.rs b/src/render/mod.rs
index 74230e6..b69a6f2 100644
--- a/src/render/mod.rs
+++ b/src/render/mod.rs
@@ -8,10 +8,12 @@ use bevy::{
             AsBindGroup, RenderPipelineDescriptor, ShaderRef, SpecializedMeshPipelineError,
             VertexBufferLayout, VertexFormat, VertexStepMode,
         },
+        renderer::RenderDevice,
         view::RenderLayers,
     },
     sprite::{Material2d, Material2dKey},
 };
+use std::sync::{Arc, Mutex};
 use vello::{AaConfig, AaSupport};
 
 mod extract;
@@ -19,7 +21,7 @@ mod plugin;
 mod prepare;
 mod systems;
 
-pub use plugin::VelloRenderPlugin;
+pub(crate) use plugin::VelloRenderPlugin;
 
 /// A handle to the screen space render target shader.
 pub const SSRT_SHADER_HANDLE: Handle<Shader> = Handle::weak_from_u128(2314894693238056781);
@@ -61,12 +63,15 @@ impl Material2d for VelloCanvasMaterial {
     }
 }
 
-#[derive(Deref, DerefMut)]
-pub struct VelloRenderer(vello::Renderer);
+#[derive(Resource, Deref, DerefMut)]
+pub struct VelloRenderer(Arc<Mutex<vello::Renderer>>);
 
 impl VelloRenderer {
-    pub fn from_device(device: &vello::wgpu::Device, settings: &VelloRenderSettings) -> Self {
-        let renderer = vello::Renderer::new(
+    pub fn new(
+        device: &vello::wgpu::Device,
+        settings: &VelloRenderSettings,
+    ) -> Result<Self, vello::Error> {
+        vello::Renderer::new(
             device,
             vello::RendererOptions {
                 surface_format: None,
@@ -79,9 +84,34 @@ impl VelloRenderer {
                 num_init_threads: None,
             },
         )
-        // TODO: Attempt CPU fallback. Support changing antialias settings.
-        .expect("No GPU Device");
-        VelloRenderer(renderer)
+        .map(Mutex::new)
+        .map(Arc::new)
+        .map(VelloRenderer)
+    }
+}
+
+impl FromWorld for VelloRenderer {
+    fn from_world(world: &mut World) -> Self {
+        match VelloRenderer::new(
+            world.get_resource::<RenderDevice>().unwrap().wgpu_device(),
+            world.get_resource::<VelloRenderSettings>().unwrap(),
+        ) {
+            Ok(r) => r,
+            Err(e) => {
+                error!("Attempting CPU fallback, failed to initialize renderer: {e:}");
+                {
+                    let mut settings = world.get_resource_mut::<VelloRenderSettings>().unwrap();
+                    settings.use_cpu = true;
+                }
+                match VelloRenderer::new(
+                    world.get_resource::<RenderDevice>().unwrap().wgpu_device(),
+                    world.get_resource::<VelloRenderSettings>().unwrap(),
+                ) {
+                    Ok(r) => r,
+                    Err(e) => panic!("Failed to start vello: {e}"),
+                }
+            }
+        }
     }
 }
 
diff --git a/src/render/plugin.rs b/src/render/plugin.rs
index 1989f9f..4307b76 100644
--- a/src/render/plugin.rs
+++ b/src/render/plugin.rs
@@ -3,8 +3,8 @@ use super::{
     prepare, systems, VelloCanvasSettings, VelloRenderSettings,
 };
 use crate::{
-    render::VelloCanvasMaterial, render::SSRT_SHADER_HANDLE, VelloAsset, VelloFont, VelloScene,
-    VelloTextSection,
+    render::{VelloCanvasMaterial, VelloRenderer, SSRT_SHADER_HANDLE},
+    VelloAsset, VelloFont, VelloScene, VelloTextSection,
 };
 use bevy::{
     asset::load_internal_asset,
@@ -98,4 +98,11 @@ impl Plugin for VelloRenderPlugin {
                     .in_set(VisibilitySystems::CheckVisibility),
             );
     }
+
+    fn finish(&self, app: &mut App) {
+        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
+            return;
+        };
+        render_app.init_resource::<VelloRenderer>();
+    }
 }
diff --git a/src/render/systems.rs b/src/render/systems.rs
index a266189..613229b 100644
--- a/src/render/systems.rs
+++ b/src/render/systems.rs
@@ -68,17 +68,11 @@ pub fn render_frame(
     gpu_images: Res<RenderAssets<GpuImage>>,
     device: Res<RenderDevice>,
     queue: Res<RenderQueue>,
-    mut vello_renderer: Local<Option<VelloRenderer>>,
-    settings: Res<VelloRenderSettings>,
+    renderer: Res<VelloRenderer>,
+    render_settings: Res<VelloRenderSettings>,
+
     #[cfg(feature = "lottie")] mut velato_renderer: ResMut<super::VelatoRenderer>,
 ) {
-    let renderer = if settings.is_changed() {
-        vello_renderer.insert(VelloRenderer::from_device(device.wgpu_device(), &settings))
-    } else {
-        vello_renderer
-            .get_or_insert_with(|| VelloRenderer::from_device(device.wgpu_device(), &settings))
-    };
-
     let Ok(SSRenderTarget(render_target_image)) = ss_render_target.get_single() else {
         error!("No render target");
         return;
@@ -230,6 +224,8 @@ pub fn render_frame(
         }
 
         renderer
+            .lock()
+            .unwrap()
             .render_to_texture(
                 device.wgpu_device(),
                 &queue,
@@ -239,7 +235,7 @@ pub fn render_frame(
                     base_color: vello::peniko::Color::TRANSPARENT,
                     width: gpu_image.size.x,
                     height: gpu_image.size.y,
-                    antialiasing_method: vello::AaConfig::Area,
+                    antialiasing_method: render_settings.antialiasing,
                 },
             )
             .unwrap();

From ca5c3b00bddf9f43e7359a0ff4c5fc7649be8f05 Mon Sep 17 00:00:00 2001
From: "Spencer C. Imbleau" <spencer@imbleau.com>
Date: Sun, 4 Aug 2024 14:05:02 -0400
Subject: [PATCH 3/8] fix: `VelloCanvasSettings` doesn't need to be public.

---
 src/render/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/render/mod.rs b/src/render/mod.rs
index b69a6f2..8bf7d9e 100644
--- a/src/render/mod.rs
+++ b/src/render/mod.rs
@@ -140,7 +140,7 @@ impl Default for VelloRenderSettings {
 
 /// Canvas settings for Vello.
 #[derive(Resource, Clone, Debug, Default, PartialEq)]
-pub struct VelloCanvasSettings {
+pub(crate) struct VelloCanvasSettings {
     /// The render layers that will be used for the Vello canvas mesh.
     pub render_layers: RenderLayers,
 }

From 14b9bfc185cdd553b30265a39b4613d76b790b85 Mon Sep 17 00:00:00 2001
From: "Spencer C. Imbleau" <spencer@imbleau.com>
Date: Sun, 4 Aug 2024 14:05:24 -0400
Subject: [PATCH 4/8] fix: remove VelloCanvasSettings from prelude

---
 src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/lib.rs b/src/lib.rs
index e040d14..9938a3f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -24,7 +24,7 @@ pub mod prelude {
     pub use crate::{
         debug::DebugVisualizations,
         integrations::{VectorFile, VelloAsset, VelloAssetAnchor},
-        render::{VelloCanvasSettings, VelloRenderSettings},
+        render::VelloRenderSettings,
         text::{VelloFont, VelloTextAnchor, VelloTextSection, VelloTextStyle},
         CoordinateSpace, VelloAssetBundle, VelloScene, VelloSceneBundle, VelloTextBundle,
     };

From e8b3cdab5cee9fb79b065084d9569d03dac558ab Mon Sep 17 00:00:00 2001
From: "Spencer C. Imbleau" <spencer@imbleau.com>
Date: Sun, 4 Aug 2024 14:05:38 -0400
Subject: [PATCH 5/8] fix: allow dynamic changing of `VelloRenderSettings`

---
 src/render/plugin.rs  |  1 +
 src/render/systems.rs | 12 ++++++++++++
 2 files changed, 13 insertions(+)

diff --git a/src/render/plugin.rs b/src/render/plugin.rs
index 4307b76..6b0b828 100644
--- a/src/render/plugin.rs
+++ b/src/render/plugin.rs
@@ -51,6 +51,7 @@ impl Plugin for VelloRenderPlugin {
         render_app
             .insert_resource(self.render_settings.clone())
             .insert_resource(ExtractedPixelScale(1.0))
+            .add_systems(Update, systems::render_settings_change_detection)
             .add_systems(
                 ExtractSchedule,
                 (
diff --git a/src/render/systems.rs b/src/render/systems.rs
index 613229b..1ecf3ab 100644
--- a/src/render/systems.rs
+++ b/src/render/systems.rs
@@ -331,6 +331,18 @@ pub fn setup_ss_rendertarget(
         .insert(settings.render_layers.clone());
 }
 
+/// Reinitialize for renderer settings changes.
+pub fn render_settings_change_detection(
+    mut commands: Commands,
+    render_settings: Res<VelloRenderSettings>,
+) {
+    if render_settings.is_changed() {
+        // Replace renderer
+        commands.remove_resource::<VelloRenderer>();
+        commands.init_resource::<VelloRenderer>();
+    }
+}
+
 /// Hide the render target canvas if there is nothing to render
 pub fn hide_when_empty(
     mut query_render_target: Query<&mut Visibility, With<SSRenderTarget>>,

From 4e5cb8b17cd8306c27eada24aa01f8c9196a37c6 Mon Sep 17 00:00:00 2001
From: "Spencer C. Imbleau" <spencer@imbleau.com>
Date: Sun, 4 Aug 2024 14:39:39 -0400
Subject: [PATCH 6/8] refactor: rename `VelloRenderer::new` to
 `VelloRenderer::try_new`

---
 src/render/mod.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/render/mod.rs b/src/render/mod.rs
index 8bf7d9e..f6556ae 100644
--- a/src/render/mod.rs
+++ b/src/render/mod.rs
@@ -67,7 +67,7 @@ impl Material2d for VelloCanvasMaterial {
 pub struct VelloRenderer(Arc<Mutex<vello::Renderer>>);
 
 impl VelloRenderer {
-    pub fn new(
+    pub fn try_new(
         device: &vello::wgpu::Device,
         settings: &VelloRenderSettings,
     ) -> Result<Self, vello::Error> {
@@ -92,7 +92,7 @@ impl VelloRenderer {
 
 impl FromWorld for VelloRenderer {
     fn from_world(world: &mut World) -> Self {
-        match VelloRenderer::new(
+        match VelloRenderer::try_new(
             world.get_resource::<RenderDevice>().unwrap().wgpu_device(),
             world.get_resource::<VelloRenderSettings>().unwrap(),
         ) {
@@ -103,7 +103,7 @@ impl FromWorld for VelloRenderer {
                     let mut settings = world.get_resource_mut::<VelloRenderSettings>().unwrap();
                     settings.use_cpu = true;
                 }
-                match VelloRenderer::new(
+                match VelloRenderer::try_new(
                     world.get_resource::<RenderDevice>().unwrap().wgpu_device(),
                     world.get_resource::<VelloRenderSettings>().unwrap(),
                 ) {

From 16be3cf028caa15f91b03c18953586f564d2fff3 Mon Sep 17 00:00:00 2001
From: "Spencer C. Imbleau" <spencer@imbleau.com>
Date: Sun, 4 Aug 2024 15:05:04 -0400
Subject: [PATCH 7/8] fix: runtime swapping of render settings

---
 CHANGELOG.md          |  1 +
 src/render/mod.rs     | 10 ++++------
 src/render/plugin.rs  |  5 ++++-
 src/render/systems.rs |  3 ++-
 4 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9ccb586..e811896 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -22,6 +22,7 @@ Subheadings to categorize changes are `added, changed, deprecated, removed, fixe
 
 - `VelloPlugin` now has configuration. To retain previous behavior, use `VelloPlugin::default()`.
 - `VelloRenderer` is now a resource.
+- The `VelloRenderer` will attempt CPU fallback if it cannot obtain a GPU.
 - The font API has changed significantly. Please visit `examples/text` for further usage. This is to prepare for additional text features such as linebreak behavior, bounded text, and text justification.
   - `VelloText` has been renamed to `VelloTextSection`.
   - `VelloText.content` has been renamed to `VelloText.value`.
diff --git a/src/render/mod.rs b/src/render/mod.rs
index f6556ae..9fbddc0 100644
--- a/src/render/mod.rs
+++ b/src/render/mod.rs
@@ -76,11 +76,8 @@ impl VelloRenderer {
             vello::RendererOptions {
                 surface_format: None,
                 use_cpu: settings.use_cpu,
-                antialiasing_support: AaSupport {
-                    area: settings.antialiasing == AaConfig::Area,
-                    msaa8: settings.antialiasing == AaConfig::Msaa8,
-                    msaa16: settings.antialiasing == AaConfig::Msaa16,
-                },
+                // TODO: Vello doesn't currently allow adding additional AA support after initialization, so we need to use all support modes here instead.
+                antialiasing_support: AaSupport::all(),
                 num_init_threads: None,
             },
         )
@@ -98,10 +95,11 @@ impl FromWorld for VelloRenderer {
         ) {
             Ok(r) => r,
             Err(e) => {
-                error!("Attempting CPU fallback, failed to initialize renderer: {e:}");
+                error!("Attempting safe-mode fallback, failed to initialize renderer: {e:}");
                 {
                     let mut settings = world.get_resource_mut::<VelloRenderSettings>().unwrap();
                     settings.use_cpu = true;
+                    settings.antialiasing = AaConfig::Area;
                 }
                 match VelloRenderer::try_new(
                     world.get_resource::<RenderDevice>().unwrap().wgpu_device(),
diff --git a/src/render/plugin.rs b/src/render/plugin.rs
index 6b0b828..0fb258c 100644
--- a/src/render/plugin.rs
+++ b/src/render/plugin.rs
@@ -51,7 +51,10 @@ impl Plugin for VelloRenderPlugin {
         render_app
             .insert_resource(self.render_settings.clone())
             .insert_resource(ExtractedPixelScale(1.0))
-            .add_systems(Update, systems::render_settings_change_detection)
+            .add_systems(
+                Render,
+                systems::render_settings_change_detection.in_set(RenderSet::Cleanup),
+            )
             .add_systems(
                 ExtractSchedule,
                 (
diff --git a/src/render/systems.rs b/src/render/systems.rs
index 1ecf3ab..4afab4e 100644
--- a/src/render/systems.rs
+++ b/src/render/systems.rs
@@ -336,8 +336,9 @@ pub fn render_settings_change_detection(
     mut commands: Commands,
     render_settings: Res<VelloRenderSettings>,
 ) {
-    if render_settings.is_changed() {
+    if render_settings.is_changed() && !render_settings.is_added() {
         // Replace renderer
+        info!("Render settings changed, re-initializing vello...");
         commands.remove_resource::<VelloRenderer>();
         commands.init_resource::<VelloRenderer>();
     }

From cf2bf3db4d9f842ba2d1c8bc2cba8053f3df8055 Mon Sep 17 00:00:00 2001
From: "Spencer C. Imbleau" <spencer@imbleau.com>
Date: Sun, 4 Aug 2024 15:08:06 -0400
Subject: [PATCH 8/8] fix: OFL license

---
 src/plugin.rs                               |   2 +-
 src/text/{ => FiraMono}/FiraMono-subset.ttf | Bin
 src/text/FiraMono/LICENSE                   |  91 ++++++++++++++++++++
 3 files changed, 92 insertions(+), 1 deletion(-)
 rename src/text/{ => FiraMono}/FiraMono-subset.ttf (100%)
 create mode 100644 src/text/FiraMono/LICENSE

diff --git a/src/plugin.rs b/src/plugin.rs
index 3f012dc..58df1ea 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -56,7 +56,7 @@ impl Plugin for VelloPlugin {
         load_internal_binary_asset!(
             app,
             Handle::default(),
-            "text/FiraMono-subset.ttf",
+            "text/FiraMono/FiraMono-subset.ttf",
             |bytes: &[u8], _path: String| { VelloFont::new(bytes.to_vec()) }
         );
     }
diff --git a/src/text/FiraMono-subset.ttf b/src/text/FiraMono/FiraMono-subset.ttf
similarity index 100%
rename from src/text/FiraMono-subset.ttf
rename to src/text/FiraMono/FiraMono-subset.ttf
diff --git a/src/text/FiraMono/LICENSE b/src/text/FiraMono/LICENSE
new file mode 100644
index 0000000..77b1731
--- /dev/null
+++ b/src/text/FiraMono/LICENSE
@@ -0,0 +1,91 @@
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.