709 lines
27 KiB
Rust
709 lines
27 KiB
Rust
#![allow(unsafe_code)]
|
|
|
|
use ash::vk;
|
|
use fparkan_platform::DepthStencilSupport;
|
|
|
|
use super::{
|
|
VulkanInstanceProbe, VulkanLogicalDeviceProbe, VulkanSmokeRendererError, VulkanStaticMesh,
|
|
VulkanStaticTexture,
|
|
};
|
|
use crate::select_depth_stencil_attachment_format;
|
|
|
|
pub(super) struct VulkanAllocatedBuffer {
|
|
pub(super) buffer: vk::Buffer,
|
|
pub(super) memory: vk::DeviceMemory,
|
|
}
|
|
|
|
pub(super) struct VulkanAllocatedImage {
|
|
pub(super) image: vk::Image,
|
|
pub(super) memory: vk::DeviceMemory,
|
|
pub(super) view: vk::ImageView,
|
|
}
|
|
|
|
/// Depth/stencil image and the exact format selected for its render pass.
|
|
pub(super) struct VulkanDepthAttachment {
|
|
pub(super) image: VulkanAllocatedImage,
|
|
pub(super) format: vk::Format,
|
|
}
|
|
|
|
#[allow(clippy::too_many_lines)]
|
|
pub(super) fn create_depth_attachment(
|
|
instance: &VulkanInstanceProbe,
|
|
device: &VulkanLogicalDeviceProbe,
|
|
extent: (u32, u32),
|
|
request: DepthStencilSupport,
|
|
) -> Result<VulkanDepthAttachment, VulkanSmokeRendererError> {
|
|
let supported_formats = depth_attachment_formats(instance, device);
|
|
let format = select_depth_stencil_attachment_format(&supported_formats, request)
|
|
.map(vk::Format::from_raw)
|
|
.ok_or(VulkanSmokeRendererError::InvalidStaticMesh {
|
|
context: "logical device has no selected depth attachment format",
|
|
})?;
|
|
let image_info = vk::ImageCreateInfo::default()
|
|
.image_type(vk::ImageType::TYPE_2D)
|
|
.format(format)
|
|
.extent(vk::Extent3D {
|
|
width: extent.0,
|
|
height: extent.1,
|
|
depth: 1,
|
|
})
|
|
.mip_levels(1)
|
|
.array_layers(1)
|
|
.samples(vk::SampleCountFlags::TYPE_1)
|
|
.tiling(vk::ImageTiling::OPTIMAL)
|
|
.usage(vk::ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT)
|
|
.sharing_mode(vk::SharingMode::EXCLUSIVE)
|
|
.initial_layout(vk::ImageLayout::UNDEFINED);
|
|
// SAFETY: The creation info is stack-owned and uses the live non-zero swapchain extent.
|
|
let image = unsafe { device.device().create_image(&image_info, None) }.map_err(|result| {
|
|
VulkanSmokeRendererError::VulkanOperation {
|
|
context: "vkCreateImage(depth attachment)",
|
|
result,
|
|
}
|
|
})?;
|
|
// SAFETY: The newly created image belongs to this device.
|
|
let requirements = unsafe { device.device().get_image_memory_requirements(image) };
|
|
let Some(memory_type_index) = find_memory_type(
|
|
instance,
|
|
device.physical_device(),
|
|
requirements.memory_type_bits,
|
|
vk::MemoryPropertyFlags::DEVICE_LOCAL,
|
|
) else {
|
|
// SAFETY: The unbound image is rolled back on its owning device.
|
|
unsafe { device.device().destroy_image(image, None) };
|
|
return Err(VulkanSmokeRendererError::MissingMemoryType {
|
|
context: "depth attachment",
|
|
});
|
|
};
|
|
let allocation = vk::MemoryAllocateInfo::default()
|
|
.allocation_size(requirements.size)
|
|
.memory_type_index(memory_type_index);
|
|
// SAFETY: Allocation parameters are derived from this image's requirements.
|
|
let allocation_result = unsafe { device.device().allocate_memory(&allocation, None) };
|
|
let memory = match allocation_result {
|
|
Ok(memory) => memory,
|
|
Err(result) => {
|
|
// SAFETY: The unbound image is rolled back on allocation failure.
|
|
unsafe { device.device().destroy_image(image, None) };
|
|
return Err(VulkanSmokeRendererError::VulkanOperation {
|
|
context: "vkAllocateMemory(depth attachment)",
|
|
result,
|
|
});
|
|
}
|
|
};
|
|
// SAFETY: The allocation satisfies this image's queried requirements.
|
|
if let Err(result) = unsafe { device.device().bind_image_memory(image, memory, 0) } {
|
|
// SAFETY: Both newly created resources are rolled back together.
|
|
unsafe {
|
|
device.device().destroy_image(image, None);
|
|
device.device().free_memory(memory, None);
|
|
}
|
|
return Err(VulkanSmokeRendererError::VulkanOperation {
|
|
context: "vkBindImageMemory(depth attachment)",
|
|
result,
|
|
});
|
|
}
|
|
let range = vk::ImageSubresourceRange::default()
|
|
.aspect_mask(depth_aspect(format))
|
|
.base_mip_level(0)
|
|
.level_count(1)
|
|
.base_array_layer(0)
|
|
.layer_count(1);
|
|
let view_info = vk::ImageViewCreateInfo::default()
|
|
.image(image)
|
|
.view_type(vk::ImageViewType::TYPE_2D)
|
|
.format(format)
|
|
.subresource_range(range);
|
|
// SAFETY: The image is bound and the depth/stencil aspect matches its selected format.
|
|
let view_result = unsafe { device.device().create_image_view(&view_info, None) };
|
|
let view = match view_result {
|
|
Ok(view) => view,
|
|
Err(result) => {
|
|
// SAFETY: Both newly created resources are rolled back together.
|
|
unsafe {
|
|
device.device().destroy_image(image, None);
|
|
device.device().free_memory(memory, None);
|
|
}
|
|
return Err(VulkanSmokeRendererError::VulkanOperation {
|
|
context: "vkCreateImageView(depth attachment)",
|
|
result,
|
|
});
|
|
}
|
|
};
|
|
Ok(VulkanDepthAttachment {
|
|
image: VulkanAllocatedImage {
|
|
image,
|
|
memory,
|
|
view,
|
|
},
|
|
format,
|
|
})
|
|
}
|
|
|
|
pub(super) fn destroy_depth_attachment(
|
|
device: &VulkanLogicalDeviceProbe,
|
|
attachment: &VulkanDepthAttachment,
|
|
) {
|
|
destroy_allocated_image(device, &attachment.image);
|
|
}
|
|
|
|
fn depth_attachment_formats(
|
|
instance: &VulkanInstanceProbe,
|
|
device: &VulkanLogicalDeviceProbe,
|
|
) -> Vec<i32> {
|
|
[
|
|
vk::Format::D16_UNORM,
|
|
vk::Format::X8_D24_UNORM_PACK32,
|
|
vk::Format::D32_SFLOAT,
|
|
vk::Format::D16_UNORM_S8_UINT,
|
|
vk::Format::D24_UNORM_S8_UINT,
|
|
vk::Format::D32_SFLOAT_S8_UINT,
|
|
]
|
|
.into_iter()
|
|
.filter(|format| {
|
|
// SAFETY: The physical device belongs to this instance and the query returns a value copy.
|
|
unsafe {
|
|
instance
|
|
.instance
|
|
.get_physical_device_format_properties(device.physical_device(), *format)
|
|
}
|
|
.optimal_tiling_features
|
|
.contains(vk::FormatFeatureFlags::DEPTH_STENCIL_ATTACHMENT)
|
|
})
|
|
.map(vk::Format::as_raw)
|
|
.collect()
|
|
}
|
|
|
|
fn depth_aspect(format: vk::Format) -> vk::ImageAspectFlags {
|
|
match format {
|
|
vk::Format::D16_UNORM_S8_UINT
|
|
| vk::Format::D24_UNORM_S8_UINT
|
|
| vk::Format::D32_SFLOAT_S8_UINT => {
|
|
vk::ImageAspectFlags::DEPTH | vk::ImageAspectFlags::STENCIL
|
|
}
|
|
_ => vk::ImageAspectFlags::DEPTH,
|
|
}
|
|
}
|
|
|
|
pub(super) struct VulkanFrameSync {
|
|
pub(super) image_available: vk::Semaphore,
|
|
pub(super) render_finished: vk::Semaphore,
|
|
pub(super) fence: vk::Fence,
|
|
}
|
|
|
|
pub(super) fn create_command_pool(
|
|
device: &VulkanLogicalDeviceProbe,
|
|
) -> Result<vk::CommandPool, VulkanSmokeRendererError> {
|
|
let create_info = vk::CommandPoolCreateInfo::default()
|
|
.queue_family_index(device.report.graphics_queue_family)
|
|
.flags(vk::CommandPoolCreateFlags::RESET_COMMAND_BUFFER);
|
|
// SAFETY: The queue-family index belongs to this live logical device.
|
|
unsafe { device.device().create_command_pool(&create_info, None) }.map_err(|error| {
|
|
VulkanSmokeRendererError::VulkanOperation {
|
|
context: "vkCreateCommandPool",
|
|
result: error,
|
|
}
|
|
})
|
|
}
|
|
|
|
pub(super) fn create_static_mesh_vertex_buffer(
|
|
instance: &VulkanInstanceProbe,
|
|
device: &VulkanLogicalDeviceProbe,
|
|
mesh: &VulkanStaticMesh,
|
|
) -> Result<VulkanAllocatedBuffer, VulkanSmokeRendererError> {
|
|
let mut bytes = Vec::with_capacity(mesh.vertices.len() * 7 * std::mem::size_of::<f32>());
|
|
for vertex in &mesh.vertices {
|
|
for value in vertex
|
|
.position
|
|
.into_iter()
|
|
.chain(vertex.color)
|
|
.chain(vertex.uv)
|
|
{
|
|
bytes.extend_from_slice(&value.to_ne_bytes());
|
|
}
|
|
}
|
|
create_host_visible_buffer(
|
|
instance,
|
|
device,
|
|
&bytes,
|
|
vk::BufferUsageFlags::VERTEX_BUFFER,
|
|
"static mesh vertex buffer",
|
|
)
|
|
}
|
|
|
|
pub(super) fn create_static_mesh_index_buffer(
|
|
instance: &VulkanInstanceProbe,
|
|
device: &VulkanLogicalDeviceProbe,
|
|
mesh: &VulkanStaticMesh,
|
|
) -> Result<VulkanAllocatedBuffer, VulkanSmokeRendererError> {
|
|
let mut bytes = Vec::with_capacity(mesh.indices.len() * std::mem::size_of::<u16>());
|
|
for &index in &mesh.indices {
|
|
bytes.extend_from_slice(&index.to_ne_bytes());
|
|
}
|
|
create_host_visible_buffer(
|
|
instance,
|
|
device,
|
|
&bytes,
|
|
vk::BufferUsageFlags::INDEX_BUFFER,
|
|
"static mesh index buffer",
|
|
)
|
|
}
|
|
|
|
#[allow(clippy::too_many_lines)]
|
|
pub(super) fn create_static_texture_image(
|
|
instance: &VulkanInstanceProbe,
|
|
device: &VulkanLogicalDeviceProbe,
|
|
command_pool: vk::CommandPool,
|
|
texture: &VulkanStaticTexture,
|
|
) -> Result<VulkanAllocatedImage, VulkanSmokeRendererError> {
|
|
let staging = create_host_visible_buffer(
|
|
instance,
|
|
device,
|
|
&texture.rgba8,
|
|
vk::BufferUsageFlags::TRANSFER_SRC,
|
|
"static texture staging buffer",
|
|
)?;
|
|
let image_info = vk::ImageCreateInfo::default()
|
|
.image_type(vk::ImageType::TYPE_2D)
|
|
.format(vk::Format::R8G8B8A8_UNORM)
|
|
.extent(vk::Extent3D {
|
|
width: texture.width,
|
|
height: texture.height,
|
|
depth: 1,
|
|
})
|
|
.mip_levels(1)
|
|
.array_layers(1)
|
|
.samples(vk::SampleCountFlags::TYPE_1)
|
|
.tiling(vk::ImageTiling::OPTIMAL)
|
|
.usage(vk::ImageUsageFlags::TRANSFER_DST | vk::ImageUsageFlags::SAMPLED)
|
|
.sharing_mode(vk::SharingMode::EXCLUSIVE)
|
|
.initial_layout(vk::ImageLayout::UNDEFINED);
|
|
// SAFETY: The create info only contains stack-owned values and a validated non-zero extent.
|
|
let image = unsafe { device.device().create_image(&image_info, None) }.map_err(|result| {
|
|
destroy_allocated_buffer(device, &staging);
|
|
VulkanSmokeRendererError::VulkanOperation {
|
|
context: "vkCreateImage(static texture)",
|
|
result,
|
|
}
|
|
})?;
|
|
// SAFETY: The image belongs to this device and is queried immediately after creation.
|
|
let requirements = unsafe { device.device().get_image_memory_requirements(image) };
|
|
let Some(memory_type_index) = find_memory_type(
|
|
instance,
|
|
device.physical_device(),
|
|
requirements.memory_type_bits,
|
|
vk::MemoryPropertyFlags::DEVICE_LOCAL,
|
|
) else {
|
|
// SAFETY: Both resources were created on this device and are being rolled back once.
|
|
unsafe { device.device().destroy_image(image, None) };
|
|
destroy_allocated_buffer(device, &staging);
|
|
return Err(VulkanSmokeRendererError::MissingMemoryType {
|
|
context: "static texture image",
|
|
});
|
|
};
|
|
let allocate_info = vk::MemoryAllocateInfo::default()
|
|
.allocation_size(requirements.size)
|
|
.memory_type_index(memory_type_index);
|
|
// SAFETY: The allocation matches the image memory requirements queried above.
|
|
let memory = {
|
|
// SAFETY: The allocation matches the image memory requirements queried above.
|
|
unsafe { device.device().allocate_memory(&allocate_info, None) }
|
|
}
|
|
.map_err(|result| {
|
|
// SAFETY: Both resources were created on this device and are being rolled back once.
|
|
unsafe { device.device().destroy_image(image, None) };
|
|
destroy_allocated_buffer(device, &staging);
|
|
VulkanSmokeRendererError::VulkanOperation {
|
|
context: "vkAllocateMemory(static texture)",
|
|
result,
|
|
}
|
|
})?;
|
|
// SAFETY: The allocation matches this image's queried requirements.
|
|
if let Err(result) = unsafe { device.device().bind_image_memory(image, memory, 0) } {
|
|
// SAFETY: Both resources were created on this device and are being rolled back once.
|
|
unsafe {
|
|
device.device().destroy_image(image, None);
|
|
device.device().free_memory(memory, None);
|
|
};
|
|
destroy_allocated_buffer(device, &staging);
|
|
return Err(VulkanSmokeRendererError::VulkanOperation {
|
|
context: "vkBindImageMemory(static texture)",
|
|
result,
|
|
});
|
|
}
|
|
if let Err(error) = upload_static_texture(
|
|
device,
|
|
command_pool,
|
|
staging.buffer,
|
|
image,
|
|
texture.width,
|
|
texture.height,
|
|
) {
|
|
// SAFETY: Both resources were created on this device and are being rolled back once.
|
|
unsafe {
|
|
device.device().destroy_image(image, None);
|
|
device.device().free_memory(memory, None);
|
|
};
|
|
destroy_allocated_buffer(device, &staging);
|
|
return Err(error);
|
|
}
|
|
destroy_allocated_buffer(device, &staging);
|
|
let view_info = vk::ImageViewCreateInfo::default()
|
|
.image(image)
|
|
.view_type(vk::ImageViewType::TYPE_2D)
|
|
.format(vk::Format::R8G8B8A8_UNORM)
|
|
.subresource_range(color_subresource_range());
|
|
// SAFETY: The image is live, initialized and has the stated color subresource.
|
|
let view = {
|
|
// SAFETY: The image is live, initialized and has the stated color subresource.
|
|
unsafe { device.device().create_image_view(&view_info, None) }
|
|
}
|
|
.map_err(|result| {
|
|
// SAFETY: Both resources were created on this device and are being rolled back once.
|
|
unsafe {
|
|
device.device().destroy_image(image, None);
|
|
device.device().free_memory(memory, None);
|
|
};
|
|
VulkanSmokeRendererError::VulkanOperation {
|
|
context: "vkCreateImageView(static texture)",
|
|
result,
|
|
}
|
|
})?;
|
|
Ok(VulkanAllocatedImage {
|
|
image,
|
|
memory,
|
|
view,
|
|
})
|
|
}
|
|
|
|
#[allow(clippy::too_many_lines)]
|
|
fn upload_static_texture(
|
|
device: &VulkanLogicalDeviceProbe,
|
|
command_pool: vk::CommandPool,
|
|
staging_buffer: vk::Buffer,
|
|
image: vk::Image,
|
|
width: u32,
|
|
height: u32,
|
|
) -> Result<(), VulkanSmokeRendererError> {
|
|
let allocate_info = vk::CommandBufferAllocateInfo::default()
|
|
.command_pool(command_pool)
|
|
.level(vk::CommandBufferLevel::PRIMARY)
|
|
.command_buffer_count(1);
|
|
// SAFETY: The command pool is live and owned by the current logical device.
|
|
let command_buffer = unsafe { device.device().allocate_command_buffers(&allocate_info) }
|
|
.map_err(|result| VulkanSmokeRendererError::VulkanOperation {
|
|
context: "vkAllocateCommandBuffers(texture upload)",
|
|
result,
|
|
})?[0];
|
|
let begin =
|
|
vk::CommandBufferBeginInfo::default().flags(vk::CommandBufferUsageFlags::ONE_TIME_SUBMIT);
|
|
// SAFETY: The command buffer is freshly allocated from the current pool.
|
|
if let Err(result) = unsafe { device.device().begin_command_buffer(command_buffer, &begin) } {
|
|
// SAFETY: The command buffer belongs to this pool and is released on failure.
|
|
unsafe {
|
|
device
|
|
.device()
|
|
.free_command_buffers(command_pool, &[command_buffer]);
|
|
};
|
|
return Err(VulkanSmokeRendererError::VulkanOperation {
|
|
context: "vkBeginCommandBuffer(texture upload)",
|
|
result,
|
|
});
|
|
}
|
|
let range = color_subresource_range();
|
|
let to_transfer = vk::ImageMemoryBarrier::default()
|
|
.old_layout(vk::ImageLayout::UNDEFINED)
|
|
.new_layout(vk::ImageLayout::TRANSFER_DST_OPTIMAL)
|
|
.src_access_mask(vk::AccessFlags::empty())
|
|
.dst_access_mask(vk::AccessFlags::TRANSFER_WRITE)
|
|
.image(image)
|
|
.subresource_range(range);
|
|
let region = vk::BufferImageCopy::default()
|
|
.image_subresource(
|
|
vk::ImageSubresourceLayers::default()
|
|
.aspect_mask(vk::ImageAspectFlags::COLOR)
|
|
.mip_level(0)
|
|
.base_array_layer(0)
|
|
.layer_count(1),
|
|
)
|
|
.image_extent(vk::Extent3D {
|
|
width,
|
|
height,
|
|
depth: 1,
|
|
});
|
|
let to_sampled = vk::ImageMemoryBarrier::default()
|
|
.old_layout(vk::ImageLayout::TRANSFER_DST_OPTIMAL)
|
|
.new_layout(vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL)
|
|
.src_access_mask(vk::AccessFlags::TRANSFER_WRITE)
|
|
.dst_access_mask(vk::AccessFlags::SHADER_READ)
|
|
.image(image)
|
|
.subresource_range(range);
|
|
// SAFETY: The commands operate on live, exclusively owned resources and the stated color subresource.
|
|
unsafe {
|
|
device.device().cmd_pipeline_barrier(
|
|
command_buffer,
|
|
vk::PipelineStageFlags::TOP_OF_PIPE,
|
|
vk::PipelineStageFlags::TRANSFER,
|
|
vk::DependencyFlags::empty(),
|
|
&[],
|
|
&[],
|
|
&[to_transfer],
|
|
);
|
|
device.device().cmd_copy_buffer_to_image(
|
|
command_buffer,
|
|
staging_buffer,
|
|
image,
|
|
vk::ImageLayout::TRANSFER_DST_OPTIMAL,
|
|
&[region],
|
|
);
|
|
device.device().cmd_pipeline_barrier(
|
|
command_buffer,
|
|
vk::PipelineStageFlags::TRANSFER,
|
|
vk::PipelineStageFlags::FRAGMENT_SHADER,
|
|
vk::DependencyFlags::empty(),
|
|
&[],
|
|
&[],
|
|
&[to_sampled],
|
|
);
|
|
}
|
|
// SAFETY: Command recording is complete on the current command buffer.
|
|
if let Err(result) = unsafe { device.device().end_command_buffer(command_buffer) } {
|
|
// SAFETY: The command buffer belongs to this pool and is released on failure.
|
|
unsafe {
|
|
device
|
|
.device()
|
|
.free_command_buffers(command_pool, &[command_buffer]);
|
|
};
|
|
return Err(VulkanSmokeRendererError::VulkanOperation {
|
|
context: "vkEndCommandBuffer(texture upload)",
|
|
result,
|
|
});
|
|
}
|
|
let command_buffers = [command_buffer];
|
|
let submit = [vk::SubmitInfo::default().command_buffers(&command_buffers)];
|
|
// SAFETY: The graphics queue and submitted command buffer are live for the duration of the wait.
|
|
let submit_result = unsafe {
|
|
device
|
|
.device()
|
|
.queue_submit(device.graphics_queue(), &submit, vk::Fence::null())
|
|
};
|
|
let result = submit_result.and_then(|()| {
|
|
// SAFETY: The graphics queue remains live until the synchronous idle wait completes.
|
|
unsafe { device.device().queue_wait_idle(device.graphics_queue()) }
|
|
});
|
|
// SAFETY: Submission completed or failed synchronously and the command buffer is no longer needed.
|
|
unsafe {
|
|
device
|
|
.device()
|
|
.free_command_buffers(command_pool, &[command_buffer]);
|
|
};
|
|
result.map_err(|result| VulkanSmokeRendererError::VulkanOperation {
|
|
context: "vkQueueSubmit/WaitIdle(texture upload)",
|
|
result,
|
|
})
|
|
}
|
|
|
|
pub(super) fn destroy_allocated_image(
|
|
device: &VulkanLogicalDeviceProbe,
|
|
image: &VulkanAllocatedImage,
|
|
) {
|
|
// SAFETY: The image, view and allocation belong to this device and are destroyed once after idle.
|
|
unsafe {
|
|
device.device().destroy_image_view(image.view, None);
|
|
device.device().destroy_image(image.image, None);
|
|
device.device().free_memory(image.memory, None);
|
|
};
|
|
}
|
|
|
|
fn create_host_visible_buffer(
|
|
instance: &VulkanInstanceProbe,
|
|
device: &VulkanLogicalDeviceProbe,
|
|
bytes: &[u8],
|
|
usage: vk::BufferUsageFlags,
|
|
context: &'static str,
|
|
) -> Result<VulkanAllocatedBuffer, VulkanSmokeRendererError> {
|
|
let create_info = vk::BufferCreateInfo::default()
|
|
.size(bytes.len().try_into().unwrap_or(u64::MAX))
|
|
.usage(usage)
|
|
.sharing_mode(vk::SharingMode::EXCLUSIVE);
|
|
// SAFETY: The create info is stack-owned and references no external memory.
|
|
let buffer = unsafe { device.device().create_buffer(&create_info, None) }.map_err(|error| {
|
|
VulkanSmokeRendererError::VulkanOperation {
|
|
context,
|
|
result: error,
|
|
}
|
|
})?;
|
|
// SAFETY: The buffer belongs to this device and is queried immediately after creation.
|
|
let requirements = unsafe { device.device().get_buffer_memory_requirements(buffer) };
|
|
let Some(memory_type_index) = find_memory_type(
|
|
instance,
|
|
device.physical_device(),
|
|
requirements.memory_type_bits,
|
|
vk::MemoryPropertyFlags::HOST_VISIBLE | vk::MemoryPropertyFlags::HOST_COHERENT,
|
|
) else {
|
|
// SAFETY: The buffer was created above on this logical device and is destroyed on setup failure.
|
|
unsafe { device.device().destroy_buffer(buffer, None) };
|
|
return Err(VulkanSmokeRendererError::MissingMemoryType { context });
|
|
};
|
|
let allocate_info = vk::MemoryAllocateInfo::default()
|
|
.allocation_size(requirements.size)
|
|
.memory_type_index(memory_type_index);
|
|
let memory =
|
|
// SAFETY: The allocation request matches the queried memory requirements for this buffer.
|
|
unsafe { device.device().allocate_memory(&allocate_info, None) }.map_err(|error| {
|
|
// SAFETY: The buffer was created above on this logical device and is destroyed on setup failure.
|
|
unsafe { device.device().destroy_buffer(buffer, None) };
|
|
VulkanSmokeRendererError::VulkanOperation {
|
|
context,
|
|
result: error,
|
|
}
|
|
})?;
|
|
// SAFETY: The allocation satisfies the queried buffer memory requirements for this device.
|
|
unsafe { device.device().bind_buffer_memory(buffer, memory, 0) }.map_err(|error| {
|
|
// SAFETY: The buffer and allocation were created above on this logical device and are destroyed on setup failure.
|
|
unsafe {
|
|
device.device().destroy_buffer(buffer, None);
|
|
device.device().free_memory(memory, None);
|
|
}
|
|
VulkanSmokeRendererError::VulkanOperation {
|
|
context,
|
|
result: error,
|
|
}
|
|
})?;
|
|
// SAFETY: The mapping range is within the host-visible allocation bound to the buffer.
|
|
let mapped = unsafe {
|
|
device
|
|
.device()
|
|
.map_memory(memory, 0, requirements.size, vk::MemoryMapFlags::empty())
|
|
}
|
|
.map_err(|error| {
|
|
// SAFETY: The buffer and allocation were created above on this logical device and are destroyed on setup failure.
|
|
unsafe {
|
|
device.device().destroy_buffer(buffer, None);
|
|
device.device().free_memory(memory, None);
|
|
}
|
|
VulkanSmokeRendererError::VulkanOperation {
|
|
context,
|
|
result: error,
|
|
}
|
|
})?;
|
|
// SAFETY: The destination points to the mapped allocation and the source slice lives for the copy.
|
|
unsafe {
|
|
std::ptr::copy_nonoverlapping(bytes.as_ptr(), mapped.cast::<u8>(), bytes.len());
|
|
device.device().unmap_memory(memory);
|
|
}
|
|
Ok(VulkanAllocatedBuffer { buffer, memory })
|
|
}
|
|
|
|
fn find_memory_type(
|
|
instance: &VulkanInstanceProbe,
|
|
physical_device: vk::PhysicalDevice,
|
|
type_bits: u32,
|
|
required: vk::MemoryPropertyFlags,
|
|
) -> Option<u32> {
|
|
let properties =
|
|
// SAFETY: The physical device was selected from this live instance and queried by value.
|
|
unsafe {
|
|
instance
|
|
.instance
|
|
.get_physical_device_memory_properties(physical_device)
|
|
};
|
|
let count = usize::try_from(properties.memory_type_count).unwrap_or(0);
|
|
properties.memory_types[..count]
|
|
.iter()
|
|
.enumerate()
|
|
.find_map(|(index, memory_type)| {
|
|
let index_u32 = u32::try_from(index).ok()?;
|
|
let supported = (type_bits & (1_u32 << index_u32)) != 0;
|
|
(supported && memory_type.property_flags.contains(required)).then_some(index_u32)
|
|
})
|
|
}
|
|
|
|
pub(super) fn create_frame_sync(
|
|
device: &VulkanLogicalDeviceProbe,
|
|
) -> Result<Vec<VulkanFrameSync>, VulkanSmokeRendererError> {
|
|
let semaphore_info = vk::SemaphoreCreateInfo::default();
|
|
let fence_info = vk::FenceCreateInfo::default().flags(vk::FenceCreateFlags::SIGNALED);
|
|
let mut sync = Vec::with_capacity(2);
|
|
for _ in 0..2 {
|
|
// SAFETY: The sync objects belong to this live logical device and are destroyed at teardown.
|
|
let image_available = unsafe { device.device().create_semaphore(&semaphore_info, None) }
|
|
.map_err(|error| VulkanSmokeRendererError::VulkanOperation {
|
|
context: "vkCreateSemaphore(image_available)",
|
|
result: error,
|
|
})?;
|
|
let render_finished = {
|
|
// SAFETY: The sync objects belong to this live logical device and are destroyed at teardown.
|
|
match unsafe { device.device().create_semaphore(&semaphore_info, None) } {
|
|
Ok(render_finished) => render_finished,
|
|
Err(error) => {
|
|
destroy_frame_sync_objects(device, &sync);
|
|
// SAFETY: The semaphore was created above on this logical device and is destroyed on setup failure.
|
|
unsafe { device.device().destroy_semaphore(image_available, None) };
|
|
return Err(VulkanSmokeRendererError::VulkanOperation {
|
|
context: "vkCreateSemaphore(render_finished)",
|
|
result: error,
|
|
});
|
|
}
|
|
}
|
|
};
|
|
// SAFETY: The fence belongs to this live logical device and is destroyed at teardown.
|
|
let fence = match unsafe { device.device().create_fence(&fence_info, None) } {
|
|
Ok(fence) => fence,
|
|
Err(error) => {
|
|
destroy_frame_sync_objects(device, &sync);
|
|
// SAFETY: These semaphores were created above on this logical device and are destroyed on setup failure.
|
|
unsafe {
|
|
device.device().destroy_semaphore(image_available, None);
|
|
device.device().destroy_semaphore(render_finished, None);
|
|
}
|
|
return Err(VulkanSmokeRendererError::VulkanOperation {
|
|
context: "vkCreateFence",
|
|
result: error,
|
|
});
|
|
}
|
|
};
|
|
sync.push(VulkanFrameSync {
|
|
image_available,
|
|
render_finished,
|
|
fence,
|
|
});
|
|
}
|
|
Ok(sync)
|
|
}
|
|
|
|
fn destroy_frame_sync_objects(device: &VulkanLogicalDeviceProbe, sync: &[VulkanFrameSync]) {
|
|
for frame_sync in sync {
|
|
// SAFETY: These sync objects belong to this live logical device and are destroyed once during teardown.
|
|
unsafe {
|
|
device
|
|
.device()
|
|
.destroy_semaphore(frame_sync.image_available, None);
|
|
device
|
|
.device()
|
|
.destroy_semaphore(frame_sync.render_finished, None);
|
|
device.device().destroy_fence(frame_sync.fence, None);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(super) fn destroy_allocated_buffer(
|
|
device: &VulkanLogicalDeviceProbe,
|
|
buffer: &VulkanAllocatedBuffer,
|
|
) {
|
|
// SAFETY: The buffer and allocation belong to this live logical device and are destroyed once during teardown.
|
|
unsafe {
|
|
device.device().destroy_buffer(buffer.buffer, None);
|
|
device.device().free_memory(buffer.memory, None);
|
|
}
|
|
}
|
|
|
|
pub(super) fn color_subresource_range() -> vk::ImageSubresourceRange {
|
|
vk::ImageSubresourceRange::default()
|
|
.aspect_mask(vk::ImageAspectFlags::COLOR)
|
|
.base_mip_level(0)
|
|
.level_count(1)
|
|
.base_array_layer(0)
|
|
.layer_count(1)
|
|
}
|