Merge pull request glium#1814 from avl/nicer_compile_errors

Report which shader stage failed to compile

Author: est31

src/program/mod.rs

@@ -62,11 +62,57 @@ lazy_static! {
     static ref COMPILER_GLOBAL_LOCK: Mutex<()> = Mutex::new(());
 }
 
+/// Used in ProgramCreationError::CompilationError to explain which shader stage failed compilation 
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum ShaderType {
+    /// Vertex shader, maps to gl::VERTEX_SHADER
+    Vertex,
+    /// Geometry shader, maps to gl::GEOMETRY_SHADER
+    Geometry,
+    /// Fragment shader, maps to gl::FRAGMENT_SHADER
+    Fragment,
+    /// Tesselation control shader, maps to gl::TESS_CONTROL_SHADER
+    TesselationControl,
+    /// Tesselation evaluation shader, maps to gl::TESS_EVALUATION_SHADER
+    TesselationEvaluation,
+    /// Compute shader, maps to gl::COMPUTE_SHADER
+    Compute,
+}
+
+impl ShaderType {
+    /// Creates an instance of gl::types::GLenum corresponding to the given ShaderType
+    pub fn to_opengl_type(self) -> gl::types::GLenum {
+        match self {
+            ShaderType::Vertex => gl::VERTEX_SHADER,
+            ShaderType::Geometry => gl::GEOMETRY_SHADER,
+            ShaderType::Fragment => gl::FRAGMENT_SHADER,
+            ShaderType::TesselationControl => gl::TESS_CONTROL_SHADER,
+            ShaderType::TesselationEvaluation => gl::TESS_EVALUATION_SHADER,
+            ShaderType::Compute => gl::COMPUTE_SHADER,
+        }
+    }
+    /// Creates an instance of ShaderType corresponding to the given gl::types::GLenum.
+    /// This routine will panic if the given shadertype is not supported by glium.
+    pub fn from_opengl_type(gl_type: gl::types::GLenum) -> Self {
+        match gl_type {
+            gl::VERTEX_SHADER => ShaderType::Vertex,
+            gl::GEOMETRY_SHADER => ShaderType::Geometry,
+            gl::FRAGMENT_SHADER => ShaderType::Fragment,
+            gl::TESS_CONTROL_SHADER => ShaderType::TesselationControl,
+            gl::TESS_EVALUATION_SHADER => ShaderType::TesselationEvaluation,
+            gl::COMPUTE_SHADER  => ShaderType::Compute,
+            _ => {
+                panic!("Unsupported shader type")
+            }
+        }
+    }
+}
+
 /// Error that can be triggered when creating a `Program`.
 #[derive(Clone, Debug)]
 pub enum ProgramCreationError {
     /// Error while compiling one of the shaders.
-    CompilationError(String),
+    CompilationError(String, ShaderType),
 
     /// Error while linking the program.
     LinkingError(String),
@@ -95,7 +141,7 @@ impl fmt::Display for ProgramCreationError {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         use self::ProgramCreationError::*;
         match *self {
-            CompilationError(ref s) =>
+            CompilationError(ref s, _) =>
                 write!(fmt, "{}: {}", self.description(), s),
             LinkingError(ref s) =>
                 write!(fmt, "{}: {}", self.description(), s),
@@ -109,8 +155,16 @@ impl Error for ProgramCreationError {
     fn description(&self) -> &str {
         use self::ProgramCreationError::*;
         match *self {
-            CompilationError(_) =>
-                "Compilation error in one of the shaders",
+            CompilationError(_,typ) => {
+                match typ {
+                    ShaderType::Vertex => "Compilation error in vertex shader",
+                    ShaderType::Geometry => "Compilation error in geometry shader",
+                    ShaderType::Fragment => "Compilation error in fragment shader",
+                    ShaderType::TesselationControl => "Compilation error in tesselation control shader",
+                    ShaderType::TesselationEvaluation => "Compilation error in tesselation evaluation shader",
+                    ShaderType::Compute => "Compilation error in compute shader"
+                }
+            },
             LinkingError(_) =>
                 "Error while linking shaders together",
             ShaderTypeNotSupported =>

src/program/program.rs

@@ -18,7 +18,7 @@ use ProgramExt;
 use Handle;
 use RawUniformValue;
 
-use program::{COMPILER_GLOBAL_LOCK, ProgramCreationInput, ProgramCreationError, Binary};
+use program::{COMPILER_GLOBAL_LOCK, ProgramCreationInput, ProgramCreationError, ShaderType, Binary};
 use program::GetBinaryError;
 
 use program::reflection::{Uniform, UniformBlock, OutputPrimitives};
@@ -55,22 +55,22 @@ impl Program {
                 let mut has_tessellation_evaluation_shader = false;
 
                 let mut shaders = vec![
-                    (vertex_shader, gl::VERTEX_SHADER),
-                    (fragment_shader, gl::FRAGMENT_SHADER)
+                    (vertex_shader, ShaderType::Vertex),
+                    (fragment_shader, ShaderType::Fragment)
                 ];
 
                 if let Some(gs) = geometry_shader {
-                    shaders.push((gs, gl::GEOMETRY_SHADER));
+                    shaders.push((gs, ShaderType::Geometry));
                     has_geometry_shader = true;
                 }
 
                 if let Some(ts) = tessellation_control_shader {
-                    shaders.push((ts, gl::TESS_CONTROL_SHADER));
+                    shaders.push((ts, ShaderType::TesselationControl));
                     has_tessellation_control_shader = true;
                 }
 
                 if let Some(ts) = tessellation_evaluation_shader {
-                    shaders.push((ts, gl::TESS_EVALUATION_SHADER));
+                    shaders.push((ts, ShaderType::TesselationEvaluation));
                     has_tessellation_evaluation_shader = true;
                 }
 
@@ -91,7 +91,7 @@ impl Program {
                 let shaders_store = {
                     let mut shaders_store = Vec::new();
                     for (src, ty) in shaders.into_iter() {
-                        shaders_store.push(build_shader(facade, ty, src)?);
+                        shaders_store.push(build_shader(facade, ty.to_opengl_type(), src)?);
                     }
                     shaders_store
                 };

src/program/shader.rs

@@ -13,7 +13,7 @@ use std::rc::Rc;
 use GlObject;
 use Handle;
 
-use program::ProgramCreationError;
+use program::{ProgramCreationError, ShaderType};
 
 /// A single, compiled but unlinked, shader.
 pub struct Shader {
@@ -172,10 +172,10 @@ pub fn build_shader<F: ?Sized>(facade: &F, shader_type: gl::types::GLenum, sourc
             error_log.set_len(error_log_size as usize);
 
             match String::from_utf8(error_log) {
-                Ok(msg) => Err(ProgramCreationError::CompilationError(msg)),
+                Ok(msg) => Err(ProgramCreationError::CompilationError(msg, ShaderType::from_opengl_type(shader_type))),
                 Err(_) => Err(
                     ProgramCreationError::CompilationError("Could not convert the log \
-                                                            message to UTF-8".to_owned())
+                                                            message to UTF-8".to_owned(), ShaderType::from_opengl_type(shader_type))
                 ),
             }
         }

tests/framebuffer.rs

@@ -209,7 +209,7 @@ fn multioutput() {
         ",
         None)
     {
-        Err(glium::CompilationError(_)) => return,
+        Err(glium::CompilationError(..)) => return,
         Ok(p) => p,
         e => e.unwrap()
     };

tests/shaders.rs

@@ -70,7 +70,7 @@ fn program_compilation_error() {
         None);
 
     match program {
-        Err(glium::CompilationError(_)) => (),
+        Err(glium::CompilationError(..)) => (),
         _ => panic!()
     };