diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..6d38120
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,87 @@
+name: Check and Lint
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+jobs:
+  check:
+    name: check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@stable
+      - name: Install alsa and udev
+        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev
+      - run: cargo run -p ci -- check
+
+  wasm-check:
+    name: wasm-check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: wasm32-unknown-unknown
+      - run: cargo run -p ci -- wasm-check
+
+  example-check:
+    name: example-check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@stable
+      - name: Install alsa and udev
+        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev
+      - run: cargo run -p ci -- example-check
+
+  fmt:
+    name: fmt
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@stable
+      - name: Install alsa and udev
+        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev
+      - run: cargo run -p ci -- fmt
+
+  test:
+    name: test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@stable
+      - name: Install alsa and udev
+        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev
+      - run: cargo run -p ci -- test
+
+  doc-test:
+    name: doc-test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@stable
+      - name: Install alsa and udev
+        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev
+      - run: cargo run -p ci -- doc-test
+
+  doc-check:
+    name: doc-check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@stable
+      - name: Install alsa and udev
+        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev
+      - run: cargo run -p ci -- doc-check
+
+  clippy:
+    name: clippy
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@stable
+      - name: Install alsa and udev
+        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev
+      - run: cargo run -p ci -- clippy
\ No newline at end of file
diff --git a/Cargo.toml b/Cargo.toml
index d46cd4e..f5c05a3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -20,3 +20,9 @@ thiserror = "1.0.50"
 [dev-dependencies]
 lerp = "0.4"
 bevy = { version = "0.12", default-features = true }
+
+[workspace]
+resolver = "2"
+members = [
+    "ci"
+]
diff --git a/ci/Cargo.toml b/ci/Cargo.toml
new file mode 100644
index 0000000..4843560
--- /dev/null
+++ b/ci/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "ci"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1.0.70"
+xshell = "0.2"
+bitflags = "2.0"
diff --git a/ci/src/main.rs b/ci/src/main.rs
new file mode 100644
index 0000000..138baea
--- /dev/null
+++ b/ci/src/main.rs
@@ -0,0 +1,118 @@
+use anyhow::bail;
+use bitflags::bitflags;
+use xshell::{cmd, Shell};
+
+mod utils;
+use utils::*;
+
+bitflags! {
+    #[derive(Clone, Copy)]
+    struct Check: u32 {
+        const CHECK = 0b00000001;
+        const WASM_CHECK = 0b00000010;
+        const EXAMPLE_CHECK = 0b00000100;
+        const FMT = 0b00001000;
+        const TEST = 0b00010000;
+        const DOC_TEST = 0b00100000;
+        const DOC_CHECK = 0b01000000;
+        const CLIPPY = 0b10000000;
+    }
+}
+
+fn main() -> anyhow::Result<()> {
+    std::env::set_var("RUSTFLAGS", "-D warnings");
+
+    let arguments = [
+        ("check", Check::CHECK),
+        ("wasm-check", Check::WASM_CHECK),
+        ("example-check", Check::EXAMPLE_CHECK),
+        ("fmt", Check::FMT),
+        ("test", Check::TEST),
+        ("doc-test", Check::DOC_TEST),
+        ("doc-check", Check::DOC_CHECK),
+        ("clippy", Check::CLIPPY),
+    ];
+
+    let what_to_run = if let Some(arg) = std::env::args().nth(1).as_deref() {
+        if let Some((_, check)) = arguments.iter().find(|(str, _)| *str == arg) {
+            *check
+        } else {
+            bail!(
+                "Invalid argument: {arg:?}.\nEnter one of: {}.",
+                arguments[1..]
+                    .iter()
+                    .map(|(s, _)| s)
+                    .fold(arguments[0].0.to_owned(), |c, v| c + ", " + v)
+            );
+        }
+    } else {
+        Check::all()
+    };
+
+    let sh = Shell::new()?;
+    if what_to_run.contains(Check::CHECK) {
+        check(&sh, Target::Default)?;
+    }
+    if what_to_run.contains(Check::WASM_CHECK) {
+        check(&sh, Target::Wasm)?;
+    }
+    if what_to_run.contains(Check::EXAMPLE_CHECK) {
+        example_check(&sh)?;
+    }
+    if what_to_run.contains(Check::FMT) {
+        fmt(&sh)?;
+    }
+    if what_to_run.contains(Check::TEST) {
+        test(&sh)?;
+    }
+    if what_to_run.contains(Check::DOC_TEST) {
+        doc_test(&sh)?;
+    }
+    if what_to_run.contains(Check::DOC_CHECK) {
+        doc_check(&sh)?;
+    }
+    if what_to_run.contains(Check::CLIPPY) {
+        clippy(&sh)?;
+    }
+    Ok(())
+}
+
+fn check(sh: &Shell, target: Target) -> anyhow::Result<()> {
+    let target_flags = &target.flags();
+    cmd!(sh, "cargo check {target_flags...} --features bevy/webgl2").run()?;
+    Ok(())
+}
+
+fn example_check(sh: &Shell) -> anyhow::Result<()> {
+    cmd!(sh, "cargo check --examples").run()?;
+    Ok(())
+}
+
+fn fmt(sh: &Shell) -> anyhow::Result<()> {
+    cmd!(sh, "cargo fmt --all -- --check").run()?;
+    Ok(())
+}
+
+fn test(sh: &Shell) -> anyhow::Result<()> {
+    cmd!(sh, "cargo test --workspace --lib --bins --tests").run()?;
+    Ok(())
+}
+
+fn doc_test(sh: &Shell) -> anyhow::Result<()> {
+    cmd!(sh, "cargo test --workspace --doc").run()?;
+    Ok(())
+}
+
+fn doc_check(sh: &Shell) -> anyhow::Result<()> {
+    cmd!(
+        sh,
+        "cargo doc --workspace --all-features --no-deps --document-private-items"
+    )
+    .run()?;
+    Ok(())
+}
+
+fn clippy(sh: &Shell) -> anyhow::Result<()> {
+    cmd!(sh, "cargo clippy --workspace --all-targets").run()?;
+    Ok(())
+}
diff --git a/ci/src/utils.rs b/ci/src/utils.rs
new file mode 100644
index 0000000..763cd26
--- /dev/null
+++ b/ci/src/utils.rs
@@ -0,0 +1,13 @@
+pub enum Target {
+    Default,
+    Wasm,
+}
+
+impl Target {
+    pub fn flags(&self) -> Vec<String> {
+        match self {
+            Target::Default => vec![],
+            Target::Wasm => vec!["--target".to_owned(), "wasm32-unknown-unknown".to_owned()],
+        }
+    }
+}
diff --git a/examples/3d.rs b/examples/3d.rs
index ebd96e9..e8560c7 100644
--- a/examples/3d.rs
+++ b/examples/3d.rs
@@ -142,11 +142,11 @@ impl SpineMaterial for Spine3DMaterial {
     type Material = StandardMaterial;
     type Params<'w, 's> = SpineSettingsQuery<'w, 's>;
 
-    fn update<'w, 's>(
+    fn update(
         material: Option<Self::Material>,
         entity: Entity,
         renderable_data: SpineMaterialInfo,
-        params: &StaticSystemParam<Self::Params<'w, 's>>,
+        params: &StaticSystemParam<Self::Params<'_, '_>>,
     ) -> Option<Self::Material> {
         let spine_settings = params
             .spine_settings_query
diff --git a/examples/crossfades.rs b/examples/crossfades.rs
index 14eb077..0500984 100644
--- a/examples/crossfades.rs
+++ b/examples/crossfades.rs
@@ -72,10 +72,8 @@ fn crossfades(mut spine_query: Query<&mut Spine>, time: Res<Time>) {
             if current_animation != "walk" {
                 let _ = spine.animation_state.set_animation_by_name(0, "walk", true);
             }
-        } else {
-            if current_animation != "idle" {
-                let _ = spine.animation_state.set_animation_by_name(0, "idle", true);
-            }
+        } else if current_animation != "idle" {
+            let _ = spine.animation_state.set_animation_by_name(0, "idle", true);
         }
     }
 }
diff --git a/examples/custom_material.rs b/examples/custom_material.rs
index a6b1d21..9c5252d 100644
--- a/examples/custom_material.rs
+++ b/examples/custom_material.rs
@@ -109,13 +109,13 @@ impl Material2d for MyMaterial {
         layout: &MeshVertexBufferLayout,
         _key: Material2dKey<Self>,
     ) -> Result<(), SpecializedMeshPipelineError> {
-        let mut vertex_attributes = Vec::new();
-        vertex_attributes.push(Mesh::ATTRIBUTE_POSITION.at_shader_location(0));
-        vertex_attributes.push(Mesh::ATTRIBUTE_NORMAL.at_shader_location(1));
-        vertex_attributes.push(Mesh::ATTRIBUTE_UV_0.at_shader_location(2));
-        vertex_attributes.push(Mesh::ATTRIBUTE_COLOR.at_shader_location(4));
-        vertex_attributes
-            .push(DARK_COLOR_ATTRIBUTE.at_shader_location(DARK_COLOR_SHADER_POSITION as u32));
+        let vertex_attributes = vec![
+            Mesh::ATTRIBUTE_POSITION.at_shader_location(0),
+            Mesh::ATTRIBUTE_NORMAL.at_shader_location(1),
+            Mesh::ATTRIBUTE_UV_0.at_shader_location(2),
+            Mesh::ATTRIBUTE_COLOR.at_shader_location(4),
+            DARK_COLOR_ATTRIBUTE.at_shader_location(DARK_COLOR_SHADER_POSITION as u32),
+        ];
         let vertex_buffer_layout = layout.get_layout(&vertex_attributes)?;
         descriptor.vertex.buffers = vec![vertex_buffer_layout];
         descriptor.primitive.cull_mode = None;
@@ -133,14 +133,14 @@ impl SpineMaterial for MyMaterial {
     type Material = Self;
     type Params<'w, 's> = MyMaterialParam<'w, 's>;
 
-    fn update<'w, 's>(
+    fn update(
         material: Option<Self>,
         entity: Entity,
         renderable_data: SpineMaterialInfo,
-        params: &StaticSystemParam<Self::Params<'w, 's>>,
+        params: &StaticSystemParam<Self::Params<'_, '_>>,
     ) -> Option<Self> {
         if let Ok(spine) = params.my_spine_query.get(entity) {
-            let mut material = material.unwrap_or_else(|| Self::default());
+            let mut material = material.unwrap_or_default();
             material.image = renderable_data.texture;
             material.time = params.time.elapsed_seconds();
             if let Some(slot) = spine
diff --git a/examples/spineboy/player.rs b/examples/spineboy/player.rs
index db59ee2..35d354c 100644
--- a/examples/spineboy/player.rs
+++ b/examples/spineboy/player.rs
@@ -106,7 +106,7 @@ fn player_spine_ready(
             }) = spine.as_mut();
             let _ = animation_state.set_animation_by_name(PLAYER_TRACK_PORTAL, "portal", false);
             for (bone, bone_entity) in spine_bone_query.iter_mut() {
-                if let Some(bone) = bone.handle.get(&skeleton) {
+                if let Some(bone) = bone.handle.get(skeleton) {
                     if bone.data().name() == "crosshair" {
                         commands
                             .entity(spine_entity)
@@ -129,43 +129,40 @@ fn player_spine_events(
     mut spine_query: Query<(&mut Spine, &mut Player)>,
 ) {
     for event in spine_events.read() {
-        match event {
-            SpineEvent::Complete { entity, animation } => {
-                if let Ok((mut spine, mut player)) = spine_query.get_mut(*entity) {
-                    let Spine(controller) = spine.as_mut();
-                    if animation == "portal" {
-                        let _ = controller.animation_state.set_animation_by_name(
-                            PLAYER_TRACK_IDLE,
-                            "idle",
-                            true,
-                        );
-                        let _ = controller.animation_state.set_animation_by_name(
-                            PLAYER_TRACK_AIM,
-                            "aim",
-                            true,
-                        );
-                        let mut run_track = controller
-                            .animation_state
-                            .set_animation_by_name(PLAYER_TRACK_RUN, "run", true)
-                            .unwrap();
-                        run_track.set_shortest_rotation(true);
-                        controller
-                            .animation_state
-                            .track_at_index_mut(PLAYER_TRACK_AIM)
-                            .unwrap()
-                            .set_alpha(0.);
-                        controller
-                            .animation_state
-                            .track_at_index_mut(PLAYER_TRACK_RUN)
-                            .unwrap()
-                            .set_alpha(0.);
-                        player.spawned = true;
-                    } else if animation == "jump" {
-                        controller.animation_state.clear_track(PLAYER_TRACK_JUMP);
-                    }
+        if let SpineEvent::Complete { entity, animation } = event {
+            if let Ok((mut spine, mut player)) = spine_query.get_mut(*entity) {
+                let Spine(controller) = spine.as_mut();
+                if animation == "portal" {
+                    let _ = controller.animation_state.set_animation_by_name(
+                        PLAYER_TRACK_IDLE,
+                        "idle",
+                        true,
+                    );
+                    let _ = controller.animation_state.set_animation_by_name(
+                        PLAYER_TRACK_AIM,
+                        "aim",
+                        true,
+                    );
+                    let mut run_track = controller
+                        .animation_state
+                        .set_animation_by_name(PLAYER_TRACK_RUN, "run", true)
+                        .unwrap();
+                    run_track.set_shortest_rotation(true);
+                    controller
+                        .animation_state
+                        .track_at_index_mut(PLAYER_TRACK_AIM)
+                        .unwrap()
+                        .set_alpha(0.);
+                    controller
+                        .animation_state
+                        .track_at_index_mut(PLAYER_TRACK_RUN)
+                        .unwrap()
+                        .set_alpha(0.);
+                    player.spawned = true;
+                } else if animation == "jump" {
+                    controller.animation_state.clear_track(PLAYER_TRACK_JUMP);
                 }
             }
-            _ => {}
         }
     }
 }
@@ -186,8 +183,8 @@ fn player_aim(
         if let Ok((camera_entity, camera)) = camera_query.get_single() {
             if let Ok(camera_transform) = global_transform_query.get(camera_entity) {
                 let window_size = Vec2::new(
-                    window_query.single().width() as f32,
-                    window_query.single().height() as f32,
+                    window_query.single().width(),
+                    window_query.single().height(),
                 );
                 let ndc = (cursor_position / window_size) * 2.0 - Vec2::ONE;
                 let ndc_to_world =
@@ -245,27 +242,23 @@ fn player_shoot(
 ) {
     for (mut shoot, player) in shoot_query.iter_mut() {
         shoot.cooldown = (shoot.cooldown - time.delta_seconds()).max(0.);
-        if mouse_buttons.just_pressed(MouseButton::Left) && player.spawned {
-            if shoot.cooldown == 0. {
-                let mut scale_x = 1.;
-                if let Ok((mut spine, spine_transform)) = spine_query.get_mut(shoot.spine) {
-                    let _ = spine.animation_state.set_animation_by_name(
-                        PLAYER_TRACK_SHOOT,
-                        "shoot",
-                        false,
-                    );
-                    scale_x = spine_transform.scale.x;
-                }
-                if let Ok(shoot_transform) = global_transform_query.get(shoot.bone) {
-                    let (_, rotation, translation) =
-                        shoot_transform.to_scale_rotation_translation();
-                    bullet_spawn_events.send(BulletSpawnEvent {
-                        position: translation.truncate(),
-                        velocity: (rotation * Vec3::X).truncate() * 1000. * scale_x.signum(),
-                    });
-                }
-                shoot.cooldown = 0.25;
+        if mouse_buttons.just_pressed(MouseButton::Left) && player.spawned && shoot.cooldown == 0. {
+            let mut scale_x = 1.;
+            if let Ok((mut spine, spine_transform)) = spine_query.get_mut(shoot.spine) {
+                let _ =
+                    spine
+                        .animation_state
+                        .set_animation_by_name(PLAYER_TRACK_SHOOT, "shoot", false);
+                scale_x = spine_transform.scale.x;
+            }
+            if let Ok(shoot_transform) = global_transform_query.get(shoot.bone) {
+                let (_, rotation, translation) = shoot_transform.to_scale_rotation_translation();
+                bullet_spawn_events.send(BulletSpawnEvent {
+                    position: translation.truncate(),
+                    velocity: (rotation * Vec3::X).truncate() * 1000. * scale_x.signum(),
+                });
             }
+            shoot.cooldown = 0.25;
         }
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index c806d61..4ac3be0 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -506,7 +506,7 @@ pub enum SpineEvent {
     },
 }
 
-/// Queued ready events, to be sent after [`SpineSet::SpawnFlush`].
+/// Queued ready events, to be sent after [`SpineSystem::SpawnFlush`].
 #[derive(Default, Resource)]
 struct SpineReadyEvents(Vec<SpineReadyEvent>);
 
@@ -844,6 +844,7 @@ pub enum SkeletonRenderableKind {
     Combined(Vec<SkeletonCombinedRenderable>),
 }
 
+#[allow(clippy::type_complexity)]
 fn spine_update_meshes(
     mut spine_query: Query<(&mut Spine, Option<&SpineSettings>)>,
     mut meshes: ResMut<Assets<Mesh>>,
@@ -951,7 +952,7 @@ fn spine_update_meshes(
                                 renderable.vertices.len()
                             ];
                             (
-                                Some(renderable.slot_index as usize),
+                                Some(renderable.slot_index),
                                 renderable.attachment_renderer_object,
                                 take(&mut renderable.vertices),
                                 take(&mut renderable.indices),
@@ -1057,7 +1058,7 @@ fn adjust_spine_textures(
     }
     let mut removed_handles = vec![];
     for (handle_index, (handle, handle_config)) in local.handles.iter().enumerate() {
-        if let Some(image) = images.get_mut(&*handle) {
+        if let Some(image) = images.get_mut(handle) {
             fn convert_filter(filter: AtlasFilter) -> ImageFilterMode {
                 match filter {
                     AtlasFilter::Nearest => ImageFilterMode::Nearest,
@@ -1091,7 +1092,7 @@ fn adjust_spine_textures(
             if handle_config.premultiplied_alpha {
                 for i in 0..(image.data.len() / 4) {
                     let mut rgba = Color::rgba_u8(
-                        image.data[i * 4 + 0],
+                        image.data[i * 4],
                         image.data[i * 4 + 1],
                         image.data[i * 4 + 2],
                         image.data[i * 4 + 3],
diff --git a/src/materials.rs b/src/materials.rs
index a60de46..f77d813 100644
--- a/src/materials.rs
+++ b/src/materials.rs
@@ -37,11 +37,11 @@ pub trait SpineMaterial: Sized {
     /// If this function returns [`Some`], then the material will be applied to the [`SpineMesh`],
     /// otherwise it will be removed. Default materials should be removed if a custom material is
     /// desired (see [`SpineSettings::default_materials`]).
-    fn update<'w, 's>(
+    fn update(
         material: Option<Self::Material>,
         entity: Entity,
         renderable_data: SpineMaterialInfo,
-        params: &StaticSystemParam<Self::Params<'w, 's>>,
+        params: &StaticSystemParam<Self::Params<'_, '_>>,
     ) -> Option<Self::Material>;
 }
 
@@ -79,11 +79,11 @@ pub struct SpineMaterialInfo {
 }
 
 #[allow(clippy::type_complexity, clippy::too_many_arguments)]
-fn update_materials<'w, 's, T: SpineMaterial>(
+fn update_materials<T: SpineMaterial>(
     mut commands: Commands,
     mut materials: ResMut<Assets<T::Material>>,
     mesh_query: Query<(Entity, &SpineMesh, Option<&Handle<T::Material>>)>,
-    params: StaticSystemParam<T::Params<'w, 's>>,
+    params: StaticSystemParam<T::Params<'_, '_>>,
 ) {
     for (mesh_entity, spine_mesh, material_handle) in mesh_query.iter() {
         let SpineMeshState::Renderable { info: data } = spine_mesh.state.clone() else {
@@ -102,12 +102,10 @@ fn update_materials<'w, 's, T: SpineMaterial>(
             } else {
                 materials.remove(handle);
             }
-        } else {
-            if let Some(material) = T::update(None, spine_mesh.spine_entity, data, &params) {
-                let handle = materials.add(material);
-                if let Some(mut entity_commands) = commands.get_entity(mesh_entity) {
-                    entity_commands.insert(handle.clone());
-                }
+        } else if let Some(material) = T::update(None, spine_mesh.spine_entity, data, &params) {
+            let handle = materials.add(material);
+            if let Some(mut entity_commands) = commands.get_entity(mesh_entity) {
+                entity_commands.insert(handle.clone());
             }
         };
     }
@@ -161,12 +159,13 @@ macro_rules! material {
                 layout: &MeshVertexBufferLayout,
                 _key: Material2dKey<Self>,
             ) -> Result<(), SpecializedMeshPipelineError> {
-                let mut vertex_attributes = Vec::new();
-                vertex_attributes.push(Mesh::ATTRIBUTE_POSITION.at_shader_location(0));
-                vertex_attributes.push(Mesh::ATTRIBUTE_NORMAL.at_shader_location(1));
-                vertex_attributes.push(Mesh::ATTRIBUTE_UV_0.at_shader_location(2));
-                vertex_attributes.push(Mesh::ATTRIBUTE_COLOR.at_shader_location(4));
-                vertex_attributes.push(DARK_COLOR_ATTRIBUTE.at_shader_location(DARK_COLOR_SHADER_POSITION as u32));
+                let vertex_attributes = vec![
+                    Mesh::ATTRIBUTE_POSITION.at_shader_location(0),
+                    Mesh::ATTRIBUTE_NORMAL.at_shader_location(1),
+                    Mesh::ATTRIBUTE_UV_0.at_shader_location(2),
+                    Mesh::ATTRIBUTE_COLOR.at_shader_location(4),
+                    DARK_COLOR_ATTRIBUTE.at_shader_location(DARK_COLOR_SHADER_POSITION as u32),
+                ];
                 let vertex_buffer_layout = layout.get_layout(&vertex_attributes)?;
                 descriptor.vertex.buffers = vec![vertex_buffer_layout];
                 if let Some(fragment) = &mut descriptor.fragment {
@@ -183,11 +182,11 @@ macro_rules! material {
             type Material = Self;
             type Params<'w, 's> = SpineSettingsQuery<'w, 's>;
 
-            fn update<'w, 's>(
+            fn update(
                 material: Option<Self>,
                 entity: Entity,
                 renderable_data: SpineMaterialInfo,
-                params: &StaticSystemParam<Self::Params<'w, 's>>,
+                params: &StaticSystemParam<Self::Params<'_, '_>>,
             ) -> Option<Self> {
                 let spine_settings = params.spine_settings_query.get(entity).copied().unwrap_or(SpineSettings::default());
                 if spine_settings.default_materials && renderable_data.blend_mode == $blend_mode && renderable_data.premultiplied_alpha == $premultiplied_alpha {