lava 0.4.9

Rust wrapper to manipulate Vulkan more conveniently than with bindings.
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
85
86
87

// Generated by `scripts/generate.js`

use utils::c_bindings::*;
use utils::vk_traits::*;
use utils::vk_ptr::*;
use utils::vk_convert::*;
use std::os::raw::c_char;
use std::ptr;
use std::mem;
use vulkan::LavaResult;
use vulkan::vk::*;


/// Wrapper for [vkCreateInstance](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateInstance.html).
pub fn vk_create_instance(create_info: VkInstanceCreateInfo) -> LavaResult<VkInstance> {
    unsafe {
        let raw_create_info = new_ptr_vk_value(&create_info);
        let mut vk_result = 0;
        let raw_instance = &mut mem::zeroed() as *mut RawVkInstance;
        
        vk_result = vkCreateInstance(raw_create_info, ptr::null(), raw_instance);
        
        let mut instance = new_vk_value(raw_instance);
        if vk_result == 0 {
            let fn_table = Box::into_raw(Box::new(VkFunctionTable::from_instance(*raw_instance)));
            VkSetup::vk_setup(&mut instance, fn_table);
        }
        free_vk_ptr(raw_create_info);
        if vk_result == 0 { Ok(instance) } else { Err((RawVkResult::vk_to_wrapped(&vk_result), instance)) }
    }
}

/// Wrapper for [vkEnumerateInstanceExtensionProperties](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateInstanceExtensionProperties.html).
pub fn vk_enumerate_instance_extension_properties(layer_name: Option<&str>) -> LavaResult<Vec<VkExtensionProperties>> {
    unsafe {
        let raw_layer_name = new_ptr_string_checked(&layer_name);
        let mut vk_result = 0;
        let mut raw_properties : *mut RawVkExtensionProperties = ptr::null_mut();
        let raw_property_count = &mut mem::zeroed() as *mut u32;
        vk_result = vkEnumerateInstanceExtensionProperties(raw_layer_name, raw_property_count, raw_properties);
        raw_properties = calloc(*raw_property_count as usize, mem::size_of::<RawVkExtensionProperties>()) as *mut RawVkExtensionProperties;
        
        vk_result = vkEnumerateInstanceExtensionProperties(raw_layer_name, raw_property_count, raw_properties);
        
        let properties = new_vk_array(*raw_property_count, raw_properties);
        free_ptr(raw_layer_name);
        free(raw_properties as *mut u8);
        if vk_result == 0 { Ok(properties) } else { Err((RawVkResult::vk_to_wrapped(&vk_result), properties)) }
    }
}

/// Wrapper for [vkEnumerateInstanceLayerProperties](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateInstanceLayerProperties.html).
pub fn vk_enumerate_instance_layer_properties() -> LavaResult<Vec<VkLayerProperties>> {
    unsafe {
        let mut vk_result = 0;
        let mut raw_properties : *mut RawVkLayerProperties = ptr::null_mut();
        let raw_property_count = &mut mem::zeroed() as *mut u32;
        vk_result = vkEnumerateInstanceLayerProperties(raw_property_count, raw_properties);
        raw_properties = calloc(*raw_property_count as usize, mem::size_of::<RawVkLayerProperties>()) as *mut RawVkLayerProperties;
        
        vk_result = vkEnumerateInstanceLayerProperties(raw_property_count, raw_properties);
        
        let properties = new_vk_array(*raw_property_count, raw_properties);
        free(raw_properties as *mut u8);
        if vk_result == 0 { Ok(properties) } else { Err((RawVkResult::vk_to_wrapped(&vk_result), properties)) }
    }
}

/// Wrapper for [vkEnumerateInstanceVersion](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateInstanceVersion.html).
pub fn vk_enumerate_instance_version() -> LavaResult<VkVersion> {
    unsafe {
        let mut vk_result = 0;
        let raw_api_version = &mut mem::zeroed() as *mut u32;
        
        vk_result = vkEnumerateInstanceVersion(raw_api_version);
        
        let api_version = new_vk_value(raw_api_version);
        if vk_result == 0 { Ok(api_version) } else { Err((RawVkResult::vk_to_wrapped(&vk_result), api_version)) }
    }
}

extern {
    fn vkCreateInstance(create_info: *mut RawVkInstanceCreateInfo, allocator: *const c_void, instance: *mut RawVkInstance) -> RawVkResult;
    fn vkEnumerateInstanceExtensionProperties(layer_name: *mut c_char, property_count: *mut u32, properties: *mut RawVkExtensionProperties) -> RawVkResult;
    fn vkEnumerateInstanceLayerProperties(property_count: *mut u32, properties: *mut RawVkLayerProperties) -> RawVkResult;
    fn vkEnumerateInstanceVersion(api_version: *mut u32) -> RawVkResult;
}