Update Rust crate anyhow to 1.0.82

Reviewed-on: #57

vma-rs/Cargo.toml

@@ -9,7 +9,7 @@ build = "build.rs"
 
 [dependencies]
 vulkan-sys = { path = "../vulkan-sys" }
-anyhow = { version = "1.0.81", features = ["backtrace"] }
+anyhow = { version = "1.0.82", features = ["backtrace"] }
 
 [build-dependencies]
-cc = "1.0.90"
+cc = "1.0.92"

vulkan-rs/Cargo.toml

@@ -5,9 +5,9 @@ authors = ["hodasemi <superschneider@t-online.de>"]
 edition = "2021"
 
 [dependencies]
-image = "0.25.0"
+image = "0.25.1"
 vulkan-sys = { path = "../vulkan-sys" }
 vma-rs = { path = "../vma-rs" }
-anyhow = { version = "1.0.81", features = ["backtrace"] }
+anyhow = { version = "1.0.82", features = ["backtrace"] }
 assetpath = { path = "../assetpath" }
 utilities = { git = "https://gavania.de/hodasemi/utilities.git" }

vulkan-rs/src/descriptorset.rs

@@ -270,15 +270,8 @@ impl DescriptorSet {
         {
             assert!(writes.len() <= self.pool.descriptor_set_layout.bindings().len());
 
-            for (i, binding) in self
+            for binding in self.pool.descriptor_set_layout.bindings().iter() {
-                .pool
+                if let Some(write) = writes.iter().find(|write| write.binding == binding.binding) {
-                .descriptor_set_layout
-                .bindings()
-                .iter()
-                .enumerate()
-            {
-                if let Some(write) = writes.get(i) {
-                    assert_eq!(write.binding, binding.binding);
                     assert_eq!(write.descriptor_type, binding.desc_type);
                 }
             }

vulkan-rs/src/macros.rs

@@ -24,6 +24,31 @@ macro_rules! impl_vk_handle {
             }
         }
     };
+    ($struct_name:ident $(<$( $name:ident: $type:ident, )*>)?, $target_name:ident, $value:ident) => {
+        impl$(<$( $name: $type, )*>)? VkHandle<$target_name> for $struct_name$(<$($name,)?>)? {
+            fn vk_handle(&self) -> $target_name {
+                self.$value
+            }
+        }
+
+        impl<'a $($(, $name: $type)*)?> VkHandle<$target_name> for &'a $struct_name$(<$($name,)?>)? {
+            fn vk_handle(&self) -> $target_name {
+                self.$value
+            }
+        }
+
+        impl$(<$( $name: $type, )*>)? VkHandle<$target_name> for Arc<$struct_name$(<$($name,)?>)?> {
+            fn vk_handle(&self) -> $target_name {
+                self.$value
+            }
+        }
+
+        impl<'a $($(, $name: $type)*)?> VkHandle<$target_name> for &'a Arc<$struct_name$(<$($name,)?>)?> {
+            fn vk_handle(&self) -> $target_name {
+                self.$value
+            }
+        }
+    };
 }
 
 macro_rules! impl_vk_handle_t {

vulkan-rs/src/pipelines/compute_pipeline.rs

@@ -6,7 +6,7 @@ use crate::prelude::*;
 use std::sync::Arc;
 
 pub struct ComputePipelineBuilder<'a> {
-    shader_module: Option<&'a Arc<ShaderModule<{ ShaderType::Compute as u8 }>>>,
+    shader_module: Option<&'a Arc<ShaderModule<shader_type::Compute>>>,
     pipeline_cache: Option<&'a Arc<PipelineCache>>,
     flags: VkPipelineCreateFlagBits,
 }
@@ -15,7 +15,7 @@ impl<'a> ComputePipelineBuilder<'a> {
     // TODO: add support for specialization constants
     pub fn set_shader_module(
         mut self,
-        shader_module: &'a Arc<ShaderModule<{ ShaderType::Compute as u8 }>>,
+        shader_module: &'a Arc<ShaderModule<shader_type::Compute>>,
     ) -> Self {
         if cfg!(debug_assertions) {
             if self.shader_module.is_some() {

vulkan-rs/src/pipelines/graphics_pipeline.rs

@@ -12,21 +12,21 @@ pub struct GraphicsPipelineBuilder {
 
     amd_rasterization_order: Option<VkPipelineRasterizationStateRasterizationOrderAMD>,
 
-    vertex_shader: Option<Arc<ShaderModule<{ ShaderType::Vertex as u8 }>>>,
+    vertex_shader: Option<Arc<ShaderModule<shader_type::Vertex>>>,
     vertex_binding_description: Vec<VkVertexInputBindingDescription>,
     vertex_attribute_description: Vec<VkVertexInputAttributeDescription>,
 
     input_assembly: Option<VkPipelineInputAssemblyStateCreateInfo>,
 
     tesselation_shader: Option<(
-        Arc<ShaderModule<{ ShaderType::TesselationControl as u8 }>>,
+        Arc<ShaderModule<shader_type::TesselationControl>>,
-        Arc<ShaderModule<{ ShaderType::TesselationEvaluation as u8 }>>,
+        Arc<ShaderModule<shader_type::TesselationEvaluation>>,
     )>,
     patch_control_points: u32,
 
-    geometry_shader: Option<Arc<ShaderModule<{ ShaderType::Geometry as u8 }>>>,
+    geometry_shader: Option<Arc<ShaderModule<shader_type::Geometry>>>,
 
-    fragment_shader: Option<Arc<ShaderModule<{ ShaderType::Fragment as u8 }>>>,
+    fragment_shader: Option<Arc<ShaderModule<shader_type::Fragment>>>,
 
     viewports: Vec<VkViewport>,
     scissors: Vec<VkRect2D>,
@@ -45,7 +45,7 @@ impl GraphicsPipelineBuilder {
     // TODO: add support for specialization constants
     pub fn set_vertex_shader<T: VertexInputDescription>(
         mut self,
-        shader: Arc<ShaderModule<{ ShaderType::Vertex as u8 }>>,
+        shader: Arc<ShaderModule<shader_type::Vertex>>,
     ) -> Self {
         self.vertex_shader = Some(shader);
         self.vertex_binding_description = T::bindings();
@@ -57,8 +57,8 @@ impl GraphicsPipelineBuilder {
     // TODO: add support for specialization constants
     pub fn set_tesselation_shader(
         mut self,
-        tesselation_control: Arc<ShaderModule<{ ShaderType::TesselationControl as u8 }>>,
+        tesselation_control: Arc<ShaderModule<shader_type::TesselationControl>>,
-        tesselation_evaluation: Arc<ShaderModule<{ ShaderType::TesselationEvaluation as u8 }>>,
+        tesselation_evaluation: Arc<ShaderModule<shader_type::TesselationEvaluation>>,
         patch_control_points: u32,
     ) -> Self {
         self.tesselation_shader = Some((tesselation_control, tesselation_evaluation));
@@ -68,20 +68,14 @@ impl GraphicsPipelineBuilder {
     }
 
     // TODO: add support for specialization constants
-    pub fn set_geometry_shader(
+    pub fn set_geometry_shader(mut self, shader: Arc<ShaderModule<shader_type::Geometry>>) -> Self {
-        mut self,
-        shader: Arc<ShaderModule<{ ShaderType::Geometry as u8 }>>,
-    ) -> Self {
         self.geometry_shader = Some(shader);
 
         self
     }
 
     // TODO: add support for specialization constants
-    pub fn set_fragment_shader(
+    pub fn set_fragment_shader(mut self, shader: Arc<ShaderModule<shader_type::Fragment>>) -> Self {
-        mut self,
-        shader: Arc<ShaderModule<{ ShaderType::Fragment as u8 }>>,
-    ) -> Self {
         self.fragment_shader = Some(shader);
 
         self

vulkan-rs/src/pipelines/ray_tracing_pipeline.rs

@@ -31,8 +31,8 @@ impl<'a> Library<'a> {
 
 macro_rules! impl_from_shader_type {
     ($struct: ident, $shader_type: ident) => {
-        impl From<Arc<ShaderModule<{ ShaderType::$shader_type as u8 }>>> for $struct {
+        impl From<Arc<ShaderModule<shader_type::$shader_type>>> for $struct {
-            fn from(value: Arc<ShaderModule<{ ShaderType::$shader_type as u8 }>>) -> Self {
+            fn from(value: Arc<ShaderModule<shader_type::$shader_type>>) -> Self {
                 Self::$shader_type(value)
             }
         }
@@ -41,11 +41,11 @@ macro_rules! impl_from_shader_type {
 
 #[derive(Clone)]
 enum RaytracingShader {
-    RayGeneration(Arc<ShaderModule<{ ShaderType::RayGeneration as u8 }>>),
+    RayGeneration(Arc<ShaderModule<shader_type::RayGeneration>>),
-    ClosestHit(Arc<ShaderModule<{ ShaderType::ClosestHit as u8 }>>),
+    ClosestHit(Arc<ShaderModule<shader_type::ClosestHit>>),
-    Miss(Arc<ShaderModule<{ ShaderType::Miss as u8 }>>),
+    Miss(Arc<ShaderModule<shader_type::Miss>>),
-    AnyHit(Arc<ShaderModule<{ ShaderType::AnyHit as u8 }>>),
+    AnyHit(Arc<ShaderModule<shader_type::AnyHit>>),
-    Intersection(Arc<ShaderModule<{ ShaderType::Intersection as u8 }>>),
+    Intersection(Arc<ShaderModule<shader_type::Intersection>>),
 }
 
 impl_from_shader_type!(RaytracingShader, RayGeneration);
@@ -75,9 +75,9 @@ impl From<OtherShader> for RaytracingShader {
 
 #[derive(Clone)]
 pub enum HitShader {
-    ClosestHit(Arc<ShaderModule<{ ShaderType::ClosestHit as u8 }>>),
+    ClosestHit(Arc<ShaderModule<shader_type::ClosestHit>>),
-    AnyHit(Arc<ShaderModule<{ ShaderType::AnyHit as u8 }>>),
+    AnyHit(Arc<ShaderModule<shader_type::AnyHit>>),
-    Intersection(Arc<ShaderModule<{ ShaderType::Intersection as u8 }>>),
+    Intersection(Arc<ShaderModule<shader_type::Intersection>>),
 }
 
 impl_from_shader_type!(HitShader, ClosestHit);
@@ -86,8 +86,8 @@ impl_from_shader_type!(HitShader, Intersection);
 
 #[derive(Clone)]
 pub enum OtherShader {
-    RayGeneration(Arc<ShaderModule<{ ShaderType::RayGeneration as u8 }>>),
+    RayGeneration(Arc<ShaderModule<shader_type::RayGeneration>>),
-    Miss(Arc<ShaderModule<{ ShaderType::Miss as u8 }>>),
+    Miss(Arc<ShaderModule<shader_type::Miss>>),
 }
 
 impl_from_shader_type!(OtherShader, RayGeneration);

vulkan-rs/src/prelude.rs

@@ -24,8 +24,9 @@ pub use super::renderpass::RenderPass;
 pub use super::sampler_manager::{Sampler, SamplerBuilder};
 pub use super::semaphore::Semaphore;
 pub use super::shadermodule::{
-    AddSpecializationConstant, PipelineStageInfo, ShaderModule, ShaderType,
+    shader_type::{self, ShaderType},
-    SpecializationConstants, VertexInputDescription,
+    AddSpecializationConstant, PipelineStageInfo, ShaderModule, SpecializationConstants,
+    VertexInputDescription,
 };
 pub use super::surface::Surface;
 pub use super::swapchain::Swapchain;

vulkan-rs/src/shadermodule.rs

@@ -4,51 +4,59 @@ use anyhow::{Context, Result};
 
 use std::fs::File;
 use std::io::Read;
+use std::marker::PhantomData;
 use std::sync::Arc;
 
-#[allow(clippy::cast_ptr_alignment)]
+pub mod shader_type {
-#[repr(u8)]
+    mod sealed {
-#[derive(Debug, Clone, Copy, PartialEq)]
+        pub trait Sealed {}
-pub enum ShaderType {
+        impl Sealed for super::Vertex {}
-    None,
+        impl Sealed for super::Fragment {}
-    Vertex,
+        impl Sealed for super::Geometry {}
-    Fragment,
+        impl Sealed for super::TesselationControl {}
-    Geometry,
+        impl Sealed for super::TesselationEvaluation {}
-    TesselationControl,
+        impl Sealed for super::Compute {}
-    TesselationEvaluation,
+        impl Sealed for super::RayGeneration {}
-    Compute,
+        impl Sealed for super::ClosestHit {}
-    RayGeneration,
+        impl Sealed for super::Miss {}
-    ClosestHit,
+        impl Sealed for super::AnyHit {}
-    Miss,
+        impl Sealed for super::Intersection {}
-    AnyHit,
-    Intersection,
-}
-
-impl From<u8> for ShaderType {
-    fn from(value: u8) -> Self {
-        match value {
-            0 => Self::None,
-            1 => Self::Vertex,
-            2 => Self::Fragment,
-            3 => Self::Geometry,
-            4 => Self::TesselationControl,
-            5 => Self::TesselationEvaluation,
-            6 => Self::Compute,
-            7 => Self::RayGeneration,
-            8 => Self::ClosestHit,
-            9 => Self::Miss,
-            10 => Self::AnyHit,
-            11 => Self::Intersection,
-
-            _ => panic!("can't convert ShaderType from {}", value),
     }
-    }
-}
 
-impl Default for ShaderType {
+    pub trait ShaderType: sealed::Sealed {}
-    fn default() -> Self {
+
-        ShaderType::None
+    pub struct Vertex;
-    }
+    impl ShaderType for Vertex {}
+
+    pub struct Fragment;
+    impl ShaderType for Fragment {}
+
+    pub struct Geometry;
+    impl ShaderType for Geometry {}
+
+    pub struct TesselationControl;
+    impl ShaderType for TesselationControl {}
+
+    pub struct TesselationEvaluation;
+    impl ShaderType for TesselationEvaluation {}
+
+    pub struct Compute;
+    impl ShaderType for Compute {}
+
+    pub struct RayGeneration;
+    impl ShaderType for RayGeneration {}
+
+    pub struct ClosestHit;
+    impl ShaderType for ClosestHit {}
+
+    pub struct Miss;
+    impl ShaderType for Miss {}
+
+    pub struct AnyHit;
+    impl ShaderType for AnyHit {}
+
+    pub struct Intersection;
+    impl ShaderType for Intersection {}
 }
 
 pub trait VertexInputDescription: ReprC + Sized {
@@ -69,7 +77,7 @@ pub trait PipelineStageInfo {
 
 macro_rules! impl_pipeline_stage_info {
     ($func:ident, $type:ident) => {
-        impl PipelineStageInfo for ShaderModule<{ ShaderType::$type as u8 }> {
+        impl PipelineStageInfo for ShaderModule<$type> {
             fn pipeline_stage_info(&self) -> VkPipelineShaderStageCreateInfo {
                 VkPipelineShaderStageCreateInfo::$func(self.shader_module)
             }
@@ -78,25 +86,30 @@ macro_rules! impl_pipeline_stage_info {
 }
 
 #[derive(Debug)]
-pub struct ShaderModule<const TYPE: u8> {
+pub struct ShaderModule<ShaderModuleType: ShaderType> {
+    t: PhantomData<ShaderModuleType>,
     device: Arc<Device>,
     shader_module: VkShaderModule,
 }
 
-impl<const TYPE: u8> ShaderModule<TYPE> {
+impl<ShaderModuleType: ShaderType> ShaderModule<ShaderModuleType> {
-    pub fn new(device: Arc<Device>, path: &str) -> Result<Arc<ShaderModule<TYPE>>> {
+    pub fn new(device: Arc<Device>, path: &str) -> Result<Arc<ShaderModule<ShaderModuleType>>> {
         let code = Self::shader_code(path)?;
 
         Self::from_slice(device, code.as_slice())
     }
 
-    pub fn from_slice(device: Arc<Device>, code: &[u8]) -> Result<Arc<ShaderModule<TYPE>>> {
+    pub fn from_slice(
+        device: Arc<Device>,
+        code: &[u8],
+    ) -> Result<Arc<ShaderModule<ShaderModuleType>>> {
         let shader_module_ci =
             VkShaderModuleCreateInfo::new(VK_SHADER_MODULE_CREATE_NULL_BIT, code);
 
         let shader_module = device.create_shader_module(&shader_module_ci)?;
 
         Ok(Arc::new(ShaderModule {
+            t: PhantomData,
             device,
             shader_module,
         }))
@@ -116,6 +129,8 @@ impl<const TYPE: u8> ShaderModule<TYPE> {
     }
 }
 
+use shader_type::*;
+
 impl_pipeline_stage_info!(vertex, Vertex);
 impl_pipeline_stage_info!(geometry, Geometry);
 impl_pipeline_stage_info!(tesselation_control, TesselationControl);
@@ -128,15 +143,15 @@ impl_pipeline_stage_info!(closest_hit, ClosestHit);
 impl_pipeline_stage_info!(ray_generation, RayGeneration);
 impl_pipeline_stage_info!(miss, Miss);
 
-impl<const TYPE: u8> VulkanDevice for ShaderModule<TYPE> {
+impl<ShaderModuleType: ShaderType> VulkanDevice for ShaderModule<ShaderModuleType> {
     fn device(&self) -> &Arc<Device> {
         &self.device
     }
 }
 
-impl_vk_handle!(ShaderModule<const TYPE: u8,>, VkShaderModule, shader_module);
+impl_vk_handle!(ShaderModule<ShaderModuleType: ShaderType,>, VkShaderModule, shader_module);
 
-impl<const TYPE: u8> Drop for ShaderModule<TYPE> {
+impl<ShaderModuleType: ShaderType> Drop for ShaderModule<ShaderModuleType> {
     fn drop(&mut self) {
         self.device.destroy_shader_module(self.shader_module);
     }

vulkan-rs/src/swapchain.rs

@@ -50,11 +50,15 @@ impl Swapchain {
         image_usage: impl Into<VkImageUsageFlagBits>,
         prefered_format: VkFormat,
         array_layers: u32,
+        window_size: (u32, u32),
     ) -> Result<Arc<Swapchain>> {
         let surface_caps = surface.capabilities(&device)?;
 
         let extent = if surface_caps.currentExtent.width == u32::max_value() {
-            return Err(anyhow::Error::msg("Surface has no extent"));
+            VkExtent2D {
+                width: window_size.0,
+                height: window_size.1,
+            }
         } else {
             VkExtent2D {
                 width: surface_caps.currentExtent.width,
@@ -178,7 +182,7 @@ impl Swapchain {
         })
     }
 
-    pub fn recreate(&self) -> Result<()> {
+    pub fn recreate(&self, window_size: (u32, u32)) -> Result<()> {
         // wait for the device to get idle
         self.device.wait_idle()?;
 
@@ -187,7 +191,10 @@ impl Swapchain {
         let extent = if surface_caps.currentExtent.width == u32::max_value()
             || surface_caps.currentExtent.height == u32::max_value()
         {
-            return Err(anyhow::Error::msg("Surface has no extent"));
+            VkExtent2D {
+                width: window_size.0,
+                height: window_size.1,
+            }
         } else if surface_caps.currentExtent.width == 0 || surface_caps.currentExtent.height == 0 {
             // don't recreate swapchain
             return Ok(());

vulkan-sys/Cargo.toml

@@ -8,5 +8,5 @@ edition = "2021"
 library_loader = { path = "../library_loader" }
 paste = "1.0.14"
 shared_library = "0.1.9"
-anyhow = { version = "1.0.81", features = ["backtrace"] }
+anyhow = { version = "1.0.82", features = ["backtrace"] }
 utilities = { git = "https://gavania.de/hodasemi/utilities.git" }

vulkan-sys/src/enums/samplecountflags.rs

@@ -15,7 +15,7 @@ pub enum VkSampleCountFlags {
 impl From<u32> for VkSampleCountFlags {
     fn from(n: u32) -> Self {
         match n {
-            1 => Self::VK_SAMPLE_COUNT_1_BIT,
+            0 | 1 => Self::VK_SAMPLE_COUNT_1_BIT,
             2 => Self::VK_SAMPLE_COUNT_2_BIT,
             4 => Self::VK_SAMPLE_COUNT_4_BIT,
             8 => Self::VK_SAMPLE_COUNT_8_BIT,

vulkan-sys/src/structs/core/prelude.rs

@@ -29,12 +29,8 @@ pub use super::computepipelinecreateinfo::*;
 pub use super::copydescriptorset::*;
 pub use super::debugreportcallbackcreateinfoext::*;
 pub use super::debugutilmessengercallbackdataext::*;
-pub use super::debugutilmessengercallbackdataext::*;
-pub use super::debugutilslabelext::*;
 pub use super::debugutilslabelext::*;
 pub use super::debugutilsmessengercreateinfoext::*;
-pub use super::debugutilsmessengercreateinfoext::*;
-pub use super::debugutilsobjectnameinfoext::*;
 pub use super::debugutilsobjectnameinfoext::*;
 pub use super::descriptorbufferinfo::*;
 pub use super::descriptorimageinfo::*;
@@ -73,7 +69,6 @@ pub use super::imagesubresourcelayers::*;
 pub use super::imagesubresourcerange::*;
 pub use super::imageviewcreateinfo::*;
 pub use super::instancecreateinfo::*;
-pub use super::instancecreateinfo::*;
 pub use super::iossurfacecreateinfomvk::*;
 pub use super::layerproperties::*;
 pub use super::macossurfacecreateinfomvk::*;
@@ -89,7 +84,6 @@ pub use super::mvkswapchainperformance::*;
 pub use super::offset2d::*;
 pub use super::offset3d::*;
 pub use super::physicaldevicefeatures::*;
-pub use super::physicaldevicefeatures::*;
 pub use super::physicaldevicelimits::*;
 pub use super::physicaldevicemaintanence3properties::*;
 pub use super::physicaldevicememoryproperties::*;