From f2b8c7609204f73511a275d57541681c043f562d Mon Sep 17 00:00:00 2001
From: Greeble <166992735+greeble-dev@users.noreply.github.com>
Date: Tue, 25 Feb 2025 18:06:46 +0000
Subject: [PATCH 01/10] Added a test that triggers bevy/#16929.

---
 Cargo.toml                       |   8 +
 tests/3d/invalid_skinned_mesh.rs | 369 +++++++++++++++++++++++++++++++
 2 files changed, 377 insertions(+)
 create mode 100644 tests/3d/invalid_skinned_mesh.rs

diff --git a/Cargo.toml b/Cargo.toml
index ba2384675c617..0d4fb87e22c08 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4098,6 +4098,14 @@ description = "Demonstrates specular tints and maps"
 category = "3D Rendering"
 wasm = true
 
+[[example]]
+name = "invalid_skinned_mesh"
+path = "tests/3d/invalid_skinned_mesh.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.invalid_skinned_mesh]
+hidden = true
+
 [profile.wasm-release]
 inherits = "release"
 opt-level = "z"
diff --git a/tests/3d/invalid_skinned_mesh.rs b/tests/3d/invalid_skinned_mesh.rs
new file mode 100644
index 0000000000000..ed68dd268d21d
--- /dev/null
+++ b/tests/3d/invalid_skinned_mesh.rs
@@ -0,0 +1,369 @@
+//! Create invalid skinned meshes to test renderer behaviour.
+
+use bevy::{
+    core_pipeline::{
+        motion_blur::MotionBlur,
+        prepass::{DeferredPrepass, DepthPrepass, MotionVectorPrepass, NormalPrepass},
+    },
+    math::ops,
+    pbr::DefaultOpaqueRendererMethod,
+    prelude::*,
+    render::{
+        camera::ScalingMode,
+        mesh::{
+            skinning::{SkinnedMesh, SkinnedMeshInverseBindposes},
+            Indices, PrimitiveTopology, VertexAttributeValues,
+        },
+        render_asset::RenderAssetUsages,
+    },
+};
+use std::f32::consts::TAU;
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .insert_resource(AmbientLight {
+            brightness: 20_000.0,
+            ..default()
+        })
+        .insert_resource(Globals::default())
+        .add_systems(Startup, (setup_environment, setup_meshes))
+        .add_systems(
+            Update,
+            (
+                update_animated_joints,
+                update_render_mode,
+                update_motion_blur,
+                update_text,
+            ),
+        )
+        .run();
+}
+
+fn setup_environment(
+    mut commands: Commands,
+    mut mesh_assets: ResMut<Assets<Mesh>>,
+    mut material_assets: ResMut<Assets<StandardMaterial>>,
+) {
+    commands.spawn((
+        Text::default(),
+        Node {
+            position_type: PositionType::Absolute,
+            top: Val::Px(12.0),
+            left: Val::Px(12.0),
+            ..default()
+        },
+    ));
+
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(0.0, 0.0, 1.0).looking_at(Vec3::new(0.0, 0.0, 0.0), Vec3::Y),
+        Projection::Orthographic(OrthographicProjection {
+            scaling_mode: ScalingMode::AutoMin {
+                min_width: 18.0,
+                min_height: 6.0,
+            },
+            ..OrthographicProjection::default_3d()
+        }),
+        default_motion_blur(),
+        // MSAA is incompatible with deferred rendering.
+        Msaa::Off,
+    ));
+
+    // Add a directional light to make sure we exercise the renderer's lighting path.
+    commands.spawn((
+        Transform::from_xyz(1.0, 1.0, 3.0).looking_at(Vec3::ZERO, Vec3::Y),
+        DirectionalLight {
+            shadows_enabled: true,
+            ..default()
+        },
+    ));
+
+    // Add a plane behind the skinned meshes so that we can see their shadows.
+    commands.spawn((
+        Transform::from_xyz(0.0, 0.0, -1.0),
+        Mesh3d(mesh_assets.add(Plane3d::default().mesh().size(100.0, 100.0).normal(Dir3::Z))),
+        MeshMaterial3d(material_assets.add(StandardMaterial {
+            base_color: Color::srgb(0.1 * 0.5, 0.3 * 0.5, 0.1 * 0.5),
+            reflectance: 0.2,
+            ..default()
+        })),
+    ));
+}
+
+fn setup_meshes(
+    mut commands: Commands,
+    mut mesh_assets: ResMut<Assets<Mesh>>,
+    mut material_assets: ResMut<Assets<StandardMaterial>>,
+    mut inverse_bindposes_assets: ResMut<Assets<SkinnedMeshInverseBindposes>>,
+) {
+    let unskinned_mesh = Mesh::new(
+        PrimitiveTopology::TriangleList,
+        RenderAssetUsages::default(),
+    )
+    .with_inserted_attribute(
+        Mesh::ATTRIBUTE_POSITION,
+        vec![
+            [-0.35, -0.35, 0.0],
+            [0.35, -0.35, 0.0],
+            [-0.35, 0.35, 0.0],
+            [0.35, 0.35, 0.0],
+            [-0.5, 1.0, 0.0],
+            [0.5, 1.0, 0.0],
+            [-0.5, 2.0, 0.0],
+            [0.5, 2.0, 0.0],
+        ],
+    )
+    .with_inserted_attribute(Mesh::ATTRIBUTE_NORMAL, vec![[0.0, 0.0, 1.0]; 8]);
+
+    let skinned_mesh = unskinned_mesh
+        .clone()
+        .with_inserted_attribute(
+            Mesh::ATTRIBUTE_JOINT_INDEX,
+            VertexAttributeValues::Uint16x4(vec![
+                [0, 0, 0, 0],
+                [0, 0, 0, 0],
+                [0, 0, 0, 0],
+                [0, 0, 0, 0],
+                [1, 0, 0, 0],
+                [1, 0, 0, 0],
+                [1, 0, 0, 0],
+                [1, 0, 0, 0],
+            ]),
+        )
+        .with_inserted_attribute(
+            Mesh::ATTRIBUTE_JOINT_WEIGHT,
+            vec![[1.00, 0.00, 0.0, 0.0]; 8],
+        )
+        .with_inserted_indices(Indices::U16(vec![0, 1, 3, 0, 3, 2, 4, 5, 7, 4, 7, 6]));
+
+    let unskinned_mesh_handle = mesh_assets.add(unskinned_mesh);
+    let skinned_mesh_handle = mesh_assets.add(skinned_mesh);
+
+    let inverse_bindposes_handle = inverse_bindposes_assets.add(vec![
+        Mat4::IDENTITY,
+        Mat4::from_translation(Vec3::new(0.0, -1.5, 0.0)),
+    ]);
+
+    let material_handle = material_assets.add(StandardMaterial {
+        cull_mode: None,
+        ..default()
+    });
+
+    // Mesh 0: Normal.
+    // Mesh 1: Asset is missing joint index and joint weight attributes.
+    // Mesh 2: Entity is missing SkinnedMesh component.
+    // Mesh 3: One joint entity deleted.
+
+    for mesh_index in 0..4 {
+        let transform = Transform::from_xyz(((mesh_index as f32) - 1.5) * 4.0, 0.0, 0.0);
+
+        let joint_0 = commands.spawn(transform).id();
+
+        let joint_1 = commands
+            .spawn((ChildOf(joint_0), AnimatedJoint, Transform::IDENTITY))
+            .id();
+
+        let mesh_handle = match mesh_index {
+            1 => &unskinned_mesh_handle,
+            _ => &skinned_mesh_handle,
+        };
+
+        let mut entity_commands = commands.spawn((
+            Mesh3d(mesh_handle.clone()),
+            MeshMaterial3d(material_handle.clone()),
+            transform,
+        ));
+
+        if mesh_index != 2 {
+            entity_commands.insert(SkinnedMesh {
+                inverse_bindposes: inverse_bindposes_handle.clone(),
+                joints: vec![joint_0, joint_1],
+            });
+        }
+
+        if mesh_index == 3 {
+            commands.entity(joint_1).despawn();
+        }
+    }
+}
+
+fn default_motion_blur() -> MotionBlur {
+    MotionBlur {
+        // Use an unrealistically large shutter angle so that motion blur is clearly visible.
+        shutter_angle: 4.0,
+        samples: 2,
+        #[cfg(all(feature = "webgl2", target_arch = "wasm32", not(feature = "webgpu")))]
+        _webgl2_padding: Default::default(),
+    }
+}
+
+#[derive(Component)]
+struct AnimatedJoint;
+
+fn update_animated_joints(time: Res<Time>, mut query: Query<(&mut Transform, &AnimatedJoint)>) {
+    for (mut transform, _) in &mut query {
+        let angle = TAU * 4.0 * ops::cos((time.elapsed_secs() / 8.0) * TAU);
+        let rotation = Quat::from_rotation_z(angle);
+
+        transform.rotation = rotation;
+        transform.translation = rotation.mul_vec3(Vec3::new(0.0, 1.5, 0.0));
+    }
+}
+
+#[derive(Default, Debug, Copy, Clone, PartialEq)]
+enum RenderMode {
+    #[default]
+    Forward,
+    ForwardPrepass,
+    Deferred,
+}
+
+impl RenderMode {
+    fn from_cycle(cycle: u32) -> Self {
+        match cycle % 3 {
+            0 => RenderMode::Forward,
+            1 => RenderMode::ForwardPrepass,
+            _ => RenderMode::Deferred,
+        }
+    }
+}
+
+#[derive(Resource)]
+struct Globals {
+    cycle_render_mode: bool,
+    render_mode: RenderMode,
+    motion_blur: bool,
+}
+
+impl Default for Globals {
+    fn default() -> Self {
+        Globals {
+            cycle_render_mode: true,
+            render_mode: RenderMode::default(),
+            motion_blur: true,
+        }
+    }
+}
+
+fn update_render_mode(
+    mut commands: Commands,
+    time: Res<Time>,
+    keys: Res<ButtonInput<KeyCode>>,
+    cameras: Query<Entity, With<Camera>>,
+    mut globals: ResMut<Globals>,
+    mut default_opaque_renderer_method: ResMut<DefaultOpaqueRendererMethod>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    // By default we cycle through rendering modes over time. If the user chooses
+    // a particular mode then we stop cycling.
+
+    let mut desired_render_mode = globals.render_mode;
+
+    if keys.just_pressed(KeyCode::Digit1) {
+        desired_render_mode = RenderMode::Forward;
+        globals.cycle_render_mode = false;
+    }
+
+    if keys.just_pressed(KeyCode::Digit2) {
+        desired_render_mode = RenderMode::ForwardPrepass;
+        globals.cycle_render_mode = false;
+    }
+
+    if keys.just_pressed(KeyCode::Digit3) {
+        desired_render_mode = RenderMode::Deferred;
+        globals.cycle_render_mode = false;
+    }
+
+    if globals.cycle_render_mode {
+        let cycle = (time.elapsed_secs() / 4.0) as u32;
+        desired_render_mode = RenderMode::from_cycle(cycle);
+    }
+
+    if globals.render_mode == desired_render_mode {
+        return;
+    }
+
+    println!("Switching render mode to {:?}", desired_render_mode);
+
+    for camera in cameras {
+        commands
+            .entity(camera)
+            .remove::<NormalPrepass>()
+            .remove::<DepthPrepass>()
+            .remove::<DepthPrepass>()
+            .remove::<MotionVectorPrepass>()
+            .remove::<DeferredPrepass>();
+    }
+
+    match desired_render_mode {
+        RenderMode::Forward => {
+            default_opaque_renderer_method.set_to_forward();
+        }
+
+        RenderMode::ForwardPrepass => {
+            default_opaque_renderer_method.set_to_forward();
+
+            for camera in cameras {
+                commands
+                    .entity(camera)
+                    .insert(DepthPrepass)
+                    .insert(MotionVectorPrepass)
+                    .insert(NormalPrepass);
+            }
+        }
+
+        RenderMode::Deferred => {
+            default_opaque_renderer_method.set_to_deferred();
+
+            for camera in cameras {
+                commands
+                    .entity(camera)
+                    .insert(DepthPrepass)
+                    .insert(DeferredPrepass)
+                    .insert(MotionVectorPrepass);
+            }
+        }
+    }
+
+    globals.render_mode = desired_render_mode;
+
+    // If this is left out then motion blur doesn't work in deferred render mode. TODO?
+    for _ in materials.iter_mut() {}
+}
+
+fn update_motion_blur(
+    keys: Res<ButtonInput<KeyCode>>,
+    cameras: Query<(Entity, &mut MotionBlur), With<Camera>>,
+    mut globals: ResMut<Globals>,
+) {
+    if keys.just_pressed(KeyCode::KeyM) {
+        globals.motion_blur = !globals.motion_blur;
+
+        for (_, mut motion_blur) in cameras {
+            motion_blur.samples = if globals.motion_blur {
+                default_motion_blur().samples
+            } else {
+                0
+            };
+        }
+    }
+}
+
+fn update_text(mut text: Single<&mut Text>, globals: Res<Globals>) {
+    text.clear();
+
+    text.push_str(&format!(
+        "{:?}, motion blur {}\n\n",
+        globals.render_mode,
+        match globals.motion_blur {
+            true => "on",
+            false => "off",
+        }
+    ));
+
+    text.push_str("(1) Forward\n");
+    text.push_str("(2) ForwardPrepass\n");
+    text.push_str("(3) Deferred\n");
+    text.push_str("(M) Toggle motion blur");
+}

From c4a32a07c94796372f8fe35a59c2469e4b827936 Mon Sep 17 00:00:00 2001
From: Greeble <166992735+greeble-dev@users.noreply.github.com>
Date: Thu, 27 Feb 2025 12:24:22 +0000
Subject: [PATCH 02/10] Fixed unskinned mesh missing indices (doh!). Rearranged
 ordering and fixed forward mode missing passes required for motion blur.

---
 tests/3d/invalid_skinned_mesh.rs | 46 +++++++++++++++++++-------------
 1 file changed, 27 insertions(+), 19 deletions(-)

diff --git a/tests/3d/invalid_skinned_mesh.rs b/tests/3d/invalid_skinned_mesh.rs
index ed68dd268d21d..8daa1790f4039 100644
--- a/tests/3d/invalid_skinned_mesh.rs
+++ b/tests/3d/invalid_skinned_mesh.rs
@@ -114,7 +114,8 @@ fn setup_meshes(
             [0.5, 2.0, 0.0],
         ],
     )
-    .with_inserted_attribute(Mesh::ATTRIBUTE_NORMAL, vec![[0.0, 0.0, 1.0]; 8]);
+    .with_inserted_attribute(Mesh::ATTRIBUTE_NORMAL, vec![[0.0, 0.0, 1.0]; 8])
+    .with_inserted_indices(Indices::U16(vec![0, 1, 3, 0, 3, 2, 4, 5, 7, 4, 7, 6]));
 
     let skinned_mesh = unskinned_mesh
         .clone()
@@ -134,8 +135,7 @@ fn setup_meshes(
         .with_inserted_attribute(
             Mesh::ATTRIBUTE_JOINT_WEIGHT,
             vec![[1.00, 0.00, 0.0, 0.0]; 8],
-        )
-        .with_inserted_indices(Indices::U16(vec![0, 1, 3, 0, 3, 2, 4, 5, 7, 4, 7, 6]));
+        );
 
     let unskinned_mesh_handle = mesh_assets.add(unskinned_mesh);
     let skinned_mesh_handle = mesh_assets.add(skinned_mesh);
@@ -151,10 +151,10 @@ fn setup_meshes(
     });
 
     // Mesh 0: Normal.
-    // Mesh 1: Asset is missing joint index and joint weight attributes.
-    // Mesh 2: Entity is missing SkinnedMesh component.
-    // Mesh 3: One joint entity deleted.
-
+    // Mesh 1: Mesh asset is missing joint index and joint weight attributes.
+    // Mesh 2: One joint entity has been deleted.
+    // Mesh 3: Mesh entity is missing SkinnedMesh component.
+    //for mesh_index in 0..4 {
     for mesh_index in 0..4 {
         let transform = Transform::from_xyz(((mesh_index as f32) - 1.5) * 4.0, 0.0, 0.0);
 
@@ -169,22 +169,24 @@ fn setup_meshes(
             _ => &skinned_mesh_handle,
         };
 
-        let mut entity_commands = commands.spawn((
-            Mesh3d(mesh_handle.clone()),
-            MeshMaterial3d(material_handle.clone()),
-            transform,
-        ));
+        let mesh_entity = commands
+            .spawn((
+                Mesh3d(mesh_handle.clone()),
+                MeshMaterial3d(material_handle.clone()),
+                transform,
+            ))
+            .id();
 
-        if mesh_index != 2 {
-            entity_commands.insert(SkinnedMesh {
+        if mesh_index == 2 {
+            commands.entity(joint_1).despawn();
+        }
+
+        if mesh_index != 3 {
+            commands.entity(mesh_entity).insert(SkinnedMesh {
                 inverse_bindposes: inverse_bindposes_handle.clone(),
                 joints: vec![joint_0, joint_1],
             });
         }
-
-        if mesh_index == 3 {
-            commands.entity(joint_1).despawn();
-        }
     }
 }
 
@@ -291,7 +293,6 @@ fn update_render_mode(
             .entity(camera)
             .remove::<NormalPrepass>()
             .remove::<DepthPrepass>()
-            .remove::<DepthPrepass>()
             .remove::<MotionVectorPrepass>()
             .remove::<DeferredPrepass>();
     }
@@ -299,6 +300,13 @@ fn update_render_mode(
     match desired_render_mode {
         RenderMode::Forward => {
             default_opaque_renderer_method.set_to_forward();
+
+            for camera in cameras {
+                commands
+                    .entity(camera)
+                    .insert(DepthPrepass)
+                    .insert(MotionVectorPrepass);
+            }
         }
 
         RenderMode::ForwardPrepass => {

From 70d46cfeebff82f545f52a402718c14030d430c8 Mon Sep 17 00:00:00 2001
From: Greeble <166992735+greeble-dev@users.noreply.github.com>
Date: Thu, 27 Feb 2025 13:46:54 +0000
Subject: [PATCH 03/10] Updated test.

- Removed render mode cycling and motion blur toggling - all renderer paths can be tested just by enabling motion blur.
- Added a text overlay documenting each mesh.
- Various tidy ups.
---
 tests/3d/invalid_skinned_mesh.rs | 266 +++++--------------------------
 1 file changed, 44 insertions(+), 222 deletions(-)

diff --git a/tests/3d/invalid_skinned_mesh.rs b/tests/3d/invalid_skinned_mesh.rs
index 8daa1790f4039..cc970ebff8849 100644
--- a/tests/3d/invalid_skinned_mesh.rs
+++ b/tests/3d/invalid_skinned_mesh.rs
@@ -1,12 +1,9 @@
-//! Create invalid skinned meshes to test renderer behaviour.
+//! Test that the renderer can handle invalid skinned meshes, and meshes that
+//! have skinning attributes but aren't instantiated as skinned.
 
 use bevy::{
-    core_pipeline::{
-        motion_blur::MotionBlur,
-        prepass::{DeferredPrepass, DepthPrepass, MotionVectorPrepass, NormalPrepass},
-    },
+    core_pipeline::motion_blur::MotionBlur,
     math::ops,
-    pbr::DefaultOpaqueRendererMethod,
     prelude::*,
     render::{
         camera::ScalingMode,
@@ -26,17 +23,8 @@ fn main() {
             brightness: 20_000.0,
             ..default()
         })
-        .insert_resource(Globals::default())
         .add_systems(Startup, (setup_environment, setup_meshes))
-        .add_systems(
-            Update,
-            (
-                update_animated_joints,
-                update_render_mode,
-                update_motion_blur,
-                update_text,
-            ),
-        )
+        .add_systems(Update, update_animated_joints)
         .run();
 }
 
@@ -45,8 +33,14 @@ fn setup_environment(
     mut mesh_assets: ResMut<Assets<Mesh>>,
     mut material_assets: ResMut<Assets<StandardMaterial>>,
 ) {
+    let description = "(left to right)\n\
+        0: Normal skinned mesh.\n\
+        1: Mesh asset is missing joint index and joint weight attributes.\n\
+        2: One joint entity has been deleted.\n\
+        3: Mesh entity is missing SkinnedMesh component.";
+
     commands.spawn((
-        Text::default(),
+        Text::new(description),
         Node {
             position_type: PositionType::Absolute,
             top: Val::Px(12.0),
@@ -65,12 +59,18 @@ fn setup_environment(
             },
             ..OrthographicProjection::default_3d()
         }),
-        default_motion_blur(),
-        // MSAA is incompatible with deferred rendering.
-        Msaa::Off,
+        // Add motion blur so that we can check if it's working for skinned
+        // meshes. This also exercises the renderer's prepass path.
+        MotionBlur {
+            // Use an unrealistically large shutter angle so that motion blur is clearly visible.
+            shutter_angle: 3.0,
+            samples: 2,
+            #[cfg(all(feature = "webgl2", target_arch = "wasm32", not(feature = "webgpu")))]
+            _webgl2_padding: Default::default(),
+        },
     ));
 
-    // Add a directional light to make sure we exercise the renderer's lighting path.
+    // Add a directional light to make sure we exercise the renderer's shadow path.
     commands.spawn((
         Transform::from_xyz(1.0, 1.0, 3.0).looking_at(Vec3::ZERO, Vec3::Y),
         DirectionalLight {
@@ -79,7 +79,7 @@ fn setup_environment(
         },
     ));
 
-    // Add a plane behind the skinned meshes so that we can see their shadows.
+    // Add a plane behind the meshes so that we can see if shadows are working.
     commands.spawn((
         Transform::from_xyz(0.0, 0.0, -1.0),
         Mesh3d(mesh_assets.add(Plane3d::default().mesh().size(100.0, 100.0).normal(Dir3::Z))),
@@ -97,6 +97,7 @@ fn setup_meshes(
     mut material_assets: ResMut<Assets<StandardMaterial>>,
     mut inverse_bindposes_assets: ResMut<Assets<SkinnedMeshInverseBindposes>>,
 ) {
+    // Create a mesh with two squares.
     let unskinned_mesh = Mesh::new(
         PrimitiveTopology::TriangleList,
         RenderAssetUsages::default(),
@@ -104,10 +105,10 @@ fn setup_meshes(
     .with_inserted_attribute(
         Mesh::ATTRIBUTE_POSITION,
         vec![
-            [-0.35, -0.35, 0.0],
-            [0.35, -0.35, 0.0],
-            [-0.35, 0.35, 0.0],
-            [0.35, 0.35, 0.0],
+            [-0.3, -0.3, 0.0],
+            [0.3, -0.3, 0.0],
+            [-0.3, 0.3, 0.0],
+            [0.3, 0.3, 0.0],
             [-0.5, 1.0, 0.0],
             [0.5, 1.0, 0.0],
             [-0.5, 2.0, 0.0],
@@ -117,6 +118,7 @@ fn setup_meshes(
     .with_inserted_attribute(Mesh::ATTRIBUTE_NORMAL, vec![[0.0, 0.0, 1.0]; 8])
     .with_inserted_indices(Indices::U16(vec![0, 1, 3, 0, 3, 2, 4, 5, 7, 4, 7, 6]));
 
+    // Copy the mesh and add skinning attributes that bind each square to a joint.
     let skinned_mesh = unskinned_mesh
         .clone()
         .with_inserted_attribute(
@@ -145,16 +147,8 @@ fn setup_meshes(
         Mat4::from_translation(Vec3::new(0.0, -1.5, 0.0)),
     ]);
 
-    let material_handle = material_assets.add(StandardMaterial {
-        cull_mode: None,
-        ..default()
-    });
+    let material_handle = material_assets.add(StandardMaterial::default());
 
-    // Mesh 0: Normal.
-    // Mesh 1: Mesh asset is missing joint index and joint weight attributes.
-    // Mesh 2: One joint entity has been deleted.
-    // Mesh 3: Mesh entity is missing SkinnedMesh component.
-    //for mesh_index in 0..4 {
     for mesh_index in 0..4 {
         let transform = Transform::from_xyz(((mesh_index as f32) - 1.5) * 4.0, 0.0, 0.0);
 
@@ -164,25 +158,26 @@ fn setup_meshes(
             .spawn((ChildOf(joint_0), AnimatedJoint, Transform::IDENTITY))
             .id();
 
+        // Optionally delete one joint entity.
+        if mesh_index == 2 {
+            commands.entity(joint_1).despawn();
+        }
+
+        // Optionally use the mesh without skinning attributes.
         let mesh_handle = match mesh_index {
             1 => &unskinned_mesh_handle,
             _ => &skinned_mesh_handle,
         };
 
-        let mesh_entity = commands
-            .spawn((
-                Mesh3d(mesh_handle.clone()),
-                MeshMaterial3d(material_handle.clone()),
-                transform,
-            ))
-            .id();
-
-        if mesh_index == 2 {
-            commands.entity(joint_1).despawn();
-        }
+        let mut entity_commands = commands.spawn((
+            Mesh3d(mesh_handle.clone()),
+            MeshMaterial3d(material_handle.clone()),
+            transform,
+        ));
 
+        // Optionally add the SkinnedMesh component.
         if mesh_index != 3 {
-            commands.entity(mesh_entity).insert(SkinnedMesh {
+            entity_commands.insert(SkinnedMesh {
                 inverse_bindposes: inverse_bindposes_handle.clone(),
                 joints: vec![joint_0, joint_1],
             });
@@ -190,21 +185,11 @@ fn setup_meshes(
     }
 }
 
-fn default_motion_blur() -> MotionBlur {
-    MotionBlur {
-        // Use an unrealistically large shutter angle so that motion blur is clearly visible.
-        shutter_angle: 4.0,
-        samples: 2,
-        #[cfg(all(feature = "webgl2", target_arch = "wasm32", not(feature = "webgpu")))]
-        _webgl2_padding: Default::default(),
-    }
-}
-
 #[derive(Component)]
 struct AnimatedJoint;
 
-fn update_animated_joints(time: Res<Time>, mut query: Query<(&mut Transform, &AnimatedJoint)>) {
-    for (mut transform, _) in &mut query {
+fn update_animated_joints(time: Res<Time>, query: Query<&mut Transform, With<AnimatedJoint>>) {
+    for mut transform in query {
         let angle = TAU * 4.0 * ops::cos((time.elapsed_secs() / 8.0) * TAU);
         let rotation = Quat::from_rotation_z(angle);
 
@@ -212,166 +197,3 @@ fn update_animated_joints(time: Res<Time>, mut query: Query<(&mut Transform, &An
         transform.translation = rotation.mul_vec3(Vec3::new(0.0, 1.5, 0.0));
     }
 }
-
-#[derive(Default, Debug, Copy, Clone, PartialEq)]
-enum RenderMode {
-    #[default]
-    Forward,
-    ForwardPrepass,
-    Deferred,
-}
-
-impl RenderMode {
-    fn from_cycle(cycle: u32) -> Self {
-        match cycle % 3 {
-            0 => RenderMode::Forward,
-            1 => RenderMode::ForwardPrepass,
-            _ => RenderMode::Deferred,
-        }
-    }
-}
-
-#[derive(Resource)]
-struct Globals {
-    cycle_render_mode: bool,
-    render_mode: RenderMode,
-    motion_blur: bool,
-}
-
-impl Default for Globals {
-    fn default() -> Self {
-        Globals {
-            cycle_render_mode: true,
-            render_mode: RenderMode::default(),
-            motion_blur: true,
-        }
-    }
-}
-
-fn update_render_mode(
-    mut commands: Commands,
-    time: Res<Time>,
-    keys: Res<ButtonInput<KeyCode>>,
-    cameras: Query<Entity, With<Camera>>,
-    mut globals: ResMut<Globals>,
-    mut default_opaque_renderer_method: ResMut<DefaultOpaqueRendererMethod>,
-    mut materials: ResMut<Assets<StandardMaterial>>,
-) {
-    // By default we cycle through rendering modes over time. If the user chooses
-    // a particular mode then we stop cycling.
-
-    let mut desired_render_mode = globals.render_mode;
-
-    if keys.just_pressed(KeyCode::Digit1) {
-        desired_render_mode = RenderMode::Forward;
-        globals.cycle_render_mode = false;
-    }
-
-    if keys.just_pressed(KeyCode::Digit2) {
-        desired_render_mode = RenderMode::ForwardPrepass;
-        globals.cycle_render_mode = false;
-    }
-
-    if keys.just_pressed(KeyCode::Digit3) {
-        desired_render_mode = RenderMode::Deferred;
-        globals.cycle_render_mode = false;
-    }
-
-    if globals.cycle_render_mode {
-        let cycle = (time.elapsed_secs() / 4.0) as u32;
-        desired_render_mode = RenderMode::from_cycle(cycle);
-    }
-
-    if globals.render_mode == desired_render_mode {
-        return;
-    }
-
-    println!("Switching render mode to {:?}", desired_render_mode);
-
-    for camera in cameras {
-        commands
-            .entity(camera)
-            .remove::<NormalPrepass>()
-            .remove::<DepthPrepass>()
-            .remove::<MotionVectorPrepass>()
-            .remove::<DeferredPrepass>();
-    }
-
-    match desired_render_mode {
-        RenderMode::Forward => {
-            default_opaque_renderer_method.set_to_forward();
-
-            for camera in cameras {
-                commands
-                    .entity(camera)
-                    .insert(DepthPrepass)
-                    .insert(MotionVectorPrepass);
-            }
-        }
-
-        RenderMode::ForwardPrepass => {
-            default_opaque_renderer_method.set_to_forward();
-
-            for camera in cameras {
-                commands
-                    .entity(camera)
-                    .insert(DepthPrepass)
-                    .insert(MotionVectorPrepass)
-                    .insert(NormalPrepass);
-            }
-        }
-
-        RenderMode::Deferred => {
-            default_opaque_renderer_method.set_to_deferred();
-
-            for camera in cameras {
-                commands
-                    .entity(camera)
-                    .insert(DepthPrepass)
-                    .insert(DeferredPrepass)
-                    .insert(MotionVectorPrepass);
-            }
-        }
-    }
-
-    globals.render_mode = desired_render_mode;
-
-    // If this is left out then motion blur doesn't work in deferred render mode. TODO?
-    for _ in materials.iter_mut() {}
-}
-
-fn update_motion_blur(
-    keys: Res<ButtonInput<KeyCode>>,
-    cameras: Query<(Entity, &mut MotionBlur), With<Camera>>,
-    mut globals: ResMut<Globals>,
-) {
-    if keys.just_pressed(KeyCode::KeyM) {
-        globals.motion_blur = !globals.motion_blur;
-
-        for (_, mut motion_blur) in cameras {
-            motion_blur.samples = if globals.motion_blur {
-                default_motion_blur().samples
-            } else {
-                0
-            };
-        }
-    }
-}
-
-fn update_text(mut text: Single<&mut Text>, globals: Res<Globals>) {
-    text.clear();
-
-    text.push_str(&format!(
-        "{:?}, motion blur {}\n\n",
-        globals.render_mode,
-        match globals.motion_blur {
-            true => "on",
-            false => "off",
-        }
-    ));
-
-    text.push_str("(1) Forward\n");
-    text.push_str("(2) ForwardPrepass\n");
-    text.push_str("(3) Deferred\n");
-    text.push_str("(M) Toggle motion blur");
-}

From 77ec8623ec4e33acacb78c980958ceba8832191f Mon Sep 17 00:00:00 2001
From: Greeble <166992735+greeble-dev@users.noreply.github.com>
Date: Thu, 27 Feb 2025 20:16:56 +0000
Subject: [PATCH 04/10] - Fixed #16929 by making `skin_uniforms` the source of
 truth for whether a mesh is skinned. This meant adding
 `MeshPipelineKey::SKINNED`. - Fixed warning spam by making `extract_skins`
 check if the mesh has skinning attributes. - Fixed panic when using uniform
 buffers for skinning. If `SkinUniforms::current_buffer` is grown the
 `SkinUniforms::prev_buffer` should grow too.

---
 crates/bevy_pbr/src/material.rs     | 16 +++++---
 crates/bevy_pbr/src/prepass/mod.rs  | 17 +++++----
 crates/bevy_pbr/src/render/light.rs |  9 ++++-
 crates/bevy_pbr/src/render/mesh.rs  | 59 +++++++++++++----------------
 crates/bevy_pbr/src/render/skin.rs  | 56 +++++++++++++++++++++++----
 5 files changed, 102 insertions(+), 55 deletions(-)

diff --git a/crates/bevy_pbr/src/material.rs b/crates/bevy_pbr/src/material.rs
index 81f1c83609046..769e16f385f3e 100644
--- a/crates/bevy_pbr/src/material.rs
+++ b/crates/bevy_pbr/src/material.rs
@@ -827,7 +827,8 @@ pub fn specialize_material_meshes<M: Material>(
     mut specialized_material_pipeline_cache: ResMut<SpecializedMaterialPipelineCache<M>>,
     mut pipelines: ResMut<SpecializedMeshPipelines<MaterialPipeline<M>>>,
     pipeline: Res<MaterialPipeline<M>>,
-    pipeline_cache: Res<PipelineCache>,
+    (pipeline_cache, skin_uniforms): (Res<PipelineCache>, Res<SkinUniforms>),
+
     ticks: SystemChangeTick,
 ) where
     M::Data: PartialEq + Eq + Hash + Clone,
@@ -910,14 +911,17 @@ pub fn specialize_material_meshes<M: Material>(
                 mesh_key |= MeshPipelineKey::VISIBILITY_RANGE_DITHER;
             }
 
+            let is_skinned = skin_uniforms.contains(*visible_entity);
+
+            if is_skinned {
+                mesh_key |= MeshPipelineKey::SKINNED;
+            }
+
             if view_key.contains(MeshPipelineKey::MOTION_VECTOR_PREPASS) {
-                // If the previous frame have skins or morph targets, note that.
-                if mesh_instance
-                    .flags
-                    .contains(RenderMeshInstanceFlags::HAS_PREVIOUS_SKIN)
-                {
+                if is_skinned {
                     mesh_key |= MeshPipelineKey::HAS_PREVIOUS_SKIN;
                 }
+                // If the previous frame has morph targets, note that.
                 if mesh_instance
                     .flags
                     .contains(RenderMeshInstanceFlags::HAS_PREVIOUS_MORPH)
diff --git a/crates/bevy_pbr/src/prepass/mod.rs b/crates/bevy_pbr/src/prepass/mod.rs
index ea60f42667815..8a35c95ae427b 100644
--- a/crates/bevy_pbr/src/prepass/mod.rs
+++ b/crates/bevy_pbr/src/prepass/mod.rs
@@ -7,7 +7,7 @@ use crate::{
     EntitySpecializationTicks, Material, MaterialPipeline, MaterialPipelineKey, MeshLayouts,
     MeshPipeline, MeshPipelineKey, OpaqueRendererMethod, PreparedMaterial, RenderLightmaps,
     RenderMaterialInstances, RenderMeshInstanceFlags, RenderMeshInstances, RenderPhaseType,
-    SetMaterialBindGroup, SetMeshBindGroup, ShadowView, StandardMaterial,
+    SetMaterialBindGroup, SetMeshBindGroup, ShadowView, SkinUniforms, StandardMaterial,
 };
 use bevy_app::{App, Plugin, PreUpdate};
 use bevy_render::{
@@ -589,7 +589,6 @@ where
 
         let bind_group = setup_morph_and_skinning_defs(
             &self.mesh_layouts,
-            layout,
             5,
             &key.mesh_key,
             &mut shader_defs,
@@ -901,6 +900,7 @@ pub fn specialize_prepass_material_meshes<M>(
     render_visibility_ranges: Res<RenderVisibilityRanges>,
     material_bind_group_allocator: Res<MaterialBindGroupAllocator<M>>,
     view_key_cache: Res<ViewKeyPrepassCache>,
+    skin_uniforms: Res<SkinUniforms>,
     views: Query<(
         &ExtractedView,
         &RenderVisibleEntities,
@@ -1042,14 +1042,17 @@ pub fn specialize_prepass_material_meshes<M>(
                 mesh_key |= MeshPipelineKey::VISIBILITY_RANGE_DITHER;
             }
 
-            // If the previous frame has skins or morph targets, note that.
+            let is_skinned = skin_uniforms.contains(*visible_entity);
+
+            if is_skinned {
+                mesh_key |= MeshPipelineKey::SKINNED;
+            }
+
             if motion_vector_prepass.is_some() {
-                if mesh_instance
-                    .flags
-                    .contains(RenderMeshInstanceFlags::HAS_PREVIOUS_SKIN)
-                {
+                if is_skinned {
                     mesh_key |= MeshPipelineKey::HAS_PREVIOUS_SKIN;
                 }
+                // If the previous frame has morph targets, note that.
                 if mesh_instance
                     .flags
                     .contains(RenderMeshInstanceFlags::HAS_PREVIOUS_MORPH)
diff --git a/crates/bevy_pbr/src/render/light.rs b/crates/bevy_pbr/src/render/light.rs
index 5dc225d4662bc..6a0e5f20b6b2d 100644
--- a/crates/bevy_pbr/src/render/light.rs
+++ b/crates/bevy_pbr/src/render/light.rs
@@ -1747,7 +1747,10 @@ pub fn specialize_shadows<M: Material>(
     light_key_cache: Res<LightKeyCache>,
     mut specialized_material_pipeline_cache: ResMut<SpecializedShadowMaterialPipelineCache<M>>,
     light_specialization_ticks: Res<LightSpecializationTicks>,
-    entity_specialization_ticks: Res<EntitySpecializationTicks<M>>,
+    (entity_specialization_ticks, skin_uniforms): (
+        Res<EntitySpecializationTicks<M>>,
+        Res<SkinUniforms>,
+    ),
     ticks: SystemChangeTick,
 ) where
     M::Data: PartialEq + Eq + Hash + Clone,
@@ -1862,6 +1865,10 @@ pub fn specialize_shadows<M: Material>(
                     mesh_key |= MeshPipelineKey::LIGHTMAPPED;
                 }
 
+                if skin_uniforms.contains(visible_entity) {
+                    mesh_key |= MeshPipelineKey::SKINNED;
+                }
+
                 mesh_key |= match material.properties.alpha_mode {
                     AlphaMode::Mask(_)
                     | AlphaMode::Blend
diff --git a/crates/bevy_pbr/src/render/mesh.rs b/crates/bevy_pbr/src/render/mesh.rs
index 433df17c54e4e..9d33373334ab7 100644
--- a/crates/bevy_pbr/src/render/mesh.rs
+++ b/crates/bevy_pbr/src/render/mesh.rs
@@ -699,12 +699,9 @@ bitflags::bitflags! {
         /// The mesh had a transform last frame and so is eligible for motion
         /// vector computation.
         const HAS_PREVIOUS_TRANSFORM  = 1 << 2;
-        /// The mesh had a skin last frame and so that skin should be taken into
-        /// account for motion vector computation.
-        const HAS_PREVIOUS_SKIN       = 1 << 3;
         /// The mesh had morph targets last frame and so they should be taken
         /// into account for motion vector computation.
-        const HAS_PREVIOUS_MORPH      = 1 << 4;
+        const HAS_PREVIOUS_MORPH      = 1 << 3;
     }
 }
 
@@ -1629,29 +1626,22 @@ fn extract_mesh_for_gpu_building(
     );
 }
 
-/// A system that sets the [`RenderMeshInstanceFlags`] for each mesh based on
-/// whether the previous frame had skins and/or morph targets.
+/// A system that sets [`RenderMeshInstanceFlags::HAS_PREVIOUS_MORPH`] for each
+/// mesh.
 ///
 /// Ordinarily, [`RenderMeshInstanceFlags`] are set during the extraction phase.
-/// However, we can't do that for the flags related to skins and morph targets
-/// because the previous frame's skin and morph targets are the responsibility
-/// of [`extract_skins`] and [`extract_morphs`] respectively. We want to run
-/// those systems in parallel with mesh extraction for performance, so we need
-/// to defer setting of these mesh instance flags to after extraction, which
-/// this system does. An alternative to having skin- and morph-target-related
-/// data in [`RenderMeshInstanceFlags`] would be to have
-/// [`crate::material::queue_material_meshes`] check the skin and morph target
-/// tables for each mesh, but that would be too slow in the hot mesh queuing
-/// loop.
-fn set_mesh_motion_vector_flags(
+/// However, we can't do that for the flags related to morph targets because the
+/// previous frame's morph targets are the responsibility of [`extract_morphs`].
+/// We want to run that system in parallel with mesh extraction for performance,
+/// so we need to defer setting of the mesh instance flag to after extraction,
+/// which this system does. An alternative to having morph target related data
+/// in [`RenderMeshInstanceFlags`] would be to have
+/// [`crate::material::queue_material_meshes`] check the morph target tables for
+/// each mesh, but that would be too slow in the hot mesh queuing loop.
+pub fn set_mesh_motion_vector_flags(
     mut render_mesh_instances: ResMut<RenderMeshInstances>,
-    skin_uniforms: Res<SkinUniforms>,
     morph_indices: Res<MorphIndices>,
 ) {
-    for &entity in skin_uniforms.all_skins() {
-        render_mesh_instances
-            .insert_mesh_instance_flags(entity, RenderMeshInstanceFlags::HAS_PREVIOUS_SKIN);
-    }
     for &entity in morph_indices.prev.keys() {
         render_mesh_instances
             .insert_mesh_instance_flags(entity, RenderMeshInstanceFlags::HAS_PREVIOUS_MORPH);
@@ -2092,10 +2082,11 @@ bitflags::bitflags! {
         const IRRADIANCE_VOLUME                 = 1 << 15;
         const VISIBILITY_RANGE_DITHER           = 1 << 16;
         const SCREEN_SPACE_REFLECTIONS          = 1 << 17;
-        const HAS_PREVIOUS_SKIN                 = 1 << 18;
-        const HAS_PREVIOUS_MORPH                = 1 << 19;
-        const OIT_ENABLED                       = 1 << 20;
-        const DISTANCE_FOG                      = 1 << 21;
+        const SKINNED                           = 1 << 18;
+        const HAS_PREVIOUS_SKIN                 = 1 << 19;
+        const HAS_PREVIOUS_MORPH                = 1 << 20;
+        const OIT_ENABLED                       = 1 << 21;
+        const DISTANCE_FOG                      = 1 << 22;
         const LAST_FLAG                         = Self::DISTANCE_FOG.bits();
 
         // Bitfields
@@ -2218,19 +2209,15 @@ const_assert_eq!(
     0
 );
 
-fn is_skinned(layout: &MeshVertexBufferLayoutRef) -> bool {
-    layout.0.contains(Mesh::ATTRIBUTE_JOINT_INDEX)
-        && layout.0.contains(Mesh::ATTRIBUTE_JOINT_WEIGHT)
-}
 pub fn setup_morph_and_skinning_defs(
     mesh_layouts: &MeshLayouts,
-    layout: &MeshVertexBufferLayoutRef,
     offset: u32,
     key: &MeshPipelineKey,
     shader_defs: &mut Vec<ShaderDefVal>,
     vertex_attributes: &mut Vec<VertexAttributeDescriptor>,
     skins_use_uniform_buffers: bool,
 ) -> BindGroupLayout {
+    let is_skinned = key.intersects(MeshPipelineKey::SKINNED);
     let is_morphed = key.intersects(MeshPipelineKey::MORPH_TARGETS);
     let is_lightmapped = key.intersects(MeshPipelineKey::LIGHTMAPPED);
     let motion_vector_prepass = key.intersects(MeshPipelineKey::MOTION_VECTOR_PREPASS);
@@ -2246,7 +2233,7 @@ pub fn setup_morph_and_skinning_defs(
     };
 
     match (
-        is_skinned(layout),
+        is_skinned,
         is_morphed,
         is_lightmapped,
         motion_vector_prepass,
@@ -2351,7 +2338,6 @@ impl SpecializedMeshPipeline for MeshPipeline {
 
         bind_group_layout.push(setup_morph_and_skinning_defs(
             &self.mesh_layouts,
-            layout,
             6,
             &key,
             &mut shader_defs,
@@ -2789,6 +2775,13 @@ pub fn prepare_mesh_bind_groups(
     }
 }
 
+/// This should match the `is_skinned` function in `skin.rs`, which takes a
+/// `Mesh` instead of a `MeshVertexBufferLayoutRef`.
+fn is_skinned(layout: &MeshVertexBufferLayoutRef) -> bool {
+    layout.0.contains(Mesh::ATTRIBUTE_JOINT_INDEX)
+        && layout.0.contains(Mesh::ATTRIBUTE_JOINT_WEIGHT)
+}
+
 /// Creates the per-mesh bind groups for each type of mesh, for a single phase.
 fn prepare_mesh_bind_groups_for_phase(
     model: BindingResource,
diff --git a/crates/bevy_pbr/src/render/skin.rs b/crates/bevy_pbr/src/render/skin.rs
index bec846a038e6a..7440ef73d6ac2 100644
--- a/crates/bevy_pbr/src/render/skin.rs
+++ b/crates/bevy_pbr/src/render/skin.rs
@@ -5,6 +5,7 @@ use bevy_asset::{prelude::AssetChanged, Assets};
 use bevy_ecs::prelude::*;
 use bevy_math::Mat4;
 use bevy_platform_support::collections::hash_map::Entry;
+use bevy_render::mesh::{Mesh, Mesh3d};
 use bevy_render::render_resource::{Buffer, BufferDescriptor};
 use bevy_render::sync_world::{MainEntity, MainEntityHashMap, MainEntityHashSet};
 use bevy_render::{
@@ -167,9 +168,9 @@ impl SkinUniforms {
         })
     }
 
-    /// Returns an iterator over all skins in the scene.
-    pub fn all_skins(&self) -> impl Iterator<Item = &MainEntity> {
-        self.skin_uniform_info.keys()
+    /// Returns true if the given entity has a skin.
+    pub fn contains(&self, skin: MainEntity) -> bool {
+        self.skin_uniform_info.contains_key(&skin)
     }
 }
 
@@ -229,12 +230,25 @@ pub fn prepare_skins(
         } else {
             BufferUsages::STORAGE
         } | BufferUsages::COPY_DST;
+
         uniform.current_buffer = render_device.create_buffer(&BufferDescriptor {
             label: Some("skin uniform buffer"),
             usage: buffer_usages,
             size: new_size,
             mapped_at_creation: false,
         });
+        uniform.prev_buffer = render_device.create_buffer(&BufferDescriptor {
+            label: Some("skin uniform buffer"),
+            usage: buffer_usages,
+            size: new_size,
+            mapped_at_creation: false,
+        });
+        // TODO: This is wrong. We should be using last frame's data for prev_buffer.
+        render_queue.write_buffer(
+            &uniform.prev_buffer,
+            0,
+            bytemuck::must_cast_slice(&uniform.current_staging_buffer[..]),
+        );
     }
 
     // Write the data from `uniform.current_staging_buffer` into
@@ -280,17 +294,20 @@ pub fn extract_skins(
     skinned_meshes: Extract<Query<(Entity, &SkinnedMesh)>>,
     changed_skinned_meshes: Extract<
         Query<
-            (Entity, &ViewVisibility, &SkinnedMesh),
+            (Entity, &ViewVisibility, &SkinnedMesh, &Mesh3d),
             Or<(
                 Changed<ViewVisibility>,
                 Changed<SkinnedMesh>,
                 AssetChanged<SkinnedMesh>,
+                Changed<Mesh3d>,
+                AssetChanged<Mesh3d>,
             )>,
         >,
     >,
     skinned_mesh_inverse_bindposes: Extract<Res<Assets<SkinnedMeshInverseBindposes>>>,
     changed_transforms: Extract<Query<(Entity, &GlobalTransform), Changed<GlobalTransform>>>,
     joints: Extract<Query<&GlobalTransform>>,
+    meshes: Extract<Res<Assets<Mesh>>>,
     mut removed_visibilities_query: Extract<RemovedComponents<ViewVisibility>>,
     mut removed_skinned_meshes_query: Extract<RemovedComponents<SkinnedMesh>>,
 ) {
@@ -303,6 +320,7 @@ pub fn extract_skins(
         &changed_skinned_meshes,
         &skinned_mesh_inverse_bindposes,
         &joints,
+        &meshes,
     );
 
     // Extract the transforms for all joints from the scene, and write them into
@@ -330,25 +348,36 @@ pub fn extract_skins(
     }
 }
 
+/// This should match the `is_skinned` function in `mesh.rs`, which takes a
+/// `MeshVertexBufferLayoutRef` instead of a `Mesh`.
+fn is_skinned(mesh: &Mesh) -> bool {
+    mesh.contains_attribute(Mesh::ATTRIBUTE_JOINT_INDEX)
+        && mesh.contains_attribute(Mesh::ATTRIBUTE_JOINT_WEIGHT)
+}
+
 /// Searches for all skins that have become visible or invisible this frame and
 /// allocations for them as necessary.
 fn add_or_delete_skins(
     skin_uniforms: &mut SkinUniforms,
     changed_skinned_meshes: &Query<
-        (Entity, &ViewVisibility, &SkinnedMesh),
+        (Entity, &ViewVisibility, &SkinnedMesh, &Mesh3d),
         Or<(
             Changed<ViewVisibility>,
             Changed<SkinnedMesh>,
             AssetChanged<SkinnedMesh>,
+            Changed<Mesh3d>,
+            AssetChanged<Mesh3d>,
         )>,
     >,
     skinned_mesh_inverse_bindposes: &Assets<SkinnedMeshInverseBindposes>,
     joints: &Query<&GlobalTransform>,
+    meshes: &Assets<Mesh>,
 ) {
     // Find every skinned mesh that changed one of (1) visibility; (2) joint
     // entities (part of `SkinnedMesh`); (3) the associated
     // `SkinnedMeshInverseBindposes` asset.
-    for (skinned_mesh_entity, skinned_mesh_view_visibility, skinned_mesh) in changed_skinned_meshes
+    for (skinned_mesh_entity, skinned_mesh_view_visibility, skinned_mesh, mesh) in
+        changed_skinned_meshes
     {
         // Remove the skin if it existed last frame.
         let skinned_mesh_entity = MainEntity::from(skinned_mesh_entity);
@@ -359,6 +388,13 @@ fn add_or_delete_skins(
             continue;
         }
 
+        // If the mesh can't be skinned, we're done.
+        if let Some(mesh_asset) = meshes.get(mesh) {
+            if !is_skinned(mesh_asset) {
+                continue;
+            }
+        }
+
         // Initialize the skin.
         add_skin(
             skinned_mesh_entity,
@@ -376,11 +412,13 @@ fn extract_joints(
     skin_uniforms: &mut SkinUniforms,
     skinned_meshes: &Query<(Entity, &SkinnedMesh)>,
     changed_skinned_meshes: &Query<
-        (Entity, &ViewVisibility, &SkinnedMesh),
+        (Entity, &ViewVisibility, &SkinnedMesh, &Mesh3d),
         Or<(
             Changed<ViewVisibility>,
             Changed<SkinnedMesh>,
             AssetChanged<SkinnedMesh>,
+            Changed<Mesh3d>,
+            AssetChanged<Mesh3d>,
         )>,
     >,
     skinned_mesh_inverse_bindposes: &Assets<SkinnedMeshInverseBindposes>,
@@ -447,11 +485,13 @@ fn extract_joints_for_skin(
     skin: &SkinnedMesh,
     skin_uniforms: &mut SkinUniforms,
     changed_skinned_meshes: &Query<
-        (Entity, &ViewVisibility, &SkinnedMesh),
+        (Entity, &ViewVisibility, &SkinnedMesh, &Mesh3d),
         Or<(
             Changed<ViewVisibility>,
             Changed<SkinnedMesh>,
             AssetChanged<SkinnedMesh>,
+            Changed<Mesh3d>,
+            AssetChanged<Mesh3d>,
         )>,
     >,
     skinned_mesh_inverse_bindposes: &Assets<SkinnedMeshInverseBindposes>,

From a2fc0c2d4b62468e2b289074f2208688ca7c8cbc Mon Sep 17 00:00:00 2001
From: Greeble <166992735+greeble-dev@users.noreply.github.com>
Date: Thu, 27 Feb 2025 21:30:39 +0000
Subject: [PATCH 05/10] Fixed CI fail following #17905 changes to `ChildOf`.

---
 tests/3d/invalid_skinned_mesh.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/tests/3d/invalid_skinned_mesh.rs b/tests/3d/invalid_skinned_mesh.rs
index cc970ebff8849..c96e8df89514d 100644
--- a/tests/3d/invalid_skinned_mesh.rs
+++ b/tests/3d/invalid_skinned_mesh.rs
@@ -155,7 +155,11 @@ fn setup_meshes(
         let joint_0 = commands.spawn(transform).id();
 
         let joint_1 = commands
-            .spawn((ChildOf(joint_0), AnimatedJoint, Transform::IDENTITY))
+            .spawn((
+                ChildOf { parent: joint_0 },
+                AnimatedJoint,
+                Transform::IDENTITY,
+            ))
             .id();
 
         // Optionally delete one joint entity.

From 9def15d712a071fae8c8e304bd4e65b21997f855 Mon Sep 17 00:00:00 2001
From: Greeble <166992735+greeble-dev@users.noreply.github.com>
Date: Thu, 27 Feb 2025 21:55:05 +0000
Subject: [PATCH 06/10] Reverted fix for warning spam when mesh has a
 `SkinnedMesh` component but no skinning attributes.

---
 crates/bevy_pbr/src/render/mesh.rs |  2 --
 crates/bevy_pbr/src/render/skin.rs | 37 ++++--------------------------
 2 files changed, 5 insertions(+), 34 deletions(-)

diff --git a/crates/bevy_pbr/src/render/mesh.rs b/crates/bevy_pbr/src/render/mesh.rs
index 9d33373334ab7..6396afade5a37 100644
--- a/crates/bevy_pbr/src/render/mesh.rs
+++ b/crates/bevy_pbr/src/render/mesh.rs
@@ -2775,8 +2775,6 @@ pub fn prepare_mesh_bind_groups(
     }
 }
 
-/// This should match the `is_skinned` function in `skin.rs`, which takes a
-/// `Mesh` instead of a `MeshVertexBufferLayoutRef`.
 fn is_skinned(layout: &MeshVertexBufferLayoutRef) -> bool {
     layout.0.contains(Mesh::ATTRIBUTE_JOINT_INDEX)
         && layout.0.contains(Mesh::ATTRIBUTE_JOINT_WEIGHT)
diff --git a/crates/bevy_pbr/src/render/skin.rs b/crates/bevy_pbr/src/render/skin.rs
index 7440ef73d6ac2..5495bbd955b2d 100644
--- a/crates/bevy_pbr/src/render/skin.rs
+++ b/crates/bevy_pbr/src/render/skin.rs
@@ -5,7 +5,6 @@ use bevy_asset::{prelude::AssetChanged, Assets};
 use bevy_ecs::prelude::*;
 use bevy_math::Mat4;
 use bevy_platform_support::collections::hash_map::Entry;
-use bevy_render::mesh::{Mesh, Mesh3d};
 use bevy_render::render_resource::{Buffer, BufferDescriptor};
 use bevy_render::sync_world::{MainEntity, MainEntityHashMap, MainEntityHashSet};
 use bevy_render::{
@@ -294,20 +293,17 @@ pub fn extract_skins(
     skinned_meshes: Extract<Query<(Entity, &SkinnedMesh)>>,
     changed_skinned_meshes: Extract<
         Query<
-            (Entity, &ViewVisibility, &SkinnedMesh, &Mesh3d),
+            (Entity, &ViewVisibility, &SkinnedMesh),
             Or<(
                 Changed<ViewVisibility>,
                 Changed<SkinnedMesh>,
                 AssetChanged<SkinnedMesh>,
-                Changed<Mesh3d>,
-                AssetChanged<Mesh3d>,
             )>,
         >,
     >,
     skinned_mesh_inverse_bindposes: Extract<Res<Assets<SkinnedMeshInverseBindposes>>>,
     changed_transforms: Extract<Query<(Entity, &GlobalTransform), Changed<GlobalTransform>>>,
     joints: Extract<Query<&GlobalTransform>>,
-    meshes: Extract<Res<Assets<Mesh>>>,
     mut removed_visibilities_query: Extract<RemovedComponents<ViewVisibility>>,
     mut removed_skinned_meshes_query: Extract<RemovedComponents<SkinnedMesh>>,
 ) {
@@ -320,7 +316,6 @@ pub fn extract_skins(
         &changed_skinned_meshes,
         &skinned_mesh_inverse_bindposes,
         &joints,
-        &meshes,
     );
 
     // Extract the transforms for all joints from the scene, and write them into
@@ -348,36 +343,25 @@ pub fn extract_skins(
     }
 }
 
-/// This should match the `is_skinned` function in `mesh.rs`, which takes a
-/// `MeshVertexBufferLayoutRef` instead of a `Mesh`.
-fn is_skinned(mesh: &Mesh) -> bool {
-    mesh.contains_attribute(Mesh::ATTRIBUTE_JOINT_INDEX)
-        && mesh.contains_attribute(Mesh::ATTRIBUTE_JOINT_WEIGHT)
-}
-
 /// Searches for all skins that have become visible or invisible this frame and
 /// allocations for them as necessary.
 fn add_or_delete_skins(
     skin_uniforms: &mut SkinUniforms,
     changed_skinned_meshes: &Query<
-        (Entity, &ViewVisibility, &SkinnedMesh, &Mesh3d),
+        (Entity, &ViewVisibility, &SkinnedMesh),
         Or<(
             Changed<ViewVisibility>,
             Changed<SkinnedMesh>,
             AssetChanged<SkinnedMesh>,
-            Changed<Mesh3d>,
-            AssetChanged<Mesh3d>,
         )>,
     >,
     skinned_mesh_inverse_bindposes: &Assets<SkinnedMeshInverseBindposes>,
     joints: &Query<&GlobalTransform>,
-    meshes: &Assets<Mesh>,
 ) {
     // Find every skinned mesh that changed one of (1) visibility; (2) joint
     // entities (part of `SkinnedMesh`); (3) the associated
     // `SkinnedMeshInverseBindposes` asset.
-    for (skinned_mesh_entity, skinned_mesh_view_visibility, skinned_mesh, mesh) in
-        changed_skinned_meshes
+    for (skinned_mesh_entity, skinned_mesh_view_visibility, skinned_mesh) in changed_skinned_meshes
     {
         // Remove the skin if it existed last frame.
         let skinned_mesh_entity = MainEntity::from(skinned_mesh_entity);
@@ -388,13 +372,6 @@ fn add_or_delete_skins(
             continue;
         }
 
-        // If the mesh can't be skinned, we're done.
-        if let Some(mesh_asset) = meshes.get(mesh) {
-            if !is_skinned(mesh_asset) {
-                continue;
-            }
-        }
-
         // Initialize the skin.
         add_skin(
             skinned_mesh_entity,
@@ -412,13 +389,11 @@ fn extract_joints(
     skin_uniforms: &mut SkinUniforms,
     skinned_meshes: &Query<(Entity, &SkinnedMesh)>,
     changed_skinned_meshes: &Query<
-        (Entity, &ViewVisibility, &SkinnedMesh, &Mesh3d),
+        (Entity, &ViewVisibility, &SkinnedMesh),
         Or<(
             Changed<ViewVisibility>,
             Changed<SkinnedMesh>,
             AssetChanged<SkinnedMesh>,
-            Changed<Mesh3d>,
-            AssetChanged<Mesh3d>,
         )>,
     >,
     skinned_mesh_inverse_bindposes: &Assets<SkinnedMeshInverseBindposes>,
@@ -485,13 +460,11 @@ fn extract_joints_for_skin(
     skin: &SkinnedMesh,
     skin_uniforms: &mut SkinUniforms,
     changed_skinned_meshes: &Query<
-        (Entity, &ViewVisibility, &SkinnedMesh, &Mesh3d),
+        (Entity, &ViewVisibility, &SkinnedMesh),
         Or<(
             Changed<ViewVisibility>,
             Changed<SkinnedMesh>,
             AssetChanged<SkinnedMesh>,
-            Changed<Mesh3d>,
-            AssetChanged<Mesh3d>,
         )>,
     >,
     skinned_mesh_inverse_bindposes: &Assets<SkinnedMeshInverseBindposes>,

From 0e4e9c1f58e1efec07262068e17ecb0a5a9c07b1 Mon Sep 17 00:00:00 2001
From: Greeble <166992735+greeble-dev@users.noreply.github.com>
Date: Thu, 27 Feb 2025 22:04:48 +0000
Subject: [PATCH 07/10] Fixed docs warning ("`extract_morphs` is private").

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

diff --git a/crates/bevy_pbr/src/render/mesh.rs b/crates/bevy_pbr/src/render/mesh.rs
index 6396afade5a37..9b757e77983eb 100644
--- a/crates/bevy_pbr/src/render/mesh.rs
+++ b/crates/bevy_pbr/src/render/mesh.rs
@@ -1638,7 +1638,7 @@ fn extract_mesh_for_gpu_building(
 /// in [`RenderMeshInstanceFlags`] would be to have
 /// [`crate::material::queue_material_meshes`] check the morph target tables for
 /// each mesh, but that would be too slow in the hot mesh queuing loop.
-pub fn set_mesh_motion_vector_flags(
+fn set_mesh_motion_vector_flags(
     mut render_mesh_instances: ResMut<RenderMeshInstances>,
     morph_indices: Res<MorphIndices>,
 ) {

From 02a52fb4697a1ee51bcd364b7c47f8d7934e4b61 Mon Sep 17 00:00:00 2001
From: Greeble <166992735+greeble-dev@users.noreply.github.com>
Date: Fri, 28 Feb 2025 09:02:46 +0000
Subject: [PATCH 08/10] Tweaked example visuals, mainly to distinguish the
 meshes from each other.

---
 tests/3d/invalid_skinned_mesh.rs | 39 +++++++++++++++++++++-----------
 1 file changed, 26 insertions(+), 13 deletions(-)

diff --git a/tests/3d/invalid_skinned_mesh.rs b/tests/3d/invalid_skinned_mesh.rs
index c96e8df89514d..6ce1a3dbc19f7 100644
--- a/tests/3d/invalid_skinned_mesh.rs
+++ b/tests/3d/invalid_skinned_mesh.rs
@@ -54,7 +54,7 @@ fn setup_environment(
         Transform::from_xyz(0.0, 0.0, 1.0).looking_at(Vec3::new(0.0, 0.0, 0.0), Vec3::Y),
         Projection::Orthographic(OrthographicProjection {
             scaling_mode: ScalingMode::AutoMin {
-                min_width: 18.0,
+                min_width: 19.0,
                 min_height: 6.0,
             },
             ..OrthographicProjection::default_3d()
@@ -84,7 +84,7 @@ fn setup_environment(
         Transform::from_xyz(0.0, 0.0, -1.0),
         Mesh3d(mesh_assets.add(Plane3d::default().mesh().size(100.0, 100.0).normal(Dir3::Z))),
         MeshMaterial3d(material_assets.add(StandardMaterial {
-            base_color: Color::srgb(0.1 * 0.5, 0.3 * 0.5, 0.1 * 0.5),
+            base_color: Color::srgb(0.05, 0.05, 0.15),
             reflectance: 0.2,
             ..default()
         })),
@@ -97,7 +97,7 @@ fn setup_meshes(
     mut material_assets: ResMut<Assets<StandardMaterial>>,
     mut inverse_bindposes_assets: ResMut<Assets<SkinnedMeshInverseBindposes>>,
 ) {
-    // Create a mesh with two squares.
+    // Create a mesh with two rectangles.
     let unskinned_mesh = Mesh::new(
         PrimitiveTopology::TriangleList,
         RenderAssetUsages::default(),
@@ -109,16 +109,16 @@ fn setup_meshes(
             [0.3, -0.3, 0.0],
             [-0.3, 0.3, 0.0],
             [0.3, 0.3, 0.0],
-            [-0.5, 1.0, 0.0],
-            [0.5, 1.0, 0.0],
-            [-0.5, 2.0, 0.0],
-            [0.5, 2.0, 0.0],
+            [-0.4, 0.8, 0.0],
+            [0.4, 0.8, 0.0],
+            [-0.4, 1.8, 0.0],
+            [0.4, 1.8, 0.0],
         ],
     )
     .with_inserted_attribute(Mesh::ATTRIBUTE_NORMAL, vec![[0.0, 0.0, 1.0]; 8])
     .with_inserted_indices(Indices::U16(vec![0, 1, 3, 0, 3, 2, 4, 5, 7, 4, 7, 6]));
 
-    // Copy the mesh and add skinning attributes that bind each square to a joint.
+    // Copy the mesh and add skinning attributes that bind each rectangle to a joint.
     let skinned_mesh = unskinned_mesh
         .clone()
         .with_inserted_attribute(
@@ -144,13 +144,19 @@ fn setup_meshes(
 
     let inverse_bindposes_handle = inverse_bindposes_assets.add(vec![
         Mat4::IDENTITY,
-        Mat4::from_translation(Vec3::new(0.0, -1.5, 0.0)),
+        Mat4::from_translation(Vec3::new(0.0, -1.3, 0.0)),
     ]);
 
-    let material_handle = material_assets.add(StandardMaterial::default());
+    let mesh_material_handle = material_assets.add(StandardMaterial::default());
+
+    let background_material_handle = material_assets.add(StandardMaterial {
+        base_color: Color::srgb(0.05, 0.15, 0.05),
+        reflectance: 0.2,
+        ..default()
+    });
 
     for mesh_index in 0..4 {
-        let transform = Transform::from_xyz(((mesh_index as f32) - 1.5) * 4.0, 0.0, 0.0);
+        let transform = Transform::from_xyz(((mesh_index as f32) - 1.5) * 4.5, 0.0, 0.0);
 
         let joint_0 = commands.spawn(transform).id();
 
@@ -175,7 +181,7 @@ fn setup_meshes(
 
         let mut entity_commands = commands.spawn((
             Mesh3d(mesh_handle.clone()),
-            MeshMaterial3d(material_handle.clone()),
+            MeshMaterial3d(mesh_material_handle.clone()),
             transform,
         ));
 
@@ -186,6 +192,13 @@ fn setup_meshes(
                 joints: vec![joint_0, joint_1],
             });
         }
+
+        // Add a square behind the mesh to distinguish it from the other meshes.
+        commands.spawn((
+            Transform::from_xyz(transform.translation.x, transform.translation.y, -0.8),
+            Mesh3d(mesh_assets.add(Plane3d::default().mesh().size(4.3, 4.3).normal(Dir3::Z))),
+            MeshMaterial3d(background_material_handle.clone()),
+        ));
     }
 }
 
@@ -198,6 +211,6 @@ fn update_animated_joints(time: Res<Time>, query: Query<&mut Transform, With<Ani
         let rotation = Quat::from_rotation_z(angle);
 
         transform.rotation = rotation;
-        transform.translation = rotation.mul_vec3(Vec3::new(0.0, 1.5, 0.0));
+        transform.translation = rotation.mul_vec3(Vec3::new(0.0, 1.3, 0.0));
     }
 }

From 85d1a00179e96a7380bd2823647940943ec8af6a Mon Sep 17 00:00:00 2001
From: Greeble <166992735+greeble-dev@users.noreply.github.com>
Date: Fri, 28 Feb 2025 09:26:33 +0000
Subject: [PATCH 09/10] Refactored specialize system parameters into a shared
 `SpecializeParams`.

---
 crates/bevy_pbr/src/material.rs     | 24 +++++++++++++++++-------
 crates/bevy_pbr/src/prepass/mod.rs  | 25 ++++++++++++-------------
 crates/bevy_pbr/src/render/light.rs | 15 +++++++--------
 3 files changed, 36 insertions(+), 28 deletions(-)

diff --git a/crates/bevy_pbr/src/material.rs b/crates/bevy_pbr/src/material.rs
index 769e16f385f3e..cb1c10e9ed693 100644
--- a/crates/bevy_pbr/src/material.rs
+++ b/crates/bevy_pbr/src/material.rs
@@ -21,7 +21,7 @@ use bevy_core_pipeline::{
 };
 use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::component::Tick;
-use bevy_ecs::system::SystemChangeTick;
+use bevy_ecs::system::{SystemChangeTick, SystemParam};
 use bevy_ecs::{
     prelude::*,
     system::{
@@ -800,7 +800,16 @@ pub fn check_entities_needing_specialization<M>(
     }
 }
 
+/// Parameters shared between specialize systems.
+#[derive(SystemParam)]
+pub struct SpecializeParams<'w, M: Material> {
+    pub pipeline_cache: Res<'w, PipelineCache>,
+    pub entity_specialization_ticks: Res<'w, EntitySpecializationTicks<M>>,
+    pub skin_uniforms: Res<'w, SkinUniforms>,
+}
+
 pub fn specialize_material_meshes<M: Material>(
+    params: SpecializeParams<M>,
     render_meshes: Res<RenderAssets<RenderMesh>>,
     render_materials: Res<RenderAssets<PreparedMaterial<M>>>,
     render_mesh_instances: Res<RenderMeshInstances>,
@@ -822,13 +831,10 @@ pub fn specialize_material_meshes<M: Material>(
     ),
     views: Query<(&ExtractedView, &RenderVisibleEntities)>,
     view_key_cache: Res<ViewKeyCache>,
-    entity_specialization_ticks: Res<EntitySpecializationTicks<M>>,
     view_specialization_ticks: Res<ViewSpecializationTicks>,
     mut specialized_material_pipeline_cache: ResMut<SpecializedMaterialPipelineCache<M>>,
     mut pipelines: ResMut<SpecializedMeshPipelines<MaterialPipeline<M>>>,
     pipeline: Res<MaterialPipeline<M>>,
-    (pipeline_cache, skin_uniforms): (Res<PipelineCache>, Res<SkinUniforms>),
-
     ticks: SystemChangeTick,
 ) where
     M::Data: PartialEq + Eq + Hash + Clone,
@@ -860,7 +866,10 @@ pub fn specialize_material_meshes<M: Material>(
             .or_default();
 
         for (_, visible_entity) in visible_entities.iter::<Mesh3d>() {
-            let entity_tick = entity_specialization_ticks.get(visible_entity).unwrap();
+            let entity_tick = params
+                .entity_specialization_ticks
+                .get(visible_entity)
+                .unwrap();
             let last_specialized_tick = view_specialized_material_pipeline_cache
                 .get(visible_entity)
                 .map(|(tick, _)| *tick);
@@ -911,7 +920,7 @@ pub fn specialize_material_meshes<M: Material>(
                 mesh_key |= MeshPipelineKey::VISIBILITY_RANGE_DITHER;
             }
 
-            let is_skinned = skin_uniforms.contains(*visible_entity);
+            let is_skinned = params.skin_uniforms.contains(*visible_entity);
 
             if is_skinned {
                 mesh_key |= MeshPipelineKey::SKINNED;
@@ -936,7 +945,8 @@ pub fn specialize_material_meshes<M: Material>(
                     .get_extra_data(material.binding.slot)
                     .clone(),
             };
-            let pipeline_id = pipelines.specialize(&pipeline_cache, &pipeline, key, &mesh.layout);
+            let pipeline_id =
+                pipelines.specialize(&params.pipeline_cache, &pipeline, key, &mesh.layout);
             let pipeline_id = match pipeline_id {
                 Ok(id) => id,
                 Err(err) => {
diff --git a/crates/bevy_pbr/src/prepass/mod.rs b/crates/bevy_pbr/src/prepass/mod.rs
index 8a35c95ae427b..bd5dbed8a2bb7 100644
--- a/crates/bevy_pbr/src/prepass/mod.rs
+++ b/crates/bevy_pbr/src/prepass/mod.rs
@@ -3,11 +3,11 @@ mod prepass_bindings;
 use crate::{
     alpha_mode_pipeline_key, binding_arrays_are_usable, buffer_layout,
     collect_meshes_for_gpu_building, material_bind_groups::MaterialBindGroupAllocator,
-    queue_material_meshes, setup_morph_and_skinning_defs, skin, DrawMesh,
-    EntitySpecializationTicks, Material, MaterialPipeline, MaterialPipelineKey, MeshLayouts,
-    MeshPipeline, MeshPipelineKey, OpaqueRendererMethod, PreparedMaterial, RenderLightmaps,
-    RenderMaterialInstances, RenderMeshInstanceFlags, RenderMeshInstances, RenderPhaseType,
-    SetMaterialBindGroup, SetMeshBindGroup, ShadowView, SkinUniforms, StandardMaterial,
+    queue_material_meshes, setup_morph_and_skinning_defs, skin, DrawMesh, Material,
+    MaterialPipeline, MaterialPipelineKey, MeshLayouts, MeshPipeline, MeshPipelineKey,
+    OpaqueRendererMethod, PreparedMaterial, RenderLightmaps, RenderMaterialInstances,
+    RenderMeshInstanceFlags, RenderMeshInstances, RenderPhaseType, SetMaterialBindGroup,
+    SetMeshBindGroup, ShadowView, SpecializeParams, StandardMaterial,
 };
 use bevy_app::{App, Plugin, PreUpdate};
 use bevy_render::{
@@ -892,6 +892,7 @@ pub fn check_prepass_views_need_specialization(
 }
 
 pub fn specialize_prepass_material_meshes<M>(
+    params: SpecializeParams<M>,
     render_meshes: Res<RenderAssets<RenderMesh>>,
     render_materials: Res<RenderAssets<PreparedMaterial<M>>>,
     render_mesh_instances: Res<RenderMeshInstances>,
@@ -900,7 +901,6 @@ pub fn specialize_prepass_material_meshes<M>(
     render_visibility_ranges: Res<RenderVisibilityRanges>,
     material_bind_group_allocator: Res<MaterialBindGroupAllocator<M>>,
     view_key_cache: Res<ViewKeyPrepassCache>,
-    skin_uniforms: Res<SkinUniforms>,
     views: Query<(
         &ExtractedView,
         &RenderVisibleEntities,
@@ -924,17 +924,13 @@ pub fn specialize_prepass_material_meshes<M>(
         ticks,
         prepass_pipeline,
         mut pipelines,
-        pipeline_cache,
         view_specialization_ticks,
-        entity_specialization_ticks,
     ): (
         ResMut<SpecializedPrepassMaterialPipelineCache<M>>,
         SystemChangeTick,
         Res<PrepassPipeline<M>>,
         ResMut<SpecializedMeshPipelines<PrepassPipeline<M>>>,
-        Res<PipelineCache>,
         Res<ViewPrepassSpecializationTicks>,
-        Res<EntitySpecializationTicks<M>>,
     ),
 ) where
     M: Material,
@@ -962,7 +958,10 @@ pub fn specialize_prepass_material_meshes<M>(
             .or_default();
 
         for (_, visible_entity) in visible_entities.iter::<Mesh3d>() {
-            let entity_tick = entity_specialization_ticks.get(visible_entity).unwrap();
+            let entity_tick = params
+                .entity_specialization_ticks
+                .get(visible_entity)
+                .unwrap();
             let last_specialized_tick = view_specialized_material_pipeline_cache
                 .get(visible_entity)
                 .map(|(tick, _)| *tick);
@@ -1042,7 +1041,7 @@ pub fn specialize_prepass_material_meshes<M>(
                 mesh_key |= MeshPipelineKey::VISIBILITY_RANGE_DITHER;
             }
 
-            let is_skinned = skin_uniforms.contains(*visible_entity);
+            let is_skinned = params.skin_uniforms.contains(*visible_entity);
 
             if is_skinned {
                 mesh_key |= MeshPipelineKey::SKINNED;
@@ -1062,7 +1061,7 @@ pub fn specialize_prepass_material_meshes<M>(
             }
 
             let pipeline_id = pipelines.specialize(
-                &pipeline_cache,
+                &params.pipeline_cache,
                 &prepass_pipeline,
                 MaterialPipelineKey {
                     mesh_key,
diff --git a/crates/bevy_pbr/src/render/light.rs b/crates/bevy_pbr/src/render/light.rs
index 25a11a1845134..ca7d345963605 100644
--- a/crates/bevy_pbr/src/render/light.rs
+++ b/crates/bevy_pbr/src/render/light.rs
@@ -1718,6 +1718,7 @@ pub fn check_views_lights_need_specialization(
 }
 
 pub fn specialize_shadows<M: Material>(
+    params: SpecializeParams<M>,
     prepass_pipeline: Res<PrepassPipeline<M>>,
     (
         render_meshes,
@@ -1734,7 +1735,6 @@ pub fn specialize_shadows<M: Material>(
     ),
     shadow_render_phases: Res<ViewBinnedRenderPhases<Shadow>>,
     mut pipelines: ResMut<SpecializedMeshPipelines<PrepassPipeline<M>>>,
-    pipeline_cache: Res<PipelineCache>,
     render_lightmaps: Res<RenderLightmaps>,
     view_lights: Query<(Entity, &ViewLightEntities), With<ExtractedView>>,
     view_light_entities: Query<(&LightEntity, &ExtractedView)>,
@@ -1747,10 +1747,6 @@ pub fn specialize_shadows<M: Material>(
     light_key_cache: Res<LightKeyCache>,
     mut specialized_material_pipeline_cache: ResMut<SpecializedShadowMaterialPipelineCache<M>>,
     light_specialization_ticks: Res<LightSpecializationTicks>,
-    (entity_specialization_ticks, skin_uniforms): (
-        Res<EntitySpecializationTicks<M>>,
-        Res<SkinUniforms>,
-    ),
     ticks: SystemChangeTick,
 ) where
     M::Data: PartialEq + Eq + Hash + Clone,
@@ -1812,7 +1808,10 @@ pub fn specialize_shadows<M: Material>(
                 .or_default();
 
             for (_, visible_entity) in visible_entities.iter().copied() {
-                let entity_tick = entity_specialization_ticks.get(&visible_entity).unwrap();
+                let entity_tick = params
+                    .entity_specialization_ticks
+                    .get(&visible_entity)
+                    .unwrap();
                 let last_specialized_tick = view_specialized_material_pipeline_cache
                     .get(&visible_entity)
                     .map(|(tick, _)| *tick);
@@ -1865,7 +1864,7 @@ pub fn specialize_shadows<M: Material>(
                     mesh_key |= MeshPipelineKey::LIGHTMAPPED;
                 }
 
-                if skin_uniforms.contains(visible_entity) {
+                if params.skin_uniforms.contains(visible_entity) {
                     mesh_key |= MeshPipelineKey::SKINNED;
                 }
 
@@ -1878,7 +1877,7 @@ pub fn specialize_shadows<M: Material>(
                     _ => MeshPipelineKey::NONE,
                 };
                 let pipeline_id = pipelines.specialize(
-                    &pipeline_cache,
+                    &params.pipeline_cache,
                     &prepass_pipeline,
                     MaterialPipelineKey {
                         mesh_key,

From 37b5a8d1abec54c70b542ba42c6d7a39642b467b Mon Sep 17 00:00:00 2001
From: Greeble <166992735+greeble-dev@users.noreply.github.com>
Date: Fri, 28 Feb 2025 13:11:31 +0000
Subject: [PATCH 10/10] Fixed test failing on WebGL - MSAA and MotionBlur can't
 be combined.

---
 tests/3d/invalid_skinned_mesh.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/tests/3d/invalid_skinned_mesh.rs b/tests/3d/invalid_skinned_mesh.rs
index 6ce1a3dbc19f7..dfa467c3df4e9 100644
--- a/tests/3d/invalid_skinned_mesh.rs
+++ b/tests/3d/invalid_skinned_mesh.rs
@@ -68,6 +68,9 @@ fn setup_environment(
             #[cfg(all(feature = "webgl2", target_arch = "wasm32", not(feature = "webgpu")))]
             _webgl2_padding: Default::default(),
         },
+        // MSAA and MotionBlur together are not compatible on WebGL.
+        #[cfg(all(feature = "webgl2", target_arch = "wasm32", not(feature = "webgpu")))]
+        Msaa::Off,
     ));
 
     // Add a directional light to make sure we exercise the renderer's shadow path.