Store Mesh AABBs on Meshes instead of Entities

Author: cart

crates/bevy_gizmos/src/lib.rs

@@ -39,7 +39,8 @@ use bevy_reflect::{
 use bevy_render::{
     color::Color,
     extract_component::{ComponentUniforms, DynamicUniformIndex, UniformComponentPlugin},
-    primitives::Aabb,
+    prelude::Mesh,
+    primitives::{Aabb, AabbSource},
     render_asset::{PrepareAssetError, RenderAsset, RenderAssetPlugin, RenderAssets},
     render_phase::{PhaseItem, RenderCommand, RenderCommandResult, TrackedRenderPass},
     render_resource::{
@@ -201,30 +202,45 @@ pub struct AabbGizmo {
 }
 
 fn draw_aabbs(
-    query: Query<(Entity, &Aabb, &GlobalTransform, &AabbGizmo)>,
+    query: Query<(
+        Entity,
+        &AabbSource,
+        &GlobalTransform,
+        &AabbGizmo,
+        Option<&Handle<Mesh>>,
+    )>,
+    meshes: Res<Assets<Mesh>>,
     config: Res<GizmoConfig>,
     mut gizmos: Gizmos,
 ) {
-    for (entity, &aabb, &transform, gizmo) in &query {
-        let color = gizmo
-            .color
-            .or(config.aabb.default_color)
-            .unwrap_or_else(|| color_from_entity(entity));
-        gizmos.cuboid(aabb_transform(aabb, transform), color);
+    for (entity, &aabb_source, &transform, gizmo, mesh) in &query {
+        if let Some(aabb) = aabb_source.get(mesh, &meshes) {
+            let color = gizmo
+                .color
+                .or(config.aabb.default_color)
+                .unwrap_or_else(|| color_from_entity(entity));
+            gizmos.cuboid(aabb_transform(aabb, transform), color);
+        }
     }
 }
 
 fn draw_all_aabbs(
-    query: Query<(Entity, &Aabb, &GlobalTransform), Without<AabbGizmo>>,
+    query: Query<
+        (Entity, &AabbSource, &GlobalTransform, Option<&Handle<Mesh>>),
+        Without<AabbGizmo>,
+    >,
+    meshes: Res<Assets<Mesh>>,
     config: Res<GizmoConfig>,
     mut gizmos: Gizmos,
 ) {
-    for (entity, &aabb, &transform) in &query {
-        let color = config
-            .aabb
-            .default_color
-            .unwrap_or_else(|| color_from_entity(entity));
-        gizmos.cuboid(aabb_transform(aabb, transform), color);
+    for (entity, &aabb_source, &transform, mesh) in &query {
+        if let Some(aabb) = aabb_source.get(mesh, &meshes) {
+            let color = config
+                .aabb
+                .default_color
+                .unwrap_or_else(|| color_from_entity(entity));
+            gizmos.cuboid(aabb_transform(aabb, transform), color);
+        }
     }
 }
 

crates/bevy_gltf/src/loader.rs

@@ -306,6 +306,12 @@ async fn load_gltf<'a, 'b>(
                 }
             }
 
+            let bounds = primitive.bounding_box();
+            mesh.set_aabb(Aabb::from_min_max(
+                Vec3::from_slice(&bounds.min),
+                Vec3::from_slice(&bounds.max),
+            ));
+
             let mesh = load_context.set_labeled_asset(&primitive_label, LoadedAsset::new(mesh));
             primitives.push(super::GltfPrimitive {
                 mesh,
@@ -783,7 +789,6 @@ fn load_node(
                 }
 
                 let primitive_label = primitive_label(&mesh, &primitive);
-                let bounds = primitive.bounding_box();
                 let mesh_asset_path =
                     AssetPath::new_ref(load_context.path(), Some(&primitive_label));
                 let material_asset_path =
@@ -808,10 +813,6 @@ fn load_node(
                     // > the accessors of the original primitive.
                     primitive_entity.insert(MeshMorphWeights::new(weights).unwrap());
                 }
-                primitive_entity.insert(Aabb::from_min_max(
-                    Vec3::from_slice(&bounds.min),
-                    Vec3::from_slice(&bounds.max),
-                ));
 
                 if let Some(extras) = primitive.extras() {
                     primitive_entity.insert(super::GltfExtras {

crates/bevy_pbr/src/bundle.rs

@@ -7,7 +7,7 @@ use bevy_ecs::{bundle::Bundle, component::Component, prelude::Entity, reflect::R
 use bevy_reflect::{FromReflect, Reflect, ReflectFromReflect};
 use bevy_render::{
     mesh::Mesh,
-    primitives::{CascadesFrusta, CubemapFrusta, Frustum},
+    primitives::{AabbSource, CascadesFrusta, CubemapFrusta, Frustum},
     view::{ComputedVisibility, Visibility, VisibleEntities},
 };
 use bevy_transform::components::{GlobalTransform, Transform};
@@ -27,12 +27,14 @@ pub struct MaterialMeshBundle<M: Material> {
     pub visibility: Visibility,
     /// Algorithmically-computed indication of whether an entity is visible and should be extracted for rendering
     pub computed_visibility: ComputedVisibility,
+    pub aabb_source: AabbSource,
 }
 
 impl<M: Material> Default for MaterialMeshBundle<M> {
     fn default() -> Self {
         Self {
             mesh: Default::default(),
+            aabb_source: Default::default(),
             material: Default::default(),
             transform: Default::default(),
             global_transform: Default::default(),

crates/bevy_pbr/src/light.rs

@@ -7,8 +7,8 @@ use bevy_render::{
     camera::Camera,
     color::Color,
     extract_resource::ExtractResource,
-    prelude::Projection,
-    primitives::{Aabb, CascadesFrusta, CubemapFrusta, Frustum, HalfSpace, Sphere},
+    prelude::{Mesh, Projection},
+    primitives::{Aabb, AabbSource, CascadesFrusta, CubemapFrusta, Frustum, HalfSpace, Sphere},
     render_resource::BufferBindingType,
     renderer::RenderDevice,
     view::{ComputedVisibility, RenderLayers, VisibleEntities},
@@ -22,6 +22,7 @@ use crate::{
     CLUSTERED_FORWARD_STORAGE_BUFFER_COUNT, CUBE_MAP_FACES, MAX_UNIFORM_BUFFER_POINT_LIGHTS,
     POINT_LIGHT_NEAR_Z,
 };
+use bevy_asset::{Assets, Handle};
 
 /// A light that emits light in all directions from a central point.
 ///
@@ -1911,6 +1912,7 @@ pub fn update_spot_light_frusta(
 }
 
 pub fn check_light_mesh_visibility(
+    meshes: Res<Assets<Mesh>>,
     visible_point_lights: Query<&VisiblePointLights>,
     mut point_lights: Query<(
         &PointLight,
@@ -1941,8 +1943,9 @@ pub fn check_light_mesh_visibility(
             Entity,
             &mut ComputedVisibility,
             Option<&RenderLayers>,
-            Option<&Aabb>,
+            Option<&AabbSource>,
             Option<&GlobalTransform>,
+            Option<&Handle<Mesh>>,
         ),
         (Without<NotShadowCaster>, Without<DirectionalLight>),
     >,
@@ -2002,8 +2005,14 @@ pub fn check_light_mesh_visibility(
 
         let view_mask = maybe_view_mask.copied().unwrap_or_default();
 
-        for (entity, mut computed_visibility, maybe_entity_mask, maybe_aabb, maybe_transform) in
-            &mut visible_entity_query
+        for (
+            entity,
+            mut computed_visibility,
+            maybe_entity_mask,
+            maybe_aabb_source,
+            maybe_transform,
+            maybe_mesh,
+        ) in &mut visible_entity_query
         {
             if !computed_visibility.is_visible_in_hierarchy() {
                 continue;
@@ -2014,6 +2023,8 @@ pub fn check_light_mesh_visibility(
                 continue;
             }
 
+            let maybe_aabb = maybe_aabb_source.and_then(|s| s.get(maybe_mesh, &meshes));
+
             // If we have an aabb and transform, do frustum culling
             if let (Some(aabb), Some(transform)) = (maybe_aabb, maybe_transform) {
                 for (view, view_frusta) in frusta.frusta.iter() {
@@ -2026,7 +2037,8 @@ pub fn check_light_mesh_visibility(
                         view_frusta.iter().zip(view_visible_entities)
                     {
                         // Disable near-plane culling, as a shadow caster could lie before the near plane.
-                        if !frustum.intersects_obb(aabb, &transform.compute_matrix(), false, true) {
+                        if !frustum.intersects_obb(&aabb, &transform.compute_matrix(), false, true)
+                        {
                             continue;
                         }
 
@@ -2084,8 +2096,9 @@ pub fn check_light_mesh_visibility(
                     entity,
                     mut computed_visibility,
                     maybe_entity_mask,
-                    maybe_aabb,
+                    maybe_aabb_source,
                     maybe_transform,
+                    maybe_mesh,
                 ) in &mut visible_entity_query
                 {
                     if !computed_visibility.is_visible_in_hierarchy() {
@@ -2097,19 +2110,20 @@ pub fn check_light_mesh_visibility(
                         continue;
                     }
 
+                    let maybe_aabb = maybe_aabb_source.and_then(|s| s.get(maybe_mesh, &meshes));
                     // If we have an aabb and transform, do frustum culling
                     if let (Some(aabb), Some(transform)) = (maybe_aabb, maybe_transform) {
                         let model_to_world = transform.compute_matrix();
                         // Do a cheap sphere vs obb test to prune out most meshes outside the sphere of the light
-                        if !light_sphere.intersects_obb(aabb, &model_to_world) {
+                        if !light_sphere.intersects_obb(&aabb, &model_to_world) {
                             continue;
                         }
 
                         for (frustum, visible_entities) in cubemap_frusta
                             .iter()
                             .zip(cubemap_visible_entities.iter_mut())
                         {
-                            if frustum.intersects_obb(aabb, &model_to_world, true, true) {
+                            if frustum.intersects_obb(&aabb, &model_to_world, true, true) {
                                 computed_visibility.set_visible_in_view();
                                 visible_entities.entities.push(entity);
                             }
@@ -2148,8 +2162,9 @@ pub fn check_light_mesh_visibility(
                     entity,
                     mut computed_visibility,
                     maybe_entity_mask,
-                    maybe_aabb,
+                    maybe_aabb_source,
                     maybe_transform,
+                    maybe_mesh,
                 ) in visible_entity_query.iter_mut()
                 {
                     if !computed_visibility.is_visible_in_hierarchy() {
@@ -2161,15 +2176,16 @@ pub fn check_light_mesh_visibility(
                         continue;
                     }
 
+                    let maybe_aabb = maybe_aabb_source.and_then(|s| s.get(maybe_mesh, &meshes));
                     // If we have an aabb and transform, do frustum culling
                     if let (Some(aabb), Some(transform)) = (maybe_aabb, maybe_transform) {
                         let model_to_world = transform.compute_matrix();
                         // Do a cheap sphere vs obb test to prune out most meshes outside the sphere of the light
-                        if !light_sphere.intersects_obb(aabb, &model_to_world) {
+                        if !light_sphere.intersects_obb(&aabb, &model_to_world) {
                             continue;
                         }
 
-                        if frustum.intersects_obb(aabb, &model_to_world, true, true) {
+                        if frustum.intersects_obb(&aabb, &model_to_world, true, true) {
                             computed_visibility.set_visible_in_view();
                             visible_entities.entities.push(entity);
                         }

crates/bevy_render/src/mesh/mesh/mod.rs

@@ -39,6 +39,7 @@ pub struct Mesh {
     indices: Option<Indices>,
     morph_targets: Option<Handle<Image>>,
     morph_target_names: Option<Vec<String>>,
+    aabb: Option<Aabb>,
 }
 
 /// Contains geometry in the form of a mesh.
@@ -133,6 +134,7 @@ impl Mesh {
             primitive_topology,
             attributes: Default::default(),
             indices: None,
+            aabb: None,
             morph_targets: None,
             morph_target_names: None,
         }
@@ -451,6 +453,20 @@ impl Mesh {
         None
     }
 
+    /// Updates the internal AABB (uses the results of [`Mesh::compute_aabb`]).
+    pub fn update_aabb(&mut self) {
+        self.aabb = self.compute_aabb();
+    }
+
+    /// Sets the current [`Aabb`] value.
+    pub fn set_aabb(&mut self, aabb: Aabb) {
+        self.aabb = Some(aabb);
+    }
+
+    pub fn aabb(&self) -> Option<Aabb> {
+        self.aabb
+    }
+
     /// Whether this mesh has morph targets.
     pub fn has_morph_targets(&self) -> bool {
         self.morph_targets.is_some()

crates/bevy_render/src/primitives/mod.rs

@@ -1,11 +1,12 @@
+use crate::mesh::Mesh;
+use bevy_asset::{Assets, Handle};
 use bevy_ecs::{component::Component, prelude::Entity, reflect::ReflectComponent};
 use bevy_math::{Mat4, Vec3, Vec3A, Vec4, Vec4Swizzles};
 use bevy_reflect::{FromReflect, Reflect, ReflectFromReflect};
 use bevy_utils::HashMap;
 
 /// An axis-aligned bounding box.
-#[derive(Component, Clone, Copy, Debug, Default, Reflect, FromReflect)]
-#[reflect(Component)]
+#[derive(Clone, Copy, Debug, Default, Reflect, FromReflect)]
 pub struct Aabb {
     pub center: Vec3A,
     pub half_extents: Vec3A,
@@ -59,6 +60,22 @@ impl From<Sphere> for Aabb {
     }
 }
 
+#[derive(Component, Clone, Copy, Debug, Default, Reflect, FromReflect)]
+pub enum AabbSource {
+    #[default]
+    Mesh,
+    Aabb(Aabb),
+}
+
+impl AabbSource {
+    pub fn get(&self, handle: Option<&Handle<Mesh>>, meshes: &Assets<Mesh>) -> Option<Aabb> {
+        match self {
+            AabbSource::Mesh => handle.and_then(|h| meshes.get(h).and_then(|m| m.aabb())),
+            AabbSource::Aabb(aabb) => Some(*aabb),
+        }
+    }
+}
+
 #[derive(Clone, Debug, Default)]
 pub struct Sphere {
     pub center: Vec3A,