From e80177774cdf7af0e04f5bc15a881802d94b09d2 Mon Sep 17 00:00:00 2001
From: "Spencer C. Imbleau" <spencer@imbleau.com>
Date: Sun, 4 Aug 2024 15:13:36 -0400
Subject: [PATCH] refactor: core pipeline changes (#73)

Addresses some friction where the `VelloRenderer` was not a resource and
required Locals temporarily. This was mainly observed in the `cube3d`
example. Likewise, the rendering params such as `use_cpu` and
`antialiasing` were not configurable and the use of `RenderLayers` were
cleaned up after @ChristopherBiscardi brought up some comments after
#71.

@ChristopherBiscardi Please let me know if you still have concerns with
RenderLayers.
---
 CHANGELOG.md                                |   8 +-
 examples/cube3d/src/main.rs                 |  15 ++--
 examples/render_layers/src/main.rs          |  48 +++--------
 src/lib.rs                                  |  18 +---
 src/plugin.rs                               |  51 ++++++++---
 src/render/mod.rs                           |  81 ++++++++++++++---
 src/render/plugin.rs                        |  78 +++++++++--------
 src/render/systems.rs                       |  40 ++++-----
 src/text/{ => FiraMono}/FiraMono-subset.ttf | Bin
 src/text/FiraMono/LICENSE                   |  91 ++++++++++++++++++++
 10 files changed, 294 insertions(+), 136 deletions(-)
 rename src/text/{ => FiraMono}/FiraMono-subset.ttf (100%)
 create mode 100644 src/text/FiraMono/LICENSE

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 48b02c8..e811896 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,10 +15,14 @@ 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.
+- 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 `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`.
@@ -27,11 +31,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.
+- `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 11cf294..60ad858 100644
--- a/examples/cube3d/src/main.rs
+++ b/examples/cube3d/src/main.rs
@@ -33,7 +33,11 @@ fn main() {
     let mut app = App::new();
 
     app.add_plugins(DefaultPlugins)
-        .add_plugins(VelloPlugin::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());
@@ -115,15 +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()));
     let target = target.single();
 
     let mut scene = VelloScene::default();
@@ -147,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/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..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::{VelloCanvasMaterial, VelloRenderSettings},
+        render::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..58df1ea 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")]
@@ -29,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/render/mod.rs b/src/render/mod.rs
index a4d7b9b..9fbddc0 100644
--- a/src/render/mod.rs
+++ b/src/render/mod.rs
@@ -8,17 +8,20 @@ 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;
 mod plugin;
 mod prepare;
 mod systems;
 
-pub use plugin::VelloRenderPlugin;
-pub use plugin::VelloRenderSettings;
+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);
@@ -60,26 +63,82 @@ 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) -> Self {
-        let renderer = vello::Renderer::new(
+    pub fn try_new(
+        device: &vello::wgpu::Device,
+        settings: &VelloRenderSettings,
+    ) -> Result<Self, vello::Error> {
+        vello::Renderer::new(
             device,
             vello::RendererOptions {
                 surface_format: None,
-                use_cpu: false,
-                antialiasing_support: vello::AaSupport::area_only(),
+                use_cpu: settings.use_cpu,
+                // 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,
             },
         )
-        // 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::try_new(
+            world.get_resource::<RenderDevice>().unwrap().wgpu_device(),
+            world.get_resource::<VelloRenderSettings>().unwrap(),
+        ) {
+            Ok(r) => r,
+            Err(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(),
+                    world.get_resource::<VelloRenderSettings>().unwrap(),
+                ) {
+                    Ok(r) => r,
+                    Err(e) => panic!("Failed to start vello: {e}"),
+                }
+            }
+        }
     }
 }
 
 #[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(crate) 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..0fb258c 100644
--- a/src/render/plugin.rs
+++ b/src/render/plugin.rs
@@ -1,10 +1,10 @@
 use super::{
     extract::{self, ExtractedPixelScale, SSRenderTarget},
-    prepare, systems,
+    prepare, systems, VelloCanvasSettings, VelloRenderSettings,
 };
 use crate::{
-    render::SSRT_SHADER_HANDLE, VelloAsset, VelloCanvasMaterial, VelloFont, VelloScene,
-    VelloTextSection,
+    render::{VelloCanvasMaterial, VelloRenderer, SSRT_SHADER_HANDLE},
+    VelloAsset, VelloFont, VelloScene, VelloTextSection,
 };
 use bevy::{
     asset::load_internal_asset,
@@ -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,7 +49,12 @@ 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(
+                Render,
+                systems::render_settings_change_detection.in_set(RenderSet::Cleanup),
+            )
             .add_systems(
                 ExtractSchedule,
                 (
@@ -73,30 +79,34 @@ 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),
+            );
+    }
+
+    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 b260e12..4afab4e 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::*,
@@ -69,11 +68,11 @@ pub fn render_frame(
     gpu_images: Res<RenderAssets<GpuImage>>,
     device: Res<RenderDevice>,
     queue: Res<RenderQueue>,
-    mut vello_renderer: Local<Option<VelloRenderer>>,
+    renderer: Res<VelloRenderer>,
+    render_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 Ok(SSRenderTarget(render_target_image)) = ss_render_target.get_single() else {
         error!("No render target");
         return;
@@ -225,6 +224,8 @@ pub fn render_frame(
         }
 
         renderer
+            .lock()
+            .unwrap()
             .render_to_texture(
                 device.wgpu_device(),
                 &queue,
@@ -234,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();
@@ -283,7 +284,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,22 +328,19 @@ pub fn setup_ss_rendertarget(
         })
         .insert(NoFrustumCulling)
         .insert(render_target)
-        .insert(settings.canvas_render_layers.clone());
+        .insert(settings.render_layers.clone());
 }
 
-/// Listen for settings changes that a developer could make.
-pub fn settings_change_detection(
+/// Reinitialize for renderer settings changes.
+pub fn render_settings_change_detection(
     mut commands: Commands,
-    mut query_render_target: Query<Entity, With<SSRenderTarget>>,
-    settings: Res<VelloRenderSettings>,
+    render_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());
-        }
+    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>();
     }
 }
 
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.