vulkan: Move to renderer module
Some checks failed
Build legacy Nix package on Ubuntu / build (push) Failing after 1s
Some checks failed
Build legacy Nix package on Ubuntu / build (push) Failing after 1s
This commit is contained in:
parent
001547dbc2
commit
a669247406
GPG key ID:
C73D37CBED7BFC77
21 changed files with 61 additions and 63 deletions
|
|
@ -1,41 +0,0 @@
|
|||
pub(self) mod vk_render_context;
|
||||
pub use vk_render_context::VkRenderContext;
|
||||
|
||||
pub(self) mod vk_instance;
|
||||
pub use vk_instance::VkInstance;
|
||||
|
||||
pub(self) mod vk_surface;
|
||||
pub use vk_surface::VkSurface;
|
||||
|
||||
pub(self) mod vk_physical_device;
|
||||
pub use vk_physical_device::VkPhysicalDevice;
|
||||
|
||||
pub(self) mod vk_device;
|
||||
pub use vk_device::VkDevice;
|
||||
|
||||
pub(self) mod vk_swapchain;
|
||||
pub use vk_swapchain::VkSwapchain;
|
||||
|
||||
pub(self) mod vk_shader_module;
|
||||
pub use vk_shader_module::VkShaderModule;
|
||||
|
||||
pub(self) mod vk_graphics_pipeline;
|
||||
pub use vk_graphics_pipeline::VkGraphicsPipeline;
|
||||
|
||||
mod vk_render_pass;
|
||||
pub(self) use vk_render_pass::VkRenderPass;
|
||||
|
||||
mod vk_semaphore;
|
||||
pub(self) use vk_semaphore::VkSemaphore;
|
||||
|
||||
mod vk_command_pool;
|
||||
pub(self) use vk_command_pool::VkCommandPool;
|
||||
|
||||
mod vk_framebuffer;
|
||||
pub(self) use vk_framebuffer::VkFramebuffer;
|
||||
|
||||
mod vk_fence;
|
||||
pub(self) use vk_fence::VkFence;
|
||||
|
||||
mod utils;
|
||||
mod vertex;
|
||||
|
|
@ -1,51 +0,0 @@
|
|||
use std::ffi::CString;
|
||||
|
||||
pub enum LayersSelector<'a> {
|
||||
Nothing,
|
||||
SpecificLayers(Vec<&'a str>),
|
||||
All,
|
||||
}
|
||||
|
||||
pub fn use_layers(entry: &ash::Entry, selector: LayersSelector) -> Vec<CString> {
|
||||
let layers_available = get_layers_available(entry)
|
||||
.iter()
|
||||
.filter_map(|layer| {
|
||||
layer
|
||||
.layer_name_as_c_str()
|
||||
.and_then(|layer_name| Ok(CString::from(layer_name)))
|
||||
.ok()
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
match selector {
|
||||
LayersSelector::Nothing => Vec::new(),
|
||||
LayersSelector::SpecificLayers(layers) => select_layers(&layers_available, &layers),
|
||||
LayersSelector::All => layers_available,
|
||||
}
|
||||
}
|
||||
|
||||
fn get_layers_available(entry: &ash::Entry) -> Vec<ash::vk::LayerProperties> {
|
||||
unsafe {
|
||||
entry
|
||||
.enumerate_instance_layer_properties()
|
||||
.unwrap_or_default()
|
||||
}
|
||||
}
|
||||
|
||||
fn select_layers(layers_available: &Vec<CString>, layers_to_select: &[&str]) -> Vec<CString> {
|
||||
layers_to_select
|
||||
.iter()
|
||||
.filter_map(|layer_name| {
|
||||
if layers_available.iter().any(|layer_available| {
|
||||
layer_available
|
||||
.to_str()
|
||||
.and_then(|layer_available| Ok(layer_available.eq(*layer_name)))
|
||||
.unwrap_or(false)
|
||||
}) {
|
||||
CString::new(*layer_name).ok()
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
}
|
||||
|
|
@ -1 +0,0 @@
|
|||
pub mod layers;
|
||||
|
|
@ -1,33 +0,0 @@
|
|||
use ash::vk;
|
||||
use std::mem::offset_of;
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct Vertex {
|
||||
pub position: [f32; 2],
|
||||
pub color: [f32; 3],
|
||||
}
|
||||
|
||||
impl Vertex {
|
||||
pub fn get_binding_description() -> vk::VertexInputBindingDescription {
|
||||
vk::VertexInputBindingDescription::default()
|
||||
.binding(0)
|
||||
.stride(size_of::<Self>() as u32)
|
||||
.input_rate(vk::VertexInputRate::VERTEX)
|
||||
}
|
||||
|
||||
pub fn get_attribute_descriptions() -> [vk::VertexInputAttributeDescription; 2] {
|
||||
let position_attribute = vk::VertexInputAttributeDescription::default()
|
||||
.binding(0)
|
||||
.location(0)
|
||||
.format(vk::Format::R32G32_SFLOAT)
|
||||
.offset(offset_of!(Vertex, position) as u32);
|
||||
|
||||
let color_attribute = vk::VertexInputAttributeDescription::default()
|
||||
.binding(0)
|
||||
.location(1)
|
||||
.format(vk::Format::R32G32B32_SFLOAT)
|
||||
.offset(offset_of!(Vertex, color) as u32);
|
||||
|
||||
[position_attribute, color_attribute]
|
||||
}
|
||||
}
|
||||
|
|
@ -1,37 +0,0 @@
|
|||
use crate::vulkan::VkDevice;
|
||||
use ash::prelude::VkResult;
|
||||
use ash::vk;
|
||||
use std::sync::Arc;
|
||||
|
||||
pub struct VkCommandPool {
|
||||
device: Arc<VkDevice>,
|
||||
|
||||
pub(super) handle: vk::CommandPool,
|
||||
}
|
||||
|
||||
impl VkCommandPool {
|
||||
pub fn new(device: &Arc<VkDevice>) -> VkResult<Self> {
|
||||
let command_pool_info =
|
||||
vk::CommandPoolCreateInfo::default()
|
||||
.flags(vk::CommandPoolCreateFlags::RESET_COMMAND_BUFFER)
|
||||
.queue_family_index(device.queue_family_index);
|
||||
let command_pool = unsafe {
|
||||
device
|
||||
.handle
|
||||
.create_command_pool(&command_pool_info, None)?
|
||||
};
|
||||
log::debug!("Command pool created ({command_pool:?})");
|
||||
|
||||
Ok(Self {
|
||||
device: device.clone(),
|
||||
handle: command_pool,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for VkCommandPool {
|
||||
fn drop(&mut self) {
|
||||
unsafe { self.device.handle.destroy_command_pool(self.handle, None) };
|
||||
log::debug!("Command pool destroyed ({:?})", self.handle);
|
||||
}
|
||||
}
|
||||
|
|
@ -1,106 +0,0 @@
|
|||
use crate::vulkan::{VkInstance, VkPhysicalDevice};
|
||||
use ash::prelude::VkResult;
|
||||
use ash::vk;
|
||||
use std::sync::Arc;
|
||||
|
||||
pub struct VkDevice {
|
||||
instance: Arc<VkInstance>,
|
||||
pub(super) handle: ash::Device,
|
||||
pub(super) swapchain_loader: ash::khr::swapchain::Device,
|
||||
pub(super) queue_family_index: u32,
|
||||
|
||||
// Arc not used because vk::Queue is destroyed with Device automatically
|
||||
// so any references of vk::Queue must be destroyed with VkDevice
|
||||
queues: Vec<vk::Queue>,
|
||||
}
|
||||
|
||||
impl VkDevice {
|
||||
pub(super) fn new_graphics_device(
|
||||
instance: &Arc<VkInstance>,
|
||||
physical_device: &VkPhysicalDevice,
|
||||
queue_family_index: u32,
|
||||
) -> anyhow::Result<Self> {
|
||||
let device_extension_names_raw = [
|
||||
ash::khr::swapchain::NAME.as_ptr(),
|
||||
#[cfg(any(target_os = "macos", target_os = "ios"))]
|
||||
ash::khr::portability_subset::NAME.as_ptr(),
|
||||
];
|
||||
let features = vk::PhysicalDeviceFeatures {
|
||||
shader_clip_distance: 1,
|
||||
..Default::default()
|
||||
};
|
||||
|
||||
let queues_priorities = [1.0];
|
||||
let queue_info = vk::DeviceQueueCreateInfo::default()
|
||||
.queue_family_index(queue_family_index)
|
||||
.queue_priorities(&queues_priorities);
|
||||
|
||||
let device_create_info = vk::DeviceCreateInfo::default()
|
||||
.queue_create_infos(std::slice::from_ref(&queue_info))
|
||||
.enabled_extension_names(&device_extension_names_raw)
|
||||
.enabled_features(&features);
|
||||
|
||||
let device = unsafe {
|
||||
instance
|
||||
.handle
|
||||
.create_device(physical_device.handle, &device_create_info, None)?
|
||||
};
|
||||
log::debug!("Device created ({:?})", device.handle());
|
||||
|
||||
let queues = queues_priorities
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(index, _)| unsafe { device.get_device_queue(queue_family_index, index as u32) })
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
let swapchain_loader = ash::khr::swapchain::Device::new(&instance.handle, &device);
|
||||
|
||||
Ok(Self {
|
||||
instance: instance.clone(),
|
||||
handle: device,
|
||||
swapchain_loader,
|
||||
queue_family_index,
|
||||
queues,
|
||||
})
|
||||
}
|
||||
|
||||
pub(super) fn get_device_queue(&self, queue_index: u32) -> Option<&vk::Queue> {
|
||||
self.queues.get(queue_index as usize)
|
||||
}
|
||||
|
||||
pub(super) fn create_command_pool(
|
||||
&self,
|
||||
info: &vk::CommandPoolCreateInfo,
|
||||
) -> VkResult<vk::CommandPool> {
|
||||
let info = info.queue_family_index(self.queue_family_index);
|
||||
|
||||
unsafe { self.handle.create_command_pool(&info, None) }
|
||||
}
|
||||
|
||||
pub(super) fn allocate_command_buffers(
|
||||
&self,
|
||||
info: &vk::CommandBufferAllocateInfo,
|
||||
) -> VkResult<Vec<vk::CommandBuffer>> {
|
||||
unsafe { self.handle.allocate_command_buffers(&info) }
|
||||
}
|
||||
|
||||
pub(super) fn create_fence(&self, info: &vk::FenceCreateInfo) -> VkResult<vk::Fence> {
|
||||
unsafe { self.handle.create_fence(&info, None) }
|
||||
}
|
||||
|
||||
pub(super) fn create_semaphore(
|
||||
&self,
|
||||
info: &vk::SemaphoreCreateInfo,
|
||||
) -> VkResult<vk::Semaphore> {
|
||||
unsafe { self.handle.create_semaphore(&info, None) }
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for VkDevice {
|
||||
fn drop(&mut self) {
|
||||
unsafe {
|
||||
self.handle.destroy_device(None);
|
||||
log::debug!("Device destroyed ({:?})", self.handle.handle());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,30 +0,0 @@
|
|||
use crate::vulkan::VkDevice;
|
||||
use ash::vk;
|
||||
use std::sync::Arc;
|
||||
|
||||
pub struct VkFence {
|
||||
device: Arc<VkDevice>,
|
||||
|
||||
pub(super) handle: vk::Fence,
|
||||
}
|
||||
|
||||
impl VkFence {
|
||||
pub fn new(device: &Arc<VkDevice>) -> anyhow::Result<Self> {
|
||||
let fence_info = vk::FenceCreateInfo::default()
|
||||
.flags(vk::FenceCreateFlags::SIGNALED);
|
||||
let fence = unsafe { device.handle.create_fence(&fence_info, None)? };
|
||||
log::debug!("Fence created ({fence:?})");
|
||||
|
||||
Ok(Self {
|
||||
device: device.clone(),
|
||||
handle: fence,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for VkFence {
|
||||
fn drop(&mut self) {
|
||||
unsafe { self.device.handle.destroy_fence(self.handle, None) };
|
||||
log::debug!("Fence destroyed ({:?})", self.handle);
|
||||
}
|
||||
}
|
||||
|
|
@ -1,45 +0,0 @@
|
|||
use crate::vulkan::vk_render_pass::VkRenderPass;
|
||||
use crate::vulkan::{VkDevice, VkSwapchain};
|
||||
use ash::vk;
|
||||
use std::sync::Arc;
|
||||
|
||||
pub struct VkFramebuffer {
|
||||
device: Arc<VkDevice>,
|
||||
image_view: Arc<vk::ImageView>,
|
||||
render_pass: Arc<VkRenderPass>,
|
||||
|
||||
pub(super) handle: vk::Framebuffer,
|
||||
}
|
||||
|
||||
impl VkFramebuffer {
|
||||
pub fn from_swapchain_image_view(
|
||||
device: &Arc<VkDevice>,
|
||||
render_pass: &Arc<VkRenderPass>,
|
||||
image_view: &Arc<vk::ImageView>,
|
||||
swapchain: &VkSwapchain,
|
||||
) -> anyhow::Result<Self> {
|
||||
let attachments = [*image_view.as_ref()];
|
||||
let framebuffer_info = vk::FramebufferCreateInfo::default()
|
||||
.render_pass(render_pass.handle)
|
||||
.width(swapchain.surface_resolution.width)
|
||||
.height(swapchain.surface_resolution.height)
|
||||
.attachments(&attachments)
|
||||
.layers(1);
|
||||
|
||||
let framebuffer = unsafe { device.handle.create_framebuffer(&framebuffer_info, None)? };
|
||||
|
||||
Ok(Self {
|
||||
device: device.clone(),
|
||||
render_pass: render_pass.clone(),
|
||||
image_view: image_view.clone(),
|
||||
|
||||
handle: framebuffer,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for VkFramebuffer {
|
||||
fn drop(&mut self) {
|
||||
unsafe { self.device.handle.destroy_framebuffer(self.handle, None) };
|
||||
}
|
||||
}
|
||||
|
|
@ -1,121 +0,0 @@
|
|||
use crate::vulkan::vk_render_pass::VkRenderPass;
|
||||
use crate::vulkan::{VkDevice, VkShaderModule, VkSwapchain};
|
||||
use ash::vk;
|
||||
use std::ffi::CStr;
|
||||
use std::sync::Arc;
|
||||
|
||||
pub struct VkGraphicsPipeline {
|
||||
device: Arc<VkDevice>,
|
||||
render_pass: Arc<VkRenderPass>,
|
||||
|
||||
pub(super) pipeline_layout: vk::PipelineLayout,
|
||||
pub(super) pipeline: vk::Pipeline,
|
||||
vertex_shader: VkShaderModule,
|
||||
fragment_shader: VkShaderModule,
|
||||
}
|
||||
|
||||
impl VkGraphicsPipeline {
|
||||
pub fn new(
|
||||
device: &Arc<VkDevice>,
|
||||
render_pass: &Arc<VkRenderPass>,
|
||||
) -> anyhow::Result<Self> {
|
||||
let shader_entry_name = CStr::from_bytes_with_nul(b"main\0")?;
|
||||
|
||||
let vert_shader_module =
|
||||
VkShaderModule::from_spv_file(device, "res/shaders/main.vert.spv")?;
|
||||
|
||||
let vert_shader_info = vk::PipelineShaderStageCreateInfo::default()
|
||||
.module(vert_shader_module.handle)
|
||||
.name(shader_entry_name)
|
||||
.stage(vk::ShaderStageFlags::VERTEX);
|
||||
|
||||
let frag_shader_module =
|
||||
VkShaderModule::from_spv_file(device, "res/shaders/main.frag.spv")?;
|
||||
|
||||
let frag_shader_info = vk::PipelineShaderStageCreateInfo::default()
|
||||
.module(frag_shader_module.handle)
|
||||
.name(shader_entry_name)
|
||||
.stage(vk::ShaderStageFlags::FRAGMENT);
|
||||
|
||||
let shader_stage_create_infos = [vert_shader_info, frag_shader_info];
|
||||
|
||||
let vertex_input_info = vk::PipelineVertexInputStateCreateInfo::default();
|
||||
|
||||
let input_assembly = vk::PipelineInputAssemblyStateCreateInfo::default()
|
||||
.topology(vk::PrimitiveTopology::TRIANGLE_LIST);
|
||||
|
||||
let viewport_state = vk::PipelineViewportStateCreateInfo::default()
|
||||
.viewport_count(1)
|
||||
.scissor_count(1);
|
||||
|
||||
let rasterizer = vk::PipelineRasterizationStateCreateInfo::default()
|
||||
.polygon_mode(vk::PolygonMode::FILL)
|
||||
.cull_mode(vk::CullModeFlags::BACK)
|
||||
.front_face(vk::FrontFace::CLOCKWISE)
|
||||
.line_width(1.0);
|
||||
|
||||
let multisampling = vk::PipelineMultisampleStateCreateInfo::default()
|
||||
.rasterization_samples(vk::SampleCountFlags::TYPE_1)
|
||||
.min_sample_shading(1.0);
|
||||
|
||||
let color_blend_attachment = vk::PipelineColorBlendAttachmentState::default()
|
||||
.color_write_mask(vk::ColorComponentFlags::RGBA);
|
||||
|
||||
let attachments = [color_blend_attachment];
|
||||
let color_blending =
|
||||
vk::PipelineColorBlendStateCreateInfo::default().attachments(&attachments);
|
||||
|
||||
let dynamic_state = vk::PipelineDynamicStateCreateInfo::default()
|
||||
.dynamic_states(&[vk::DynamicState::VIEWPORT, vk::DynamicState::SCISSOR]);
|
||||
|
||||
let pipeline_layout_info = vk::PipelineLayoutCreateInfo::default();
|
||||
let pipeline_layout = unsafe {
|
||||
device
|
||||
.handle
|
||||
.create_pipeline_layout(&pipeline_layout_info, None)?
|
||||
};
|
||||
log::debug!("Pipeline layout created ({pipeline_layout:?})");
|
||||
|
||||
let pipeline_info = vk::GraphicsPipelineCreateInfo::default()
|
||||
.stages(&shader_stage_create_infos)
|
||||
.vertex_input_state(&vertex_input_info)
|
||||
.input_assembly_state(&input_assembly)
|
||||
.viewport_state(&viewport_state)
|
||||
.rasterization_state(&rasterizer)
|
||||
.multisample_state(&multisampling)
|
||||
.color_blend_state(&color_blending)
|
||||
.dynamic_state(&dynamic_state)
|
||||
.layout(pipeline_layout)
|
||||
.render_pass(render_pass.handle);
|
||||
let pipeline = unsafe {
|
||||
device
|
||||
.handle
|
||||
.create_graphics_pipelines(vk::PipelineCache::null(), &[pipeline_info], None)
|
||||
.map_err(|(_, error)| error)?[0]
|
||||
};
|
||||
log::debug!("Pipeline created ({pipeline_layout:?})");
|
||||
|
||||
Ok(Self {
|
||||
device: device.clone(),
|
||||
render_pass: render_pass.clone(),
|
||||
pipeline_layout,
|
||||
pipeline,
|
||||
vertex_shader: vert_shader_module,
|
||||
fragment_shader: frag_shader_module,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for VkGraphicsPipeline {
|
||||
fn drop(&mut self) {
|
||||
unsafe {
|
||||
self.device.handle.destroy_pipeline(self.pipeline, None);
|
||||
log::debug!("Pipeline destroyed ({:?})", self.pipeline);
|
||||
|
||||
self.device
|
||||
.handle
|
||||
.destroy_pipeline_layout(self.pipeline_layout, None);
|
||||
log::debug!("Pipeline layout destroyed ({:?})", self.pipeline_layout);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,125 +0,0 @@
|
|||
use crate::vulkan::utils::layers::{use_layers, LayersSelector};
|
||||
use crate::vulkan::VkPhysicalDevice;
|
||||
use ash::khr::surface;
|
||||
use ash::{vk, Entry, Instance};
|
||||
use std::ffi::{c_char, CStr, CString};
|
||||
|
||||
pub struct VkInstance {
|
||||
pub(super) entry: Entry,
|
||||
pub(super) handle: Instance,
|
||||
pub(super) surface_loader: surface::Instance,
|
||||
}
|
||||
|
||||
impl VkInstance {
|
||||
pub fn new(required_extensions: &Vec<*const c_char>) -> Self {
|
||||
let entry = Entry::linked();
|
||||
|
||||
log::debug!("Initializing Vulkan instance");
|
||||
|
||||
if log::log_enabled!(log::Level::Debug) {
|
||||
let layer_properties =
|
||||
unsafe { entry.enumerate_instance_layer_properties() }.unwrap_or_default();
|
||||
|
||||
for layer_property in layer_properties {
|
||||
let layer_extensions = unsafe {
|
||||
entry.enumerate_instance_extension_properties(
|
||||
layer_property.layer_name_as_c_str().ok(),
|
||||
)
|
||||
}
|
||||
.unwrap_or_default();
|
||||
log::debug!("{layer_property:#?} {layer_extensions:#?}");
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
let required_extensions = required_extensions
|
||||
.iter()
|
||||
.map(|str| unsafe { CStr::from_ptr(*str) })
|
||||
.map(|cstr| cstr.to_string_lossy())
|
||||
.collect::<Vec<_>>();
|
||||
log::debug!(
|
||||
"Required instance extensions: {}",
|
||||
required_extensions.join(", ")
|
||||
);
|
||||
}
|
||||
|
||||
// Layers
|
||||
#[allow(unused)]
|
||||
let mut layer_selector = LayersSelector::Nothing;
|
||||
#[cfg(debug_assertions)]
|
||||
{
|
||||
layer_selector = LayersSelector::SpecificLayers(vec![
|
||||
"VK_LAYER_KHRONOS_validation",
|
||||
"VK_LAYER_MANGOHUD_overlay_x86_64",
|
||||
"VK_LAYER_NV_optimus",
|
||||
]);
|
||||
}
|
||||
let layers = use_layers(&entry, layer_selector);
|
||||
|
||||
{
|
||||
let layers = layers
|
||||
.iter()
|
||||
.map(|layer| layer.to_string_lossy())
|
||||
.collect::<Vec<_>>();
|
||||
log::debug!("Selected debug layers : {}", layers.join(", "))
|
||||
}
|
||||
|
||||
let layers_raw = layers.iter().map(|s| s.as_ptr()).collect::<Vec<_>>();
|
||||
|
||||
// App Info
|
||||
let app_name = CString::new("VulkanTriangle").unwrap();
|
||||
let appinfo = vk::ApplicationInfo::default()
|
||||
.application_name(app_name.as_c_str())
|
||||
.application_version(0)
|
||||
.engine_name(app_name.as_c_str())
|
||||
.engine_version(0)
|
||||
.api_version(vk::make_api_version(0, 1, 0, 0));
|
||||
|
||||
let create_flags = if cfg!(any(target_os = "macos", target_os = "ios")) {
|
||||
vk::InstanceCreateFlags::ENUMERATE_PORTABILITY_KHR
|
||||
} else {
|
||||
vk::InstanceCreateFlags::default()
|
||||
};
|
||||
|
||||
// Instance Info
|
||||
let create_info = vk::InstanceCreateInfo::default()
|
||||
.application_info(&appinfo)
|
||||
.enabled_layer_names(&layers_raw)
|
||||
.enabled_extension_names(&required_extensions)
|
||||
.flags(create_flags);
|
||||
|
||||
let instance: Instance = unsafe {
|
||||
entry
|
||||
.create_instance(&create_info, None)
|
||||
.expect("Instance creation error")
|
||||
};
|
||||
|
||||
let surface_loader = surface::Instance::new(&entry, &instance);
|
||||
|
||||
log::debug!("Vulkan instance created ({:?})", instance.handle());
|
||||
|
||||
Self {
|
||||
entry,
|
||||
handle: instance,
|
||||
surface_loader,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_physical_devices(&self) -> Vec<VkPhysicalDevice> {
|
||||
let physical_devices = unsafe { self.handle.enumerate_physical_devices() };
|
||||
physical_devices
|
||||
.unwrap_or_default()
|
||||
.iter()
|
||||
.map(|physical_device| VkPhysicalDevice::new(&self.handle, *physical_device))
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for VkInstance {
|
||||
fn drop(&mut self) {
|
||||
unsafe {
|
||||
self.handle.destroy_instance(None);
|
||||
}
|
||||
log::debug!("Vulkan instance destroyed ({:?})", self.handle.handle());
|
||||
}
|
||||
}
|
||||
|
|
@ -1,82 +0,0 @@
|
|||
use crate::vulkan::vk_surface::VkSurface;
|
||||
use ash::vk;
|
||||
|
||||
pub struct VkPhysicalDevice {
|
||||
// Vulkan properties
|
||||
pub(super) handle: vk::PhysicalDevice,
|
||||
pub properties: vk::PhysicalDeviceProperties,
|
||||
pub features: vk::PhysicalDeviceFeatures,
|
||||
pub queue_family_properties: Vec<vk::QueueFamilyProperties>,
|
||||
}
|
||||
|
||||
impl VkPhysicalDevice {
|
||||
pub fn new(instance: &ash::Instance, physical_device: vk::PhysicalDevice) -> Self {
|
||||
log::debug!("New physical device");
|
||||
let device_properties = unsafe { instance.get_physical_device_properties(physical_device) };
|
||||
log::debug!("{device_properties:#?}");
|
||||
let device_features = unsafe { instance.get_physical_device_features(physical_device) };
|
||||
log::debug!("{device_features:#?}");
|
||||
let device_queue_families =
|
||||
unsafe { instance.get_physical_device_queue_family_properties(physical_device) };
|
||||
log::debug!("{device_queue_families:#?}");
|
||||
|
||||
Self {
|
||||
handle: physical_device,
|
||||
properties: device_properties,
|
||||
features: device_features,
|
||||
queue_family_properties: device_queue_families,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn find_queue_family_by(
|
||||
&self,
|
||||
queue_flags: Option<vk::QueueFlags>,
|
||||
surface: Option<&VkSurface>,
|
||||
) -> Option<(u32, &vk::QueueFamilyProperties)> {
|
||||
self.queue_family_properties.iter().enumerate().find_map(
|
||||
|(index, queue_family_property)| {
|
||||
let surface_check_passed = match surface {
|
||||
Some(surface) => surface
|
||||
.physical_device_queue_supported(self, index as u32)
|
||||
.unwrap_or(false),
|
||||
None => true,
|
||||
};
|
||||
|
||||
let queue_flags_check_passed = match queue_flags {
|
||||
Some(queue_flags) => queue_family_property.queue_flags.contains(queue_flags),
|
||||
None => true,
|
||||
};
|
||||
|
||||
if surface_check_passed && queue_flags_check_passed {
|
||||
Some((index as u32, queue_family_property))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
pub fn pick_physical_device_and_queue_by<'a>(
|
||||
physical_devices: &'a Vec<VkPhysicalDevice>,
|
||||
queue_flags: Option<vk::QueueFlags>,
|
||||
surface: Option<&VkSurface>,
|
||||
) -> Option<(&'a VkPhysicalDevice, u32, &'a vk::QueueFamilyProperties)> {
|
||||
physical_devices.iter().find_map(|physical_device| {
|
||||
physical_device
|
||||
.find_queue_family_by(queue_flags, surface)
|
||||
.and_then(|(queue_index, queue_family_properties)| {
|
||||
Some((physical_device, queue_index, queue_family_properties))
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
pub fn priority(&self) -> usize {
|
||||
match self.properties.device_type {
|
||||
vk::PhysicalDeviceType::CPU => 1,
|
||||
vk::PhysicalDeviceType::VIRTUAL_GPU => 2,
|
||||
vk::PhysicalDeviceType::INTEGRATED_GPU => 3,
|
||||
vk::PhysicalDeviceType::DISCRETE_GPU => 4,
|
||||
_ => 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,229 +0,0 @@
|
|||
use crate::vulkan::{
|
||||
VkCommandPool, VkDevice, VkFence, VkFramebuffer, VkGraphicsPipeline, VkInstance, VkPhysicalDevice,
|
||||
VkRenderPass, VkSemaphore, VkSurface, VkSwapchain,
|
||||
};
|
||||
use ash::vk;
|
||||
use std::sync::Arc;
|
||||
|
||||
pub struct VkRenderContext {
|
||||
instance: Arc<VkInstance>,
|
||||
surface: Arc<VkSurface>,
|
||||
device: Arc<VkDevice>,
|
||||
|
||||
swapchain: Arc<VkSwapchain>,
|
||||
render_pass: Arc<VkRenderPass>,
|
||||
framebuffers: Vec<Arc<VkFramebuffer>>,
|
||||
pipeline: Arc<VkGraphicsPipeline>,
|
||||
command_pool: VkCommandPool,
|
||||
command_buffers: Vec<vk::CommandBuffer>,
|
||||
image_available_semaphore: VkSemaphore,
|
||||
render_finished_semaphore: VkSemaphore,
|
||||
in_flight_fence: VkFence,
|
||||
}
|
||||
|
||||
impl VkRenderContext {
|
||||
pub fn init(window: &crate::display::Window) -> anyhow::Result<Self> {
|
||||
let required_extensions = window.required_extensions()?;
|
||||
|
||||
let instance = Arc::new(VkInstance::new(&required_extensions));
|
||||
let surface = Arc::new(VkSurface::new(&window, instance.clone())?);
|
||||
|
||||
let mut physical_devices = instance.get_physical_devices();
|
||||
physical_devices.sort_by(|a, b| b.priority().cmp(&a.priority()));
|
||||
|
||||
let (physical_device, queue_family_index, properties) =
|
||||
VkPhysicalDevice::pick_physical_device_and_queue_by(
|
||||
&physical_devices,
|
||||
Some(vk::QueueFlags::GRAPHICS),
|
||||
Some(&surface),
|
||||
)
|
||||
.ok_or_else(|| anyhow::anyhow!("Unable to find physical device"))?;
|
||||
log::debug!(
|
||||
"Selected queue {properties:#?} for physical device {:?}",
|
||||
physical_device.properties.device_name_as_c_str()
|
||||
);
|
||||
|
||||
let device = Arc::new(VkDevice::new_graphics_device(
|
||||
&instance,
|
||||
&physical_device,
|
||||
queue_family_index,
|
||||
)?);
|
||||
|
||||
let swapchain = Arc::new(VkSwapchain::new(
|
||||
&window,
|
||||
&surface,
|
||||
&device,
|
||||
&physical_device,
|
||||
)?);
|
||||
|
||||
let render_pass = Arc::new(VkRenderPass::new(&device, &swapchain)?);
|
||||
|
||||
let framebuffers = swapchain
|
||||
.create_framebuffers(&render_pass)
|
||||
.ok_or_else(|| anyhow::anyhow!("Failed to get framebuffers"))?;
|
||||
|
||||
let pipeline = Arc::new(VkGraphicsPipeline::new(&device, &render_pass)?);
|
||||
|
||||
let command_pool = VkCommandPool::new(&device)?;
|
||||
|
||||
let command_buffer_info = vk::CommandBufferAllocateInfo::default()
|
||||
.command_pool(command_pool.handle)
|
||||
.level(vk::CommandBufferLevel::PRIMARY)
|
||||
.command_buffer_count(framebuffers.len() as u32);
|
||||
|
||||
// Destroyed with command pool
|
||||
let command_buffers = unsafe {
|
||||
device
|
||||
.handle
|
||||
.allocate_command_buffers(&command_buffer_info)?
|
||||
};
|
||||
|
||||
let image_available_semaphore = VkSemaphore::new(&device)?;
|
||||
let render_finished_semaphore = VkSemaphore::new(&device)?;
|
||||
let in_flight_fence = VkFence::new(&device)?;
|
||||
|
||||
Ok(Self {
|
||||
instance,
|
||||
surface,
|
||||
device,
|
||||
|
||||
swapchain,
|
||||
render_pass,
|
||||
framebuffers,
|
||||
pipeline,
|
||||
|
||||
command_pool,
|
||||
command_buffers,
|
||||
|
||||
image_available_semaphore,
|
||||
render_finished_semaphore,
|
||||
in_flight_fence,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn render(&mut self) -> anyhow::Result<()> {
|
||||
unsafe { self.device.handle.wait_for_fences(&[self.in_flight_fence.handle], true, u64::MAX)? };
|
||||
unsafe { self.device.handle.reset_fences(&[self.in_flight_fence.handle])? };
|
||||
|
||||
let (index, _) = self
|
||||
.swapchain
|
||||
.acquire_next_image(&self.image_available_semaphore)?;
|
||||
|
||||
// if self.swapchain.is_dirty() {
|
||||
// self.update_swapchain()?
|
||||
// }
|
||||
|
||||
let command_buffer = self.command_buffers[index as usize];
|
||||
unsafe { self.device.handle.reset_command_buffer(command_buffer, vk::CommandBufferResetFlags::default())? };
|
||||
|
||||
let render_area = vk::Rect2D::default().extent(self.swapchain.surface_resolution);
|
||||
let clear_value = vk::ClearValue::default();
|
||||
let command_buffer_begin_info = vk::CommandBufferBeginInfo::default();
|
||||
unsafe {
|
||||
self.device
|
||||
.handle
|
||||
.begin_command_buffer(command_buffer, &command_buffer_begin_info)?
|
||||
};
|
||||
|
||||
let clear_values = [clear_value];
|
||||
let framebuffer = self.framebuffers[index as usize].as_ref();
|
||||
let render_pass_begin_info = vk::RenderPassBeginInfo::default()
|
||||
.render_pass(self.render_pass.handle)
|
||||
.framebuffer(framebuffer.handle)
|
||||
.render_area(render_area)
|
||||
.clear_values(&clear_values);
|
||||
|
||||
unsafe {
|
||||
self.device.handle.cmd_begin_render_pass(
|
||||
command_buffer,
|
||||
&render_pass_begin_info,
|
||||
vk::SubpassContents::INLINE,
|
||||
);
|
||||
};
|
||||
|
||||
unsafe {
|
||||
self.device.handle.cmd_bind_pipeline(
|
||||
command_buffer,
|
||||
vk::PipelineBindPoint::GRAPHICS,
|
||||
self.pipeline.pipeline,
|
||||
)
|
||||
};
|
||||
|
||||
let viewport = vk::Viewport::default()
|
||||
.width(self.swapchain.surface_resolution.width as f32)
|
||||
.height(self.swapchain.surface_resolution.height as f32)
|
||||
.max_depth(1.0);
|
||||
|
||||
unsafe { self.device.handle.cmd_set_viewport(command_buffer, 0, &[viewport]) }
|
||||
|
||||
let scissor = self.swapchain.surface_resolution.into();
|
||||
|
||||
unsafe { self.device.handle.cmd_set_scissor(command_buffer, 0, &[scissor]) }
|
||||
|
||||
unsafe { self.device.handle.cmd_draw(command_buffer, 3, 1, 0, 0) };
|
||||
|
||||
unsafe { self.device.handle.cmd_end_render_pass(command_buffer) };
|
||||
|
||||
unsafe { self.device.handle.end_command_buffer(command_buffer)? };
|
||||
|
||||
let wait_semaphores = [self.image_available_semaphore.handle];
|
||||
let signal_semaphores = [self.render_finished_semaphore.handle];
|
||||
let wait_stages = [vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT];
|
||||
let command_buffers_to_submit = [command_buffer];
|
||||
let submit_info = vk::SubmitInfo::default()
|
||||
.wait_semaphores(&wait_semaphores)
|
||||
.wait_dst_stage_mask(&wait_stages)
|
||||
.command_buffers(&command_buffers_to_submit)
|
||||
.signal_semaphores(&signal_semaphores);
|
||||
|
||||
let queue = self
|
||||
.device
|
||||
.get_device_queue(0)
|
||||
.ok_or_else(|| anyhow::anyhow!("Failed to get a queue"))?;
|
||||
|
||||
unsafe {
|
||||
self.device
|
||||
.handle
|
||||
.queue_submit(*queue, &[submit_info], self.in_flight_fence.handle)?
|
||||
};
|
||||
|
||||
let swapchains = [self.swapchain.handle.unwrap()];
|
||||
let indices = [index];
|
||||
let present_info = vk::PresentInfoKHR::default()
|
||||
.wait_semaphores(&signal_semaphores)
|
||||
.swapchains(&swapchains)
|
||||
.image_indices(&indices);
|
||||
|
||||
unsafe { self.device.swapchain_loader.queue_present(*queue, &present_info)? };
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn update_resolution(&mut self, width: u32, height: u32) -> anyhow::Result<()> {
|
||||
match Arc::get_mut(&mut self.swapchain) {
|
||||
Some(swapchain) => swapchain.update_resolution(width, height)?,
|
||||
None => log::warn!("Impossible to get mutable swapchain"),
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn exit(&self) {
|
||||
unsafe { self.device.handle.device_wait_idle().unwrap() }
|
||||
}
|
||||
|
||||
fn update_swapchain(&mut self) -> anyhow::Result<()> {
|
||||
match Arc::get_mut(&mut self.swapchain) {
|
||||
Some(swapchain) => {
|
||||
swapchain.create_swapchain()?;
|
||||
|
||||
self.framebuffers = self.swapchain
|
||||
.create_framebuffers(&self.render_pass)
|
||||
.ok_or_else(|| anyhow::anyhow!("Failed to get framebuffers"))?;
|
||||
}
|
||||
None => log::warn!("Impossible to get mutable swapchain"),
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
|
@ -1,56 +0,0 @@
|
|||
use crate::vulkan::{VkDevice, VkSwapchain};
|
||||
use ash::prelude::VkResult;
|
||||
use ash::vk;
|
||||
use std::sync::Arc;
|
||||
|
||||
pub struct VkRenderPass {
|
||||
device: Arc<VkDevice>,
|
||||
|
||||
pub(super) handle: vk::RenderPass,
|
||||
}
|
||||
|
||||
impl VkRenderPass {
|
||||
pub fn new(device: &Arc<VkDevice>, swapchain: &Arc<VkSwapchain>) -> VkResult<Self> {
|
||||
let color_attachment = vk::AttachmentDescription::default()
|
||||
.format(swapchain.surface_format.format)
|
||||
.samples(vk::SampleCountFlags::TYPE_1)
|
||||
.load_op(vk::AttachmentLoadOp::CLEAR)
|
||||
.store_op(vk::AttachmentStoreOp::STORE)
|
||||
.stencil_load_op(vk::AttachmentLoadOp::DONT_CARE)
|
||||
.stencil_store_op(vk::AttachmentStoreOp::DONT_CARE)
|
||||
.initial_layout(vk::ImageLayout::UNDEFINED)
|
||||
.final_layout(vk::ImageLayout::PRESENT_SRC_KHR);
|
||||
|
||||
let color_attachment_ref = vk::AttachmentReference::default()
|
||||
.attachment(0)
|
||||
.layout(vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL);
|
||||
|
||||
let color_attachments = [color_attachment_ref];
|
||||
let subpass = vk::SubpassDescription::default()
|
||||
.pipeline_bind_point(vk::PipelineBindPoint::GRAPHICS)
|
||||
.color_attachments(&color_attachments);
|
||||
|
||||
let attachments = [color_attachment];
|
||||
let subpasses = [subpass];
|
||||
let render_pass_info = vk::RenderPassCreateInfo::default()
|
||||
.attachments(&attachments)
|
||||
.subpasses(&subpasses);
|
||||
|
||||
let render_pass = unsafe { device.handle.create_render_pass(&render_pass_info, None)? };
|
||||
log::debug!("Render pass created ({render_pass:?})");
|
||||
|
||||
Ok(Self {
|
||||
device: device.clone(),
|
||||
handle: render_pass,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for VkRenderPass {
|
||||
fn drop(&mut self) {
|
||||
unsafe {
|
||||
self.device.handle.destroy_render_pass(self.handle, None);
|
||||
log::debug!("Render pass destroyed ({:?})", self.handle);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,29 +0,0 @@
|
|||
use crate::vulkan::VkDevice;
|
||||
use ash::vk;
|
||||
use std::sync::Arc;
|
||||
|
||||
pub struct VkSemaphore {
|
||||
device: Arc<VkDevice>,
|
||||
|
||||
pub(super) handle: vk::Semaphore,
|
||||
}
|
||||
|
||||
impl VkSemaphore {
|
||||
pub fn new(device: &Arc<VkDevice>) -> anyhow::Result<Self> {
|
||||
let semaphore_info = vk::SemaphoreCreateInfo::default();
|
||||
let semaphore = unsafe { device.handle.create_semaphore(&semaphore_info, None)? };
|
||||
log::debug!("Semaphore created ({semaphore:?})");
|
||||
|
||||
Ok(Self {
|
||||
device: device.clone(),
|
||||
handle: semaphore,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for VkSemaphore {
|
||||
fn drop(&mut self) {
|
||||
unsafe { self.device.handle.destroy_semaphore(self.handle, None) };
|
||||
log::debug!("Semaphore destroyed ({:?})", self.handle);
|
||||
}
|
||||
}
|
||||
|
|
@ -1,42 +0,0 @@
|
|||
use crate::vulkan::VkDevice;
|
||||
use ash::vk;
|
||||
use std::path::Path;
|
||||
use std::sync::Arc;
|
||||
|
||||
pub struct VkShaderModule {
|
||||
device: Arc<VkDevice>,
|
||||
|
||||
pub(super) handle: vk::ShaderModule,
|
||||
}
|
||||
|
||||
impl VkShaderModule {
|
||||
pub fn from_spv_file<P: AsRef<Path>>(device: &Arc<VkDevice>, path: P) -> anyhow::Result<Self> {
|
||||
let mut file = std::fs::File::open(&path)?;
|
||||
let frag_shader_str = ash::util::read_spv(&mut file)?;
|
||||
|
||||
let shader_create_info = vk::ShaderModuleCreateInfo::default().code(&frag_shader_str);
|
||||
let shader_module = unsafe {
|
||||
device
|
||||
.handle
|
||||
.create_shader_module(&shader_create_info, None)?
|
||||
};
|
||||
log::debug!(
|
||||
"Shader module created ({shader_module:?}) from {:?}",
|
||||
path.as_ref()
|
||||
);
|
||||
|
||||
Ok(Self {
|
||||
device: device.clone(),
|
||||
handle: shader_module,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for VkShaderModule {
|
||||
fn drop(&mut self) {
|
||||
unsafe {
|
||||
self.device.handle.destroy_shader_module(self.handle, None);
|
||||
log::debug!("Shader module destroyed ({:?})", self.handle);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,94 +0,0 @@
|
|||
use crate::vulkan::{VkInstance, VkPhysicalDevice};
|
||||
use ash::prelude::VkResult;
|
||||
use ash::vk;
|
||||
use std::sync::Arc;
|
||||
use winit::raw_window_handle::{HasDisplayHandle, HasWindowHandle};
|
||||
|
||||
pub struct SwapchainSupportDetails(
|
||||
pub Vec<vk::SurfaceFormatKHR>,
|
||||
pub vk::SurfaceCapabilitiesKHR,
|
||||
pub Vec<vk::PresentModeKHR>,
|
||||
);
|
||||
|
||||
pub struct VkSurface {
|
||||
instance: Arc<VkInstance>,
|
||||
|
||||
pub(super) handle: vk::SurfaceKHR,
|
||||
}
|
||||
|
||||
impl VkSurface {
|
||||
pub fn new(window: &crate::display::Window, instance: Arc<VkInstance>) -> anyhow::Result<Self> {
|
||||
let window_handle = window
|
||||
.handle()
|
||||
.ok_or_else(|| anyhow::anyhow!("Window handle is not available."))?;
|
||||
|
||||
let surface = unsafe {
|
||||
ash_window::create_surface(
|
||||
&instance.entry,
|
||||
&instance.handle,
|
||||
window_handle.display_handle()?.as_raw(),
|
||||
window_handle.window_handle()?.as_raw(),
|
||||
None,
|
||||
)?
|
||||
};
|
||||
|
||||
log::debug!("Surface created ({:?})", surface);
|
||||
|
||||
Ok(Self { instance, handle: surface })
|
||||
}
|
||||
|
||||
pub fn physical_device_queue_supported(
|
||||
&self,
|
||||
physical_device: &VkPhysicalDevice,
|
||||
queue_index: u32,
|
||||
) -> VkResult<bool> {
|
||||
unsafe {
|
||||
self.instance
|
||||
.surface_loader
|
||||
.get_physical_device_surface_support(
|
||||
physical_device.handle,
|
||||
queue_index,
|
||||
self.handle,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_physical_device_swapchain_support_details(
|
||||
&self,
|
||||
physical_device: &VkPhysicalDevice,
|
||||
) -> VkResult<SwapchainSupportDetails> {
|
||||
unsafe {
|
||||
let formats = self
|
||||
.instance
|
||||
.surface_loader
|
||||
.get_physical_device_surface_formats(physical_device.handle, self.handle)?;
|
||||
|
||||
let capabilities = self
|
||||
.instance
|
||||
.surface_loader
|
||||
.get_physical_device_surface_capabilities(physical_device.handle, self.handle)?;
|
||||
|
||||
let present_modes = self
|
||||
.instance
|
||||
.surface_loader
|
||||
.get_physical_device_surface_present_modes(physical_device.handle, self.handle)?;
|
||||
|
||||
Ok(SwapchainSupportDetails(
|
||||
formats,
|
||||
capabilities,
|
||||
present_modes,
|
||||
))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for VkSurface {
|
||||
fn drop(&mut self) {
|
||||
unsafe {
|
||||
self.instance
|
||||
.surface_loader
|
||||
.destroy_surface(self.handle, None);
|
||||
}
|
||||
log::debug!("Surface destroyed ({:?})", self.handle);
|
||||
}
|
||||
}
|
||||
|
|
@ -1,300 +0,0 @@
|
|||
use crate::display::Window;
|
||||
use crate::vulkan::vk_render_pass::VkRenderPass;
|
||||
use crate::vulkan::vk_semaphore::VkSemaphore;
|
||||
use crate::vulkan::vk_surface::SwapchainSupportDetails;
|
||||
use crate::vulkan::{VkDevice, VkFramebuffer, VkPhysicalDevice, VkSurface};
|
||||
use ash::prelude::VkResult;
|
||||
use ash::vk;
|
||||
use std::sync::Arc;
|
||||
|
||||
pub struct VkSwapchain {
|
||||
surface: Arc<VkSurface>,
|
||||
device: Arc<VkDevice>,
|
||||
|
||||
pub(super) handle: Option<vk::SwapchainKHR>,
|
||||
swapchain_support_details: SwapchainSupportDetails,
|
||||
|
||||
pub(super) desired_image_count: u32,
|
||||
pub(super) surface_format: vk::SurfaceFormatKHR,
|
||||
pub(super) surface_resolution: vk::Extent2D,
|
||||
pub(super) new_requested_surface_resolution: Option<vk::Extent2D>,
|
||||
pub(super) present_mode: vk::PresentModeKHR,
|
||||
pub(super) pre_transform: vk::SurfaceTransformFlagsKHR,
|
||||
|
||||
pub(super) present_images: Option<Vec<vk::Image>>,
|
||||
pub(super) present_image_views: Option<Vec<Arc<vk::ImageView>>>,
|
||||
}
|
||||
|
||||
impl VkSwapchain {
|
||||
pub(super) fn new(
|
||||
window: &Window,
|
||||
surface: &Arc<VkSurface>,
|
||||
device: &Arc<VkDevice>,
|
||||
physical_device: &VkPhysicalDevice,
|
||||
) -> anyhow::Result<Self> {
|
||||
log::debug!("Creating swapchain");
|
||||
|
||||
let window_size = window
|
||||
.physical_size::<u32>()
|
||||
.and_then(|size| {
|
||||
Some(vk::Extent2D {
|
||||
width: size.width,
|
||||
height: size.height,
|
||||
})
|
||||
})
|
||||
.ok_or_else(|| anyhow::anyhow!("Failed to get swapchain extent"))?;
|
||||
log::debug!("Window size ({}x{})", window_size.width, window_size.height);
|
||||
|
||||
let swapchain_support_details =
|
||||
surface.get_physical_device_swapchain_support_details(physical_device)?;
|
||||
let SwapchainSupportDetails(surface_formats, surface_capabilities, present_modes) =
|
||||
&swapchain_support_details;
|
||||
log::debug!("Supported surface formats by physical device: {surface_formats:#?}");
|
||||
log::debug!("Surface capabilities: {surface_capabilities:#?}");
|
||||
log::debug!("Present modes: {present_modes:#?}");
|
||||
|
||||
let surface_format = Self::choose_surface_format(surface_formats)
|
||||
.ok_or_else(|| anyhow::anyhow!("No available surface formats"))?;
|
||||
let desired_image_count = Self::choose_desired_image_count(surface_capabilities);
|
||||
let swapchain_extent = Self::choose_swapchain_extent(window_size, surface_capabilities);
|
||||
let pre_transform = Self::choose_pre_transform(surface_capabilities);
|
||||
let present_mode = Self::choose_present_mode(present_modes);
|
||||
|
||||
let mut swapchain = Self {
|
||||
surface: surface.clone(),
|
||||
device: device.clone(),
|
||||
|
||||
handle: None,
|
||||
new_requested_surface_resolution: None,
|
||||
swapchain_support_details,
|
||||
desired_image_count,
|
||||
surface_format,
|
||||
surface_resolution: swapchain_extent,
|
||||
present_mode,
|
||||
pre_transform,
|
||||
present_images: None,
|
||||
present_image_views: None,
|
||||
};
|
||||
|
||||
swapchain.create_swapchain()?;
|
||||
|
||||
Ok(swapchain)
|
||||
}
|
||||
|
||||
pub(super) fn create_swapchain(&mut self) -> VkResult<()> {
|
||||
if let Some(new_requested_surface_resolution) = self.new_requested_surface_resolution {
|
||||
self.surface_resolution = new_requested_surface_resolution;
|
||||
self.new_requested_surface_resolution = None;
|
||||
}
|
||||
|
||||
let mut swapchain_create_info = self.create_swapchain_info(&self.surface);
|
||||
|
||||
if let Some(old_swapchain) = self.handle {
|
||||
swapchain_create_info.old_swapchain = old_swapchain;
|
||||
}
|
||||
|
||||
let swapchain = unsafe {
|
||||
self.device
|
||||
.swapchain_loader
|
||||
.create_swapchain(&swapchain_create_info, None)?
|
||||
};
|
||||
|
||||
let present_images = unsafe {
|
||||
self.device
|
||||
.swapchain_loader
|
||||
.get_swapchain_images(swapchain)?
|
||||
};
|
||||
let present_images_view = present_images
|
||||
.iter()
|
||||
.map(|i| {
|
||||
self.create_present_image_view(*i)
|
||||
.expect("Failed to create image view")
|
||||
})
|
||||
.map(|i| Arc::new(i))
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
if log::log_enabled!(log::Level::Debug) {
|
||||
let label = match self.handle {
|
||||
None => "Swapchain created",
|
||||
Some(_) => "Swapchain updated",
|
||||
};
|
||||
log::debug!("{label} ({swapchain:?}) : {swapchain_create_info:#?}");
|
||||
}
|
||||
|
||||
self.handle = Some(swapchain);
|
||||
self.present_image_views = Some(present_images_view);
|
||||
self.present_images = Some(present_images);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(super) fn create_framebuffers(
|
||||
&self,
|
||||
render_pass: &Arc<VkRenderPass>,
|
||||
) -> Option<Vec<Arc<VkFramebuffer>>> {
|
||||
let present_image_views = self.present_image_views.as_ref()?;
|
||||
|
||||
Some(
|
||||
present_image_views
|
||||
.iter()
|
||||
.map(|image_view| {
|
||||
VkFramebuffer::from_swapchain_image_view(
|
||||
&self.device,
|
||||
&render_pass,
|
||||
&image_view,
|
||||
&self,
|
||||
)
|
||||
.unwrap()
|
||||
})
|
||||
.map(|framebuffer| Arc::new(framebuffer))
|
||||
.collect::<Vec<_>>(),
|
||||
)
|
||||
}
|
||||
|
||||
pub(super) fn update_resolution(&mut self, width: u32, height: u32) -> VkResult<()> {
|
||||
log::debug!("New resolution requested ({width}x{height})");
|
||||
|
||||
let chosen_extent = Self::choose_swapchain_extent(
|
||||
vk::Extent2D { width, height },
|
||||
&self.swapchain_support_details.1,
|
||||
);
|
||||
if chosen_extent.width != self.surface_resolution.width
|
||||
|| chosen_extent.height != self.surface_resolution.height
|
||||
{
|
||||
self.new_requested_surface_resolution = Some(chosen_extent);
|
||||
log::debug!(
|
||||
"New resolution submitted ({}x{})",
|
||||
chosen_extent.width,
|
||||
chosen_extent.height
|
||||
);
|
||||
} else {
|
||||
log::debug!("New resolution skipped ({width}x{height}) : Same resolution");
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(super) fn acquire_next_image(&self, semaphore: &VkSemaphore) -> VkResult<(u32, bool)> {
|
||||
unsafe {
|
||||
self.device.swapchain_loader.acquire_next_image(
|
||||
self.handle.unwrap(),
|
||||
u64::MAX,
|
||||
semaphore.handle,
|
||||
vk::Fence::null(),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn is_dirty(&self) -> bool {
|
||||
self.new_requested_surface_resolution.is_some()
|
||||
}
|
||||
|
||||
fn create_swapchain_info(&self, surface: &VkSurface) -> vk::SwapchainCreateInfoKHR {
|
||||
vk::SwapchainCreateInfoKHR::default()
|
||||
.surface(surface.handle)
|
||||
.min_image_count(self.desired_image_count)
|
||||
.image_color_space(self.surface_format.color_space)
|
||||
.image_format(self.surface_format.format)
|
||||
.image_extent(self.surface_resolution)
|
||||
.image_usage(vk::ImageUsageFlags::COLOR_ATTACHMENT)
|
||||
.image_sharing_mode(vk::SharingMode::EXCLUSIVE)
|
||||
.pre_transform(self.pre_transform)
|
||||
.composite_alpha(vk::CompositeAlphaFlagsKHR::OPAQUE)
|
||||
.present_mode(self.present_mode)
|
||||
.clipped(true)
|
||||
.image_array_layers(1)
|
||||
}
|
||||
|
||||
fn choose_swapchain_extent(
|
||||
window_size: vk::Extent2D,
|
||||
surface_capabilities: &vk::SurfaceCapabilitiesKHR,
|
||||
) -> vk::Extent2D {
|
||||
vk::Extent2D {
|
||||
width: window_size
|
||||
.width
|
||||
.max(surface_capabilities.min_image_extent.width)
|
||||
.min(surface_capabilities.max_image_extent.width),
|
||||
height: window_size
|
||||
.height
|
||||
.max(surface_capabilities.min_image_extent.height)
|
||||
.min(surface_capabilities.max_image_extent.height),
|
||||
}
|
||||
}
|
||||
|
||||
fn choose_surface_format(
|
||||
surface_formats: &Vec<vk::SurfaceFormatKHR>,
|
||||
) -> Option<vk::SurfaceFormatKHR> {
|
||||
surface_formats.first().and_then(|f| Some(*f))
|
||||
}
|
||||
|
||||
fn choose_desired_image_count(surface_capabilities: &vk::SurfaceCapabilitiesKHR) -> u32 {
|
||||
let mut desired_image_count = surface_capabilities.min_image_count + 1;
|
||||
if surface_capabilities.max_image_count > 0
|
||||
&& desired_image_count > surface_capabilities.max_image_count
|
||||
{
|
||||
desired_image_count = surface_capabilities.max_image_count;
|
||||
}
|
||||
desired_image_count
|
||||
}
|
||||
|
||||
fn choose_pre_transform(
|
||||
surface_capabilities: &vk::SurfaceCapabilitiesKHR,
|
||||
) -> vk::SurfaceTransformFlagsKHR {
|
||||
if surface_capabilities
|
||||
.supported_transforms
|
||||
.contains(vk::SurfaceTransformFlagsKHR::IDENTITY)
|
||||
{
|
||||
vk::SurfaceTransformFlagsKHR::IDENTITY
|
||||
} else {
|
||||
surface_capabilities.current_transform
|
||||
}
|
||||
}
|
||||
|
||||
fn choose_present_mode(present_modes: &Vec<vk::PresentModeKHR>) -> vk::PresentModeKHR {
|
||||
present_modes
|
||||
.iter()
|
||||
.cloned()
|
||||
.find(|&mode| mode == vk::PresentModeKHR::MAILBOX)
|
||||
.unwrap_or(vk::PresentModeKHR::FIFO)
|
||||
}
|
||||
|
||||
fn create_present_image_view(&self, image: vk::Image) -> VkResult<vk::ImageView> {
|
||||
let create_view_info = vk::ImageViewCreateInfo::default()
|
||||
.view_type(vk::ImageViewType::TYPE_2D)
|
||||
.format(self.surface_format.format)
|
||||
.components(vk::ComponentMapping {
|
||||
r: vk::ComponentSwizzle::IDENTITY,
|
||||
g: vk::ComponentSwizzle::IDENTITY,
|
||||
b: vk::ComponentSwizzle::IDENTITY,
|
||||
a: vk::ComponentSwizzle::IDENTITY,
|
||||
})
|
||||
.subresource_range(vk::ImageSubresourceRange {
|
||||
aspect_mask: vk::ImageAspectFlags::COLOR,
|
||||
base_mip_level: 0,
|
||||
level_count: 1,
|
||||
base_array_layer: 0,
|
||||
layer_count: 1,
|
||||
})
|
||||
.image(image);
|
||||
|
||||
unsafe {
|
||||
self.device
|
||||
.handle
|
||||
.create_image_view(&create_view_info, None)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for VkSwapchain {
|
||||
fn drop(&mut self) {
|
||||
if let Some(swapchain) = self.handle {
|
||||
unsafe {
|
||||
self.device
|
||||
.swapchain_loader
|
||||
.destroy_swapchain(swapchain, None);
|
||||
}
|
||||
self.handle = None;
|
||||
log::debug!("Swapchain destroyed ({swapchain:?})");
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue