1114 lines
No EOL
43 KiB
Rust
1114 lines
No EOL
43 KiB
Rust
#![allow(
|
|
dead_code,
|
|
unused_variables,
|
|
clippy::too_many_arguments,
|
|
clippy::unnecessary_wraps
|
|
)]
|
|
|
|
use anyhow::{anyhow, Result};
|
|
use log::*;
|
|
use winit::dpi::{LogicalSize, LogicalPosition};
|
|
use winit::event::{ElementState, Event, WindowEvent};
|
|
use winit::event_loop::EventLoop;
|
|
use winit::keyboard::NamedKey;
|
|
use winit::window::{Window, WindowBuilder};
|
|
|
|
use vulkanalia::loader::{LibloadingLoader, LIBRARY};
|
|
use vulkanalia::window as vk_window;
|
|
use vulkanalia::prelude::v1_0::*;
|
|
use vulkanalia::Version;
|
|
use vulkanalia::bytecode::Bytecode;
|
|
|
|
use std::collections::HashSet;
|
|
use std::ffi::CStr;
|
|
use std::os::raw::c_void;
|
|
|
|
// extension imports
|
|
use vulkanalia::vk::ExtDebugUtilsExtension;
|
|
use vulkanalia::vk::KhrSurfaceExtension;
|
|
use vulkanalia::vk::KhrSwapchainExtension;
|
|
|
|
use cgmath::Matrix;
|
|
use std::mem::size_of;
|
|
use std::ptr::copy_nonoverlapping as memcpy;
|
|
|
|
use std::time::Instant;
|
|
use crate::vertex::VertexContainer;
|
|
|
|
pub mod app_data;
|
|
pub mod errors;
|
|
pub mod swapchain;
|
|
pub mod queue_family_indices;
|
|
pub mod vertex;
|
|
pub mod buffer;
|
|
pub mod image;
|
|
pub mod command_buffer;
|
|
pub mod depth_buffer;
|
|
pub mod load_model;
|
|
pub mod scene;
|
|
pub mod primitives;
|
|
|
|
const PORTABILITY_MACOS_VERSION: Version = Version::new(1, 3, 216);
|
|
const VALIDATION_ENABLED: bool =
|
|
cfg!(debug_assertions);
|
|
|
|
const VALIDATION_LAYER: vk::ExtensionName =
|
|
vk::ExtensionName::from_bytes(b"VK_LAYER_KHRONOS_validation");
|
|
const DEVICE_EXTENSIONS: &[vk::ExtensionName] = &[
|
|
vk::KHR_SWAPCHAIN_EXTENSION.name
|
|
];
|
|
|
|
const MAX_FRAMES_IN_FLIGHT: usize = 3;
|
|
|
|
fn main() -> Result<()> {
|
|
pretty_env_logger::init();
|
|
|
|
// Window
|
|
|
|
let event_loop = EventLoop::new()?;
|
|
let window = WindowBuilder::new()
|
|
.with_title("Vulkan Tutorial (Rust)")
|
|
.with_inner_size(LogicalSize::new(1024, 768))
|
|
.build(&event_loop)?;
|
|
//window.set_cursor_visible(false);
|
|
|
|
// event_loop.set_control_flow(winit::event_loop::ControlFlow::Poll);
|
|
// App
|
|
|
|
let mut app = unsafe { App::create(&window)? };
|
|
event_loop.run(move |event, elwt| {
|
|
match event {
|
|
// Request a redraw when all events were processed.
|
|
Event::AboutToWait => window.request_redraw(),
|
|
Event::WindowEvent { event, .. } => match event {
|
|
// Render a frame if our Vulkan app is not being destroyed.
|
|
WindowEvent::RedrawRequested if !elwt.exiting() && !app.minimized => unsafe { app.render(&window) }.unwrap(),
|
|
// Destroy our Vulkan app.
|
|
WindowEvent::CloseRequested => {
|
|
elwt.exit();
|
|
unsafe { app.device.device_wait_idle().unwrap(); }
|
|
unsafe { app.destroy(); }
|
|
},
|
|
WindowEvent::Resized(size) => {
|
|
if size.width == 0 || size.height == 0 {
|
|
app.minimized = true;
|
|
} else {
|
|
app.minimized = false;
|
|
app.resized = true;
|
|
}
|
|
},
|
|
WindowEvent::CursorMoved { device_id, position } => {
|
|
let log_pos: LogicalPosition<f32> = position.to_logical(window.scale_factor());
|
|
if app.last_pos.x != -1.0 {
|
|
app.cam_angle_x += ((log_pos.x - (window.inner_size().width as f32 / 2.0)) / (window.inner_size().width as f32)) * 180.0;
|
|
app.cam_angle_y += ((log_pos.y - (window.inner_size().height as f32 / 2.0)) / (window.inner_size().height as f32)) * 180.0;
|
|
|
|
if app.cam_angle_x >= 360.0 {
|
|
app.cam_angle_x -= 360.0;
|
|
}
|
|
if app.cam_angle_x <= -360.0 {
|
|
app.cam_angle_x += 360.0;
|
|
}
|
|
app.cam_angle_y = app.cam_angle_y.max(-90.0).min(90.0);
|
|
}
|
|
|
|
let cursor_res = window.set_cursor_position(LogicalPosition::new(window.inner_size().width / 2, window.inner_size().height / 2));
|
|
if cursor_res.is_err() {
|
|
println!("Attempted to move cursor while not in possession")
|
|
}
|
|
|
|
app.last_pos = LogicalPosition::new(window.inner_size().width as f32 / 2 as f32, window.inner_size().height as f32 / 2 as f32);
|
|
},
|
|
WindowEvent::KeyboardInput { device_id, event, is_synthetic } => {
|
|
if event.logical_key == "w" {
|
|
app.cur_pos += app.view_direction * 0.1;
|
|
}
|
|
if event.logical_key == "s" {
|
|
app.cur_pos -= app.view_direction * 0.1;
|
|
}
|
|
if event.logical_key == "a" {
|
|
app.cur_pos -= app.view_direction.cross(vertex::Vec3::new(0.0, 0.0, 1.0)) * 0.1;
|
|
}
|
|
if event.logical_key == "d" {
|
|
app.cur_pos += app.view_direction.cross(vertex::Vec3::new(0.0, 0.0, 1.0)) * 0.1;
|
|
}
|
|
if event.logical_key == "f" && event.state == ElementState::Pressed && event.repeat == false {
|
|
app.show_frame_rate = !app.show_frame_rate;
|
|
}
|
|
if event.logical_key == NamedKey::Escape {
|
|
elwt.exit();
|
|
unsafe { app.device.device_wait_idle().unwrap(); }
|
|
unsafe { app.destroy(); }
|
|
}
|
|
},
|
|
_ => {}
|
|
}
|
|
_ => {}
|
|
}
|
|
})?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Our Vulkan app.
|
|
#[derive(Clone, Debug)]
|
|
struct App {
|
|
entry: Entry,
|
|
instance: Instance,
|
|
data: app_data::AppData,
|
|
device: Device,
|
|
frame: usize,
|
|
resized: bool,
|
|
minimized: bool,
|
|
start: Instant,
|
|
cam_angle_x: f32,
|
|
cam_angle_y: f32,
|
|
last_pos: LogicalPosition<f32>,
|
|
view_direction: vertex::Vec3,
|
|
cur_pos: cgmath::Point3<f32>,
|
|
scene_handler: scene::Scene,
|
|
show_frame_rate: bool,
|
|
synchronized: usize,
|
|
}
|
|
|
|
impl App {
|
|
/// Creates our Vulkan app.
|
|
unsafe fn create(window: &Window) -> Result<Self> {
|
|
let loader = LibloadingLoader::new(LIBRARY)?;
|
|
let entry = Entry::new(loader).map_err(|b| anyhow!("{}", b))?;
|
|
let mut data = app_data::AppData::default();
|
|
data.use_geometry_shader = false;
|
|
data.num_lights_per_volume = 2;
|
|
data.max_iterations_per_light = 20;
|
|
let mut scene_handler = scene::Scene::default();
|
|
|
|
//load_model::load_model(&mut data)?;
|
|
|
|
let instance = create_instance(window, &entry, &mut data)?;
|
|
data.surface = vk_window::create_surface(&instance, &window, &window)?;
|
|
pick_physical_device(&instance, &mut data)?;
|
|
let device = create_logical_device(&entry, &instance, &mut data)?;
|
|
swapchain::create_swapchain(window, &instance, &device, &mut data)?;
|
|
swapchain::create_swapchain_image_views(&device, &mut data)?;
|
|
create_render_pass(&instance, &device, &mut data)?;
|
|
|
|
buffer::create_descriptor_set_layout(&device, &mut data)?;
|
|
create_pipeline(&device, &mut data)?;
|
|
|
|
command_buffer::create_command_pool(&instance, &device, &mut data)?;
|
|
|
|
create_color_objects(&instance, &device, &mut data)?;
|
|
depth_buffer::create_depth_objects(&instance, &device, &mut data)?;
|
|
create_framebuffers(&device, &mut data)?;
|
|
|
|
|
|
image::create_texture_image(&instance, &device, &mut data)?;
|
|
image::create_texture_image_view(&device, &mut data)?;
|
|
image::create_texture_sampler(&device, &mut data)?;
|
|
|
|
scene_handler.prepare_data(&instance, &device, &mut data)?;
|
|
|
|
buffer::create_uniform_buffers(&instance, &device, &mut data)?;
|
|
buffer::create_storage_buffers(&instance, &device, &mut data)?;
|
|
buffer::create_descriptor_pool(&device, &mut data)?;
|
|
buffer::create_descriptor_sets(&device, &mut data)?;
|
|
|
|
command_buffer::create_command_buffers(&device, &mut data, &scene_handler)?;
|
|
|
|
create_sync_objects(&device, &mut data)?;
|
|
|
|
Ok(Self { entry, instance, data, device, frame: 0 , resized: false, minimized: false, start: Instant::now(),
|
|
cam_angle_x: 0.0, cam_angle_y: 0.0,
|
|
last_pos: LogicalPosition::new(-1 as f32, -1 as f32),
|
|
view_direction: vertex::Vec3::new(0.0, 0.0, 0.0),
|
|
cur_pos: cgmath::point3(0.0, 0.0, 0.0),
|
|
scene_handler,
|
|
show_frame_rate: false,
|
|
synchronized: 0
|
|
})
|
|
}
|
|
|
|
/// Renders a frame for our Vulkan app.
|
|
unsafe fn render(&mut self, window: &Window) -> Result<()> {
|
|
let start_time = Instant::now();
|
|
let in_flight_fence = self.data.in_flight_fences[self.frame];
|
|
|
|
self.device.wait_for_fences(&[in_flight_fence], true, u64::MAX)?;
|
|
|
|
let result = self.device.acquire_next_image_khr(
|
|
self.data.swapchain,
|
|
u64::MAX,
|
|
self.data.image_available_semaphores[self.frame],
|
|
vk::Fence::null(),
|
|
);
|
|
|
|
let image_index = match result {
|
|
Ok((image_index, _)) => image_index as usize,
|
|
Err(vk::ErrorCode::OUT_OF_DATE_KHR) => return self.recreate_swapchain(window),
|
|
Err(e) => return Err(anyhow!(e)),
|
|
};
|
|
|
|
let image_in_flight = self.data.images_in_flight[image_index];
|
|
if !image_in_flight.is_null() {
|
|
self.device.wait_for_fences(&[image_in_flight], true, u64::MAX)?;
|
|
}
|
|
|
|
self.data.images_in_flight[image_index] = in_flight_fence;
|
|
|
|
self.update_uniform_buffer(image_index)?;
|
|
if self.synchronized < MAX_FRAMES_IN_FLIGHT {
|
|
buffer::update_storage_buffer(&self.instance, &self.device, &self.data, image_index, &self.scene_handler)?;
|
|
self.synchronized += 1
|
|
}
|
|
|
|
let wait_semaphores = &[self.data.image_available_semaphores[self.frame]];
|
|
let wait_stages = &[vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT];
|
|
let command_buffers = &[self.data.command_buffers[image_index]];
|
|
let signal_semaphores = &[self.data.render_finished_semaphores[self.frame]];
|
|
let submit_info = vk::SubmitInfo::builder()
|
|
.wait_semaphores(wait_semaphores)
|
|
.wait_dst_stage_mask(wait_stages)
|
|
.command_buffers(command_buffers)
|
|
.signal_semaphores(signal_semaphores);
|
|
|
|
self.device.reset_fences(&[in_flight_fence])?;
|
|
|
|
self.device
|
|
.queue_submit(self.data.graphics_queue, &[submit_info], in_flight_fence)?;
|
|
|
|
let swapchains = &[self.data.swapchain];
|
|
let image_indices = &[image_index as u32];
|
|
let present_info = vk::PresentInfoKHR::builder()
|
|
.wait_semaphores(signal_semaphores)
|
|
.swapchains(swapchains)
|
|
.image_indices(image_indices);
|
|
|
|
let result = self.device.queue_present_khr(self.data.present_queue, &present_info);
|
|
let changed = result == Ok(vk::SuccessCode::SUBOPTIMAL_KHR) || result == Err(vk::ErrorCode::OUT_OF_DATE_KHR);
|
|
if self.resized || changed {
|
|
self.resized = false;
|
|
self.recreate_swapchain(window)?;
|
|
} else if let Err(e) = result {
|
|
return Err(anyhow!(e));
|
|
}
|
|
|
|
self.frame = (self.frame + 1) % MAX_FRAMES_IN_FLIGHT;
|
|
|
|
if self.show_frame_rate {
|
|
println!("{}", 1000000.0 / start_time.elapsed().as_micros() as f32);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Destroys our Vulkan app.
|
|
unsafe fn destroy(&mut self) {
|
|
self.destroy_swapchain();
|
|
|
|
self.device.destroy_sampler(self.data.texture_sampler, None);
|
|
|
|
self.device.destroy_image_view(self.data.texture_image_view, None);
|
|
|
|
self.device.destroy_image(self.data.texture_image, None);
|
|
self.device.free_memory(self.data.texture_image_memory, None);
|
|
|
|
self.device.destroy_descriptor_set_layout(self.data.descriptor_set_layout, None);
|
|
|
|
self.scene_handler.destroy(&self.device);
|
|
|
|
self.data.in_flight_fences
|
|
.iter()
|
|
.for_each(|f| self.device.destroy_fence(*f, None));
|
|
self.data.render_finished_semaphores
|
|
.iter()
|
|
.for_each(|s| self.device.destroy_semaphore(*s, None));
|
|
self.data.image_available_semaphores
|
|
.iter()
|
|
.for_each(|s| self.device.destroy_semaphore(*s, None));
|
|
self.device.destroy_command_pool(self.data.command_pool, None);
|
|
self.device.destroy_device(None);
|
|
self.instance.destroy_surface_khr(self.data.surface, None);
|
|
|
|
if VALIDATION_ENABLED {
|
|
self.instance.destroy_debug_utils_messenger_ext(self.data.messenger, None);
|
|
}
|
|
|
|
self.instance.destroy_instance(None);
|
|
}
|
|
|
|
unsafe fn recreate_swapchain(&mut self, window: &Window) -> Result<()> {
|
|
self.device.device_wait_idle()?;
|
|
self.destroy_swapchain();
|
|
swapchain::create_swapchain(window, &self.instance, &self.device, &mut self.data)?;
|
|
swapchain::create_swapchain_image_views(&self.device, &mut self.data)?;
|
|
create_render_pass(&self.instance, &self.device, &mut self.data)?;
|
|
create_pipeline(&self.device, &mut self.data)?;
|
|
buffer::create_descriptor_pool(&self.device, &mut self.data)?;
|
|
create_color_objects(&self.instance, &self.device, &mut self.data)?;
|
|
depth_buffer::create_depth_objects(&self.instance, &self.device, &mut self.data)?;
|
|
create_framebuffers(&self.device, &mut self.data)?;
|
|
buffer::create_uniform_buffers(&self.instance, &self.device, &mut self.data)?;
|
|
buffer::create_storage_buffers(&self.instance, &self.device, &mut self.data)?;
|
|
buffer::create_descriptor_sets(&self.device, &mut self.data)?;
|
|
command_buffer::create_command_buffers(&self.device, &mut self.data, &self.scene_handler)?;
|
|
self.data
|
|
.images_in_flight
|
|
.resize(self.data.swapchain_images.len(), vk::Fence::null());
|
|
self.synchronized = 0;
|
|
Ok(())
|
|
}
|
|
|
|
unsafe fn destroy_swapchain(&mut self) {
|
|
self.device.destroy_image_view(self.data.color_image_view, None);
|
|
self.device.free_memory(self.data.color_image_memory, None);
|
|
self.device.destroy_image(self.data.color_image, None);
|
|
|
|
self.device.destroy_image_view(self.data.depth_image_view, None);
|
|
|
|
self.device.destroy_image(self.data.depth_image, None);
|
|
self.device.free_memory(self.data.depth_image_memory, None);
|
|
|
|
self.device.destroy_descriptor_pool(self.data.descriptor_pool, None);
|
|
self.data.uniform_buffers
|
|
.iter()
|
|
.for_each(|b| self.device.destroy_buffer(*b, None));
|
|
self.data.uniform_buffers_memory
|
|
.iter()
|
|
.for_each(|m| self.device.free_memory(*m, None));
|
|
self.data.storage_buffers
|
|
.iter()
|
|
.for_each(|b| self.device.destroy_buffer(*b, None));
|
|
self.data.storage_buffers_memory
|
|
.iter()
|
|
.for_each(|m| self.device.free_memory(*m, None));
|
|
|
|
self.data.framebuffers
|
|
.iter()
|
|
.for_each(|f| self.device.destroy_framebuffer(*f, None));
|
|
self.device.free_command_buffers(self.data.command_pool, &self.data.command_buffers);
|
|
self.device.destroy_pipeline(self.data.pipeline_cube, None);
|
|
self.device.destroy_pipeline(self.data.pipeline_cuboid, None);
|
|
self.device.destroy_pipeline(self.data.pipeline_quad, None);
|
|
self.device.destroy_pipeline_layout(self.data.pipeline_layout, None);
|
|
self.device.destroy_render_pass(self.data.render_pass, None);
|
|
self.data.swapchain_image_views
|
|
.iter()
|
|
.for_each(|v| self.device.destroy_image_view(*v, None));
|
|
self.device.destroy_swapchain_khr(self.data.swapchain, None);
|
|
|
|
}
|
|
|
|
unsafe fn update_uniform_buffer(&mut self, image_index: usize) -> Result<()> {
|
|
let time = self.start.elapsed().as_secs_f32();
|
|
|
|
/*let model = buffer::Mat4::from_axis_angle(
|
|
vec3(0.0, 1.0, 0.0),
|
|
cgmath::Deg(90.0) * 0.0 //time
|
|
);*/
|
|
|
|
let rot_mat = cgmath::Matrix3::from_angle_y(cgmath::Deg(-self.cam_angle_y)) * cgmath::Matrix3::from_angle_z(cgmath::Deg(self.cam_angle_x));
|
|
let rot_mat4 = cgmath::Matrix4::from_angle_y(cgmath::Deg(-self.cam_angle_y)) * cgmath::Matrix4::from_angle_z(cgmath::Deg(self.cam_angle_x));
|
|
self.view_direction = rot_mat.transpose() * vertex::Vec3::new(1.0, 0.0, 0.0);
|
|
let model = cgmath::Matrix4::from_translation( cgmath::Point3::new(0.0, 0.0, 0.0) - self.cur_pos );
|
|
|
|
let view = buffer::Mat4::look_to_rh(
|
|
cgmath::point3(0.0, 0.0, 0.0),
|
|
vertex::Vec3::new(1.0, 0.0, 0.0),
|
|
vertex::Vec3::new(0.0, 0.0, 1.0)
|
|
);
|
|
|
|
|
|
let correction = buffer::Mat4::new( //column major order, matrix looks transposed
|
|
1.0, 0.0, 0.0, 0.0,
|
|
// We're also flipping the Y-axis with this line's `-1.0`.
|
|
0.0, -1.0, 0.0, 0.0,
|
|
0.0, 0.0, 1.0 / 2.0, 0.0,
|
|
0.0, 0.0, 1.0 / 2.0, 1.0,
|
|
);
|
|
|
|
let proj = correction
|
|
* cgmath::perspective(
|
|
cgmath::Deg(45.0),
|
|
self.data.swapchain_extent.width as f32 / self.data.swapchain_extent.height as f32,
|
|
0.1,
|
|
10000.0,
|
|
);
|
|
|
|
let ubo = buffer::UniformBufferObject { model, geom_rot: rot_mat4, view, proj,
|
|
use_geom_shader: [self.data.use_geometry_shader, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false],
|
|
camera_pos: self.cur_pos.clone()};
|
|
|
|
let memory = self.device.map_memory(
|
|
self.data.uniform_buffers_memory[image_index],
|
|
0,
|
|
size_of::<buffer::UniformBufferObject>() as u64,
|
|
vk::MemoryMapFlags::empty(),
|
|
)?;
|
|
|
|
memcpy(&ubo, memory.cast(), 1);
|
|
|
|
self.device.unmap_memory(self.data.uniform_buffers_memory[image_index]);
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
//================================================
|
|
// MARK: Instance
|
|
//================================================
|
|
|
|
unsafe fn create_instance(window: &Window, entry: &Entry, data: &mut app_data::AppData) -> Result<Instance> {
|
|
let application_info = vk::ApplicationInfo::builder()
|
|
.application_name(b"Vulkan Tutorial\0")
|
|
.application_version(vk::make_version(1, 0, 0))
|
|
.engine_name(b"No Engine\0")
|
|
.engine_version(vk::make_version(1, 0, 0))
|
|
.api_version(vk::make_version(1, 1, 0));
|
|
|
|
// Validation layers
|
|
|
|
let available_layers = entry
|
|
.enumerate_instance_layer_properties()?
|
|
.iter()
|
|
.map(|l| l.layer_name)
|
|
.collect::<HashSet<_>>();
|
|
|
|
if VALIDATION_ENABLED && !available_layers.contains(&VALIDATION_LAYER) {
|
|
return Err(anyhow!("Validation layer requested but not supported."));
|
|
}
|
|
|
|
let layers = if VALIDATION_ENABLED {
|
|
vec![VALIDATION_LAYER.as_ptr()]
|
|
} else {
|
|
Vec::new()
|
|
};
|
|
|
|
// Extension
|
|
let mut extensions = vk_window::get_required_instance_extensions(window)
|
|
.iter()
|
|
.map(|e| e.as_ptr())
|
|
.collect::<Vec<_>>();
|
|
|
|
if VALIDATION_ENABLED {
|
|
extensions.push(vk::EXT_DEBUG_UTILS_EXTENSION.name.as_ptr());
|
|
}
|
|
|
|
// Required by Vulkan SDK on macOS since 1.3.216.
|
|
let flags = if
|
|
cfg!(target_os = "macos") &&
|
|
entry.version()? >= PORTABILITY_MACOS_VERSION
|
|
{
|
|
info!("Enabling extensions for macOS portability.");
|
|
extensions.push(vk::KHR_GET_PHYSICAL_DEVICE_PROPERTIES2_EXTENSION.name.as_ptr());
|
|
extensions.push(vk::KHR_PORTABILITY_ENUMERATION_EXTENSION.name.as_ptr());
|
|
vk::InstanceCreateFlags::ENUMERATE_PORTABILITY_KHR
|
|
} else {
|
|
vk::InstanceCreateFlags::empty()
|
|
};
|
|
|
|
let mut info = vk::InstanceCreateInfo::builder()
|
|
.application_info(&application_info)
|
|
.enabled_layer_names(&layers)
|
|
.enabled_extension_names(&extensions)
|
|
.flags(flags);
|
|
|
|
let mut debug_info = vk::DebugUtilsMessengerCreateInfoEXT::builder()
|
|
.message_severity(vk::DebugUtilsMessageSeverityFlagsEXT::all())
|
|
.message_type(vk::DebugUtilsMessageTypeFlagsEXT::all())
|
|
.user_callback(Some(debug_callback));
|
|
|
|
if VALIDATION_ENABLED {
|
|
info = info.push_next(&mut debug_info);
|
|
}
|
|
|
|
let instance = entry.create_instance(&info, None)?;
|
|
|
|
if VALIDATION_ENABLED {
|
|
data.messenger = instance.create_debug_utils_messenger_ext(&debug_info, None)?;
|
|
}
|
|
|
|
Ok(instance)
|
|
}
|
|
|
|
extern "system" fn debug_callback(
|
|
severity: vk::DebugUtilsMessageSeverityFlagsEXT,
|
|
type_: vk::DebugUtilsMessageTypeFlagsEXT,
|
|
data: *const vk::DebugUtilsMessengerCallbackDataEXT,
|
|
_: *mut c_void,
|
|
) -> vk::Bool32 {
|
|
let data = unsafe { *data };
|
|
let message = unsafe { CStr::from_ptr(data.message) }.to_string_lossy();
|
|
|
|
if severity >= vk::DebugUtilsMessageSeverityFlagsEXT::ERROR {
|
|
error!("({:?}) {}", type_, message);
|
|
} else if severity >= vk::DebugUtilsMessageSeverityFlagsEXT::WARNING {
|
|
warn!("({:?}) {}", type_, message);
|
|
} else if severity >= vk::DebugUtilsMessageSeverityFlagsEXT::INFO {
|
|
debug!("({:?}) {}", type_, message);
|
|
} else {
|
|
trace!("({:?}) {}", type_, message);
|
|
}
|
|
|
|
vk::FALSE
|
|
}
|
|
|
|
unsafe fn pick_physical_device(instance: &Instance, data: &mut app_data::AppData) -> Result<()> {
|
|
for physical_device in instance.enumerate_physical_devices()? {
|
|
let properties = instance.get_physical_device_properties(physical_device);
|
|
|
|
if let Err(error) = check_physical_device(instance, data, physical_device) {
|
|
warn!("Skipping physical device (`{}`): {}", properties.device_name, error);
|
|
} else {
|
|
info!("Selected physical device (`{}`).", properties.device_name);
|
|
data.physical_device = physical_device;
|
|
data.msaa_samples = get_max_msaa_samples(instance, data);
|
|
return Ok(());
|
|
}
|
|
}
|
|
|
|
Err(anyhow!("Failed to find suitable physical device."))
|
|
}
|
|
|
|
unsafe fn check_physical_device(
|
|
instance: &Instance,
|
|
data: &app_data::AppData,
|
|
physical_device: vk::PhysicalDevice,
|
|
) -> Result<()> {
|
|
let properties = instance.get_physical_device_properties(physical_device);
|
|
if properties.device_type != vk::PhysicalDeviceType::DISCRETE_GPU {
|
|
return Err(anyhow!(errors::SuitabilityError("Only discrete GPUs are supported.")));
|
|
}
|
|
|
|
let features = instance.get_physical_device_features(physical_device);
|
|
if features.geometry_shader != vk::TRUE {
|
|
return Err(anyhow!(errors::SuitabilityError("Missing geometry shader support.")));
|
|
}
|
|
if features.sampler_anisotropy != vk::TRUE {
|
|
return Err(anyhow!(errors::SuitabilityError("No sampler anisotropy.")));
|
|
}
|
|
|
|
queue_family_indices::QueueFamilyIndices::get(instance, data, physical_device)?;
|
|
check_physical_device_extensions(instance, physical_device)?;
|
|
|
|
let support = swapchain::SwapchainSupport::get(instance, data, physical_device)?;
|
|
if support.formats.is_empty() || support.present_modes.is_empty() {
|
|
return Err(anyhow!(errors::SuitabilityError("Insufficient swapchain support.")));
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
unsafe fn check_physical_device_extensions(
|
|
instance: &Instance,
|
|
physical_device: vk::PhysicalDevice,
|
|
) -> Result<()> {
|
|
let extensions = instance
|
|
.enumerate_device_extension_properties(physical_device, None)?
|
|
.iter()
|
|
.map(|e| e.extension_name)
|
|
.collect::<HashSet<_>>();
|
|
if DEVICE_EXTENSIONS.iter().all(|e| extensions.contains(e)) {
|
|
Ok(())
|
|
} else {
|
|
let missing = DEVICE_EXTENSIONS.iter().filter(|e| !extensions.contains(e)).collect::<Vec<&vk::ExtensionName>>();
|
|
for missing_extension in missing {
|
|
println!("Missing extension: {}", missing_extension);
|
|
}
|
|
Err(anyhow!(errors::SuitabilityError("Missing required device extensions.")))
|
|
}
|
|
}
|
|
|
|
|
|
unsafe fn create_logical_device(
|
|
entry: &Entry,
|
|
instance: &Instance,
|
|
data: &mut app_data::AppData,
|
|
) -> Result<Device> {
|
|
let indices = queue_family_indices::QueueFamilyIndices::get(instance, data, data.physical_device)?;
|
|
|
|
let queue_priorities = &[1.0];
|
|
let queue_info = vk::DeviceQueueCreateInfo::builder()
|
|
.queue_family_index(indices.graphics)
|
|
.queue_priorities(queue_priorities);
|
|
|
|
let layers = if VALIDATION_ENABLED {
|
|
vec![VALIDATION_LAYER.as_ptr()]
|
|
} else {
|
|
vec![]
|
|
};
|
|
|
|
let mut extensions = DEVICE_EXTENSIONS
|
|
.iter()
|
|
.map(|n| n.as_ptr())
|
|
.collect::<Vec<_>>();
|
|
|
|
// Required by Vulkan SDK on macOS since 1.3.216.
|
|
if cfg!(target_os = "macos") && entry.version()? >= PORTABILITY_MACOS_VERSION {
|
|
extensions.push(vk::KHR_PORTABILITY_SUBSET_EXTENSION.name.as_ptr());
|
|
};
|
|
|
|
let features = vk::PhysicalDeviceFeatures::builder()
|
|
.sampler_anisotropy(true)
|
|
.geometry_shader(true);
|
|
|
|
let indices = queue_family_indices::QueueFamilyIndices::get(instance, data, data.physical_device)?;
|
|
|
|
let mut unique_indices = HashSet::new();
|
|
unique_indices.insert(indices.graphics);
|
|
unique_indices.insert(indices.present);
|
|
|
|
let queue_priorities = &[1.0];
|
|
let queue_infos = unique_indices
|
|
.iter()
|
|
.map(|i| {
|
|
vk::DeviceQueueCreateInfo::builder()
|
|
.queue_family_index(*i)
|
|
.queue_priorities(queue_priorities)
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
|
|
let info = vk::DeviceCreateInfo::builder()
|
|
.queue_create_infos(&queue_infos)
|
|
.enabled_layer_names(&layers)
|
|
.enabled_extension_names(&extensions)
|
|
.enabled_features(&features);
|
|
let device = instance.create_device(data.physical_device, &info, None)?;
|
|
|
|
data.graphics_queue = device.get_device_queue(indices.graphics, 0);
|
|
data.present_queue = device.get_device_queue(indices.present, 0);
|
|
|
|
Ok(device)
|
|
}
|
|
|
|
unsafe fn create_pipeline(device: &Device, data: &mut app_data::AppData) -> Result<()> {
|
|
// set up shaders for cubes
|
|
// load the byte data
|
|
let vert_cube = include_bytes!("../shaders/compiled/vert_cube.spv");
|
|
let geo_cube = include_bytes!("../shaders/compiled/geo_cube.spv");
|
|
let frag_cube = include_bytes!("../shaders/compiled/frag_cube.spv");
|
|
// create the shaders
|
|
let vert_shader_module_cube = create_shader_module(device, &vert_cube[..])?;
|
|
let geo_shader_module_cube = create_shader_module(device, &geo_cube[..])?;
|
|
let frag_shader_module_cube = create_shader_module(device, &frag_cube[..])?;
|
|
//create the shader stage for the vertex shader
|
|
let vert_stage_cube = vk::PipelineShaderStageCreateInfo::builder()
|
|
.stage(vk::ShaderStageFlags::VERTEX)
|
|
.module(vert_shader_module_cube)
|
|
.name(b"main\0");
|
|
//create the shader stage for the geometry shader
|
|
let geo_stage_cube = vk::PipelineShaderStageCreateInfo::builder()
|
|
.stage(vk::ShaderStageFlags::GEOMETRY)
|
|
.module(geo_shader_module_cube)
|
|
.name(b"main\0");
|
|
//create the shader stage for the fragment shader
|
|
let frag_stage_cube = vk::PipelineShaderStageCreateInfo::builder()
|
|
.stage(vk::ShaderStageFlags::FRAGMENT)
|
|
.module(frag_shader_module_cube)
|
|
.name(b"main\0");
|
|
// create the binding description for the cube vertex
|
|
let binding_descriptions_cube = &[vertex::Vertex::binding_description()];
|
|
let attribute_descriptions_cube = vertex::Vertex::attribute_descriptions();
|
|
let vertex_input_state_cube = vk::PipelineVertexInputStateCreateInfo::builder()
|
|
.vertex_binding_descriptions(binding_descriptions_cube)
|
|
.vertex_attribute_descriptions(&attribute_descriptions_cube);
|
|
|
|
// set up shaders for cuboids
|
|
// load the byte data
|
|
let vert_cuboid = include_bytes!("../shaders/compiled/vert_cuboid.spv");
|
|
let geo_cuboid = include_bytes!("../shaders/compiled/geo_cuboid.spv");
|
|
let frag_cuboid = include_bytes!("../shaders/compiled/frag_cuboid.spv");
|
|
// create the shaders
|
|
let vert_shader_module_cuboid = create_shader_module(device, &vert_cuboid[..])?;
|
|
let geo_shader_module_cuboid = create_shader_module(device, &geo_cuboid[..])?;
|
|
let frag_shader_module_cuboid = create_shader_module(device, &frag_cuboid[..])?;
|
|
//create the shader stage for the vertex shader
|
|
let vert_stage_cuboid = vk::PipelineShaderStageCreateInfo::builder()
|
|
.stage(vk::ShaderStageFlags::VERTEX)
|
|
.module(vert_shader_module_cuboid)
|
|
.name(b"main\0");
|
|
//create the shader stage for the geometry shader
|
|
let geo_stage_cuboid = vk::PipelineShaderStageCreateInfo::builder()
|
|
.stage(vk::ShaderStageFlags::GEOMETRY)
|
|
.module(geo_shader_module_cuboid)
|
|
.name(b"main\0");
|
|
//create the shader stage for the fragment shader
|
|
let frag_stage_cuboid = vk::PipelineShaderStageCreateInfo::builder()
|
|
.stage(vk::ShaderStageFlags::FRAGMENT)
|
|
.module(frag_shader_module_cuboid)
|
|
.name(b"main\0");
|
|
// create the binding description for the sized vertex
|
|
let binding_descriptions_cuboid = &[vertex::SizedVertex::binding_description()];
|
|
let attribute_descriptions_cuboid = vertex::SizedVertex::attribute_descriptions();
|
|
let vertex_input_state_cuboid = vk::PipelineVertexInputStateCreateInfo::builder()
|
|
.vertex_binding_descriptions(binding_descriptions_cuboid)
|
|
.vertex_attribute_descriptions(&attribute_descriptions_cuboid);
|
|
|
|
// set up shaders for quads/raytracing
|
|
// load the byte data
|
|
let vert_quad = include_bytes!("../shaders/compiled/vert_rt_quad.spv");
|
|
let frag_quad = include_bytes!("../shaders/compiled/frag_rt_quad.spv");
|
|
// create the shaders
|
|
let vert_shader_module_quad = create_shader_module(device, &vert_quad[..])?;
|
|
let frag_shader_module_quad = create_shader_module(device, &frag_quad[..])?;
|
|
//create the shader stage for the vertex shader
|
|
let vert_stage_quad = vk::PipelineShaderStageCreateInfo::builder()
|
|
.stage(vk::ShaderStageFlags::VERTEX)
|
|
.module(vert_shader_module_quad)
|
|
.name(b"main\0");
|
|
//create the shader stage for the fragment shader
|
|
let frag_stage_quad = vk::PipelineShaderStageCreateInfo::builder()
|
|
.stage(vk::ShaderStageFlags::FRAGMENT)
|
|
.module(frag_shader_module_quad)
|
|
.name(b"main\0");
|
|
// create the binding description for the quad vertex
|
|
let binding_descriptions_quad = &[vertex::RTVertex::binding_description()];
|
|
let attribute_descriptions_quad = vertex::RTVertex::attribute_descriptions();
|
|
let vertex_input_state_quad = vk::PipelineVertexInputStateCreateInfo::builder()
|
|
.vertex_binding_descriptions(binding_descriptions_quad)
|
|
.vertex_attribute_descriptions(&attribute_descriptions_quad);
|
|
|
|
// define input assembly and object type. This is altered when using geometry shader
|
|
let mut topology = vk::PrimitiveTopology::TRIANGLE_LIST;
|
|
if data.use_geometry_shader {
|
|
topology = vk::PrimitiveTopology::POINT_LIST;
|
|
}
|
|
data.topology = topology;
|
|
|
|
let input_assembly_state = vk::PipelineInputAssemblyStateCreateInfo::builder()
|
|
.topology(topology)
|
|
.primitive_restart_enable(false);
|
|
|
|
// define viewport and other transformations when projecting onto the screen
|
|
let viewport = vk::Viewport::builder()
|
|
.x(0.0)
|
|
.y(0.0)
|
|
.width(data.swapchain_extent.width as f32)
|
|
.height(data.swapchain_extent.height as f32)
|
|
.min_depth(0.0)
|
|
.max_depth(1.0);
|
|
|
|
let scissor = vk::Rect2D::builder()
|
|
.offset(vk::Offset2D { x: 0, y: 0 })
|
|
.extent(data.swapchain_extent);
|
|
|
|
let viewports = &[viewport];
|
|
let scissors = &[scissor];
|
|
let viewport_state = vk::PipelineViewportStateCreateInfo::builder()
|
|
.viewports(viewports)
|
|
.scissors(scissors);
|
|
|
|
let rasterization_state = vk::PipelineRasterizationStateCreateInfo::builder()
|
|
.depth_clamp_enable(false)
|
|
.rasterizer_discard_enable(false)
|
|
.polygon_mode(vk::PolygonMode::FILL)
|
|
.line_width(1.0)
|
|
.cull_mode(vk::CullModeFlags::BACK)
|
|
.front_face(vk::FrontFace::COUNTER_CLOCKWISE)
|
|
.depth_bias_enable(false);
|
|
|
|
let multisample_state = vk::PipelineMultisampleStateCreateInfo::builder()
|
|
.sample_shading_enable(false)
|
|
.rasterization_samples(data.msaa_samples);
|
|
|
|
let depth_stencil_state = vk::PipelineDepthStencilStateCreateInfo::builder()
|
|
.depth_test_enable(true)
|
|
.depth_write_enable(true)
|
|
.depth_compare_op(vk::CompareOp::LESS)
|
|
.depth_bounds_test_enable(false)
|
|
.min_depth_bounds(0.0) // Optional.
|
|
.max_depth_bounds(1.0) // Optional.
|
|
.stencil_test_enable(false);
|
|
|
|
let attachment = vk::PipelineColorBlendAttachmentState::builder()
|
|
.color_write_mask(vk::ColorComponentFlags::all())
|
|
.blend_enable(false)
|
|
.src_color_blend_factor(vk::BlendFactor::ONE) // Optional
|
|
.dst_color_blend_factor(vk::BlendFactor::ZERO) // Optional
|
|
.color_blend_op(vk::BlendOp::ADD) // Optional
|
|
.src_alpha_blend_factor(vk::BlendFactor::ONE) // Optional
|
|
.dst_alpha_blend_factor(vk::BlendFactor::ZERO) // Optional
|
|
.alpha_blend_op(vk::BlendOp::ADD); // Optional
|
|
|
|
let attachments = &[attachment];
|
|
let color_blend_state = vk::PipelineColorBlendStateCreateInfo::builder()
|
|
.logic_op_enable(false)
|
|
.logic_op(vk::LogicOp::COPY)
|
|
.attachments(attachments)
|
|
.blend_constants([0.0, 0.0, 0.0, 0.0]);
|
|
|
|
// define the work pipeline
|
|
let set_layouts = &[data.descriptor_set_layout];
|
|
let layout_info = vk::PipelineLayoutCreateInfo::builder()
|
|
.set_layouts(set_layouts);
|
|
|
|
data.pipeline_layout = device.create_pipeline_layout(&layout_info, None)?;
|
|
// define stages for the cubes pipeline
|
|
let stages_cube = &[vert_stage_cube, frag_stage_cube];
|
|
let stages_geom_cube = &[vert_stage_cube, geo_stage_cube,frag_stage_cube];
|
|
|
|
let mut info_cube = vk::GraphicsPipelineCreateInfo::builder()
|
|
.vertex_input_state(&vertex_input_state_cube)
|
|
.input_assembly_state(&input_assembly_state)
|
|
.viewport_state(&viewport_state)
|
|
.rasterization_state(&rasterization_state)
|
|
.multisample_state(&multisample_state)
|
|
.depth_stencil_state(&depth_stencil_state)
|
|
.color_blend_state(&color_blend_state)
|
|
.layout(data.pipeline_layout)
|
|
.render_pass(data.render_pass)
|
|
.subpass(0);
|
|
|
|
if data.use_geometry_shader {
|
|
info_cube = info_cube.stages(stages_geom_cube);
|
|
}
|
|
else {
|
|
info_cube = info_cube.stages(stages_cube);
|
|
}
|
|
// define stages for the cuboid pipeline
|
|
let stages_cuboid = &[vert_stage_cuboid, frag_stage_cuboid];
|
|
let stages_geom_cuboid = &[vert_stage_cuboid, geo_stage_cuboid,frag_stage_cuboid];
|
|
|
|
let mut info_cuboid = vk::GraphicsPipelineCreateInfo::builder()
|
|
.vertex_input_state(&vertex_input_state_cuboid)
|
|
.input_assembly_state(&input_assembly_state)
|
|
.viewport_state(&viewport_state)
|
|
.rasterization_state(&rasterization_state)
|
|
.multisample_state(&multisample_state)
|
|
.depth_stencil_state(&depth_stencil_state)
|
|
.color_blend_state(&color_blend_state)
|
|
.layout(data.pipeline_layout)
|
|
.render_pass(data.render_pass)
|
|
.subpass(0);
|
|
|
|
if data.use_geometry_shader {
|
|
info_cuboid = info_cuboid.stages(stages_geom_cuboid);
|
|
}
|
|
else {
|
|
info_cuboid = info_cuboid.stages(stages_cuboid);
|
|
}
|
|
// define stages for the quad/rt pipeline
|
|
let stages_quad = &[vert_stage_quad, frag_stage_quad];
|
|
|
|
let mut info_quad = vk::GraphicsPipelineCreateInfo::builder()
|
|
.vertex_input_state(&vertex_input_state_quad)
|
|
.input_assembly_state(&input_assembly_state)
|
|
.viewport_state(&viewport_state)
|
|
.rasterization_state(&rasterization_state)
|
|
.multisample_state(&multisample_state)
|
|
.depth_stencil_state(&depth_stencil_state)
|
|
.color_blend_state(&color_blend_state)
|
|
.layout(data.pipeline_layout)
|
|
.render_pass(data.render_pass)
|
|
.subpass(0);
|
|
|
|
|
|
info_quad = info_quad.stages(stages_quad);
|
|
|
|
// create the pipeline
|
|
let pipelines = device.create_graphics_pipelines(vk::PipelineCache::null(), &[info_cube, info_cuboid, info_quad], None)?.0;
|
|
|
|
data.pipeline_cube = pipelines[0];
|
|
data.pipeline_cuboid = pipelines[1];
|
|
data.pipeline_quad = pipelines[2];
|
|
|
|
device.destroy_shader_module(vert_shader_module_cube, None);
|
|
device.destroy_shader_module(geo_shader_module_cube, None);
|
|
device.destroy_shader_module(frag_shader_module_cube, None);
|
|
|
|
device.destroy_shader_module(vert_shader_module_cuboid, None);
|
|
device.destroy_shader_module(geo_shader_module_cuboid, None);
|
|
device.destroy_shader_module(frag_shader_module_cuboid, None);
|
|
|
|
device.destroy_shader_module(vert_shader_module_quad, None);
|
|
device.destroy_shader_module(frag_shader_module_quad, None);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
unsafe fn create_shader_module(
|
|
device: &Device,
|
|
bytecode: &[u8],
|
|
) -> Result<vk::ShaderModule> {
|
|
let bytecode = Bytecode::new(bytecode).unwrap();
|
|
let info = vk::ShaderModuleCreateInfo::builder()
|
|
.code_size(bytecode.code_size())
|
|
.code(bytecode.code());
|
|
|
|
Ok(device.create_shader_module(&info, None)?)
|
|
}
|
|
|
|
unsafe fn create_render_pass(
|
|
instance: &Instance,
|
|
device: &Device,
|
|
data: &mut app_data::AppData,
|
|
) -> Result<()> {
|
|
let color_attachment = vk::AttachmentDescription::builder()
|
|
.format(data.swapchain_format)
|
|
.samples(data.msaa_samples)
|
|
.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::COLOR_ATTACHMENT_OPTIMAL);
|
|
|
|
let color_attachment_ref = vk::AttachmentReference::builder()
|
|
.attachment(0)
|
|
.layout(vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL);
|
|
|
|
let color_resolve_attachment = vk::AttachmentDescription::builder()
|
|
.format(data.swapchain_format)
|
|
.samples(vk::SampleCountFlags::_1)
|
|
.load_op(vk::AttachmentLoadOp::DONT_CARE)
|
|
.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_resolve_attachment_ref = vk::AttachmentReference::builder()
|
|
.attachment(2)
|
|
.layout(vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL);
|
|
|
|
let depth_stencil_attachment = vk::AttachmentDescription::builder()
|
|
.format(depth_buffer::get_depth_format(instance, data)?)
|
|
.samples(data.msaa_samples)
|
|
.load_op(vk::AttachmentLoadOp::CLEAR)
|
|
.store_op(vk::AttachmentStoreOp::DONT_CARE)
|
|
.stencil_load_op(vk::AttachmentLoadOp::DONT_CARE)
|
|
.stencil_store_op(vk::AttachmentStoreOp::DONT_CARE)
|
|
.initial_layout(vk::ImageLayout::UNDEFINED)
|
|
.final_layout(vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
|
|
|
|
let depth_stencil_attachment_ref = vk::AttachmentReference::builder()
|
|
.attachment(1)
|
|
.layout(vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
|
|
|
|
let color_attachments = &[color_attachment_ref];
|
|
let resolve_attachments = &[color_resolve_attachment_ref];
|
|
let subpass = vk::SubpassDescription::builder()
|
|
.pipeline_bind_point(vk::PipelineBindPoint::GRAPHICS)
|
|
.color_attachments(color_attachments)
|
|
.depth_stencil_attachment(&depth_stencil_attachment_ref)
|
|
.resolve_attachments(resolve_attachments);
|
|
|
|
let dependency = vk::SubpassDependency::builder()
|
|
.src_subpass(vk::SUBPASS_EXTERNAL)
|
|
.dst_subpass(0)
|
|
.src_stage_mask(vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT
|
|
| vk::PipelineStageFlags::EARLY_FRAGMENT_TESTS)
|
|
.src_access_mask(vk::AccessFlags::empty())
|
|
.dst_stage_mask(vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT
|
|
| vk::PipelineStageFlags::EARLY_FRAGMENT_TESTS)
|
|
.dst_access_mask(vk::AccessFlags::COLOR_ATTACHMENT_WRITE
|
|
| vk::AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE);
|
|
|
|
let attachments = &[color_attachment, depth_stencil_attachment, color_resolve_attachment];
|
|
let subpasses = &[subpass];
|
|
let dependencies = &[dependency];
|
|
let info = vk::RenderPassCreateInfo::builder()
|
|
.attachments(attachments)
|
|
.subpasses(subpasses)
|
|
.dependencies(dependencies);
|
|
|
|
data.render_pass = device.create_render_pass(&info, None)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
unsafe fn create_framebuffers(device: &Device, data: &mut app_data::AppData) -> Result<()> {
|
|
data.framebuffers = data
|
|
.swapchain_image_views
|
|
.iter()
|
|
.map(|i| {
|
|
let attachments = &[data.color_image_view, data.depth_image_view, *i];
|
|
let create_info = vk::FramebufferCreateInfo::builder()
|
|
.render_pass(data.render_pass)
|
|
.attachments(attachments)
|
|
.width(data.swapchain_extent.width)
|
|
.height(data.swapchain_extent.height)
|
|
.layers(1);
|
|
|
|
device.create_framebuffer(&create_info, None)
|
|
})
|
|
.collect::<Result<Vec<_>, _>>()?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
unsafe fn create_sync_objects(device: &Device, data: &mut app_data::AppData) -> Result<()> {
|
|
let semaphore_info = vk::SemaphoreCreateInfo::builder();
|
|
let fence_info = vk::FenceCreateInfo::builder()
|
|
.flags(vk::FenceCreateFlags::SIGNALED);
|
|
|
|
for _ in 0..MAX_FRAMES_IN_FLIGHT {
|
|
data.image_available_semaphores
|
|
.push(device.create_semaphore(&semaphore_info, None)?);
|
|
data.render_finished_semaphores
|
|
.push(device.create_semaphore(&semaphore_info, None)?);
|
|
|
|
data.in_flight_fences.push(device.create_fence(&fence_info, None)?);
|
|
}
|
|
|
|
data.images_in_flight = data.swapchain_images
|
|
.iter()
|
|
.map(|_| vk::Fence::null())
|
|
.collect();
|
|
|
|
Ok(())
|
|
}
|
|
|
|
unsafe fn get_max_msaa_samples(
|
|
instance: &Instance,
|
|
data: &app_data::AppData,
|
|
) -> vk::SampleCountFlags {
|
|
let properties = instance.get_physical_device_properties(data.physical_device);
|
|
let counts = properties.limits.framebuffer_color_sample_counts
|
|
& properties.limits.framebuffer_depth_sample_counts;
|
|
[
|
|
vk::SampleCountFlags::_64,
|
|
vk::SampleCountFlags::_32,
|
|
vk::SampleCountFlags::_16,
|
|
vk::SampleCountFlags::_8,
|
|
vk::SampleCountFlags::_4,
|
|
vk::SampleCountFlags::_2,
|
|
]
|
|
.iter()
|
|
.cloned()
|
|
.find(|c| counts.contains(*c))
|
|
.unwrap_or(vk::SampleCountFlags::_1)
|
|
}
|
|
|
|
unsafe fn create_color_objects(
|
|
instance: &Instance,
|
|
device: &Device,
|
|
data: &mut app_data::AppData,
|
|
) -> Result<()> {
|
|
let (color_image, color_image_memory) = image::create_image(
|
|
instance,
|
|
device,
|
|
data,
|
|
data.swapchain_extent.width,
|
|
data.swapchain_extent.height,
|
|
1,
|
|
data.msaa_samples,
|
|
data.swapchain_format,
|
|
vk::ImageTiling::OPTIMAL,
|
|
vk::ImageUsageFlags::COLOR_ATTACHMENT
|
|
| vk::ImageUsageFlags::TRANSIENT_ATTACHMENT,
|
|
vk::MemoryPropertyFlags::DEVICE_LOCAL,
|
|
)?;
|
|
|
|
data.color_image = color_image;
|
|
data.color_image_memory = color_image_memory;
|
|
|
|
data.color_image_view = image::create_image_view(
|
|
device,
|
|
data.color_image,
|
|
data.swapchain_format,
|
|
vk::ImageAspectFlags::COLOR,
|
|
1,
|
|
)?;
|
|
|
|
Ok(())
|
|
} |