hodasemi/vulkan_lib
1
0
Fork 0
Code Issues 1 Pull requests Projects Releases Wiki Activity Actions

Rework shadermodule typing

Browse source
This commit is contained in:
hodasemi 2024-03-24 21:29:47 +01:00
parent 23d0adbc03
commit 4d476c4263
6 changed files with 116 additions and 81 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

25
vulkan-rs/src/macros.rs
View file

@ -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 {

4
vulkan-rs/src/pipelines/compute_pipeline.rs
View file

@ -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() {

26
vulkan-rs/src/pipelines/graphics_pipeline.rs
View file

@ -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<{ ShaderType::TesselationEvaluation as u8 }>>,
Arc<ShaderModule<shader_type::TesselationControl>>,
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_evaluation: Arc<ShaderModule<{ ShaderType::TesselationEvaluation as u8 }>>,
tesselation_control: Arc<ShaderModule<shader_type::TesselationControl>>,
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(
mut self,
shader: Arc<ShaderModule<{ ShaderType::Geometry as u8 }>>,
) -> Self {
pub fn set_geometry_shader(mut self, shader: Arc<ShaderModule<shader_type::Geometry>>) -> Self {
self.geometry_shader = Some(shader);
self
}
// TODO: add support for specialization constants
pub fn set_fragment_shader(
mut self,
shader: Arc<ShaderModule<{ ShaderType::Fragment as u8 }>>,
) -> Self {
pub fn set_fragment_shader(mut self, shader: Arc<ShaderModule<shader_type::Fragment>>) -> Self {
self.fragment_shader = Some(shader);
self

24
vulkan-rs/src/pipelines/ray_tracing_pipeline.rs
View file

@ -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 {
fn from(value: Arc<ShaderModule<{ ShaderType::$shader_type as u8 }>>) -> Self {
impl From<Arc<ShaderModule<shader_type::$shader_type>>> for $struct {
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 }>>),
ClosestHit(Arc<ShaderModule<{ ShaderType::ClosestHit as u8 }>>),
Miss(Arc<ShaderModule<{ ShaderType::Miss as u8 }>>),
AnyHit(Arc<ShaderModule<{ ShaderType::AnyHit as u8 }>>),
Intersection(Arc<ShaderModule<{ ShaderType::Intersection as u8 }>>),
RayGeneration(Arc<ShaderModule<shader_type::RayGeneration>>),
ClosestHit(Arc<ShaderModule<shader_type::ClosestHit>>),
Miss(Arc<ShaderModule<shader_type::Miss>>),
AnyHit(Arc<ShaderModule<shader_type::AnyHit>>),
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 }>>),
AnyHit(Arc<ShaderModule<{ ShaderType::AnyHit as u8 }>>),
Intersection(Arc<ShaderModule<{ ShaderType::Intersection as u8 }>>),
ClosestHit(Arc<ShaderModule<shader_type::ClosestHit>>),
AnyHit(Arc<ShaderModule<shader_type::AnyHit>>),
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 }>>),
Miss(Arc<ShaderModule<{ ShaderType::Miss as u8 }>>),
RayGeneration(Arc<ShaderModule<shader_type::RayGeneration>>),
Miss(Arc<ShaderModule<shader_type::Miss>>),
}
impl_from_shader_type!(OtherShader, RayGeneration);

5
vulkan-rs/src/prelude.rs
View file

@ -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,
SpecializationConstants, VertexInputDescription,
shader_type::{self, ShaderType},
AddSpecializationConstant, PipelineStageInfo, ShaderModule, SpecializationConstants,
VertexInputDescription,
};
pub use super::surface::Surface;
pub use super::swapchain::Swapchain;

109
vulkan-rs/src/shadermodule.rs
View file

@ -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)]
#[repr(u8)]
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum ShaderType {
None,
Vertex,
Fragment,
Geometry,
TesselationControl,
TesselationEvaluation,
Compute,
RayGeneration,
ClosestHit,
Miss,
AnyHit,
Intersection,
pub mod shader_type {
mod sealed {
pub trait Sealed {}
impl Sealed for super::Vertex {}
impl Sealed for super::Fragment {}
impl Sealed for super::Geometry {}
impl Sealed for super::TesselationControl {}
impl Sealed for super::TesselationEvaluation {}
impl Sealed for super::Compute {}
impl Sealed for super::RayGeneration {}
impl Sealed for super::ClosestHit {}
impl Sealed for super::Miss {}
impl Sealed for super::AnyHit {}
impl Sealed for super::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,
pub trait ShaderType: sealed::Sealed {}
_ => panic!("can't convert ShaderType from {}", value),
}
}
}
pub struct Vertex;
impl ShaderType for Vertex {}
impl Default for ShaderType {
fn default() -> Self {
ShaderType::None
}
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> {
pub fn new(device: Arc<Device>, path: &str) -> Result<Arc<ShaderModule<TYPE>>> {
impl<ShaderModuleType: ShaderType> ShaderModule<ShaderModuleType> {
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);
}