miel 0.2.0

A simple rendering framework leveraging the Vulkan API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

use std::{ffi::CString, ops::Deref};

use ash::{ext, vk};
use thiserror::Error;
use winit::raw_window_handle::RawDisplayHandle;

pub(crate) struct Instance {
    pub loader: ash::Instance,
}

impl Deref for Instance {
    type Target = ash::Instance;

    fn deref(&self) -> &Self::Target {
        &self.loader
    }
}

#[derive(Debug, Error)]
pub enum InstanceCreateError {
    #[error("query for necessary extensions from ash_window failed")]
    ExtensionQuery(vk::Result),
    #[error("vulkan call to create instance failed")]
    VulkanCreation(vk::Result),
}

impl Instance {
    pub fn create(
        entry: &ash::Entry,
        application_name: &CString,
        application_version: u32,
        vk_version: u32,
        display_handle: RawDisplayHandle,
    ) -> Result<Self, InstanceCreateError> {
        let mut engine_version_numbers = option_env!("CARGO_PKG_VERSION")
            .unwrap_or("1.0.0")
            .split('.')
            .flat_map(|value| value.parse::<u32>())
            .chain(std::iter::repeat(0));
        let engine_version = vk::make_api_version(
            engine_version_numbers.next().unwrap(),
            engine_version_numbers.next().unwrap(),
            engine_version_numbers.next().unwrap(),
            engine_version_numbers.next().unwrap(),
        );
        let app_info = vk::ApplicationInfo::default()
            .application_name(application_name)
            .application_version(application_version)
            .engine_name(c"miel")
            .engine_version(engine_version)
            .api_version(vk_version);
        let mut enabled_extensions = ash_window::enumerate_required_extensions(display_handle)
            .map_err(InstanceCreateError::ExtensionQuery)?
            .to_vec();
        let mut enabled_layers = vec![];
        if cfg!(debug_assertions) {
            enabled_extensions.push(ext::debug_utils::NAME.as_ptr());
            enabled_layers.push(c"VK_LAYER_KHRONOS_validation".as_ptr());
        }

        let instance_create_info = vk::InstanceCreateInfo::default()
            .application_info(&app_info)
            .enabled_extension_names(&enabled_extensions)
            .enabled_layer_names(&enabled_layers);

        // SAFETY: This is only safe is we keep the entry alive for longer than the instance, which
        // we do by storing it as well.
        let handle = unsafe {
            entry
                .create_instance(&instance_create_info, None)
                .map_err(InstanceCreateError::VulkanCreation)?
        };

        Ok(Self { loader: handle })
    }
}

impl Drop for Instance {
    fn drop(&mut self) {
        log::debug!("destroying instance");
        // SAFETY: This is safe as long as the entry used to create the loader is still alive.
        unsafe { self.loader.destroy_instance(None) };
    }
}