nordic-dev.net/vulkano
nordic-dev.net/vulkano
2
0
Fork 0
mirror of https://github.com/vulkano-rs/vulkano.git synced 2024-11-21 22:34:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

ValidationError-ify ShaderModule (#2268)

Browse Source 
* ValidationError-ify `ShaderModule`

* Typo

* Remove leftover comments

* slice, not Iterator

* Update vulkano/src/shader/mod.rs

Co-authored-by: marc0246 <40955683+marc0246@users.noreply.github.com>

* Update vulkano/src/shader/mod.rs

Co-authored-by: marc0246 <40955683+marc0246@users.noreply.github.com>

---------

Co-authored-by: marc0246 <40955683+marc0246@users.noreply.github.com>
This commit is contained in:
Rua 2023-07-24 22:21:05 +02:00 committed by GitHub
parent 3300f9095d
commit 17dbd1ac2c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 646 additions and 526 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
examples/src/bin/runtime-shader/main.rs
View File

@ -21,7 +21,7 @@
//
// Vulkano uses shaderc to build your shaders internally.
use std::{fs::File, io::Read, sync::Arc};
use std::{fs::File, io::Read, path::Path, sync::Arc};
use vulkano::{
buffer::{Buffer, BufferContents, BufferCreateInfo, BufferUsage},
command_buffer::{
@ -49,7 +49,7 @@ use vulkano::{
GraphicsPipeline, PipelineLayout, PipelineShaderStageCreateInfo,
},
render_pass::{Framebuffer, FramebufferCreateInfo, RenderPass, Subpass},
shader::ShaderModule,
shader::{ShaderModule, ShaderModuleCreateInfo},
swapchain::{
acquire_next_image, AcquireError, Surface, Swapchain, SwapchainCreateInfo,
SwapchainPresentInfo,
@ -178,26 +178,22 @@ fn main() {
let graphics_pipeline = {
let vs = {
let mut f = File::open("src/bin/runtime-shader/vert.spv").expect(
"can't find file `src/bin/runtime-shader/vert.spv`, this example needs to be run from \
the root of the example crate",
);
let mut v = vec![];
f.read_to_end(&mut v).unwrap();
let code = read_spirv_words_from_file("src/bin/runtime-shader/vert.spv");
// Create a ShaderModule on a device the same Shader::load does it.
// NOTE: You will have to verify correctness of the data by yourself!
let module = unsafe { ShaderModule::from_bytes(device.clone(), &v).unwrap() };
let module = unsafe {
ShaderModule::new(device.clone(), ShaderModuleCreateInfo::new(&code)).unwrap()
};
module.entry_point("main").unwrap()
};
let fs = {
let mut f = File::open("src/bin/runtime-shader/frag.spv")
.expect("can't find file `src/bin/runtime-shader/frag.spv`");
let mut v = vec![];
f.read_to_end(&mut v).unwrap();
let code = read_spirv_words_from_file("src/bin/runtime-shader/frag.spv");
let module = unsafe { ShaderModule::from_bytes(device.clone(), &v).unwrap() };
let module = unsafe {
ShaderModule::new(device.clone(), ShaderModuleCreateInfo::new(&code)).unwrap()
};
module.entry_point("main").unwrap()
};
@ -427,3 +423,32 @@ fn window_size_dependent_setup(
})
.collect::<Vec<_>>()
}
fn read_spirv_words_from_file(path: impl AsRef<Path>) -> Vec<u32> {
// Read the file.
let path = path.as_ref();
let mut bytes = vec![];
let mut file = File::open(path).unwrap_or_else(|err| {
panic!(
"can't open file `{}`: {}.\n\
Note: this example needs to be run from the root of the example crate",
path.display(),
err,
)
});
file.read_to_end(&mut bytes).unwrap();
// Convert the bytes to words.
// SPIR-V is defined to be always little-endian, so this may need an endianness conversion.
assert!(
bytes.len() % 4 == 0,
"file `{}` does not contain a whole number of SPIR-V words",
path.display(),
);
// TODO: Use `slice::array_chunks` once it's stable.
bytes
.chunks_exact(4)
.map(|chunk| u32::from_le_bytes(chunk.try_into().unwrap()))
.collect()
}

8
vulkano-shaders/src/codegen.rs
View File

@ -275,20 +275,20 @@ pub(super) fn reflect(
device: ::std::sync::Arc<::vulkano::device::Device>,
) -> ::std::result::Result<
::std::sync::Arc<::vulkano::shader::ShaderModule>,
::vulkano::shader::ShaderModuleCreationError,
::vulkano::Validated<::vulkano::VulkanError>,
> {
let _bytes = ( #( #include_bytes ),* );
static WORDS: &[u32] = &[ #( #words ),* ];
unsafe {
::vulkano::shader::ShaderModule::from_words_with_data(
::vulkano::shader::ShaderModule::new_with_data(
device,
WORDS,
::vulkano::shader::ShaderModuleCreateInfo::new(&WORDS),
[ #( #entry_points ),* ],
#spirv_version,
[ #( #spirv_capabilities ),* ],
[ #( #spirv_extensions ),* ],
[ #( #entry_points ),* ],
)
}
}

15
vulkano-shaders/src/lib.rs
View File

@ -31,10 +31,10 @@
//!
//! The macro generates the following items of interest:
//!
//! - The `load` constructor. This function takes an `Arc<Device>`, calls
//! [`ShaderModule::from_words_with_data`] with the passed-in device and the shader data provided
//! via the macro, and returns `Result<Arc<ShaderModule>, ShaderModuleCreationError>`.
//! Before doing so, it loops through every capability instruction in the shader data,
//! - The `load` constructor. This function takes an `Arc<Device>`, constructs a
//! [`ShaderModule`] with the passed-in device and the shader data provided
//! via the macro, and returns `Result<Arc<ShaderModule>, Validated<VulkanError>>`.
//! Before doing so, it checks every capability instruction in the shader data,
//! verifying that the passed-in `Device` has the appropriate features enabled.
//! - If the `shaders` option is used, then instead of one `load` constructor, there is one for
//! each shader. They are named based on the provided names, `load_first`, `load_second` etc.
@ -50,8 +50,7 @@
//! ```
//! # fn main() {}
//! # use std::sync::Arc;
//! # use vulkano::shader::{ShaderModuleCreationError, ShaderModule};
//! # use vulkano::device::Device;
//! # use vulkano::{device::Device, shader::ShaderModule, Validated, VulkanError};
//! #
//! # mod vs {
//! # vulkano_shaders::shader!{
@ -75,7 +74,7 @@
//! }
//!
//! impl Shaders {
//! pub fn load(device: Arc<Device>) -> Result<Self, ShaderModuleCreationError> {
//! pub fn load(device: Arc<Device>) -> Result<Self, Validated<VulkanError>> {
//! Ok(Self {
//! vs: vs::load(device)?,
//! })
@ -208,7 +207,7 @@
//!
//! [`cargo-env-vars`]: https://doc.rust-lang.org/cargo/reference/environment-variables.html
//! [cargo-expand]: https://github.com/dtolnay/cargo-expand
//! [`ShaderModule::from_words_with_data`]: vulkano::shader::ShaderModule::from_words_with_data
//! [`ShaderModule`]: vulkano::shader::ShaderModule
//! [pipeline]: vulkano::pipeline
//! [`set_target_env`]: shaderc::CompileOptions::set_target_env
//! [`set_target_spirv`]: shaderc::CompileOptions::set_target_spirv

37
vulkano/autogen/extensions.rs
View File

@ -7,13 +7,13 @@
// notice may not be copied, modified, or distributed except
// according to those terms.
use super::{write_file, IndexMap, VkRegistryData};
use super::{write_file, IndexMap, RequiresOneOf, VkRegistryData};
use heck::ToSnakeCase;
use once_cell::sync::Lazy;
use proc_macro2::{Ident, Literal, TokenStream};
use quote::{format_ident, quote};
use regex::Regex;
use std::{cmp::min, fmt::Write as _, ops::BitOrAssign};
use std::fmt::Write as _;
use vk_parse::Extension;
// This is not included in vk.xml, so it's added here manually
@ -49,35 +49,6 @@ struct ExtensionsMember {
status: Option<ExtensionStatus>,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct RequiresOneOf {
pub api_version: Option<(u32, u32)>,
pub device_extensions: Vec<String>,
pub instance_extensions: Vec<String>,
}
impl BitOrAssign<&Self> for RequiresOneOf {
fn bitor_assign(&mut self, rhs: &Self) {
self.api_version = match (self.api_version, rhs.api_version) {
(None, None) => None,
(None, Some(x)) | (Some(x), None) => Some(x),
(Some(lhs), Some(rhs)) => Some(min(lhs, rhs)),
};
for rhs_ext in &rhs.device_extensions {
if !self.device_extensions.contains(rhs_ext) {
self.device_extensions.push(rhs_ext.to_owned());
}
}
for rhs_ext in &rhs.instance_extensions {
if !self.instance_extensions.contains(rhs_ext) {
self.instance_extensions.push(rhs_ext.to_owned());
}
}
}
}
#[derive(Clone, Debug)]
enum ExtensionStatus {
PromotedTo(Requires),
@ -129,6 +100,7 @@ fn device_extensions_output(members: &[ExtensionsMember]) -> TokenStream {
api_version,
device_extensions,
instance_extensions,
features: _,
}| {
(device_extensions.is_empty()
&& (api_version.is_some() || !instance_extensions.is_empty()))
@ -204,6 +176,7 @@ fn device_extensions_output(members: &[ExtensionsMember]) -> TokenStream {
api_version,
device_extensions,
instance_extensions: _,
features: _,
}| {
(!device_extensions.is_empty()).then(|| {
let condition_items = api_version
@ -310,6 +283,7 @@ fn instance_extensions_output(members: &[ExtensionsMember]) -> TokenStream {
api_version,
device_extensions: _,
instance_extensions,
features: _,
}| {
api_version.filter(|_| instance_extensions.is_empty()).map(|(major, minor)| {
let version = format_ident!("V{}_{}", major, minor);
@ -363,6 +337,7 @@ fn instance_extensions_output(members: &[ExtensionsMember]) -> TokenStream {
api_version,
device_extensions: _,
instance_extensions,
features: _,
}| {
(!instance_extensions.is_empty()).then(|| {
let condition_items = api_version

3
vulkano/autogen/formats.rs
View File

@ -7,7 +7,7 @@
// notice may not be copied, modified, or distributed except
// according to those terms.
use super::{extensions::RequiresOneOf, write_file, IndexMap, VkRegistryData};
use super::{write_file, IndexMap, RequiresOneOf, VkRegistryData};
use heck::ToSnakeCase;
use once_cell::sync::Lazy;
use proc_macro2::{Ident, Literal, TokenStream};
@ -271,6 +271,7 @@ fn formats_output(members: &[FormatMember]) -> TokenStream {
api_version,
device_extensions,
instance_extensions,
features: _,
}| {
let condition_items = (api_version.iter().map(|(major, minor)| {
let version = format_ident!("V{}_{}", major, minor);

54
vulkano/autogen/mod.rs
View File

@ -12,10 +12,12 @@ use ahash::HashMap;
use once_cell::sync::Lazy;
use regex::Regex;
use std::{
cmp::min,
env,
fmt::Display,
fs::File,
io::{BufWriter, Write},
ops::BitOrAssign,
path::Path,
process::Command,
};
@ -451,3 +453,55 @@ fn suffix_key(name: &str) -> u32 {
0
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct RequiresOneOf {
pub api_version: Option<(u32, u32)>,
pub device_extensions: Vec<String>,
pub instance_extensions: Vec<String>,
pub features: Vec<String>,
}
impl RequiresOneOf {
pub fn is_empty(&self) -> bool {
let Self {
api_version,
device_extensions,
instance_extensions,
features,
} = self;
api_version.is_none()
&& device_extensions.is_empty()
&& instance_extensions.is_empty()
&& features.is_empty()
}
}
impl BitOrAssign<&Self> for RequiresOneOf {
fn bitor_assign(&mut self, rhs: &Self) {
self.api_version = match (self.api_version, rhs.api_version) {
(None, None) => None,
(None, Some(x)) | (Some(x), None) => Some(x),
(Some(lhs), Some(rhs)) => Some(min(lhs, rhs)),
};
for rhs in &rhs.device_extensions {
if !self.device_extensions.contains(rhs) {
self.device_extensions.push(rhs.to_owned());
}
}
for rhs in &rhs.instance_extensions {
if !self.instance_extensions.contains(rhs) {
self.instance_extensions.push(rhs.to_owned());
}
}
for rhs in &rhs.features {
if !self.features.contains(rhs) {
self.features.push(rhs.to_owned());
}
}
}
}

299
vulkano/autogen/spirv_reqs.rs
View File

@ -9,12 +9,12 @@
use super::{
spirv_grammar::{SpirvGrammar, SpirvKindEnumerant},
write_file, IndexMap, VkRegistryData,
write_file, IndexMap, RequiresOneOf, VkRegistryData,
};
use heck::ToSnakeCase;
use indexmap::map::Entry;
use once_cell::sync::Lazy;
use proc_macro2::{Ident, TokenStream};
use proc_macro2::TokenStream;
use quote::{format_ident, quote};
use regex::Regex;
use vk_parse::SpirvExtOrCap;
@ -46,103 +46,202 @@ pub fn write(vk_data: &VkRegistryData, grammar: &SpirvGrammar) {
);
}
#[derive(Clone, Debug)]
struct SpirvReqsMember {
name: String,
enables: Vec<(Enable, String)>,
requires_one_of: RequiresOneOf,
requires_properties: Vec<RequiresProperty>,
}
#[derive(Clone, Debug, PartialEq)]
enum Enable {
Core((String, String)),
Extension(Ident),
Feature(Ident),
Property((Ident, PropertyValue)),
struct RequiresProperty {
name: String,
value: PropertyValue,
}
#[derive(Clone, Debug, PartialEq)]
enum PropertyValue {
Bool,
BoolMember(Vec<Ident>),
FlagsIntersects {
path: TokenStream,
ty: String,
flag: String,
},
}
fn spirv_reqs_output(members: &[SpirvReqsMember], extension: bool) -> TokenStream {
let items = members.iter().map(|SpirvReqsMember { name, enables }| {
let arm = if extension {
fn spirv_reqs_output(members: &[SpirvReqsMember], is_extension: bool) -> TokenStream {
let (item_type, fn_def, not_supported_vuid, item_vuid) = if is_extension {
(
"extension",
quote! { validate_spirv_extension(device: &Device, item: &str) },
"VUID-VkShaderModuleCreateInfo-pCode-08739",
"VUID-VkShaderModuleCreateInfo-pCode-08740",
)
} else {
(
"capability",
quote! { validate_spirv_capability(device: &Device, item: Capability) },
"VUID-VkShaderModuleCreateInfo-pCode-08741",
"VUID-VkShaderModuleCreateInfo-pCode-08742",
)
};
let items = members.iter().map(
|SpirvReqsMember {
name,
requires_one_of,
requires_properties,
}| {
let arm = if is_extension {
quote! { #name }
} else {
let name = format_ident!("{}", name);
quote! { Capability::#name }
};
if enables.is_empty() {
quote! {
#arm => (),
}
} else {
let enables_items = enables.iter().map(|(enable, _description)| match enable {
Enable::Core((major, minor)) => {
if !requires_one_of.is_empty() {
let &RequiresOneOf {
api_version,
ref device_extensions,
instance_extensions: _,
ref features,
} = requires_one_of;
let condition_items = (api_version.iter().map(|version| {
let version = format_ident!("V{}_{}", version.0, version.1);
quote! { api_version >= crate::Version::#version }
}))
.chain(device_extensions.iter().map(|name| {
let ident = format_ident!("{}", name);
quote! { device_extensions.#ident }
}))
.chain(features.iter().map(|name| {
let ident = format_ident!("{}", name);
quote! { features.#ident }
}));
let requires_one_of_items = (api_version.iter().map(|(major, minor)| {
let version = format_ident!("V{}_{}", major, minor);
quote! {
device.api_version() >= Version::#version
crate::RequiresAllOf(&[
crate::Requires::APIVersion(crate::Version::#version),
]),
}
}))
.chain(device_extensions.iter().map(|name| {
quote! {
crate::RequiresAllOf(&[
crate::Requires::DeviceExtension(#name),
]),
}
}))
.chain(features.iter().map(|name| {
quote! {
crate::RequiresAllOf(&[
crate::Requires::Feature(#name),
]),
}
}));
let problem = format!("uses the SPIR-V {} `{}`", item_type, name);
quote! {
#arm => {
if !(#(#condition_items)||*) {
return Err(Box::new(crate::ValidationError {
problem: #problem.into(),
requires_one_of: crate::RequiresOneOf(&[
#(#requires_one_of_items)*
]),
vuids: &[#item_vuid],
..Default::default()
}));
}
Enable::Extension(extension) => quote! {
device.enabled_extensions().#extension
},
Enable::Feature(feature) => quote! {
device.enabled_features().#feature
},
Enable::Property((name, value)) => {
}
} else if !requires_properties.is_empty() {
let condition_items = requires_properties.iter().map(
|RequiresProperty { name, value }| {
let name = format_ident!("{}", name);
let access = match value {
PropertyValue::Bool => quote! {},
PropertyValue::BoolMember(member) => quote! {
.map(|x| x.intersects(#(#member)::*))
},
PropertyValue::FlagsIntersects { path, ty, flag } => {
let ty = format_ident!("{}", ty);
let flag = format_ident!("{}", flag);
quote! {
.map(|x| x.intersects(#path :: #ty :: #flag))
}
}
};
quote! {
device.physical_device().properties().#name #access .unwrap_or(false)
}
},
);
let problem = {
let requirements_items: Vec<_> = requires_properties
.iter()
.map(|RequiresProperty { name, value }| match value {
PropertyValue::Bool => format!("`{}` must be `true`", name),
PropertyValue::FlagsIntersects { path: _, ty, flag } => {
format!("`{}` must contain `{}::{}`", name, ty, flag)
}
});
})
.collect();
let description_items = enables.iter().map(|(_enable, description)| description);
format!(
"uses the SPIR-V {} `{}`, but the device properties do not meet at \
least one of the requirements ({})",
item_type,
name,
requirements_items.join(" or ")
)
};
quote! {
#arm => {
if !(#(#enables_items)||*) {
return Err(ShaderSupportError::RequirementsNotMet(&[
#(#description_items),*
]));
if !(#(#condition_items)||*) {
return Err(Box::new(crate::ValidationError {
problem: #problem.into(),
vuids: &[#item_vuid],
..Default::default()
}));
}
},
}
}
});
if extension {
quote! {
fn check_spirv_extension(device: &Device, extension: &str) -> Result<(), ShaderSupportError> {
match extension {
#(#items)*
_ => return Err(ShaderSupportError::NotSupportedByVulkan),
}
Ok(())
}
}
} else {
quote! {
fn check_spirv_capability(device: &Device, capability: Capability) -> Result<(), ShaderSupportError> {
match capability {
#arm => (),
}
}
},
);
let problem = format!(
"uses the SPIR-V {} `{{item:?}}`, which is not supported by Vulkan",
item_type,
);
quote! {
fn #fn_def -> Result<(), Box<ValidationError>> {
#[allow(unused_variables)]
let api_version = device.api_version();
#[allow(unused_variables)]
let device_extensions = device.enabled_extensions();
#[allow(unused_variables)]
let features = device.enabled_features();
#[allow(unused_variables)]
let properties = device.physical_device().properties();
match item {
#(#items)*
_ => return Err(ShaderSupportError::NotSupportedByVulkan),
_ => {
return Err(Box::new(crate::ValidationError {
problem: format!(#problem).into(),
vuids: &[#not_supported_vuid],
..Default::default()
}));
}
}
Ok(())
}
}
}
}
fn spirv_capabilities_members(
capabilities: &[&SpirvExtOrCap],
@ -151,8 +250,7 @@ fn spirv_capabilities_members(
let mut members: IndexMap<String, SpirvReqsMember> = IndexMap::default();
for ext_or_cap in capabilities {
let mut enables: Vec<_> = ext_or_cap.enables.iter().filter_map(make_enable).collect();
enables.dedup();
let (requires_one_of, requires_properties) = make_requires(&ext_or_cap.enables);
// Find the capability in the list of enumerants, then go backwards through the list to find
// the first enumerant with the same value.
@ -181,12 +279,15 @@ fn spirv_capabilities_members(
match members.entry(name.clone()) {
Entry::Occupied(entry) => {
entry.into_mut().enables.extend(enables);
let member = entry.into_mut();
member.requires_one_of |= &requires_one_of;
member.requires_properties.extend(requires_properties);
}
Entry::Vacant(entry) => {
entry.insert(SpirvReqsMember {
name: name.clone(),
enables,
requires_one_of,
requires_properties,
});
}
}
@ -199,77 +300,75 @@ fn spirv_extensions_members(extensions: &[&SpirvExtOrCap]) -> Vec<SpirvReqsMembe
extensions
.iter()
.map(|ext_or_cap| {
let enables: Vec<_> = ext_or_cap.enables.iter().filter_map(make_enable).collect();
let (requires_one_of, requires_properties) = make_requires(&ext_or_cap.enables);
SpirvReqsMember {
name: ext_or_cap.name.clone(),
enables,
requires_one_of,
requires_properties,
}
})
.collect()
}
fn make_enable(enable: &vk_parse::Enable) -> Option<(Enable, String)> {
fn make_requires(enables: &[vk_parse::Enable]) -> (RequiresOneOf, Vec<RequiresProperty>) {
static VK_API_VERSION: Lazy<Regex> =
Lazy::new(|| Regex::new(r"^VK_(?:API_)?VERSION_(\d+)_(\d+)$").unwrap());
static BIT: Lazy<Regex> = Lazy::new(|| Regex::new(r"_BIT(?:_NV)?$").unwrap());
if matches!(enable, vk_parse::Enable::Version(version) if version == "VK_VERSION_1_0") {
return None;
}
let mut requires_one_of = RequiresOneOf::default();
let mut requires_properties = vec![];
Some(match enable {
for enable in enables {
match enable {
vk_parse::Enable::Version(version) => {
if version != "VK_VERSION_1_0" {
let captures = VK_API_VERSION.captures(version).unwrap();
let major = captures.get(1).unwrap().as_str();
let minor = captures.get(1).unwrap().as_str();
(
Enable::Core((major.parse().unwrap(), minor.parse().unwrap())),
format!("Vulkan API version {}.{}", major, minor),
)
requires_one_of.api_version =
Some((major.parse().unwrap(), minor.parse().unwrap()));
}
}
vk_parse::Enable::Extension(extension) => {
let extension_name = extension.strip_prefix("VK_").unwrap().to_snake_case();
(
Enable::Extension(format_ident!("{}", extension_name)),
format!("device extension `{}`", extension_name),
)
requires_one_of
.device_extensions
.push(extension.strip_prefix("VK_").unwrap().to_snake_case());
}
vk_parse::Enable::Feature(feature) => {
let feature_name = feature.feature.to_snake_case();
(
Enable::Feature(format_ident!("{}", feature_name)),
format!("feature `{}`", feature_name),
)
requires_one_of
.features
.push(feature.feature.to_snake_case());
}
vk_parse::Enable::Property(property) => {
let property_name = property.member.to_snake_case();
let name = property.member.to_snake_case();
let (value, description) = if property.value == "VK_TRUE" {
(PropertyValue::Bool, format!("property `{}`", property_name))
let value = if property.value == "VK_TRUE" {
PropertyValue::Bool
} else if let Some(member) = property.value.strip_prefix("VK_SUBGROUP_FEATURE_") {
let member = BIT.replace(member, "");
(
PropertyValue::BoolMember(
["crate", "device", "physical", "SubgroupFeatures", &member]
.into_iter()
.map(|s| format_ident!("{}", s))
.collect(),
),
format!("property `{}.{}`", property_name, member),
)
PropertyValue::FlagsIntersects {
path: quote! { crate::device::physical },
ty: "SubgroupFeatures".to_string(),
flag: BIT.replace(member, "").to_string(),
}
} else {
unimplemented!()
};
(
Enable::Property((format_ident!("{}", property_name), value)),
description,
)
requires_properties.push(RequiresProperty { name, value });
}
_ => unimplemented!(),
})
}
}
assert!(requires_one_of.is_empty() || requires_properties.is_empty());
requires_one_of.device_extensions.sort_unstable();
requires_one_of.device_extensions.dedup();
requires_one_of.features.sort_unstable();
requires_one_of.features.dedup();
(requires_one_of, requires_properties)
}

16
vulkano/src/pipeline/cache.rs
View File

@ -400,7 +400,7 @@ mod tests {
layout::PipelineDescriptorSetLayoutCreateInfo, ComputePipeline, PipelineLayout,
PipelineShaderStageCreateInfo,
},
shader::ShaderModule,
shader::{ShaderModule, ShaderModuleCreateInfo},
};
#[test]
@ -431,7 +431,8 @@ mod tests {
196611, 2, 450, 262149, 4, 1852399981, 0, 131091, 2, 196641, 3, 2, 327734, 2, 4, 0,
3, 131320, 5, 65789, 65592,
];
let module = ShaderModule::from_words(device.clone(), &MODULE).unwrap();
let module =
ShaderModule::new(device.clone(), ShaderModuleCreateInfo::new(&MODULE)).unwrap();
module.entry_point("main").unwrap()
};
@ -477,7 +478,9 @@ mod tests {
1, 196611, 2, 450, 262149, 4, 1852399981, 0, 131091, 2, 196641, 3, 2, 327734,
2, 4, 0, 3, 131320, 5, 65789, 65592,
];
let module = ShaderModule::from_words(device.clone(), &MODULE).unwrap();
let module =
ShaderModule::new(device.clone(), ShaderModuleCreateInfo::new(&MODULE))
.unwrap();
module.entry_point("main").unwrap()
};
@ -518,7 +521,9 @@ mod tests {
327734, 2, 4, 0, 3, 131320, 5, 262203, 7, 8, 7, 327745, 13, 14, 11, 12, 262205,
6, 15, 14, 196670, 8, 15, 65789, 65592,
];
let module = ShaderModule::from_words(device.clone(), &MODULE).unwrap();
let module =
ShaderModule::new(device.clone(), ShaderModuleCreateInfo::new(&MODULE))
.unwrap();
module.entry_point("main").unwrap()
};
@ -565,7 +570,8 @@ mod tests {
196611, 2, 450, 262149, 4, 1852399981, 0, 131091, 2, 196641, 3, 2, 327734, 2, 4, 0,
3, 131320, 5, 65789, 65592,
];
let module = ShaderModule::from_words(device.clone(), &MODULE).unwrap();
let module =
ShaderModule::new(device.clone(), ShaderModuleCreateInfo::new(&MODULE)).unwrap();
module.entry_point("main").unwrap()
};

5
vulkano/src/pipeline/compute.rs
View File

@ -394,7 +394,7 @@ mod tests {
ComputePipeline, Pipeline, PipelineBindPoint, PipelineLayout,
PipelineShaderStageCreateInfo,
},
shader::ShaderModule,
shader::{ShaderModule, ShaderModuleCreateInfo},
sync::{now, GpuFuture},
};
@ -435,7 +435,8 @@ mod tests {
8, 9, 2, 262187, 6, 10, 0, 262194, 6, 11, 3735928559, 262176, 12, 2, 6, 327734, 2,
4, 0, 3, 131320, 5, 327745, 12, 13, 9, 10, 196670, 13, 11, 65789, 65592,
];
let module = ShaderModule::from_words(device.clone(), &MODULE).unwrap();
let module =
ShaderModule::new(device.clone(), ShaderModuleCreateInfo::new(&MODULE)).unwrap();
module.entry_point("main").unwrap()
};

612
vulkano/src/shader/mod.rs
View File

@ -139,16 +139,18 @@ use crate::{
instance::InstanceOwnedDebugWrapper,
macros::{impl_id_counter, vulkan_bitflags_enum},
pipeline::{graphics::input_assembly::PrimitiveTopology, layout::PushConstantRange},
shader::spirv::{Capability, Spirv, SpirvError},
shader::spirv::{Capability, Spirv},
sync::PipelineStages,
OomError, Version, VulkanError, VulkanObject,
Requires, RequiresAllOf, RequiresOneOf, Validated, ValidationError, Version, VulkanError,
VulkanObject,
};
use ahash::{HashMap, HashSet};
use bytemuck::bytes_of;
use half::f16;
use spirv::ExecutionModel;
use std::{
borrow::Cow,
collections::hash_map::Entry,
error::Error,
fmt::{Display, Error as FmtError, Formatter},
mem::{align_of, discriminant, size_of, size_of_val, MaybeUninit},
num::NonZeroU64,
ptr,
@ -158,10 +160,6 @@ use std::{
pub mod reflect;
pub mod spirv;
use bytemuck::bytes_of;
use half::f16;
use spirv::ExecutionModel;
// Generated by build.rs
include!(concat!(env!("OUT_DIR"), "/spirv_reqs.rs"));
@ -176,95 +174,95 @@ pub struct ShaderModule {
}
impl ShaderModule {
/// Builds a new shader module from SPIR-V 32-bit words. The shader code is parsed and the
/// necessary information is extracted from it.
/// Creates a new shader module.
///
/// # Safety
///
/// - The SPIR-V code is not validated beyond the minimum needed to extract the information.
/// - The SPIR-V code in `create_info.code` must be valid.
#[inline]
pub unsafe fn from_words(
pub unsafe fn new(
device: Arc<Device>,
words: &[u32],
) -> Result<Arc<ShaderModule>, ShaderModuleCreationError> {
let spirv = Spirv::new(words)?;
create_info: ShaderModuleCreateInfo<'_>,
) -> Result<Arc<ShaderModule>, Validated<VulkanError>> {
let spirv = Spirv::new(create_info.code).map_err(|err| {
Box::new(ValidationError {
context: "create_info.code".into(),
problem: format!("error while parsing: {}", err).into(),
..Default::default()
})
})?;
Self::from_words_with_data(
Self::new_with_data(
device,
words,
create_info,
reflect::entry_points(&spirv),
spirv.version(),
reflect::spirv_capabilities(&spirv),
reflect::spirv_extensions(&spirv),
reflect::entry_points(&spirv),
)
}
/// As `from_words`, but takes a slice of bytes.
///
/// # Panics
///
/// - Panics if `bytes` is not aligned to 4.
/// - Panics if the length of `bytes` is not a multiple of 4.
#[inline]
pub unsafe fn from_bytes(
// This is public only for vulkano-shaders, do not use otherwise.
#[doc(hidden)]
pub unsafe fn new_with_data<'a>(
device: Arc<Device>,
bytes: &[u8],
) -> Result<Arc<ShaderModule>, ShaderModuleCreationError> {
assert!(bytes.as_ptr() as usize % align_of::<u32>() == 0);
assert!(bytes.len() % size_of::<u32>() == 0);
Self::from_words(
device,
std::slice::from_raw_parts(bytes.as_ptr() as *const _, bytes.len() / size_of::<u32>()),
)
}
/// As `from_words`, but does not parse the code. Instead, you must provide the needed
/// information yourself. This can be useful if you've already done parsing yourself and
/// want to prevent Vulkano from doing it a second time.
///
/// # Safety
///
/// - The SPIR-V code is not validated at all.
/// - The provided information must match what the SPIR-V code contains.
pub unsafe fn from_words_with_data<'a>(
device: Arc<Device>,
words: &[u32],
create_info: ShaderModuleCreateInfo<'_>,
entry_points: impl IntoIterator<Item = EntryPointInfo>,
spirv_version: Version,
spirv_capabilities: impl IntoIterator<Item = &'a Capability>,
spirv_extensions: impl IntoIterator<Item = &'a str>,
) -> Result<Arc<ShaderModule>, Validated<VulkanError>> {
Self::validate_new(
&device,
&create_info,
spirv_version,
spirv_capabilities,
spirv_extensions,
)?;
Ok(Self::new_with_data_unchecked(
device,
create_info,
entry_points,
)?)
}
fn validate_new<'a>(
device: &Device,
create_info: &ShaderModuleCreateInfo<'_>,
spirv_version: Version,
spirv_capabilities: impl IntoIterator<Item = &'a Capability>,
spirv_extensions: impl IntoIterator<Item = &'a str>,
) -> Result<(), Box<ValidationError>> {
create_info
.validate(device, spirv_version, spirv_capabilities, spirv_extensions)
.map_err(|err| err.add_context("create_info"))?;
Ok(())
}
#[cfg_attr(not(feature = "document_unchecked"), doc(hidden))]
pub unsafe fn new_unchecked(
device: Arc<Device>,
create_info: ShaderModuleCreateInfo<'_>,
) -> Result<Arc<ShaderModule>, VulkanError> {
let spirv = Spirv::new(create_info.code).unwrap();
Self::new_with_data_unchecked(device, create_info, reflect::entry_points(&spirv))
}
unsafe fn new_with_data_unchecked(
device: Arc<Device>,
create_info: ShaderModuleCreateInfo<'_>,
entry_points: impl IntoIterator<Item = EntryPointInfo>,
) -> Result<Arc<ShaderModule>, ShaderModuleCreationError> {
if let Err(reason) = check_spirv_version(&device, spirv_version) {
return Err(ShaderModuleCreationError::SpirvVersionNotSupported {
version: spirv_version,
reason,
});
}
for &capability in spirv_capabilities {
if let Err(reason) = check_spirv_capability(&device, capability) {
return Err(ShaderModuleCreationError::SpirvCapabilityNotSupported {
capability,
reason,
});
}
}
for extension in spirv_extensions {
if let Err(reason) = check_spirv_extension(&device, extension) {
return Err(ShaderModuleCreationError::SpirvExtensionNotSupported {
extension: extension.to_owned(),
reason,
});
}
}
) -> Result<Arc<ShaderModule>, VulkanError> {
let &ShaderModuleCreateInfo { code, _ne: _ } = &create_info;
let handle = {
let infos = ash::vk::ShaderModuleCreateInfo {
flags: ash::vk::ShaderModuleCreateFlags::empty(),
code_size: size_of_val(words),
p_code: words.as_ptr(),
code_size: size_of_val(code),
p_code: code.as_ptr(),
..Default::default()
};
@ -281,6 +279,38 @@ impl ShaderModule {
output.assume_init()
};
Ok(Self::from_handle_with_data(
device,
handle,
create_info,
entry_points,
))
}
/// Creates a new `ShaderModule` from a raw object handle.
///
/// # Safety
///
/// - `handle` must be a valid Vulkan object handle created from `device`.
/// - `create_info` must match the info used to create the object.
pub unsafe fn from_handle(
device: Arc<Device>,
handle: ash::vk::ShaderModule,
create_info: ShaderModuleCreateInfo<'_>,
) -> Arc<ShaderModule> {
let spirv = Spirv::new(create_info.code).unwrap();
Self::from_handle_with_data(device, handle, create_info, reflect::entry_points(&spirv))
}
unsafe fn from_handle_with_data(
device: Arc<Device>,
handle: ash::vk::ShaderModule,
create_info: ShaderModuleCreateInfo<'_>,
entry_points: impl IntoIterator<Item = EntryPointInfo>,
) -> Arc<ShaderModule> {
let ShaderModuleCreateInfo { code: _, _ne: _ } = create_info;
let mut entry_point_map: HashMap<String, HashMap<ExecutionModel, usize>> =
HashMap::default();
let entry_point_infos: Vec<_> = entry_points
@ -295,39 +325,54 @@ impl ShaderModule {
})
.collect();
Ok(Arc::new(ShaderModule {
Arc::new(ShaderModule {
handle,
device: InstanceOwnedDebugWrapper(device),
id: Self::next_id(),
entry_point_map,
entry_point_infos,
}))
})
}
/// As `from_words_with_data`, but takes a slice of bytes.
/// Builds a new shader module from SPIR-V 32-bit words. The shader code is parsed and the
/// necessary information is extracted from it.
///
/// # Safety
///
/// - The SPIR-V code is not validated beyond the minimum needed to extract the information.
#[deprecated(since = "0.34.0", note = "use `new` instead")]
#[inline]
pub unsafe fn from_words(
device: Arc<Device>,
words: &[u32],
) -> Result<Arc<ShaderModule>, Validated<VulkanError>> {
Self::new(device, ShaderModuleCreateInfo::new(words))
}
/// As `from_words`, but takes a slice of bytes.
///
/// # Panics
///
/// - Panics if `bytes` is not aligned to 4.
/// - Panics if the length of `bytes` is not a multiple of 4.
pub unsafe fn from_bytes_with_data<'a>(
#[deprecated(
since = "0.34.0",
note = "read little-endian words yourself, and then use `new` instead"
)]
#[inline]
pub unsafe fn from_bytes(
device: Arc<Device>,
bytes: &[u8],
spirv_version: Version,
spirv_capabilities: impl IntoIterator<Item = &'a Capability>,
spirv_extensions: impl IntoIterator<Item = &'a str>,
entry_points: impl IntoIterator<Item = EntryPointInfo>,
) -> Result<Arc<ShaderModule>, ShaderModuleCreationError> {
) -> Result<Arc<ShaderModule>, Validated<VulkanError>> {
assert!(bytes.as_ptr() as usize % align_of::<u32>() == 0);
assert!(bytes.len() % size_of::<u32>() == 0);
Self::from_words_with_data(
Self::new(
device,
std::slice::from_raw_parts(bytes.as_ptr() as *const _, bytes.len() / size_of::<u32>()),
spirv_version,
spirv_capabilities,
spirv_extensions,
entry_points,
ShaderModuleCreateInfo::new(std::slice::from_raw_parts(
bytes.as_ptr() as *const _,
bytes.len() / size_of::<u32>(),
)),
)
}
@ -393,6 +438,113 @@ unsafe impl DeviceOwned for ShaderModule {
impl_id_counter!(ShaderModule);
pub struct ShaderModuleCreateInfo<'a> {
/// The SPIR-V code, in the form of 32-bit words.
///
/// There is no default value.
pub code: &'a [u32],
pub _ne: crate::NonExhaustive,
}
impl<'a> ShaderModuleCreateInfo<'a> {
/// Returns a `ShaderModuleCreateInfo` with the specified `code`.
#[inline]
pub fn new(code: &'a [u32]) -> Self {
Self {
code,
_ne: crate::NonExhaustive(()),
}
}
pub(crate) fn validate<'b>(
&self,
device: &Device,
mut spirv_version: Version,
spirv_capabilities: impl IntoIterator<Item = &'b Capability>,
spirv_extensions: impl IntoIterator<Item = &'b str>,
) -> Result<(), Box<ValidationError>> {
let &Self { code, _ne: _ } = self;
if code.is_empty() {
return Err(Box::new(ValidationError {
context: "code".into(),
problem: "is empty".into(),
vuids: &["VUID-VkShaderModuleCreateInfo-codeSize-01085"],
..Default::default()
}));
}
{
spirv_version.patch = 0; // Ignore the patch version
match spirv_version {
Version::V1_0 => None,
Version::V1_1 | Version::V1_2 | Version::V1_3 => {
(!(device.api_version() >= Version::V1_1)).then_some(RequiresOneOf(&[
RequiresAllOf(&[Requires::APIVersion(Version::V1_1)]),
]))
}
Version::V1_4 => (!(device.api_version() >= Version::V1_2
|| device.enabled_extensions().khr_spirv_1_4))
.then_some(RequiresOneOf(&[
RequiresAllOf(&[Requires::APIVersion(Version::V1_2)]),
RequiresAllOf(&[Requires::DeviceExtension("khr_spirv_1_4")]),
])),
Version::V1_5 => {
(!(device.api_version() >= Version::V1_2)).then_some(RequiresOneOf(&[
RequiresAllOf(&[Requires::APIVersion(Version::V1_2)]),
]))
}
Version::V1_6 => {
(!(device.api_version() >= Version::V1_3)).then_some(RequiresOneOf(&[
RequiresAllOf(&[Requires::APIVersion(Version::V1_3)]),
]))
}
_ => {
return Err(Box::new(ValidationError {
context: "code".into(),
problem: format!(
"uses SPIR-V version {}.{}, which is not supported by Vulkan",
spirv_version.major, spirv_version.minor
)
.into(),
// vuids?
..Default::default()
}));
}
}
}
.map_or(Ok(()), |requires_one_of| {
Err(Box::new(ValidationError {
context: "code".into(),
problem: format!(
"uses SPIR-V version {}.{}",
spirv_version.major, spirv_version.minor
)
.into(),
requires_one_of,
..Default::default()
}))
})?;
for &capability in spirv_capabilities {
validate_spirv_capability(device, capability).map_err(|err| err.add_context("code"))?;
}
for extension in spirv_extensions {
validate_spirv_extension(device, extension).map_err(|err| err.add_context("code"))?;
}
// VUID-VkShaderModuleCreateInfo-pCode-08736
// VUID-VkShaderModuleCreateInfo-pCode-08737
// VUID-VkShaderModuleCreateInfo-pCode-08738
// Unsafe
Ok(())
}
}
/// The information associated with a single entry point in a shader.
#[derive(Clone, Debug)]
pub struct EntryPointInfo {
@ -636,7 +788,7 @@ impl DescriptorBindingRequirements {
/// Merges `other` into `self`, so that `self` satisfies the requirements of both.
/// An error is returned if the requirements conflict.
#[inline]
pub fn merge(&mut self, other: &Self) -> Result<(), DescriptorBindingRequirementsIncompatible> {
pub fn merge(&mut self, other: &Self) -> Result<(), Box<ValidationError>> {
let Self {
descriptor_types,
descriptor_count,
@ -654,29 +806,45 @@ impl DescriptorBindingRequirements {
.iter()
.any(|ty| other.descriptor_types.contains(ty))
{
return Err(DescriptorBindingRequirementsIncompatible::DescriptorType);
return Err(Box::new(ValidationError {
problem: "the allowed descriptor types of the two descriptors do not overlap"
.into(),
..Default::default()
}));
}
if let (Some(first), Some(second)) = (*image_format, other.image_format) {
if first != second {
return Err(DescriptorBindingRequirementsIncompatible::ImageFormat);
return Err(Box::new(ValidationError {
problem: "the descriptors require different formats".into(),
..Default::default()
}));
}
}
if let (Some(first), Some(second)) = (*image_scalar_type, other.image_scalar_type) {
if first != second {
return Err(DescriptorBindingRequirementsIncompatible::ImageScalarType);
return Err(Box::new(ValidationError {
problem: "the descriptors require different scalar types".into(),
..Default::default()
}));
}
}
if let (Some(first), Some(second)) = (*image_view_type, other.image_view_type) {
if first != second {
return Err(DescriptorBindingRequirementsIncompatible::ImageViewType);
return Err(Box::new(ValidationError {
problem: "the descriptors require different image view types".into(),
..Default::default()
}));
}
}
if *image_multisampled != other.image_multisampled {
return Err(DescriptorBindingRequirementsIncompatible::ImageMultisampled);
return Err(Box::new(ValidationError {
problem: "the multisampling requirements of the descriptors differ".into(),
..Default::default()
}));
}
/* Merge */
@ -896,12 +1064,12 @@ impl ShaderInterface {
///
/// Returns `Ok` if the two interfaces are compatible.
#[inline]
pub fn matches(&self, other: &ShaderInterface) -> Result<(), ShaderInterfaceMismatchError> {
pub fn matches(&self, other: &ShaderInterface) -> Result<(), Box<ValidationError>> {
if self.elements().len() != other.elements().len() {
return Err(ShaderInterfaceMismatchError::ElementsCountMismatch {
self_elements: self.elements().len() as u32,
other_elements: other.elements().len() as u32,
});
return Err(Box::new(ValidationError {
problem: "the number of elements in the shader interfaces are not equal".into(),
..Default::default()
}));
}
for a in self.elements() {
@ -913,17 +1081,28 @@ impl ShaderInterface {
.find(|e| loc >= e.location && loc < e.location + e.ty.num_locations())
{
None => {
return Err(ShaderInterfaceMismatchError::MissingElement { location: loc })
return Err(Box::new(ValidationError {
problem: format!(
"the second shader is missing an interface element at location {}",
loc
)
.into(),
..Default::default()
}));
}
Some(b) => b,
};
if a.ty != b.ty {
return Err(ShaderInterfaceMismatchError::TypeMismatch {
location: loc,
self_ty: a.ty,
other_ty: b.ty,
});
return Err(Box::new(ValidationError {
problem: format!(
"the interface element at location {} does not have the same type \
in both shaders",
loc
)
.into(),
..Default::default()
}));
}
// TODO: enforce this?
@ -1187,222 +1366,3 @@ impl From<ShaderStages> for PipelineStages {
result
}
}
fn check_spirv_version(device: &Device, mut version: Version) -> Result<(), ShaderSupportError> {
version.patch = 0; // Ignore the patch version
match version {
Version::V1_0 => {}
Version::V1_1 | Version::V1_2 | Version::V1_3 => {
if !(device.api_version() >= Version::V1_1) {
return Err(ShaderSupportError::RequirementsNotMet(&[
"Vulkan API version 1.1",
]));
}
}
Version::V1_4 => {
if !(device.api_version() >= Version::V1_2 || device.enabled_extensions().khr_spirv_1_4)
{
return Err(ShaderSupportError::RequirementsNotMet(&[
"Vulkan API version 1.2",
"extension `khr_spirv_1_4`",
]));
}
}
Version::V1_5 => {
if !(device.api_version() >= Version::V1_2) {
return Err(ShaderSupportError::RequirementsNotMet(&[
"Vulkan API version 1.2",
]));
}
}
Version::V1_6 => {
if !(device.api_version() >= Version::V1_3) {
return Err(ShaderSupportError::RequirementsNotMet(&[
"Vulkan API version 1.3",
]));
}
}
_ => return Err(ShaderSupportError::NotSupportedByVulkan),
}
Ok(())
}
/// Error that can happen when creating a new shader module.
#[derive(Clone, Debug)]
pub enum ShaderModuleCreationError {
OomError(OomError),
SpirvCapabilityNotSupported {
capability: Capability,
reason: ShaderSupportError,
},
SpirvError(SpirvError),
SpirvExtensionNotSupported {
extension: String,
reason: ShaderSupportError,
},
SpirvVersionNotSupported {
version: Version,
reason: ShaderSupportError,
},
}
impl Error for ShaderModuleCreationError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match self {
Self::OomError(err) => Some(err),
Self::SpirvCapabilityNotSupported { reason, .. } => Some(reason),
Self::SpirvError(err) => Some(err),
Self::SpirvExtensionNotSupported { reason, .. } => Some(reason),
Self::SpirvVersionNotSupported { reason, .. } => Some(reason),
}
}
}
impl Display for ShaderModuleCreationError {
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), FmtError> {
match self {
Self::OomError(_) => write!(f, "not enough memory available"),
Self::SpirvCapabilityNotSupported { capability, .. } => write!(
f,
"the SPIR-V capability {:?} enabled by the shader is not supported by the device",
capability,
),
Self::SpirvError(_) => write!(f, "the SPIR-V module could not be read"),
Self::SpirvExtensionNotSupported { extension, .. } => write!(
f,
"the SPIR-V extension {} enabled by the shader is not supported by the device",
extension,
),
Self::SpirvVersionNotSupported { version, .. } => write!(
f,
"the shader uses SPIR-V version {}.{}, which is not supported by the device",
version.major, version.minor,
),
}
}
}
impl From<VulkanError> for ShaderModuleCreationError {
fn from(err: VulkanError) -> Self {
Self::OomError(err.into())
}
}
impl From<SpirvError> for ShaderModuleCreationError {
fn from(err: SpirvError) -> Self {
Self::SpirvError(err)
}
}
/// Error that can happen when checking whether a shader is supported by a device.
#[derive(Clone, Copy, Debug)]
pub enum ShaderSupportError {
NotSupportedByVulkan,
RequirementsNotMet(&'static [&'static str]),
}
impl Error for ShaderSupportError {}
impl Display for ShaderSupportError {
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), FmtError> {
match self {
Self::NotSupportedByVulkan => write!(f, "not supported by Vulkan"),
Self::RequirementsNotMet(requirements) => write!(
f,
"at least one of the following must be available/enabled on the device: {}",
requirements.join(", "),
),
}
}
}
/// An error that can be returned when trying to create the intersection of two
/// `DescriptorBindingRequirements` values.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum DescriptorBindingRequirementsIncompatible {
/// The allowed descriptor types of the descriptors do not overlap.
DescriptorType,
/// The descriptors require different formats.
ImageFormat,
/// The descriptors require different scalar types.
ImageScalarType,
/// The multisampling requirements of the descriptors differ.
ImageMultisampled,
/// The descriptors require different image view types.
ImageViewType,
}
impl Error for DescriptorBindingRequirementsIncompatible {}
impl Display for DescriptorBindingRequirementsIncompatible {
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), FmtError> {
match self {
DescriptorBindingRequirementsIncompatible::DescriptorType => write!(
f,
"the allowed descriptor types of the two descriptors do not overlap",
),
DescriptorBindingRequirementsIncompatible::ImageFormat => {
write!(f, "the descriptors require different formats",)
}
DescriptorBindingRequirementsIncompatible::ImageMultisampled => write!(
f,
"the multisampling requirements of the descriptors differ",
),
DescriptorBindingRequirementsIncompatible::ImageScalarType => {
write!(f, "the descriptors require different scalar types",)
}
DescriptorBindingRequirementsIncompatible::ImageViewType => {
write!(f, "the descriptors require different image view types",)
}
}
}
}
/// Error that can happen when the interface mismatches between two shader stages.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ShaderInterfaceMismatchError {
/// The number of elements is not the same between the two shader interfaces.
ElementsCountMismatch {
/// Number of elements in the first interface.
self_elements: u32,
/// Number of elements in the second interface.
other_elements: u32,
},
/// An element is missing from one of the interfaces.
MissingElement {
/// Location of the missing element.
location: u32,
},
/// The type of an element does not match.
TypeMismatch {
/// Location of the element that mismatches.
location: u32,
/// Type in the first interface.
self_ty: ShaderInterfaceEntryType,
/// Type in the second interface.
other_ty: ShaderInterfaceEntryType,
},
}
impl Error for ShaderInterfaceMismatchError {}
impl Display for ShaderInterfaceMismatchError {
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), FmtError> {
write!(
f,
"{}",
match self {
ShaderInterfaceMismatchError::ElementsCountMismatch { .. } => {
"the number of elements mismatches"
}
ShaderInterfaceMismatchError::MissingElement { .. } => "an element is missing",
ShaderInterfaceMismatchError::TypeMismatch { .. } => {
"the type of an element does not match"
}
}
)
}
}