vulkan-rust 0.10.0

Ergonomic Vulkan bindings for Rust, generated from vk.xml
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

mod common;

use vk::Handle;
use vulkan_rust::vk;

#[test]
#[ignore] // requires Vulkan runtime
fn enumerate_physical_devices_returns_at_least_one() {
    let (_entry, instance) = common::create_instance();

    let devices = unsafe { instance.enumerate_physical_devices() }
        .expect("enumerate_physical_devices failed");
    assert!(!devices.is_empty(), "expected at least one physical device");

    unsafe { instance.destroy_instance(None) };
}

#[test]
#[ignore] // requires Vulkan runtime
fn get_physical_device_properties_reports_device_name() {
    let (_entry, instance) = common::create_instance();

    let devices = unsafe { instance.enumerate_physical_devices() }
        .expect("enumerate_physical_devices failed");
    let props = unsafe { instance.get_physical_device_properties(devices[0]) };

    let name_bytes: Vec<u8> = props
        .device_name
        .iter()
        .take_while(|&&c| c != 0)
        .map(|&c| c as u8)
        .collect();
    let name = String::from_utf8_lossy(&name_bytes);
    println!("GPU: {name}");
    assert!(!name.is_empty());

    unsafe { instance.destroy_instance(None) };
}

#[test]
#[ignore] // requires Vulkan runtime
fn get_physical_device_queue_family_properties_returns_at_least_one() {
    let (_entry, instance) = common::create_instance();

    let devices = unsafe { instance.enumerate_physical_devices() }
        .expect("enumerate_physical_devices failed");
    let families = unsafe { instance.get_physical_device_queue_family_properties(devices[0]) };
    assert!(!families.is_empty(), "expected at least one queue family");

    unsafe { instance.destroy_instance(None) };
}

#[test]
#[ignore] // requires Vulkan runtime
fn full_lifecycle() {
    let (_entry, instance) = common::create_instance();

    let physical_devices = unsafe { instance.enumerate_physical_devices() }
        .expect("enumerate_physical_devices failed");
    assert!(!physical_devices.is_empty());
    let physical_device = physical_devices[0];

    let props = unsafe { instance.get_physical_device_properties(physical_device) };
    let name_bytes: Vec<u8> = props
        .device_name
        .iter()
        .take_while(|&&c| c != 0)
        .map(|&c| c as u8)
        .collect();
    println!("GPU: {}", String::from_utf8_lossy(&name_bytes));

    let families = unsafe { instance.get_physical_device_queue_family_properties(physical_device) };
    let graphics_family = families
        .iter()
        .position(|f| f.queue_flags.contains(vk::QueueFlagBits::GRAPHICS))
        .expect("no graphics queue family") as u32;

    let queue_priority = 1.0f32;
    let queue_create_info = vk::DeviceQueueCreateInfo {
        s_type: vk::StructureType::DEVICE_QUEUE_CREATE_INFO,
        p_next: std::ptr::null(),
        flags: vk::DeviceQueueCreateFlagBits::empty(),
        queue_family_index: graphics_family,
        queue_count: 1,
        p_queue_priorities: &queue_priority,
    };
    let device_create_info = vk::DeviceCreateInfo {
        s_type: vk::StructureType::DEVICE_CREATE_INFO,
        p_next: std::ptr::null(),
        flags: 0,
        queue_create_info_count: 1,
        p_queue_create_infos: &queue_create_info,
        enabled_layer_count: 0,
        pp_enabled_layer_names: std::ptr::null(),
        enabled_extension_count: 0,
        pp_enabled_extension_names: std::ptr::null(),
        p_enabled_features: std::ptr::null(),
    };
    let device = unsafe { instance.create_device(physical_device, &device_create_info, None) }
        .expect("failed to create device");

    let queue = unsafe { device.get_device_queue(graphics_family, 0) };
    assert!(!queue.is_null(), "expected non-null queue handle");

    unsafe { device.device_wait_idle() }.expect("device_wait_idle failed");

    unsafe { device.destroy_device(None) };
    unsafe { instance.destroy_instance(None) };
}