[Merged by Bors] - use error scope to handle errors on shader module creation

crates/bevy_render/src/render_resource/pipeline_cache.rs

@@ -129,9 +129,24 @@ impl ShaderCache {
                         return Err(PipelineCacheError::AsModuleDescriptorError(err, processed));
                     }
                 };
-                entry.insert(Arc::new(
-                    render_device.create_shader_module(&module_descriptor),
-                ))
+
+                render_device
+                    .wgpu_device()
+                    .push_error_scope(wgpu::ErrorFilter::Validation);
+                let shader_module = render_device.create_shader_module(&module_descriptor);
+                let error = render_device.wgpu_device().pop_error_scope();
+
+                // `now_or_never` will return Some if the future is ready and None otherwise.
+                // On native platforms, wgpu will yield the error immediatly while on wasm it may take longer since the browser APIs are asynchronous.
+                // So to keep the complexity of the ShaderCache low, we will only catch this error early on native platforms,
+                // and on wasm the error will be handled by wgpu and crash the application.
+                if let Some(Some(wgpu::Error::Validation { description, .. })) =
+                    futures_helper::now_or_never(error)
+                {
+                    return Err(PipelineCacheError::CreateShaderModule(description));
+                }
+
+                entry.insert(Arc::new(shader_module))
             }
         };
 
@@ -479,6 +494,10 @@ impl PipelineCache {
                             log_shader_error(source, err);
                             continue;
                         }
+                        PipelineCacheError::CreateShaderModule(description) => {
+                            error!("failed to create shader module: {}", description);
+                            continue;
+                        }
                     }
                 }
             }
@@ -626,6 +645,8 @@ pub enum PipelineCacheError {
     AsModuleDescriptorError(AsModuleDescriptorError, ProcessedShader),
     #[error("Shader import not yet available.")]
     ShaderImportNotYetAvailable,
+    #[error("Could not create shader module: {0}")]
+    CreateShaderModule(String),
 }
 
 struct ErrorSources<'a> {
@@ -649,3 +670,37 @@ impl<'a> Iterator for ErrorSources<'a> {
         current
     }
 }
+
+mod futures_helper {
+    use std::{
+        future::Future,
+        task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
+    };
+
+    pub fn now_or_never<F: Future>(future: F) -> Option<F::Output> {
+        let noop_waker = noop_waker();
+        let mut cx = Context::from_waker(&noop_waker);
+
+        futures_lite::pin!(future);
+        match future.poll(&mut cx) {
+            Poll::Ready(x) => Some(x),
+            _ => None,
+        }
+    }
+
+    unsafe fn noop_clone(_data: *const ()) -> RawWaker {
+        noop_raw_waker()
+    }
+
+    unsafe fn noop(_data: *const ()) {}
+
+    const NOOP_WAKER_VTABLE: RawWakerVTable = RawWakerVTable::new(noop_clone, noop, noop, noop);
+
+    fn noop_raw_waker() -> RawWaker {
+        RawWaker::new(std::ptr::null(), &NOOP_WAKER_VTABLE)
+    }
+
+    fn noop_waker() -> Waker {
+        unsafe { Waker::from_raw(noop_raw_waker()) }
+    }
+}

crates/bevy_render/src/render_resource/shader.rs

@@ -161,9 +161,9 @@ impl ProcessedShader {
             source: match self {
                 ProcessedShader::Wgsl(source) => {
                     #[cfg(debug_assertions)]
-                    // This isn't neccessary, but catches errors early during hot reloading of invalid wgsl shaders.
-                    // Eventually, wgpu will have features that will make this unneccessary like compilation info
-                    // or error scopes, but until then parsing the shader twice during development the easiest solution.
+                    // Parse and validate the shader early, so that (e.g. while hot reloading) we can
+                    // display nicely formatted error messages instead of relying on just displaying the error string
+                    // returned by wgpu upon creating the shader module.
                     let _ = self.reflect()?;
 
                     ShaderSource::Wgsl(source.clone())