Changed back to putting SkinnedMeshBounds on Mesh. This assumes that bevyengine#21732 or similar will land, so we don't lose the bounds if the mesh doesn't have RenderAssetUsages::MAIN_WORLD.

Author: greeble-dev

crates/bevy_camera/src/visibility/mod.rs

@@ -7,8 +7,7 @@ use bevy_ecs::entity::{EntityHashMap, EntityHashSet};
 use bevy_ecs::lifecycle::HookContext;
 use bevy_ecs::world::DeferredWorld;
 use bevy_mesh::skinning::{
-    entity_aabb_from_skinned_mesh_bounds, SkinnedMesh, SkinnedMeshBounds, SkinnedMeshBoundsAsset,
-    SkinnedMeshInverseBindposes,
+    entity_aabb_from_skinned_mesh_bounds, SkinnedMesh, SkinnedMeshInverseBindposes,
 };
 use derive_more::derive::{Deref, DerefMut};
 pub use range::*;
@@ -220,6 +219,15 @@ impl ViewVisibility {
 #[reflect(Component, Default, Debug)]
 pub struct NoFrustumCulling;
 
+/// Use this component to enable dynamic skinned mesh bounds. The [`Aabb`]
+/// component of the skinned mesh will be automatically updated each frame based
+/// on the current joint transforms.
+///
+/// XXX TODO: More documentation.
+#[derive(Debug, Component, Default, Reflect)]
+#[reflect(Component, Default, Debug)]
+pub struct DynamicSkinnedMeshBounds;
+
 /// Collection of entities visible from the current view.
 ///
 /// This component contains all entities which are visible from the currently
@@ -411,44 +419,29 @@ pub fn calculate_bounds(
 // XXX TODO: Document.
 fn update_skinned_mesh_bounds(
     inverse_bindposes_assets: Res<Assets<SkinnedMeshInverseBindposes>>,
-    bounds_assets: Res<Assets<SkinnedMeshBoundsAsset>>,
+    mesh_assets: Res<Assets<Mesh>>,
     mut mesh_entities: Query<
-        (
-            &SkinnedMesh,
-            &SkinnedMeshBounds,
-            Option<&GlobalTransform>,
-            &mut Aabb,
-        ),
-        // XXX TODO: This is debatable - frustum culling is not the only
-        // system that might want skinned bounds.
-        Without<NoFrustumCulling>,
+        (&mut Aabb, &Mesh3d, &SkinnedMesh, Option<&GlobalTransform>),
+        With<DynamicSkinnedMeshBounds>,
     >,
     joint_entities: Query<&GlobalTransform>,
 ) {
     mesh_entities
         .par_iter_mut()
-        .for_each(|(mesh, bounds, world_from_entity, mut aabb)| {
-            let Some(inverse_bindposes_asset) =
-                inverse_bindposes_assets.get(&mesh.inverse_bindposes)
-            else {
-                return;
-            };
-
-            let Some(bounds_asset) = bounds_assets.get(bounds) else {
-                return;
-            };
-
-            let Some(skinned_aabb) = entity_aabb_from_skinned_mesh_bounds(
-                &joint_entities,
-                mesh,
-                inverse_bindposes_asset,
-                bounds_asset,
-                world_from_entity,
-            ) else {
-                return;
-            };
-
-            *aabb = skinned_aabb.into();
+        .for_each(|(mut aabb, mesh, skinned_mesh, world_from_entity)| {
+            if let Some(inverse_bindposes_asset) =
+                inverse_bindposes_assets.get(&skinned_mesh.inverse_bindposes)
+                && let Some(mesh_asset) = mesh_assets.get(mesh)
+                && let Some(skinned_aabb) = entity_aabb_from_skinned_mesh_bounds(
+                    &joint_entities,
+                    mesh_asset,
+                    skinned_mesh,
+                    inverse_bindposes_asset,
+                    world_from_entity,
+                )
+            {
+                *aabb = skinned_aabb.into();
+            }
         });
 }
 

crates/bevy_gizmos/src/skinned_mesh_bounds.rs

@@ -2,17 +2,19 @@
 
 use bevy_app::{Plugin, PostUpdate};
 use bevy_asset::Assets;
+use bevy_camera::visibility::DynamicSkinnedMeshBounds;
 use bevy_color::Color;
 use bevy_ecs::{
     component::Component,
-    query::Without,
+    query::{With, Without},
     reflect::ReflectComponent,
     schedule::IntoScheduleConfigs,
     system::{Query, Res},
 };
 use bevy_math::Affine3A;
-use bevy_mesh::skinning::{
-    SkinnedMesh, SkinnedMeshBounds, SkinnedMeshBoundsAsset, SkinnedMeshInverseBindposes,
+use bevy_mesh::{
+    skinning::{SkinnedMesh, SkinnedMeshInverseBindposes},
+    Mesh, Mesh3d,
 };
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_transform::{components::GlobalTransform, TransformSystems};
@@ -23,7 +25,7 @@ use crate::{
     AppGizmoBuilder,
 };
 
-/// A [`Plugin`] that provides visualization of [`SkinnedMeshBounds`]s for debugging.
+/// A [`Plugin`] that provides visualization of entities with [`DynamicSkinnedMeshBounds`].
 pub struct SkinnedMeshBoundsGizmoPlugin;
 
 impl Plugin for SkinnedMeshBoundsGizmoPlugin {
@@ -44,7 +46,7 @@ impl Plugin for SkinnedMeshBoundsGizmoPlugin {
             );
     }
 }
-/// The [`GizmoConfigGroup`] used for debug visualizations of [`SkinnedMeshBounds`] components on entities.
+/// The [`GizmoConfigGroup`] used for debug visualizations of entities with [`DynamicSkinnedMeshBounds`]
 #[derive(Clone, Reflect, GizmoConfigGroup)]
 #[reflect(Clone, Default)]
 pub struct SkinnedMeshBoundsGizmoConfigGroup {
@@ -68,7 +70,7 @@ impl Default for SkinnedMeshBoundsGizmoConfigGroup {
     }
 }
 
-/// Add this [`Component`] to an entity to draw its [`SkinnedMeshBounds`] component.
+/// Add this [`Component`] to an entity to draw its [`DynamicSkinnedMeshBounds`] component.
 #[derive(Component, Reflect, Default, Debug)]
 #[reflect(Component, Default, Debug)]
 pub struct ShowSkinnedMeshBoundsGizmo {
@@ -80,25 +82,27 @@ pub struct ShowSkinnedMeshBoundsGizmo {
 
 fn draw(
     color: Color,
-    mesh: &SkinnedMesh,
-    bounds: &SkinnedMeshBounds,
-    joints: &Query<&GlobalTransform>,
-    bounds_assets: &Res<Assets<SkinnedMeshBoundsAsset>>,
+    mesh: &Mesh3d,
+    mesh_assets: &Res<Assets<Mesh>>,
+    skinned_mesh: &SkinnedMesh,
+    joint_entities: &Query<&GlobalTransform>,
     inverse_bindposes_assets: &Res<Assets<SkinnedMeshInverseBindposes>>,
     gizmos: &mut Gizmos<SkinnedMeshBoundsGizmoConfigGroup>,
 ) {
-    if let Some(bounds_asset) = bounds_assets.get(bounds)
-        && let Some(inverse_bindposes_asset) = inverse_bindposes_assets.get(&mesh.inverse_bindposes)
+    if let Some(mesh_asset) = mesh_assets.get(mesh)
+        && let Some(bounds) = mesh_asset.skinned_mesh_bounds()
+        && let Some(inverse_bindposes_asset) =
+            inverse_bindposes_assets.get(&skinned_mesh.inverse_bindposes)
     {
-        for (&joint_index, &joint_aabb) in bounds_asset
+        for (&joint_index, &joint_aabb) in bounds
             .aabb_index_to_joint_index
             .iter()
-            .zip(bounds_asset.aabbs.iter())
+            .zip(bounds.aabbs.iter())
         {
             let joint_index = joint_index as usize;
 
-            if let Some(&joint_entity) = mesh.joints.get(joint_index)
-                && let Ok(&world_from_joint) = joints.get(joint_entity)
+            if let Some(&joint_entity) = skinned_mesh.joints.get(joint_index)
+                && let Ok(&world_from_joint) = joint_entities.get(joint_entity)
                 && let Some(&joint_from_mesh) = inverse_bindposes_asset.get(joint_index)
             {
                 let world_from_mesh =
@@ -111,45 +115,50 @@ fn draw(
 }
 
 fn draw_skinned_mesh_bounds(
-    meshes: Query<(
-        &SkinnedMesh,
-        &SkinnedMeshBounds,
-        &ShowSkinnedMeshBoundsGizmo,
-    )>,
-    joints: Query<&GlobalTransform>,
-    bounds_assets: Res<Assets<SkinnedMeshBoundsAsset>>,
+    mesh_entities: Query<
+        (&Mesh3d, &SkinnedMesh, &ShowSkinnedMeshBoundsGizmo),
+        With<DynamicSkinnedMeshBounds>,
+    >,
+    joint_entities: Query<&GlobalTransform>,
+    mesh_assets: Res<Assets<Mesh>>,
     inverse_bindposes_assets: Res<Assets<SkinnedMeshInverseBindposes>>,
     mut gizmos: Gizmos<SkinnedMeshBoundsGizmoConfigGroup>,
 ) {
-    for (mesh_bounds, mesh, gizmo) in meshes {
+    for (mesh, skinned_mesh, gizmo) in mesh_entities {
         let color = gizmo.color.unwrap_or(gizmos.config_ext.default_color);
 
         draw(
             color,
-            mesh_bounds,
             mesh,
-            &joints,
-            &bounds_assets,
+            &mesh_assets,
+            skinned_mesh,
+            &joint_entities,
             &inverse_bindposes_assets,
             &mut gizmos,
         );
     }
 }
 
 fn draw_all_skinned_mesh_bounds(
-    meshes: Query<(&SkinnedMesh, &SkinnedMeshBounds), Without<ShowSkinnedMeshBoundsGizmo>>,
-    joints: Query<&GlobalTransform>,
-    bounds_assets: Res<Assets<SkinnedMeshBoundsAsset>>,
+    mesh_entities: Query<
+        (&Mesh3d, &SkinnedMesh),
+        (
+            With<DynamicSkinnedMeshBounds>,
+            Without<ShowSkinnedMeshBoundsGizmo>,
+        ),
+    >,
+    joint_entities: Query<&GlobalTransform>,
+    mesh_assets: Res<Assets<Mesh>>,
     inverse_bindposes_assets: Res<Assets<SkinnedMeshInverseBindposes>>,
     mut gizmos: Gizmos<SkinnedMeshBoundsGizmoConfigGroup>,
 ) {
-    for (mesh_bounds, mesh) in meshes {
+    for (mesh, skinned_mesh) in mesh_entities {
         draw(
             gizmos.config_ext.default_color,
-            mesh_bounds,
             mesh,
-            &joints,
-            &bounds_assets,
+            &mesh_assets,
+            skinned_mesh,
+            &joint_entities,
             &inverse_bindposes_assets,
             &mut gizmos,
         );

crates/bevy_gltf/src/assets.rs

@@ -6,10 +6,7 @@ use core::ops::Deref;
 use bevy_animation::AnimationClip;
 use bevy_asset::{Asset, Handle};
 use bevy_ecs::{component::Component, reflect::ReflectComponent};
-use bevy_mesh::{
-    skinning::{SkinnedMeshBoundsAsset, SkinnedMeshInverseBindposes},
-    Mesh,
-};
+use bevy_mesh::{skinning::SkinnedMeshInverseBindposes, Mesh};
 use bevy_pbr::StandardMaterial;
 use bevy_platform::collections::HashMap;
 use bevy_reflect::{prelude::ReflectDefault, Reflect, TypePath};
@@ -180,8 +177,6 @@ pub struct GltfPrimitive {
     pub extras: Option<GltfExtras>,
     /// Additional data of the `material`.
     pub material_extras: Option<GltfExtras>,
-    /// Optional skinned mesh bounds of this primitive.
-    pub skinned_mesh_bounds: Option<Handle<SkinnedMeshBoundsAsset>>,
 }
 
 impl GltfPrimitive {
@@ -193,7 +188,6 @@ impl GltfPrimitive {
         material: Option<Handle<StandardMaterial>>,
         extras: Option<GltfExtras>,
         material_extras: Option<GltfExtras>,
-        skinned_mesh_bounds: Option<Handle<SkinnedMeshBoundsAsset>>,
     ) -> Self {
         GltfPrimitive {
             index: gltf_primitive.index(),
@@ -210,7 +204,6 @@ impl GltfPrimitive {
             material,
             extras,
             material_extras,
-            skinned_mesh_bounds,
         }
     }
 

crates/bevy_gltf/src/label.rs

@@ -72,14 +72,6 @@ pub enum GltfAssetLabel {
     /// `Skin{}/InverseBindMatrices`: glTF mesh skin matrices as Bevy
     /// [`SkinnedMeshInverseBindposes`](bevy_mesh::skinning::SkinnedMeshInverseBindposes)
     InverseBindMatrices(usize),
-    /// `Mesh{}/Primitive{}/SkinnedMeshBounds`: the optional [`SkinnedMeshBoundsAsset`](bevy_mesh::skinning::SkinnedMeshBoundsAsset)
-    /// created from a primitive.
-    SkinnedMeshBounds {
-        /// Index of the mesh for the primitive
-        mesh: usize,
-        /// Index of the primitive in its parent mesh
-        primitive: usize,
-    },
 }
 
 impl core::fmt::Display for GltfAssetLabel {
@@ -112,9 +104,6 @@ impl core::fmt::Display for GltfAssetLabel {
             GltfAssetLabel::InverseBindMatrices(index) => {
                 f.write_str(&format!("Skin{index}/InverseBindMatrices"))
             }
-            GltfAssetLabel::SkinnedMeshBounds { mesh, primitive } => f.write_str(&format!(
-                "Mesh{mesh}/Primitive{primitive}/SkinnedMeshBounds"
-            )),
         }
     }
 }

crates/bevy_gltf/src/lib.rs

@@ -201,9 +201,10 @@ pub enum GltfSkinnedMeshBoundsPolicy {
     /// Skinned meshes are assigned an `Aabb` component calculated from the bind
     /// pose `Mesh`.
     BindPose,
-    /// Skinned meshes are assigned a `SkinnedMeshBounds` component, which will
-    /// be used by the `bevy_camera` plugin to update the `Aabb` component
-    /// based on joint positions.
+    /// Skinned meshes are created with `SkinnedMeshBounds` and assigned
+    /// a [`DynamicSkinnedMeshBounds`](bevy_camera::visibility::DynamicSkinnedMeshBounds)
+    /// component. This means the `bevy_camera` plugin will update the `Aabb`
+    /// component based on joint positions.
     Dynamic,
     /// Same as `BindPose`, but also assign a `NoFrustumCulling` component. That
     /// component tells the `bevy_camera` plugin to avoid frustum culling the