From cd160e0ac0be0c29d65187b45fb244f4538038b0 Mon Sep 17 00:00:00 2001 From: Daniel Keitel Date: Wed, 22 Mar 2023 02:18:30 +0100 Subject: [PATCH] first successful raytracing shader compile (hit shader with rayPayloadInEXT) --- cli/src/bin/naga.rs | 9 +++++++- src/back/glsl/mod.rs | 21 ++++++++++++++++++ src/back/hlsl/mod.rs | 6 ++++++ src/back/hlsl/writer.rs | 1 + src/back/msl/writer.rs | 10 +++++++++ src/back/spv/helpers.rs | 1 + src/back/spv/writer.rs | 25 ++++++++++++++++++++++ src/back/wgsl/writer.rs | 19 +++++++++++++++++ src/front/glsl/lex.rs | 1 + src/front/glsl/parser/types.rs | 9 ++++++-- src/front/glsl/token.rs | 1 + src/front/glsl/variables.rs | 15 +++++++++++++ src/front/spv/mod.rs | 3 +++ src/front/wgsl/lower/mod.rs | 1 + src/lib.rs | 10 +++++++++ src/proc/mod.rs | 1 + src/valid/analyzer.rs | 3 +++ src/valid/handles.rs | 1 + src/valid/interface.rs | 33 +++++++++++++++++++++++++++++ src/valid/mod.rs | 10 ++++++++- src/valid/type.rs | 6 +++++- tests/out/analysis/access.info.ron | 20 ++++++++--------- tests/out/analysis/collatz.info.ron | 4 ++-- tests/out/analysis/shadow.info.ron | 6 +++--- tests/out/ir/access.ron | 6 ++++++ tests/out/ir/collatz.ron | 1 + tests/out/ir/shadow.ron | 7 ++++++ tests/snapshots.rs | 6 ++++++ 28 files changed, 216 insertions(+), 20 deletions(-) diff --git a/cli/src/bin/naga.rs b/cli/src/bin/naga.rs index b121dd52db..49bc71b416 100644 --- a/cli/src/bin/naga.rs +++ b/cli/src/bin/naga.rs @@ -287,7 +287,8 @@ fn run() -> Result<(), Box> { } } } - ext @ ("vert" | "frag" | "comp") => { + ext @ ("vert" | "frag" | "comp" | "rgen" | "rmiss" | "rcall" | "rchit" | "rahit" + | "rint") => { let input = String::from_utf8(input)?; let mut parser = naga::front::glsl::Frontend::default(); @@ -299,6 +300,12 @@ fn run() -> Result<(), Box> { "vert" => naga::ShaderStage::Vertex, "frag" => naga::ShaderStage::Fragment, "comp" => naga::ShaderStage::Compute, + "rgen" => naga::ShaderStage::RayGen, + "rmiss" => naga::ShaderStage::Miss, + "rcall" => naga::ShaderStage::Callable, + "rchit" => naga::ShaderStage::ClosestHit, + "rahit" => naga::ShaderStage::AnyHit, + "rint" => naga::ShaderStage::Intersection, _ => unreachable!(), }, defines: Default::default(), diff --git a/src/back/glsl/mod.rs b/src/back/glsl/mod.rs index 44685fb99e..d40e336f92 100644 --- a/src/back/glsl/mod.rs +++ b/src/back/glsl/mod.rs @@ -107,6 +107,7 @@ impl crate::AddressSpace { | crate::AddressSpace::Storage { .. } | crate::AddressSpace::Handle | crate::AddressSpace::PushConstant => false, + crate::AddressSpace::IncomingRayPayload => unimplemented!(), } } } @@ -335,6 +336,12 @@ impl fmt::Display for VaryingName<'_> { crate::Binding::Location { location, .. } => { let prefix = match (self.stage, self.output) { (ShaderStage::Compute, _) => unreachable!(), + (ShaderStage::RayGen, _) => unreachable!(), + (ShaderStage::Miss, _) => unreachable!(), + (ShaderStage::Callable, _) => unreachable!(), + (ShaderStage::ClosestHit, _) => unreachable!(), + (ShaderStage::AnyHit, _) => unreachable!(), + (ShaderStage::Intersection, _) => unreachable!(), // pipeline to vertex (ShaderStage::Vertex, false) => "p2vs", // vertex to fragment @@ -361,6 +368,12 @@ impl ShaderStage { ShaderStage::Compute => "cs", ShaderStage::Fragment => "fs", ShaderStage::Vertex => "vs", + ShaderStage::RayGen + | ShaderStage::Miss + | ShaderStage::Callable + | ShaderStage::ClosestHit + | ShaderStage::AnyHit + | ShaderStage::Intersection => unimplemented!(), } } } @@ -1030,6 +1043,7 @@ impl<'a, W: Write> Writer<'a, W> { crate::AddressSpace::Function => unreachable!(), // Textures and samplers are handled directly in `Writer::write`. crate::AddressSpace::Handle => unreachable!(), + crate::AddressSpace::IncomingRayPayload => unimplemented!(), } Ok(()) @@ -1302,6 +1316,12 @@ impl<'a, W: Write> Writer<'a, W> { ShaderStage::Vertex => output, ShaderStage::Fragment => !output, ShaderStage::Compute => false, + ShaderStage::RayGen + | ShaderStage::Miss + | ShaderStage::Callable + | ShaderStage::ClosestHit + | ShaderStage::AnyHit + | ShaderStage::Intersection => unimplemented!(), }; // Write the I/O locations, if allowed @@ -4010,6 +4030,7 @@ const fn glsl_storage_qualifier(space: crate::AddressSpace) -> Option<&'static s As::Handle => Some("uniform"), As::WorkGroup => Some("shared"), As::PushConstant => Some("uniform"), + As::IncomingRayPayload => unimplemented!(), } } diff --git a/src/back/hlsl/mod.rs b/src/back/hlsl/mod.rs index 6f31ed3743..55811dfe70 100644 --- a/src/back/hlsl/mod.rs +++ b/src/back/hlsl/mod.rs @@ -149,6 +149,12 @@ impl crate::ShaderStage { Self::Vertex => "vs", Self::Fragment => "ps", Self::Compute => "cs", + Self::RayGen + | Self::Miss + | Self::Callable + | Self::ClosestHit + | Self::AnyHit + | Self::Intersection => unimplemented!(), } } } diff --git a/src/back/hlsl/writer.rs b/src/back/hlsl/writer.rs index d11032bbf5..a2f2b8bd71 100644 --- a/src/back/hlsl/writer.rs +++ b/src/back/hlsl/writer.rs @@ -676,6 +676,7 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> { write!(self.out, "ConstantBuffer<")?; "b" } + crate::AddressSpace::IncomingRayPayload => unimplemented!(), }; // If the global is a push constant write the type now because it will be a diff --git a/src/back/msl/writer.rs b/src/back/msl/writer.rs index ee23ca294a..fed4ae5ee3 100644 --- a/src/back/msl/writer.rs +++ b/src/back/msl/writer.rs @@ -438,6 +438,7 @@ impl crate::AddressSpace { | Self::PushConstant | Self::Handle => true, Self::Function => false, + Self::IncomingRayPayload => unimplemented!(), } } @@ -455,6 +456,7 @@ impl crate::AddressSpace { Self::Uniform | Self::PushConstant => false, // Not applicable. Self::Handle | Self::Function => false, + Self::IncomingRayPayload => unimplemented!(), } } @@ -465,6 +467,7 @@ impl crate::AddressSpace { Self::Storage { .. } => Some("device"), Self::Private | Self::Function => Some("thread"), Self::WorkGroup => Some("threadgroup"), + Self::IncomingRayPayload => unimplemented!(), } } } @@ -3432,6 +3435,7 @@ impl Writer { crate::AddressSpace::Function | crate::AddressSpace::Private | crate::AddressSpace::WorkGroup => {} + crate::AddressSpace::IncomingRayPayload => unimplemented!(), } } if supports_array_length { @@ -3464,6 +3468,12 @@ impl Writer { crate::ShaderStage::Compute { .. } => { ("kernel", LocationMode::Uniform, LocationMode::Uniform) } + crate::ShaderStage::RayGen + | crate::ShaderStage::Miss + | crate::ShaderStage::Callable + | crate::ShaderStage::ClosestHit + | crate::ShaderStage::AnyHit + | crate::ShaderStage::Intersection => unimplemented!(), }; // List all the Naga `EntryPoint`'s `Function`'s arguments, diff --git a/src/back/spv/helpers.rs b/src/back/spv/helpers.rs index 1ef0db1912..c914ec5ac1 100644 --- a/src/back/spv/helpers.rs +++ b/src/back/spv/helpers.rs @@ -29,6 +29,7 @@ pub(super) const fn map_storage_class(space: crate::AddressSpace) -> spirv::Stor crate::AddressSpace::Uniform => spirv::StorageClass::Uniform, crate::AddressSpace::WorkGroup => spirv::StorageClass::Workgroup, crate::AddressSpace::PushConstant => spirv::StorageClass::PushConstant, + crate::AddressSpace::IncomingRayPayload => spirv::StorageClass::IncomingRayPayloadKHR, } } diff --git a/src/back/spv/writer.rs b/src/back/spv/writer.rs index f264c107d3..39e5557d29 100644 --- a/src/back/spv/writer.rs +++ b/src/back/spv/writer.rs @@ -766,6 +766,13 @@ impl Writer { .to_words(&mut self.logical_layout.execution_modes); spirv::ExecutionModel::GLCompute } + // TODO + crate::ShaderStage::RayGen => spirv::ExecutionModel::RayGenerationKHR, + crate::ShaderStage::Miss => spirv::ExecutionModel::MissKHR, + crate::ShaderStage::Callable => spirv::ExecutionModel::CallableKHR, + crate::ShaderStage::ClosestHit => spirv::ExecutionModel::ClosestHitKHR, + crate::ShaderStage::AnyHit => spirv::ExecutionModel::AnyHitKHR, + crate::ShaderStage::Intersection => spirv::ExecutionModel::IntersectionKHR, }; //self.check(exec_model.required_capabilities())?; @@ -1587,6 +1594,24 @@ impl Writer { } }; + match global_variable.space { + crate::AddressSpace::Function + | crate::AddressSpace::Private + | crate::AddressSpace::WorkGroup + | crate::AddressSpace::Uniform + | crate::AddressSpace::Storage { .. } + | crate::AddressSpace::Handle + | crate::AddressSpace::PushConstant => {} + crate::AddressSpace::IncomingRayPayload => { + self.require_any("Incoming Ray Payload", &[spirv::Capability::RayTracingKHR])?; + self.use_extension("SPV_KHR_ray_tracing"); + } + }; + + if let Some(location) = global_variable.location { + self.decorate(id, Decoration::Location, &[location]); + }; + let init_word = global_variable .init .map(|constant| self.constant_ids[constant.index()]); diff --git a/src/back/wgsl/writer.rs b/src/back/wgsl/writer.rs index f24f4a9c26..a495ab3de6 100644 --- a/src/back/wgsl/writer.rs +++ b/src/back/wgsl/writer.rs @@ -157,6 +157,12 @@ impl Writer { Attribute::Stage(ShaderStage::Compute), Attribute::WorkGroupSize(ep.workgroup_size), ], + ShaderStage::RayGen + | ShaderStage::Miss + | ShaderStage::Callable + | ShaderStage::ClosestHit + | ShaderStage::AnyHit + | ShaderStage::Intersection => unimplemented!(), }; self.write_attributes(&attributes)?; @@ -209,6 +215,12 @@ impl Writer { ShaderStage::Compute => "ComputeOutput", ShaderStage::Fragment => "FragmentOutput", ShaderStage::Vertex => "VertexOutput", + ShaderStage::RayGen + | ShaderStage::Miss + | ShaderStage::Callable + | ShaderStage::ClosestHit + | ShaderStage::AnyHit + | ShaderStage::Intersection => unimplemented!(), }; write!(self.out, "{name}")?; @@ -343,6 +355,12 @@ impl Writer { ShaderStage::Vertex => "vertex", ShaderStage::Fragment => "fragment", ShaderStage::Compute => "compute", + ShaderStage::RayGen + | ShaderStage::Miss + | ShaderStage::Callable + | ShaderStage::ClosestHit + | ShaderStage::AnyHit + | ShaderStage::Intersection => unimplemented!(), }; write!(self.out, "@{stage_str} ")?; } @@ -1931,6 +1949,7 @@ const fn address_space_str( As::WorkGroup => "workgroup", As::Handle => return (None, None), As::Function => "function", + As::IncomingRayPayload => unimplemented!(), }), None, ) diff --git a/src/front/glsl/lex.rs b/src/front/glsl/lex.rs index 1b59a9bf3e..7703eb425a 100644 --- a/src/front/glsl/lex.rs +++ b/src/front/glsl/lex.rs @@ -108,6 +108,7 @@ impl<'a> Iterator for Lexer<'a> { // types "void" => TokenValue::Void, "struct" => TokenValue::Struct, + "rayPayloadInEXT" => TokenValue::RayPayloadInEXT, word => match parse_type(word) { Some(t) => TokenValue::TypeName(t), None => TokenValue::Identifier(String::from(word)), diff --git a/src/front/glsl/parser/types.rs b/src/front/glsl/parser/types.rs index 08a70669a0..4ee80cc3b3 100644 --- a/src/front/glsl/parser/types.rs +++ b/src/front/glsl/parser/types.rs @@ -156,7 +156,8 @@ impl<'source> ParsingContext<'source> { | TokenValue::Buffer | TokenValue::Restrict | TokenValue::MemoryQualifier(_) - | TokenValue::Layout => true, + | TokenValue::Layout + | TokenValue::RayPayloadInEXT => true, _ => false, }) } @@ -210,7 +211,8 @@ impl<'source> ParsingContext<'source> { | TokenValue::Out | TokenValue::Uniform | TokenValue::Shared - | TokenValue::Buffer => { + | TokenValue::Buffer + | TokenValue::RayPayloadInEXT => { let storage = match token.value { TokenValue::Const => StorageQualifier::Const, TokenValue::In => StorageQualifier::Input, @@ -226,6 +228,9 @@ impl<'source> ParsingContext<'source> { access: crate::StorageAccess::all(), }) } + TokenValue::RayPayloadInEXT => { + StorageQualifier::AddressSpace(AddressSpace::IncomingRayPayload) + } _ => unreachable!(), }; diff --git a/src/front/glsl/token.rs b/src/front/glsl/token.rs index 74f10cbf85..e1d636608f 100644 --- a/src/front/glsl/token.rs +++ b/src/front/glsl/token.rs @@ -36,6 +36,7 @@ pub enum TokenValue { Buffer, Const, Shared, + RayPayloadInEXT, Restrict, /// A `glsl` memory qualifier such as `writeonly` diff --git a/src/front/glsl/variables.rs b/src/front/glsl/variables.rs index 4c0e0a927d..e2ad012aa5 100644 --- a/src/front/glsl/variables.rs +++ b/src/front/glsl/variables.rs @@ -58,6 +58,7 @@ impl Frontend { name: Some(name.into()), space: AddressSpace::Private, binding: None, + location: None, ty, init: None, }, @@ -462,6 +463,7 @@ impl Frontend { name: name.clone(), space: AddressSpace::Private, binding: None, + location: None, ty, init, }, @@ -600,11 +602,24 @@ impl Frontend { _ => None, }; + let location = match space { + AddressSpace::IncomingRayPayload => { + // TODO: glslang seems to use a counter for variables without + // explicit location (even if that causes collisions) + let location = qualifiers + .uint_layout_qualifier("location", &mut self.errors) + .unwrap_or(0); + Some(location) + } + _ => None, + }; + let handle = self.module.global_variables.append( GlobalVariable { name: name.clone(), space, binding, + location, ty, init, }, diff --git a/src/front/spv/mod.rs b/src/front/spv/mod.rs index ce42be35b2..c9e2d9fcf5 100644 --- a/src/front/spv/mod.rs +++ b/src/front/spv/mod.rs @@ -5003,6 +5003,7 @@ impl> Frontend { } let var = crate::GlobalVariable { binding: dec.resource_binding(), + location: None, name: dec.name, space, ty, @@ -5048,6 +5049,7 @@ impl> Frontend { name: dec.name.clone(), space: crate::AddressSpace::Private, binding: None, + location: None, ty, init: None, }; @@ -5121,6 +5123,7 @@ impl> Frontend { name: dec.name, space: crate::AddressSpace::Private, binding: None, + location: None, ty, init, }; diff --git a/src/front/wgsl/lower/mod.rs b/src/front/wgsl/lower/mod.rs index f3b157caa7..a56d7b6aeb 100644 --- a/src/front/wgsl/lower/mod.rs +++ b/src/front/wgsl/lower/mod.rs @@ -666,6 +666,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> { name: Some(v.name.name.to_string()), space: v.space, binding: v.binding.clone(), + location: None, ty, init, }, diff --git a/src/lib.rs b/src/lib.rs index c1b48b8991..5a39df4642 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -302,6 +302,12 @@ pub enum ShaderStage { Vertex, Fragment, Compute, + RayGen, + Miss, + Callable, + ClosestHit, + AnyHit, + Intersection, } /// Addressing space of variables. @@ -324,6 +330,8 @@ pub enum AddressSpace { Handle, /// Push constants. PushConstant, + /// Incoming ray payload for SPV_KHR_ray_tracing + IncomingRayPayload, } /// Built-in inputs and outputs. @@ -861,6 +869,8 @@ pub struct GlobalVariable { pub space: AddressSpace, /// For resources, defines the binding point. pub binding: Option, + /// For some ray-tracing storage qualifiers, define the location + pub location: Option, /// The type of this variable. pub ty: Handle, /// Initial value for this variable. diff --git a/src/proc/mod.rs b/src/proc/mod.rs index 6a8bfa03c7..cb597904fe 100644 --- a/src/proc/mod.rs +++ b/src/proc/mod.rs @@ -213,6 +213,7 @@ impl super::AddressSpace { crate::AddressSpace::Storage { access } => access, crate::AddressSpace::Handle => Sa::LOAD, crate::AddressSpace::PushConstant => Sa::LOAD, + crate::AddressSpace::IncomingRayPayload => Sa::LOAD | Sa::STORE, } } } diff --git a/src/valid/analyzer.rs b/src/valid/analyzer.rs index 40d5f95c10..44b238e500 100644 --- a/src/valid/analyzer.rs +++ b/src/valid/analyzer.rs @@ -550,6 +550,7 @@ impl FunctionInfo { // storage data is only uniform when read-only As::Storage { access } => !access.contains(crate::StorageAccess::STORE), As::Handle => false, + As::IncomingRayPayload => false, }; Uniformity { non_uniform_result: if uniform { None } else { Some(handle) }, @@ -994,6 +995,7 @@ fn uniform_control_flow() { ty, space: crate::AddressSpace::Handle, binding: None, + location: None, }, Default::default(), ); @@ -1003,6 +1005,7 @@ fn uniform_control_flow() { init: None, ty, binding: None, + location: None, space: crate::AddressSpace::Uniform, }, Default::default(), diff --git a/src/valid/handles.rs b/src/valid/handles.rs index e3f9fe2531..ff49fc44ee 100644 --- a/src/valid/handles.rs +++ b/src/valid/handles.rs @@ -122,6 +122,7 @@ impl super::Validator { name: _, space: _, binding: _, + location: _, ty, init, } = global_variable; diff --git a/src/valid/interface.rs b/src/valid/interface.rs index 13dbd75761..8b655fc544 100644 --- a/src/valid/interface.rs +++ b/src/valid/interface.rs @@ -193,6 +193,12 @@ impl VaryingContext<'_> { St::Vertex => self.output, St::Fragment => !self.output, St::Compute => false, + St::RayGen + | St::Miss + | St::Callable + | St::ClosestHit + | St::AnyHit + | St::Intersection => false, }, *ty_inner == Ti::Vector { @@ -205,6 +211,12 @@ impl VaryingContext<'_> { match self.stage { St::Vertex | St::Fragment => !self.output, St::Compute => false, + St::RayGen + | St::Miss + | St::Callable + | St::ClosestHit + | St::AnyHit + | St::Intersection => false, }, *ty_inner == Ti::Scalar { @@ -306,6 +318,12 @@ impl VaryingContext<'_> { crate::ShaderStage::Vertex => self.output, crate::ShaderStage::Fragment => !self.output, crate::ShaderStage::Compute => false, + crate::ShaderStage::RayGen => false, + crate::ShaderStage::Miss => false, + crate::ShaderStage::Callable => false, + crate::ShaderStage::ClosestHit => false, + crate::ShaderStage::AnyHit => false, + crate::ShaderStage::Intersection => false, }; // It doesn't make sense to specify a sampling when `interpolation` is `Flat`, but @@ -493,6 +511,14 @@ impl super::Validator { false, ) } + crate::AddressSpace::IncomingRayPayload => { + if !self.capabilities.contains(Capabilities::RAY_TRACING) { + return Err(GlobalVariableError::UnsupportedCapability( + Capabilities::RAY_TRACING, + )); + } + (TypeFlags::DATA | TypeFlags::COPY | TypeFlags::SIZED, false) + } }; if !type_info.flags.contains(required_type_flags) { @@ -557,6 +583,12 @@ impl super::Validator { crate::ShaderStage::Vertex => ShaderStages::VERTEX, crate::ShaderStage::Fragment => ShaderStages::FRAGMENT, crate::ShaderStage::Compute => ShaderStages::COMPUTE, + crate::ShaderStage::RayGen => ShaderStages::RAY_GEN, + crate::ShaderStage::Miss => ShaderStages::MISS, + crate::ShaderStage::Callable => ShaderStages::CALLABLE, + crate::ShaderStage::ClosestHit => ShaderStages::CLOSEST_HIT, + crate::ShaderStage::AnyHit => ShaderStages::ANY_HIT, + crate::ShaderStage::Intersection => ShaderStages::INTERSECTION, }; if !info.available_stages.contains(stage_bit) { @@ -634,6 +666,7 @@ impl super::Validator { }, crate::AddressSpace::Private | crate::AddressSpace::WorkGroup => GlobalUse::all(), crate::AddressSpace::PushConstant => GlobalUse::READ, + crate::AddressSpace::IncomingRayPayload => GlobalUse::all(), }; if !allowed_usage.contains(usage) { log::warn!("\tUsage error for: {:?}", var); diff --git a/src/valid/mod.rs b/src/valid/mod.rs index eb92e8892d..32c0e11e91 100644 --- a/src/valid/mod.rs +++ b/src/valid/mod.rs @@ -111,6 +111,8 @@ bitflags::bitflags! { const EARLY_DEPTH_TEST = 0x400; /// Support for [`Builtin::SampleIndex`] and [`Sampling::Sample`]. const MULTISAMPLED_SHADING = 0x800; + /// Support for RayTracingKHR + const RAY_TRACING = 0x2000; } } @@ -124,10 +126,16 @@ bitflags::bitflags! { /// Validation flags. #[cfg_attr(feature = "serialize", derive(serde::Serialize))] #[cfg_attr(feature = "deserialize", derive(serde::Deserialize))] - pub struct ShaderStages: u8 { + pub struct ShaderStages: u16 { const VERTEX = 0x1; const FRAGMENT = 0x2; const COMPUTE = 0x4; + const RAY_GEN = 1 << 3; + const MISS = 1 << 4; + const CALLABLE = 1 << 5; + const CLOSEST_HIT = 1 << 6; + const ANY_HIT = 1 << 7; + const INTERSECTION = 1 << 8; } } diff --git a/src/valid/type.rs b/src/valid/type.rs index 4fcc1a1c58..a22b589693 100644 --- a/src/valid/type.rs +++ b/src/valid/type.rs @@ -173,7 +173,11 @@ const fn ptr_space_argument_flag(space: crate::AddressSpace) -> TypeFlags { use crate::AddressSpace as As; match space { As::Function | As::Private | As::WorkGroup => TypeFlags::ARGUMENT, - As::Uniform | As::Storage { .. } | As::Handle | As::PushConstant => TypeFlags::empty(), + As::Uniform + | As::Storage { .. } + | As::Handle + | As::PushConstant + | As::IncomingRayPayload => TypeFlags::empty(), } } diff --git a/tests/out/analysis/access.info.ron b/tests/out/analysis/access.info.ron index 01e08a63ba..c03fa931c8 100644 --- a/tests/out/analysis/access.info.ron +++ b/tests/out/analysis/access.info.ron @@ -106,7 +106,7 @@ bits: 63, ), available_stages: ( - bits: 7, + bits: 511, ), uniformity: ( non_uniform_result: None, @@ -1541,7 +1541,7 @@ bits: 63, ), available_stages: ( - bits: 7, + bits: 511, ), uniformity: ( non_uniform_result: None, @@ -3374,7 +3374,7 @@ bits: 63, ), available_stages: ( - bits: 7, + bits: 511, ), uniformity: ( non_uniform_result: Some(1), @@ -3435,7 +3435,7 @@ bits: 63, ), available_stages: ( - bits: 7, + bits: 511, ), uniformity: ( non_uniform_result: Some(1), @@ -3535,7 +3535,7 @@ bits: 63, ), available_stages: ( - bits: 7, + bits: 511, ), uniformity: ( non_uniform_result: None, @@ -3599,7 +3599,7 @@ bits: 63, ), available_stages: ( - bits: 7, + bits: 511, ), uniformity: ( non_uniform_result: None, @@ -3720,7 +3720,7 @@ bits: 63, ), available_stages: ( - bits: 7, + bits: 511, ), uniformity: ( non_uniform_result: Some(1), @@ -4559,7 +4559,7 @@ bits: 63, ), available_stages: ( - bits: 7, + bits: 511, ), uniformity: ( non_uniform_result: None, @@ -5128,7 +5128,7 @@ bits: 63, ), available_stages: ( - bits: 7, + bits: 511, ), uniformity: ( non_uniform_result: None, @@ -5755,7 +5755,7 @@ bits: 63, ), available_stages: ( - bits: 7, + bits: 511, ), uniformity: ( non_uniform_result: None, diff --git a/tests/out/analysis/collatz.info.ron b/tests/out/analysis/collatz.info.ron index 3896cd9437..31097ac3a3 100644 --- a/tests/out/analysis/collatz.info.ron +++ b/tests/out/analysis/collatz.info.ron @@ -19,7 +19,7 @@ bits: 63, ), available_stages: ( - bits: 7, + bits: 511, ), uniformity: ( non_uniform_result: Some(4), @@ -345,7 +345,7 @@ bits: 63, ), available_stages: ( - bits: 7, + bits: 511, ), uniformity: ( non_uniform_result: Some(4), diff --git a/tests/out/analysis/shadow.info.ron b/tests/out/analysis/shadow.info.ron index 54731d00ec..110fc110f9 100644 --- a/tests/out/analysis/shadow.info.ron +++ b/tests/out/analysis/shadow.info.ron @@ -100,7 +100,7 @@ bits: 63, ), available_stages: ( - bits: 7, + bits: 511, ), uniformity: ( non_uniform_result: Some(4), @@ -1166,7 +1166,7 @@ bits: 63, ), available_stages: ( - bits: 7, + bits: 511, ), uniformity: ( non_uniform_result: Some(4), @@ -2969,7 +2969,7 @@ bits: 63, ), available_stages: ( - bits: 7, + bits: 511, ), uniformity: ( non_uniform_result: Some(4), diff --git a/tests/out/ir/access.ron b/tests/out/ir/access.ron index e544ee1a5d..726c70ded5 100644 --- a/tests/out/ir/access.ron +++ b/tests/out/ir/access.ron @@ -675,6 +675,7 @@ name: Some("global_const"), space: Private, binding: None, + location: None, ty: 4, init: Some(4), ), @@ -689,6 +690,7 @@ group: 0, binding: 0, )), + location: None, ty: 14, init: None, ), @@ -699,6 +701,7 @@ group: 0, binding: 1, )), + location: None, ty: 16, init: None, ), @@ -713,6 +716,7 @@ group: 0, binding: 2, )), + location: None, ty: 17, init: None, ), @@ -723,6 +727,7 @@ group: 0, binding: 3, )), + location: None, ty: 21, init: None, ), @@ -730,6 +735,7 @@ name: Some("val"), space: WorkGroup, binding: None, + location: None, ty: 1, init: None, ), diff --git a/tests/out/ir/collatz.ron b/tests/out/ir/collatz.ron index 00cab8e885..052545d883 100644 --- a/tests/out/ir/collatz.ron +++ b/tests/out/ir/collatz.ron @@ -84,6 +84,7 @@ group: 0, binding: 0, )), + location: None, ty: 3, init: None, ), diff --git a/tests/out/ir/shadow.ron b/tests/out/ir/shadow.ron index 8956076ef3..ab2d1ae682 100644 --- a/tests/out/ir/shadow.ron +++ b/tests/out/ir/shadow.ron @@ -612,6 +612,7 @@ group: 0, binding: 2, )), + location: None, ty: 30, init: None, ), @@ -622,6 +623,7 @@ group: 0, binding: 3, )), + location: None, ty: 31, init: None, ), @@ -632,6 +634,7 @@ group: 0, binding: 0, )), + location: None, ty: 13, init: None, ), @@ -646,6 +649,7 @@ group: 0, binding: 1, )), + location: None, ty: 20, init: None, ), @@ -653,6 +657,7 @@ name: Some("in_position_fs"), space: Private, binding: None, + location: None, ty: 4, init: None, ), @@ -660,6 +665,7 @@ name: Some("in_normal_fs"), space: Private, binding: None, + location: None, ty: 2, init: None, ), @@ -667,6 +673,7 @@ name: Some("out_color_fs"), space: Private, binding: None, + location: None, ty: 4, init: None, ), diff --git a/tests/snapshots.rs b/tests/snapshots.rs index 691c074a93..068471803c 100644 --- a/tests/snapshots.rs +++ b/tests/snapshots.rs @@ -387,6 +387,12 @@ fn write_output_hlsl( ) .unwrap(); } + naga::ShaderStage::RayGen => unimplemented!(), + naga::ShaderStage::Miss => unimplemented!(), + naga::ShaderStage::Callable => unimplemented!(), + naga::ShaderStage::ClosestHit => unimplemented!(), + naga::ShaderStage::AnyHit => unimplemented!(), + naga::ShaderStage::Intersection => unimplemented!(), } }