From 903f1a349d13b716b2ba7920c796f5024ebdfb09 Mon Sep 17 00:00:00 2001 From: mitchellhansen Date: Sat, 28 Sep 2019 21:51:46 -0700 Subject: [PATCH] hacked out some stuff while I'm testing --- examples/compile.rs | 17 +- src/layouts.rs | 165 ++--------- src/lib.rs | 54 ++-- src/reflection.rs | 58 ++-- src/watch.rs | 32 +- tests/tests.rs | 690 ++++++++++++++++++++++---------------------- 6 files changed, 444 insertions(+), 572 deletions(-) diff --git a/examples/compile.rs b/examples/compile.rs index fe6b915..6fb33df 100644 --- a/examples/compile.rs +++ b/examples/compile.rs @@ -2,12 +2,13 @@ use shade_runner as sr; use std::path::PathBuf; fn main() { - let project_root = std::env::current_dir().expect("failed to get root directory"); - let mut vert_path = project_root.clone(); - vert_path.push(PathBuf::from("examples/shaders/vert.glsl")); - let mut frag_path = project_root.clone(); - frag_path.push(PathBuf::from("examples/shaders/frag.glsl")); - let shader = sr::load(vert_path, frag_path).expect("Failed to compile"); - let vulkano_entry = sr::parse(&shader).expect("failed to parse"); - dbg!(vulkano_entry); + +// let project_root = std::env::current_dir().expect("failed to get root directory"); +// let mut vert_path = project_root.clone(); +// vert_path.push(PathBuf::from("examples/shaders/vert.glsl")); +// let mut frag_path = project_root.clone(); +// frag_path.push(PathBuf::from("examples/shaders/frag.glsl")); +// let shader = sr::load(vert_path, frag_path).expect("Failed to compile"); +// let vulkano_entry = sr::parse(&shader).expect("failed to parse"); +// dbg!(vulkano_entry); } diff --git a/src/layouts.rs b/src/layouts.rs index 55f3ce1..10a920b 100644 --- a/src/layouts.rs +++ b/src/layouts.rs @@ -7,51 +7,46 @@ use crate::reflection::LayoutData; #[derive(Debug, Clone, Default)] pub struct Entry { - pub frag_input: FragInput, - pub frag_output: FragOutput, - pub frag_layout: FragLayout, - pub vert_input: VertInput, - pub vert_output: VertOutput, - pub vert_layout: VertLayout, - pub compute_layout: ComputeLayout, + pub input: Option, + pub output: Option, + pub layout: Layout, } #[derive(Debug, Clone, Default)] -pub struct FragInput { +pub struct Input { pub inputs: Vec, } -unsafe impl ShaderInterfaceDef for FragInput { - type Iter = FragInputIter; +unsafe impl ShaderInterfaceDef for Input { + type Iter = InputIter; - fn elements(&self) -> FragInputIter { + fn elements(&self) -> InputIter { self.inputs.clone().into_iter() } } -pub type FragInputIter = std::vec::IntoIter; +pub type InputIter = std::vec::IntoIter; #[derive(Debug, Clone, Default)] -pub struct FragOutput { +pub struct Output { pub outputs: Vec, } -unsafe impl ShaderInterfaceDef for FragOutput { - type Iter = FragOutputIter; +unsafe impl ShaderInterfaceDef for Output { + type Iter = OutputIter; - fn elements(&self) -> FragOutputIter { + fn elements(&self) -> OutputIter { self.outputs.clone().into_iter() } } -pub type FragOutputIter = std::vec::IntoIter; +pub type OutputIter = std::vec::IntoIter; -// Layout same as with vertex shader. #[derive(Debug, Clone, Default)] -pub struct FragLayout { +pub struct Layout { pub layout_data: LayoutData, } -impl FragLayout { +impl Layout { const STAGES: ShaderStages = ShaderStages { vertex: false, tessellation_control: false, @@ -61,130 +56,8 @@ impl FragLayout { compute: false, }; } -unsafe impl PipelineLayoutDesc for FragLayout { - fn num_sets(&self) -> usize { - self.layout_data.num_sets - } - fn num_bindings_in_set(&self, set: usize) -> Option { - self.layout_data.num_bindings.get(&set).map(|&b|b) - } - fn descriptor(&self, set: usize, binding: usize) -> Option { - self.layout_data.descriptions.get(&set) - .and_then(|s|s.get(&binding)) - .map(|desc| { - let mut desc = desc.clone(); - desc.stages = FragLayout::STAGES; - desc - }) - - } - fn num_push_constants_ranges(&self) -> usize { - self.layout_data.num_constants - } - fn push_constants_range(&self, num: usize) -> Option { - self.layout_data.pc_ranges.get(num) - .map(|desc| { - let mut desc = *desc; - desc.stages = FragLayout::STAGES; - desc - }) - - } -} - -#[derive(Debug, Clone, Default)] -pub struct VertInput { - pub inputs: Vec, -} - -unsafe impl ShaderInterfaceDef for VertInput { - type Iter = VertInputIter; - - fn elements(&self) -> VertInputIter { - self.inputs.clone().into_iter() - } -} - -pub type VertInputIter = std::vec::IntoIter; - -#[derive(Debug, Clone, Default)] -pub struct VertOutput { - pub outputs: Vec, -} - -unsafe impl ShaderInterfaceDef for VertOutput { - type Iter = VertOutputIter; - - fn elements(&self) -> VertOutputIter { - self.outputs.clone().into_iter() - } -} - -pub type VertOutputIter = std::vec::IntoIter; - -// This structure describes layout of this stage. -#[derive(Debug, Clone, Default)] -pub struct VertLayout { - pub layout_data: LayoutData, -} -impl VertLayout { - const STAGES: ShaderStages = ShaderStages { - vertex: true, - tessellation_control: false, - tessellation_evaluation: false, - geometry: false, - fragment: false, - compute: false, - }; -} -unsafe impl PipelineLayoutDesc for VertLayout { - fn num_sets(&self) -> usize { - self.layout_data.num_sets - } - fn num_bindings_in_set(&self, set: usize) -> Option { - self.layout_data.num_bindings.get(&set).map(|&b|b) - } - fn descriptor(&self, set: usize, binding: usize) -> Option { - self.layout_data.descriptions.get(&set) - .and_then(|s|s.get(&binding)) - .map(|desc| { - let mut desc = desc.clone(); - desc.stages = VertLayout::STAGES; - desc - }) - } - fn num_push_constants_ranges(&self) -> usize { - self.layout_data.num_constants - } - fn push_constants_range(&self, num: usize) -> Option { - self.layout_data.pc_ranges.get(num) - .map(|desc| { - let mut desc = *desc; - desc.stages = VertLayout::STAGES; - desc - }) - - } -} - -#[derive(Debug, Clone, Default)] -pub struct ComputeLayout { - pub layout_data: LayoutData, -} - -impl ComputeLayout { - const STAGES: ShaderStages = ShaderStages { - vertex: false, - tessellation_control: false, - tessellation_evaluation: false, - geometry: false, - fragment: false, - compute: true, - }; -} - -unsafe impl PipelineLayoutDesc for ComputeLayout { +unsafe impl PipelineLayoutDesc for Layout { fn num_sets(&self) -> usize { self.layout_data.num_sets } @@ -196,7 +69,7 @@ unsafe impl PipelineLayoutDesc for ComputeLayout { .and_then(|s|s.get(&binding)) .map(|desc| { let mut desc = desc.clone(); - desc.stages = Self::STAGES; + desc.stages = Layout::STAGES; desc }) @@ -208,9 +81,9 @@ unsafe impl PipelineLayoutDesc for ComputeLayout { self.layout_data.pc_ranges.get(num) .map(|desc| { let mut desc = *desc; - desc.stages = Self::STAGES; + desc.stages = Layout::STAGES; desc }) } -} +} \ No newline at end of file diff --git a/src/lib.rs b/src/lib.rs index 7ab5c10..35d4d62 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -28,13 +28,21 @@ pub struct CompiledShader { pub spriv: Vec, } +pub fn load(input: T, shader_kind: ShaderKind) -> Result + where + T: AsRef, +{ + Ok(CompiledShader { spriv: compiler::compile(input, shader_kind).map_err(Error::Compile)? }) +} + + /// Loads and compiles the vertex shader pub fn load_vertex(vertex: T) -> Result where T: AsRef, { let vertex = compiler::compile(vertex, ShaderKind::Vertex).map_err(Error::Compile)?; - Ok(CompiledShader{ spriv: vertex }) + Ok(CompiledShader { spriv: vertex }) } /// Loads and compiles the fragment shader @@ -42,8 +50,8 @@ pub fn load_fragment(fragment: T) -> Result where T: AsRef, { - let fragment = compiler::compile(vertex, ShaderKind::Fragment).map_err(Error::Compile)?; - Ok(CompiledShader{ spriv: fragment }) + let fragment = compiler::compile(fragment, ShaderKind::Fragment).map_err(Error::Compile)?; + Ok(CompiledShader { spriv: fragment }) } /// Loads and compiles the geometry shader @@ -51,55 +59,51 @@ pub fn load_geometry(geometry: T) -> Result where T: AsRef, { - let geometry = compiler::compile(vertex, ShaderKind::Geometry).map_err(Error::Compile)?; - Ok(CompiledShader{ spriv: geometry }) + 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(geometry: T) -> Result +pub fn load_tessellation_control(tessellation_control: T) -> Result where T: AsRef, { - let tess = compiler::compile(vertex, ShaderKind::TessControl).map_err(Error::Compile)?; - Ok(CompiledShader{ spriv: tess }) + 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(geometry: T) -> Result +pub fn load_tessellation_evaluation(tessellation_evaluation: T) -> Result where T: AsRef, { - let tess = compiler::compile(vertex, ShaderKind::TessEvaluation).map_err(Error::Compile)?; - Ok(CompiledShader{ spriv: tess }) + let tess = compiler::compile(tessellation_evaluation, ShaderKind::TessEvaluation).map_err(Error::Compile)?; + Ok(CompiledShader { spriv: tess }) } -// TODO this should be incorpoarted into load but that would be -// a breaking change. Do this in next major version -pub fn load_compute(compute: T) -> Result -where - T: AsRef, +pub fn load_compute(compute: T) -> Result + where + T: AsRef, { let options = CompileOptions::new().ok_or(CompileError::CreateCompiler).unwrap(); load_compute_with_options(compute, options) } -pub fn load_compute_with_options(compute: T, options: CompileOptions) -> Result +pub fn load_compute_with_options(compute: T, options: CompileOptions) -> Result where T: AsRef, { let compute = compiler::compile_with_options(compute, ShaderKind::Compute, options).map_err(Error::Compile)?; - Ok(CompiledShaders{ - vertex: Vec::new(), - fragment: Vec::new(), - compute, + Ok(CompiledShader { + spriv: compute, }) } -pub fn parse_compute(code: &CompiledShaders) -> Result { - reflection::create_compute_entry(code) +pub fn parse_compute(code: &CompiledShader) -> Result { + reflection::create_compute_entry(&code.spriv) } /// Parses the shaders and gives an entry point -pub fn parse(code: &CompiledShaders) -> Result { - reflection::create_entry(code) +pub fn parse(code: &CompiledShader) -> Result { + reflection::create_entry(&code.spriv) } diff --git a/src/reflection.rs b/src/reflection.rs index 7222bac..9d74f7e 100644 --- a/src/reflection.rs +++ b/src/reflection.rs @@ -1,6 +1,6 @@ use crate::error::Error; use crate::layouts::*; -use crate::sr; +use crate::{sr, CompiledShader}; use crate::srvk::{DescriptorDescInfo, SpirvTy}; use crate::vk::descriptor::descriptor::*; use crate::vk::descriptor::pipeline_layout::PipelineLayoutDescPcRange; @@ -24,46 +24,40 @@ pub struct LayoutData { pub pc_ranges: Vec, } -pub fn create_entry(shaders: &CompiledShaders) -> Result { - let vertex_interfaces = create_interfaces(&shaders.vertex)?; - let vertex_layout = create_layouts(&shaders.vertex)?; - let fragment_interfaces = create_interfaces(&shaders.fragment)?; - let fragment_layout = create_layouts(&shaders.fragment)?; +pub fn create_entry(spirv: &Vec) -> Result { - let frag_input = FragInput { - inputs: fragment_interfaces.inputs, - }; - let frag_output = FragOutput { - outputs: fragment_interfaces.outputs, - }; - let frag_layout = FragLayout { - layout_data: fragment_layout, - }; - let vert_input = VertInput { + let vertex_interfaces = create_interfaces(spirv)?; + let vertex_layout = create_layouts(spirv)?; + + let input = Some(Input { inputs: vertex_interfaces.inputs, - }; - let vert_output = VertOutput { + }); + let output = Some(Output { outputs: vertex_interfaces.outputs, - }; - let vert_layout = VertLayout { + }); + let layout = Layout { layout_data: vertex_layout, }; + Ok(Entry { - frag_input, - frag_output, - vert_input, - vert_output, - frag_layout, - vert_layout, - compute_layout: Default::default(), + input, + output, + layout, }) } -pub fn create_compute_entry(shaders: &CompiledShaders) -> Result { - create_layouts(&shaders.compute).map(|layout_data| { - let mut entry = Entry::default(); - entry.compute_layout = ComputeLayout{ layout_data }; - entry +pub fn create_compute_entry(spirv: &Vec) -> Result { + + let compute_layout = create_layouts(spirv)?; + + let layout = Layout { + layout_data: compute_layout, + }; + + Ok(Entry { + input: None, + output: None, + layout, }) } diff --git a/src/watch.rs b/src/watch.rs index 7cc9b8d..ec78200 100644 --- a/src/watch.rs +++ b/src/watch.rs @@ -90,14 +90,14 @@ impl GraphicsLoader { } fn reload(&self) { - match crate::load(&self.vertex, &self.fragment) { - Ok(shaders) => { - let entry = crate::parse(&shaders); - let msg = entry.map(|entry| Message { shaders, entry }); - self.tx.send(msg).ok() - } - Err(e) => self.tx.send(Err(e)).ok(), - }; +// match crate::load(&self.vertex, &self.fragment) { +// Ok(shaders) => { +// let entry = crate::parse(&shaders); +// let msg = entry.map(|entry| Message { shaders, entry }); +// self.tx.send(msg).ok() +// } +// Err(e) => self.tx.send(Err(e)).ok(), +// }; } } @@ -113,14 +113,14 @@ impl ComputeLoader { } fn reload(&self) { - match crate::load_compute(&self.compute) { - Ok(shaders) => { - let entry = crate::parse_compute(&shaders); - let msg = entry.map(|entry| Message { shaders, entry }); - self.tx.send(msg).ok() - } - Err(e) => self.tx.send(Err(e)).ok(), - }; +// match crate::load_compute(&self.compute) { +// Ok(shaders) => { +// let entry = crate::parse_compute(&shaders); +// let msg = entry.map(|entry| Message { shaders, entry }); +// self.tx.send(msg).ok() +// } +// Err(e) => self.tx.send(Err(e)).ok(), +// }; } } diff --git a/tests/tests.rs b/tests/tests.rs index 9c207ba..1c1d523 100644 --- a/tests/tests.rs +++ b/tests/tests.rs @@ -1,345 +1,345 @@ -use color_backtrace; -use difference::{Changeset, Difference}; -use shade_runner::*; -use std::borrow::Cow; -use std::collections::HashMap; -use std::path::{Path, PathBuf}; -use vulkano::descriptor::descriptor::*; -use vulkano::descriptor::pipeline_layout::{PipelineLayoutDesc, PipelineLayoutDescPcRange}; -use vulkano::format::*; -use vulkano::pipeline::shader::ShaderInterfaceDefEntry; - -fn setup() { - color_backtrace::install(); -} - -fn difference(e: &str, t: &str) -> String { - let diffs = Changeset::new(&e, &t, ""); - diffs - .diffs - .iter() - .filter(|d| match d { - Difference::Add(_) => true, - Difference::Rem(_) => true, - _ => false, - }) - .map(|d| match d { - Difference::Add(a) => format!("add: {}", a), - Difference::Rem(a) => format!("remove: {}", a), - _ => "".to_string(), - }) - .collect::>() - .join("\n") -} - -fn descriptor_layout(desc: &T) -> String -where - T: PipelineLayoutDesc, -{ - let num_sets = desc.num_sets(); - let mut r = format!("{:?}", num_sets); - for n in 0..num_sets { - let num_bindings = desc.num_bindings_in_set(n); - r = format!("{:?}{:?}", r, num_bindings); - for b in num_bindings { - r = format!("{:?}{:?}", r, desc.descriptor(n, b)); - } - } - let num_push_constants = desc.num_push_constants_ranges(); - r = format!("{:?}{:?}", r, num_push_constants); - for i in 0..num_push_constants { - r = format!("{:?}{:?}", r, desc.push_constants_range(i)); - } - r -} - -fn parse(vertex: T, fragment: T) -> shade_runner::Entry -where - T: AsRef, -{ - let project_root = std::env::current_dir().expect("failed to get root directory"); - let mut path = project_root.clone(); - path.push(PathBuf::from("tests/shaders/")); - let mut vertex_path = path.clone(); - vertex_path.push(vertex); - let mut fragment_path = path.clone(); - fragment_path.push(fragment); - let shader = shade_runner::load(vertex_path, fragment_path).expect("Failed to compile"); - shade_runner::parse(&shader).unwrap() -} - -fn do_test(a: &T, b: &T) -where - T: std::fmt::Debug, -{ - let a = format!("{:?}", a); - let b = format!("{:?}", b); - assert_eq!(&a, &b, "\n\nDifference: {}", difference(&a, &b)); -} - -#[test] -fn test_shade1() { - setup(); - let target = Entry { - compute_layout: Default::default(), - frag_input: FragInput { inputs: Vec::new() }, - frag_output: FragOutput { - outputs: vec![ShaderInterfaceDefEntry { - location: 0..1, - format: Format::R32G32B32A32Sfloat, - name: Some(Cow::Borrowed("f_color")), - }], - }, - frag_layout: FragLayout { - layout_data: LayoutData { - num_sets: 0, - num_bindings: HashMap::new(), - descriptions: HashMap::new(), - num_constants: 0, - pc_ranges: Vec::new(), - }, - }, - vert_input: VertInput { - inputs: vec![ShaderInterfaceDefEntry { - location: 0..1, - format: Format::R32G32Sfloat, - name: Some(Cow::Borrowed("position")), - }], - }, - vert_output: VertOutput { - outputs: Vec::new(), - }, - vert_layout: VertLayout { - layout_data: LayoutData { - num_sets: 0, - num_bindings: HashMap::new(), - descriptions: HashMap::new(), - num_constants: 0, - pc_ranges: Vec::new(), - }, - }, - }; - let entry = parse("vert1.glsl", "frag1.glsl"); - do_test(&entry, &target); -} - -#[test] -fn test_shade2() { - setup(); - let target = Entry { - compute_layout: Default::default(), - frag_input: FragInput { - inputs: vec![ - ShaderInterfaceDefEntry { - location: 0..1, - format: Format::R32G32B32A32Sfloat, - name: Some(Cow::Borrowed("cool")), - }, - ShaderInterfaceDefEntry { - location: 1..2, - format: Format::R32G32Sfloat, - name: Some(Cow::Borrowed("yep")), - }, - ShaderInterfaceDefEntry { - location: 2..3, - format: Format::R32Sfloat, - name: Some(Cow::Borrowed("monkey")), - }, - ], - }, - frag_output: FragOutput { - outputs: vec![ShaderInterfaceDefEntry { - location: 0..1, - format: Format::R32G32B32A32Sfloat, - name: Some(Cow::Borrowed("f_color")), - }], - }, - frag_layout: FragLayout { - layout_data: LayoutData { - num_sets: 0, - num_bindings: HashMap::new(), - descriptions: HashMap::new(), - num_constants: 0, - pc_ranges: Vec::new(), - }, - }, - vert_input: VertInput { - inputs: vec![ShaderInterfaceDefEntry { - location: 0..1, - format: Format::R32G32Sfloat, - name: Some(Cow::Borrowed("position")), - }], - }, - vert_output: VertOutput { - outputs: vec![ - ShaderInterfaceDefEntry { - location: 0..1, - format: Format::R32G32B32A32Sfloat, - name: Some(Cow::Borrowed("cool")), - }, - ShaderInterfaceDefEntry { - location: 1..2, - format: Format::R32G32Sfloat, - name: Some(Cow::Borrowed("yep")), - }, - ShaderInterfaceDefEntry { - location: 2..3, - format: Format::R32Sfloat, - name: Some(Cow::Borrowed("monkey")), - }, - ], - }, - vert_layout: VertLayout { - layout_data: LayoutData { - num_sets: 0, - num_bindings: HashMap::new(), - descriptions: HashMap::new(), - num_constants: 0, - pc_ranges: Vec::new(), - }, - }, - }; - let entry = parse("vert2.glsl", "frag2.glsl"); - do_test(&entry, &target); -} - -#[test] -fn test_shade3() { - setup(); - let target = Entry { - compute_layout: Default::default(), - frag_input: FragInput { inputs: Vec::new() }, - frag_output: FragOutput { - outputs: vec![ShaderInterfaceDefEntry { - location: 0..1, - format: Format::R32G32B32A32Sfloat, - name: Some(Cow::Borrowed("f_color")), - }], - }, - frag_layout: FragLayout { - layout_data: LayoutData { - num_sets: 1, - num_bindings: vec![(0, 1)].into_iter().collect(), - descriptions: vec![( - 0, - vec![( - 0, - DescriptorDesc { - ty: DescriptorDescTy::CombinedImageSampler(DescriptorImageDesc { - sampled: true, - dimensions: DescriptorImageDescDimensions::TwoDimensional, - format: None, - multisampled: false, - array_layers: DescriptorImageDescArray::NonArrayed, - }), - array_count: 1, - stages: ShaderStages { - fragment: true, - ..ShaderStages::none() - }, - readonly: true, - }, - )] - .into_iter() - .collect(), - )] - .into_iter() - .collect(), - num_constants: 0, - pc_ranges: Vec::new(), - }, - }, - vert_input: VertInput { - inputs: vec![ShaderInterfaceDefEntry { - location: 0..1, - format: Format::R32G32Sfloat, - name: Some(Cow::Borrowed("position")), - }], - }, - vert_output: VertOutput { - outputs: Vec::new(), - }, - vert_layout: VertLayout { - layout_data: LayoutData { - num_sets: 0, - num_bindings: HashMap::new(), - descriptions: HashMap::new(), - num_constants: 0, - pc_ranges: Vec::new(), - }, - }, - }; - let entry = parse("vert3.glsl", "frag3.glsl"); - do_test(&entry.frag_input, &target.frag_input); - do_test(&entry.frag_output, &target.frag_output); - do_test(&entry.vert_input, &target.vert_input); - do_test(&entry.vert_output, &target.vert_output); - do_test( - &descriptor_layout(&entry.frag_layout), - &descriptor_layout(&target.frag_layout), - ); - do_test( - &descriptor_layout(&entry.vert_layout), - &descriptor_layout(&target.vert_layout), - ); -} - -#[test] -fn test_shade4() { - setup(); - let target = Entry { - compute_layout: Default::default(), - frag_input: FragInput { inputs: Vec::new() }, - frag_output: FragOutput { - outputs: vec![ShaderInterfaceDefEntry { - location: 0..1, - format: Format::R32G32B32A32Sfloat, - name: Some(Cow::Borrowed("f_color")), - }], - }, - frag_layout: FragLayout { - layout_data: LayoutData { - num_sets: 0, - num_bindings: HashMap::new(), - descriptions: HashMap::new(), - num_constants: 1, - pc_ranges: vec![PipelineLayoutDescPcRange { - offset: 0, - size: 16, - stages: ShaderStages { - fragment: true, - ..ShaderStages::none() - }, - }], - }, - }, - vert_input: VertInput { - inputs: vec![ShaderInterfaceDefEntry { - location: 0..1, - format: Format::R32G32Sfloat, - name: Some(Cow::Borrowed("position")), - }], - }, - vert_output: VertOutput { - outputs: Vec::new(), - }, - vert_layout: VertLayout { - layout_data: LayoutData { - num_sets: 0, - num_bindings: HashMap::new(), - descriptions: HashMap::new(), - num_constants: 0, - pc_ranges: Vec::new(), - }, - }, - }; - let entry = parse("vert4.glsl", "frag4.glsl"); - do_test(&entry.frag_input, &target.frag_input); - do_test(&entry.frag_output, &target.frag_output); - do_test(&entry.vert_input, &target.vert_input); - do_test(&entry.vert_output, &target.vert_output); - do_test( - &descriptor_layout(&entry.frag_layout), - &descriptor_layout(&target.frag_layout), - ); -} +//use color_backtrace; +//use difference::{Changeset, Difference}; +//use shade_runner::*; +//use std::borrow::Cow; +//use std::collections::HashMap; +//use std::path::{Path, PathBuf}; +//use vulkano::descriptor::descriptor::*; +//use vulkano::descriptor::pipeline_layout::{PipelineLayoutDesc, PipelineLayoutDescPcRange}; +//use vulkano::format::*; +//use vulkano::pipeline::shader::ShaderInterfaceDefEntry; +// +//fn setup() { +// color_backtrace::install(); +//} +// +//fn difference(e: &str, t: &str) -> String { +// let diffs = Changeset::new(&e, &t, ""); +// diffs +// .diffs +// .iter() +// .filter(|d| match d { +// Difference::Add(_) => true, +// Difference::Rem(_) => true, +// _ => false, +// }) +// .map(|d| match d { +// Difference::Add(a) => format!("add: {}", a), +// Difference::Rem(a) => format!("remove: {}", a), +// _ => "".to_string(), +// }) +// .collect::>() +// .join("\n") +//} +// +//fn descriptor_layout(desc: &T) -> String +//where +// T: PipelineLayoutDesc, +//{ +// let num_sets = desc.num_sets(); +// let mut r = format!("{:?}", num_sets); +// for n in 0..num_sets { +// let num_bindings = desc.num_bindings_in_set(n); +// r = format!("{:?}{:?}", r, num_bindings); +// for b in num_bindings { +// r = format!("{:?}{:?}", r, desc.descriptor(n, b)); +// } +// } +// let num_push_constants = desc.num_push_constants_ranges(); +// r = format!("{:?}{:?}", r, num_push_constants); +// for i in 0..num_push_constants { +// r = format!("{:?}{:?}", r, desc.push_constants_range(i)); +// } +// r +//} +// +//fn parse(vertex: T, fragment: T) -> shade_runner::Entry +//where +// T: AsRef, +//{ +// let project_root = std::env::current_dir().expect("failed to get root directory"); +// let mut path = project_root.clone(); +// path.push(PathBuf::from("tests/shaders/")); +// let mut vertex_path = path.clone(); +// vertex_path.push(vertex); +// let mut fragment_path = path.clone(); +// fragment_path.push(fragment); +// let shader = shade_runner::load(vertex_path, fragment_path).expect("Failed to compile"); +// shade_runner::parse(&shader).unwrap() +//} +// +//fn do_test(a: &T, b: &T) +//where +// T: std::fmt::Debug, +//{ +// let a = format!("{:?}", a); +// let b = format!("{:?}", b); +// assert_eq!(&a, &b, "\n\nDifference: {}", difference(&a, &b)); +//} +// +//#[test] +//fn test_shade1() { +// setup(); +// let target = Entry { +// compute_layout: Default::default(), +// frag_input: FragInput { inputs: Vec::new() }, +// frag_output: FragOutput { +// outputs: vec![ShaderInterfaceDefEntry { +// location: 0..1, +// format: Format::R32G32B32A32Sfloat, +// name: Some(Cow::Borrowed("f_color")), +// }], +// }, +// frag_layout: FragLayout { +// layout_data: LayoutData { +// num_sets: 0, +// num_bindings: HashMap::new(), +// descriptions: HashMap::new(), +// num_constants: 0, +// pc_ranges: Vec::new(), +// }, +// }, +// vert_input: VertInput { +// inputs: vec![ShaderInterfaceDefEntry { +// location: 0..1, +// format: Format::R32G32Sfloat, +// name: Some(Cow::Borrowed("position")), +// }], +// }, +// vert_output: VertOutput { +// outputs: Vec::new(), +// }, +// vert_layout: VertLayout { +// layout_data: LayoutData { +// num_sets: 0, +// num_bindings: HashMap::new(), +// descriptions: HashMap::new(), +// num_constants: 0, +// pc_ranges: Vec::new(), +// }, +// }, +// }; +// let entry = parse("vert1.glsl", "frag1.glsl"); +// do_test(&entry, &target); +//} +// +//#[test] +//fn test_shade2() { +// setup(); +// let target = Entry { +// compute_layout: Default::default(), +// frag_input: FragInput { +// inputs: vec![ +// ShaderInterfaceDefEntry { +// location: 0..1, +// format: Format::R32G32B32A32Sfloat, +// name: Some(Cow::Borrowed("cool")), +// }, +// ShaderInterfaceDefEntry { +// location: 1..2, +// format: Format::R32G32Sfloat, +// name: Some(Cow::Borrowed("yep")), +// }, +// ShaderInterfaceDefEntry { +// location: 2..3, +// format: Format::R32Sfloat, +// name: Some(Cow::Borrowed("monkey")), +// }, +// ], +// }, +// frag_output: FragOutput { +// outputs: vec![ShaderInterfaceDefEntry { +// location: 0..1, +// format: Format::R32G32B32A32Sfloat, +// name: Some(Cow::Borrowed("f_color")), +// }], +// }, +// frag_layout: FragLayout { +// layout_data: LayoutData { +// num_sets: 0, +// num_bindings: HashMap::new(), +// descriptions: HashMap::new(), +// num_constants: 0, +// pc_ranges: Vec::new(), +// }, +// }, +// vert_input: VertInput { +// inputs: vec![ShaderInterfaceDefEntry { +// location: 0..1, +// format: Format::R32G32Sfloat, +// name: Some(Cow::Borrowed("position")), +// }], +// }, +// vert_output: VertOutput { +// outputs: vec![ +// ShaderInterfaceDefEntry { +// location: 0..1, +// format: Format::R32G32B32A32Sfloat, +// name: Some(Cow::Borrowed("cool")), +// }, +// ShaderInterfaceDefEntry { +// location: 1..2, +// format: Format::R32G32Sfloat, +// name: Some(Cow::Borrowed("yep")), +// }, +// ShaderInterfaceDefEntry { +// location: 2..3, +// format: Format::R32Sfloat, +// name: Some(Cow::Borrowed("monkey")), +// }, +// ], +// }, +// vert_layout: VertLayout { +// layout_data: LayoutData { +// num_sets: 0, +// num_bindings: HashMap::new(), +// descriptions: HashMap::new(), +// num_constants: 0, +// pc_ranges: Vec::new(), +// }, +// }, +// }; +// let entry = parse("vert2.glsl", "frag2.glsl"); +// do_test(&entry, &target); +//} +// +//#[test] +//fn test_shade3() { +// setup(); +// let target = Entry { +// compute_layout: Default::default(), +// frag_input: FragInput { inputs: Vec::new() }, +// frag_output: FragOutput { +// outputs: vec![ShaderInterfaceDefEntry { +// location: 0..1, +// format: Format::R32G32B32A32Sfloat, +// name: Some(Cow::Borrowed("f_color")), +// }], +// }, +// frag_layout: FragLayout { +// layout_data: LayoutData { +// num_sets: 1, +// num_bindings: vec![(0, 1)].into_iter().collect(), +// descriptions: vec![( +// 0, +// vec![( +// 0, +// DescriptorDesc { +// ty: DescriptorDescTy::CombinedImageSampler(DescriptorImageDesc { +// sampled: true, +// dimensions: DescriptorImageDescDimensions::TwoDimensional, +// format: None, +// multisampled: false, +// array_layers: DescriptorImageDescArray::NonArrayed, +// }), +// array_count: 1, +// stages: ShaderStages { +// fragment: true, +// ..ShaderStages::none() +// }, +// readonly: true, +// }, +// )] +// .into_iter() +// .collect(), +// )] +// .into_iter() +// .collect(), +// num_constants: 0, +// pc_ranges: Vec::new(), +// }, +// }, +// vert_input: VertInput { +// inputs: vec![ShaderInterfaceDefEntry { +// location: 0..1, +// format: Format::R32G32Sfloat, +// name: Some(Cow::Borrowed("position")), +// }], +// }, +// vert_output: VertOutput { +// outputs: Vec::new(), +// }, +// vert_layout: VertLayout { +// layout_data: LayoutData { +// num_sets: 0, +// num_bindings: HashMap::new(), +// descriptions: HashMap::new(), +// num_constants: 0, +// pc_ranges: Vec::new(), +// }, +// }, +// }; +// let entry = parse("vert3.glsl", "frag3.glsl"); +// do_test(&entry.frag_input, &target.frag_input); +// do_test(&entry.frag_output, &target.frag_output); +// do_test(&entry.vert_input, &target.vert_input); +// do_test(&entry.vert_output, &target.vert_output); +// do_test( +// &descriptor_layout(&entry.frag_layout), +// &descriptor_layout(&target.frag_layout), +// ); +// do_test( +// &descriptor_layout(&entry.vert_layout), +// &descriptor_layout(&target.vert_layout), +// ); +//} +// +//#[test] +//fn test_shade4() { +// setup(); +// let target = Entry { +// compute_layout: Default::default(), +// frag_input: FragInput { inputs: Vec::new() }, +// frag_output: FragOutput { +// outputs: vec![ShaderInterfaceDefEntry { +// location: 0..1, +// format: Format::R32G32B32A32Sfloat, +// name: Some(Cow::Borrowed("f_color")), +// }], +// }, +// frag_layout: FragLayout { +// layout_data: LayoutData { +// num_sets: 0, +// num_bindings: HashMap::new(), +// descriptions: HashMap::new(), +// num_constants: 1, +// pc_ranges: vec![PipelineLayoutDescPcRange { +// offset: 0, +// size: 16, +// stages: ShaderStages { +// fragment: true, +// ..ShaderStages::none() +// }, +// }], +// }, +// }, +// vert_input: VertInput { +// inputs: vec![ShaderInterfaceDefEntry { +// location: 0..1, +// format: Format::R32G32Sfloat, +// name: Some(Cow::Borrowed("position")), +// }], +// }, +// vert_output: VertOutput { +// outputs: Vec::new(), +// }, +// vert_layout: VertLayout { +// layout_data: LayoutData { +// num_sets: 0, +// num_bindings: HashMap::new(), +// descriptions: HashMap::new(), +// num_constants: 0, +// pc_ranges: Vec::new(), +// }, +// }, +// }; +// let entry = parse("vert4.glsl", "frag4.glsl"); +// do_test(&entry.frag_input, &target.frag_input); +// do_test(&entry.frag_output, &target.frag_output); +// do_test(&entry.vert_input, &target.vert_input); +// do_test(&entry.vert_output, &target.vert_output); +// do_test( +// &descriptor_layout(&entry.frag_layout), +// &descriptor_layout(&target.frag_layout), +// ); +//}