bevyengine#12502 Remove limit on RenderLayers.

Author: tychedelia

crates/bevy_gizmos/src/config.rs

@@ -197,7 +197,7 @@ impl From<&GizmoConfig> for GizmoMeshConfig {
         GizmoMeshConfig {
             line_perspective: item.line_perspective,
             line_style: item.line_style,
-            render_layers: item.render_layers,
+            render_layers: item.render_layers.clone(),
         }
     }
 }

crates/bevy_gizmos/src/pipeline_2d.rs

@@ -269,8 +269,8 @@ fn queue_line_gizmos_2d(
         let mesh_key = Mesh2dPipelineKey::from_msaa_samples(msaa.samples())
             | Mesh2dPipelineKey::from_hdr(view.hdr);
 
+        let render_layers = render_layers.unwrap_or_default();
         for (entity, handle, config) in &line_gizmos {
-            let render_layers = render_layers.copied().unwrap_or_default();
             if !config.render_layers.intersects(&render_layers) {
                 continue;
             }
@@ -325,8 +325,8 @@ fn queue_line_joint_gizmos_2d(
         let mesh_key = Mesh2dPipelineKey::from_msaa_samples(msaa.samples())
             | Mesh2dPipelineKey::from_hdr(view.hdr);
 
+        let render_layers = render_layers.unwrap_or_default();
         for (entity, handle, config) in &line_gizmos {
-            let render_layers = render_layers.copied().unwrap_or_default();
             if !config.render_layers.intersects(&render_layers) {
                 continue;
             }

crates/bevy_gizmos/src/pipeline_3d.rs

@@ -303,7 +303,7 @@ fn queue_line_gizmos_3d(
         (normal_prepass, depth_prepass, motion_vector_prepass, deferred_prepass),
     ) in &mut views
     {
-        let render_layers = render_layers.copied().unwrap_or_default();
+        let render_layers = render_layers.unwrap_or_default();
 
         let mut view_key = MeshPipelineKey::from_msaa_samples(msaa.samples())
             | MeshPipelineKey::from_hdr(view.hdr);
@@ -389,7 +389,7 @@ fn queue_line_joint_gizmos_3d(
         (normal_prepass, depth_prepass, motion_vector_prepass, deferred_prepass),
     ) in &mut views
     {
-        let render_layers = render_layers.copied().unwrap_or_default();
+        let render_layers = render_layers.unwrap_or_default();
 
         let mut view_key = MeshPipelineKey::from_msaa_samples(msaa.samples())
             | MeshPipelineKey::from_hdr(view.hdr);

crates/bevy_pbr/src/light/mod.rs

@@ -23,6 +23,7 @@ use crate::*;
 
 mod ambient_light;
 pub use ambient_light::AmbientLight;
+
 mod point_light;
 pub use point_light::PointLight;
 mod spot_light;
@@ -1015,7 +1016,7 @@ pub(crate) fn directional_light_order(
         .then_with(|| entity_1.cmp(entity_2)) // stable
 }
 
-#[derive(Clone, Copy)]
+#[derive(Clone)]
 // data required for assigning lights to clusters
 pub(crate) struct PointLightAssignmentData {
     entity: Entity,
@@ -1105,7 +1106,7 @@ pub(crate) fn assign_lights_to_clusters(
                         shadows_enabled: point_light.shadows_enabled,
                         range: point_light.range,
                         spot_light_angle: None,
-                        render_layers: maybe_layers.copied().unwrap_or_default(),
+                        render_layers: maybe_layers.unwrap_or_default().clone(),
                     }
                 },
             ),
@@ -1122,7 +1123,7 @@ pub(crate) fn assign_lights_to_clusters(
                         shadows_enabled: spot_light.shadows_enabled,
                         range: spot_light.range,
                         spot_light_angle: Some(spot_light.outer_angle),
-                        render_layers: maybe_layers.copied().unwrap_or_default(),
+                        render_layers: maybe_layers.unwrap_or_default().clone(),
                     }
                 },
             ),
@@ -1196,7 +1197,7 @@ pub(crate) fn assign_lights_to_clusters(
         mut visible_lights,
     ) in &mut views
     {
-        let view_layers = maybe_layers.copied().unwrap_or_default();
+        let view_layers = maybe_layers.unwrap_or_default().clone();
         let clusters = clusters.into_inner();
 
         if matches!(config, ClusterConfig::None) {
@@ -1919,7 +1920,7 @@ pub fn check_light_mesh_visibility(
             continue;
         }
 
-        let view_mask = maybe_view_mask.copied().unwrap_or_default();
+        let view_mask = maybe_view_mask.unwrap_or_default().clone();
 
         for (
             entity,
@@ -1934,7 +1935,7 @@ pub fn check_light_mesh_visibility(
                 continue;
             }
 
-            let entity_mask = maybe_entity_mask.copied().unwrap_or_default();
+            let entity_mask = maybe_entity_mask.unwrap_or_default().clone();
             if !view_mask.intersects(&entity_mask) {
                 continue;
             }
@@ -1999,7 +2000,7 @@ pub fn check_light_mesh_visibility(
                     continue;
                 }
 
-                let view_mask = maybe_view_mask.copied().unwrap_or_default();
+                let view_mask = maybe_view_mask.unwrap_or_default().clone();
                 let light_sphere = Sphere {
                     center: Vec3A::from(transform.translation()),
                     radius: point_light.range,
@@ -2018,7 +2019,7 @@ pub fn check_light_mesh_visibility(
                         continue;
                     }
 
-                    let entity_mask = maybe_entity_mask.copied().unwrap_or_default();
+                    let entity_mask = maybe_entity_mask.unwrap_or_default().clone();
                     if !view_mask.intersects(&entity_mask) {
                         continue;
                     }
@@ -2064,7 +2065,7 @@ pub fn check_light_mesh_visibility(
                     continue;
                 }
 
-                let view_mask = maybe_view_mask.copied().unwrap_or_default();
+                let view_mask = maybe_view_mask.unwrap_or_default().clone();
                 let light_sphere = Sphere {
                     center: Vec3A::from(transform.translation()),
                     radius: point_light.range,
@@ -2083,7 +2084,7 @@ pub fn check_light_mesh_visibility(
                         continue;
                     }
 
-                    let entity_mask = maybe_entity_mask.copied().unwrap_or_default();
+                    let entity_mask = maybe_entity_mask.unwrap_or_default().clone();
                     if !view_mask.intersects(&entity_mask) {
                         continue;
                     }

crates/bevy_pbr/src/render/light.rs

@@ -164,6 +164,7 @@ pub struct GpuDirectionalCascade {
 
 #[derive(Copy, Clone, ShaderType, Default, Debug)]
 pub struct GpuDirectionalLight {
+    skip: u32,
     cascades: [GpuDirectionalCascade; MAX_CASCADES_PER_LIGHT],
     color: Vec4,
     dir_to_light: Vec3,
@@ -173,7 +174,6 @@ pub struct GpuDirectionalLight {
     num_cascades: u32,
     cascades_overlap_proportion: f32,
     depth_texture_base_index: u32,
-    render_layers: u32,
 }
 
 // NOTE: These must match the bit flags in bevy_pbr/src/render/mesh_view_types.wgsl!
@@ -488,7 +488,7 @@ pub fn extract_lights(
                 cascade_shadow_config: cascade_config.clone(),
                 cascades: cascades.cascades.clone(),
                 frusta: frusta.frusta.clone(),
-                render_layers: maybe_layers.copied().unwrap_or_default(),
+                render_layers: maybe_layers.unwrap_or_default().clone(),
             },
             render_visible_entities,
         ));
@@ -684,7 +684,12 @@ pub fn prepare_lights(
     mut global_light_meta: ResMut<GlobalLightMeta>,
     mut light_meta: ResMut<LightMeta>,
     views: Query<
-        (Entity, &ExtractedView, &ExtractedClusterConfig),
+        (
+            Entity,
+            &ExtractedView,
+            &ExtractedClusterConfig,
+            Option<&RenderLayers>,
+        ),
         With<SortedRenderPhase<Transparent3d>>,
     >,
     ambient_light: Res<AmbientLight>,
@@ -904,6 +909,8 @@ pub fn prepare_lights(
             .len()
             .min(MAX_CASCADES_PER_LIGHT);
         gpu_directional_lights[index] = GpuDirectionalLight {
+            // Set to true later when necessary.
+            skip: 0u32,
             // Filled in later.
             cascades: [GpuDirectionalCascade::default(); MAX_CASCADES_PER_LIGHT],
             // premultiply color by illuminance
@@ -917,7 +924,6 @@ pub fn prepare_lights(
             num_cascades: num_cascades as u32,
             cascades_overlap_proportion: light.cascade_shadow_config.overlap_proportion,
             depth_texture_base_index: num_directional_cascades_enabled as u32,
-            render_layers: light.render_layers.bits(),
         };
         if index < directional_shadow_enabled_count {
             num_directional_cascades_enabled += num_cascades;
@@ -930,7 +936,7 @@ pub fn prepare_lights(
         .write_buffer(&render_device, &render_queue);
 
     // set up light data for each view
-    for (entity, extracted_view, clusters) in &views {
+    for (entity, extracted_view, clusters, maybe_layers) in &views {
         let point_light_depth_texture = texture_cache.get(
             &render_device,
             TextureDescriptor {
@@ -1128,11 +1134,20 @@ pub fn prepare_lights(
 
         // directional lights
         let mut directional_depth_texture_array_index = 0u32;
+        let view_layers = maybe_layers.unwrap_or_default();
         for (light_index, &(light_entity, light)) in directional_lights
             .iter()
             .enumerate()
-            .take(directional_shadow_enabled_count)
+            .take(MAX_DIRECTIONAL_LIGHTS)
         {
+            let gpu_light = &mut gpu_lights.directional_lights[light_index];
+
+            // Check if the light intersects with the view.
+            if !view_layers.intersects(&light.render_layers) {
+                gpu_light.skip = 1u32;
+                continue;
+            }
+
             let cascades = light
                 .cascades
                 .get(&entity)

crates/bevy_pbr/src/render/mesh_view_types.wgsl

@@ -23,6 +23,7 @@ struct DirectionalCascade {
 }
 
 struct DirectionalLight {
+    skip: u32,
     cascades: array<DirectionalCascade, #{MAX_CASCADES_PER_LIGHT}>,
     color: vec4<f32>,
     direction_to_light: vec3<f32>,
@@ -33,7 +34,6 @@ struct DirectionalLight {
     num_cascades: u32,
     cascades_overlap_proportion: f32,
     depth_texture_base_index: u32,
-    render_layers: u32,
 };
 
 const DIRECTIONAL_LIGHT_FLAGS_SHADOWS_ENABLED_BIT: u32 = 1u;

crates/bevy_pbr/src/render/pbr_functions.wgsl

@@ -281,10 +281,10 @@ fn apply_pbr_lighting(
     // directional lights (direct)
     let n_directional_lights = view_bindings::lights.n_directional_lights;
     for (var i: u32 = 0u; i < n_directional_lights; i = i + 1u) {
-        // check the directional light render layers intersect the view render layers
-        // note this is not necessary for point and spot lights, as the relevant lights are filtered in `assign_lights_to_clusters`
+        // check if this light should be skipped, which occurs if this light does not intersect with the view
+        // note point and spot lights aren't skippable, as the relevant lights are filtered in `assign_lights_to_clusters`
         let light = &view_bindings::lights.directional_lights[i];
-        if ((*light).render_layers & view_bindings::view.render_layers) == 0u {
+        if (*light).skip != 0u {
             continue;
         }
 

crates/bevy_render/Cargo.toml

@@ -100,7 +100,7 @@ profiling = { version = "1", features = [
 ], optional = true }
 async-channel = "2.2.0"
 nonmax = "0.5"
-smallvec = "1.11"
+smallvec = {  version = "1.11", features = ["const_new"] }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 # Omit the `glsl` feature in non-WebAssembly by default.

crates/bevy_render/src/camera/camera.rs

@@ -916,7 +916,7 @@ pub fn extract_cameras(
             }
 
             if let Some(render_layers) = render_layers {
-                commands.insert(*render_layers);
+                commands.insert(render_layers.clone());
             }
 
             if let Some(perspective) = projection {

crates/bevy_render/src/view/mod.rs

@@ -408,7 +408,6 @@ pub struct ViewUniform {
     frustum: [Vec4; 6],
     color_grading: ColorGradingUniform,
     mip_bias: f32,
-    render_layers: u32,
 }
 
 #[derive(Resource, Default)]
@@ -691,7 +690,6 @@ pub fn prepare_view_uniforms(
         Option<&Frustum>,
         Option<&TemporalJitter>,
         Option<&MipBias>,
-        Option<&RenderLayers>,
     )>,
 ) {
     let view_iter = views.iter();
@@ -710,7 +708,6 @@ pub fn prepare_view_uniforms(
         frustum,
         temporal_jitter,
         mip_bias,
-        maybe_layers,
     ) in &views
     {
         let viewport = extracted_view.viewport.as_vec4();
@@ -755,7 +752,6 @@ pub fn prepare_view_uniforms(
                 frustum,
                 color_grading: extracted_view.color_grading.clone().into(),
                 mip_bias: mip_bias.unwrap_or(&MipBias(0.0)).0,
-                render_layers: maybe_layers.copied().unwrap_or_default().bits(),
             }),
         };
 

crates/bevy_render/src/view/view.wgsl

@@ -28,5 +28,4 @@ struct View {
     frustum: array<vec4<f32>, 6>,
     color_grading: ColorGrading,
     mip_bias: f32,
-    render_layers: u32,
 };

crates/bevy_render/src/view/visibility/mod.rs

@@ -422,7 +422,7 @@ pub fn check_visibility<QF>(
             continue;
         }
 
-        let view_mask = maybe_view_mask.copied().unwrap_or_default();
+        let view_mask = maybe_view_mask.unwrap_or_default();
 
         visible_aabb_query.par_iter_mut().for_each_init(
             || thread_queues.borrow_local_mut(),
@@ -443,7 +443,7 @@ pub fn check_visibility<QF>(
                     return;
                 }
 
-                let entity_mask = maybe_entity_mask.copied().unwrap_or_default();
+                let entity_mask = maybe_entity_mask.unwrap_or_default();
                 if !view_mask.intersects(&entity_mask) {
                     return;
                 }