Respect DownLevel flag for Cube Array Textures for point_light_shadow_map_array_texture_view.

crates/bevy_pbr/Cargo.toml

@@ -51,6 +51,7 @@ bincode = "1"
 range-alloc = "0.1"
 nonmax = "0.5"
 static_assertions = "1"
+wgpu = { version = "0.19.3", default-features = false, features = [] }
 
 [lints]
 workspace = true

crates/bevy_pbr/src/render/light.rs

@@ -12,7 +12,7 @@ use bevy_render::{
  render_graph::{Node, NodeRunError, RenderGraphContext},
  render_phase::*,
  render_resource::*,
- renderer::{RenderContext, RenderDevice, RenderQueue},
+ renderer::{RenderAdapter, RenderContext, RenderDevice, RenderQueue},
  texture::*,
  view::{ExtractedView, RenderLayers, ViewVisibility, VisibleEntities},
  Extract,
@@ -23,6 +23,7 @@ use bevy_utils::tracing::info_span;
 use bevy_utils::tracing::{error, warn};
 use nonmax::NonMaxU32;
 use std::{hash::Hash, num::NonZeroU64, ops::Range};
+use wgpu::DownlevelFlags;
 
 use crate::*;
 
@@ -681,6 +682,7 @@ pub fn prepare_lights(
  mut texture_cache: ResMut<TextureCache>,
  render_device: Res<RenderDevice>,
  render_queue: Res<RenderQueue>,
+ render_adapter: Res<RenderAdapter>,
  mut global_light_meta: ResMut<GlobalLightMeta>,
  mut light_meta: ResMut<LightMeta>,
  views: Query<
@@ -1208,34 +1210,35 @@ pub fn prepare_lights(
  }
  }
 
+ let point_light_texture_descriptor = if render_adapter.get_downlevel_capabilities().flags.contains(DownlevelFlags::CUBE_ARRAY_TEXTURES) {
+ &TextureViewDescriptor {
+ label: Some("point_light_shadow_map_array_texture_view"),
+ format: None,
+ dimension: Some(TextureViewDimension::CubeArray),
+ aspect: TextureAspect::DepthOnly,
+ base_mip_level: 0,
+ mip_level_count: None,
+ base_array_layer: 0,
+ array_layer_count: None,
+ }
+ } else {
+ &TextureViewDescriptor {
+ label: Some("point_light_shadow_map_array_texture_view"),
+ format: None,
+ dimension: Some(TextureViewDimension::Cube),
+ aspect: TextureAspect::DepthOnly,
+ base_mip_level: 0,
+ mip_level_count: None,
+ base_array_layer: 0,
+ array_layer_count: None,
+ } 
+ };
+
  let point_light_depth_texture_view =
  point_light_depth_texture
  .texture
- .create_view(&TextureViewDescriptor {
- label: Some("point_light_shadow_map_array_texture_view"),
- format: None,
- // NOTE: iOS Simulator is missing CubeArray support so we use Cube instead.
- // See https://github.com/bevyengine/bevy/pull/12052 - remove if support is added.
- #[cfg(all(
- not(feature = "ios_simulator"),
- any(
- not(feature = "webgl"),
- not(target_arch = "wasm32"),
- feature = "webgpu"
- )
- ))]
- dimension: Some(TextureViewDimension::CubeArray),
- #[cfg(any(
- feature = "ios_simulator",
- all(feature = "webgl", target_arch = "wasm32", not(feature = "webgpu"))
- ))]
- dimension: Some(TextureViewDimension::Cube),
- aspect: TextureAspect::DepthOnly,
- base_mip_level: 0,
- mip_level_count: None,
- base_array_layer: 0,
- array_layer_count: None,
- });
+ .create_view(point_light_texture_descriptor);
+
  let directional_light_depth_texture_view = directional_light_depth_texture
  .texture
  .create_view(&TextureViewDescriptor {

crates/bevy_pbr/src/render/mesh.rs

@@ -21,8 +21,10 @@ use bevy_render::{
  render_asset::RenderAssets,
  render_phase::{PhaseItem, RenderCommand, RenderCommandResult, TrackedRenderPass},
  render_resource::*,
- renderer::{RenderDevice, RenderQueue},
- texture::{BevyDefault, DefaultImageSampler, GpuImage, ImageSampler, TextureFormatPixelInfo},
+ renderer::{RenderAdapter, RenderDevice, RenderQueue},
+ texture::{
+ BevyDefault, DefaultImageSampler, GpuImage, Image, ImageSampler, TextureFormatPixelInfo,
+ },
  view::{ViewTarget, ViewUniformOffset, ViewVisibility},
  Extract,
 };
@@ -369,15 +371,16 @@ impl FromWorld for MeshPipeline {
  fn from_world(world: &mut World) -> Self {
  let mut system_state: SystemState<(
  Res<RenderDevice>,
+ Res<RenderAdapter>,
  Res<DefaultImageSampler>,
  Res<RenderQueue>,
  )> = SystemState::new(world);
- let (render_device, default_sampler, render_queue) = system_state.get_mut(world);
+ let (render_device, render_adapter, default_sampler, render_queue) = system_state.get_mut(world);
  let clustered_forward_buffer_binding_type = render_device
  .get_supported_read_only_binding_type(CLUSTERED_FORWARD_STORAGE_BUFFER_COUNT);
 
  let view_layouts =
- generate_view_layouts(&render_device, clustered_forward_buffer_binding_type);
+ generate_view_layouts(&render_device, &render_adapter, clustered_forward_buffer_binding_type);
 
  // A 1x1x1 'all 1.0' texture to use as a dummy texture to use in place of optional StandardMaterial textures
  let dummy_white_gpu_image = {

crates/bevy_pbr/src/render/mesh_view_bindings.rs

@@ -20,6 +20,8 @@ use bevy_render::{
  texture::{BevyDefault, FallbackImage, FallbackImageMsaa, FallbackImageZero, Image},
  view::{Msaa, ViewUniform, ViewUniforms},
 };
+use bevy_render::renderer::RenderAdapter;
+use wgpu::DownlevelFlags;
 
 #[cfg(all(feature = "webgl", target_arch = "wasm32", not(feature = "webgpu")))]
 use bevy_render::render_resource::binding_types::texture_cube;
@@ -171,7 +173,9 @@ fn layout_entries(
  clustered_forward_buffer_binding_type: BufferBindingType,
  layout_key: MeshPipelineViewLayoutKey,
  render_device: &RenderDevice,
+ render_adapter: &RenderAdapter
 ) -> Vec<BindGroupLayoutEntry> {
+
  let mut entries = DynamicBindGroupLayoutEntries::new_with_indices(
  ShaderStages::FRAGMENT,
  (
@@ -185,20 +189,11 @@ fn layout_entries(
  // Point Shadow Texture Cube Array
  (
  2,
- #[cfg(all(
- not(feature = "ios_simulator"),
- any(
- not(feature = "webgl"),
- not(target_arch = "wasm32"),
- feature = "webgpu"
- )
- ))]
- texture_cube_array(TextureSampleType::Depth),
- #[cfg(any(
- feature = "ios_simulator",
- all(feature = "webgl", target_arch = "wasm32", not(feature = "webgpu"))
- ))]
- texture_cube(TextureSampleType::Depth),
+ if render_adapter.get_downlevel_capabilities().flags.contains(DownlevelFlags::CUBE_ARRAY_TEXTURES) {
+ texture_cube_array(TextureSampleType::Depth)
+ } else {
+ texture_cube(TextureSampleType::Depth)
+ },
  ),
  // Point Shadow Texture Array Sampler
  (3, sampler(SamplerBindingType::Comparison)),
@@ -322,11 +317,12 @@ fn layout_entries(
 /// [`MeshPipelineViewLayoutKey`] flags.
 pub fn generate_view_layouts(
  render_device: &RenderDevice,
+ render_adapter: &RenderAdapter,
  clustered_forward_buffer_binding_type: BufferBindingType,
 ) -> [MeshPipelineViewLayout; MeshPipelineViewLayoutKey::COUNT] {
  array::from_fn(|i| {
  let key = MeshPipelineViewLayoutKey::from_bits_truncate(i as u32);
- let entries = layout_entries(clustered_forward_buffer_binding_type, key, render_device);
+ let entries = layout_entries(clustered_forward_buffer_binding_type, key, render_device, render_adapter);
 
  #[cfg(debug_assertions)]
  let texture_count: usize = entries

crates/bevy_render/src/render_resource/pipeline_cache.rs

@@ -286,7 +286,7 @@ impl ShaderCache {
  shader_defs.push("SIXTEEN_BYTE_ALIGNMENT".into());
  }
 
- if cfg!(feature = "ios_simulator") {
+ if !self.composer.capabilities.contains(Capabilities::CUBE_ARRAY_TEXTURES) {
  shader_defs.push("NO_CUBE_ARRAY_TEXTURES_SUPPORT".into());
  }