updated API further to just use optionals. Updated tests

src/compiler.rs

@@ -4,32 +4,56 @@ use shaderc::{ShaderKind, CompileOptions};
 use std::fs::File;
 use std::io::Read;
 use std::path::{Path, PathBuf};
+use std::borrow::Cow;
 
-pub fn compile<T>(path: T, shader_kind: ShaderKind) -> Result<Vec<u32>, CompileError>
-where
-    T: AsRef<Path>,
+pub fn compile<T>(path: T, include_path: Option<T>, shader_kind: ShaderKind, compiler_options: Option<CompileOptions>) -> Result<Vec<u32>, CompileError>
+    where
+        T: AsRef<Path>,
 {
-    let mut options = CompileOptions::new().ok_or(CompileError::CreateCompiler)?;
-    compile_with_options(path, shader_kind, options)
+    compile_with_options(&read_to_string(&path), include_path, shader_kind, compiler_options)
 }
 
-pub fn compile_with_options<T>(path: T, shader_kind: ShaderKind, mut options: CompileOptions) -> Result<Vec<u32>, CompileError>
+pub fn compile_from_string<T>(input: &str, include_path: Option<T>, shader_kind: ShaderKind, compiler_options: Option<CompileOptions>) -> Result<Vec<u32>, CompileError>
+    where
+        T: AsRef<Path>,
+{
+    compile_with_options(input, include_path, shader_kind, compiler_options)
+}
+
+pub fn compile_with_options<T>(src: &str, include_path: Option<T>, shader_kind: ShaderKind, options: Option<CompileOptions>)
+                               -> Result<Vec<u32>, CompileError>
     where
         T: AsRef<Path>,
 {
     // TODO Probably shouldn't create this every time.
     let mut compiler = shaderc::Compiler::new().ok_or(CompileError::CreateCompiler)?;
-    let mut f = File::open(&path).map_err(CompileError::Open)?;
-    let mut src = String::new();
-    f.read_to_string(&mut src).map_err(CompileError::Open)?;
-    options.set_include_callback(|path, include_type, folder_path, depth| {
-        get_include(path, include_type, folder_path, depth)
-    });
+
+    let mut options = {
+        match options {
+            None => CompileOptions::new().ok_or(CompileError::CreateCompiler).unwrap(),
+            Some(option) => option,
+        }
+    };
+
+    let path = {
+        if let Some(path) = &include_path {
+            options.set_include_callback(|path, include_type, folder_path, depth| {
+                get_include(path, include_type, folder_path, depth)
+            });
+            path.as_ref().to_str().ok_or(CompileError::InvalidPath)?
+        } else {
+            options.set_include_callback(|path, include_type, folder_path, depth| {
+                default_get_include(path, include_type, folder_path, depth)
+            });
+            ""
+        }
+    };
+
     let result = compiler
         .compile_into_spirv(
-            src.as_str(),
+            src,
             shader_kind,
-            path.as_ref().to_str().ok_or(CompileError::InvalidPath)?,
+            path,
             "main",
             Some(&options),
         )
@@ -38,6 +62,26 @@ pub fn compile_with_options<T>(path: T, shader_kind: ShaderKind, mut options: Co
     Ok(data.to_owned())
 }
 
+pub fn read_to_string<'a, T>(path: &T) -> Cow<'a, str>
+    where
+        T: AsRef<Path>,
+{
+    let mut f = File::open(path).map_err(CompileError::Open).expect("");
+    let mut src = String::new();
+    f.read_to_string(&mut src).map_err(CompileError::Open).expect("");
+    Cow::Owned(src)
+}
+
+fn default_get_include(
+    path: &str,
+    include_type: IncludeType,
+    folder_path: &str,
+    _depth: usize,
+) -> Result<ResolvedInclude, String> {
+    // TODO: Does this print out anything meaningful?
+    Err(format!("No include path given for {}", path).to_string())
+}
+
 fn get_include(
     path: &str,
     include_type: IncludeType,
@@ -59,12 +103,12 @@ fn get_include(
                 .to_str()
                 .ok_or("Path has invalid characters".to_string())?
                 .to_owned();
-            let p = p.canonicalize().map_err(|_|"Failed to parse include path".to_string())?;
+            let p = p.canonicalize().map_err(|_| "Failed to parse include path".to_string())?;
             let mut content = String::new();
             File::open(p)
-                .map_err(|_|"Couldn't open include directory".to_string())?
+                .map_err(|_| "Couldn't open include directory".to_string())?
                 .read_to_string(&mut content)
-                .map_err(|_|"Failed to read included shader".to_string())?;
+                .map_err(|_| "Failed to read included shader".to_string())?;
             Ok(ResolvedInclude {
                 resolved_name,
                 content,

src/lib.rs

@@ -15,6 +15,7 @@ use spirv_reflect as sr;
 use vulkano as vk;
 use std::path::Path;
 use shaderc::ShaderKind;
+use std::borrow::Borrow;
 
 #[derive(Clone)]
 pub struct CompiledShaders {
@@ -28,74 +29,38 @@ pub struct CompiledShader {
     pub spriv: Vec<u32>,
 }
 
-pub fn load<T>(input: T, shader_kind: ShaderKind) -> Result<CompiledShader, Error>
+pub fn load<T>(input: T, include_path: Option<T>, shader_kind: ShaderKind, compiler_options: Option<CompileOptions>)
+               -> Result<CompiledShader, Error>
     where
         T: AsRef<Path>,
 {
-    Ok(CompiledShader { spriv: compiler::compile(input, shader_kind).map_err(Error::Compile)? })
-}
-
-
-/// Loads and compiles the vertex shader
-pub fn load_vertex<T>(vertex: T) -> Result<CompiledShader, Error>
-    where
-        T: AsRef<Path>,
-{
-    let vertex = compiler::compile(vertex, ShaderKind::Vertex).map_err(Error::Compile)?;
-    Ok(CompiledShader { spriv: vertex })
-}
-
-/// Loads and compiles the fragment shader
-pub fn load_fragment<T>(fragment: T) -> Result<CompiledShader, Error>
-    where
-        T: AsRef<Path>,
-{
-    let fragment = compiler::compile(fragment, ShaderKind::Fragment).map_err(Error::Compile)?;
-    Ok(CompiledShader { spriv: fragment })
-}
-
-/// Loads and compiles the geometry shader
-pub fn load_geometry<T>(geometry: T) -> Result<CompiledShader, Error>
-    where
-        T: AsRef<Path>,
-{
-    let geometry = compiler::compile(geometry, ShaderKind::Geometry).map_err(Error::Compile)?;
-    Ok(CompiledShader { spriv: geometry })
-}
-
-/// Loads and compiles the tessellation shader
-pub fn load_tessellation_control<T>(tessellation_control: T) -> Result<CompiledShader, Error>
-    where
-        T: AsRef<Path>,
-{
-    let tess = compiler::compile(tessellation_control, ShaderKind::TessControl).map_err(Error::Compile)?;
-    Ok(CompiledShader { spriv: tess })
-}
-
-/// Loads and compiles the tessellation shader
-pub fn load_tessellation_evaluation<T>(tessellation_evaluation: T) -> Result<CompiledShader, Error>
-    where
-        T: AsRef<Path>,
-{
-    let tess = compiler::compile(tessellation_evaluation, ShaderKind::TessEvaluation).map_err(Error::Compile)?;
-    Ok(CompiledShader { spriv: tess })
-}
-
-pub fn load_compute<T>(compute: T) -> Result<CompiledShader, Error>
-    where
-        T: AsRef<Path>,
-{
-    let options = CompileOptions::new().ok_or(CompileError::CreateCompiler).unwrap();
-    load_compute_with_options(compute, options)
-}
-
-pub fn load_compute_with_options<T>(compute: T, options: CompileOptions) -> Result<CompiledShader, Error>
-    where
-        T: AsRef<Path>,
-{
-    let compute = compiler::compile_with_options(compute, ShaderKind::Compute, options).map_err(Error::Compile)?;
     Ok(CompiledShader {
-        spriv: compute,
+        spriv: compiler::compile(input, include_path, shader_kind, compiler_options).map_err(Error::Compile)?
+    })
+}
+
+pub fn load_from_string<T>(source: &str, include_path: Option<T>, shader_kind: ShaderKind, compiler_options: Option<CompileOptions>) -> Result<CompiledShader, Error>
+    where
+        T: AsRef<Path>,
+{
+    Ok(CompiledShader {
+        spriv: compiler::compile_from_string(source, include_path, shader_kind, compiler_options).map_err(Error::Compile)?
+    })
+}
+
+pub fn load_compute<T>(compute: T, compiler_options: Option<CompileOptions>) -> Result<CompiledShader, Error>
+    where
+        T: AsRef<Path>,
+{
+    load_compute_from_string(&compiler::read_to_string(&compute), Some(compute), compiler_options)
+}
+
+pub fn load_compute_from_string<T>(source : &str, include_path : Option<T>, compiler_options: Option<CompileOptions>) -> Result<CompiledShader, Error>
+    where
+        T: AsRef<Path>,
+{
+    Ok(CompiledShader {
+        spriv: compiler::compile_from_string(source, include_path, ShaderKind::Compute, compiler_options).map_err(Error::Compile)?
     })
 }