kazan 0.3.9+1.4.359

Vulkan bindings for Rust
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190

//! <https://registry.khronos.org/vulkan/specs/latest/man/html/VK_KHR_synchronization2.html>
#![allow(unused_imports)]
use crate::{vk::Result as VkResult, vk::*, *};
use core::ffi::{CStr, c_char, c_int, c_void};
use core::mem::transmute;
use core::ptr;

pub const EXTENSION_NAME: &CStr = c"VK_KHR_synchronization2";

pub(super) mod defs {
    #![allow(non_camel_case_types, unused_imports)]
    use crate::{vk::*, *};
    use core::ffi::{CStr, c_char, c_int, c_void};
    use core::fmt;
    use core::marker::PhantomData;
    use core::ptr;

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryBarrier2KHR.html>
    pub type MemoryBarrier2KHR<'a> = MemoryBarrier2<'a>;
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageMemoryBarrier2KHR.html>
    pub type ImageMemoryBarrier2KHR<'a> = ImageMemoryBarrier2<'a>;
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferMemoryBarrier2KHR.html>
    pub type BufferMemoryBarrier2KHR<'a> = BufferMemoryBarrier2<'a>;
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkDependencyInfoKHR.html>
    pub type DependencyInfoKHR<'a> = DependencyInfo<'a>;
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreSubmitInfoKHR.html>
    pub type SemaphoreSubmitInfoKHR<'a> = SemaphoreSubmitInfo<'a>;
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferSubmitInfoKHR.html>
    pub type CommandBufferSubmitInfoKHR<'a> = CommandBufferSubmitInfo<'a>;
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubmitInfo2KHR.html>
    pub type SubmitInfo2KHR<'a> = SubmitInfo2<'a>;
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSynchronization2FeaturesKHR.html>
    pub type PhysicalDeviceSynchronization2FeaturesKHR<'a> =
        PhysicalDeviceSynchronization2Features<'a>;
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccessFlags2KHR.html>
    pub type AccessFlags2KHR = AccessFlags2;
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineStageFlags2KHR.html>
    pub type PipelineStageFlags2KHR = PipelineStageFlags2;
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubmitFlagsKHR.html>
    pub type SubmitFlagsKHR = SubmitFlags;
    pub type PFN_vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2;
    pub type PFN_vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2;
    pub type PFN_vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2;
    pub type PFN_vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2;
    pub type PFN_vkQueueSubmit2KHR = PFN_vkQueueSubmit2;
    pub type PFN_vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2;
}

#[cfg(feature = "ffi")]
pub(super) mod ffi {
    #![allow(non_camel_case_types)]
    use super::defs::*;

    pub type VkMemoryBarrier2KHR = MemoryBarrier2KHR<'static>;
    pub type VkImageMemoryBarrier2KHR = ImageMemoryBarrier2KHR<'static>;
    pub type VkBufferMemoryBarrier2KHR = BufferMemoryBarrier2KHR<'static>;
    pub type VkDependencyInfoKHR = DependencyInfoKHR<'static>;
    pub type VkSemaphoreSubmitInfoKHR = SemaphoreSubmitInfoKHR<'static>;
    pub type VkCommandBufferSubmitInfoKHR = CommandBufferSubmitInfoKHR<'static>;
    pub type VkSubmitInfo2KHR = SubmitInfo2KHR<'static>;
    pub type VkPhysicalDeviceSynchronization2FeaturesKHR =
        PhysicalDeviceSynchronization2FeaturesKHR<'static>;
    pub type VkAccessFlags2KHR = AccessFlags2KHR;
    pub type VkPipelineStageFlags2KHR = PipelineStageFlags2KHR;
    pub type VkSubmitFlagsKHR = SubmitFlagsKHR;
}

pub struct DeviceFn {
    cmd_set_event2: PFN_vkCmdSetEvent2,
    cmd_reset_event2: PFN_vkCmdResetEvent2,
    cmd_wait_events2: PFN_vkCmdWaitEvents2,
    cmd_pipeline_barrier2: PFN_vkCmdPipelineBarrier2,
    cmd_write_timestamp2: PFN_vkCmdWriteTimestamp2,
    queue_submit2: PFN_vkQueueSubmit2,
}

impl LoadDeviceFn for DeviceFn {
    unsafe fn load_with(
        load: impl Fn(&CStr) -> Option<PFN_vkVoidFunction>,
    ) -> core::result::Result<Self, MissingEntryPointError> {
        unsafe {
            Ok(Self {
                cmd_set_event2: transmute(
                    load(c"vkCmdSetEvent2KHR").ok_or(MissingEntryPointError)?,
                ),
                cmd_reset_event2: transmute(
                    load(c"vkCmdResetEvent2KHR").ok_or(MissingEntryPointError)?,
                ),
                cmd_wait_events2: transmute(
                    load(c"vkCmdWaitEvents2KHR").ok_or(MissingEntryPointError)?,
                ),
                cmd_pipeline_barrier2: transmute(
                    load(c"vkCmdPipelineBarrier2KHR").ok_or(MissingEntryPointError)?,
                ),
                cmd_write_timestamp2: transmute(
                    load(c"vkCmdWriteTimestamp2KHR").ok_or(MissingEntryPointError)?,
                ),
                queue_submit2: transmute(load(c"vkQueueSubmit2KHR").ok_or(MissingEntryPointError)?),
            })
        }
    }
}

impl DeviceFn {
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html>
    #[inline]
    pub unsafe fn cmd_set_event2(
        &self,
        command_buffer: CommandBuffer,
        event: Event,
        dependency_info: &DependencyInfo<'_>,
    ) {
        unsafe { (self.cmd_set_event2)(command_buffer, event, dependency_info) }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2KHR.html>
    #[inline]
    pub unsafe fn cmd_reset_event2(
        &self,
        command_buffer: CommandBuffer,
        event: Event,
        stage_mask: PipelineStageFlags2,
    ) {
        unsafe { (self.cmd_reset_event2)(command_buffer, event, stage_mask) }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2KHR.html>
    #[inline]
    pub unsafe fn cmd_wait_events2(
        &self,
        command_buffer: CommandBuffer,
        events: &[Event],
        dependency_infos: &[DependencyInfo<'_>],
    ) {
        unsafe {
            assert_eq!(dependency_infos.len(), events.len());
            (self.cmd_wait_events2)(
                command_buffer,
                events.len().try_into().unwrap(),
                events.as_ptr() as _,
                dependency_infos.as_ptr() as _,
            )
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2KHR.html>
    #[inline]
    pub unsafe fn cmd_pipeline_barrier2(
        &self,
        command_buffer: CommandBuffer,
        dependency_info: &DependencyInfo<'_>,
    ) {
        unsafe { (self.cmd_pipeline_barrier2)(command_buffer, dependency_info) }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2KHR.html>
    #[inline]
    pub unsafe fn cmd_write_timestamp2(
        &self,
        command_buffer: CommandBuffer,
        stage: PipelineStageFlags2,
        query_pool: QueryPool,
        query: u32,
    ) {
        unsafe { (self.cmd_write_timestamp2)(command_buffer, stage, query_pool, query) }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2KHR.html>
    #[inline]
    pub unsafe fn queue_submit2(
        &self,
        queue: Queue,
        submits: &[SubmitInfo2<'_>],
        fence: Fence,
    ) -> crate::Result<()> {
        unsafe {
            let result = (self.queue_submit2)(
                queue,
                submits.len().try_into().unwrap(),
                submits.as_ptr() as _,
                fence,
            );

            match result {
                VkResult::SUCCESS => Ok(()),
                err => Err(err),
            }
        }
    }
}