Rework shadermodule typing

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);
     }