fix shader compilation error reporting for non-wgsl shaders (#3441)

in #3289 I accidentally only logged errors for wgsl shaders, this PR expands the error reporting the the other supported shader types.

crates/bevy_render/src/render_resource/pipeline_cache.rs

@@ -407,22 +407,60 @@ impl RenderPipelineCache {
     }
 }
 
-fn log_shader_error(source: &ProcessedShader, err: &AsModuleDescriptorError) {
+fn log_shader_error(source: &ProcessedShader, error: &AsModuleDescriptorError) {
     use codespan_reporting::{
         diagnostic::{Diagnostic, Label},
         files::SimpleFile,
         term,
     };
 
-    if let ProcessedShader::Wgsl(source) = source {
+    match error {
-        if let AsModuleDescriptorError::ShaderReflectError(err) = err {
+        AsModuleDescriptorError::ShaderReflectError(error) => match error {
-            match err {
+            ShaderReflectError::WgslParse(error) => {
-                ShaderReflectError::WgslParse(parse) => {
+                let source = source
-                    let msg = parse.emit_to_string(source);
+                    .get_wgsl_source()
+                    .expect("non-wgsl source for wgsl error");
+                let msg = error.emit_to_string(source);
                 error!("failed to process shader:\n{}", msg);
             }
+            ShaderReflectError::GlslParse(errors) => {
+                let source = source
+                    .get_glsl_source()
+                    .expect("non-glsl source for glsl error");
+                let files = SimpleFile::new("glsl", source);
+                let config = codespan_reporting::term::Config::default();
+                let mut writer = term::termcolor::Ansi::new(Vec::new());
+
+                for err in errors {
+                    let mut diagnostic = Diagnostic::error().with_message(err.kind.to_string());
+
+                    if let Some(range) = err.meta.to_range() {
+                        diagnostic = diagnostic.with_labels(vec![Label::primary((), range)]);
+                    }
+
+                    term::emit(&mut writer, &config, &files, &diagnostic)
+                        .expect("cannot write error");
+                }
+
+                let msg = writer.into_inner();
+                let msg = String::from_utf8_lossy(&msg);
+
+                error!("failed to process shader: \n{}", msg);
+            }
+            ShaderReflectError::SpirVParse(error) => {
+                error!("failed to process shader:\n{}", error);
+            }
             ShaderReflectError::Validation(error) => {
-                    let files = SimpleFile::new("wgsl", &source);
+                let (filename, source) = match source {
+                    ProcessedShader::Wgsl(source) => ("wgsl", source.as_ref()),
+                    ProcessedShader::Glsl(source, _) => ("glsl", source.as_ref()),
+                    ProcessedShader::SpirV(_) => {
+                        error!("failed to process shader:\n{}", error);
+                        return;
+                    }
+                };
+
+                let files = SimpleFile::new(filename, source);
                 let config = term::Config::default();
                 let mut writer = term::termcolor::Ansi::new(Vec::new());
 
@@ -436,17 +474,19 @@ fn log_shader_error(source: &ProcessedShader, err: &AsModuleDescriptorError) {
                         .collect(),
                 );
 
-                    term::emit(&mut writer, &config, &files, &diagnostic)
+                term::emit(&mut writer, &config, &files, &diagnostic).expect("cannot write error");
-                        .expect("cannot write error");
 
                 let msg = writer.into_inner();
                 let msg = String::from_utf8_lossy(&msg);
 
                 error!("failed to process shader: \n{}", msg);
             }
-                ShaderReflectError::GlslParse(_) => {}
+        },
-                ShaderReflectError::SpirVParse(_) => {}
+        AsModuleDescriptorError::WgslConversion(error) => {
+            error!("failed to convert shader to wgsl: \n{}", error);
         }
+        AsModuleDescriptorError::SpirVConversion(error) => {
+            error!("failed to convert shader to spirv: \n{}", error);
         }
     }
 }