118 lines
3.2 KiB
Rust
118 lines
3.2 KiB
Rust
use crate::create_instance;
|
|
use crate::VALIDATION_ENABLED;
|
|
use ::anyhow::{anyhow, Result};
|
|
use ::log::*;
|
|
use ::thiserror::Error;
|
|
use ::vulkanalia::loader::{LibloadingLoader, LIBRARY};
|
|
use ::vulkanalia::prelude::v1_0::*;
|
|
use ::vulkanalia::vk::ExtDebugUtilsExtension;
|
|
use ::winit::window::Window;
|
|
|
|
/// Our Vulkan app.
|
|
#[derive(Clone, Debug)]
|
|
pub struct App {
|
|
entry: Entry,
|
|
instance: Instance,
|
|
data: AppData,
|
|
}
|
|
|
|
impl App {
|
|
/// Creates our Vulkan app.
|
|
pub 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 = AppData::default();
|
|
let instance = create_instance(window, &entry, &mut data)?;
|
|
|
|
pick_physical_device(&instance, &mut data)?;
|
|
Ok(Self {
|
|
entry,
|
|
instance,
|
|
data,
|
|
})
|
|
}
|
|
|
|
/// Renders a frame for our Vulkan app.
|
|
pub unsafe fn render(&mut self, window: &Window) -> Result<()> {
|
|
Ok(())
|
|
}
|
|
|
|
/// Destroys our Vulkan app.
|
|
pub unsafe fn destroy(&mut self) {
|
|
if VALIDATION_ENABLED {
|
|
self.instance
|
|
.destroy_debug_utils_messenger_ext(self.data.messenger, None);
|
|
}
|
|
|
|
self.instance.destroy_instance(None);
|
|
}
|
|
}
|
|
|
|
/// The Vulkan handles and associated properties used by our Vulkan app.
|
|
#[derive(Clone, Debug, Default)]
|
|
pub struct AppData {
|
|
messenger: vk::DebugUtilsMessengerEXT,
|
|
physical_device: vk::PhysicalDevice,
|
|
}
|
|
|
|
#[derive(Debug, Error)]
|
|
#[error("Missing {0}.")]
|
|
pub struct SuitabilityError(pub &'static str);
|
|
|
|
unsafe fn pick_physical_device(instance: &Instance, data: &mut 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;
|
|
return Ok(());
|
|
}
|
|
}
|
|
|
|
Err(anyhow!("Failed to find suitable physical device."))
|
|
}
|
|
|
|
unsafe fn check_physical_device(
|
|
instance: &Instance,
|
|
data: &AppData,
|
|
physical_device: vk::PhysicalDevice,
|
|
) -> Result<()> {
|
|
QueueFamilyIndicies::get(instance, data, physical_device)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[derive(Copy, Clone, Debug)]
|
|
struct QueueFamilyIndicies {
|
|
graphics: u32,
|
|
}
|
|
|
|
impl QueueFamilyIndicies {
|
|
unsafe fn get(
|
|
instance: &Instance,
|
|
data: &AppData,
|
|
physical_device: vk::PhysicalDevice,
|
|
) -> Result<Self> {
|
|
let properties = instance.get_physical_device_queue_family_properties(physical_device);
|
|
|
|
let graphics = properties
|
|
.iter()
|
|
.position(|p| p.queue_flags.contains(vk::QueueFlags::GRAPHICS))
|
|
.map(|i| i as u32);
|
|
|
|
if let Some(graphics) = graphics {
|
|
Ok(Self { graphics })
|
|
} else {
|
|
Err(anyhow!(SuitabilityError(
|
|
"Missing required queue families."
|
|
)))
|
|
}
|
|
}
|
|
}
|