From ad322d24fe48d44f3df2cc233bc276287cad3dc7 Mon Sep 17 00:00:00 2001
From: Chris Biscardi <chris@christopherbiscardi.com>
Date: Sat, 27 Jul 2024 11:26:45 -0700
Subject: [PATCH] Fix render layers (#68)

This is a rebased version of #49 which looks like it only needed merge
conflicts resolved

---------

Co-authored-by: Conner Petzold <cpetzold@gmail.com>
Co-authored-by: Spencer C. Imbleau <spencer@imbleau.com>
---
 CHANGELOG.md                       |   7 +
 Cargo.toml                         |   2 +
 examples/cube3d/Cargo.toml         |  12 ++
 examples/cube3d/src/main.rs        | 169 +++++++++++++++++
 examples/render_layers/Cargo.toml  |  12 ++
 examples/render_layers/src/main.rs | 148 +++++++++++++++
 examples/text/Cargo.toml           |   2 +-
 examples/text/src/main.rs          |  23 ++-
 src/render/extract.rs              |  91 +++++----
 src/render/mod.rs                  |  27 ++-
 src/render/plugin.rs               |  24 ++-
 src/render/prepare.rs              | 291 ++++++++++++++++-------------
 src/render/systems.rs              | 245 +++++++++++++-----------
 13 files changed, 747 insertions(+), 306 deletions(-)
 create mode 100644 examples/cube3d/Cargo.toml
 create mode 100644 examples/cube3d/src/main.rs
 create mode 100644 examples/render_layers/Cargo.toml
 create mode 100644 examples/render_layers/src/main.rs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 05c1ee7..71e00d0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,8 @@ Subheadings to categorize changes are `added, changed, deprecated, removed, fixe
 ### Added
 
 - 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.
 
 ### Changed
 
@@ -24,11 +26,16 @@ 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.
 
 ### 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.
 
+### Fixed
+
+- Text, assets, and scenes rendered will now correctly respect camera `RenderLayers`.
+
 ## 0.5.1
 
 ### Fixed
diff --git a/Cargo.toml b/Cargo.toml
index cf74bb9..86cb96d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,6 +9,8 @@ members = [
   "examples/svg",
   "examples/lottie",
   "examples/scene_ui",
+  "examples/render_layers",
+  "examples/cube3d",
 ]
 
 [workspace.package]
diff --git a/examples/cube3d/Cargo.toml b/examples/cube3d/Cargo.toml
new file mode 100644
index 0000000..0b66c94
--- /dev/null
+++ b/examples/cube3d/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "cube3d"
+version.workspace = true
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
+publish = false
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[dependencies]
+bevy_vello = { path = "../../" }
+bevy = { workspace = true }
diff --git a/examples/cube3d/src/main.rs b/examples/cube3d/src/main.rs
new file mode 100644
index 0000000..6940bcf
--- /dev/null
+++ b/examples/cube3d/src/main.rs
@@ -0,0 +1,169 @@
+use bevy::{
+    prelude::*,
+    render::{
+        extract_component::{ExtractComponent, ExtractComponentPlugin},
+        render_asset::RenderAssets,
+        render_resource::{
+            Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsages,
+        },
+        renderer::{RenderDevice, RenderQueue},
+        texture::GpuImage,
+        Render, RenderApp, RenderSet,
+    },
+};
+use bevy_vello::{prelude::*, render::VelloRenderer, VelloPlugin};
+
+#[derive(Component)]
+pub struct VelloTarget(Handle<Image>);
+
+impl ExtractComponent for VelloTarget {
+    type QueryData = &'static VelloTarget;
+    type QueryFilter = ();
+    type Out = Self;
+    fn extract_component(target: bevy::ecs::query::QueryItem<'_, Self::QueryData>) -> Option<Self> {
+        Some(Self(target.0.clone()))
+    }
+}
+
+// Marks the main pass cube, to which the texture is applied.
+#[derive(Component)]
+struct MainPassCube;
+
+fn main() {
+    let mut app = App::new();
+
+    app.add_plugins(DefaultPlugins)
+        .add_plugins(VelloPlugin)
+        .add_systems(Startup, setup)
+        .add_systems(Update, cube_rotator_system)
+        .add_plugins(ExtractComponentPlugin::<VelloTarget>::default());
+
+    let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
+        return;
+    };
+    render_app.add_systems(
+        Render,
+        render_texture
+            .in_set(RenderSet::Render)
+            .run_if(resource_exists::<RenderDevice>),
+    );
+
+    app.run();
+}
+
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    mut images: ResMut<Assets<Image>>,
+) {
+    let size = Extent3d {
+        width: 512,
+        height: 512,
+        ..default()
+    };
+    // This is the texture that will be rendered to.
+    let mut image = Image {
+        texture_descriptor: TextureDescriptor {
+            label: None,
+            size,
+            dimension: TextureDimension::D2,
+            format: TextureFormat::Rgba8Unorm,
+            mip_level_count: 1,
+            sample_count: 1,
+            usage: TextureUsages::TEXTURE_BINDING
+                | TextureUsages::COPY_DST
+                | TextureUsages::STORAGE_BINDING,
+            view_formats: &[],
+        },
+        ..default()
+    };
+
+    // fill image.data with zeroes
+    image.resize(size);
+
+    let image_handle = images.add(image);
+
+    // This material has the texture that has been rendered.
+    let material_handle = materials.add(StandardMaterial {
+        base_color_texture: Some(image_handle.clone()),
+        reflectance: 0.02,
+        unlit: false,
+        ..default()
+    });
+    // Main pass cube, with material containing the rendered first pass texture.
+    commands.spawn((
+        PbrBundle {
+            mesh: meshes.add(Cuboid::new(4.0, 4.0, 4.0)),
+            material: material_handle,
+            transform: Transform::from_xyz(0.0, 0.0, 1.5)
+                .with_rotation(Quat::from_rotation_x(-std::f32::consts::PI / 5.0)),
+            ..default()
+        },
+        MainPassCube,
+    ));
+    // The main pass camera.
+    commands.spawn(PointLightBundle {
+        transform: Transform::from_translation(Vec3::new(0.0, 0.0, 10.0)),
+        ..default()
+    });
+    commands.spawn(Camera3dBundle {
+        transform: Transform::from_xyz(0.0, 0.0, 15.0).looking_at(Vec3::ZERO, Vec3::Y),
+        ..default()
+    });
+    commands.spawn(VelloTarget(image_handle));
+}
+
+fn render_texture(
+    mut vello_renderer: Local<Option<VelloRenderer>>,
+    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();
+    // Animate the scene
+    let sin_time = time.elapsed_seconds().sin().mul_add(0.5, 0.5);
+    let c = Vec3::lerp(
+        Vec3::new(-1.0, 0.0, 1.0),
+        Vec3::new(1.0, 0.0, 1.0),
+        sin_time + 0.5,
+    );
+    scene.fill(
+        peniko::Fill::NonZero,
+        kurbo::Affine::translate((128.0, 128.0)),
+        peniko::Color::rgb(c.x as f64, c.y as f64, c.z as f64),
+        None,
+        &kurbo::RoundedRect::new(0.0, 0.0, 256.0, 256.0, (sin_time as f64) * 128.0),
+    );
+
+    let gpu_image = gpu_images.get(&target.0).unwrap();
+    let params = vello::RenderParams {
+        base_color: vello::peniko::Color::WHITE,
+        width: gpu_image.size.x,
+        height: gpu_image.size.y,
+        antialiasing_method: vello::AaConfig::Area,
+    };
+    renderer
+        .render_to_texture(
+            device.wgpu_device(),
+            &queue,
+            &scene,
+            &gpu_image.texture_view,
+            &params,
+        )
+        .unwrap();
+}
+
+/// Rotates the outer cube (main pass)
+fn cube_rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<MainPassCube>>) {
+    for mut transform in &mut query {
+        transform.rotate_x(1.0 * time.delta_seconds());
+        transform.rotate_y(0.7 * time.delta_seconds());
+    }
+}
diff --git a/examples/render_layers/Cargo.toml b/examples/render_layers/Cargo.toml
new file mode 100644
index 0000000..27449c2
--- /dev/null
+++ b/examples/render_layers/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "render_layers"
+version.workspace = true
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
+publish = false
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[dependencies]
+bevy_vello = { path = "../../" }
+bevy = { workspace = true, features = ["bevy_gizmos"] }
diff --git a/examples/render_layers/src/main.rs b/examples/render_layers/src/main.rs
new file mode 100644
index 0000000..95dc339
--- /dev/null
+++ b/examples/render_layers/src/main.rs
@@ -0,0 +1,148 @@
+//! Shows how to use render layers.
+
+use bevy::{color::palettes::css, prelude::*, render::view::RenderLayers};
+use bevy_vello::{prelude::*, VelloPlugin};
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_plugins(VelloPlugin)
+        .add_systems(Startup, (setup_animation, setup_background))
+        .add_systems(
+            Update,
+            (
+                layer0_animation,
+                layer1_animation,
+                layer2_background,
+                run_gizmos,
+            ),
+        )
+        .run();
+}
+
+/// A tag that will mark the scene on RenderLayer 0.
+#[derive(Component)]
+struct Layer0Scene;
+
+/// A tag that will mark the scene on RenderLayer 1.
+#[derive(Component)]
+struct Layer1Scene;
+
+/// A tag that will mark the scene on RenderLayer 2.
+#[derive(Component)]
+struct Layer2Scene;
+
+fn setup_animation(mut commands: Commands) {
+    const LAYER_0: RenderLayers = RenderLayers::layer(0);
+    const LAYER_1: RenderLayers = RenderLayers::layer(1);
+
+    // This camera can see everything on Layer 1 and Layer 2.
+    commands.spawn((
+        Camera2dBundle {
+            camera: Camera {
+                // This camera will render AFTER the blue background camera!
+                order: 1,
+                ..default()
+            },
+            ..default()
+        },
+        LAYER_0.union(&LAYER_1),
+    ));
+
+    commands.spawn((VelloSceneBundle::default(), Layer0Scene, LAYER_0));
+    commands.spawn((VelloSceneBundle::default(), Layer1Scene, LAYER_1));
+}
+
+fn setup_background(mut commands: Commands) {
+    const LAYER: RenderLayers = RenderLayers::layer(2);
+    commands.spawn((
+        Camera2dBundle {
+            camera: Camera {
+                // Render first
+                order: -1,
+                ..default()
+            },
+            ..default()
+        },
+        LAYER,
+    ));
+    commands.spawn((VelloSceneBundle::default(), Layer2Scene, LAYER));
+}
+
+fn layer0_animation(
+    mut query_scene: Query<(&mut Transform, &mut VelloScene), With<Layer0Scene>>,
+    time: Res<Time>,
+) {
+    let sin_time = time.elapsed_seconds().sin().mul_add(0.5, 0.5);
+    let (mut transform, mut scene) = query_scene.single_mut();
+    // Reset scene every frame
+    *scene = VelloScene::default();
+
+    // Animate color green to blue
+    let c = Vec3::lerp(
+        Vec3::new(0.0, 1.0, -1.0),
+        Vec3::new(0.0, 1.0, 1.0),
+        sin_time + 0.5,
+    );
+
+    // Animate the corner radius
+    scene.fill(
+        peniko::Fill::NonZero,
+        kurbo::Affine::default(),
+        peniko::Color::rgb(c.x as f64, c.y as f64, c.z as f64),
+        None,
+        &kurbo::RoundedRect::new(-50.0, -50.0, 50.0, 50.0, (sin_time as f64) * 50.0),
+    );
+
+    transform.scale = Vec3::lerp(Vec3::ONE * 0.5, Vec3::ONE * 1.0, sin_time);
+    transform.translation =
+        Vec3::lerp(Vec3::X * -100.0, Vec3::X * 100.0, sin_time) - Vec3::Y * 100.0;
+    transform.rotation = Quat::from_rotation_z(-std::f32::consts::TAU * sin_time);
+}
+
+fn layer1_animation(
+    mut query_scene: Query<(&mut Transform, &mut VelloScene), With<Layer1Scene>>,
+    time: Res<Time>,
+) {
+    let sin_time = time.elapsed_seconds().sin().mul_add(0.5, 0.5);
+    let (mut transform, mut scene) = query_scene.single_mut();
+    // Reset scene every frame
+    *scene = VelloScene::default();
+
+    // Animate color green to blue
+    let c = Vec3::lerp(
+        Vec3::new(1.0, -1.0, 0.0),
+        Vec3::new(1.0, 1.0, 0.0),
+        sin_time + 0.5,
+    );
+
+    // Animate the corner radius
+    scene.fill(
+        peniko::Fill::NonZero,
+        kurbo::Affine::default(),
+        peniko::Color::rgb(c.x as f64, c.y as f64, c.z as f64),
+        None,
+        &kurbo::RoundedRect::new(-50.0, -50.0, 50.0, 50.0, (sin_time as f64) * 50.0),
+    );
+
+    transform.scale = Vec3::lerp(Vec3::ONE * 0.5, Vec3::ONE * 1.0, sin_time);
+    transform.translation =
+        Vec3::lerp(Vec3::X * -100.0, Vec3::X * 100.0, sin_time) * Vec3::NEG_X + Vec3::Y * 100.0;
+    transform.rotation = Quat::from_rotation_z(-std::f32::consts::TAU * sin_time);
+}
+
+fn layer2_background(mut query_scene: Query<&mut VelloScene, With<Layer2Scene>>) {
+    let mut scene = query_scene.single_mut();
+    *scene = VelloScene::default();
+    scene.fill(
+        peniko::Fill::NonZero,
+        kurbo::Affine::default(),
+        peniko::Color::rgb(0.0, 0.0, 1.0),
+        None,
+        &kurbo::RoundedRect::new(-200.0, -200.0, 200.0, 200.0, 0.0),
+    );
+}
+
+fn run_gizmos(mut gizmos: Gizmos) {
+    gizmos.circle_2d(Vec2::splat(0.0), 20.0, css::RED);
+}
diff --git a/examples/text/Cargo.toml b/examples/text/Cargo.toml
index 07eaba2..89bb46e 100644
--- a/examples/text/Cargo.toml
+++ b/examples/text/Cargo.toml
@@ -9,4 +9,4 @@ publish = false
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [dependencies]
 bevy_vello = { path = "../../", features = ["default_font"] }
-bevy = { workspace = true }
+bevy = { workspace = true, features = ["default_font"] }
diff --git a/examples/text/src/main.rs b/examples/text/src/main.rs
index 291b117..e7e857e 100644
--- a/examples/text/src/main.rs
+++ b/examples/text/src/main.rs
@@ -55,8 +55,9 @@ fn setup_screenspace_text(mut commands: Commands) {
     // Vello text
     commands.spawn(VelloTextBundle {
         text: VelloTextSection {
-            value: "World-space text rendered by Vello!".to_string(),
+            value: "Screen-space text rendered by Vello!".to_string(),
             style: VelloTextStyle {
+                font_size: 24.0,
                 brush: peniko::Brush::Solid(peniko::Color::RED),
                 ..default()
             },
@@ -70,13 +71,19 @@ fn setup_screenspace_text(mut commands: Commands) {
 
     // Bevy text
     commands.spawn(
-        TextBundle::from_section("Screen-space text rendered by Bevy!", TextStyle::default())
-            .with_style(Style {
-                position_type: PositionType::Absolute,
-                top: Val::Px(100.0),
-                left: Val::Px(100.0),
+        TextBundle::from_section(
+            "Screen-space text rendered by Bevy!",
+            TextStyle {
+                font_size: 24.0,
                 ..default()
-            })
-            .with_text_justify(JustifyText::Left),
+            },
+        )
+        .with_style(Style {
+            position_type: PositionType::Absolute,
+            top: Val::Px(100.0),
+            left: Val::Px(100.0),
+            ..default()
+        })
+        .with_text_justify(JustifyText::Left),
     );
 }
diff --git a/src/render/extract.rs b/src/render/extract.rs
index 5607309..5a3cc0c 100644
--- a/src/render/extract.rs
+++ b/src/render/extract.rs
@@ -4,7 +4,7 @@ use crate::{
 };
 use bevy::{
     prelude::*,
-    render::{extract_component::ExtractComponent, Extract},
+    render::{extract_component::ExtractComponent, view::RenderLayers, Extract},
     window::PrimaryWindow,
 };
 
@@ -15,6 +15,7 @@ pub struct ExtractedRenderAsset {
     pub transform: GlobalTransform,
     pub render_mode: CoordinateSpace,
     pub ui_node: Option<Node>,
+    pub render_layers: Option<RenderLayers>,
     pub alpha: f32,
     #[cfg(feature = "lottie")]
     pub theme: Option<crate::Theme>,
@@ -23,7 +24,7 @@ pub struct ExtractedRenderAsset {
 }
 
 #[cfg(feature = "svg")]
-pub fn extract_svg_instances(
+pub fn extract_svg_assets(
     mut commands: Commands,
     query_vectors: Extract<
         Query<(
@@ -32,6 +33,7 @@ pub fn extract_svg_instances(
             &CoordinateSpace,
             &GlobalTransform,
             Option<&Node>,
+            Option<&RenderLayers>,
             &ViewVisibility,
             &InheritedVisibility,
         )>,
@@ -44,6 +46,7 @@ pub fn extract_svg_instances(
         coord_space,
         transform,
         ui_node,
+        render_layers,
         view_visibility,
         inherited_visibility,
     ) in query_vectors.iter()
@@ -63,6 +66,7 @@ pub fn extract_svg_instances(
                     asset_anchor: *asset_anchor,
                     render_mode: *coord_space,
                     ui_node: ui_node.cloned(),
+                    render_layers: render_layers.cloned(),
                     alpha: *alpha,
                     #[cfg(feature = "lottie")]
                     theme: None,
@@ -75,7 +79,7 @@ pub fn extract_svg_instances(
 }
 
 #[cfg(feature = "lottie")]
-pub fn extract_lottie_instances(
+pub fn extract_lottie_assets(
     mut commands: Commands,
     query_vectors: Extract<
         Query<(
@@ -86,6 +90,7 @@ pub fn extract_lottie_instances(
             &crate::Playhead,
             Option<&crate::Theme>,
             Option<&Node>,
+            Option<&RenderLayers>,
             &ViewVisibility,
             &InheritedVisibility,
         )>,
@@ -100,6 +105,7 @@ pub fn extract_lottie_instances(
         playhead,
         theme,
         ui_node,
+        render_layers,
         view_visibility,
         inherited_visibility,
     ) in query_vectors.iter()
@@ -123,6 +129,7 @@ pub fn extract_lottie_instances(
                     playhead,
                     alpha: *alpha,
                     ui_node: ui_node.cloned(),
+                    render_layers: render_layers.cloned(),
                 });
             }
         }
@@ -135,9 +142,10 @@ pub struct ExtractedRenderScene {
     pub transform: GlobalTransform,
     pub render_mode: CoordinateSpace,
     pub ui_node: Option<Node>,
+    pub render_layers: Option<RenderLayers>,
 }
 
-pub fn scene_instances(
+pub fn extract_scenes(
     mut commands: Commands,
     query_scenes: Extract<
         Query<(
@@ -147,11 +155,19 @@ pub fn scene_instances(
             &ViewVisibility,
             &InheritedVisibility,
             Option<&Node>,
+            Option<&RenderLayers>,
         )>,
     >,
 ) {
-    for (scene, coord_space, transform, view_visibility, inherited_visibility, ui_node) in
-        query_scenes.iter()
+    for (
+        scene,
+        coord_space,
+        transform,
+        view_visibility,
+        inherited_visibility,
+        ui_node,
+        render_layers,
+    ) in query_scenes.iter()
     {
         if view_visibility.get() && inherited_visibility.get() {
             commands.spawn(ExtractedRenderScene {
@@ -159,6 +175,7 @@ pub fn scene_instances(
                 render_mode: *coord_space,
                 scene: scene.clone(),
                 ui_node: ui_node.cloned(),
+                render_layers: render_layers.cloned(),
             });
         }
     }
@@ -169,36 +186,47 @@ pub struct ExtractedRenderText {
     pub text: VelloTextSection,
     pub text_anchor: VelloTextAnchor,
     pub transform: GlobalTransform,
-    pub render_mode: CoordinateSpace,
+    pub render_space: CoordinateSpace,
+    pub render_layers: Option<RenderLayers>,
 }
 
-impl ExtractComponent for ExtractedRenderText {
-    type QueryData = (
-        &'static VelloTextSection,
-        &'static VelloTextAnchor,
-        &'static GlobalTransform,
-        &'static CoordinateSpace,
-    );
-
-    type QueryFilter = ();
-
-    type Out = Self;
-
-    fn extract_component(
-        (text, text_anchor, transform, render_mode): bevy::ecs::query::QueryItem<
-            '_,
-            Self::QueryData,
-        >,
-    ) -> Option<Self> {
-        Some(Self {
-            text: text.clone(),
-            text_anchor: *text_anchor,
-            transform: *transform,
-            render_mode: *render_mode,
-        })
+pub fn extract_text(
+    mut commands: Commands,
+    query_scenes: Extract<
+        Query<(
+            &VelloTextSection,
+            &VelloTextAnchor,
+            &GlobalTransform,
+            &ViewVisibility,
+            &InheritedVisibility,
+            &CoordinateSpace,
+            Option<&RenderLayers>,
+        )>,
+    >,
+) {
+    for (
+        text,
+        text_anchor,
+        transform,
+        view_visibility,
+        inherited_visibility,
+        render_space,
+        render_layers,
+    ) in query_scenes.iter()
+    {
+        if view_visibility.get() && inherited_visibility.get() {
+            commands.spawn(ExtractedRenderText {
+                text: text.clone(),
+                text_anchor: *text_anchor,
+                transform: *transform,
+                render_space: *render_space,
+                render_layers: render_layers.cloned(),
+            });
+        }
     }
 }
 
+/// A screenspace render target. We use a resizable fullscreen quad.
 #[derive(Component, Default)]
 pub struct SSRenderTarget(pub Handle<Image>);
 
@@ -227,6 +255,5 @@ pub fn extract_pixel_scale(
         .get_single()
         .map(|window| window.resolution.scale_factor())
         .unwrap_or(1.0);
-
     pixel_scale.0 = scale_factor;
 }
diff --git a/src/render/mod.rs b/src/render/mod.rs
index 2647444..c33ef9a 100644
--- a/src/render/mod.rs
+++ b/src/render/mod.rs
@@ -62,14 +62,23 @@ impl Material2d for VelloCanvasMaterial {
 #[derive(Deref, DerefMut)]
 pub struct VelloRenderer(vello::Renderer);
 
-#[derive(Resource, Deref, DerefMut)]
-#[cfg(feature = "lottie")]
-pub struct VelatoRenderer(velato::Renderer);
-
-#[cfg(feature = "lottie")]
-impl Default for VelatoRenderer {
-    fn default() -> Self {
-        // TODO: Velato should have a ::default()
-        Self(velato::Renderer::new())
+impl VelloRenderer {
+    pub fn from_device(device: &vello::wgpu::Device) -> Self {
+        let renderer = vello::Renderer::new(
+            device,
+            vello::RendererOptions {
+                surface_format: None,
+                use_cpu: false,
+                antialiasing_support: vello::AaSupport::area_only(),
+                num_init_threads: None,
+            },
+        )
+        // TODO: Attempt CPU fallback. Support changing antialias settings.
+        .expect("No GPU Device");
+        VelloRenderer(renderer)
     }
 }
+
+#[derive(Resource, Deref, DerefMut, Default)]
+#[cfg(feature = "lottie")]
+pub struct VelatoRenderer(velato::Renderer);
diff --git a/src/render/plugin.rs b/src/render/plugin.rs
index 5682093..ede5723 100644
--- a/src/render/plugin.rs
+++ b/src/render/plugin.rs
@@ -3,8 +3,8 @@ use super::{
     prepare, systems,
 };
 use crate::{
-    render::{extract::ExtractedRenderText, SSRT_SHADER_HANDLE},
-    VelloAsset, VelloCanvasMaterial, VelloFont, VelloScene,
+    render::SSRT_SHADER_HANDLE, VelloAsset, VelloCanvasMaterial, VelloFont, VelloScene,
+    VelloTextSection,
 };
 use bevy::{
     asset::load_internal_asset,
@@ -35,11 +35,11 @@ impl Plugin for VelloRenderPlugin {
         };
 
         #[cfg(feature = "svg")]
-        render_app.add_systems(ExtractSchedule, extract::extract_svg_instances);
+        render_app.add_systems(ExtractSchedule, extract::extract_svg_assets);
         #[cfg(feature = "lottie")]
         render_app
             .init_resource::<super::VelatoRenderer>()
-            .add_systems(ExtractSchedule, extract::extract_lottie_instances);
+            .add_systems(ExtractSchedule, extract::extract_lottie_assets);
 
         render_app
             .insert_resource(ExtractedPixelScale(1.0))
@@ -47,13 +47,14 @@ impl Plugin for VelloRenderPlugin {
                 ExtractSchedule,
                 (
                     extract::extract_pixel_scale.in_set(RenderSet::ExtractCommands),
-                    extract::scene_instances,
+                    extract::extract_scenes,
+                    extract::extract_text,
                 ),
             )
             .add_systems(
                 Render,
                 (
-                    prepare::prepare_vector_affines,
+                    prepare::prepare_asset_affines,
                     prepare::prepare_scene_affines,
                     prepare::prepare_text_affines,
                 )
@@ -61,14 +62,13 @@ impl Plugin for VelloRenderPlugin {
             )
             .add_systems(
                 Render,
-                systems::render_scene
+                systems::render_frame
                     .in_set(RenderSet::Render)
                     .run_if(resource_exists::<RenderDevice>),
             );
 
         app.add_plugins((
             Material2dPlugin::<VelloCanvasMaterial>::default(),
-            ExtractComponentPlugin::<ExtractedRenderText>::default(),
             ExtractComponentPlugin::<SSRenderTarget>::default(),
             RenderAssetPlugin::<VelloFont>::default(),
         ))
@@ -79,7 +79,13 @@ impl Plugin for VelloRenderPlugin {
         )
         .add_systems(
             PostUpdate,
-            check_visibility::<Or<(With<VelloScene>, With<Handle<VelloAsset>>)>>
+            check_visibility::<
+                Or<(
+                    With<VelloScene>,
+                    With<Handle<VelloAsset>>,
+                    With<VelloTextSection>,
+                )>,
+            >
                 .in_set(VisibilitySystems::CheckVisibility),
         );
     }
diff --git a/src/render/prepare.rs b/src/render/prepare.rs
index 7d0d291..140b691 100644
--- a/src/render/prepare.rs
+++ b/src/render/prepare.rs
@@ -4,7 +4,10 @@ use super::extract::{
 use crate::CoordinateSpace;
 use bevy::{
     prelude::*,
-    render::{camera::ExtractedCamera, view::ExtractedView},
+    render::{
+        camera::ExtractedCamera,
+        view::{ExtractedView, RenderLayers},
+    },
 };
 use vello::kurbo::Affine;
 
@@ -105,165 +108,187 @@ impl PrepareRenderInstance for ExtractedRenderAsset {
     }
 }
 
-pub fn prepare_vector_affines(
+pub fn prepare_asset_affines(
     mut commands: Commands,
-    camera: Query<(&ExtractedCamera, &ExtractedView), With<Camera2d>>,
-    mut render_assets: Query<(Entity, &ExtractedRenderAsset)>,
+    views: Query<(&ExtractedCamera, &ExtractedView, Option<&RenderLayers>), With<Camera2d>>,
+    mut render_entities: Query<(Entity, &ExtractedRenderAsset)>,
     pixel_scale: Res<ExtractedPixelScale>,
 ) {
-    let Ok((camera, view)) = camera.get_single() else {
-        return;
-    };
-    let viewport_size: UVec2 = camera.physical_viewport_size.unwrap();
-    for (entity, render_asset) in render_assets.iter_mut() {
-        // Prepare render data needed for the subsequent render system
-        let final_transform = render_asset.final_transform();
-        let affine =
-            render_asset.scene_affine(view, *final_transform, pixel_scale.0, viewport_size);
-
-        commands.entity(entity).insert((affine, final_transform));
+    for (camera, view, maybe_camera_layers) in views.iter() {
+        let camera_render_layers = maybe_camera_layers.unwrap_or_default();
+        let viewport_size: UVec2 = camera.physical_viewport_size.unwrap();
+        for (entity, render_entity) in render_entities.iter_mut() {
+            let maybe_entity_layers = render_entity.render_layers.clone();
+            let entity_render_layers = maybe_entity_layers.unwrap_or_default();
+            if !camera_render_layers.intersects(&entity_render_layers) {
+                continue;
+            }
+
+            // Prepare render data needed for the subsequent render system
+            let final_transform = render_entity.final_transform();
+            let affine =
+                render_entity.scene_affine(view, *final_transform, pixel_scale.0, viewport_size);
+
+            commands.entity(entity).insert((affine, final_transform));
+        }
     }
 }
 
 pub fn prepare_scene_affines(
     mut commands: Commands,
-    camera: Query<(&ExtractedCamera, &ExtractedView), With<Camera2d>>,
-    mut render_scenes: Query<(Entity, &ExtractedRenderScene)>,
+    views: Query<(&ExtractedCamera, &ExtractedView, Option<&RenderLayers>), With<Camera2d>>,
+    render_entities: Query<(Entity, &ExtractedRenderScene)>,
     pixel_scale: Res<ExtractedPixelScale>,
 ) {
-    let Ok((camera, view)) = camera.get_single() else {
-        return;
-    };
-    let size_pixels: UVec2 = camera.physical_viewport_size.unwrap();
-    let (pixels_x, pixels_y) = (size_pixels.x as f32, size_pixels.y as f32);
-    for (entity, render_scene) in render_scenes.iter_mut() {
-        let ndc_to_pixels_matrix = Mat4::from_cols_array_2d(&[
-            [pixels_x / 2.0, 0.0, 0.0, pixels_x / 2.0],
-            [0.0, pixels_y / 2.0, 0.0, pixels_y / 2.0],
-            [0.0, 0.0, 1.0, 0.0],
-            [0.0, 0.0, 0.0, 1.0],
-        ])
-        .transpose();
-
-        let world_transform = render_scene.transform;
-
-        let raw_transform = match render_scene.render_mode {
-            CoordinateSpace::ScreenSpace => {
-                let mut model_matrix = world_transform.compute_matrix().mul_scalar(pixel_scale.0);
-
-                if let Some(node) = &render_scene.ui_node {
-                    // The Bevy Transform for a UI node seems to always have the origin
-                    // of the translation at the center of its bounding box. Here we
-                    // move the origin back to the top left, so that, e.g., drawing a
-                    // shape with center=(20,20) inside of a 40x40 UI node results in
-                    // the shape being centered within the node.
-                    let Vec2 { x, y } = node.size() * pixel_scale.0;
-                    model_matrix.w_axis.x -= x / 2.0;
-                    model_matrix.w_axis.y -= y / 2.0;
-
-                    // Note that there's no need to flip the Y axis in this case, as
-                    // Bevy handles it for us.
-                } else {
-                    model_matrix.w_axis.y *= -1.0;
-                }
-
-                model_matrix
+    for (camera, view, maybe_camera_layers) in views.iter() {
+        let camera_render_layers = maybe_camera_layers.unwrap_or_default();
+        let size_pixels: UVec2 = camera.physical_viewport_size.unwrap();
+        let (pixels_x, pixels_y) = (size_pixels.x as f32, size_pixels.y as f32);
+
+        // Render scenes
+        for (entity, render_entity) in render_entities.iter() {
+            let maybe_entity_layers = render_entity.render_layers.clone();
+            let entity_render_layers = maybe_entity_layers.unwrap_or_default();
+            if !camera_render_layers.intersects(&entity_render_layers) {
+                continue;
             }
-            CoordinateSpace::WorldSpace => {
-                let mut model_matrix = world_transform.compute_matrix();
-                model_matrix.w_axis.y *= -1.0;
 
-                let (projection_mat, view_mat) = {
-                    let mut view_mat = view.world_from_view.compute_matrix();
-                    view_mat.w_axis.y *= -1.0;
-
-                    (view.clip_from_view, view_mat)
-                };
+            let ndc_to_pixels_matrix = Mat4::from_cols_array_2d(&[
+                [pixels_x / 2.0, 0.0, 0.0, pixels_x / 2.0],
+                [0.0, pixels_y / 2.0, 0.0, pixels_y / 2.0],
+                [0.0, 0.0, 1.0, 0.0],
+                [0.0, 0.0, 0.0, 1.0],
+            ])
+            .transpose();
+
+            let world_transform = render_entity.transform;
+
+            let raw_transform = match render_entity.render_mode {
+                CoordinateSpace::ScreenSpace => {
+                    let mut model_matrix =
+                        world_transform.compute_matrix().mul_scalar(pixel_scale.0);
+
+                    if let Some(node) = &render_entity.ui_node {
+                        // The Bevy Transform for a UI node seems to always have the origin
+                        // of the translation at the center of its bounding box. Here we
+                        // move the origin back to the top left, so that, e.g., drawing a
+                        // shape with center=(20,20) inside of a 40x40 UI node results in
+                        // the shape being centered within the node.
+                        let Vec2 { x, y } = node.size() * pixel_scale.0;
+                        model_matrix.w_axis.x -= x / 2.0;
+                        model_matrix.w_axis.y -= y / 2.0;
+
+                        // Note that there's no need to flip the Y axis in this case, as
+                        // Bevy handles it for us.
+                    } else {
+                        model_matrix.w_axis.y *= -1.0;
+                    }
+
+                    model_matrix
+                }
+                CoordinateSpace::WorldSpace => {
+                    let mut model_matrix = world_transform.compute_matrix();
+                    model_matrix.w_axis.y *= -1.0;
 
-                let view_proj_matrix = projection_mat * view_mat.inverse();
+                    let (projection_mat, view_mat) = {
+                        let mut view_mat = view.world_from_view.compute_matrix();
+                        view_mat.w_axis.y *= -1.0;
 
-                ndc_to_pixels_matrix * view_proj_matrix * model_matrix
-            }
-        };
+                        (view.clip_from_view, view_mat)
+                    };
 
-        let transform: [f32; 16] = raw_transform.to_cols_array();
+                    let view_proj_matrix = projection_mat * view_mat.inverse();
 
-        // | a c e |
-        // | b d f |
-        // | 0 0 1 |
-        let transform: [f64; 6] = [
-            transform[0] as f64,  // a
-            -transform[1] as f64, // b
-            -transform[4] as f64, // c
-            transform[5] as f64,  // d
-            transform[12] as f64, // e
-            transform[13] as f64, // f
-        ];
-
-        commands
-            .entity(entity)
-            .insert(PreparedAffine(Affine::new(transform)));
+                    ndc_to_pixels_matrix * view_proj_matrix * model_matrix
+                }
+            };
+
+            let transform: [f32; 16] = raw_transform.to_cols_array();
+
+            // | a c e |
+            // | b d f |
+            // | 0 0 1 |
+            let transform: [f64; 6] = [
+                transform[0] as f64,  // a
+                -transform[1] as f64, // b
+                -transform[4] as f64, // c
+                transform[5] as f64,  // d
+                transform[12] as f64, // e
+                transform[13] as f64, // f
+            ];
+
+            commands
+                .entity(entity)
+                .insert(PreparedAffine(Affine::new(transform)));
+        }
     }
 }
 
 pub fn prepare_text_affines(
     mut commands: Commands,
-    camera: Query<(&ExtractedCamera, &ExtractedView), With<Camera2d>>,
-    render_texts: Query<(Entity, &ExtractedRenderText)>,
+    views: Query<(&ExtractedCamera, &ExtractedView, Option<&RenderLayers>), With<Camera2d>>,
+    render_entities: Query<(Entity, &ExtractedRenderText)>,
     pixel_scale: Res<ExtractedPixelScale>,
 ) {
-    let Ok((camera, view)) = camera.get_single() else {
-        return;
-    };
-    let size_pixels: UVec2 = camera.physical_viewport_size.unwrap();
-    let (pixels_x, pixels_y) = (size_pixels.x as f32, size_pixels.y as f32);
-    for (entity, render_text) in render_texts.iter() {
-        let ndc_to_pixels_matrix = Mat4::from_cols_array_2d(&[
-            [pixels_x / 2.0, 0.0, 0.0, pixels_x / 2.0],
-            [0.0, pixels_y / 2.0, 0.0, pixels_y / 2.0],
-            [0.0, 0.0, 1.0, 0.0],
-            [0.0, 0.0, 0.0, 1.0],
-        ])
-        .transpose();
-
-        let world_transform = render_text.transform;
-
-        let mut model_matrix = world_transform.compute_matrix();
-        model_matrix.w_axis.y *= -1.0;
-
-        let (projection_mat, view_mat) = {
-            let mut view_mat = view.world_from_view.compute_matrix();
-            view_mat.w_axis.y *= -1.0;
-
-            (view.clip_from_view, view_mat)
-        };
+    for (camera, view, maybe_camera_layers) in views.iter() {
+        let camera_render_layers = maybe_camera_layers.unwrap_or_default();
+        let size_pixels: UVec2 = camera.physical_viewport_size.unwrap();
+        let (pixels_x, pixels_y) = (size_pixels.x as f32, size_pixels.y as f32);
+
+        for (entity, render_entity) in render_entities.iter() {
+            let maybe_entity_layers = render_entity.render_layers.clone();
+            let entity_render_layers = maybe_entity_layers.unwrap_or_default();
+            if !camera_render_layers.intersects(&entity_render_layers) {
+                continue;
+            }
 
-        let view_proj_matrix = projection_mat * view_mat.inverse();
-        let vello_matrix = ndc_to_pixels_matrix * view_proj_matrix;
+            let ndc_to_pixels_matrix = Mat4::from_cols_array_2d(&[
+                [pixels_x / 2.0, 0.0, 0.0, pixels_x / 2.0],
+                [0.0, pixels_y / 2.0, 0.0, pixels_y / 2.0],
+                [0.0, 0.0, 1.0, 0.0],
+                [0.0, 0.0, 0.0, 1.0],
+            ])
+            .transpose();
 
-        let raw_transform = match render_text.render_mode {
-            CoordinateSpace::ScreenSpace => {
-                world_transform.compute_matrix().mul_scalar(pixel_scale.0)
-            }
-            CoordinateSpace::WorldSpace => vello_matrix * model_matrix,
-        };
+            let world_transform = render_entity.transform;
 
-        let transform: [f32; 16] = raw_transform.to_cols_array();
+            let mut model_matrix = world_transform.compute_matrix();
+            model_matrix.w_axis.y *= -1.0;
 
-        // | a c e |
-        // | b d f |
-        // | 0 0 1 |
-        let transform: [f64; 6] = [
-            transform[0] as f64,  // a
-            -transform[1] as f64, // b
-            -transform[4] as f64, // c
-            transform[5] as f64,  // d
-            transform[12] as f64, // e
-            transform[13] as f64, // f
-        ];
+            let (projection_mat, view_mat) = {
+                let mut view_mat = view.world_from_view.compute_matrix();
+                view_mat.w_axis.y *= -1.0;
 
-        commands
-            .entity(entity)
-            .insert(PreparedAffine(Affine::new(transform)));
+                (view.clip_from_view, view_mat)
+            };
+
+            let view_proj_matrix = projection_mat * view_mat.inverse();
+            let vello_matrix = ndc_to_pixels_matrix * view_proj_matrix;
+
+            let raw_transform = match render_entity.render_space {
+                CoordinateSpace::ScreenSpace => {
+                    world_transform.compute_matrix().mul_scalar(pixel_scale.0)
+                }
+                CoordinateSpace::WorldSpace => vello_matrix * model_matrix,
+            };
+
+            let transform: [f32; 16] = raw_transform.to_cols_array();
+
+            // | a c e |
+            // | b d f |
+            // | 0 0 1 |
+            let transform: [f64; 6] = [
+                transform[0] as f64,  // a
+                -transform[1] as f64, // b
+                -transform[4] as f64, // c
+                transform[5] as f64,  // d
+                transform[12] as f64, // e
+                transform[13] as f64, // f
+            ];
+
+            commands
+                .entity(entity)
+                .insert(PreparedAffine(Affine::new(transform)));
+        }
     }
 }
diff --git a/src/render/systems.rs b/src/render/systems.rs
index fd53266..8de93d6 100644
--- a/src/render/systems.rs
+++ b/src/render/systems.rs
@@ -4,11 +4,13 @@ use super::{
     VelloRenderer,
 };
 use crate::{
-    render::extract::ExtractedRenderScene, CoordinateSpace, VelloCanvasMaterial, VelloFont,
+    render::extract::ExtractedRenderScene, CoordinateSpace, VelloAsset, VelloCanvasMaterial,
+    VelloFont, VelloScene, VelloTextSection,
 };
 use bevy::{
     prelude::*,
     render::{
+        camera::ExtractedCamera,
         mesh::Indices,
         render_asset::{RenderAssetUsages, RenderAssets},
         render_resource::{
@@ -17,12 +19,12 @@ use bevy::{
         },
         renderer::{RenderDevice, RenderQueue},
         texture::GpuImage,
-        view::NoFrustumCulling,
+        view::{NoFrustumCulling, RenderLayers},
     },
     sprite::{MaterialMesh2dBundle, Mesh2dHandle},
     window::{WindowResized, WindowResolution},
 };
-use vello::{kurbo::Affine, AaSupport, RenderParams, Renderer, RendererOptions, Scene};
+use vello::{kurbo::Affine, RenderParams, Scene};
 
 pub fn setup_image(images: &mut Assets<Image>, window: &WindowResolution) -> Handle<Image> {
     let size = Extent3d {
@@ -56,11 +58,12 @@ pub fn setup_image(images: &mut Assets<Image>, window: &WindowResolution) -> Han
 /// Transforms all the vectors extracted from the game world and places them in
 /// a scene, and renders the scene to a texture with WGPU
 #[allow(clippy::complexity)]
-pub fn render_scene(
+pub fn render_frame(
     ss_render_target: Query<&SSRenderTarget>,
-    query_render_assets: Query<(&PreparedAffine, &ExtractedRenderAsset)>,
-    query_render_scenes: Query<(&PreparedAffine, &ExtractedRenderScene)>,
-    query_render_texts: Query<(&PreparedAffine, &ExtractedRenderText)>,
+    views: Query<(&ExtractedCamera, Option<&RenderLayers>), With<Camera2d>>,
+    view_assets: Query<(&PreparedAffine, &ExtractedRenderAsset)>,
+    view_scenes: Query<(&PreparedAffine, &ExtractedRenderScene)>,
+    view_text: Query<(&PreparedAffine, &ExtractedRenderText)>,
     mut font_render_assets: ResMut<RenderAssets<VelloFont>>,
     gpu_images: Res<RenderAssets<GpuImage>>,
     device: Res<RenderDevice>,
@@ -68,22 +71,8 @@ pub fn render_scene(
     mut vello_renderer: Local<Option<VelloRenderer>>,
     #[cfg(feature = "lottie")] mut velato_renderer: ResMut<super::VelatoRenderer>,
 ) {
-    let renderer = vello_renderer.get_or_insert_with(|| {
-        VelloRenderer(
-            Renderer::new(
-                device.wgpu_device(),
-                RendererOptions {
-                    surface_format: None,
-                    use_cpu: false,
-                    antialiasing_support: AaSupport::area_only(),
-                    num_init_threads: None,
-                },
-            )
-            // TODO: Attempt CPU fallback. Support changing antialias settings.
-            .expect("No GPU Device"),
-        )
-    });
-
+    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;
@@ -95,7 +84,7 @@ pub fn render_scene(
         Scene(&'a ExtractedRenderScene),
         Text(&'a ExtractedRenderText),
     }
-    let mut render_queue: Vec<(f32, CoordinateSpace, (Affine, RenderItem))> = query_render_assets
+    let mut render_queue: Vec<(f32, CoordinateSpace, (Affine, RenderItem))> = view_assets
         .iter()
         .map(|(&affine, asset)| {
             (
@@ -105,17 +94,17 @@ pub fn render_scene(
             )
         })
         .collect();
-    render_queue.extend(query_render_scenes.iter().map(|(&affine, scene)| {
+    render_queue.extend(view_scenes.iter().map(|(&affine, scene)| {
         (
             scene.transform.translation().z,
             scene.render_mode,
             (*affine, RenderItem::Scene(scene)),
         )
     }));
-    render_queue.extend(query_render_texts.iter().map(|(&affine, text)| {
+    render_queue.extend(view_text.iter().map(|(&affine, text)| {
         (
             text.transform.translation().z,
-            text.render_mode,
+            text.render_space,
             (*affine, RenderItem::Text(text)),
         )
     }));
@@ -131,103 +120,124 @@ pub fn render_scene(
         },
     );
 
-    // Apply transforms to the respective fragments and add them to the
-    // scene to be rendered
+    // Respect camera ordering
+    let mut views: Vec<(&ExtractedCamera, Option<&RenderLayers>)> = views.into_iter().collect();
+    views.sort_by(|(camera_a, _), (camera_b, _)| camera_a.order.cmp(&camera_b.order));
+
+    // Render the frame
     let mut scene_buffer = Scene::new();
-    for (_, _, (affine, render_item)) in render_queue.iter_mut() {
-        #[allow(unused_variables)]
-        match render_item {
-            RenderItem::Asset(ExtractedRenderAsset {
-                asset,
-                alpha,
-                #[cfg(feature = "lottie")]
-                theme,
-                #[cfg(feature = "lottie")]
-                playhead,
-                ..
-            }) => match &asset.file {
-                #[cfg(feature = "svg")]
-                crate::VectorFile::Svg(scene) => {
-                    if *alpha < 1.0 {
-                        scene_buffer.push_layer(
-                            vello::peniko::Mix::Normal,
-                            *alpha,
-                            *affine,
-                            &vello::kurbo::Rect::new(
-                                0.0,
-                                0.0,
-                                asset.width as f64,
-                                asset.height as f64,
-                            ),
-                        );
+    for (_, maybe_camera_layers) in views.iter() {
+        let view_camera_layers = maybe_camera_layers.unwrap_or_default();
+        // Apply transforms to the respective fragments and add them to the
+        // scene to be rendered
+        for (_, _, (affine, render_item)) in
+            render_queue
+                .iter()
+                .filter(|(_, _, (_, asset))| match asset {
+                    RenderItem::Scene(ExtractedRenderScene { render_layers, .. })
+                    | &RenderItem::Text(ExtractedRenderText { render_layers, .. })
+                    | RenderItem::Asset(ExtractedRenderAsset { render_layers, .. }) => {
+                        render_layers
+                            .as_ref()
+                            .unwrap_or_default()
+                            .intersects(view_camera_layers)
                     }
-                    scene_buffer.append(scene, Some(*affine));
-                    if *alpha < 1.0 {
-                        scene_buffer.pop_layer();
+                })
+        {
+            #[allow(unused_variables)]
+            match render_item {
+                RenderItem::Asset(ExtractedRenderAsset {
+                    asset,
+                    alpha,
+                    #[cfg(feature = "lottie")]
+                    theme,
+                    #[cfg(feature = "lottie")]
+                    playhead,
+                    ..
+                }) => match &asset.file {
+                    #[cfg(feature = "svg")]
+                    crate::VectorFile::Svg(scene) => {
+                        if *alpha < 1.0 {
+                            scene_buffer.push_layer(
+                                vello::peniko::Mix::Normal,
+                                *alpha,
+                                *affine,
+                                &vello::kurbo::Rect::new(
+                                    0.0,
+                                    0.0,
+                                    asset.width as f64,
+                                    asset.height as f64,
+                                ),
+                            );
+                        }
+                        scene_buffer.append(scene, Some(*affine));
+                        if *alpha < 1.0 {
+                            scene_buffer.pop_layer();
+                        }
                     }
-                }
-                #[cfg(feature = "lottie")]
-                crate::VectorFile::Lottie(composition) => {
-                    if *alpha < 1.0 {
-                        scene_buffer.push_layer(
-                            vello::peniko::Mix::Normal,
-                            *alpha,
+                    #[cfg(feature = "lottie")]
+                    crate::VectorFile::Lottie(composition) => {
+                        if *alpha < 1.0 {
+                            scene_buffer.push_layer(
+                                vello::peniko::Mix::Normal,
+                                *alpha,
+                                *affine,
+                                &vello::kurbo::Rect::new(
+                                    0.0,
+                                    0.0,
+                                    asset.width as f64,
+                                    asset.height as f64,
+                                ),
+                            );
+                        }
+                        velato_renderer.append(
+                            {
+                                theme
+                                    .as_ref()
+                                    .map(|cs| cs.recolor(composition))
+                                    .as_ref()
+                                    .unwrap_or(composition)
+                            },
+                            *playhead as f64,
                             *affine,
-                            &vello::kurbo::Rect::new(
-                                0.0,
-                                0.0,
-                                asset.width as f64,
-                                asset.height as f64,
-                            ),
+                            1.0,
+                            &mut scene_buffer,
                         );
+                        if *alpha < 1.0 {
+                            scene_buffer.pop_layer();
+                        }
                     }
-                    velato_renderer.append(
-                        {
-                            theme
-                                .as_ref()
-                                .map(|cs| cs.recolor(composition))
-                                .as_ref()
-                                .unwrap_or(composition)
-                        },
-                        *playhead as f64,
-                        *affine,
-                        1.0,
-                        &mut scene_buffer,
-                    );
-                    if *alpha < 1.0 {
-                        scene_buffer.pop_layer();
-                    }
+                    #[cfg(not(any(feature = "svg", feature = "lottie")))]
+                    _ => unimplemented!(),
+                },
+                RenderItem::Scene(ExtractedRenderScene { scene, .. }) => {
+                    scene_buffer.append(scene, Some(*affine));
                 }
-                #[cfg(not(any(feature = "svg", feature = "lottie")))]
-                _ => unimplemented!(),
-            },
-            RenderItem::Scene(ExtractedRenderScene { scene, .. }) => {
-                scene_buffer.append(scene, Some(*affine));
-            }
-            RenderItem::Text(ExtractedRenderText {
-                text, text_anchor, ..
-            }) => {
-                if let Some(font) = font_render_assets.get_mut(text.style.font.id()) {
-                    font.render(&mut scene_buffer, *affine, text, *text_anchor);
+                RenderItem::Text(ExtractedRenderText {
+                    text, text_anchor, ..
+                }) => {
+                    if let Some(font) = font_render_assets.get_mut(text.style.font.id()) {
+                        font.render(&mut scene_buffer, *affine, text, *text_anchor);
+                    }
                 }
             }
         }
-    }
 
-    renderer
-        .render_to_texture(
-            device.wgpu_device(),
-            &queue,
-            &scene_buffer,
-            &gpu_image.texture_view,
-            &RenderParams {
-                base_color: vello::peniko::Color::TRANSPARENT,
-                width: gpu_image.size.x as u32,
-                height: gpu_image.size.y as u32,
-                antialiasing_method: vello::AaConfig::Area,
-            },
-        )
-        .unwrap();
+        renderer
+            .render_to_texture(
+                device.wgpu_device(),
+                &queue,
+                &scene_buffer,
+                &gpu_image.texture_view,
+                &RenderParams {
+                    base_color: vello::peniko::Color::TRANSPARENT,
+                    width: gpu_image.size.x,
+                    height: gpu_image.size.y,
+                    antialiasing_method: vello::AaConfig::Area,
+                },
+            )
+            .unwrap();
+    }
 }
 
 pub fn resize_rendertargets(
@@ -323,7 +333,14 @@ pub fn setup_ss_rendertarget(
 /// Hide the render target canvas if there is nothing to render
 pub fn clear_when_empty(
     mut query_render_target: Query<&mut Visibility, With<SSRenderTarget>>,
-    render_items: Query<(&mut CoordinateSpace, &ViewVisibility)>,
+    render_items: Query<
+        (),
+        Or<(
+            With<VelloScene>,
+            With<Handle<VelloAsset>>,
+            With<VelloTextSection>,
+        )>,
+    >,
 ) {
     if let Ok(mut visibility) = query_render_target.get_single_mut() {
         if render_items.is_empty() {