alex/gb-emu
1
0
Fork 0
Code Pull requests Actions Packages Releases Activity

vulkan: update + cleanup

Browse source
This commit is contained in:
Alex Janka 2024-08-18 14:27:36 +10:00
parent 11512e92ea
commit 27464daae3
4 changed files with 83 additions and 163 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
lib/src/renderer/vulkan/debug.rs
View file

@ -1,13 +1,13 @@
use ash::{extensions::ext::DebugUtils, vk, Entry, Instance}; use ash::{ext::debug_utils, vk, Entry, Instance};
pub(super) struct VulkanDebug { pub(super) struct VulkanDebug {
debug_utils_loader: DebugUtils, debug_utils_loader: debug_utils::Instance,
debug_call_back: vk::DebugUtilsMessengerEXT, debug_call_back: vk::DebugUtilsMessengerEXT,
} }
impl VulkanDebug { impl VulkanDebug {
pub(super) fn new(entry: &Entry, instance: &Instance) -> Self { pub(super) fn new(entry: &Entry, instance: &Instance) -> Self {
let debug_info = vk::DebugUtilsMessengerCreateInfoEXT::builder() let debug_info = vk::DebugUtilsMessengerCreateInfoEXT::default()
.message_severity( .message_severity(
vk::DebugUtilsMessageSeverityFlagsEXT::ERROR vk::DebugUtilsMessageSeverityFlagsEXT::ERROR
| vk::DebugUtilsMessageSeverityFlagsEXT::WARNING | vk::DebugUtilsMessageSeverityFlagsEXT::WARNING
@ -19,10 +19,9 @@ impl VulkanDebug {
| vk::DebugUtilsMessageTypeFlagsEXT::VALIDATION | vk::DebugUtilsMessageTypeFlagsEXT::VALIDATION
| vk::DebugUtilsMessageTypeFlagsEXT::PERFORMANCE, | vk::DebugUtilsMessageTypeFlagsEXT::PERFORMANCE,
) )
.pfn_user_callback(Some(vulkan_debug_callback)) .pfn_user_callback(Some(vulkan_debug_callback));
.build();
let debug_utils_loader = DebugUtils::new(entry, instance); let debug_utils_loader = debug_utils::Instance::new(entry, instance);
let debug_call_back = let debug_call_back =
unsafe { debug_utils_loader.create_debug_utils_messenger(&debug_info, None) }.unwrap(); unsafe { debug_utils_loader.create_debug_utils_messenger(&debug_info, None) }.unwrap();

57
lib/src/renderer/vulkan/mod.rs
View file

@ -4,13 +4,10 @@ use librashader::runtime::vk::{FilterChain, FilterChainOptions, FrameOptions, Vu
use raw_window_handle::{DisplayHandle, HasDisplayHandle, HasWindowHandle}; use raw_window_handle::{DisplayHandle, HasDisplayHandle, HasWindowHandle};
use std::{mem::ManuallyDrop, path::PathBuf, sync::Arc}; use std::{mem::ManuallyDrop, path::PathBuf, sync::Arc};
use crate::connect::ResolutionData; use crate::{connect::ResolutionData, error::VulkanError};
use self::{ use self::{
types::{ types::{FramebufferData, SurfaceData, SwapchainData, Vertex, VulkanData, SHADER_INPUT_FORMAT},
FramebufferData, SurfaceData, SwapchainData, Vertex, VulkanData, VulkanError,
SHADER_INPUT_FORMAT,
},
utils::{ utils::{
begin_commandbuffer, find_memorytype_index, record_submit_commandbuffer, begin_commandbuffer, find_memorytype_index, record_submit_commandbuffer,
submit_commandbuffer, submit_commandbuffer,
@ -53,22 +50,22 @@ impl RendererBackendManager for VulkanBackendManager {
.to_vec(); .to_vec();
#[cfg(all(debug_assertions, feature = "vulkan-debug"))] #[cfg(all(debug_assertions, feature = "vulkan-debug"))]
extension_names.push(ash::extensions::ext::DebugUtils::name().as_ptr()); extension_names.push(ash::ext::debug_utils::NAME.as_ptr());
#[cfg(any(target_os = "macos", target_os = "ios"))] #[cfg(any(target_os = "macos", target_os = "ios"))]
{ {
#[cfg(not(feature = "vulkan-static"))] #[cfg(not(feature = "vulkan-static"))]
extension_names.push(vk::KhrPortabilityEnumerationFn::name().as_ptr()); extension_names.push(vk::KHR_PORTABILITY_ENUMERATION_NAME.as_ptr());
extension_names.push(vk::KhrGetPhysicalDeviceProperties2Fn::name().as_ptr());
extension_names.push(vk::KHR_GET_PHYSICAL_DEVICE_PROPERTIES2_NAME.as_ptr());
} }
let appinfo = vk::ApplicationInfo::builder() let appinfo = vk::ApplicationInfo::default()
.application_name(&name) .application_name(&name)
.engine_name(&name) .engine_name(&name)
.application_version(0) .application_version(0)
.engine_version(0) .engine_version(0)
.api_version(vk::make_api_version(0, 1, 0, 0)) .api_version(vk::make_api_version(0, 1, 0, 0));
.build();
let create_flags = if cfg!(any(target_os = "macos", target_os = "ios")) { let create_flags = if cfg!(any(target_os = "macos", target_os = "ios")) {
vk::InstanceCreateFlags::ENUMERATE_PORTABILITY_KHR vk::InstanceCreateFlags::ENUMERATE_PORTABILITY_KHR
@ -76,11 +73,10 @@ impl RendererBackendManager for VulkanBackendManager {
vk::InstanceCreateFlags::default() vk::InstanceCreateFlags::default()
}; };
let create_info = vk::InstanceCreateInfo::builder() let create_info = vk::InstanceCreateInfo::default()
.application_info(&appinfo) .application_info(&appinfo)
.enabled_extension_names(&extension_names) .enabled_extension_names(&extension_names)
.flags(create_flags) .flags(create_flags);
.build();
let instance = unsafe { entry.create_instance(&create_info, None) }.unwrap(); let instance = unsafe { entry.create_instance(&create_info, None) }.unwrap();
@ -135,8 +131,8 @@ impl RendererBackend for VulkanBackend {
let filter_chain_options = FilterChainOptions { let filter_chain_options = FilterChainOptions {
frames_in_flight: 0, frames_in_flight: 0,
force_no_mipmaps: false, force_no_mipmaps: false,
use_render_pass: true,
disable_cache: false, disable_cache: false,
use_dynamic_rendering: false,
}; };
let vulkan = VulkanObjects::try_from(( let vulkan = VulkanObjects::try_from((
@ -213,8 +209,7 @@ impl VulkanWindowInner {
let vulkan_data = VulkanData::new(manager, &surface); let vulkan_data = VulkanData::new(manager, &surface);
let (swapchain, _viewport_state_info) = let swapchain = SwapchainData::new(resolutions, manager, &surface, &vulkan_data);
SwapchainData::new(resolutions, manager, &surface, &vulkan_data);
let renderpass_attachments = [vk::AttachmentDescription { let renderpass_attachments = [vk::AttachmentDescription {
format: swapchain.format.format, format: swapchain.format.format,
@ -237,16 +232,14 @@ impl VulkanWindowInner {
..Default::default() ..Default::default()
}]; }];
let subpass = vk::SubpassDescription::builder() let subpass = vk::SubpassDescription::default()
.color_attachments(&color_attachment_refs) .color_attachments(&color_attachment_refs)
.pipeline_bind_point(vk::PipelineBindPoint::GRAPHICS) .pipeline_bind_point(vk::PipelineBindPoint::GRAPHICS);
.build();
let renderpass_create_info = vk::RenderPassCreateInfo::builder() let renderpass_create_info = vk::RenderPassCreateInfo::default()
.attachments(&renderpass_attachments) .attachments(&renderpass_attachments)
.subpasses(std::slice::from_ref(&subpass)) .subpasses(std::slice::from_ref(&subpass))
.dependencies(&dependencies) .dependencies(&dependencies);
.build();
let renderpass = vulkan_data let renderpass = vulkan_data
.device .device
@ -339,8 +332,7 @@ impl VulkanWindowInner {
.device .device
.destroy_framebuffer(*framebuffer, None); .destroy_framebuffer(*framebuffer, None);
} }
(self.swapchain, _) = self.swapchain = SwapchainData::new(resolutions, manager, &self.surface, &self.vulkan_data);
SwapchainData::new(resolutions, manager, &self.surface, &self.vulkan_data);
self.framebuffers = self.framebuffers =
FramebufferData::new(&self.swapchain, &self.vulkan_data, self.renderpass); FramebufferData::new(&self.swapchain, &self.vulkan_data, self.renderpass);
@ -395,15 +387,13 @@ impl VulkanWindowInner {
&[], &[],
&[texture_barrier], &[texture_barrier],
); );
let buffer_copy_regions = vk::BufferImageCopy::builder() let buffer_copy_regions = vk::BufferImageCopy::default()
.image_subresource( .image_subresource(
vk::ImageSubresourceLayers::builder() vk::ImageSubresourceLayers::default()
.aspect_mask(vk::ImageAspectFlags::COLOR) .aspect_mask(vk::ImageAspectFlags::COLOR)
.layer_count(1) .layer_count(1),
.build(),
) )
.image_extent(self.swapchain.shader_input_image_extent.into()) .image_extent(self.swapchain.shader_input_image_extent.into());
.build();
device.cmd_copy_buffer_to_image( device.cmd_copy_buffer_to_image(
texture_command_buffer, texture_command_buffer,
@ -450,7 +440,7 @@ impl VulkanWindowInner {
.swapchain_loader .swapchain_loader
.acquire_next_image( .acquire_next_image(
self.swapchain.swapchain, self.swapchain.swapchain,
std::u64::MAX, u64::MAX,
self.vulkan_data.present_complete_semaphore, self.vulkan_data.present_complete_semaphore,
vk::Fence::null(), vk::Fence::null(),
) )
@ -488,6 +478,9 @@ impl VulkanWindowInner {
Some(&FrameOptions { Some(&FrameOptions {
clear_history: true, clear_history: true,
frame_direction: 0, frame_direction: 0,
rotation: 0,
total_subframes: 0,
current_subframe: 0,
}), }),
) )
.unwrap(); .unwrap();

166
lib/src/renderer/vulkan/types.rs
View file

@ -1,10 +1,5 @@
use ash::{ use ash::{khr::swapchain, vk, Device};
extensions::khr::{Surface, Swapchain}, use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
vk, Device,
};
#[allow(deprecated)]
use raw_window_handle::{HasRawDisplayHandle, HasRawWindowHandle};
use thiserror::Error;
use crate::connect::ResolutionData; use crate::connect::ResolutionData;
@ -24,10 +19,8 @@ pub(super) struct VulkanData {
pub(super) pdevice: vk::PhysicalDevice, pub(super) pdevice: vk::PhysicalDevice,
pub(super) device: Device, pub(super) device: Device,
pub(super) device_memory_properties: vk::PhysicalDeviceMemoryProperties, pub(super) device_memory_properties: vk::PhysicalDeviceMemoryProperties,
// pub(super) desc_set_layouts: [vk::DescriptorSetLayout; 1],
pub(super) present_queue: vk::Queue, pub(super) present_queue: vk::Queue,
// pub(super) pool: vk::CommandPool,
pub(super) draw_command_buffer: vk::CommandBuffer, pub(super) draw_command_buffer: vk::CommandBuffer,
pub(super) setup_command_buffer: vk::CommandBuffer, pub(super) setup_command_buffer: vk::CommandBuffer,
pub(super) texture_copy_command_buffer: vk::CommandBuffer, pub(super) texture_copy_command_buffer: vk::CommandBuffer,
@ -38,7 +31,6 @@ pub(super) struct VulkanData {
pub(super) draw_commands_reuse_fence: vk::Fence, pub(super) draw_commands_reuse_fence: vk::Fence,
pub(super) setup_commands_reuse_fence: vk::Fence, pub(super) setup_commands_reuse_fence: vk::Fence,
pub(super) texture_copy_commands_reuse_fence: vk::Fence, pub(super) texture_copy_commands_reuse_fence: vk::Fence,
// pub(super) descriptor_pool: vk::DescriptorPool,
} }
impl VulkanData { impl VulkanData {
@ -76,9 +68,9 @@ impl VulkanData {
.expect("Couldn't find suitable device."); .expect("Couldn't find suitable device.");
let queue_family_index = queue_family_index as u32; let queue_family_index = queue_family_index as u32;
let device_extension_names_raw = [ let device_extension_names_raw = [
Swapchain::name().as_ptr(), swapchain::NAME.as_ptr(),
#[cfg(any(target_os = "macos", target_os = "ios"))] #[cfg(any(target_os = "macos", target_os = "ios"))]
vk::KhrPortabilitySubsetFn::name().as_ptr(), vk::KHR_PORTABILITY_SUBSET_NAME.as_ptr(),
]; ];
let features = vk::PhysicalDeviceFeatures { let features = vk::PhysicalDeviceFeatures {
shader_clip_distance: 1, shader_clip_distance: 1,
@ -86,16 +78,14 @@ impl VulkanData {
}; };
let priorities = [1.0]; let priorities = [1.0];
let queue_info = vk::DeviceQueueCreateInfo::builder() let queue_info = vk::DeviceQueueCreateInfo::default()
.queue_family_index(queue_family_index) .queue_family_index(queue_family_index)
.queue_priorities(&priorities) .queue_priorities(&priorities);
.build();
let device_create_info = vk::DeviceCreateInfo::builder() let device_create_info = vk::DeviceCreateInfo::default()
.queue_create_infos(std::slice::from_ref(&queue_info)) .queue_create_infos(std::slice::from_ref(&queue_info))
.enabled_extension_names(&device_extension_names_raw) .enabled_extension_names(&device_extension_names_raw)
.enabled_features(&features) .enabled_features(&features);
.build();
let device = manager let device = manager
.instance .instance
@ -104,18 +94,16 @@ impl VulkanData {
let present_queue = device.get_device_queue(queue_family_index, 0); let present_queue = device.get_device_queue(queue_family_index, 0);
let pool_create_info = vk::CommandPoolCreateInfo::builder() let pool_create_info = vk::CommandPoolCreateInfo::default()
.flags(vk::CommandPoolCreateFlags::RESET_COMMAND_BUFFER) .flags(vk::CommandPoolCreateFlags::RESET_COMMAND_BUFFER)
.queue_family_index(queue_family_index) .queue_family_index(queue_family_index);
.build();
let pool = device.create_command_pool(&pool_create_info, None).unwrap(); let pool = device.create_command_pool(&pool_create_info, None).unwrap();
let command_buffer_allocate_info = vk::CommandBufferAllocateInfo::builder() let command_buffer_allocate_info = vk::CommandBufferAllocateInfo::default()
.command_buffer_count(3) .command_buffer_count(3)
.command_pool(pool) .command_pool(pool)
.level(vk::CommandBufferLevel::PRIMARY) .level(vk::CommandBufferLevel::PRIMARY);
.build();
let command_buffers = device let command_buffers = device
.allocate_command_buffers(&command_buffer_allocate_info) .allocate_command_buffers(&command_buffer_allocate_info)
@ -128,9 +116,8 @@ impl VulkanData {
.instance .instance
.get_physical_device_memory_properties(pdevice); .get_physical_device_memory_properties(pdevice);
let fence_create_info = vk::FenceCreateInfo::builder() let fence_create_info =
.flags(vk::FenceCreateFlags::SIGNALED) vk::FenceCreateInfo::default().flags(vk::FenceCreateFlags::SIGNALED);
.build();
let draw_commands_reuse_fence = device let draw_commands_reuse_fence = device
.create_fence(&fence_create_info, None) .create_fence(&fence_create_info, None)
@ -151,38 +138,6 @@ impl VulkanData {
.create_semaphore(&semaphore_create_info, None) .create_semaphore(&semaphore_create_info, None)
.unwrap(); .unwrap();
// let descriptor_sizes = [
// vk::DescriptorPoolSize {
// ty: vk::DescriptorType::UNIFORM_BUFFER,
// descriptor_count: 1,
// },
// vk::DescriptorPoolSize {
// ty: vk::DescriptorType::COMBINED_IMAGE_SAMPLER,
// descriptor_count: 1,
// },
// ];
// let descriptor_pool_info = vk::DescriptorPoolCreateInfo::builder()
// .pool_sizes(&descriptor_sizes)
// .max_sets(1)
// .build();
// let descriptor_pool = device
// .create_descriptor_pool(&descriptor_pool_info, None)
// .unwrap();
// let desc_layout_bindings = [vk::DescriptorSetLayoutBinding {
// descriptor_type: vk::DescriptorType::COMBINED_IMAGE_SAMPLER,
// descriptor_count: 1,
// stage_flags: vk::ShaderStageFlags::FRAGMENT,
// ..Default::default()
// }];
// let descriptor_info = vk::DescriptorSetLayoutCreateInfo::builder()
// .bindings(&desc_layout_bindings)
// .build();
// let desc_set_layouts = [device
// .create_descriptor_set_layout(&descriptor_info, None)
// .unwrap()];
Self { Self {
pdevice, pdevice,
device, device,
@ -197,33 +152,30 @@ impl VulkanData {
draw_commands_reuse_fence, draw_commands_reuse_fence,
setup_commands_reuse_fence, setup_commands_reuse_fence,
texture_copy_commands_reuse_fence, texture_copy_commands_reuse_fence,
// desc_set_layouts,
// descriptor_pool,
} }
} }
} }
pub(super) struct SurfaceData { pub(super) struct SurfaceData {
pub(super) surface: vk::SurfaceKHR, pub(super) surface: vk::SurfaceKHR,
pub(super) surface_loader: Surface, pub(super) surface_loader: ash::khr::surface::Instance,
} }
impl SurfaceData { impl SurfaceData {
#[allow(deprecated)] pub(super) unsafe fn new<W: HasDisplayHandle + HasWindowHandle>(
pub(super) unsafe fn new<W: HasRawDisplayHandle + HasRawWindowHandle>(
window: &W, window: &W,
manager: &VulkanBackendManager, manager: &VulkanBackendManager,
) -> Self { ) -> Self {
let surface = ash_window::create_surface( let surface = ash_window::create_surface(
&manager.entry, &manager.entry,
&manager.instance, &manager.instance,
window.raw_display_handle().unwrap(), window.display_handle().unwrap().as_raw(),
window.raw_window_handle().unwrap(), window.window_handle().unwrap().as_raw(),
None, None,
) )
.unwrap(); .unwrap();
let surface_loader = Surface::new(&manager.entry, &manager.instance); let surface_loader = ash::khr::surface::Instance::new(&manager.entry, &manager.instance);
Self { Self {
surface, surface,
@ -233,7 +185,7 @@ impl SurfaceData {
} }
pub(super) struct SwapchainData { pub(super) struct SwapchainData {
pub(super) swapchain_loader: Swapchain, pub(super) swapchain_loader: swapchain::Device,
pub(super) swapchain: vk::SwapchainKHR, pub(super) swapchain: vk::SwapchainKHR,
pub(super) format: vk::SurfaceFormatKHR, pub(super) format: vk::SurfaceFormatKHR,
pub(super) surface_resolution: vk::Extent2D, pub(super) surface_resolution: vk::Extent2D,
@ -255,7 +207,7 @@ impl SwapchainData {
manager: &VulkanBackendManager, manager: &VulkanBackendManager,
surface: &SurfaceData, surface: &SurfaceData,
vulkan: &VulkanData, vulkan: &VulkanData,
) -> (Self, vk::PipelineViewportStateCreateInfo) { ) -> Self {
let format = surface let format = surface
.surface_loader .surface_loader
.get_physical_device_surface_formats(vulkan.pdevice, surface.surface) .get_physical_device_surface_formats(vulkan.pdevice, surface.surface)
@ -295,9 +247,9 @@ impl SwapchainData {
.cloned() .cloned()
.find(|&mode| mode == vk::PresentModeKHR::MAILBOX) .find(|&mode| mode == vk::PresentModeKHR::MAILBOX)
.unwrap_or(vk::PresentModeKHR::FIFO); .unwrap_or(vk::PresentModeKHR::FIFO);
let swapchain_loader = Swapchain::new(&manager.instance, &vulkan.device); let swapchain_loader = swapchain::Device::new(&manager.instance, &vulkan.device);
let swapchain_create_info = vk::SwapchainCreateInfoKHR::builder() let swapchain_create_info = vk::SwapchainCreateInfoKHR::default()
.surface(surface.surface) .surface(surface.surface)
.min_image_count(desired_image_count) .min_image_count(desired_image_count)
.image_color_space(format.color_space) .image_color_space(format.color_space)
@ -309,8 +261,7 @@ impl SwapchainData {
.composite_alpha(vk::CompositeAlphaFlagsKHR::OPAQUE) .composite_alpha(vk::CompositeAlphaFlagsKHR::OPAQUE)
.present_mode(present_mode) .present_mode(present_mode)
.clipped(true) .clipped(true)
.image_array_layers(1) .image_array_layers(1);
.build();
let swapchain = swapchain_loader let swapchain = swapchain_loader
.create_swapchain(&swapchain_create_info, None) .create_swapchain(&swapchain_create_info, None)
@ -320,7 +271,7 @@ impl SwapchainData {
let present_image_views: Vec<vk::ImageView> = present_images let present_image_views: Vec<vk::ImageView> = present_images
.iter() .iter()
.map(|&image| { .map(|&image| {
let create_view_info = vk::ImageViewCreateInfo::builder() let create_view_info = vk::ImageViewCreateInfo::default()
.view_type(vk::ImageViewType::TYPE_2D) .view_type(vk::ImageViewType::TYPE_2D)
.format(format.format) .format(format.format)
.components(vk::ComponentMapping { .components(vk::ComponentMapping {
@ -336,8 +287,7 @@ impl SwapchainData {
base_array_layer: 0, base_array_layer: 0,
layer_count: 1, layer_count: 1,
}) })
.image(image) .image(image);
.build();
vulkan vulkan
.device .device
.create_image_view(&create_view_info, None) .create_image_view(&create_view_info, None)
@ -345,20 +295,6 @@ impl SwapchainData {
}) })
.collect(); .collect();
let viewports = [vk::Viewport {
x: 0.0,
y: 0.0,
width: surface_resolution.width as f32,
height: surface_resolution.height as f32,
min_depth: 0.0,
max_depth: 1.0,
}];
let scissors = [surface_resolution.into()];
let viewport_state_info = vk::PipelineViewportStateCreateInfo::builder()
.scissors(&scissors)
.viewports(&viewports)
.build();
let shader_input_image_extent = vk::Extent2D { let shader_input_image_extent = vk::Extent2D {
width: resolutions.scaled_width, width: resolutions.scaled_width,
height: resolutions.scaled_height, height: resolutions.scaled_height,
@ -475,15 +411,13 @@ impl SwapchainData {
&[], &[],
&[texture_barrier], &[texture_barrier],
); );
let buffer_copy_regions = vk::BufferImageCopy::builder() let buffer_copy_regions = vk::BufferImageCopy::default()
.image_subresource( .image_subresource(
vk::ImageSubresourceLayers::builder() vk::ImageSubresourceLayers::default()
.aspect_mask(vk::ImageAspectFlags::COLOR) .aspect_mask(vk::ImageAspectFlags::COLOR)
.layer_count(1) .layer_count(1),
.build(),
) )
.image_extent(shader_input_image_extent.into()) .image_extent(shader_input_image_extent.into());
.build();
device.cmd_copy_buffer_to_image( device.cmd_copy_buffer_to_image(
texture_command_buffer, texture_command_buffer,
@ -557,25 +491,22 @@ impl SwapchainData {
.create_image_view(&shader_input_tex_image_view_info, None) .create_image_view(&shader_input_tex_image_view_info, None)
.unwrap(); .unwrap();
( Self {
Self { swapchain_loader,
swapchain_loader, swapchain,
swapchain, format,
format, surface_resolution,
surface_resolution, present_image_views,
present_image_views, sampler,
sampler, shader_input_texture_memory,
shader_input_texture_memory, shader_input_tex_image_view,
shader_input_tex_image_view, shader_input_image_buffer,
shader_input_image_buffer, shader_input_image_buffer_memory,
shader_input_image_buffer_memory, shader_input_image_buffer_memory_req,
shader_input_image_buffer_memory_req, shader_input_image_extent,
shader_input_image_extent, shader_input_texture,
shader_input_texture, present_images,
present_images, }
},
viewport_state_info,
)
} }
pub(super) unsafe fn manual_drop(&mut self, vulkan: &VulkanData) { pub(super) unsafe fn manual_drop(&mut self, vulkan: &VulkanData) {
@ -619,13 +550,12 @@ impl FramebufferData {
.iter() .iter()
.map(|&present_image_view| { .map(|&present_image_view| {
let framebuffer_attachments = [present_image_view]; let framebuffer_attachments = [present_image_view];
let frame_buffer_create_info = vk::FramebufferCreateInfo::builder() let frame_buffer_create_info = vk::FramebufferCreateInfo::default()
.render_pass(renderpass) .render_pass(renderpass)
.attachments(&framebuffer_attachments) .attachments(&framebuffer_attachments)
.width(swapchain.surface_resolution.width) .width(swapchain.surface_resolution.width)
.height(swapchain.surface_resolution.height) .height(swapchain.surface_resolution.height)
.layers(1) .layers(1);
.build();
vulkan vulkan
.device .device

12
lib/src/renderer/vulkan/utils.rs
View file

@ -30,7 +30,7 @@ pub(super) unsafe fn begin_commandbuffer(
command_buffer_reuse_fence: vk::Fence, command_buffer_reuse_fence: vk::Fence,
) { ) {
device device
.wait_for_fences(&[command_buffer_reuse_fence], true, std::u64::MAX) .wait_for_fences(&[command_buffer_reuse_fence], true, u64::MAX)
.expect("Wait for fence failed."); .expect("Wait for fence failed.");
device device
@ -44,9 +44,8 @@ pub(super) unsafe fn begin_commandbuffer(
) )
.expect("Reset command buffer failed."); .expect("Reset command buffer failed.");
let command_buffer_begin_info = vk::CommandBufferBeginInfo::builder() let command_buffer_begin_info =
.flags(vk::CommandBufferUsageFlags::ONE_TIME_SUBMIT) vk::CommandBufferBeginInfo::default().flags(vk::CommandBufferUsageFlags::ONE_TIME_SUBMIT);
.build();
device device
.begin_command_buffer(command_buffer, &command_buffer_begin_info) .begin_command_buffer(command_buffer, &command_buffer_begin_info)
@ -68,12 +67,11 @@ pub(super) unsafe fn submit_commandbuffer(
let command_buffers = vec![command_buffer]; let command_buffers = vec![command_buffer];
let submit_info = vk::SubmitInfo::builder() let submit_info = vk::SubmitInfo::default()
.wait_semaphores(wait_semaphores) .wait_semaphores(wait_semaphores)
.wait_dst_stage_mask(wait_mask) .wait_dst_stage_mask(wait_mask)
.command_buffers(&command_buffers) .command_buffers(&command_buffers)
.signal_semaphores(signal_semaphores) .signal_semaphores(signal_semaphores);
.build();
device device
.queue_submit(submit_queue, &[submit_info], command_buffer_reuse_fence) .queue_submit(submit_queue, &[submit_info], command_buffer_reuse_fence)