use crate::{Error, Result, runtime::shader::ShaderArtifact};
use super::physical::DeviceLimits;
pub(crate) const GRAPHICS_PUSH_CONSTANT_SIZE: u32 = 80;
pub(crate) const FLAT_COLOR_PUSH_SIZE: u32 = 96;
pub(crate) const UNLIT_PUSH_SIZE: u32 = 96;
pub(crate) const SURFACE_PUSH_SIZE: u32 = 128;
static RENDER_VERT_SPV: &[u8] = include_bytes!(concat!(
env!("OUT_DIR"),
"/render_vertex_color_lit_vert.spv"
));
static RENDER_FRAG_SPV: &[u8] = include_bytes!(concat!(
env!("OUT_DIR"),
"/render_vertex_color_lit_frag.spv"
));
static FLAT_COLOR_VERT_SPV: &[u8] =
include_bytes!(concat!(env!("OUT_DIR"), "/render_flat_color_vert.spv"));
static FLAT_COLOR_FRAG_SPV: &[u8] =
include_bytes!(concat!(env!("OUT_DIR"), "/render_flat_color_frag.spv"));
static UNLIT_VERT_SPV: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/render_unlit_vert.spv"));
static UNLIT_FRAG_SPV: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/render_unlit_frag.spv"));
static SURFACE_VERT_SPV: &[u8] =
include_bytes!(concat!(env!("OUT_DIR"), "/render_surface_vert.spv"));
static SURFACE_FRAG_SPV: &[u8] =
include_bytes!(concat!(env!("OUT_DIR"), "/render_surface_frag.spv"));
pub(in crate::runtime) const RENDER_COLOR_FORMAT: vk::Format = vk::Format::R8G8B8A8_UNORM;
pub(in crate::runtime) const RENDER_DEPTH_FORMAT: vk::Format = vk::Format::D32_SFLOAT;
pub(crate) struct GraphicsPipeline {
handle: vk::Pipeline,
layout: vk::PipelineLayout,
device: std::sync::Arc<vk::Device>,
}
impl GraphicsPipeline {
#[allow(private_interfaces)]
pub(in crate::runtime) fn new(
device: std::sync::Arc<vk::Device>,
limits: DeviceLimits,
cache: vk::PipelineCache,
) -> Result<Self> {
if limits.max_push_constants_size < GRAPHICS_PUSH_CONSTANT_SIZE {
return Err(Error::missing_capability(
"graphics pipeline requires 80 bytes of push constants",
));
}
let push_range = vk::PushConstantRange::default()
.stage_flags(vk::ShaderStageFlagBits::VERTEX_BIT)
.offset(0)
.size(GRAPHICS_PUSH_CONSTANT_SIZE);
let layout_info = vk::PipelineLayoutCreateInfo::default()
.push_constant_ranges(std::slice::from_ref(&push_range));
let layout =
unsafe { device.create_pipeline_layout(&(layout_info).map_err(Error::from)?, None) }
.map_err(|s| Error::backend_failure("Vulkan", "graphics pipeline-layout creation", s))?;
let vert_words = decode_spirv_bytes(RENDER_VERT_SPV)
.inspect_err(|_| destroy_pipeline_layout(&device, layout))?;
let frag_words = decode_spirv_bytes(RENDER_FRAG_SPV)
.inspect_err(|_| destroy_pipeline_layout(&device, layout))?;
let vert_module = create_shader_module(&device, &vert_words)
.inspect_err(|_| destroy_pipeline_layout(&device, layout))?;
let frag_module = match create_shader_module(&device, &frag_words) {
Ok(m) => m,
Err(e) => {
unsafe { device.destroy_shader_module(vert_module, None) }?;
destroy_pipeline_layout(&device, layout);
return Err(e);
}
};
let stages = [
vk::PipelineShaderStageCreateInfo::default()
.stage(vk::ShaderStageFlagBits::VERTEX_BIT)
.module(vert_module)
.name(c"main"),
vk::PipelineShaderStageCreateInfo::default()
.stage(vk::ShaderStageFlagBits::FRAGMENT_BIT)
.module(frag_module)
.name(c"main"),
];
let binding = vk::VertexInputBindingDescription::default()
.binding(0)
.stride(48)
.input_rate(vk::VertexInputRate::VERTEX);
let attributes = [
vk::VertexInputAttributeDescription::default()
.location(0)
.binding(0)
.format(vk::Format::R32G32B32_SFLOAT)
.offset(0), vk::VertexInputAttributeDescription::default()
.location(1)
.binding(0)
.format(vk::Format::R32G32B32_SFLOAT)
.offset(12), vk::VertexInputAttributeDescription::default()
.location(2)
.binding(0)
.format(vk::Format::R32G32B32A32_SFLOAT)
.offset(32), ];
let vertex_input = vk::PipelineVertexInputStateCreateInfo::default()
.vertex_binding_descriptions(std::slice::from_ref(&binding))
.map_err(Error::from)?
.vertex_attribute_descriptions(&attributes)
.map_err(Error::from)?;
let assembly = vk::PipelineInputAssemblyStateCreateInfo::default()
.topology(vk::PrimitiveTopology::TRIANGLE_LIST);
let viewport_state = vk::PipelineViewportStateCreateInfo::default()
.viewport_count(1)
.scissor_count(1);
let raster = vk::PipelineRasterizationStateCreateInfo::default()
.polygon_mode(vk::PolygonMode::FILL)
.cull_mode(vk::CullModeFlagBits::NONE)
.front_face(vk::FrontFace::COUNTER_CLOCKWISE)
.line_width(1.0);
let multisample = vk::PipelineMultisampleStateCreateInfo::default()
.rasterization_samples(vk::SampleCountFlagBits::_1_BIT);
let depth_stencil = vk::PipelineDepthStencilStateCreateInfo::default()
.depth_test_enable(u32::from(true))
.depth_write_enable(u32::from(true))
.depth_compare_op(vk::CompareOp::LESS)
.min_depth_bounds(0.0)
.max_depth_bounds(1.0);
let blend_attachment = vk::PipelineColorBlendAttachmentState::default().color_write_mask(
vk::ColorComponentFlagBits::R_BIT
| vk::ColorComponentFlagBits::G_BIT
| vk::ColorComponentFlagBits::B_BIT
| vk::ColorComponentFlagBits::A_BIT,
);
let blend = vk::PipelineColorBlendStateCreateInfo::default()
.attachments(std::slice::from_ref(&blend_attachment))
.map_err(Error::from)?;
let dynamic_states = [vk::DynamicState::VIEWPORT, vk::DynamicState::SCISSOR];
let dynamic = vk::PipelineDynamicStateCreateInfo::default()
.dynamic_states(&dynamic_states)
.map_err(Error::from)?;
let color_formats = [RENDER_COLOR_FORMAT];
let mut rendering = vk::PipelineRenderingCreateInfo::default()
.color_attachment_formats(&color_formats)
.map_err(Error::from)?
.depth_attachment_format(RENDER_DEPTH_FORMAT);
let pipeline_info = vk::GraphicsPipelineCreateInfo::default()
.push_next(&mut rendering)
.map_err(Error::from)?
.stages(&stages)
.map_err(Error::from)?
.vertex_input_state(&vertex_input)
.input_assembly_state(&assembly)
.viewport_state(&viewport_state)
.rasterization_state(&raster)
.multisample_state(&multisample)
.depth_stencil_state(&depth_stencil)
.color_blend_state(&blend)
.dynamic_state(&dynamic)
.layout(layout);
let mut pipelines = [vk::Pipeline::default(); 1];
let result = unsafe {
device.create_graphics_pipelines(
cache,
std::slice::from_ref(&pipeline_info),
None,
&mut pipelines,
)
};
unsafe {
let _ = device.destroy_shader_module(vert_module, None);
let _ = device.destroy_shader_module(frag_module, None);
}
let handle = match result {
Ok(vk::Result::SUCCESS) => pipelines[0],
result => {
for handle in pipelines
.into_iter()
.filter(|handle| *handle != vk::Pipeline::default())
{
destroy_pipeline(&device, handle);
}
destroy_pipeline_layout(&device, layout);
return Err(Error::backend_dispatch_failure(
"Vulkan",
"graphics-pipeline creation",
result,
));
}
};
Ok(Self {
handle,
layout,
device,
})
}
pub(crate) const fn raw(&self) -> vk::Pipeline {
self.handle
}
pub(crate) const fn layout(&self) -> vk::PipelineLayout {
self.layout
}
}
impl Drop for GraphicsPipeline {
fn drop(&mut self) {
destroy_pipeline(&self.device, self.handle);
destroy_pipeline_layout(&self.device, self.layout);
}
}
pub(crate) struct FlatColorPipeline {
handle: vk::Pipeline,
layout: vk::PipelineLayout,
device: std::sync::Arc<vk::Device>,
}
impl FlatColorPipeline {
#[allow(private_interfaces)]
pub(in crate::runtime) fn new(
device: std::sync::Arc<vk::Device>,
limits: DeviceLimits,
cache: vk::PipelineCache,
) -> Result<Self> {
if limits.max_push_constants_size < FLAT_COLOR_PUSH_SIZE {
return Err(Error::missing_capability(
"flat-color pipeline requires 96 bytes of push constants",
));
}
let push_range = vk::PushConstantRange::default()
.stage_flags(vk::ShaderStageFlagBits::VERTEX_BIT | vk::ShaderStageFlagBits::FRAGMENT_BIT)
.offset(0)
.size(FLAT_COLOR_PUSH_SIZE);
let layout_info = vk::PipelineLayoutCreateInfo::default()
.push_constant_ranges(std::slice::from_ref(&push_range));
let layout =
unsafe { device.create_pipeline_layout(&(layout_info).map_err(Error::from)?, None) }
.map_err(|s| Error::backend_failure("Vulkan", "flat-color pipeline-layout creation", s))?;
let vert_words = decode_spirv_bytes(FLAT_COLOR_VERT_SPV)
.inspect_err(|_| destroy_pipeline_layout(&device, layout))?;
let frag_words = decode_spirv_bytes(FLAT_COLOR_FRAG_SPV)
.inspect_err(|_| destroy_pipeline_layout(&device, layout))?;
let vert_module = create_shader_module(&device, &vert_words)
.inspect_err(|_| destroy_pipeline_layout(&device, layout))?;
let frag_module = match create_shader_module(&device, &frag_words) {
Ok(m) => m,
Err(e) => {
unsafe { device.destroy_shader_module(vert_module, None) }?;
destroy_pipeline_layout(&device, layout);
return Err(e);
}
};
let handle = match create_graphics_pipeline_inner(
&device,
layout,
vert_module,
frag_module,
PipelineDepth::Disabled,
PipelineBlend::PremultipliedAlpha,
cache,
) {
Ok(h) => h,
Err(e) => {
destroy_pipeline_layout(&device, layout);
return Err(e);
}
};
Ok(Self {
handle,
layout,
device,
})
}
pub(crate) const fn raw(&self) -> vk::Pipeline {
self.handle
}
pub(crate) const fn layout(&self) -> vk::PipelineLayout {
self.layout
}
}
impl Drop for FlatColorPipeline {
fn drop(&mut self) {
destroy_pipeline(&self.device, self.handle);
destroy_pipeline_layout(&self.device, self.layout);
}
}
pub(crate) struct UnlitPipeline {
handle: vk::Pipeline,
layout: vk::PipelineLayout,
device: std::sync::Arc<vk::Device>,
}
impl UnlitPipeline {
#[allow(private_interfaces)]
pub(in crate::runtime) fn new(
device: std::sync::Arc<vk::Device>,
sampler_layout: vk::DescriptorSetLayout,
limits: DeviceLimits,
cache: vk::PipelineCache,
) -> Result<Self> {
if limits.max_push_constants_size < UNLIT_PUSH_SIZE {
return Err(Error::missing_capability(
"unlit pipeline requires 96 bytes of push constants",
));
}
let push_range = vk::PushConstantRange::default()
.stage_flags(vk::ShaderStageFlagBits::VERTEX_BIT | vk::ShaderStageFlagBits::FRAGMENT_BIT)
.offset(0)
.size(UNLIT_PUSH_SIZE);
let set_layouts = [sampler_layout];
let layout_info = vk::PipelineLayoutCreateInfo::default()
.set_layouts(&set_layouts)
.map_err(Error::from)?
.push_constant_ranges(std::slice::from_ref(&push_range));
let layout =
unsafe { device.create_pipeline_layout(&(layout_info).map_err(Error::from)?, None) }
.map_err(|s| Error::backend_failure("Vulkan", "unlit pipeline-layout creation", s))?;
let vert_words = decode_spirv_bytes(UNLIT_VERT_SPV)
.inspect_err(|_| destroy_pipeline_layout(&device, layout))?;
let frag_words = decode_spirv_bytes(UNLIT_FRAG_SPV)
.inspect_err(|_| destroy_pipeline_layout(&device, layout))?;
let vert_module = create_shader_module(&device, &vert_words)
.inspect_err(|_| destroy_pipeline_layout(&device, layout))?;
let frag_module = match create_shader_module(&device, &frag_words) {
Ok(m) => m,
Err(e) => {
unsafe { device.destroy_shader_module(vert_module, None) }?;
destroy_pipeline_layout(&device, layout);
return Err(e);
}
};
let handle = match create_graphics_pipeline_inner(
&device,
layout,
vert_module,
frag_module,
PipelineDepth::Disabled,
PipelineBlend::PremultipliedAlpha,
cache,
) {
Ok(h) => h,
Err(e) => {
destroy_pipeline_layout(&device, layout);
return Err(e);
}
};
Ok(Self {
handle,
layout,
device,
})
}
pub(crate) const fn raw(&self) -> vk::Pipeline {
self.handle
}
pub(crate) const fn layout(&self) -> vk::PipelineLayout {
self.layout
}
}
impl Drop for UnlitPipeline {
fn drop(&mut self) {
destroy_pipeline(&self.device, self.handle);
destroy_pipeline_layout(&self.device, self.layout);
}
}
pub(crate) struct SurfacePipeline {
handle: vk::Pipeline,
layout: vk::PipelineLayout,
device: std::sync::Arc<vk::Device>,
}
impl SurfacePipeline {
#[allow(private_interfaces)]
pub(in crate::runtime) fn new(
device: std::sync::Arc<vk::Device>,
scene_layout: vk::DescriptorSetLayout,
material_layout: vk::DescriptorSetLayout,
limits: DeviceLimits,
cache: vk::PipelineCache,
) -> Result<Self> {
if limits.max_push_constants_size < SURFACE_PUSH_SIZE {
return Err(Error::missing_capability(
"surface pipeline requires 128 bytes of push constants",
));
}
let push_range = vk::PushConstantRange::default()
.stage_flags(vk::ShaderStageFlagBits::VERTEX_BIT)
.offset(0)
.size(SURFACE_PUSH_SIZE);
let set_layouts = [scene_layout, material_layout];
let layout_info = vk::PipelineLayoutCreateInfo::default()
.set_layouts(&set_layouts)
.map_err(Error::from)?
.push_constant_ranges(std::slice::from_ref(&push_range));
let layout =
unsafe { device.create_pipeline_layout(&(layout_info).map_err(Error::from)?, None) }
.map_err(|s| Error::backend_failure("Vulkan", "surface pipeline-layout creation", s))?;
let vert_words = decode_spirv_bytes(SURFACE_VERT_SPV)
.inspect_err(|_| destroy_pipeline_layout(&device, layout))?;
let frag_words = decode_spirv_bytes(SURFACE_FRAG_SPV)
.inspect_err(|_| destroy_pipeline_layout(&device, layout))?;
let vert_module = create_shader_module(&device, &vert_words)
.inspect_err(|_| destroy_pipeline_layout(&device, layout))?;
let frag_module = match create_shader_module(&device, &frag_words) {
Ok(m) => m,
Err(e) => {
unsafe { device.destroy_shader_module(vert_module, None) }?;
destroy_pipeline_layout(&device, layout);
return Err(e);
}
};
let handle = match create_graphics_pipeline_inner(
&device,
layout,
vert_module,
frag_module,
PipelineDepth::WriteAndTest,
PipelineBlend::Opaque,
cache,
) {
Ok(h) => h,
Err(e) => {
destroy_pipeline_layout(&device, layout);
return Err(e);
}
};
Ok(Self {
handle,
layout,
device,
})
}
pub(crate) const fn raw(&self) -> vk::Pipeline {
self.handle
}
pub(crate) const fn layout(&self) -> vk::PipelineLayout {
self.layout
}
}
impl Drop for SurfacePipeline {
fn drop(&mut self) {
destroy_pipeline(&self.device, self.handle);
destroy_pipeline_layout(&self.device, self.layout);
}
}
pub(crate) struct SurfaceBlendPipeline {
handle: vk::Pipeline,
device: std::sync::Arc<vk::Device>,
}
impl SurfaceBlendPipeline {
pub(in crate::runtime) fn new(
device: std::sync::Arc<vk::Device>,
layout: vk::PipelineLayout,
cache: vk::PipelineCache,
) -> Result<Self> {
let vert_words = decode_spirv_bytes(SURFACE_VERT_SPV)?;
let frag_words = decode_spirv_bytes(SURFACE_FRAG_SPV)?;
let vert_module = create_shader_module(&device, &vert_words)?;
let frag_module = match create_shader_module(&device, &frag_words) {
Ok(m) => m,
Err(e) => {
unsafe { device.destroy_shader_module(vert_module, None) }?;
return Err(e);
}
};
let handle = create_graphics_pipeline_inner(
&device,
layout,
vert_module,
frag_module,
PipelineDepth::TestOnly,
PipelineBlend::PremultipliedAlpha,
cache,
)?;
Ok(Self { handle, device })
}
pub(crate) const fn raw(&self) -> vk::Pipeline {
self.handle
}
}
impl Drop for SurfaceBlendPipeline {
fn drop(&mut self) {
destroy_pipeline(&self.device, self.handle);
}
}
pub(crate) struct UnlitDescriptorLayouts {
pub(crate) sampler_layout: vk::DescriptorSetLayout,
device: std::sync::Arc<vk::Device>,
}
impl UnlitDescriptorLayouts {
pub(in crate::runtime) fn new(device: std::sync::Arc<vk::Device>) -> Result<Self> {
let sampler_binding = vk::DescriptorSetLayoutBinding::default()
.binding(0)
.descriptor_type(vk::DescriptorType::COMBINED_IMAGE_SAMPLER)
.descriptor_count(1)
.stage_flags(vk::ShaderStageFlagBits::FRAGMENT_BIT);
let bindings = [sampler_binding];
let info = vk::DescriptorSetLayoutCreateInfo::default().bindings(&bindings);
let layout =
unsafe { device.create_descriptor_set_layout(&(info).map_err(Error::from)?, None) }
.map_err(|s| Error::backend_failure("Vulkan", "unlit descriptor-set-layout creation", s))?;
Ok(Self {
sampler_layout: layout,
device,
})
}
}
impl Drop for UnlitDescriptorLayouts {
fn drop(&mut self) {
let _ = unsafe {
self
.device
.destroy_descriptor_set_layout(self.sampler_layout, None)
};
}
}
pub(crate) struct UnlitDescriptorArena {
device: std::sync::Arc<vk::Device>,
pool: vk::DescriptorPool,
sampler: vk::Sampler,
sets: Vec<vk::DescriptorSet>,
}
impl UnlitDescriptorArena {
pub(in crate::runtime) fn new(
device: std::sync::Arc<vk::Device>,
layout: vk::DescriptorSetLayout,
set_count: u32,
) -> Result<Self> {
let sampler_info = vk::SamplerCreateInfo::default()
.mag_filter(vk::Filter::LINEAR)
.min_filter(vk::Filter::LINEAR)
.mipmap_mode(vk::SamplerMipmapMode::NEAREST)
.address_mode_u(vk::SamplerAddressMode::CLAMP_TO_EDGE)
.address_mode_v(vk::SamplerAddressMode::CLAMP_TO_EDGE)
.address_mode_w(vk::SamplerAddressMode::CLAMP_TO_EDGE)
.min_lod(0.0)
.max_lod(0.0);
let sampler = unsafe { device.create_sampler(&sampler_info, None) }
.map_err(|source| Error::backend_failure("Vulkan", "unlit sampler creation", source))?;
let pool_size = vk::DescriptorPoolSize::default()
.r#type(vk::DescriptorType::COMBINED_IMAGE_SAMPLER)
.descriptor_count(set_count);
let pool_info = vk::DescriptorPoolCreateInfo::default()
.max_sets(set_count)
.pool_sizes(std::slice::from_ref(&pool_size));
let pool =
match unsafe { device.create_descriptor_pool(&(pool_info).map_err(Error::from)?, None) } {
Ok(pool) => pool,
Err(source) => {
unsafe { device.destroy_sampler(sampler, None) }?;
return Err(Error::backend_failure(
"Vulkan",
"unlit descriptor-pool creation",
source,
));
}
};
let layouts = vec![layout; set_count as usize];
let allocate_info = vk::DescriptorSetAllocateInfo::default()
.descriptor_pool(pool)
.set_layouts(&layouts);
let allocate_info = allocate_info.map_err(Error::from)?;
let mut sets = vec![vk::DescriptorSet::default(); layouts.len()];
let sets = match unsafe { device.allocate_descriptor_sets(&allocate_info, &mut sets) } {
Ok(()) => sets,
Err(source) => {
unsafe {
device.destroy_descriptor_pool(pool, None)?;
device.destroy_sampler(sampler, None)?;
}
return Err(Error::backend_failure(
"Vulkan",
"unlit descriptor-set allocation",
source,
));
}
};
Ok(Self {
device,
pool,
sampler,
sets,
})
}
pub(crate) fn write_sampled_image(
&self,
set_index: usize,
view: vk::ImageView,
) -> Result<vk::DescriptorSet> {
let set = *self
.sets
.get(set_index)
.ok_or_else(|| Error::internal("unlit descriptor-set index is out of range"))?;
let image = vk::DescriptorImageInfo::default()
.sampler(self.sampler)
.image_view(view)
.image_layout(vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL);
let write = vk::WriteDescriptorSet::default()
.dst_set(set)
.dst_binding(0)
.descriptor_type(vk::DescriptorType::COMBINED_IMAGE_SAMPLER)
.image_info(std::slice::from_ref(&image));
unsafe {
self
.device
.update_descriptor_sets(&[(write).map_err(Error::from)?], &[])
}?;
Ok(set)
}
}
impl Drop for UnlitDescriptorArena {
fn drop(&mut self) {
unsafe {
let _ = self.device.destroy_descriptor_pool(self.pool, None);
let _ = self.device.destroy_sampler(self.sampler, None);
}
}
}
pub(crate) struct SurfaceDescriptorLayouts {
pub(crate) scene_layout: vk::DescriptorSetLayout,
pub(crate) material_layout: vk::DescriptorSetLayout,
device: std::sync::Arc<vk::Device>,
}
impl SurfaceDescriptorLayouts {
pub(in crate::runtime) fn new(device: std::sync::Arc<vk::Device>) -> Result<Self> {
let scene_binding = vk::DescriptorSetLayoutBinding::default()
.binding(0)
.descriptor_type(vk::DescriptorType::UNIFORM_BUFFER)
.descriptor_count(1)
.stage_flags(vk::ShaderStageFlagBits::FRAGMENT_BIT);
let scene_bindings = [scene_binding];
let scene_info = vk::DescriptorSetLayoutCreateInfo::default().bindings(&scene_bindings);
let scene_layout =
unsafe { device.create_descriptor_set_layout(&(scene_info).map_err(Error::from)?, None) }
.map_err(|s| {
Error::backend_failure("Vulkan", "surface scene descriptor-set-layout creation", s)
})?;
let mat_bindings = [
vk::DescriptorSetLayoutBinding::default()
.binding(0)
.descriptor_type(vk::DescriptorType::COMBINED_IMAGE_SAMPLER)
.descriptor_count(1)
.stage_flags(vk::ShaderStageFlagBits::FRAGMENT_BIT),
vk::DescriptorSetLayoutBinding::default()
.binding(1)
.descriptor_type(vk::DescriptorType::COMBINED_IMAGE_SAMPLER)
.descriptor_count(1)
.stage_flags(vk::ShaderStageFlagBits::FRAGMENT_BIT),
vk::DescriptorSetLayoutBinding::default()
.binding(2)
.descriptor_type(vk::DescriptorType::COMBINED_IMAGE_SAMPLER)
.descriptor_count(1)
.stage_flags(vk::ShaderStageFlagBits::FRAGMENT_BIT),
vk::DescriptorSetLayoutBinding::default()
.binding(3)
.descriptor_type(vk::DescriptorType::UNIFORM_BUFFER)
.descriptor_count(1)
.stage_flags(vk::ShaderStageFlagBits::FRAGMENT_BIT),
];
let mat_info = vk::DescriptorSetLayoutCreateInfo::default().bindings(&mat_bindings);
let material_layout =
match unsafe { device.create_descriptor_set_layout(&(mat_info).map_err(Error::from)?, None) }
{
Ok(l) => l,
Err(s) => {
unsafe { device.destroy_descriptor_set_layout(scene_layout, None) }?;
return Err(Error::backend_failure(
"Vulkan",
"surface material descriptor-set-layout creation",
s,
));
}
};
Ok(Self {
scene_layout,
material_layout,
device,
})
}
}
impl Drop for SurfaceDescriptorLayouts {
fn drop(&mut self) {
unsafe {
let _ = self
.device
.destroy_descriptor_set_layout(self.material_layout, None);
let _ = self
.device
.destroy_descriptor_set_layout(self.scene_layout, None);
}
}
}
pub(crate) struct SurfaceDescriptorArena {
device: std::sync::Arc<vk::Device>,
pool: vk::DescriptorPool,
sampler: vk::Sampler,
scene_sets: Vec<vk::DescriptorSet>,
material_sets: Vec<vk::DescriptorSet>,
max_materials: usize,
}
impl SurfaceDescriptorArena {
pub(in crate::runtime) fn new(
device: std::sync::Arc<vk::Device>,
scene_layout: vk::DescriptorSetLayout,
material_layout: vk::DescriptorSetLayout,
set_count: u32,
max_materials_per_slot: u32,
) -> Result<Self> {
let max_materials_per_slot = max_materials_per_slot.max(1);
let sampler_info = vk::SamplerCreateInfo::default()
.mag_filter(vk::Filter::LINEAR)
.min_filter(vk::Filter::LINEAR)
.mipmap_mode(vk::SamplerMipmapMode::NEAREST)
.address_mode_u(vk::SamplerAddressMode::REPEAT)
.address_mode_v(vk::SamplerAddressMode::REPEAT)
.address_mode_w(vk::SamplerAddressMode::REPEAT)
.min_lod(0.0)
.max_lod(0.0);
let sampler = unsafe { device.create_sampler(&sampler_info, None) }
.map_err(|source| Error::backend_failure("Vulkan", "surface sampler creation", source))?;
let mat_set_total = set_count.saturating_mul(max_materials_per_slot);
let pool_sizes = [
vk::DescriptorPoolSize::default()
.r#type(vk::DescriptorType::UNIFORM_BUFFER)
.descriptor_count(set_count.saturating_add(mat_set_total)),
vk::DescriptorPoolSize::default()
.r#type(vk::DescriptorType::COMBINED_IMAGE_SAMPLER)
.descriptor_count(mat_set_total.saturating_mul(3)),
];
let pool_info = vk::DescriptorPoolCreateInfo::default()
.max_sets(set_count.saturating_add(mat_set_total))
.pool_sizes(&pool_sizes);
let pool =
match unsafe { device.create_descriptor_pool(&(pool_info).map_err(Error::from)?, None) } {
Ok(p) => p,
Err(source) => {
unsafe { device.destroy_sampler(sampler, None) }?;
return Err(Error::backend_failure(
"Vulkan",
"surface descriptor-pool creation",
source,
));
}
};
let allocate_n = |layout: vk::DescriptorSetLayout, n: u32| -> Result<Vec<vk::DescriptorSet>> {
let layouts = vec![layout; n as usize];
let info = vk::DescriptorSetAllocateInfo::default()
.descriptor_pool(pool)
.set_layouts(&layouts)
.map_err(Error::from)?;
let mut sets = vec![vk::DescriptorSet::default(); layouts.len()];
unsafe { device.allocate_descriptor_sets(&info, &mut sets) }.map_err(Error::from)?;
Ok(sets)
};
let scene_sets = match allocate_n(scene_layout, set_count) {
Ok(sets) => sets,
Err(source) => {
unsafe {
device.destroy_descriptor_pool(pool, None)?;
device.destroy_sampler(sampler, None)?;
}
return Err(Error::backend_failure(
"Vulkan",
"surface scene descriptor allocation",
source,
));
}
};
let material_sets = match allocate_n(material_layout, mat_set_total) {
Ok(sets) => sets,
Err(source) => {
unsafe {
device.destroy_descriptor_pool(pool, None)?;
device.destroy_sampler(sampler, None)?;
}
return Err(Error::backend_failure(
"Vulkan",
"surface material descriptor allocation",
source,
));
}
};
Ok(Self {
device,
pool,
sampler,
scene_sets,
material_sets,
max_materials: max_materials_per_slot as usize,
})
}
pub(crate) fn write_scene_slot(
&self,
slot_index: usize,
scene_buffer: vk::Buffer,
scene_size: u64,
) -> Result<vk::DescriptorSet> {
let scene_set = *self
.scene_sets
.get(slot_index)
.ok_or_else(|| Error::internal("surface scene set index is out of range"))?;
let scene_info = vk::DescriptorBufferInfo::default()
.buffer(scene_buffer)
.range(scene_size);
let write = vk::WriteDescriptorSet::default()
.dst_set(scene_set)
.dst_binding(0)
.descriptor_type(vk::DescriptorType::UNIFORM_BUFFER)
.buffer_info(std::slice::from_ref(&scene_info));
unsafe {
self
.device
.update_descriptor_sets(&[(write).map_err(Error::from)?], &[])
}?;
Ok(scene_set)
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn write_material_slot(
&self,
slot_index: usize,
material_index: usize,
material_buffer: vk::Buffer,
material_size: u64,
base_view: Option<vk::ImageView>,
orm_view: Option<vk::ImageView>,
normal_view: Option<vk::ImageView>,
white_view: vk::ImageView,
) -> Result<vk::DescriptorSet> {
let flat = slot_index * self.max_materials + material_index;
let mat_set = *self
.material_sets
.get(flat)
.ok_or_else(|| Error::internal("surface material set index is out of range"))?;
let sampler_image = |view: Option<vk::ImageView>| {
vk::DescriptorImageInfo::default()
.sampler(self.sampler)
.image_view(view.unwrap_or(white_view))
.image_layout(vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL)
};
let base_img = sampler_image(base_view);
let orm_img = sampler_image(orm_view);
let normal_img = sampler_image(normal_view);
let mat_buf_info = vk::DescriptorBufferInfo::default()
.buffer(material_buffer)
.range(material_size);
let writes = [
vk::WriteDescriptorSet::default()
.dst_set(mat_set)
.dst_binding(0)
.descriptor_type(vk::DescriptorType::COMBINED_IMAGE_SAMPLER)
.image_info(std::slice::from_ref(&base_img)),
vk::WriteDescriptorSet::default()
.dst_set(mat_set)
.dst_binding(1)
.descriptor_type(vk::DescriptorType::COMBINED_IMAGE_SAMPLER)
.image_info(std::slice::from_ref(&orm_img)),
vk::WriteDescriptorSet::default()
.dst_set(mat_set)
.dst_binding(2)
.descriptor_type(vk::DescriptorType::COMBINED_IMAGE_SAMPLER)
.image_info(std::slice::from_ref(&normal_img)),
vk::WriteDescriptorSet::default()
.dst_set(mat_set)
.dst_binding(3)
.descriptor_type(vk::DescriptorType::UNIFORM_BUFFER)
.buffer_info(std::slice::from_ref(&mat_buf_info)),
]
.into_iter()
.collect::<std::result::Result<Vec<_>, _>>()
.map_err(Error::from)?;
unsafe { self.device.update_descriptor_sets(&writes, &[]) }?;
Ok(mat_set)
}
#[allow(dead_code)]
pub(crate) const fn max_materials(&self) -> usize {
self.max_materials
}
}
impl Drop for SurfaceDescriptorArena {
fn drop(&mut self) {
unsafe {
let _ = self.device.destroy_descriptor_pool(self.pool, None);
let _ = self.device.destroy_sampler(self.sampler, None);
}
}
}
enum PipelineDepth {
Disabled,
WriteAndTest,
TestOnly,
}
enum PipelineBlend {
Opaque,
PremultipliedAlpha,
}
fn create_graphics_pipeline_inner(
device: &vk::Device,
layout: vk::PipelineLayout,
vert_module: vk::ShaderModule,
frag_module: vk::ShaderModule,
depth: PipelineDepth,
blend: PipelineBlend,
cache: vk::PipelineCache,
) -> Result<vk::Pipeline> {
let stages = [
vk::PipelineShaderStageCreateInfo::default()
.stage(vk::ShaderStageFlagBits::VERTEX_BIT)
.module(vert_module)
.name(c"main"),
vk::PipelineShaderStageCreateInfo::default()
.stage(vk::ShaderStageFlagBits::FRAGMENT_BIT)
.module(frag_module)
.name(c"main"),
];
let binding = vk::VertexInputBindingDescription::default()
.binding(0)
.stride(48)
.input_rate(vk::VertexInputRate::VERTEX);
let attributes = [
vk::VertexInputAttributeDescription::default()
.location(0)
.binding(0)
.format(vk::Format::R32G32B32_SFLOAT)
.offset(0),
vk::VertexInputAttributeDescription::default()
.location(1)
.binding(0)
.format(vk::Format::R32G32B32_SFLOAT)
.offset(12),
vk::VertexInputAttributeDescription::default()
.location(2)
.binding(0)
.format(vk::Format::R32G32_SFLOAT)
.offset(24),
vk::VertexInputAttributeDescription::default()
.location(3)
.binding(0)
.format(vk::Format::R32G32B32A32_SFLOAT)
.offset(32),
];
let vertex_input = vk::PipelineVertexInputStateCreateInfo::default()
.vertex_binding_descriptions(std::slice::from_ref(&binding))
.map_err(Error::from)?
.vertex_attribute_descriptions(&attributes)
.map_err(Error::from)?;
let assembly = vk::PipelineInputAssemblyStateCreateInfo::default()
.topology(vk::PrimitiveTopology::TRIANGLE_LIST);
let viewport_state = vk::PipelineViewportStateCreateInfo::default()
.viewport_count(1)
.scissor_count(1);
let raster = vk::PipelineRasterizationStateCreateInfo::default()
.polygon_mode(vk::PolygonMode::FILL)
.cull_mode(vk::CullModeFlagBits::NONE)
.front_face(vk::FrontFace::COUNTER_CLOCKWISE)
.line_width(1.0);
let multisample = vk::PipelineMultisampleStateCreateInfo::default()
.rasterization_samples(vk::SampleCountFlagBits::_1_BIT);
let depth_stencil = match depth {
PipelineDepth::Disabled => vk::PipelineDepthStencilStateCreateInfo::default(),
PipelineDepth::WriteAndTest => vk::PipelineDepthStencilStateCreateInfo::default()
.depth_test_enable(u32::from(true))
.depth_write_enable(u32::from(true))
.depth_compare_op(vk::CompareOp::LESS)
.min_depth_bounds(0.0)
.max_depth_bounds(1.0),
PipelineDepth::TestOnly => vk::PipelineDepthStencilStateCreateInfo::default()
.depth_test_enable(u32::from(true))
.depth_write_enable(u32::from(false))
.depth_compare_op(vk::CompareOp::LESS)
.min_depth_bounds(0.0)
.max_depth_bounds(1.0),
};
let blend_attachment = match blend {
PipelineBlend::Opaque => vk::PipelineColorBlendAttachmentState::default().color_write_mask(
vk::ColorComponentFlagBits::R_BIT
| vk::ColorComponentFlagBits::G_BIT
| vk::ColorComponentFlagBits::B_BIT
| vk::ColorComponentFlagBits::A_BIT,
),
PipelineBlend::PremultipliedAlpha => vk::PipelineColorBlendAttachmentState::default()
.blend_enable(u32::from(true))
.src_color_blend_factor(vk::BlendFactor::ONE)
.dst_color_blend_factor(vk::BlendFactor::ONE_MINUS_SRC_ALPHA)
.color_blend_op(vk::BlendOp::ADD)
.src_alpha_blend_factor(vk::BlendFactor::ONE)
.dst_alpha_blend_factor(vk::BlendFactor::ONE_MINUS_SRC_ALPHA)
.alpha_blend_op(vk::BlendOp::ADD)
.color_write_mask(
vk::ColorComponentFlagBits::R_BIT
| vk::ColorComponentFlagBits::G_BIT
| vk::ColorComponentFlagBits::B_BIT
| vk::ColorComponentFlagBits::A_BIT,
),
};
let color_blend = vk::PipelineColorBlendStateCreateInfo::default()
.attachments(std::slice::from_ref(&blend_attachment))
.map_err(Error::from)?;
let dynamic_states = [vk::DynamicState::VIEWPORT, vk::DynamicState::SCISSOR];
let dynamic = vk::PipelineDynamicStateCreateInfo::default()
.dynamic_states(&dynamic_states)
.map_err(Error::from)?;
let color_formats = [RENDER_COLOR_FORMAT];
let mut rendering = vk::PipelineRenderingCreateInfo::default()
.color_attachment_formats(&color_formats)
.map_err(Error::from)?
.depth_attachment_format(RENDER_DEPTH_FORMAT);
let pipeline_info = vk::GraphicsPipelineCreateInfo::default()
.push_next(&mut rendering)
.map_err(Error::from)?
.stages(&stages)
.map_err(Error::from)?
.vertex_input_state(&vertex_input)
.input_assembly_state(&assembly)
.viewport_state(&viewport_state)
.rasterization_state(&raster)
.multisample_state(&multisample)
.depth_stencil_state(&depth_stencil)
.color_blend_state(&color_blend)
.dynamic_state(&dynamic)
.layout(layout);
let mut pipelines = [vk::Pipeline::default(); 1];
let result = unsafe {
device.create_graphics_pipelines(
cache,
std::slice::from_ref(&pipeline_info),
None,
&mut pipelines,
)
};
unsafe {
let _ = device.destroy_shader_module(vert_module, None);
let _ = device.destroy_shader_module(frag_module, None);
}
match result {
Ok(vk::Result::SUCCESS) => Ok(pipelines[0]),
result => {
for handle in pipelines
.into_iter()
.filter(|handle| *handle != vk::Pipeline::default())
{
destroy_pipeline(device, handle);
}
Err(Error::backend_dispatch_failure(
"Vulkan",
"graphics-pipeline creation",
result,
))
}
}
}
fn decode_spirv_bytes(bytes: &[u8]) -> Result<Vec<u32>> {
if bytes.len() < 4 || !bytes.len().is_multiple_of(4) {
return Err(Error::backend_failure(
"Vulkan",
"graphics shader SPIR-V byte length",
std::io::Error::other("not a multiple of 4"),
));
}
Ok(
bytes
.chunks(4)
.map(|c| {
let mut word = [0u8; 4];
word.copy_from_slice(c);
u32::from_le_bytes(word)
})
.collect(),
)
}
fn create_shader_module(device: &vk::Device, words: &[u32]) -> Result<vk::ShaderModule> {
let info = vk::ShaderModuleCreateInfo::default().code(words);
unsafe { device.create_shader_module(&info, None) }
.map_err(|s| Error::backend_failure("Vulkan", "graphics shader-module creation", s))
}
const PIPELINE_CACHE_FILE: &str = "pipeline.vcache";
fn pipeline_cache_dir() -> crate::Path {
crate::Path::var().join("vk")
}
pub(in crate::runtime) fn pipeline_cache_path() -> crate::Path {
pipeline_cache_dir().join(PIPELINE_CACHE_FILE)
}
pub(super) struct PipelineCache {
handle: vk::PipelineCache,
device: std::sync::Arc<vk::Device>,
initial_data_bytes: usize,
}
impl PipelineCache {
pub(super) fn new(device: std::sync::Arc<vk::Device>, initial_data: &[u8]) -> Result<Self> {
let info = vk::PipelineCacheCreateInfo::default()
.initial_data(initial_data)
.map_err(Error::from)?;
let handle = unsafe { device.create_pipeline_cache(&info, None) }
.map_err(|s| Error::backend_failure("Vulkan", "pipeline-cache creation", s))?;
Ok(Self {
handle,
device,
initial_data_bytes: initial_data.len(),
})
}
pub(super) fn open(device: &std::sync::Arc<vk::Device>) -> Option<Self> {
let path = pipeline_cache_path();
let initial_data = crate::Filesystem::read_binary(&path).unwrap_or_default();
match Self::new(std::sync::Arc::clone(device), &initial_data) {
Ok(cache) => {
if !initial_data.is_empty() {
crate::log_info!(
crate::LogComponent::COMPUTE,
"pipeline cache: loaded {} bytes from {}",
initial_data.len(),
path.display()
);
}
Some(cache)
}
Err(_) if !initial_data.is_empty() => {
crate::log_warn!(
crate::LogComponent::COMPUTE,
"pipeline cache: driver rejected persisted data; starting cold"
);
Self::new(std::sync::Arc::clone(device), &[]).ok()
}
Err(_) => None,
}
}
pub(super) fn save(&self) {
let data = match self.data() {
Ok(data) if !data.is_empty() => data,
_ => return,
};
let dir = pipeline_cache_dir();
let path = dir.join(PIPELINE_CACHE_FILE);
if crate::Filesystem::create_directories(&dir).is_err()
|| crate::Filesystem::write_binary(&path, &data).is_err()
{
return;
}
crate::log_info!(
crate::LogComponent::COMPUTE,
"pipeline cache: saved {} bytes to {}",
data.len(),
path.display()
);
}
pub(super) fn data(&self) -> Result<Vec<u8>> {
unsafe { self.device.get_pipeline_cache_data(self.handle) }
.map_err(|s| Error::backend_failure("Vulkan", "pipeline-cache data query", s))
}
pub(super) fn merge(&self, sources: &[vk::PipelineCache]) -> Result<()> {
if sources.is_empty() {
return Ok(());
}
unsafe { self.device.merge_pipeline_caches(self.handle, sources) }
.map_err(|s| Error::backend_failure("Vulkan", "pipeline-cache merge", s))
}
pub(super) const fn raw(&self) -> vk::PipelineCache {
self.handle
}
pub(super) const fn initial_data_bytes(&self) -> usize {
self.initial_data_bytes
}
}
impl Drop for PipelineCache {
fn drop(&mut self) {
let _ = unsafe { self.device.destroy_pipeline_cache(self.handle, None) };
}
}
pub(super) struct ComputePipeline {
handle: vk::Pipeline,
layout: vk::PipelineLayout,
max_dispatch_group_count: [u32; 3],
push_constant_size: u32,
}
impl ComputePipeline {
pub(super) fn new(
device: std::sync::Arc<vk::Device>,
descriptor_layout: vk::DescriptorSetLayout,
artifact: &'static ShaderArtifact,
limits: DeviceLimits,
cache: vk::PipelineCache,
) -> Result<Self> {
let push_constant_size = artifact.push_constant_size()?;
validate_artifact_limits(artifact.workgroup_size, push_constant_size, limits)?;
let descriptor_layouts = [descriptor_layout];
let push_range = vk::PushConstantRange::default()
.stage_flags(vk::ShaderStageFlagBits::COMPUTE_BIT)
.offset(0)
.size(push_constant_size);
let push_ranges = [push_range];
let layout_info = vk::PipelineLayoutCreateInfo::default()
.set_layouts(&descriptor_layouts)
.map_err(Error::from)?
.push_constant_ranges(&push_ranges);
let layout =
unsafe { device.create_pipeline_layout(&(layout_info).map_err(Error::from)?, None) }
.map_err(|source| {
Error::backend_failure("Vulkan", "compute pipeline-layout creation", source)
})?;
let words = match artifact.spirv_words() {
Ok(words) => words,
Err(error) => {
destroy_pipeline_layout(&device, layout);
return Err(error);
}
};
let module_info = vk::ShaderModuleCreateInfo::default().code(&words);
let module = match unsafe { device.create_shader_module(&module_info, None) } {
Ok(module) => module,
Err(source) => {
destroy_pipeline_layout(&device, layout);
return Err(Error::backend_failure(
"Vulkan",
"compute shader-module creation",
source,
));
}
};
let stage = vk::PipelineShaderStageCreateInfo::default()
.stage(vk::ShaderStageFlagBits::COMPUTE_BIT)
.module(module)
.name(c"main");
let pipeline_info = vk::ComputePipelineCreateInfo::default()
.stage(stage)
.layout(layout);
let mut pipelines = [vk::Pipeline::default(); 1];
let pipeline_result =
unsafe { device.create_compute_pipelines(cache, &[pipeline_info], None, &mut pipelines) };
unsafe {
let _ = device.destroy_shader_module(module, None);
}
let handle = match pipeline_result {
Ok(vk::Result::SUCCESS) => pipelines[0],
result => {
for pipeline in pipelines
.into_iter()
.filter(|handle| *handle != vk::Pipeline::default())
{
destroy_pipeline(&device, pipeline);
}
destroy_pipeline_layout(&device, layout);
return Err(Error::backend_dispatch_failure(
"Vulkan",
"compute-pipeline creation",
result,
));
}
};
Ok(Self {
handle,
layout,
max_dispatch_group_count: limits.max_compute_work_group_count,
push_constant_size,
})
}
pub(super) fn destroy(&mut self, device: &vk::Device) {
destroy_pipeline(device, self.handle);
destroy_pipeline_layout(device, self.layout);
}
pub(super) const fn raw(&self) -> vk::Pipeline {
self.handle
}
pub(super) const fn layout(&self) -> vk::PipelineLayout {
self.layout
}
pub(super) const fn max_dispatch_group_count(&self) -> [u32; 3] {
self.max_dispatch_group_count
}
pub(super) const fn push_constant_size(&self) -> u32 {
self.push_constant_size
}
}
pub(super) fn validate_artifact_limits(
workgroup_size: [u32; 3],
push_constant_size: u32,
limits: DeviceLimits,
) -> Result<()> {
let invocation_count = workgroup_size
.into_iter()
.try_fold(1_u32, u32::checked_mul)
.ok_or_else(|| Error::missing_capability("shader workgroup size overflows u32"))?;
if push_constant_size > limits.max_push_constants_size
|| invocation_count > limits.max_compute_work_group_invocations
|| workgroup_size
.into_iter()
.zip(limits.max_compute_work_group_size)
.any(|(required, available)| required > available)
{
return Err(Error::missing_capability(
"selected device cannot admit the reflected compute shader ABI",
));
}
Ok(())
}
fn destroy_pipeline(device: &vk::Device, pipeline: vk::Pipeline) {
let _ = unsafe { device.destroy_pipeline(pipeline, None) };
}
fn destroy_pipeline_layout(device: &vk::Device, layout: vk::PipelineLayout) {
let _ = unsafe { device.destroy_pipeline_layout(layout, None) };
}