Try #7356:

.gitignore

@@ -7,6 +7,8 @@ Cargo.lock
 /.idea
 /.vscode
 /benches/target
+dxcompiler.dll
+dxil.dll
 
 # Generated by "examples/scene/scene.rs"
 assets/scenes/load_scene_example-new.scn.ron

crates/bevy_core_pipeline/src/bloom/mod.rs

@@ -580,6 +580,7 @@ fn prepare_bloom_textures(
                 dimension: TextureDimension::D2,
                 format: ViewTarget::TEXTURE_FORMAT_HDR,
                 usage: TextureUsages::RENDER_ATTACHMENT | TextureUsages::TEXTURE_BINDING,
+                view_formats: &[],
             };
 
             texture_descriptor.label = Some("bloom_texture_a");

crates/bevy_core_pipeline/src/core_3d/mod.rs

@@ -308,6 +308,7 @@ pub fn prepare_core_3d_depth_textures(
                     // PERF: vulkan docs recommend using 24 bit depth for better performance
                     format: TextureFormat::Depth32Float,
                     usage,
+                    view_formats: &[],
                 };
 
                 texture_cache.get(&render_device, descriptor)

crates/bevy_core_pipeline/src/fxaa/fxaa.wgsl

@@ -15,48 +15,48 @@ var samp: sampler;
 
 // Trims the algorithm from processing darks.
 #ifdef EDGE_THRESH_MIN_LOW
-    let EDGE_THRESHOLD_MIN: f32 = 0.0833;
+    const EDGE_THRESHOLD_MIN: f32 = 0.0833;
 #endif
 
 #ifdef EDGE_THRESH_MIN_MEDIUM
-    let EDGE_THRESHOLD_MIN: f32 = 0.0625;
+    const EDGE_THRESHOLD_MIN: f32 = 0.0625;
 #endif
 
 #ifdef EDGE_THRESH_MIN_HIGH
-    let EDGE_THRESHOLD_MIN: f32 = 0.0312;
+    const EDGE_THRESHOLD_MIN: f32 = 0.0312;
 #endif
 
 #ifdef EDGE_THRESH_MIN_ULTRA
-    let EDGE_THRESHOLD_MIN: f32 = 0.0156;
+    const EDGE_THRESHOLD_MIN: f32 = 0.0156;
 #endif
 
 #ifdef EDGE_THRESH_MIN_EXTREME
-    let EDGE_THRESHOLD_MIN: f32 = 0.0078;
+    const EDGE_THRESHOLD_MIN: f32 = 0.0078;
 #endif
 
 // The minimum amount of local contrast required to apply algorithm.
 #ifdef EDGE_THRESH_LOW
-    let EDGE_THRESHOLD_MAX: f32 = 0.250;
+    const EDGE_THRESHOLD_MAX: f32 = 0.250;
 #endif
 
 #ifdef EDGE_THRESH_MEDIUM
-    let EDGE_THRESHOLD_MAX: f32 = 0.166;
+    const EDGE_THRESHOLD_MAX: f32 = 0.166;
 #endif
 
 #ifdef EDGE_THRESH_HIGH
-    let EDGE_THRESHOLD_MAX: f32 = 0.125;
+    const EDGE_THRESHOLD_MAX: f32 = 0.125;
 #endif
 
 #ifdef EDGE_THRESH_ULTRA
-    let EDGE_THRESHOLD_MAX: f32 = 0.063;
+    const EDGE_THRESHOLD_MAX: f32 = 0.063;
 #endif
 
 #ifdef EDGE_THRESH_EXTREME
-    let EDGE_THRESHOLD_MAX: f32 = 0.031;
+    const EDGE_THRESHOLD_MAX: f32 = 0.031;
 #endif
 
-let ITERATIONS: i32 = 12; //default is 12
-let SUBPIXEL_QUALITY: f32 = 0.75;
+const ITERATIONS: i32 = 12; //default is 12
+const SUBPIXEL_QUALITY: f32 = 0.75;
 // #define QUALITY(q) ((q) < 5 ? 1.0 : ((q) > 5 ? ((q) < 10 ? 2.0 : ((q) < 11 ? 4.0 : 8.0)) : 1.5))
 fn QUALITY(q: i32) -> f32 {
     switch (q) {

crates/bevy_pbr/src/prepass/mod.rs

@@ -411,6 +411,7 @@ pub fn prepare_prepass_textures(
                         usage: TextureUsages::COPY_DST
                             | TextureUsages::RENDER_ATTACHMENT
                             | TextureUsages::TEXTURE_BINDING,
+                        view_formats: &[],
                     };
                     texture_cache.get(&render_device, descriptor)
                 })
@@ -432,6 +433,7 @@ pub fn prepare_prepass_textures(
                             format: NORMAL_PREPASS_FORMAT,
                             usage: TextureUsages::RENDER_ATTACHMENT
                                 | TextureUsages::TEXTURE_BINDING,
+                            view_formats: &[],
                         },
                     )
                 })

crates/bevy_pbr/src/render/clustered_forward.wgsl

@@ -27,7 +27,7 @@ fn fragment_cluster_index(frag_coord: vec2<f32>, view_z: f32, is_orthographic: b
 }
 
 // this must match CLUSTER_COUNT_SIZE in light.rs
-let CLUSTER_COUNT_SIZE = 9u;
+const CLUSTER_COUNT_SIZE = 9u;
 fn unpack_offset_and_counts(cluster_index: u32) -> vec3<u32> {
 #if AVAILABLE_STORAGE_BUFFER_BINDINGS >= 3
     return cluster_offsets_and_counts.data[cluster_index].xyz;

crates/bevy_pbr/src/render/light.rs

@@ -1043,6 +1043,7 @@ pub fn prepare_lights(
                 format: SHADOW_FORMAT,
                 label: Some("point_light_shadow_map_texture"),
                 usage: TextureUsages::RENDER_ATTACHMENT | TextureUsages::TEXTURE_BINDING,
+                view_formats: &[],
             },
         );
         let directional_light_depth_texture = texture_cache.get(
@@ -1063,6 +1064,7 @@ pub fn prepare_lights(
                 format: SHADOW_FORMAT,
                 label: Some("directional_light_shadow_map_texture"),
                 usage: TextureUsages::RENDER_ATTACHMENT | TextureUsages::TEXTURE_BINDING,
+                view_formats: &[],
             },
         );
         let mut view_lights = Vec::new();

crates/bevy_pbr/src/render/mesh_types.wgsl

@@ -13,6 +13,6 @@ struct SkinnedMesh {
 };
 #endif
 
-let MESH_FLAGS_SHADOW_RECEIVER_BIT: u32 = 1u;
+const MESH_FLAGS_SHADOW_RECEIVER_BIT: u32 = 1u;
 // 2^31 - if the flag is set, the sign is positive, else it is negative
-let MESH_FLAGS_SIGN_DETERMINANT_MODEL_3X3_BIT: u32 = 2147483648u;
+const MESH_FLAGS_SIGN_DETERMINANT_MODEL_3X3_BIT: u32 = 2147483648u;

crates/bevy_pbr/src/render/mesh_view_types.wgsl

@@ -25,8 +25,8 @@ struct PointLight {
     spot_light_tan_angle: f32,
 };
 
-let POINT_LIGHT_FLAGS_SHADOWS_ENABLED_BIT: u32   = 1u;
-let POINT_LIGHT_FLAGS_SPOT_LIGHT_Y_NEGATIVE: u32 = 2u;
+const POINT_LIGHT_FLAGS_SHADOWS_ENABLED_BIT: u32   = 1u;
+const POINT_LIGHT_FLAGS_SPOT_LIGHT_Y_NEGATIVE: u32 = 2u;
 
 struct DirectionalCascade {
     view_projection: mat4x4<f32>,
@@ -47,7 +47,7 @@ struct DirectionalLight {
     depth_texture_base_index: u32,
 };
 
-let DIRECTIONAL_LIGHT_FLAGS_SHADOWS_ENABLED_BIT: u32 = 1u;
+const DIRECTIONAL_LIGHT_FLAGS_SHADOWS_ENABLED_BIT: u32 = 1u;
 
 struct Lights {
     // NOTE: this array size must be kept in sync with the constants defined in bevy_pbr/src/render/light.rs

crates/bevy_pbr/src/render/pbr_types.wgsl

@@ -11,21 +11,21 @@ struct StandardMaterial {
     alpha_cutoff: f32,
 };
 
-let STANDARD_MATERIAL_FLAGS_BASE_COLOR_TEXTURE_BIT: u32         = 1u;
-let STANDARD_MATERIAL_FLAGS_EMISSIVE_TEXTURE_BIT: u32           = 2u;
-let STANDARD_MATERIAL_FLAGS_METALLIC_ROUGHNESS_TEXTURE_BIT: u32 = 4u;
-let STANDARD_MATERIAL_FLAGS_OCCLUSION_TEXTURE_BIT: u32          = 8u;
-let STANDARD_MATERIAL_FLAGS_DOUBLE_SIDED_BIT: u32               = 16u;
-let STANDARD_MATERIAL_FLAGS_UNLIT_BIT: u32                      = 32u;
-let STANDARD_MATERIAL_FLAGS_TWO_COMPONENT_NORMAL_MAP: u32       = 64u;
-let STANDARD_MATERIAL_FLAGS_FLIP_NORMAL_MAP_Y: u32              = 128u;
-let STANDARD_MATERIAL_FLAGS_ALPHA_MODE_RESERVED_BITS: u32       = 3758096384u; // (0b111u32 << 29)
-let STANDARD_MATERIAL_FLAGS_ALPHA_MODE_OPAQUE: u32              = 0u;          // (0u32 << 29)
-let STANDARD_MATERIAL_FLAGS_ALPHA_MODE_MASK: u32                = 536870912u;  // (1u32 << 29)
-let STANDARD_MATERIAL_FLAGS_ALPHA_MODE_BLEND: u32               = 1073741824u; // (2u32 << 29)
-let STANDARD_MATERIAL_FLAGS_ALPHA_MODE_PREMULTIPLIED: u32       = 1610612736u; // (3u32 << 29)
-let STANDARD_MATERIAL_FLAGS_ALPHA_MODE_ADD: u32                 = 2147483648u; // (4u32 << 29)
-let STANDARD_MATERIAL_FLAGS_ALPHA_MODE_MULTIPLY: u32            = 2684354560u; // (5u32 << 29)
+const STANDARD_MATERIAL_FLAGS_BASE_COLOR_TEXTURE_BIT: u32         = 1u;
+const STANDARD_MATERIAL_FLAGS_EMISSIVE_TEXTURE_BIT: u32           = 2u;
+const STANDARD_MATERIAL_FLAGS_METALLIC_ROUGHNESS_TEXTURE_BIT: u32 = 4u;
+const STANDARD_MATERIAL_FLAGS_OCCLUSION_TEXTURE_BIT: u32          = 8u;
+const STANDARD_MATERIAL_FLAGS_DOUBLE_SIDED_BIT: u32               = 16u;
+const STANDARD_MATERIAL_FLAGS_UNLIT_BIT: u32                      = 32u;
+const STANDARD_MATERIAL_FLAGS_TWO_COMPONENT_NORMAL_MAP: u32       = 64u;
+const STANDARD_MATERIAL_FLAGS_FLIP_NORMAL_MAP_Y: u32              = 128u;
+const STANDARD_MATERIAL_FLAGS_ALPHA_MODE_RESERVED_BITS: u32       = 3758096384u; // (0b111u32 << 29)
+const STANDARD_MATERIAL_FLAGS_ALPHA_MODE_OPAQUE: u32              = 0u;          // (0u32 << 29)
+const STANDARD_MATERIAL_FLAGS_ALPHA_MODE_MASK: u32                = 536870912u;  // (1u32 << 29)
+const STANDARD_MATERIAL_FLAGS_ALPHA_MODE_BLEND: u32               = 1073741824u; // (2u32 << 29)
+const STANDARD_MATERIAL_FLAGS_ALPHA_MODE_PREMULTIPLIED: u32       = 1610612736u; // (3u32 << 29)
+const STANDARD_MATERIAL_FLAGS_ALPHA_MODE_ADD: u32                 = 2147483648u; // (4u32 << 29)
+const STANDARD_MATERIAL_FLAGS_ALPHA_MODE_MULTIPLY: u32            = 2684354560u; // (5u32 << 29)
 // ↑ To calculate/verify the values above, use the following playground:
 // https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=7792f8dd6fc6a8d4d0b6b1776898a7f4
 

crates/bevy_pbr/src/render/utils.wgsl

@@ -1,6 +1,6 @@
 #define_import_path bevy_pbr::utils
 
-let PI: f32 = 3.141592653589793;
+const PI: f32 = 3.141592653589793;
 
 fn hsv2rgb(hue: f32, saturation: f32, value: f32) -> vec3<f32> {
     let rgb = clamp(

crates/bevy_render/Cargo.toml

@@ -50,10 +50,10 @@ bevy_tasks = { path = "../bevy_tasks", version = "0.9.0" }
 image = { version = "0.24", default-features = false }
 
 # misc
-wgpu = { version = "0.14.0", features = ["spirv"] }
-wgpu-hal = "0.14.1"
+wgpu = { version = "0.15.0", features = ["spirv"] }
+wgpu-hal = "0.15.1"
 codespan-reporting = "0.11.0"
-naga = { version = "0.10.0", features = ["glsl-in", "spv-in", "spv-out", "wgsl-in", "wgsl-out"] }
+naga = { version = "0.11.0", features = ["glsl-in", "spv-in", "spv-out", "wgsl-in", "wgsl-out"] }
 serde = { version = "1", features = ["derive"] }
 bitflags = "1.2.1"
 smallvec = { version = "1.6", features = ["union", "const_generics"] }

crates/bevy_render/src/lib.rs

@@ -148,11 +148,14 @@ impl Plugin for RenderPlugin {
         let primary_window = system_state.get(&app.world);
 
         if let Some(backends) = self.wgpu_settings.backends {
-            let instance = wgpu::Instance::new(backends);
+            let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
+                backends,
+                dx12_shader_compiler: self.wgpu_settings.dx12_shader_compiler.clone(),
+            });
             let surface = primary_window.get_single().ok().map(|wrapper| unsafe {
                 // SAFETY: Plugins should be set up on the main thread.
                 let handle = wrapper.get_handle();
-                instance.create_surface(&handle)
+                instance.create_surface(&handle).unwrap()
             });
 
             let request_adapter_options = wgpu::RequestAdapterOptions {

crates/bevy_render/src/renderer/mod.rs

@@ -251,6 +251,9 @@ pub async fn initialize_renderer(
             max_buffer_size: limits
                 .max_buffer_size
                 .min(constrained_limits.max_buffer_size),
+            max_bindings_per_bind_group: limits
+                .max_bindings_per_bind_group
+                .min(constrained_limits.max_bindings_per_bind_group),
         };
     }
 

crates/bevy_render/src/settings.rs

@@ -1,6 +1,8 @@
 use std::borrow::Cow;
 
-pub use wgpu::{Backends, Features as WgpuFeatures, Limits as WgpuLimits, PowerPreference};
+pub use wgpu::{
+    Backends, Dx12Compiler, Features as WgpuFeatures, Limits as WgpuLimits, PowerPreference,
+};
 
 /// Configures the priority used when automatically configuring the features/limits of `wgpu`.
 #[derive(Clone)]
@@ -37,6 +39,8 @@ pub struct WgpuSettings {
     pub limits: WgpuLimits,
     /// The constraints on limits allowed regardless of what the adapter/backend supports
     pub constrained_limits: Option<WgpuLimits>,
+    /// The compiler to use for DX12 shaders. If `None`, then FXC will be used.
+    pub dx12_shader_compiler: Dx12Compiler,
 }
 
 impl Default for WgpuSettings {
@@ -65,6 +69,12 @@ impl Default for WgpuSettings {
             limits
         };
 
+        let dx12_compiler =
+            wgpu::util::dx12_shader_compiler_from_env().unwrap_or(Dx12Compiler::Dxc {
+                dxil_path: None,
+                dxc_path: None,
+            });
+
         Self {
             device_label: Default::default(),
             backends,
@@ -74,6 +84,7 @@ impl Default for WgpuSettings {
             disabled_features: None,
             limits,
             constrained_limits: None,
+            dx12_shader_compiler: dx12_compiler,
         }
     }
 }

crates/bevy_render/src/texture/image.rs

@@ -184,6 +184,7 @@ impl Default for Image {
                 mip_level_count: 1,
                 sample_count: 1,
                 usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+                view_formats: &[],
             },
             sampler_descriptor: ImageSampler::Default,
             texture_view_descriptor: None,

crates/bevy_render/src/view/mod.rs

@@ -324,6 +324,8 @@ fn prepare_view_targets(
                             format: main_texture_format,
                             usage: TextureUsages::RENDER_ATTACHMENT
                                 | TextureUsages::TEXTURE_BINDING,
+                            // TODO: Consider changing this if main_texture_format is not sRGB
+                            view_formats: &[],
                         };
                         MainTargetTextures {
                             a: texture_cache
@@ -356,6 +358,7 @@ fn prepare_view_targets(
                                             dimension: TextureDimension::D2,
                                             format: main_texture_format,
                                             usage: TextureUsages::RENDER_ATTACHMENT,
+                                            view_formats: &[],
                                         },
                                     )
                                     .default_view

crates/bevy_render/src/view/window.rs

@@ -184,15 +184,25 @@ pub fn prepare_windows(
             .entry(window.entity)
             .or_insert_with(|| unsafe {
                 // NOTE: On some OSes this MUST be called from the main thread.
-                let surface = render_instance.create_surface(&window.handle.get_handle());
-                let format = *surface
-                    .get_supported_formats(&render_adapter)
-                    .get(0)
-                    .unwrap_or_else(|| {
-                        panic!(
-                            "No supported formats found for surface {surface:?} on adapter {render_adapter:?}"
-                        )
-                    });
+                // As of wgpu 0.15, only failable if the given window is a HTML canvas and obtaining a WebGPU or WebGL2 context fails.
+                let surface = render_instance
+                    .create_surface(&window.handle.get_handle())
+                    .unwrap();
+                let caps = surface.get_capabilities(&render_adapter);
+                let formats = caps.formats;
+                // Explicitly request an sRGB format, otherwise fallback to the first available format.
+                // For future HDR output support, we'll need to request a format that supports HDR,
+                // but as of wgpu 0.15 that is not yet supported.
+                let format = if formats.contains(&TextureFormat::Rgba8UnormSrgb) {
+                    TextureFormat::Rgba8UnormSrgb
+                } else if formats.contains(&TextureFormat::Bgra8UnormSrgb) {
+                    TextureFormat::Bgra8UnormSrgb
+                } else {
+                    // TODO: If this isn't an sRGB surface (eg. on webgpu), use an sRGB view_format on the SurfaceConfiguration.
+                    // TODO: webgpu doesn't support sRGB surfaces, and requires an sRGB view_format, but that was causing issues on Vulkan
+                    // so it's getting skipped for now.
+                    formats[0]
+                };
                 SurfaceData { surface, format }
             });
 
@@ -215,6 +225,8 @@ pub fn prepare_windows(
                 CompositeAlphaMode::PostMultiplied => wgpu::CompositeAlphaMode::PostMultiplied,
                 CompositeAlphaMode::Inherit => wgpu::CompositeAlphaMode::Inherit,
             },
+            // TODO: Figure out why Vulkan is spitting out tons of validation errors when attempting to use an sRGB view_format on the surface.
+            view_formats: vec![],
         };
 
         // A recurring issue is hitting `wgpu::SurfaceError::Timeout` on certain Linux

crates/bevy_sprite/src/mesh2d/color_material.wgsl

@@ -6,7 +6,7 @@ struct ColorMaterial {
     // 'flags' is a bit field indicating various options. u32 is 32 bits so we have up to 32 options.
     flags: u32,
 };
-let COLOR_MATERIAL_FLAGS_TEXTURE_BIT: u32 = 1u;
+const COLOR_MATERIAL_FLAGS_TEXTURE_BIT: u32 = 1u;
 
 @group(1) @binding(0)
 var<uniform> material: ColorMaterial;

examples/3d/render_to_texture.rs

@@ -55,6 +55,7 @@ fn setup(
             usage: TextureUsages::TEXTURE_BINDING
                 | TextureUsages::COPY_DST
                 | TextureUsages::RENDER_ATTACHMENT,
+            view_formats: &[],
         },
         ..default()
     };

examples/shader/post_processing.rs

@@ -61,6 +61,7 @@ fn setup(
             usage: TextureUsages::TEXTURE_BINDING
                 | TextureUsages::COPY_DST
                 | TextureUsages::RENDER_ATTACHMENT,
+            view_formats: &[],
         },
         ..default()
     };