bedrock_vk/
fns.rs

1use crate::*;
2use core::ffi::*;
3
4#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
5/// # Safety
6///
7/// direct calling ffi functions.
8pub unsafe fn create_instance(create_info: *const VkInstanceCreateInfo, allocator: *const VkAllocationCallbacks, instance_out: *mut VkInstance) -> VkResult {
9    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_instance.0)(create_info, allocator, instance_out) }
10    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateInstance(create_info, allocator, instance_out) }
11}
12#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
13/// # Safety
14///
15/// direct calling ffi functions.
16pub unsafe fn destroy_instance(instance: VkInstance, allocator: *const VkAllocationCallbacks) {
17    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.destroy_instance.0)(instance, allocator) }
18    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDestroyInstance(instance, allocator) }
19}
20#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
21/// # Safety
22///
23/// direct calling ffi functions.
24pub unsafe fn enumerate_physical_devices(instance: VkInstance, physical_devices_count_out: *mut u32, physical_devices_out: *mut VkPhysicalDevice) -> VkResult {
25    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.enumerate_physical_devices.0)(instance, physical_devices_count_out, physical_devices_out) }
26    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkEnumeratePhysicalDevices(instance, physical_devices_count_out, physical_devices_out) }
27}
28#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
29/// # Safety
30///
31/// direct calling ffi functions.
32pub unsafe fn get_physical_device_features(physical_device: VkPhysicalDevice, features_out: *mut VkPhysicalDeviceFeatures) {
33    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_features.0)(physical_device, features_out) }
34    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceFeatures(physical_device, features_out) }
35}
36#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
37/// # Safety
38///
39/// direct calling ffi functions.
40pub unsafe fn get_physical_device_format_properties(physical_device: VkPhysicalDevice, format: VkFormat, format_properties_out: *mut VkFormatProperties) {
41    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_format_properties.0)(physical_device, format, format_properties_out) }
42    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceFormatProperties(physical_device, format, format_properties_out) }
43}
44#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
45/// # Safety
46///
47/// direct calling ffi functions.
48pub unsafe fn get_physical_device_image_format_properties(physical_device: VkPhysicalDevice, format: VkFormat, image_type: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, image_format_properties_out: *mut VkImageFormatProperties) -> VkResult {
49    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_image_format_properties.0)(physical_device, format, image_type, tiling, usage, flags, image_format_properties_out) }
50    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceImageFormatProperties(physical_device, format, image_type, tiling, usage, flags, image_format_properties_out) }
51}
52#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
53/// # Safety
54///
55/// direct calling ffi functions.
56pub unsafe fn get_physical_device_properties(physical_device: VkPhysicalDevice, properties_out: *mut VkPhysicalDeviceProperties) {
57    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_properties.0)(physical_device, properties_out) }
58    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceProperties(physical_device, properties_out) }
59}
60#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
61/// # Safety
62///
63/// direct calling ffi functions.
64pub unsafe fn get_physical_device_queue_family_properties(physical_device: VkPhysicalDevice, queue_family_properties_count_out: *mut u32, queue_family_properties_out: *mut VkQueueFamilyProperties) {
65    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_queue_family_properties.0)(physical_device, queue_family_properties_count_out, queue_family_properties_out) }
66    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceQueueFamilyProperties(physical_device, queue_family_properties_count_out, queue_family_properties_out) }
67}
68#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
69/// # Safety
70///
71/// direct calling ffi functions.
72pub unsafe fn get_physical_device_memory_properties(physical_device: VkPhysicalDevice, memory_properties_out: *mut VkPhysicalDeviceMemoryProperties) {
73    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_memory_properties.0)(physical_device, memory_properties_out) }
74    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceMemoryProperties(physical_device, memory_properties_out) }
75}
76#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
77/// # Safety
78///
79/// direct calling ffi functions.
80pub unsafe fn get_instance_proc_addr(instance: VkInstance, name: *const c_char) -> Option<PFN_vkVoidFunction> {
81    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_instance_proc_addr.0)(instance, name) }
82    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetInstanceProcAddr(instance, name) }
83}
84#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
85/// # Safety
86///
87/// direct calling ffi functions.
88pub unsafe fn get_device_proc_addr(device: VkDevice, name: *const c_char) -> Option<PFN_vkVoidFunction> {
89    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_device_proc_addr.0)(device, name) }
90    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetDeviceProcAddr(device, name) }
91}
92#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
93/// # Safety
94///
95/// direct calling ffi functions.
96pub unsafe fn create_device(physical_device: VkPhysicalDevice, create_info: *const VkDeviceCreateInfo, allocator: *const VkAllocationCallbacks, device_out: *mut VkDevice) -> VkResult {
97    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_device.0)(physical_device, create_info, allocator, device_out) }
98    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateDevice(physical_device, create_info, allocator, device_out) }
99}
100#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
101/// # Safety
102///
103/// direct calling ffi functions.
104pub unsafe fn destroy_device(device: VkDevice, allocator: *const VkAllocationCallbacks) {
105    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.destroy_device.0)(device, allocator) }
106    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDestroyDevice(device, allocator) }
107}
108#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
109/// # Safety
110///
111/// direct calling ffi functions.
112pub unsafe fn enumerate_instance_extension_properties(layer_name: *const c_char, property_count_out: *mut u32, properties_out: *mut VkExtensionProperties) -> VkResult {
113    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.enumerate_instance_extension_properties.0)(layer_name, property_count_out, properties_out) }
114    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkEnumerateInstanceExtensionProperties(layer_name, property_count_out, properties_out) }
115}
116#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
117/// # Safety
118///
119/// direct calling ffi functions.
120pub unsafe fn enumerate_device_extension_properties(physical_device: VkPhysicalDevice, layer_name: *const c_char, property_count_out: *mut u32, properties_out: *mut VkExtensionProperties) -> VkResult {
121    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.enumerate_device_extension_properties.0)(physical_device, layer_name, property_count_out, properties_out) }
122    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkEnumerateDeviceExtensionProperties(physical_device, layer_name, property_count_out, properties_out) }
123}
124#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
125/// # Safety
126///
127/// direct calling ffi functions.
128pub unsafe fn enumerate_instance_layer_properties(property_count_out: *mut u32, properties_out: *mut VkLayerProperties) -> VkResult {
129    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.enumerate_instance_layer_properties.0)(property_count_out, properties_out) }
130    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkEnumerateInstanceLayerProperties(property_count_out, properties_out) }
131}
132#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
133/// # Safety
134///
135/// direct calling ffi functions.
136pub unsafe fn enumerate_device_layer_properties(physical_device: VkPhysicalDevice, property_count_out: *mut u32, properties_out: *mut VkLayerProperties) -> VkResult {
137    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.enumerate_device_layer_properties.0)(physical_device, property_count_out, properties_out) }
138    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkEnumerateDeviceLayerProperties(physical_device, property_count_out, properties_out) }
139}
140#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
141/// # Safety
142///
143/// direct calling ffi functions.
144pub unsafe fn get_device_queue(device: VkDevice, queue_family_index: u32, queue_index: u32, queue_out: *mut VkQueue) {
145    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_device_queue.0)(device, queue_family_index, queue_index, queue_out) }
146    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetDeviceQueue(device, queue_family_index, queue_index, queue_out) }
147}
148#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
149/// # Safety
150///
151/// direct calling ffi functions.
152pub unsafe fn queue_submit(queue: VkQueue, submit_count: u32, submits: *const VkSubmitInfo, fence: Option<VkFence>) -> VkResult {
153    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.queue_submit.0)(queue, submit_count, submits, fence) }
154    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkQueueSubmit(queue, submit_count, submits, fence) }
155}
156#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
157/// # Safety
158///
159/// direct calling ffi functions.
160pub unsafe fn queue_wait_idle(queue: VkQueue) -> VkResult {
161    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.queue_wait_idle.0)(queue) }
162    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkQueueWaitIdle(queue) }
163}
164#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
165/// # Safety
166///
167/// direct calling ffi functions.
168pub unsafe fn device_wait_idle(device: VkDevice) -> VkResult {
169    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.device_wait_idle.0)(device) }
170    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDeviceWaitIdle(device) }
171}
172#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
173/// # Safety
174///
175/// direct calling ffi functions.
176pub unsafe fn allocate_memory(device: VkDevice, allocate_info: *const VkMemoryAllocateInfo, allocator: *const VkAllocationCallbacks, memory_out: *mut VkDeviceMemory) -> VkResult {
177    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.allocate_memory.0)(device, allocate_info, allocator, memory_out) }
178    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkAllocateMemory(device, allocate_info, allocator, memory_out) }
179}
180#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
181/// # Safety
182///
183/// direct calling ffi functions.
184pub unsafe fn free_memory(device: VkDevice, memory: VkDeviceMemory, allocator: *const VkAllocationCallbacks) {
185    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.free_memory.0)(device, memory, allocator) }
186    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkFreeMemory(device, memory, allocator) }
187}
188#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
189/// # Safety
190///
191/// direct calling ffi functions.
192pub unsafe fn map_memory(device: VkDevice, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize, flags: VkMemoryMapFlags, data_ptr_out: *mut *mut c_void) -> VkResult {
193    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.map_memory.0)(device, memory, offset, size, flags, data_ptr_out) }
194    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkMapMemory(device, memory, offset, size, flags, data_ptr_out) }
195}
196#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
197/// # Safety
198///
199/// direct calling ffi functions.
200pub unsafe fn unmap_memory(device: VkDevice, memory: VkDeviceMemory) {
201    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.unmap_memory.0)(device, memory) }
202    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkUnmapMemory(device, memory) }
203}
204#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
205/// # Safety
206///
207/// direct calling ffi functions.
208pub unsafe fn flush_mapped_memory_ranges(device: VkDevice, memory_range_count: u32, memory_ranges: *const VkMappedMemoryRange) -> VkResult {
209    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.flush_mapped_memory_ranges.0)(device, memory_range_count, memory_ranges) }
210    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkFlushMappedMemoryRanges(device, memory_range_count, memory_ranges) }
211}
212#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
213/// # Safety
214///
215/// direct calling ffi functions.
216pub unsafe fn invalidate_mapped_memory_ranges(device: VkDevice, memory_range_count: u32, memory_ranges: *const VkMappedMemoryRange) -> VkResult {
217    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.invalidate_mapped_memory_ranges.0)(device, memory_range_count, memory_ranges) }
218    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkInvalidateMappedMemoryRanges(device, memory_range_count, memory_ranges) }
219}
220#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
221/// # Safety
222///
223/// direct calling ffi functions.
224pub unsafe fn get_device_memory_commitment(device: VkDevice, memory: VkDeviceMemory, committed_memory_bytes_out: *mut VkDeviceSize) {
225    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_device_memory_commitment.0)(device, memory, committed_memory_bytes_out) }
226    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetDeviceMemoryCommitment(device, memory, committed_memory_bytes_out) }
227}
228#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
229/// # Safety
230///
231/// direct calling ffi functions.
232pub unsafe fn bind_buffer_memory(device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memory_offset: VkDeviceSize) -> VkResult {
233    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.bind_buffer_memory.0)(device, buffer, memory, memory_offset) }
234    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkBindBufferMemory(device, buffer, memory, memory_offset) }
235}
236#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
237/// # Safety
238///
239/// direct calling ffi functions.
240pub unsafe fn bind_image_memory(device: VkDevice, image: VkImage, memory: VkDeviceMemory, memory_offset: VkDeviceSize) -> VkResult {
241    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.bind_image_memory.0)(device, image, memory, memory_offset) }
242    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkBindImageMemory(device, image, memory, memory_offset) }
243}
244#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
245/// # Safety
246///
247/// direct calling ffi functions.
248pub unsafe fn get_buffer_memory_requirements(device: VkDevice, buffer: VkBuffer, memory_requirements_out: *mut VkMemoryRequirements) {
249    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_buffer_memory_requirements.0)(device, buffer, memory_requirements_out) }
250    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetBufferMemoryRequirements(device, buffer, memory_requirements_out) }
251}
252#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
253/// # Safety
254///
255/// direct calling ffi functions.
256pub unsafe fn get_image_memory_requirements(device: VkDevice, image: VkImage, memory_requirements_out: *mut VkMemoryRequirements) {
257    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_image_memory_requirements.0)(device, image, memory_requirements_out) }
258    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetImageMemoryRequirements(device, image, memory_requirements_out) }
259}
260#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
261/// # Safety
262///
263/// direct calling ffi functions.
264pub unsafe fn get_image_sparse_memory_requirements(device: VkDevice, image: VkImage, sparse_memory_requirement_count_out: *mut u32, sparse_memory_requirements_out: *mut VkSparseImageMemoryRequirements) {
265    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_image_sparse_memory_requirements.0)(device, image, sparse_memory_requirement_count_out, sparse_memory_requirements_out) }
266    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetImageSparseMemoryRequirements(device, image, sparse_memory_requirement_count_out, sparse_memory_requirements_out) }
267}
268#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
269/// # Safety
270///
271/// direct calling ffi functions.
272pub unsafe fn get_physical_device_sparse_image_format_properties(physical_device: VkPhysicalDevice, format: VkFormat, r#type: VkImageType, samples: VkSampleCountFlags, usage: VkImageUsageFlags, tiling: VkImageTiling, property_count_out: *mut u32, properties_out: *mut VkSparseImageFormatProperties) {
273    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_sparse_image_format_properties.0)(physical_device, format, r#type, samples, usage, tiling, property_count_out, properties_out) }
274    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceSparseImageFormatProperties(physical_device, format, r#type, samples, usage, tiling, property_count_out, properties_out) }
275}
276#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
277/// # Safety
278///
279/// direct calling ffi functions.
280pub unsafe fn queue_bind_sparse(queue: VkQueue, bind_info_count: u32, bind_info: *const VkBindSparseInfo, fence: Option<VkFence>) -> VkResult {
281    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.queue_bind_sparse.0)(queue, bind_info_count, bind_info, fence) }
282    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkQueueBindSparse(queue, bind_info_count, bind_info, fence) }
283}
284#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
285/// # Safety
286///
287/// direct calling ffi functions.
288pub unsafe fn create_fence(device: VkDevice, create_info: *const VkFenceCreateInfo, allocator: *const VkAllocationCallbacks, fence_out: *mut VkFence) -> VkResult {
289    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_fence.0)(device, create_info, allocator, fence_out) }
290    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateFence(device, create_info, allocator, fence_out) }
291}
292#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
293/// # Safety
294///
295/// direct calling ffi functions.
296pub unsafe fn destroy_fence(device: VkDevice, fence: VkFence, allocator: *const VkAllocationCallbacks) {
297    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.destroy_fence.0)(device, fence, allocator) }
298    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDestroyFence(device, fence, allocator) }
299}
300#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
301/// # Safety
302///
303/// direct calling ffi functions.
304pub unsafe fn reset_fences(device: VkDevice, fence_count: u32, fences: *const VkFence) -> VkResult {
305    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.reset_fences.0)(device, fence_count, fences) }
306    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkResetFences(device, fence_count, fences) }
307}
308#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
309/// # Safety
310///
311/// direct calling ffi functions.
312pub unsafe fn get_fence_status(device: VkDevice, fence: VkFence) -> VkResult {
313    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_fence_status.0)(device, fence) }
314    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetFenceStatus(device, fence) }
315}
316#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
317/// # Safety
318///
319/// direct calling ffi functions.
320pub unsafe fn wait_for_fences(device: VkDevice, fence_count: u32, fences: *const VkFence, wait_all: VkBool32, timeout: u64) -> VkResult {
321    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.wait_for_fences.0)(device, fence_count, fences, wait_all, timeout) }
322    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkWaitForFences(device, fence_count, fences, wait_all, timeout) }
323}
324#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
325/// # Safety
326///
327/// direct calling ffi functions.
328pub unsafe fn create_semaphore(device: VkDevice, create_info: *const VkSemaphoreCreateInfo, allocator: *const VkAllocationCallbacks, semaphore_out: *mut VkSemaphore) -> VkResult {
329    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_semaphore.0)(device, create_info, allocator, semaphore_out) }
330    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateSemaphore(device, create_info, allocator, semaphore_out) }
331}
332#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
333/// # Safety
334///
335/// direct calling ffi functions.
336pub unsafe fn destroy_semaphore(device: VkDevice, semaphore: VkSemaphore, allocator: *const VkAllocationCallbacks) {
337    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.destroy_semaphore.0)(device, semaphore, allocator) }
338    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDestroySemaphore(device, semaphore, allocator) }
339}
340#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
341/// # Safety
342///
343/// direct calling ffi functions.
344pub unsafe fn create_event(device: VkDevice, create_info: *const VkEventCreateInfo, allocator: *const VkAllocationCallbacks, event_out: *mut VkEvent) -> VkResult {
345    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_event.0)(device, create_info, allocator, event_out) }
346    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateEvent(device, create_info, allocator, event_out) }
347}
348#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
349/// # Safety
350///
351/// direct calling ffi functions.
352pub unsafe fn destroy_event(device: VkDevice, event: VkEvent, allocator: *const VkAllocationCallbacks) {
353    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.destroy_event.0)(device, event, allocator) }
354    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDestroyEvent(device, event, allocator) }
355}
356#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
357/// # Safety
358///
359/// direct calling ffi functions.
360pub unsafe fn get_event_status(device: VkDevice, event: VkEvent) -> VkResult {
361    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_event_status.0)(device, event) }
362    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetEventStatus(device, event) }
363}
364#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
365/// # Safety
366///
367/// direct calling ffi functions.
368pub unsafe fn set_event(device: VkDevice, event: VkEvent) -> VkResult {
369    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.set_event.0)(device, event) }
370    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkSetEvent(device, event) }
371}
372#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
373/// # Safety
374///
375/// direct calling ffi functions.
376pub unsafe fn reset_event(device: VkDevice, event: VkEvent) -> VkResult {
377    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.reset_event.0)(device, event) }
378    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkResetEvent(device, event) }
379}
380#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
381/// # Safety
382///
383/// direct calling ffi functions.
384pub unsafe fn create_query_pool(device: VkDevice, create_info: *const VkQueryPoolCreateInfo, allocator: *const VkAllocationCallbacks, query_pool_out: *mut VkQueryPool) -> VkResult {
385    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_query_pool.0)(device, create_info, allocator, query_pool_out) }
386    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateQueryPool(device, create_info, allocator, query_pool_out) }
387}
388#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
389/// # Safety
390///
391/// direct calling ffi functions.
392pub unsafe fn destroy_query_pool(device: VkDevice, query_pool: VkQueryPool, allocator: *const VkAllocationCallbacks) {
393    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.destroy_query_pool.0)(device, query_pool, allocator) }
394    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDestroyQueryPool(device, query_pool, allocator) }
395}
396#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
397/// # Safety
398///
399/// direct calling ffi functions.
400pub unsafe fn get_query_pool_results(device: VkDevice, query_pool: VkQueryPool, first_query: u32, query_count: u32, data_size: usize, data_out: *mut c_void, stride: VkDeviceSize, flags: VkQueryResultFlags) -> VkResult {
401    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_query_pool_results.0)(device, query_pool, first_query, query_count, data_size, data_out, stride, flags) }
402    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetQueryPoolResults(device, query_pool, first_query, query_count, data_size, data_out, stride, flags) }
403}
404#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
405/// # Safety
406///
407/// direct calling ffi functions.
408pub unsafe fn create_buffer(device: VkDevice, create_info: *const VkBufferCreateInfo, allocator: *const VkAllocationCallbacks, buffer_out: *mut VkBuffer) -> VkResult {
409    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_buffer.0)(device, create_info, allocator, buffer_out) }
410    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateBuffer(device, create_info, allocator, buffer_out) }
411}
412#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
413/// # Safety
414///
415/// direct calling ffi functions.
416pub unsafe fn destroy_buffer(device: VkDevice, buffer: VkBuffer, allocator: *const VkAllocationCallbacks) {
417    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.destroy_buffer.0)(device, buffer, allocator) }
418    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDestroyBuffer(device, buffer, allocator) }
419}
420#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
421/// # Safety
422///
423/// direct calling ffi functions.
424pub unsafe fn create_buffer_view(device: VkDevice, create_info: *const VkBufferViewCreateInfo, allocator: *const VkAllocationCallbacks, view_out: *mut VkBufferView) -> VkResult {
425    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_buffer_view.0)(device, create_info, allocator, view_out) }
426    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateBufferView(device, create_info, allocator, view_out) }
427}
428#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
429/// # Safety
430///
431/// direct calling ffi functions.
432pub unsafe fn destroy_buffer_view(device: VkDevice, buffer_view: VkBufferView, allocator: *const VkAllocationCallbacks) {
433    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.destroy_buffer_view.0)(device, buffer_view, allocator) }
434    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDestroyBufferView(device, buffer_view, allocator) }
435}
436#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
437/// # Safety
438///
439/// direct calling ffi functions.
440pub unsafe fn create_image(device: VkDevice, create_info: *const VkImageCreateInfo, allocator: *const VkAllocationCallbacks, image_out: *mut VkImage) -> VkResult {
441    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_image.0)(device, create_info, allocator, image_out) }
442    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateImage(device, create_info, allocator, image_out) }
443}
444#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
445/// # Safety
446///
447/// direct calling ffi functions.
448pub unsafe fn destroy_image(device: VkDevice, image: VkImage, allocator: *const VkAllocationCallbacks) {
449    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.destroy_image.0)(device, image, allocator) }
450    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDestroyImage(device, image, allocator) }
451}
452#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
453/// # Safety
454///
455/// direct calling ffi functions.
456pub unsafe fn get_image_subresource_layout(device: VkDevice, image: VkImage, subresource: *const VkImageSubresource, layout_out: *mut VkSubresourceLayout) {
457    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_image_subresource_layout.0)(device, image, subresource, layout_out) }
458    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetImageSubresourceLayout(device, image, subresource, layout_out) }
459}
460#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
461/// # Safety
462///
463/// direct calling ffi functions.
464pub unsafe fn create_image_view(device: VkDevice, create_info: *const VkImageViewCreateInfo, allocator: *const VkAllocationCallbacks, view_out: *mut VkImageView) -> VkResult {
465    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_image_view.0)(device, create_info, allocator, view_out) }
466    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateImageView(device, create_info, allocator, view_out) }
467}
468#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
469/// # Safety
470///
471/// direct calling ffi functions.
472pub unsafe fn destroy_image_view(device: VkDevice, image_view: VkImageView, allocator: *const VkAllocationCallbacks) {
473    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.destroy_image_view.0)(device, image_view, allocator) }
474    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDestroyImageView(device, image_view, allocator) }
475}
476#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
477/// # Safety
478///
479/// direct calling ffi functions.
480pub unsafe fn create_shader_module(device: VkDevice, create_info: *const VkShaderModuleCreateInfo, allocator: *const VkAllocationCallbacks, shader_module_out: *mut VkShaderModule) -> VkResult {
481    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_shader_module.0)(device, create_info, allocator, shader_module_out) }
482    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateShaderModule(device, create_info, allocator, shader_module_out) }
483}
484#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
485/// # Safety
486///
487/// direct calling ffi functions.
488pub unsafe fn destroy_shader_module(device: VkDevice, shader_module: VkShaderModule, allocator: *const VkAllocationCallbacks) {
489    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.destroy_shader_module.0)(device, shader_module, allocator) }
490    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDestroyShaderModule(device, shader_module, allocator) }
491}
492#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
493/// # Safety
494///
495/// direct calling ffi functions.
496pub unsafe fn create_pipeline_cache(device: VkDevice, create_info: *const VkPipelineCacheCreateInfo, allocator: *const VkAllocationCallbacks, pipeline_cache_out: *mut VkPipelineCache) -> VkResult {
497    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_pipeline_cache.0)(device, create_info, allocator, pipeline_cache_out) }
498    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreatePipelineCache(device, create_info, allocator, pipeline_cache_out) }
499}
500#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
501/// # Safety
502///
503/// direct calling ffi functions.
504pub unsafe fn destroy_pipeline_cache(device: VkDevice, pipeline_cache: VkPipelineCache, allocator: *const VkAllocationCallbacks) {
505    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.destroy_pipeline_cache.0)(device, pipeline_cache, allocator) }
506    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDestroyPipelineCache(device, pipeline_cache, allocator) }
507}
508#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
509/// # Safety
510///
511/// direct calling ffi functions.
512pub unsafe fn get_pipeline_cache_data(device: VkDevice, pipeline_cache: VkPipelineCache, data_size_out: *mut usize, data_out: *mut c_void) -> VkResult {
513    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_pipeline_cache_data.0)(device, pipeline_cache, data_size_out, data_out) }
514    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPipelineCacheData(device, pipeline_cache, data_size_out, data_out) }
515}
516#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
517/// # Safety
518///
519/// direct calling ffi functions.
520pub unsafe fn merge_pipeline_caches(device: VkDevice, dst_cache: VkPipelineCache, src_cache_count: u32, src_caches: *const VkPipelineCache) -> VkResult {
521    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.merge_pipeline_caches.0)(device, dst_cache, src_cache_count, src_caches) }
522    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkMergePipelineCaches(device, dst_cache, src_cache_count, src_caches) }
523}
524#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
525/// # Safety
526///
527/// direct calling ffi functions.
528pub unsafe fn create_graphics_pipelines(device: VkDevice, pipeline_cache: Option<VkPipelineCache>, create_info_count: u32, create_infos: *const VkGraphicsPipelineCreateInfo, allocator: *const VkAllocationCallbacks, pipelines_out: *mut VkPipeline) -> VkResult {
529    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_graphics_pipelines.0)(device, pipeline_cache, create_info_count, create_infos, allocator, pipelines_out) }
530    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateGraphicsPipelines(device, pipeline_cache, create_info_count, create_infos, allocator, pipelines_out) }
531}
532#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
533/// # Safety
534///
535/// direct calling ffi functions.
536pub unsafe fn create_compute_pipelines(device: VkDevice, pipeline_cache: Option<VkPipelineCache>, create_info_count: u32, create_infos: *const VkComputePipelineCreateInfo, allocator: *const VkAllocationCallbacks, pipelines_out: *mut VkPipeline) -> VkResult {
537    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_compute_pipelines.0)(device, pipeline_cache, create_info_count, create_infos, allocator, pipelines_out) }
538    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateComputePipelines(device, pipeline_cache, create_info_count, create_infos, allocator, pipelines_out) }
539}
540#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
541/// # Safety
542///
543/// direct calling ffi functions.
544pub unsafe fn destroy_pipeline(device: VkDevice, pipeline: VkPipeline, allocator: *const VkAllocationCallbacks) {
545    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.destroy_pipeline.0)(device, pipeline, allocator) }
546    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDestroyPipeline(device, pipeline, allocator) }
547}
548#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
549/// # Safety
550///
551/// direct calling ffi functions.
552pub unsafe fn create_pipeline_layout(device: VkDevice, create_info: *const VkPipelineLayoutCreateInfo, allocator: *const VkAllocationCallbacks, pipeline_layout_out: *mut VkPipelineLayout) -> VkResult {
553    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_pipeline_layout.0)(device, create_info, allocator, pipeline_layout_out) }
554    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreatePipelineLayout(device, create_info, allocator, pipeline_layout_out) }
555}
556#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
557/// # Safety
558///
559/// direct calling ffi functions.
560pub unsafe fn destroy_pipeline_layout(device: VkDevice, pipeline_layout: VkPipelineLayout, allocator: *const VkAllocationCallbacks) {
561    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.destroy_pipeline_layout.0)(device, pipeline_layout, allocator) }
562    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDestroyPipelineLayout(device, pipeline_layout, allocator) }
563}
564#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
565/// # Safety
566///
567/// direct calling ffi functions.
568pub unsafe fn create_sampler(device: VkDevice, create_info: *const VkSamplerCreateInfo, allocator: *const VkAllocationCallbacks, sampler_out: *mut VkSampler) -> VkResult {
569    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_sampler.0)(device, create_info, allocator, sampler_out) }
570    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateSampler(device, create_info, allocator, sampler_out) }
571}
572#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
573/// # Safety
574///
575/// direct calling ffi functions.
576pub unsafe fn destroy_sampler(device: VkDevice, sampler: VkSampler, allocator: *const VkAllocationCallbacks) {
577    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.destroy_sampler.0)(device, sampler, allocator) }
578    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDestroySampler(device, sampler, allocator) }
579}
580#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
581/// # Safety
582///
583/// direct calling ffi functions.
584pub unsafe fn create_descriptor_set_layout(device: VkDevice, create_info: *const VkDescriptorSetLayoutCreateInfo, allocator: *const VkAllocationCallbacks, set_layout_out: *mut VkDescriptorSetLayout) -> VkResult {
585    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_descriptor_set_layout.0)(device, create_info, allocator, set_layout_out) }
586    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateDescriptorSetLayout(device, create_info, allocator, set_layout_out) }
587}
588#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
589/// # Safety
590///
591/// direct calling ffi functions.
592pub unsafe fn destroy_descriptor_set_layout(device: VkDevice, descriptor_set_layout: VkDescriptorSetLayout, allocator: *const VkAllocationCallbacks) {
593    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.destroy_descriptor_set_layout.0)(device, descriptor_set_layout, allocator) }
594    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDestroyDescriptorSetLayout(device, descriptor_set_layout, allocator) }
595}
596#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
597/// # Safety
598///
599/// direct calling ffi functions.
600pub unsafe fn create_descriptor_pool(device: VkDevice, create_info: *const VkDescriptorPoolCreateInfo, allocator: *const VkAllocationCallbacks, descriptor_pool_out: *mut VkDescriptorPool) -> VkResult {
601    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_descriptor_pool.0)(device, create_info, allocator, descriptor_pool_out) }
602    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateDescriptorPool(device, create_info, allocator, descriptor_pool_out) }
603}
604#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
605/// # Safety
606///
607/// direct calling ffi functions.
608pub unsafe fn destroy_descriptor_pool(device: VkDevice, descriptor_pool: VkDescriptorPool, allocator: *const VkAllocationCallbacks) {
609    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.destroy_descriptor_pool.0)(device, descriptor_pool, allocator) }
610    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDestroyDescriptorPool(device, descriptor_pool, allocator) }
611}
612#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
613/// # Safety
614///
615/// direct calling ffi functions.
616pub unsafe fn reset_descriptor_pool(device: VkDevice, descriptor_pool: VkDescriptorPool, flags: VkDescriptorPoolResetFlags) -> VkResult {
617    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.reset_descriptor_pool.0)(device, descriptor_pool, flags) }
618    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkResetDescriptorPool(device, descriptor_pool, flags) }
619}
620#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
621/// # Safety
622///
623/// direct calling ffi functions.
624pub unsafe fn allocate_descriptor_sets(device: VkDevice, allocate_info: *const VkDescriptorSetAllocateInfo, descriptor_sets_out: *mut VkDescriptorSet) -> VkResult {
625    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.allocate_descriptor_sets.0)(device, allocate_info, descriptor_sets_out) }
626    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkAllocateDescriptorSets(device, allocate_info, descriptor_sets_out) }
627}
628#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
629/// # Safety
630///
631/// direct calling ffi functions.
632pub unsafe fn free_descriptor_sets(device: VkDevice, descriptor_pool: VkDescriptorPool, descriptor_set_count: u32, descriptor_sets: *const VkDescriptorSet) -> VkResult {
633    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.free_descriptor_sets.0)(device, descriptor_pool, descriptor_set_count, descriptor_sets) }
634    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkFreeDescriptorSets(device, descriptor_pool, descriptor_set_count, descriptor_sets) }
635}
636#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
637/// # Safety
638///
639/// direct calling ffi functions.
640pub unsafe fn update_descriptor_sets(device: VkDevice, descriptor_write_count: u32, descriptor_writes: *const VkWriteDescriptorSet, descriptor_copy_count: u32, descriptor_copies: *const VkCopyDescriptorSet) {
641    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.update_descriptor_sets.0)(device, descriptor_write_count, descriptor_writes, descriptor_copy_count, descriptor_copies) }
642    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkUpdateDescriptorSets(device, descriptor_write_count, descriptor_writes, descriptor_copy_count, descriptor_copies) }
643}
644#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
645/// # Safety
646///
647/// direct calling ffi functions.
648pub unsafe fn create_framebuffer(device: VkDevice, create_info: *const VkFramebufferCreateInfo, allocator: *const VkAllocationCallbacks, framebuffer_out: *mut VkFramebuffer) -> VkResult {
649    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_framebuffer.0)(device, create_info, allocator, framebuffer_out) }
650    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateFramebuffer(device, create_info, allocator, framebuffer_out) }
651}
652#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
653/// # Safety
654///
655/// direct calling ffi functions.
656pub unsafe fn destroy_framebuffer(device: VkDevice, framebuffer: VkFramebuffer, allocator: *const VkAllocationCallbacks) {
657    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.destroy_framebuffer.0)(device, framebuffer, allocator) }
658    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDestroyFramebuffer(device, framebuffer, allocator) }
659}
660#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
661/// # Safety
662///
663/// direct calling ffi functions.
664pub unsafe fn create_render_pass(device: VkDevice, create_info: *const VkRenderPassCreateInfo, allocator: *const VkAllocationCallbacks, render_pass_out: *mut VkRenderPass) -> VkResult {
665    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_render_pass.0)(device, create_info, allocator, render_pass_out) }
666    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateRenderPass(device, create_info, allocator, render_pass_out) }
667}
668#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
669/// # Safety
670///
671/// direct calling ffi functions.
672pub unsafe fn destroy_render_pass(device: VkDevice, render_pass: VkRenderPass, allocator: *const VkAllocationCallbacks) {
673    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.destroy_render_pass.0)(device, render_pass, allocator) }
674    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDestroyRenderPass(device, render_pass, allocator) }
675}
676#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
677/// # Safety
678///
679/// direct calling ffi functions.
680pub unsafe fn get_render_area_granularity(device: VkDevice, render_pass: VkRenderPass, granularity_out: *mut VkExtent2D) {
681    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_render_area_granularity.0)(device, render_pass, granularity_out) }
682    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetRenderAreaGranularity(device, render_pass, granularity_out) }
683}
684#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
685/// # Safety
686///
687/// direct calling ffi functions.
688pub unsafe fn create_command_pool(device: VkDevice, create_info: *const VkCommandPoolCreateInfo, allocator: *const VkAllocationCallbacks, command_pool_out: *mut VkCommandPool) -> VkResult {
689    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_command_pool.0)(device, create_info, allocator, command_pool_out) }
690    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateCommandPool(device, create_info, allocator, command_pool_out) }
691}
692#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
693/// # Safety
694///
695/// direct calling ffi functions.
696pub unsafe fn destroy_command_pool(device: VkDevice, command_pool: VkCommandPool, allocator: *const VkAllocationCallbacks) {
697    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.destroy_command_pool.0)(device, command_pool, allocator) }
698    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDestroyCommandPool(device, command_pool, allocator) }
699}
700#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
701/// # Safety
702///
703/// direct calling ffi functions.
704pub unsafe fn reset_command_pool(device: VkDevice, command_pool: VkCommandPool, flags: VkCommandPoolResetFlags) -> VkResult {
705    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.reset_command_pool.0)(device, command_pool, flags) }
706    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkResetCommandPool(device, command_pool, flags) }
707}
708#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
709/// # Safety
710///
711/// direct calling ffi functions.
712pub unsafe fn allocate_command_buffers(device: VkDevice, allocate_info: *const VkCommandBufferAllocateInfo, command_buffers_out: *mut VkCommandBuffer) -> VkResult {
713    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.allocate_command_buffers.0)(device, allocate_info, command_buffers_out) }
714    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkAllocateCommandBuffers(device, allocate_info, command_buffers_out) }
715}
716#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
717/// # Safety
718///
719/// direct calling ffi functions.
720pub unsafe fn free_command_buffers(device: VkDevice, command_pool: VkCommandPool, command_buffer_count: u32, command_buffers: *const VkCommandBuffer) {
721    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.free_command_buffers.0)(device, command_pool, command_buffer_count, command_buffers) }
722    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkFreeCommandBuffers(device, command_pool, command_buffer_count, command_buffers) }
723}
724#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
725/// # Safety
726///
727/// direct calling ffi functions.
728pub unsafe fn begin_command_buffer(command_buffer: VkCommandBuffer, begin_info: *const VkCommandBufferBeginInfo) -> VkResult {
729    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.begin_command_buffer.0)(command_buffer, begin_info) }
730    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkBeginCommandBuffer(command_buffer, begin_info) }
731}
732#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
733/// # Safety
734///
735/// direct calling ffi functions.
736pub unsafe fn end_command_buffer(command_buffer: VkCommandBuffer) -> VkResult {
737    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.end_command_buffer.0)(command_buffer) }
738    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkEndCommandBuffer(command_buffer) }
739}
740#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
741/// # Safety
742///
743/// direct calling ffi functions.
744pub unsafe fn reset_command_buffer(command_buffer: VkCommandBuffer, flags: VkCommandBufferResetFlags) -> VkResult {
745    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.reset_command_buffer.0)(command_buffer, flags) }
746    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkResetCommandBuffer(command_buffer, flags) }
747}
748#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
749/// # Safety
750///
751/// direct calling ffi functions.
752pub unsafe fn cmd_bind_pipeline(command_buffer: VkCommandBuffer, pipeline_bind_point: VkPipelineBindPoint, pipeline: VkPipeline) {
753    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_bind_pipeline.0)(command_buffer, pipeline_bind_point, pipeline) }
754    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdBindPipeline(command_buffer, pipeline_bind_point, pipeline) }
755}
756#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
757/// # Safety
758///
759/// direct calling ffi functions.
760pub unsafe fn cmd_set_viewport(command_buffer: VkCommandBuffer, first_viewport: u32, viewport_count: u32, viewports: *const VkViewport) {
761    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_set_viewport.0)(command_buffer, first_viewport, viewport_count, viewports) }
762    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdSetViewport(command_buffer, first_viewport, viewport_count, viewports) }
763}
764#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
765/// # Safety
766///
767/// direct calling ffi functions.
768pub unsafe fn cmd_set_scissor(command_buffer: VkCommandBuffer, first_scissor: u32, scissor_count: u32, scissors: *const VkRect2D) {
769    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_set_scissor.0)(command_buffer, first_scissor, scissor_count, scissors) }
770    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdSetScissor(command_buffer, first_scissor, scissor_count, scissors) }
771}
772#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
773/// # Safety
774///
775/// direct calling ffi functions.
776pub unsafe fn cmd_set_line_width(command_buffer: VkCommandBuffer, line_width: c_float) {
777    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_set_line_width.0)(command_buffer, line_width) }
778    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdSetLineWidth(command_buffer, line_width) }
779}
780#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
781/// # Safety
782///
783/// direct calling ffi functions.
784pub unsafe fn cmd_set_depth_bias(command_buffer: VkCommandBuffer, depth_bias_constant_factor: c_float, depth_bias_clamp: c_float, depth_bias_slope_factor: c_float) {
785    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_set_depth_bias.0)(command_buffer, depth_bias_constant_factor, depth_bias_clamp, depth_bias_slope_factor) }
786    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdSetDepthBias(command_buffer, depth_bias_constant_factor, depth_bias_clamp, depth_bias_slope_factor) }
787}
788#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
789/// # Safety
790///
791/// direct calling ffi functions.
792pub unsafe fn cmd_set_blend_constants(command_buffer: VkCommandBuffer, blend_constants: *const c_float) {
793    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_set_blend_constants.0)(command_buffer, blend_constants) }
794    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdSetBlendConstants(command_buffer, blend_constants) }
795}
796#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
797/// # Safety
798///
799/// direct calling ffi functions.
800pub unsafe fn cmd_set_depth_bounds(command_buffer: VkCommandBuffer, min_depth_bounds: c_float, max_depth_bounds: c_float) {
801    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_set_depth_bounds.0)(command_buffer, min_depth_bounds, max_depth_bounds) }
802    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdSetDepthBounds(command_buffer, min_depth_bounds, max_depth_bounds) }
803}
804#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
805/// # Safety
806///
807/// direct calling ffi functions.
808pub unsafe fn cmd_set_stencil_compare_mask(command_buffer: VkCommandBuffer, face_mask: VkStencilFaceFlags, compare_mask: u32) {
809    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_set_stencil_compare_mask.0)(command_buffer, face_mask, compare_mask) }
810    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdSetStencilCompareMask(command_buffer, face_mask, compare_mask) }
811}
812#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
813/// # Safety
814///
815/// direct calling ffi functions.
816pub unsafe fn cmd_set_stencil_write_mask(command_buffer: VkCommandBuffer, face_mask: VkStencilFaceFlags, write_mask: u32) {
817    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_set_stencil_write_mask.0)(command_buffer, face_mask, write_mask) }
818    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdSetStencilWriteMask(command_buffer, face_mask, write_mask) }
819}
820#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
821/// # Safety
822///
823/// direct calling ffi functions.
824pub unsafe fn cmd_set_stencil_reference(command_buffer: VkCommandBuffer, face_mask: VkStencilFaceFlags, reference: u32) {
825    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_set_stencil_reference.0)(command_buffer, face_mask, reference) }
826    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdSetStencilReference(command_buffer, face_mask, reference) }
827}
828#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
829/// # Safety
830///
831/// direct calling ffi functions.
832pub unsafe fn cmd_bind_descriptor_sets(command_buffer: VkCommandBuffer, pipeline_bind_point: VkPipelineBindPoint, layout: VkPipelineLayout, first_set: u32, descriptor_set_count: u32, descriptor_sets: *const VkDescriptorSet, dynamic_offset_count: u32, dynamic_offsets: *const u32) {
833    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_bind_descriptor_sets.0)(command_buffer, pipeline_bind_point, layout, first_set, descriptor_set_count, descriptor_sets, dynamic_offset_count, dynamic_offsets) }
834    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdBindDescriptorSets(command_buffer, pipeline_bind_point, layout, first_set, descriptor_set_count, descriptor_sets, dynamic_offset_count, dynamic_offsets) }
835}
836#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
837/// # Safety
838///
839/// direct calling ffi functions.
840pub unsafe fn cmd_bind_index_buffer(command_buffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, index_type: VkIndexType) {
841    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_bind_index_buffer.0)(command_buffer, buffer, offset, index_type) }
842    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdBindIndexBuffer(command_buffer, buffer, offset, index_type) }
843}
844#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
845/// # Safety
846///
847/// direct calling ffi functions.
848pub unsafe fn cmd_bind_vertex_buffers(command_buffer: VkCommandBuffer, first_binding: u32, binding_count: u32, buffers: *const VkBuffer, offsets: *const VkDeviceSize) {
849    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_bind_vertex_buffers.0)(command_buffer, first_binding, binding_count, buffers, offsets) }
850    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdBindVertexBuffers(command_buffer, first_binding, binding_count, buffers, offsets) }
851}
852#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
853/// # Safety
854///
855/// direct calling ffi functions.
856pub unsafe fn cmd_draw(command_buffer: VkCommandBuffer, vertex_count: u32, instance_count: u32, first_vertex: u32, first_index: u32) {
857    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_draw.0)(command_buffer, vertex_count, instance_count, first_vertex, first_index) }
858    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdDraw(command_buffer, vertex_count, instance_count, first_vertex, first_index) }
859}
860#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
861/// # Safety
862///
863/// direct calling ffi functions.
864pub unsafe fn cmd_draw_indexed(command_buffer: VkCommandBuffer, index_count: u32, instance_count: u32, first_index: u32, vertex_offset: i32, first_instance: u32) {
865    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_draw_indexed.0)(command_buffer, index_count, instance_count, first_index, vertex_offset, first_instance) }
866    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdDrawIndexed(command_buffer, index_count, instance_count, first_index, vertex_offset, first_instance) }
867}
868#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
869/// # Safety
870///
871/// direct calling ffi functions.
872pub unsafe fn cmd_draw_indirect(command_buffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, draw_count: u32, stride: u32) {
873    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_draw_indirect.0)(command_buffer, buffer, offset, draw_count, stride) }
874    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdDrawIndirect(command_buffer, buffer, offset, draw_count, stride) }
875}
876#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
877/// # Safety
878///
879/// direct calling ffi functions.
880pub unsafe fn cmd_draw_indexed_indirect(command_buffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, draw_count: u32, stride: u32) {
881    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_draw_indexed_indirect.0)(command_buffer, buffer, offset, draw_count, stride) }
882    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdDrawIndexedIndirect(command_buffer, buffer, offset, draw_count, stride) }
883}
884#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
885/// # Safety
886///
887/// direct calling ffi functions.
888pub unsafe fn cmd_dispatch(command_buffer: VkCommandBuffer, group_count_x: u32, group_count_y: u32, group_count_z: u32) {
889    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_dispatch.0)(command_buffer, group_count_x, group_count_y, group_count_z) }
890    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdDispatch(command_buffer, group_count_x, group_count_y, group_count_z) }
891}
892#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
893/// # Safety
894///
895/// direct calling ffi functions.
896pub unsafe fn cmd_dispatch_indirect(command_buffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize) {
897    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_dispatch_indirect.0)(command_buffer, buffer, offset) }
898    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdDispatchIndirect(command_buffer, buffer, offset) }
899}
900#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
901/// # Safety
902///
903/// direct calling ffi functions.
904pub unsafe fn cmd_copy_buffer(command_buffer: VkCommandBuffer, src_buffer: VkBuffer, dst_buffer: VkBuffer, region_count: u32, regions: *const VkBufferCopy) {
905    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_copy_buffer.0)(command_buffer, src_buffer, dst_buffer, region_count, regions) }
906    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdCopyBuffer(command_buffer, src_buffer, dst_buffer, region_count, regions) }
907}
908#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
909/// # Safety
910///
911/// direct calling ffi functions.
912pub unsafe fn cmd_copy_image(command_buffer: VkCommandBuffer, src_image: VkImage, src_image_layout: VkImageLayout, dst_image: VkImage, dst_image_layout: VkImageLayout, region_count: u32, regions: *const VkImageCopy) {
913    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_copy_image.0)(command_buffer, src_image, src_image_layout, dst_image, dst_image_layout, region_count, regions) }
914    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdCopyImage(command_buffer, src_image, src_image_layout, dst_image, dst_image_layout, region_count, regions) }
915}
916#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
917/// # Safety
918///
919/// direct calling ffi functions.
920pub unsafe fn cmd_blit_image(command_buffer: VkCommandBuffer, src_image: VkImage, src_image_layout: VkImageLayout, dst_image: VkImage, dst_image_layout: VkImageLayout, region_count: u32, regions: *const VkImageBlit, filter: VkFilter) {
921    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_blit_image.0)(command_buffer, src_image, src_image_layout, dst_image, dst_image_layout, region_count, regions, filter) }
922    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdBlitImage(command_buffer, src_image, src_image_layout, dst_image, dst_image_layout, region_count, regions, filter) }
923}
924#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
925/// # Safety
926///
927/// direct calling ffi functions.
928pub unsafe fn cmd_copy_buffer_to_image(command_buffer: VkCommandBuffer, src_buffer: VkBuffer, dst_image: VkImage, dst_image_layout: VkImageLayout, region_count: u32, regions: *const VkBufferImageCopy) {
929    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_copy_buffer_to_image.0)(command_buffer, src_buffer, dst_image, dst_image_layout, region_count, regions) }
930    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdCopyBufferToImage(command_buffer, src_buffer, dst_image, dst_image_layout, region_count, regions) }
931}
932#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
933/// # Safety
934///
935/// direct calling ffi functions.
936pub unsafe fn cmd_copy_image_to_buffer(command_buffer: VkCommandBuffer, src_image: VkImage, src_image_layout: VkImageLayout, dst_buffer: VkBuffer, region_count: u32, regions: *const VkBufferImageCopy) {
937    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_copy_image_to_buffer.0)(command_buffer, src_image, src_image_layout, dst_buffer, region_count, regions) }
938    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdCopyImageToBuffer(command_buffer, src_image, src_image_layout, dst_buffer, region_count, regions) }
939}
940#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
941/// # Safety
942///
943/// direct calling ffi functions.
944pub unsafe fn cmd_update_buffer(command_buffer: VkCommandBuffer, dst_buffer: VkBuffer, dst_offset: VkDeviceSize, data_size: VkDeviceSize, data: *const c_void) {
945    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_update_buffer.0)(command_buffer, dst_buffer, dst_offset, data_size, data) }
946    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdUpdateBuffer(command_buffer, dst_buffer, dst_offset, data_size, data) }
947}
948#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
949/// # Safety
950///
951/// direct calling ffi functions.
952pub unsafe fn cmd_fill_buffer(command_buffer: VkCommandBuffer, dst_buffer: VkBuffer, dst_offset: VkDeviceSize, size: VkDeviceSize, data: u32) {
953    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_fill_buffer.0)(command_buffer, dst_buffer, dst_offset, size, data) }
954    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdFillBuffer(command_buffer, dst_buffer, dst_offset, size, data) }
955}
956#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
957/// # Safety
958///
959/// direct calling ffi functions.
960pub unsafe fn cmd_clear_color_image(command_buffer: VkCommandBuffer, image: VkImage, image_layout: VkImageLayout, color: *const VkClearColorValue, range_count: u32, ranges: *const VkImageSubresourceRange) {
961    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_clear_color_image.0)(command_buffer, image, image_layout, color, range_count, ranges) }
962    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdClearColorImage(command_buffer, image, image_layout, color, range_count, ranges) }
963}
964#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
965/// # Safety
966///
967/// direct calling ffi functions.
968pub unsafe fn cmd_clear_depth_stencil_image(command_buffer: VkCommandBuffer, image: VkImage, image_layout: VkImageLayout, depth_stencil: *const VkClearDepthStencilValue, range_count: u32, ranges: *const VkImageSubresourceRange) {
969    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_clear_depth_stencil_image.0)(command_buffer, image, image_layout, depth_stencil, range_count, ranges) }
970    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdClearDepthStencilImage(command_buffer, image, image_layout, depth_stencil, range_count, ranges) }
971}
972#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
973/// # Safety
974///
975/// direct calling ffi functions.
976pub unsafe fn cmd_clear_attachments(command_buffer: VkCommandBuffer, attachment_count: u32, attachments: *const VkClearAttachment, rect_count: u32, rects: *const VkClearRect) {
977    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_clear_attachments.0)(command_buffer, attachment_count, attachments, rect_count, rects) }
978    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdClearAttachments(command_buffer, attachment_count, attachments, rect_count, rects) }
979}
980#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
981/// # Safety
982///
983/// direct calling ffi functions.
984pub unsafe fn cmd_resolve_image(command_buffer: VkCommandBuffer, src_image: VkImage, src_image_layout: VkImageLayout, dst_image: VkImage, dst_image_layout: VkImageLayout, region_count: u32, regions: *const VkImageResolve) {
985    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_resolve_image.0)(command_buffer, src_image, src_image_layout, dst_image, dst_image_layout, region_count, regions) }
986    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdResolveImage(command_buffer, src_image, src_image_layout, dst_image, dst_image_layout, region_count, regions) }
987}
988#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
989/// # Safety
990///
991/// direct calling ffi functions.
992pub unsafe fn cmd_set_event(command_buffer: VkCommandBuffer, event: VkEvent, stage_mask: VkPipelineStageFlags) {
993    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_set_event.0)(command_buffer, event, stage_mask) }
994    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdSetEvent(command_buffer, event, stage_mask) }
995}
996#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
997/// # Safety
998///
999/// direct calling ffi functions.
1000pub unsafe fn cmd_reset_event(command_buffer: VkCommandBuffer, event: VkEvent, stage_mask: VkPipelineStageFlags) {
1001    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_reset_event.0)(command_buffer, event, stage_mask) }
1002    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdResetEvent(command_buffer, event, stage_mask) }
1003}
1004#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1005/// # Safety
1006///
1007/// direct calling ffi functions.
1008pub unsafe fn cmd_wait_events(command_buffer: VkCommandBuffer, event_count: u32, events: *const VkEvent, src_stage_mask: VkPipelineStageFlags, dst_stage_mask: VkPipelineStageFlags, memory_barrier_count: u32, memory_barriers: *const VkMemoryBarrier, buffer_memory_barrier_count: u32, buffer_memory_barriers: *const VkBufferMemoryBarrier, image_memory_barrier_count: u32, image_memory_barriers: *const VkImageMemoryBarrier) {
1009    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_wait_events.0)(command_buffer, event_count, events, src_stage_mask, dst_stage_mask, memory_barrier_count, memory_barriers, buffer_memory_barrier_count, buffer_memory_barriers, image_memory_barrier_count, image_memory_barriers) }
1010    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdWaitEvents(command_buffer, event_count, events, src_stage_mask, dst_stage_mask, memory_barrier_count, memory_barriers, buffer_memory_barrier_count, buffer_memory_barriers, image_memory_barrier_count, image_memory_barriers) }
1011}
1012#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1013/// # Safety
1014///
1015/// direct calling ffi functions.
1016pub unsafe fn cmd_pipeline_barrier(command_buffer: VkCommandBuffer, src_stage_mask: VkPipelineStageFlags, dst_stage_mask: VkPipelineStageFlags, dependency_flags: VkDependencyFlags, memory_barrier_count: u32, memory_barriers: *const VkMemoryBarrier, buffer_memory_barrier_count: u32, buffer_memory_barriers: *const VkBufferMemoryBarrier, image_memory_barrier_count: u32, image_memory_barriers: *const VkImageMemoryBarrier) {
1017    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_pipeline_barrier.0)(command_buffer, src_stage_mask, dst_stage_mask, dependency_flags, memory_barrier_count, memory_barriers, buffer_memory_barrier_count, buffer_memory_barriers, image_memory_barrier_count, image_memory_barriers) }
1018    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdPipelineBarrier(command_buffer, src_stage_mask, dst_stage_mask, dependency_flags, memory_barrier_count, memory_barriers, buffer_memory_barrier_count, buffer_memory_barriers, image_memory_barrier_count, image_memory_barriers) }
1019}
1020#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1021/// # Safety
1022///
1023/// direct calling ffi functions.
1024pub unsafe fn cmd_begin_query(command_buffer: VkCommandBuffer, query_pool: VkQueryPool, query: u32, flags: VkQueryControlFlags) {
1025    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_begin_query.0)(command_buffer, query_pool, query, flags) }
1026    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdBeginQuery(command_buffer, query_pool, query, flags) }
1027}
1028#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1029/// # Safety
1030///
1031/// direct calling ffi functions.
1032pub unsafe fn cmd_end_query(command_buffer: VkCommandBuffer, query_pool: VkQueryPool, query: u32) {
1033    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_end_query.0)(command_buffer, query_pool, query) }
1034    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdEndQuery(command_buffer, query_pool, query) }
1035}
1036#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1037/// # Safety
1038///
1039/// direct calling ffi functions.
1040pub unsafe fn cmd_reset_query_pool(command_buffer: VkCommandBuffer, query_pool: VkQueryPool, first_query: u32, query_count: u32) {
1041    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_reset_query_pool.0)(command_buffer, query_pool, first_query, query_count) }
1042    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdResetQueryPool(command_buffer, query_pool, first_query, query_count) }
1043}
1044#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1045/// # Safety
1046///
1047/// direct calling ffi functions.
1048pub unsafe fn cmd_write_timestamp(command_buffer: VkCommandBuffer, pipeline_stage: VkPipelineStageFlags, query_pool: VkQueryPool, query: u32) {
1049    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_write_timestamp.0)(command_buffer, pipeline_stage, query_pool, query) }
1050    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdWriteTimestamp(command_buffer, pipeline_stage, query_pool, query) }
1051}
1052#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1053/// # Safety
1054///
1055/// direct calling ffi functions.
1056pub unsafe fn cmd_copy_query_pool_results(command_buffer: VkCommandBuffer, query_pool: VkQueryPool, first_query: u32, query_count: u32, dst_buffer: VkBuffer, dst_offset: VkDeviceSize, stride: VkDeviceSize, flags: VkQueryResultFlags) {
1057    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_copy_query_pool_results.0)(command_buffer, query_pool, first_query, query_count, dst_buffer, dst_offset, stride, flags) }
1058    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdCopyQueryPoolResults(command_buffer, query_pool, first_query, query_count, dst_buffer, dst_offset, stride, flags) }
1059}
1060#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1061/// # Safety
1062///
1063/// direct calling ffi functions.
1064pub unsafe fn cmd_push_constants(command_buffer: VkCommandBuffer, layout: VkPipelineLayout, stage_flags: VkShaderStageFlags, offset: u32, size: u32, values: *const c_void) {
1065    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_push_constants.0)(command_buffer, layout, stage_flags, offset, size, values) }
1066    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdPushConstants(command_buffer, layout, stage_flags, offset, size, values) }
1067}
1068#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1069/// # Safety
1070///
1071/// direct calling ffi functions.
1072pub unsafe fn cmd_begin_render_pass(command_buffer: VkCommandBuffer, render_pass_begin_info: *const VkRenderPassBeginInfo, contents: VkSubpassContents) {
1073    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_begin_render_pass.0)(command_buffer, render_pass_begin_info, contents) }
1074    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdBeginRenderPass(command_buffer, render_pass_begin_info, contents) }
1075}
1076#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1077/// # Safety
1078///
1079/// direct calling ffi functions.
1080pub unsafe fn cmd_next_subpass(command_buffer: VkCommandBuffer, contents: VkSubpassContents) {
1081    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_next_subpass.0)(command_buffer, contents) }
1082    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdNextSubpass(command_buffer, contents) }
1083}
1084#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1085/// # Safety
1086///
1087/// direct calling ffi functions.
1088pub unsafe fn cmd_end_render_pass(command_buffer: VkCommandBuffer) {
1089    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_end_render_pass.0)(command_buffer) }
1090    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdEndRenderPass(command_buffer) }
1091}
1092#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1093/// # Safety
1094///
1095/// direct calling ffi functions.
1096pub unsafe fn cmd_execute_commands(command_buffer: VkCommandBuffer, command_buffer_count: u32, command_buffers: *const VkCommandBuffer) {
1097    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_execute_commands.0)(command_buffer, command_buffer_count, command_buffers) }
1098    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdExecuteCommands(command_buffer, command_buffer_count, command_buffers) }
1099}
1100#[cfg(feature = "Allow1_1APIs")]
1101#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1102/// # Safety
1103///
1104/// direct calling ffi functions.
1105pub unsafe fn enumerate_instance_version(api_version: *mut u32) -> VkResult {
1106    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.enumerate_instance_version.0)(api_version) }
1107    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkEnumerateInstanceVersion(api_version) }
1108}
1109#[cfg(feature = "Allow1_1APIs")]
1110#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1111/// # Safety
1112///
1113/// direct calling ffi functions.
1114pub unsafe fn trim_command_pool(device: VkDevice, command_pool: VkCommandPool, flags: VkCommandPoolTrimFlags) {
1115    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.trim_command_pool.0)(device, command_pool, flags) }
1116    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkTrimCommandPool(device, command_pool, flags) }
1117}
1118#[cfg(feature = "VK_KHR_surface")]
1119#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1120/// # Safety
1121///
1122/// direct calling ffi functions.
1123pub unsafe fn destroy_surface_khr(instance: VkInstance, surface: VkSurfaceKHR, allocator: *const VkAllocationCallbacks) {
1124    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.destroy_surface_khr.0)(instance, surface, allocator) }
1125    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDestroySurfaceKHR(instance, surface, allocator) }
1126}
1127#[cfg(feature = "VK_KHR_surface")]
1128#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1129/// # Safety
1130///
1131/// direct calling ffi functions.
1132pub unsafe fn get_physical_device_surface_support_khr(physical_device: VkPhysicalDevice, queue_family_index: u32, surface: VkSurfaceKHR, supported_out: *mut VkBool32) -> VkResult {
1133    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_surface_support_khr.0)(physical_device, queue_family_index, surface, supported_out) }
1134    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceSurfaceSupportKHR(physical_device, queue_family_index, surface, supported_out) }
1135}
1136#[cfg(feature = "VK_KHR_surface")]
1137#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1138/// # Safety
1139///
1140/// direct calling ffi functions.
1141pub unsafe fn get_physical_device_surface_capabilities_khr(physical_device: VkPhysicalDevice, surface: VkSurfaceKHR, surface_capabilities_out: *mut VkSurfaceCapabilitiesKHR) -> VkResult {
1142    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_surface_capabilities_khr.0)(physical_device, surface, surface_capabilities_out) }
1143    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical_device, surface, surface_capabilities_out) }
1144}
1145#[cfg(feature = "VK_KHR_surface")]
1146#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1147/// # Safety
1148///
1149/// direct calling ffi functions.
1150pub unsafe fn get_physical_device_surface_formats_khr(physical_device: VkPhysicalDevice, surface: VkSurfaceKHR, surface_format_count_out: *mut u32, surface_formats_out: *mut VkSurfaceFormatKHR) -> VkResult {
1151    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_surface_formats_khr.0)(physical_device, surface, surface_format_count_out, surface_formats_out) }
1152    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, surface, surface_format_count_out, surface_formats_out) }
1153}
1154#[cfg(feature = "VK_KHR_surface")]
1155#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1156/// # Safety
1157///
1158/// direct calling ffi functions.
1159pub unsafe fn get_physical_device_surface_present_modes_khr(physical_device: VkPhysicalDevice, surface: VkSurfaceKHR, present_mode_count_out: *mut u32, present_modes_out: *mut VkPresentModeKHR) -> VkResult {
1160    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_surface_present_modes_khr.0)(physical_device, surface, present_mode_count_out, present_modes_out) }
1161    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceSurfacePresentModesKHR(physical_device, surface, present_mode_count_out, present_modes_out) }
1162}
1163#[cfg(feature = "VK_KHR_swapchain")]
1164#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1165/// # Safety
1166///
1167/// direct calling ffi functions.
1168pub unsafe fn create_swapchain_khr(device: VkDevice, create_info: *const VkSwapchainCreateInfoKHR, allocator: *const VkAllocationCallbacks, swapchain_out: *mut VkSwapchainKHR) -> VkResult {
1169    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_swapchain_khr.0)(device, create_info, allocator, swapchain_out) }
1170    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateSwapchainKHR(device, create_info, allocator, swapchain_out) }
1171}
1172#[cfg(feature = "VK_KHR_swapchain")]
1173#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1174/// # Safety
1175///
1176/// direct calling ffi functions.
1177pub unsafe fn destroy_swapchain_khr(device: VkDevice, swapchain: VkSwapchainKHR, allocator: *const VkAllocationCallbacks) {
1178    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.destroy_swapchain_khr.0)(device, swapchain, allocator) }
1179    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDestroySwapchainKHR(device, swapchain, allocator) }
1180}
1181#[cfg(feature = "VK_KHR_swapchain")]
1182#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1183/// # Safety
1184///
1185/// direct calling ffi functions.
1186pub unsafe fn get_swapchain_images_khr(device: VkDevice, swapchain: VkSwapchainKHR, swapchain_image_count_out: *mut u32, swapchain_images_out: *mut VkImage) -> VkResult {
1187    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_swapchain_images_khr.0)(device, swapchain, swapchain_image_count_out, swapchain_images_out) }
1188    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetSwapchainImagesKHR(device, swapchain, swapchain_image_count_out, swapchain_images_out) }
1189}
1190#[cfg(feature = "VK_KHR_swapchain")]
1191#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1192/// # Safety
1193///
1194/// direct calling ffi functions.
1195pub unsafe fn acquire_next_image_khr(device: VkDevice, swapchain: VkSwapchainKHR, timeout: u64, semaphore: Option<VkSemaphore>, fence: Option<VkFence>, image_index_out: *mut u32) -> VkResult {
1196    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.acquire_next_image_khr.0)(device, swapchain, timeout, semaphore, fence, image_index_out) }
1197    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, image_index_out) }
1198}
1199#[cfg(feature = "VK_KHR_swapchain")]
1200#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1201/// # Safety
1202///
1203/// direct calling ffi functions.
1204pub unsafe fn queue_present_khr(queue: VkQueue, present_info: *const VkPresentInfoKHR) -> VkResult {
1205    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.queue_present_khr.0)(queue, present_info) }
1206    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkQueuePresentKHR(queue, present_info) }
1207}
1208#[cfg(feature = "VK_KHR_xlib_surface")]
1209#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1210/// # Safety
1211///
1212/// direct calling ffi functions.
1213pub unsafe fn create_xlib_surface_khr(instance: VkInstance, create_info: *const VkXlibSurfaceCreateInfoKHR, allocator: *const VkAllocationCallbacks, surface_out: *mut VkSurfaceKHR) -> VkResult {
1214    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_xlib_surface_khr.0)(instance, create_info, allocator, surface_out) }
1215    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateXlibSurfaceKHR(instance, create_info, allocator, surface_out) }
1216}
1217#[cfg(feature = "VK_KHR_xlib_surface")]
1218#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1219/// # Safety
1220///
1221/// direct calling ffi functions.
1222pub unsafe fn get_physical_device_xlib_presentation_support_khr(physical_device: VkPhysicalDevice, queue_family_index: u32, dpy: *mut x11::xlib::Display, visual_id: x11::xlib::VisualID) -> VkBool32 {
1223    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_xlib_presentation_support_khr.0)(physical_device, queue_family_index, dpy, visual_id) }
1224    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceXlibPresentationSupportKHR(physical_device, queue_family_index, dpy, visual_id) }
1225}
1226#[cfg(feature = "VK_KHR_xcb_surface")]
1227#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1228/// # Safety
1229///
1230/// direct calling ffi functions.
1231pub unsafe fn create_xcb_surface_khr(instance: VkInstance, create_info: *const VkXcbSurfaceCreateInfoKHR, allocator: *const VkAllocationCallbacks, surface_out: *mut VkSurfaceKHR) -> VkResult {
1232    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_xcb_surface_khr.0)(instance, create_info, allocator, surface_out) }
1233    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateXcbSurfaceKHR(instance, create_info, allocator, surface_out) }
1234}
1235#[cfg(feature = "VK_KHR_xcb_surface")]
1236#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1237/// # Safety
1238///
1239/// direct calling ffi functions.
1240pub unsafe fn get_physical_device_xcb_presentation_support_khr(physical_device: VkPhysicalDevice, queue_family_index: u32, connection: *mut xcb::ffi::xcb_connection_t, visual_id: xcb::x::Visualid) -> VkBool32 {
1241    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_xcb_presentation_support_khr.0)(physical_device, queue_family_index, connection, visual_id) }
1242    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceXcbPresentationSupportKHR(physical_device, queue_family_index, connection, visual_id) }
1243}
1244#[cfg(feature = "VK_KHR_wayland_surface")]
1245#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1246/// # Safety
1247///
1248/// direct calling ffi functions.
1249pub unsafe fn create_wayland_surface_khr(instance: VkInstance, create_info: *const VkWaylandSurfaceCreateInfoKHR, allocator: *const VkAllocationCallbacks, surface_out: *mut VkSurfaceKHR) -> VkResult {
1250    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_wayland_surface_khr.0)(instance, create_info, allocator, surface_out) }
1251    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateWaylandSurfaceKHR(instance, create_info, allocator, surface_out) }
1252}
1253#[cfg(feature = "VK_KHR_wayland_surface")]
1254#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1255/// # Safety
1256///
1257/// direct calling ffi functions.
1258pub unsafe fn get_physical_device_wayland_presentation_support_khr(physical_device: VkPhysicalDevice, queue_family_index: u32, display: *mut c_void) -> VkBool32 {
1259    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_wayland_presentation_support_khr.0)(physical_device, queue_family_index, display) }
1260    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceWaylandPresentationSupportKHR(physical_device, queue_family_index, display) }
1261}
1262#[cfg(feature = "VK_KHR_android_surface")]
1263#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1264/// # Safety
1265///
1266/// direct calling ffi functions.
1267pub unsafe fn create_android_surface_khr(instance: VkInstance, create_info: *const VkAndroidSurfaceCreateInfoKHR, allocator: *const VkAllocationCallbacks, surface_out: *mut VkSurfaceKHR) -> VkResult {
1268    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_android_surface_khr.0)(instance, create_info, allocator, surface_out) }
1269    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateAndroidSurfaceKHR(instance, create_info, allocator, surface_out) }
1270}
1271#[cfg(feature = "VK_KHR_win32_surface")]
1272#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1273/// # Safety
1274///
1275/// direct calling ffi functions.
1276pub unsafe fn create_win32_surface_khr(instance: VkInstance, create_info: *const VkWin32SurfaceCreateInfoKHR, allocator: *const VkAllocationCallbacks, surface_out: *mut VkSurfaceKHR) -> VkResult {
1277    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_win32_surface_khr.0)(instance, create_info, allocator, surface_out) }
1278    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateWin32SurfaceKHR(instance, create_info, allocator, surface_out) }
1279}
1280#[cfg(feature = "VK_KHR_win32_surface")]
1281#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1282/// # Safety
1283///
1284/// direct calling ffi functions.
1285pub unsafe fn get_physical_device_win32_presentation_support_khr(physical_device: VkPhysicalDevice, queue_family_index: u32) -> VkBool32 {
1286    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_win32_presentation_support_khr.0)(physical_device, queue_family_index) }
1287    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceWin32PresentationSupportKHR(physical_device, queue_family_index) }
1288}
1289#[cfg(feature = "VK_MVK_macos_surface")]
1290#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1291/// # Safety
1292///
1293/// direct calling ffi functions.
1294pub unsafe fn create_macos_surface_mvk(instance: VkInstance, create_info: *const VkMacOSSurfaceCreateInfoMVK, allocator: *const VkAllocationCallbacks, surface_out: *mut VkSurfaceKHR) -> VkResult {
1295    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_macos_surface_mvk.0)(instance, create_info, allocator, surface_out) }
1296    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateMacOSSurfaceMVK(instance, create_info, allocator, surface_out) }
1297}
1298#[cfg(feature = "VK_EXT_metal_surface")]
1299#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1300/// # Safety
1301///
1302/// direct calling ffi functions.
1303pub unsafe fn create_metal_surface_ext(instance: VkInstance, create_info: *const VkMetalSurfaceCreateInfoEXT, allocator: *const VkAllocationCallbacks, surface_out: *mut VkSurfaceKHR) -> VkResult {
1304    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_metal_surface_ext.0)(instance, create_info, allocator, surface_out) }
1305    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateMetalSurfaceEXT(instance, create_info, allocator, surface_out) }
1306}
1307#[cfg(feature = "VK_KHR_display")]
1308#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1309/// # Safety
1310///
1311/// direct calling ffi functions.
1312pub unsafe fn get_physical_device_display_properties_khr(physical_device: VkPhysicalDevice, property_count_out: *mut u32, properties_out: *mut VkDisplayPropertiesKHR) -> VkResult {
1313    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_display_properties_khr.0)(physical_device, property_count_out, properties_out) }
1314    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceDisplayPropertiesKHR(physical_device, property_count_out, properties_out) }
1315}
1316#[cfg(feature = "VK_KHR_display")]
1317#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1318/// # Safety
1319///
1320/// direct calling ffi functions.
1321pub unsafe fn get_physical_device_display_plane_properties_khr(physical_device: VkPhysicalDevice, property_count_out: *mut u32, properties_out: *mut VkDisplayPlanePropertiesKHR) -> VkResult {
1322    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_display_plane_properties_khr.0)(physical_device, property_count_out, properties_out) }
1323    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physical_device, property_count_out, properties_out) }
1324}
1325#[cfg(feature = "VK_KHR_display")]
1326#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1327/// # Safety
1328///
1329/// direct calling ffi functions.
1330pub unsafe fn get_display_plane_supported_displays_khr(physical_device: VkPhysicalDevice, plane_index: u32, display_count_out: *mut u32, displays_out: *mut VkDisplayKHR) -> VkResult {
1331    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_display_plane_supported_displays_khr.0)(physical_device, plane_index, display_count_out, displays_out) }
1332    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetDisplayPlaneSupportedDisplaysKHR(physical_device, plane_index, display_count_out, displays_out) }
1333}
1334#[cfg(feature = "VK_KHR_display")]
1335#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1336/// # Safety
1337///
1338/// direct calling ffi functions.
1339pub unsafe fn get_display_mode_properties_khr(physical_device: VkPhysicalDevice, display: VkDisplayKHR, property_count_out: *mut u32, properties_out: *mut VkDisplayModePropertiesKHR) -> VkResult {
1340    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_display_mode_properties_khr.0)(physical_device, display, property_count_out, properties_out) }
1341    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetDisplayModePropertiesKHR(physical_device, display, property_count_out, properties_out) }
1342}
1343#[cfg(feature = "VK_KHR_display")]
1344#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1345/// # Safety
1346///
1347/// direct calling ffi functions.
1348pub unsafe fn create_display_mode_khr(physical_device: VkPhysicalDevice, display: VkDisplayKHR, create_info: *const VkDisplayModeCreateInfoKHR, allocator: *const VkAllocationCallbacks, mode_out: *mut VkDisplayModeKHR) -> VkResult {
1349    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_display_mode_khr.0)(physical_device, display, create_info, allocator, mode_out) }
1350    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateDisplayModeKHR(physical_device, display, create_info, allocator, mode_out) }
1351}
1352#[cfg(feature = "VK_KHR_display")]
1353#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1354/// # Safety
1355///
1356/// direct calling ffi functions.
1357pub unsafe fn get_display_plane_capabilities_khr(physcial_device: VkPhysicalDevice, mode: VkDisplayModeKHR, plane_index: u32, capabilities_out: *mut VkDisplayPlaneCapabilitiesKHR) -> VkResult {
1358    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_display_plane_capabilities_khr.0)(physcial_device, mode, plane_index, capabilities_out) }
1359    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetDisplayPlaneCapabilitiesKHR(physcial_device, mode, plane_index, capabilities_out) }
1360}
1361#[cfg(all(feature = "VK_KHR_display", feature = "VK_KHR_surface"))]
1362#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1363/// # Safety
1364///
1365/// direct calling ffi functions.
1366pub unsafe fn create_display_plane_surface_khr(instance: VkInstance, create_info: *const VkDisplaySurfaceCreateInfoKHR, allocator: *const VkAllocationCallbacks, surface_out: *mut VkSurfaceKHR) -> VkResult {
1367    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_display_plane_surface_khr.0)(instance, create_info, allocator, surface_out) }
1368    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateDisplayPlaneSurfaceKHR(instance, create_info, allocator, surface_out) }
1369}
1370#[cfg(feature = "Allow1_1APIs")]
1371#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1372/// # Safety
1373///
1374/// direct calling ffi functions.
1375pub unsafe fn get_physical_device_features2(physical_device: VkPhysicalDevice, features_out: *mut VkPhysicalDeviceFeatures2) {
1376    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_features2.0)(physical_device, features_out) }
1377    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceFeatures2(physical_device, features_out) }
1378}
1379#[cfg(feature = "Allow1_1APIs")]
1380#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1381/// # Safety
1382///
1383/// direct calling ffi functions.
1384pub unsafe fn get_physical_device_format_properties2(physical_device: VkPhysicalDevice, format: VkFormat, format_properties_out: *mut VkFormatProperties2) {
1385    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_format_properties2.0)(physical_device, format, format_properties_out) }
1386    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceFormatProperties2(physical_device, format, format_properties_out) }
1387}
1388#[cfg(feature = "Allow1_1APIs")]
1389#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1390/// # Safety
1391///
1392/// direct calling ffi functions.
1393pub unsafe fn get_physical_device_image_format_properties2(physical_device: VkPhysicalDevice, image_format_info: *const VkPhysicalDeviceImageFormatInfo2, image_format_properties_out: *mut VkImageFormatProperties2) -> VkResult {
1394    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_image_format_properties2.0)(physical_device, image_format_info, image_format_properties_out) }
1395    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceImageFormatProperties2(physical_device, image_format_info, image_format_properties_out) }
1396}
1397#[cfg(feature = "Allow1_1APIs")]
1398#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1399/// # Safety
1400///
1401/// direct calling ffi functions.
1402pub unsafe fn get_physical_device_memory_properties2(physical_device: VkPhysicalDevice, memory_properties_out: *mut VkPhysicalDeviceMemoryProperties2) {
1403    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_memory_properties2.0)(physical_device, memory_properties_out) }
1404    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceMemoryProperties2(physical_device, memory_properties_out) }
1405}
1406#[cfg(feature = "Allow1_1APIs")]
1407#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1408/// # Safety
1409///
1410/// direct calling ffi functions.
1411pub unsafe fn get_physical_device_properties2(physical_device: VkPhysicalDevice, properties_out: *mut VkPhysicalDeviceProperties2) {
1412    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_properties2.0)(physical_device, properties_out) }
1413    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceProperties2(physical_device, properties_out) }
1414}
1415#[cfg(feature = "Allow1_1APIs")]
1416#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1417/// # Safety
1418///
1419/// direct calling ffi functions.
1420pub unsafe fn get_physical_device_queue_family_properties2(physical_device: VkPhysicalDevice, queue_family_property_count: *mut u32, queue_family_properties_out: *mut VkQueueFamilyProperties2) {
1421    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_queue_family_properties2.0)(physical_device, queue_family_property_count, queue_family_properties_out) }
1422    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceQueueFamilyProperties2(physical_device, queue_family_property_count, queue_family_properties_out) }
1423}
1424#[cfg(feature = "Allow1_1APIs")]
1425#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1426/// # Safety
1427///
1428/// direct calling ffi functions.
1429pub unsafe fn get_physical_device_sparse_image_format_properties2(physical_device: VkPhysicalDevice, format_info: *const VkPhysicalDeviceSparseImageFormatInfo2, property_count: *mut u32, properties_out: *mut VkSparseImageFormatProperties2) {
1430    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_physical_device_sparse_image_format_properties2.0)(physical_device, format_info, property_count, properties_out) }
1431    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetPhysicalDeviceSparseImageFormatProperties2(physical_device, format_info, property_count, properties_out) }
1432}
1433#[cfg(feature = "Allow1_1APIs")]
1434#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1435/// # Safety
1436///
1437/// direct calling ffi functions.
1438pub unsafe fn create_descriptor_update_template(device: VkDevice, create_info: *const VkDescriptorUpdateTemplateCreateInfo, allocator: *const VkAllocationCallbacks, descriptor_update_template_out: *mut VkDescriptorUpdateTemplate) -> VkResult {
1439    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_descriptor_update_template.0)(device, create_info, allocator, descriptor_update_template_out) }
1440    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateDescriptorUpdateTemplate(device, create_info, allocator, descriptor_update_template_out) }
1441}
1442#[cfg(feature = "Allow1_1APIs")]
1443#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1444/// # Safety
1445///
1446/// direct calling ffi functions.
1447pub unsafe fn destroy_descriptor_update_template(device: VkDevice, descriptor_update_template: VkDescriptorUpdateTemplate, allocator: *const VkAllocationCallbacks) {
1448    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.destroy_descriptor_update_template.0)(device, descriptor_update_template, allocator) }
1449    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkDestroyDescriptorUpdateTemplate(device, descriptor_update_template, allocator) }
1450}
1451#[cfg(feature = "Allow1_1APIs")]
1452#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1453/// # Safety
1454///
1455/// direct calling ffi functions.
1456pub unsafe fn update_descriptor_set_with_template(device: VkDevice, descriptor_set: VkDescriptorSet, descriptor_update_template: VkDescriptorUpdateTemplate, data: *const core::ffi::c_void) {
1457    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.update_descriptor_set_with_template.0)(device, descriptor_set, descriptor_update_template, data) }
1458    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkUpdateDescriptorSetWithTemplate(device, descriptor_set, descriptor_update_template, data) }
1459}
1460#[cfg(feature = "Allow1_1APIs")]
1461#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1462/// # Safety
1463///
1464/// direct calling ffi functions.
1465pub unsafe fn get_buffer_memory_requirements2(device: VkDevice, info: *const VkBufferMemoryRequirementsInfo2, memory_requirements: *mut VkMemoryRequirements2) {
1466    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_buffer_memory_requirements2.0)(device, info, memory_requirements) }
1467    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetBufferMemoryRequirements2(device, info, memory_requirements) }
1468}
1469#[cfg(feature = "Allow1_1APIs")]
1470#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1471/// # Safety
1472///
1473/// direct calling ffi functions.
1474pub unsafe fn get_image_memory_requirements2(device: VkDevice, info: *const VkImageMemoryRequirementsInfo2, memory_requirements: *mut VkMemoryRequirements2) {
1475    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_image_memory_requirements2.0)(device, info, memory_requirements) }
1476    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetImageMemoryRequirements2(device, info, memory_requirements) }
1477}
1478#[cfg(feature = "Allow1_1APIs")]
1479#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1480/// # Safety
1481///
1482/// direct calling ffi functions.
1483pub unsafe fn get_image_sparse_memory_requirements2(device: VkDevice, info: *const VkImageSparseMemoryRequirementsInfo2, sparse_memory_requirements_count: *mut u32, sparse_memory_requirements: *mut VkSparseImageMemoryRequirements2) {
1484    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_image_sparse_memory_requirements2.0)(device, info, sparse_memory_requirements_count, sparse_memory_requirements) }
1485    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetImageSparseMemoryRequirements2(device, info, sparse_memory_requirements_count, sparse_memory_requirements) }
1486}
1487#[cfg(feature = "Allow1_1APIs")]
1488#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1489/// # Safety
1490///
1491/// direct calling ffi functions.
1492pub unsafe fn bind_buffer_memory2(device: VkDevice, bind_info_count: u32, bind_infos: *const VkBindBufferMemoryInfo) -> VkResult {
1493    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.bind_buffer_memory2.0)(device, bind_info_count, bind_infos) }
1494    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkBindBufferMemory2(device, bind_info_count, bind_infos) }
1495}
1496#[cfg(feature = "Allow1_1APIs")]
1497#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1498/// # Safety
1499///
1500/// direct calling ffi functions.
1501pub unsafe fn bind_image_memory2(device: VkDevice, bind_info_count: u32, bind_infos: *const VkBindImageMemoryInfo) -> VkResult {
1502    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.bind_image_memory2.0)(device, bind_info_count, bind_infos) }
1503    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkBindImageMemory2(device, bind_info_count, bind_infos) }
1504}
1505#[cfg(feature = "Allow1_2APIs")]
1506#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1507/// # Safety
1508///
1509/// direct calling ffi functions.
1510pub unsafe fn create_render_pass2(device: VkDevice, create_info: *const VkRenderPassCreateInfo2, allocator: *const VkAllocationCallbacks, out: *mut VkRenderPass) -> VkResult {
1511    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.create_render_pass2.0)(device, create_info, allocator, out) }
1512    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCreateRenderPass2(device, create_info, allocator, out) }
1513}
1514#[cfg(feature = "Allow1_2APIs")]
1515#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1516/// # Safety
1517///
1518/// direct calling ffi functions.
1519pub unsafe fn get_semaphore_counter_value(device: VkDevice, semaphore: VkSemaphore, value: *mut u64) -> VkResult {
1520    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.get_semaphore_counter_value.0)(device, semaphore, value) }
1521    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkGetSemaphoreCounterValue(device, semaphore, value) }
1522}
1523#[cfg(feature = "Allow1_2APIs")]
1524#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1525/// # Safety
1526///
1527/// direct calling ffi functions.
1528pub unsafe fn signal_semaphore(device: VkDevice, signal_info: *const VkSemaphoreSignalInfo) -> VkResult {
1529    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.signal_semaphore.0)(device, signal_info) }
1530    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkSignalSemaphore(device, signal_info) }
1531}
1532#[cfg(feature = "Allow1_2APIs")]
1533#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1534/// # Safety
1535///
1536/// direct calling ffi functions.
1537pub unsafe fn wait_semaphores(device: VkDevice, wait_info: *const VkSemaphoreWaitInfo, timeout: u64) -> VkResult {
1538    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.wait_semaphores.0)(device, wait_info, timeout) }
1539    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkWaitSemaphores(device, wait_info, timeout) }
1540}
1541#[cfg(feature = "Allow1_2APIs")]
1542#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1543/// # Safety
1544///
1545/// direct calling ffi functions.
1546pub unsafe fn cmd_begin_render_pass2(command_buffer: VkCommandBuffer, begin_info: *const VkRenderPassBeginInfo, begin_subpass_info: *const VkSubpassBeginInfo) {
1547    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_begin_render_pass2.0)(command_buffer, begin_info, begin_subpass_info) }
1548    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdBeginRenderPass2(command_buffer, begin_info, begin_subpass_info) }
1549}
1550#[cfg(feature = "Allow1_2APIs")]
1551#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1552/// # Safety
1553///
1554/// direct calling ffi functions.
1555pub unsafe fn cmd_next_subpass2(command_buffer: VkCommandBuffer, begin_subpass_info: *const VkSubpassBeginInfo, end_subpass_info: *const VkSubpassEndInfo) {
1556    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_next_subpass2.0)(command_buffer, begin_subpass_info, end_subpass_info) }
1557    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdNextSubpass2(command_buffer, begin_subpass_info, end_subpass_info) }
1558}
1559#[cfg(feature = "Allow1_2APIs")]
1560#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1561/// # Safety
1562///
1563/// direct calling ffi functions.
1564pub unsafe fn cmd_end_render_pass2(command_buffer: VkCommandBuffer, end_subpass_info: *const VkSubpassEndInfo) {
1565    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_end_render_pass2.0)(command_buffer, end_subpass_info) }
1566    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdEndRenderPass2(command_buffer, end_subpass_info) }
1567}
1568#[cfg(feature = "Allow1_3APIs")]
1569#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1570/// # Safety
1571///
1572/// direct calling ffi functions.
1573pub unsafe fn cmd_pipeline_barrier2(command_buffer: VkCommandBuffer, dependency_info: *const VkDependencyInfo) {
1574    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_pipeline_barrier2.0)(command_buffer, dependency_info) }
1575    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdPipelineBarrier2(command_buffer, dependency_info) }
1576}
1577#[cfg(feature = "Allow1_3APIs")]
1578#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1579/// # Safety
1580///
1581/// direct calling ffi functions.
1582pub unsafe fn queue_submit2(queue: VkQueue, submit_count: u32, submits: *const VkSubmitInfo2, fence: Option<VkFence>) -> VkResult {
1583    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.queue_submit2.0)(queue, submit_count, submits, fence) }
1584    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkQueueSubmit2(queue, submit_count, submits, fence) }
1585}
1586#[cfg(feature = "Allow1_4APIs")]
1587#[rustfmt::skip] #[inline(always)] #[allow(clippy::too_many_arguments)]
1588/// # Safety
1589///
1590/// direct calling ffi functions.
1591pub unsafe fn cmd_push_descriptor_set(command_buffer: VkCommandBuffer, pipeline_bind_point: VkPipelineBindPoint, layout: VkPipelineLayout, set: u32, descriptor_write_count: u32, descriptor_writes: *const VkWriteDescriptorSet) {
1592    #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))] unsafe { (FPTBL.cmd_push_descriptor_set.0)(command_buffer, pipeline_bind_point, layout, set, descriptor_write_count, descriptor_writes) }
1593    #[cfg(not(any(feature = "DynamicLoaded", feature = "CustomResolver")))] unsafe { vkCmdPushDescriptorSet(command_buffer, pipeline_bind_point, layout, set, descriptor_write_count, descriptor_writes) }
1594}
1595
1596#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
1597pub(crate) struct FunctionPointerTable {
1598    create_instance: PFN_vkCreateInstance,
1599    destroy_instance: PFN_vkDestroyInstance,
1600    enumerate_physical_devices: PFN_vkEnumeratePhysicalDevices,
1601    get_physical_device_features: PFN_vkGetPhysicalDeviceFeatures,
1602    get_physical_device_format_properties: PFN_vkGetPhysicalDeviceFormatProperties,
1603    get_physical_device_image_format_properties: PFN_vkGetPhysicalDeviceImageFormatProperties,
1604    get_physical_device_properties: PFN_vkGetPhysicalDeviceProperties,
1605    get_physical_device_queue_family_properties: PFN_vkGetPhysicalDeviceQueueFamilyProperties,
1606    get_physical_device_memory_properties: PFN_vkGetPhysicalDeviceMemoryProperties,
1607    get_instance_proc_addr: PFN_vkGetInstanceProcAddr,
1608    get_device_proc_addr: PFN_vkGetDeviceProcAddr,
1609    create_device: PFN_vkCreateDevice,
1610    destroy_device: PFN_vkDestroyDevice,
1611    enumerate_instance_extension_properties: PFN_vkEnumerateInstanceExtensionProperties,
1612    enumerate_device_extension_properties: PFN_vkEnumerateDeviceExtensionProperties,
1613    enumerate_instance_layer_properties: PFN_vkEnumerateInstanceLayerProperties,
1614    enumerate_device_layer_properties: PFN_vkEnumerateDeviceLayerProperties,
1615    get_device_queue: PFN_vkGetDeviceQueue,
1616    queue_submit: PFN_vkQueueSubmit,
1617    queue_wait_idle: PFN_vkQueueWaitIdle,
1618    device_wait_idle: PFN_vkDeviceWaitIdle,
1619    allocate_memory: PFN_vkAllocateMemory,
1620    free_memory: PFN_vkFreeMemory,
1621    map_memory: PFN_vkMapMemory,
1622    unmap_memory: PFN_vkUnmapMemory,
1623    flush_mapped_memory_ranges: PFN_vkFlushMappedMemoryRanges,
1624    invalidate_mapped_memory_ranges: PFN_vkInvalidateMappedMemoryRanges,
1625    get_device_memory_commitment: PFN_vkGetDeviceMemoryCommitment,
1626    bind_buffer_memory: PFN_vkBindBufferMemory,
1627    bind_image_memory: PFN_vkBindImageMemory,
1628    get_buffer_memory_requirements: PFN_vkGetBufferMemoryRequirements,
1629    get_image_memory_requirements: PFN_vkGetImageMemoryRequirements,
1630    get_image_sparse_memory_requirements: PFN_vkGetImageSparseMemoryRequirements,
1631    get_physical_device_sparse_image_format_properties: PFN_vkGetPhysicalDeviceSparseImageFormatProperties,
1632    queue_bind_sparse: PFN_vkQueueBindSparse,
1633    create_fence: PFN_vkCreateFence,
1634    destroy_fence: PFN_vkDestroyFence,
1635    reset_fences: PFN_vkResetFences,
1636    get_fence_status: PFN_vkGetFenceStatus,
1637    wait_for_fences: PFN_vkWaitForFences,
1638    create_semaphore: PFN_vkCreateSemaphore,
1639    destroy_semaphore: PFN_vkDestroySemaphore,
1640    create_event: PFN_vkCreateEvent,
1641    destroy_event: PFN_vkDestroyEvent,
1642    get_event_status: PFN_vkGetEventStatus,
1643    set_event: PFN_vkSetEvent,
1644    reset_event: PFN_vkResetEvent,
1645    create_query_pool: PFN_vkCreateQueryPool,
1646    destroy_query_pool: PFN_vkDestroyQueryPool,
1647    get_query_pool_results: PFN_vkGetQueryPoolResults,
1648    create_buffer: PFN_vkCreateBuffer,
1649    destroy_buffer: PFN_vkDestroyBuffer,
1650    create_buffer_view: PFN_vkCreateBufferView,
1651    destroy_buffer_view: PFN_vkDestroyBufferView,
1652    create_image: PFN_vkCreateImage,
1653    destroy_image: PFN_vkDestroyImage,
1654    get_image_subresource_layout: PFN_vkGetImageSubresourceLayout,
1655    create_image_view: PFN_vkCreateImageView,
1656    destroy_image_view: PFN_vkDestroyImageView,
1657    create_shader_module: PFN_vkCreateShaderModule,
1658    destroy_shader_module: PFN_vkDestroyShaderModule,
1659    create_pipeline_cache: PFN_vkCreatePipelineCache,
1660    destroy_pipeline_cache: PFN_vkDestroyPipelineCache,
1661    get_pipeline_cache_data: PFN_vkGetPipelineCacheData,
1662    merge_pipeline_caches: PFN_vkMergePipelineCaches,
1663    create_graphics_pipelines: PFN_vkCreateGraphicsPipelines,
1664    create_compute_pipelines: PFN_vkCreateComputePipelines,
1665    destroy_pipeline: PFN_vkDestroyPipeline,
1666    create_pipeline_layout: PFN_vkCreatePipelineLayout,
1667    destroy_pipeline_layout: PFN_vkDestroyPipelineLayout,
1668    create_sampler: PFN_vkCreateSampler,
1669    destroy_sampler: PFN_vkDestroySampler,
1670    create_descriptor_set_layout: PFN_vkCreateDescriptorSetLayout,
1671    destroy_descriptor_set_layout: PFN_vkDestroyDescriptorSetLayout,
1672    create_descriptor_pool: PFN_vkCreateDescriptorPool,
1673    destroy_descriptor_pool: PFN_vkDestroyDescriptorPool,
1674    reset_descriptor_pool: PFN_vkResetDescriptorPool,
1675    allocate_descriptor_sets: PFN_vkAllocateDescriptorSets,
1676    free_descriptor_sets: PFN_vkFreeDescriptorSets,
1677    update_descriptor_sets: PFN_vkUpdateDescriptorSets,
1678    create_framebuffer: PFN_vkCreateFramebuffer,
1679    destroy_framebuffer: PFN_vkDestroyFramebuffer,
1680    create_render_pass: PFN_vkCreateRenderPass,
1681    destroy_render_pass: PFN_vkDestroyRenderPass,
1682    get_render_area_granularity: PFN_vkGetRenderAreaGranularity,
1683    create_command_pool: PFN_vkCreateCommandPool,
1684    destroy_command_pool: PFN_vkDestroyCommandPool,
1685    reset_command_pool: PFN_vkResetCommandPool,
1686    allocate_command_buffers: PFN_vkAllocateCommandBuffers,
1687    free_command_buffers: PFN_vkFreeCommandBuffers,
1688    begin_command_buffer: PFN_vkBeginCommandBuffer,
1689    end_command_buffer: PFN_vkEndCommandBuffer,
1690    reset_command_buffer: PFN_vkResetCommandBuffer,
1691    cmd_bind_pipeline: PFN_vkCmdBindPipeline,
1692    cmd_set_viewport: PFN_vkCmdSetViewport,
1693    cmd_set_scissor: PFN_vkCmdSetScissor,
1694    cmd_set_line_width: PFN_vkCmdSetLineWidth,
1695    cmd_set_depth_bias: PFN_vkCmdSetDepthBias,
1696    cmd_set_blend_constants: PFN_vkCmdSetBlendConstants,
1697    cmd_set_depth_bounds: PFN_vkCmdSetDepthBounds,
1698    cmd_set_stencil_compare_mask: PFN_vkCmdSetStencilCompareMask,
1699    cmd_set_stencil_write_mask: PFN_vkCmdSetStencilWriteMask,
1700    cmd_set_stencil_reference: PFN_vkCmdSetStencilReference,
1701    cmd_bind_descriptor_sets: PFN_vkCmdBindDescriptorSets,
1702    cmd_bind_index_buffer: PFN_vkCmdBindIndexBuffer,
1703    cmd_bind_vertex_buffers: PFN_vkCmdBindVertexBuffers,
1704    cmd_draw: PFN_vkCmdDraw,
1705    cmd_draw_indexed: PFN_vkCmdDrawIndexed,
1706    cmd_draw_indirect: PFN_vkCmdDrawIndirect,
1707    cmd_draw_indexed_indirect: PFN_vkCmdDrawIndexedIndirect,
1708    cmd_dispatch: PFN_vkCmdDispatch,
1709    cmd_dispatch_indirect: PFN_vkCmdDispatchIndirect,
1710    cmd_copy_buffer: PFN_vkCmdCopyBuffer,
1711    cmd_copy_image: PFN_vkCmdCopyImage,
1712    cmd_blit_image: PFN_vkCmdBlitImage,
1713    cmd_copy_buffer_to_image: PFN_vkCmdCopyBufferToImage,
1714    cmd_copy_image_to_buffer: PFN_vkCmdCopyImageToBuffer,
1715    cmd_update_buffer: PFN_vkCmdUpdateBuffer,
1716    cmd_fill_buffer: PFN_vkCmdFillBuffer,
1717    cmd_clear_color_image: PFN_vkCmdClearColorImage,
1718    cmd_clear_depth_stencil_image: PFN_vkCmdClearDepthStencilImage,
1719    cmd_clear_attachments: PFN_vkCmdClearAttachments,
1720    cmd_resolve_image: PFN_vkCmdResolveImage,
1721    cmd_set_event: PFN_vkCmdSetEvent,
1722    cmd_reset_event: PFN_vkCmdResetEvent,
1723    cmd_wait_events: PFN_vkCmdWaitEvents,
1724    cmd_pipeline_barrier: PFN_vkCmdPipelineBarrier,
1725    cmd_begin_query: PFN_vkCmdBeginQuery,
1726    cmd_end_query: PFN_vkCmdEndQuery,
1727    cmd_reset_query_pool: PFN_vkCmdResetQueryPool,
1728    cmd_write_timestamp: PFN_vkCmdWriteTimestamp,
1729    cmd_copy_query_pool_results: PFN_vkCmdCopyQueryPoolResults,
1730    cmd_push_constants: PFN_vkCmdPushConstants,
1731    cmd_begin_render_pass: PFN_vkCmdBeginRenderPass,
1732    cmd_next_subpass: PFN_vkCmdNextSubpass,
1733    cmd_end_render_pass: PFN_vkCmdEndRenderPass,
1734    cmd_execute_commands: PFN_vkCmdExecuteCommands,
1735    #[cfg(feature = "Allow1_1APIs")]
1736    enumerate_instance_version: PFN_vkEnumerateInstanceVersion,
1737    #[cfg(feature = "Allow1_1APIs")]
1738    trim_command_pool: PFN_vkTrimCommandPool,
1739    #[cfg(feature = "VK_KHR_surface")]
1740    destroy_surface_khr: PFN_vkDestroySurfaceKHR,
1741    #[cfg(feature = "VK_KHR_surface")]
1742    get_physical_device_surface_support_khr: PFN_vkGetPhysicalDeviceSurfaceSupportKHR,
1743    #[cfg(feature = "VK_KHR_surface")]
1744    get_physical_device_surface_capabilities_khr: PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
1745    #[cfg(feature = "VK_KHR_surface")]
1746    get_physical_device_surface_formats_khr: PFN_vkGetPhysicalDeviceSurfaceFormatsKHR,
1747    #[cfg(feature = "VK_KHR_surface")]
1748    get_physical_device_surface_present_modes_khr: PFN_vkGetPhysicalDeviceSurfacePresentModesKHR,
1749    #[cfg(feature = "VK_KHR_swapchain")]
1750    create_swapchain_khr: PFN_vkCreateSwapchainKHR,
1751    #[cfg(feature = "VK_KHR_swapchain")]
1752    destroy_swapchain_khr: PFN_vkDestroySwapchainKHR,
1753    #[cfg(feature = "VK_KHR_swapchain")]
1754    get_swapchain_images_khr: PFN_vkGetSwapchainImagesKHR,
1755    #[cfg(feature = "VK_KHR_swapchain")]
1756    acquire_next_image_khr: PFN_vkAcquireNextImageKHR,
1757    #[cfg(feature = "VK_KHR_swapchain")]
1758    queue_present_khr: PFN_vkQueuePresentKHR,
1759    #[cfg(feature = "VK_KHR_xlib_surface")]
1760    create_xlib_surface_khr: PFN_vkCreateXlibSurfaceKHR,
1761    #[cfg(feature = "VK_KHR_xlib_surface")]
1762    get_physical_device_xlib_presentation_support_khr: PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR,
1763    #[cfg(feature = "VK_KHR_xcb_surface")]
1764    create_xcb_surface_khr: PFN_vkCreateXcbSurfaceKHR,
1765    #[cfg(feature = "VK_KHR_xcb_surface")]
1766    get_physical_device_xcb_presentation_support_khr: PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR,
1767    #[cfg(feature = "VK_KHR_wayland_surface")]
1768    create_wayland_surface_khr: PFN_vkCreateWaylandSurfaceKHR,
1769    #[cfg(feature = "VK_KHR_wayland_surface")]
1770    get_physical_device_wayland_presentation_support_khr: PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR,
1771    #[cfg(feature = "VK_KHR_android_surface")]
1772    create_android_surface_khr: PFN_vkCreateAndroidSurfaceKHR,
1773    #[cfg(feature = "VK_KHR_win32_surface")]
1774    create_win32_surface_khr: PFN_vkCreateWin32SurfaceKHR,
1775    #[cfg(feature = "VK_KHR_win32_surface")]
1776    get_physical_device_win32_presentation_support_khr: PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR,
1777    #[cfg(feature = "VK_MVK_macos_surface")]
1778    create_macos_surface_mvk: PFN_vkCreateMacOSSurfaceMVK,
1779    #[cfg(feature = "VK_EXT_metal_surface")]
1780    create_metal_surface_ext: PFN_vkCreateMetalSurfaceEXT,
1781    #[cfg(feature = "VK_KHR_display")]
1782    get_physical_device_display_properties_khr: PFN_vkGetPhysicalDeviceDisplayPropertiesKHR,
1783    #[cfg(feature = "VK_KHR_display")]
1784    get_physical_device_display_plane_properties_khr: PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR,
1785    #[cfg(feature = "VK_KHR_display")]
1786    get_display_plane_supported_displays_khr: PFN_vkGetDisplayPlaneSupportedDisplaysKHR,
1787    #[cfg(feature = "VK_KHR_display")]
1788    get_display_mode_properties_khr: PFN_vkGetDisplayModePropertiesKHR,
1789    #[cfg(feature = "VK_KHR_display")]
1790    create_display_mode_khr: PFN_vkCreateDisplayModeKHR,
1791    #[cfg(feature = "VK_KHR_display")]
1792    get_display_plane_capabilities_khr: PFN_vkGetDisplayPlaneCapabilitiesKHR,
1793    #[cfg(all(feature = "VK_KHR_display", feature = "VK_KHR_surface"))]
1794    create_display_plane_surface_khr: PFN_vkCreateDisplayPlaneSurfaceKHR,
1795    #[cfg(feature = "Allow1_1APIs")]
1796    get_physical_device_features2: PFN_vkGetPhysicalDeviceFeatures2,
1797    #[cfg(feature = "Allow1_1APIs")]
1798    get_physical_device_format_properties2: PFN_vkGetPhysicalDeviceFormatProperties2,
1799    #[cfg(feature = "Allow1_1APIs")]
1800    get_physical_device_image_format_properties2: PFN_vkGetPhysicalDeviceImageFormatProperties2,
1801    #[cfg(feature = "Allow1_1APIs")]
1802    get_physical_device_memory_properties2: PFN_vkGetPhysicalDeviceMemoryProperties2,
1803    #[cfg(feature = "Allow1_1APIs")]
1804    get_physical_device_properties2: PFN_vkGetPhysicalDeviceProperties2,
1805    #[cfg(feature = "Allow1_1APIs")]
1806    get_physical_device_queue_family_properties2: PFN_vkGetPhysicalDeviceQueueFamilyProperties2,
1807    #[cfg(feature = "Allow1_1APIs")]
1808    get_physical_device_sparse_image_format_properties2: PFN_vkGetPhysicalDeviceSparseImageFormatProperties2,
1809    #[cfg(feature = "Allow1_1APIs")]
1810    create_descriptor_update_template: PFN_vkCreateDescriptorUpdateTemplate,
1811    #[cfg(feature = "Allow1_1APIs")]
1812    destroy_descriptor_update_template: PFN_vkDestroyDescriptorUpdateTemplate,
1813    #[cfg(feature = "Allow1_1APIs")]
1814    update_descriptor_set_with_template: PFN_vkUpdateDescriptorSetWithTemplate,
1815    #[cfg(feature = "Allow1_1APIs")]
1816    get_buffer_memory_requirements2: PFN_vkGetBufferMemoryRequirements2,
1817    #[cfg(feature = "Allow1_1APIs")]
1818    get_image_memory_requirements2: PFN_vkGetImageMemoryRequirements2,
1819    #[cfg(feature = "Allow1_1APIs")]
1820    get_image_sparse_memory_requirements2: PFN_vkGetImageSparseMemoryRequirements2,
1821    #[cfg(feature = "Allow1_1APIs")]
1822    bind_buffer_memory2: PFN_vkBindBufferMemory2,
1823    #[cfg(feature = "Allow1_1APIs")]
1824    bind_image_memory2: PFN_vkBindImageMemory2,
1825    #[cfg(feature = "Allow1_2APIs")]
1826    create_render_pass2: PFN_vkCreateRenderPass2,
1827    #[cfg(feature = "Allow1_2APIs")]
1828    get_semaphore_counter_value: PFN_vkGetSemaphoreCounterValue,
1829    #[cfg(feature = "Allow1_2APIs")]
1830    signal_semaphore: PFN_vkSignalSemaphore,
1831    #[cfg(feature = "Allow1_2APIs")]
1832    wait_semaphores: PFN_vkWaitSemaphores,
1833    #[cfg(feature = "Allow1_2APIs")]
1834    cmd_begin_render_pass2: PFN_vkCmdBeginRenderPass2,
1835    #[cfg(feature = "Allow1_2APIs")]
1836    cmd_next_subpass2: PFN_vkCmdNextSubpass2,
1837    #[cfg(feature = "Allow1_2APIs")]
1838    cmd_end_render_pass2: PFN_vkCmdEndRenderPass2,
1839    #[cfg(feature = "Allow1_3APIs")]
1840    cmd_pipeline_barrier2: PFN_vkCmdPipelineBarrier2,
1841    #[cfg(feature = "Allow1_3APIs")]
1842    queue_submit2: PFN_vkQueueSubmit2,
1843    #[cfg(feature = "Allow1_4APIs")]
1844    cmd_push_descriptor_set: PFN_vkCmdPushDescriptorSet
1845}
1846#[rustfmt::skip]
1847#[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
1848static mut FPTBL: FunctionPointerTable = FunctionPointerTable::INIT;
1849
1850#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
1851impl FunctionPointerTable {
1852    const INIT: Self = Self {
1853        create_instance: PFN_vkCreateInstance(stub_create_instance),
1854        destroy_instance: PFN_vkDestroyInstance(stub_destroy_instance),
1855        enumerate_physical_devices: PFN_vkEnumeratePhysicalDevices(stub_enumerate_physical_devices),
1856        get_physical_device_features: PFN_vkGetPhysicalDeviceFeatures(stub_get_physical_device_features),
1857        get_physical_device_format_properties: PFN_vkGetPhysicalDeviceFormatProperties(stub_get_physical_device_format_properties),
1858        get_physical_device_image_format_properties: PFN_vkGetPhysicalDeviceImageFormatProperties(stub_get_physical_device_image_format_properties),
1859        get_physical_device_properties: PFN_vkGetPhysicalDeviceProperties(stub_get_physical_device_properties),
1860        get_physical_device_queue_family_properties: PFN_vkGetPhysicalDeviceQueueFamilyProperties(stub_get_physical_device_queue_family_properties),
1861        get_physical_device_memory_properties: PFN_vkGetPhysicalDeviceMemoryProperties(stub_get_physical_device_memory_properties),
1862        get_instance_proc_addr: PFN_vkGetInstanceProcAddr(stub_get_instance_proc_addr),
1863        get_device_proc_addr: PFN_vkGetDeviceProcAddr(stub_get_device_proc_addr),
1864        create_device: PFN_vkCreateDevice(stub_create_device),
1865        destroy_device: PFN_vkDestroyDevice(stub_destroy_device),
1866        enumerate_instance_extension_properties: PFN_vkEnumerateInstanceExtensionProperties(stub_enumerate_instance_extension_properties),
1867        enumerate_device_extension_properties: PFN_vkEnumerateDeviceExtensionProperties(stub_enumerate_device_extension_properties),
1868        enumerate_instance_layer_properties: PFN_vkEnumerateInstanceLayerProperties(stub_enumerate_instance_layer_properties),
1869        enumerate_device_layer_properties: PFN_vkEnumerateDeviceLayerProperties(stub_enumerate_device_layer_properties),
1870        get_device_queue: PFN_vkGetDeviceQueue(stub_get_device_queue),
1871        queue_submit: PFN_vkQueueSubmit(stub_queue_submit),
1872        queue_wait_idle: PFN_vkQueueWaitIdle(stub_queue_wait_idle),
1873        device_wait_idle: PFN_vkDeviceWaitIdle(stub_device_wait_idle),
1874        allocate_memory: PFN_vkAllocateMemory(stub_allocate_memory),
1875        free_memory: PFN_vkFreeMemory(stub_free_memory),
1876        map_memory: PFN_vkMapMemory(stub_map_memory),
1877        unmap_memory: PFN_vkUnmapMemory(stub_unmap_memory),
1878        flush_mapped_memory_ranges: PFN_vkFlushMappedMemoryRanges(stub_flush_mapped_memory_ranges),
1879        invalidate_mapped_memory_ranges: PFN_vkInvalidateMappedMemoryRanges(stub_invalidate_mapped_memory_ranges),
1880        get_device_memory_commitment: PFN_vkGetDeviceMemoryCommitment(stub_get_device_memory_commitment),
1881        bind_buffer_memory: PFN_vkBindBufferMemory(stub_bind_buffer_memory),
1882        bind_image_memory: PFN_vkBindImageMemory(stub_bind_image_memory),
1883        get_buffer_memory_requirements: PFN_vkGetBufferMemoryRequirements(stub_get_buffer_memory_requirements),
1884        get_image_memory_requirements: PFN_vkGetImageMemoryRequirements(stub_get_image_memory_requirements),
1885        get_image_sparse_memory_requirements: PFN_vkGetImageSparseMemoryRequirements(stub_get_image_sparse_memory_requirements),
1886        get_physical_device_sparse_image_format_properties: PFN_vkGetPhysicalDeviceSparseImageFormatProperties(stub_get_physical_device_sparse_image_format_properties),
1887        queue_bind_sparse: PFN_vkQueueBindSparse(stub_queue_bind_sparse),
1888        create_fence: PFN_vkCreateFence(stub_create_fence),
1889        destroy_fence: PFN_vkDestroyFence(stub_destroy_fence),
1890        reset_fences: PFN_vkResetFences(stub_reset_fences),
1891        get_fence_status: PFN_vkGetFenceStatus(stub_get_fence_status),
1892        wait_for_fences: PFN_vkWaitForFences(stub_wait_for_fences),
1893        create_semaphore: PFN_vkCreateSemaphore(stub_create_semaphore),
1894        destroy_semaphore: PFN_vkDestroySemaphore(stub_destroy_semaphore),
1895        create_event: PFN_vkCreateEvent(stub_create_event),
1896        destroy_event: PFN_vkDestroyEvent(stub_destroy_event),
1897        get_event_status: PFN_vkGetEventStatus(stub_get_event_status),
1898        set_event: PFN_vkSetEvent(stub_set_event),
1899        reset_event: PFN_vkResetEvent(stub_reset_event),
1900        create_query_pool: PFN_vkCreateQueryPool(stub_create_query_pool),
1901        destroy_query_pool: PFN_vkDestroyQueryPool(stub_destroy_query_pool),
1902        get_query_pool_results: PFN_vkGetQueryPoolResults(stub_get_query_pool_results),
1903        create_buffer: PFN_vkCreateBuffer(stub_create_buffer),
1904        destroy_buffer: PFN_vkDestroyBuffer(stub_destroy_buffer),
1905        create_buffer_view: PFN_vkCreateBufferView(stub_create_buffer_view),
1906        destroy_buffer_view: PFN_vkDestroyBufferView(stub_destroy_buffer_view),
1907        create_image: PFN_vkCreateImage(stub_create_image),
1908        destroy_image: PFN_vkDestroyImage(stub_destroy_image),
1909        get_image_subresource_layout: PFN_vkGetImageSubresourceLayout(stub_get_image_subresource_layout),
1910        create_image_view: PFN_vkCreateImageView(stub_create_image_view),
1911        destroy_image_view: PFN_vkDestroyImageView(stub_destroy_image_view),
1912        create_shader_module: PFN_vkCreateShaderModule(stub_create_shader_module),
1913        destroy_shader_module: PFN_vkDestroyShaderModule(stub_destroy_shader_module),
1914        create_pipeline_cache: PFN_vkCreatePipelineCache(stub_create_pipeline_cache),
1915        destroy_pipeline_cache: PFN_vkDestroyPipelineCache(stub_destroy_pipeline_cache),
1916        get_pipeline_cache_data: PFN_vkGetPipelineCacheData(stub_get_pipeline_cache_data),
1917        merge_pipeline_caches: PFN_vkMergePipelineCaches(stub_merge_pipeline_caches),
1918        create_graphics_pipelines: PFN_vkCreateGraphicsPipelines(stub_create_graphics_pipelines),
1919        create_compute_pipelines: PFN_vkCreateComputePipelines(stub_create_compute_pipelines),
1920        destroy_pipeline: PFN_vkDestroyPipeline(stub_destroy_pipeline),
1921        create_pipeline_layout: PFN_vkCreatePipelineLayout(stub_create_pipeline_layout),
1922        destroy_pipeline_layout: PFN_vkDestroyPipelineLayout(stub_destroy_pipeline_layout),
1923        create_sampler: PFN_vkCreateSampler(stub_create_sampler),
1924        destroy_sampler: PFN_vkDestroySampler(stub_destroy_sampler),
1925        create_descriptor_set_layout: PFN_vkCreateDescriptorSetLayout(stub_create_descriptor_set_layout),
1926        destroy_descriptor_set_layout: PFN_vkDestroyDescriptorSetLayout(stub_destroy_descriptor_set_layout),
1927        create_descriptor_pool: PFN_vkCreateDescriptorPool(stub_create_descriptor_pool),
1928        destroy_descriptor_pool: PFN_vkDestroyDescriptorPool(stub_destroy_descriptor_pool),
1929        reset_descriptor_pool: PFN_vkResetDescriptorPool(stub_reset_descriptor_pool),
1930        allocate_descriptor_sets: PFN_vkAllocateDescriptorSets(stub_allocate_descriptor_sets),
1931        free_descriptor_sets: PFN_vkFreeDescriptorSets(stub_free_descriptor_sets),
1932        update_descriptor_sets: PFN_vkUpdateDescriptorSets(stub_update_descriptor_sets),
1933        create_framebuffer: PFN_vkCreateFramebuffer(stub_create_framebuffer),
1934        destroy_framebuffer: PFN_vkDestroyFramebuffer(stub_destroy_framebuffer),
1935        create_render_pass: PFN_vkCreateRenderPass(stub_create_render_pass),
1936        destroy_render_pass: PFN_vkDestroyRenderPass(stub_destroy_render_pass),
1937        get_render_area_granularity: PFN_vkGetRenderAreaGranularity(stub_get_render_area_granularity),
1938        create_command_pool: PFN_vkCreateCommandPool(stub_create_command_pool),
1939        destroy_command_pool: PFN_vkDestroyCommandPool(stub_destroy_command_pool),
1940        reset_command_pool: PFN_vkResetCommandPool(stub_reset_command_pool),
1941        allocate_command_buffers: PFN_vkAllocateCommandBuffers(stub_allocate_command_buffers),
1942        free_command_buffers: PFN_vkFreeCommandBuffers(stub_free_command_buffers),
1943        begin_command_buffer: PFN_vkBeginCommandBuffer(stub_begin_command_buffer),
1944        end_command_buffer: PFN_vkEndCommandBuffer(stub_end_command_buffer),
1945        reset_command_buffer: PFN_vkResetCommandBuffer(stub_reset_command_buffer),
1946        cmd_bind_pipeline: PFN_vkCmdBindPipeline(stub_cmd_bind_pipeline),
1947        cmd_set_viewport: PFN_vkCmdSetViewport(stub_cmd_set_viewport),
1948        cmd_set_scissor: PFN_vkCmdSetScissor(stub_cmd_set_scissor),
1949        cmd_set_line_width: PFN_vkCmdSetLineWidth(stub_cmd_set_line_width),
1950        cmd_set_depth_bias: PFN_vkCmdSetDepthBias(stub_cmd_set_depth_bias),
1951        cmd_set_blend_constants: PFN_vkCmdSetBlendConstants(stub_cmd_set_blend_constants),
1952        cmd_set_depth_bounds: PFN_vkCmdSetDepthBounds(stub_cmd_set_depth_bounds),
1953        cmd_set_stencil_compare_mask: PFN_vkCmdSetStencilCompareMask(stub_cmd_set_stencil_compare_mask),
1954        cmd_set_stencil_write_mask: PFN_vkCmdSetStencilWriteMask(stub_cmd_set_stencil_write_mask),
1955        cmd_set_stencil_reference: PFN_vkCmdSetStencilReference(stub_cmd_set_stencil_reference),
1956        cmd_bind_descriptor_sets: PFN_vkCmdBindDescriptorSets(stub_cmd_bind_descriptor_sets),
1957        cmd_bind_index_buffer: PFN_vkCmdBindIndexBuffer(stub_cmd_bind_index_buffer),
1958        cmd_bind_vertex_buffers: PFN_vkCmdBindVertexBuffers(stub_cmd_bind_vertex_buffers),
1959        cmd_draw: PFN_vkCmdDraw(stub_cmd_draw),
1960        cmd_draw_indexed: PFN_vkCmdDrawIndexed(stub_cmd_draw_indexed),
1961        cmd_draw_indirect: PFN_vkCmdDrawIndirect(stub_cmd_draw_indirect),
1962        cmd_draw_indexed_indirect: PFN_vkCmdDrawIndexedIndirect(stub_cmd_draw_indexed_indirect),
1963        cmd_dispatch: PFN_vkCmdDispatch(stub_cmd_dispatch),
1964        cmd_dispatch_indirect: PFN_vkCmdDispatchIndirect(stub_cmd_dispatch_indirect),
1965        cmd_copy_buffer: PFN_vkCmdCopyBuffer(stub_cmd_copy_buffer),
1966        cmd_copy_image: PFN_vkCmdCopyImage(stub_cmd_copy_image),
1967        cmd_blit_image: PFN_vkCmdBlitImage(stub_cmd_blit_image),
1968        cmd_copy_buffer_to_image: PFN_vkCmdCopyBufferToImage(stub_cmd_copy_buffer_to_image),
1969        cmd_copy_image_to_buffer: PFN_vkCmdCopyImageToBuffer(stub_cmd_copy_image_to_buffer),
1970        cmd_update_buffer: PFN_vkCmdUpdateBuffer(stub_cmd_update_buffer),
1971        cmd_fill_buffer: PFN_vkCmdFillBuffer(stub_cmd_fill_buffer),
1972        cmd_clear_color_image: PFN_vkCmdClearColorImage(stub_cmd_clear_color_image),
1973        cmd_clear_depth_stencil_image: PFN_vkCmdClearDepthStencilImage(stub_cmd_clear_depth_stencil_image),
1974        cmd_clear_attachments: PFN_vkCmdClearAttachments(stub_cmd_clear_attachments),
1975        cmd_resolve_image: PFN_vkCmdResolveImage(stub_cmd_resolve_image),
1976        cmd_set_event: PFN_vkCmdSetEvent(stub_cmd_set_event),
1977        cmd_reset_event: PFN_vkCmdResetEvent(stub_cmd_reset_event),
1978        cmd_wait_events: PFN_vkCmdWaitEvents(stub_cmd_wait_events),
1979        cmd_pipeline_barrier: PFN_vkCmdPipelineBarrier(stub_cmd_pipeline_barrier),
1980        cmd_begin_query: PFN_vkCmdBeginQuery(stub_cmd_begin_query),
1981        cmd_end_query: PFN_vkCmdEndQuery(stub_cmd_end_query),
1982        cmd_reset_query_pool: PFN_vkCmdResetQueryPool(stub_cmd_reset_query_pool),
1983        cmd_write_timestamp: PFN_vkCmdWriteTimestamp(stub_cmd_write_timestamp),
1984        cmd_copy_query_pool_results: PFN_vkCmdCopyQueryPoolResults(stub_cmd_copy_query_pool_results),
1985        cmd_push_constants: PFN_vkCmdPushConstants(stub_cmd_push_constants),
1986        cmd_begin_render_pass: PFN_vkCmdBeginRenderPass(stub_cmd_begin_render_pass),
1987        cmd_next_subpass: PFN_vkCmdNextSubpass(stub_cmd_next_subpass),
1988        cmd_end_render_pass: PFN_vkCmdEndRenderPass(stub_cmd_end_render_pass),
1989        cmd_execute_commands: PFN_vkCmdExecuteCommands(stub_cmd_execute_commands),
1990        #[cfg(feature = "Allow1_1APIs")]
1991        enumerate_instance_version: PFN_vkEnumerateInstanceVersion(stub_enumerate_instance_version),
1992        #[cfg(feature = "Allow1_1APIs")]
1993        trim_command_pool: PFN_vkTrimCommandPool(stub_trim_command_pool),
1994        #[cfg(feature = "VK_KHR_surface")]
1995        destroy_surface_khr: PFN_vkDestroySurfaceKHR(stub_destroy_surface_khr),
1996        #[cfg(feature = "VK_KHR_surface")]
1997        get_physical_device_surface_support_khr: PFN_vkGetPhysicalDeviceSurfaceSupportKHR(stub_get_physical_device_surface_support_khr),
1998        #[cfg(feature = "VK_KHR_surface")]
1999        get_physical_device_surface_capabilities_khr: PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(stub_get_physical_device_surface_capabilities_khr),
2000        #[cfg(feature = "VK_KHR_surface")]
2001        get_physical_device_surface_formats_khr: PFN_vkGetPhysicalDeviceSurfaceFormatsKHR(stub_get_physical_device_surface_formats_khr),
2002        #[cfg(feature = "VK_KHR_surface")]
2003        get_physical_device_surface_present_modes_khr: PFN_vkGetPhysicalDeviceSurfacePresentModesKHR(stub_get_physical_device_surface_present_modes_khr),
2004        #[cfg(feature = "VK_KHR_swapchain")]
2005        create_swapchain_khr: PFN_vkCreateSwapchainKHR(stub_create_swapchain_khr),
2006        #[cfg(feature = "VK_KHR_swapchain")]
2007        destroy_swapchain_khr: PFN_vkDestroySwapchainKHR(stub_destroy_swapchain_khr),
2008        #[cfg(feature = "VK_KHR_swapchain")]
2009        get_swapchain_images_khr: PFN_vkGetSwapchainImagesKHR(stub_get_swapchain_images_khr),
2010        #[cfg(feature = "VK_KHR_swapchain")]
2011        acquire_next_image_khr: PFN_vkAcquireNextImageKHR(stub_acquire_next_image_khr),
2012        #[cfg(feature = "VK_KHR_swapchain")]
2013        queue_present_khr: PFN_vkQueuePresentKHR(stub_queue_present_khr),
2014        #[cfg(feature = "VK_KHR_xlib_surface")]
2015        create_xlib_surface_khr: PFN_vkCreateXlibSurfaceKHR(stub_create_xlib_surface_khr),
2016        #[cfg(feature = "VK_KHR_xlib_surface")]
2017        get_physical_device_xlib_presentation_support_khr: PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR(stub_get_physical_device_xlib_presentation_support_khr),
2018        #[cfg(feature = "VK_KHR_xcb_surface")]
2019        create_xcb_surface_khr: PFN_vkCreateXcbSurfaceKHR(stub_create_xcb_surface_khr),
2020        #[cfg(feature = "VK_KHR_xcb_surface")]
2021        get_physical_device_xcb_presentation_support_khr: PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR(stub_get_physical_device_xcb_presentation_support_khr),
2022        #[cfg(feature = "VK_KHR_wayland_surface")]
2023        create_wayland_surface_khr: PFN_vkCreateWaylandSurfaceKHR(stub_create_wayland_surface_khr),
2024        #[cfg(feature = "VK_KHR_wayland_surface")]
2025        get_physical_device_wayland_presentation_support_khr: PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR(stub_get_physical_device_wayland_presentation_support_khr),
2026        #[cfg(feature = "VK_KHR_android_surface")]
2027        create_android_surface_khr: PFN_vkCreateAndroidSurfaceKHR(stub_create_android_surface_khr),
2028        #[cfg(feature = "VK_KHR_win32_surface")]
2029        create_win32_surface_khr: PFN_vkCreateWin32SurfaceKHR(stub_create_win32_surface_khr),
2030        #[cfg(feature = "VK_KHR_win32_surface")]
2031        get_physical_device_win32_presentation_support_khr: PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR(stub_get_physical_device_win32_presentation_support_khr),
2032        #[cfg(feature = "VK_MVK_macos_surface")]
2033        create_macos_surface_mvk: PFN_vkCreateMacOSSurfaceMVK(stub_create_macos_surface_mvk),
2034        #[cfg(feature = "VK_EXT_metal_surface")]
2035        create_metal_surface_ext: PFN_vkCreateMetalSurfaceEXT(stub_create_metal_surface_ext),
2036        #[cfg(feature = "VK_KHR_display")]
2037        get_physical_device_display_properties_khr: PFN_vkGetPhysicalDeviceDisplayPropertiesKHR(stub_get_physical_device_display_properties_khr),
2038        #[cfg(feature = "VK_KHR_display")]
2039        get_physical_device_display_plane_properties_khr: PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(stub_get_physical_device_display_plane_properties_khr),
2040        #[cfg(feature = "VK_KHR_display")]
2041        get_display_plane_supported_displays_khr: PFN_vkGetDisplayPlaneSupportedDisplaysKHR(stub_get_display_plane_supported_displays_khr),
2042        #[cfg(feature = "VK_KHR_display")]
2043        get_display_mode_properties_khr: PFN_vkGetDisplayModePropertiesKHR(stub_get_display_mode_properties_khr),
2044        #[cfg(feature = "VK_KHR_display")]
2045        create_display_mode_khr: PFN_vkCreateDisplayModeKHR(stub_create_display_mode_khr),
2046        #[cfg(feature = "VK_KHR_display")]
2047        get_display_plane_capabilities_khr: PFN_vkGetDisplayPlaneCapabilitiesKHR(stub_get_display_plane_capabilities_khr),
2048        #[cfg(all(feature = "VK_KHR_display", feature = "VK_KHR_surface"))]
2049        create_display_plane_surface_khr: PFN_vkCreateDisplayPlaneSurfaceKHR(stub_create_display_plane_surface_khr),
2050        #[cfg(feature = "Allow1_1APIs")]
2051        get_physical_device_features2: PFN_vkGetPhysicalDeviceFeatures2(stub_get_physical_device_features2),
2052        #[cfg(feature = "Allow1_1APIs")]
2053        get_physical_device_format_properties2: PFN_vkGetPhysicalDeviceFormatProperties2(stub_get_physical_device_format_properties2),
2054        #[cfg(feature = "Allow1_1APIs")]
2055        get_physical_device_image_format_properties2: PFN_vkGetPhysicalDeviceImageFormatProperties2(stub_get_physical_device_image_format_properties2),
2056        #[cfg(feature = "Allow1_1APIs")]
2057        get_physical_device_memory_properties2: PFN_vkGetPhysicalDeviceMemoryProperties2(stub_get_physical_device_memory_properties2),
2058        #[cfg(feature = "Allow1_1APIs")]
2059        get_physical_device_properties2: PFN_vkGetPhysicalDeviceProperties2(stub_get_physical_device_properties2),
2060        #[cfg(feature = "Allow1_1APIs")]
2061        get_physical_device_queue_family_properties2: PFN_vkGetPhysicalDeviceQueueFamilyProperties2(stub_get_physical_device_queue_family_properties2),
2062        #[cfg(feature = "Allow1_1APIs")]
2063        get_physical_device_sparse_image_format_properties2: PFN_vkGetPhysicalDeviceSparseImageFormatProperties2(stub_get_physical_device_sparse_image_format_properties2),
2064        #[cfg(feature = "Allow1_1APIs")]
2065        create_descriptor_update_template: PFN_vkCreateDescriptorUpdateTemplate(stub_create_descriptor_update_template),
2066        #[cfg(feature = "Allow1_1APIs")]
2067        destroy_descriptor_update_template: PFN_vkDestroyDescriptorUpdateTemplate(stub_destroy_descriptor_update_template),
2068        #[cfg(feature = "Allow1_1APIs")]
2069        update_descriptor_set_with_template: PFN_vkUpdateDescriptorSetWithTemplate(stub_update_descriptor_set_with_template),
2070        #[cfg(feature = "Allow1_1APIs")]
2071        get_buffer_memory_requirements2: PFN_vkGetBufferMemoryRequirements2(stub_get_buffer_memory_requirements2),
2072        #[cfg(feature = "Allow1_1APIs")]
2073        get_image_memory_requirements2: PFN_vkGetImageMemoryRequirements2(stub_get_image_memory_requirements2),
2074        #[cfg(feature = "Allow1_1APIs")]
2075        get_image_sparse_memory_requirements2: PFN_vkGetImageSparseMemoryRequirements2(stub_get_image_sparse_memory_requirements2),
2076        #[cfg(feature = "Allow1_1APIs")]
2077        bind_buffer_memory2: PFN_vkBindBufferMemory2(stub_bind_buffer_memory2),
2078        #[cfg(feature = "Allow1_1APIs")]
2079        bind_image_memory2: PFN_vkBindImageMemory2(stub_bind_image_memory2),
2080        #[cfg(feature = "Allow1_2APIs")]
2081        create_render_pass2: PFN_vkCreateRenderPass2(stub_create_render_pass2),
2082        #[cfg(feature = "Allow1_2APIs")]
2083        get_semaphore_counter_value: PFN_vkGetSemaphoreCounterValue(stub_get_semaphore_counter_value),
2084        #[cfg(feature = "Allow1_2APIs")]
2085        signal_semaphore: PFN_vkSignalSemaphore(stub_signal_semaphore),
2086        #[cfg(feature = "Allow1_2APIs")]
2087        wait_semaphores: PFN_vkWaitSemaphores(stub_wait_semaphores),
2088        #[cfg(feature = "Allow1_2APIs")]
2089        cmd_begin_render_pass2: PFN_vkCmdBeginRenderPass2(stub_cmd_begin_render_pass2),
2090        #[cfg(feature = "Allow1_2APIs")]
2091        cmd_next_subpass2: PFN_vkCmdNextSubpass2(stub_cmd_next_subpass2),
2092        #[cfg(feature = "Allow1_2APIs")]
2093        cmd_end_render_pass2: PFN_vkCmdEndRenderPass2(stub_cmd_end_render_pass2),
2094        #[cfg(feature = "Allow1_3APIs")]
2095        cmd_pipeline_barrier2: PFN_vkCmdPipelineBarrier2(stub_cmd_pipeline_barrier2),
2096        #[cfg(feature = "Allow1_3APIs")]
2097        queue_submit2: PFN_vkQueueSubmit2(stub_queue_submit2),
2098        #[cfg(feature = "Allow1_4APIs")]
2099        cmd_push_descriptor_set: PFN_vkCmdPushDescriptorSet(stub_cmd_push_descriptor_set)
2100    };
2101    #[inline(always)] #[rustfmt::skip] #[allow(dead_code)] pub(crate) fn reset() { unsafe { FPTBL = Self::INIT; } }
2102}
2103
2104#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2105unsafe extern "system" fn stub_create_instance(create_info: *const VkInstanceCreateInfo, allocator: *const VkAllocationCallbacks, instance_out: *mut VkInstance) -> VkResult {
2106    let fp: PFN_vkCreateInstance = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2107    unsafe { FPTBL.create_instance = fp; }
2108    unsafe { (fp.0)(create_info, allocator, instance_out) }
2109}
2110#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2111unsafe extern "system" fn stub_destroy_instance(instance: VkInstance, allocator: *const VkAllocationCallbacks) {
2112    let fp: PFN_vkDestroyInstance = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2113    unsafe { FPTBL.destroy_instance = fp; }
2114    unsafe { (fp.0)(instance, allocator) }
2115}
2116#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2117unsafe extern "system" fn stub_enumerate_physical_devices(instance: VkInstance, physical_devices_count_out: *mut u32, physical_devices_out: *mut VkPhysicalDevice) -> VkResult {
2118    let fp: PFN_vkEnumeratePhysicalDevices = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2119    unsafe { FPTBL.enumerate_physical_devices = fp; }
2120    unsafe { (fp.0)(instance, physical_devices_count_out, physical_devices_out) }
2121}
2122#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2123unsafe extern "system" fn stub_get_physical_device_features(physical_device: VkPhysicalDevice, features_out: *mut VkPhysicalDeviceFeatures) {
2124    let fp: PFN_vkGetPhysicalDeviceFeatures = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2125    unsafe { FPTBL.get_physical_device_features = fp; }
2126    unsafe { (fp.0)(physical_device, features_out) }
2127}
2128#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2129unsafe extern "system" fn stub_get_physical_device_format_properties(physical_device: VkPhysicalDevice, format: VkFormat, format_properties_out: *mut VkFormatProperties) {
2130    let fp: PFN_vkGetPhysicalDeviceFormatProperties = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2131    unsafe { FPTBL.get_physical_device_format_properties = fp; }
2132    unsafe { (fp.0)(physical_device, format, format_properties_out) }
2133}
2134#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2135unsafe extern "system" fn stub_get_physical_device_image_format_properties(physical_device: VkPhysicalDevice, format: VkFormat, image_type: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, image_format_properties_out: *mut VkImageFormatProperties) -> VkResult {
2136    let fp: PFN_vkGetPhysicalDeviceImageFormatProperties = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2137    unsafe { FPTBL.get_physical_device_image_format_properties = fp; }
2138    unsafe { (fp.0)(physical_device, format, image_type, tiling, usage, flags, image_format_properties_out) }
2139}
2140#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2141unsafe extern "system" fn stub_get_physical_device_properties(physical_device: VkPhysicalDevice, properties_out: *mut VkPhysicalDeviceProperties) {
2142    let fp: PFN_vkGetPhysicalDeviceProperties = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2143    unsafe { FPTBL.get_physical_device_properties = fp; }
2144    unsafe { (fp.0)(physical_device, properties_out) }
2145}
2146#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2147unsafe extern "system" fn stub_get_physical_device_queue_family_properties(physical_device: VkPhysicalDevice, queue_family_properties_count_out: *mut u32, queue_family_properties_out: *mut VkQueueFamilyProperties) {
2148    let fp: PFN_vkGetPhysicalDeviceQueueFamilyProperties = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2149    unsafe { FPTBL.get_physical_device_queue_family_properties = fp; }
2150    unsafe { (fp.0)(physical_device, queue_family_properties_count_out, queue_family_properties_out) }
2151}
2152#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2153unsafe extern "system" fn stub_get_physical_device_memory_properties(physical_device: VkPhysicalDevice, memory_properties_out: *mut VkPhysicalDeviceMemoryProperties) {
2154    let fp: PFN_vkGetPhysicalDeviceMemoryProperties = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2155    unsafe { FPTBL.get_physical_device_memory_properties = fp; }
2156    unsafe { (fp.0)(physical_device, memory_properties_out) }
2157}
2158#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2159unsafe extern "system" fn stub_get_instance_proc_addr(instance: VkInstance, name: *const c_char) -> Option<PFN_vkVoidFunction> {
2160    let fp: PFN_vkGetInstanceProcAddr = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2161    unsafe { FPTBL.get_instance_proc_addr = fp; }
2162    unsafe { (fp.0)(instance, name) }
2163}
2164#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2165unsafe extern "system" fn stub_get_device_proc_addr(device: VkDevice, name: *const c_char) -> Option<PFN_vkVoidFunction> {
2166    let fp: PFN_vkGetDeviceProcAddr = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2167    unsafe { FPTBL.get_device_proc_addr = fp; }
2168    unsafe { (fp.0)(device, name) }
2169}
2170#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2171unsafe extern "system" fn stub_create_device(physical_device: VkPhysicalDevice, create_info: *const VkDeviceCreateInfo, allocator: *const VkAllocationCallbacks, device_out: *mut VkDevice) -> VkResult {
2172    let fp: PFN_vkCreateDevice = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2173    unsafe { FPTBL.create_device = fp; }
2174    unsafe { (fp.0)(physical_device, create_info, allocator, device_out) }
2175}
2176#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2177unsafe extern "system" fn stub_destroy_device(device: VkDevice, allocator: *const VkAllocationCallbacks) {
2178    let fp: PFN_vkDestroyDevice = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2179    unsafe { FPTBL.destroy_device = fp; }
2180    unsafe { (fp.0)(device, allocator) }
2181}
2182#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2183unsafe extern "system" fn stub_enumerate_instance_extension_properties(layer_name: *const c_char, property_count_out: *mut u32, properties_out: *mut VkExtensionProperties) -> VkResult {
2184    let fp: PFN_vkEnumerateInstanceExtensionProperties = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2185    unsafe { FPTBL.enumerate_instance_extension_properties = fp; }
2186    unsafe { (fp.0)(layer_name, property_count_out, properties_out) }
2187}
2188#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2189unsafe extern "system" fn stub_enumerate_device_extension_properties(physical_device: VkPhysicalDevice, layer_name: *const c_char, property_count_out: *mut u32, properties_out: *mut VkExtensionProperties) -> VkResult {
2190    let fp: PFN_vkEnumerateDeviceExtensionProperties = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2191    unsafe { FPTBL.enumerate_device_extension_properties = fp; }
2192    unsafe { (fp.0)(physical_device, layer_name, property_count_out, properties_out) }
2193}
2194#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2195unsafe extern "system" fn stub_enumerate_instance_layer_properties(property_count_out: *mut u32, properties_out: *mut VkLayerProperties) -> VkResult {
2196    let fp: PFN_vkEnumerateInstanceLayerProperties = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2197    unsafe { FPTBL.enumerate_instance_layer_properties = fp; }
2198    unsafe { (fp.0)(property_count_out, properties_out) }
2199}
2200#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2201unsafe extern "system" fn stub_enumerate_device_layer_properties(physical_device: VkPhysicalDevice, property_count_out: *mut u32, properties_out: *mut VkLayerProperties) -> VkResult {
2202    let fp: PFN_vkEnumerateDeviceLayerProperties = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2203    unsafe { FPTBL.enumerate_device_layer_properties = fp; }
2204    unsafe { (fp.0)(physical_device, property_count_out, properties_out) }
2205}
2206#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2207unsafe extern "system" fn stub_get_device_queue(device: VkDevice, queue_family_index: u32, queue_index: u32, queue_out: *mut VkQueue) {
2208    let fp: PFN_vkGetDeviceQueue = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2209    unsafe { FPTBL.get_device_queue = fp; }
2210    unsafe { (fp.0)(device, queue_family_index, queue_index, queue_out) }
2211}
2212#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2213unsafe extern "system" fn stub_queue_submit(queue: VkQueue, submit_count: u32, submits: *const VkSubmitInfo, fence: Option<VkFence>) -> VkResult {
2214    let fp: PFN_vkQueueSubmit = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2215    unsafe { FPTBL.queue_submit = fp; }
2216    unsafe { (fp.0)(queue, submit_count, submits, fence) }
2217}
2218#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2219unsafe extern "system" fn stub_queue_wait_idle(queue: VkQueue) -> VkResult {
2220    let fp: PFN_vkQueueWaitIdle = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2221    unsafe { FPTBL.queue_wait_idle = fp; }
2222    unsafe { (fp.0)(queue) }
2223}
2224#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2225unsafe extern "system" fn stub_device_wait_idle(device: VkDevice) -> VkResult {
2226    let fp: PFN_vkDeviceWaitIdle = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2227    unsafe { FPTBL.device_wait_idle = fp; }
2228    unsafe { (fp.0)(device) }
2229}
2230#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2231unsafe extern "system" fn stub_allocate_memory(device: VkDevice, allocate_info: *const VkMemoryAllocateInfo, allocator: *const VkAllocationCallbacks, memory_out: *mut VkDeviceMemory) -> VkResult {
2232    let fp: PFN_vkAllocateMemory = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2233    unsafe { FPTBL.allocate_memory = fp; }
2234    unsafe { (fp.0)(device, allocate_info, allocator, memory_out) }
2235}
2236#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2237unsafe extern "system" fn stub_free_memory(device: VkDevice, memory: VkDeviceMemory, allocator: *const VkAllocationCallbacks) {
2238    let fp: PFN_vkFreeMemory = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2239    unsafe { FPTBL.free_memory = fp; }
2240    unsafe { (fp.0)(device, memory, allocator) }
2241}
2242#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2243unsafe extern "system" fn stub_map_memory(device: VkDevice, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize, flags: VkMemoryMapFlags, data_ptr_out: *mut *mut c_void) -> VkResult {
2244    let fp: PFN_vkMapMemory = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2245    unsafe { FPTBL.map_memory = fp; }
2246    unsafe { (fp.0)(device, memory, offset, size, flags, data_ptr_out) }
2247}
2248#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2249unsafe extern "system" fn stub_unmap_memory(device: VkDevice, memory: VkDeviceMemory) {
2250    let fp: PFN_vkUnmapMemory = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2251    unsafe { FPTBL.unmap_memory = fp; }
2252    unsafe { (fp.0)(device, memory) }
2253}
2254#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2255unsafe extern "system" fn stub_flush_mapped_memory_ranges(device: VkDevice, memory_range_count: u32, memory_ranges: *const VkMappedMemoryRange) -> VkResult {
2256    let fp: PFN_vkFlushMappedMemoryRanges = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2257    unsafe { FPTBL.flush_mapped_memory_ranges = fp; }
2258    unsafe { (fp.0)(device, memory_range_count, memory_ranges) }
2259}
2260#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2261unsafe extern "system" fn stub_invalidate_mapped_memory_ranges(device: VkDevice, memory_range_count: u32, memory_ranges: *const VkMappedMemoryRange) -> VkResult {
2262    let fp: PFN_vkInvalidateMappedMemoryRanges = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2263    unsafe { FPTBL.invalidate_mapped_memory_ranges = fp; }
2264    unsafe { (fp.0)(device, memory_range_count, memory_ranges) }
2265}
2266#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2267unsafe extern "system" fn stub_get_device_memory_commitment(device: VkDevice, memory: VkDeviceMemory, committed_memory_bytes_out: *mut VkDeviceSize) {
2268    let fp: PFN_vkGetDeviceMemoryCommitment = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2269    unsafe { FPTBL.get_device_memory_commitment = fp; }
2270    unsafe { (fp.0)(device, memory, committed_memory_bytes_out) }
2271}
2272#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2273unsafe extern "system" fn stub_bind_buffer_memory(device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memory_offset: VkDeviceSize) -> VkResult {
2274    let fp: PFN_vkBindBufferMemory = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2275    unsafe { FPTBL.bind_buffer_memory = fp; }
2276    unsafe { (fp.0)(device, buffer, memory, memory_offset) }
2277}
2278#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2279unsafe extern "system" fn stub_bind_image_memory(device: VkDevice, image: VkImage, memory: VkDeviceMemory, memory_offset: VkDeviceSize) -> VkResult {
2280    let fp: PFN_vkBindImageMemory = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2281    unsafe { FPTBL.bind_image_memory = fp; }
2282    unsafe { (fp.0)(device, image, memory, memory_offset) }
2283}
2284#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2285unsafe extern "system" fn stub_get_buffer_memory_requirements(device: VkDevice, buffer: VkBuffer, memory_requirements_out: *mut VkMemoryRequirements) {
2286    let fp: PFN_vkGetBufferMemoryRequirements = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2287    unsafe { FPTBL.get_buffer_memory_requirements = fp; }
2288    unsafe { (fp.0)(device, buffer, memory_requirements_out) }
2289}
2290#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2291unsafe extern "system" fn stub_get_image_memory_requirements(device: VkDevice, image: VkImage, memory_requirements_out: *mut VkMemoryRequirements) {
2292    let fp: PFN_vkGetImageMemoryRequirements = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2293    unsafe { FPTBL.get_image_memory_requirements = fp; }
2294    unsafe { (fp.0)(device, image, memory_requirements_out) }
2295}
2296#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2297unsafe extern "system" fn stub_get_image_sparse_memory_requirements(device: VkDevice, image: VkImage, sparse_memory_requirement_count_out: *mut u32, sparse_memory_requirements_out: *mut VkSparseImageMemoryRequirements) {
2298    let fp: PFN_vkGetImageSparseMemoryRequirements = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2299    unsafe { FPTBL.get_image_sparse_memory_requirements = fp; }
2300    unsafe { (fp.0)(device, image, sparse_memory_requirement_count_out, sparse_memory_requirements_out) }
2301}
2302#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2303unsafe extern "system" fn stub_get_physical_device_sparse_image_format_properties(physical_device: VkPhysicalDevice, format: VkFormat, r#type: VkImageType, samples: VkSampleCountFlags, usage: VkImageUsageFlags, tiling: VkImageTiling, property_count_out: *mut u32, properties_out: *mut VkSparseImageFormatProperties) {
2304    let fp: PFN_vkGetPhysicalDeviceSparseImageFormatProperties = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2305    unsafe { FPTBL.get_physical_device_sparse_image_format_properties = fp; }
2306    unsafe { (fp.0)(physical_device, format, r#type, samples, usage, tiling, property_count_out, properties_out) }
2307}
2308#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2309unsafe extern "system" fn stub_queue_bind_sparse(queue: VkQueue, bind_info_count: u32, bind_info: *const VkBindSparseInfo, fence: Option<VkFence>) -> VkResult {
2310    let fp: PFN_vkQueueBindSparse = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2311    unsafe { FPTBL.queue_bind_sparse = fp; }
2312    unsafe { (fp.0)(queue, bind_info_count, bind_info, fence) }
2313}
2314#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2315unsafe extern "system" fn stub_create_fence(device: VkDevice, create_info: *const VkFenceCreateInfo, allocator: *const VkAllocationCallbacks, fence_out: *mut VkFence) -> VkResult {
2316    let fp: PFN_vkCreateFence = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2317    unsafe { FPTBL.create_fence = fp; }
2318    unsafe { (fp.0)(device, create_info, allocator, fence_out) }
2319}
2320#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2321unsafe extern "system" fn stub_destroy_fence(device: VkDevice, fence: VkFence, allocator: *const VkAllocationCallbacks) {
2322    let fp: PFN_vkDestroyFence = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2323    unsafe { FPTBL.destroy_fence = fp; }
2324    unsafe { (fp.0)(device, fence, allocator) }
2325}
2326#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2327unsafe extern "system" fn stub_reset_fences(device: VkDevice, fence_count: u32, fences: *const VkFence) -> VkResult {
2328    let fp: PFN_vkResetFences = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2329    unsafe { FPTBL.reset_fences = fp; }
2330    unsafe { (fp.0)(device, fence_count, fences) }
2331}
2332#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2333unsafe extern "system" fn stub_get_fence_status(device: VkDevice, fence: VkFence) -> VkResult {
2334    let fp: PFN_vkGetFenceStatus = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2335    unsafe { FPTBL.get_fence_status = fp; }
2336    unsafe { (fp.0)(device, fence) }
2337}
2338#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2339unsafe extern "system" fn stub_wait_for_fences(device: VkDevice, fence_count: u32, fences: *const VkFence, wait_all: VkBool32, timeout: u64) -> VkResult {
2340    let fp: PFN_vkWaitForFences = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2341    unsafe { FPTBL.wait_for_fences = fp; }
2342    unsafe { (fp.0)(device, fence_count, fences, wait_all, timeout) }
2343}
2344#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2345unsafe extern "system" fn stub_create_semaphore(device: VkDevice, create_info: *const VkSemaphoreCreateInfo, allocator: *const VkAllocationCallbacks, semaphore_out: *mut VkSemaphore) -> VkResult {
2346    let fp: PFN_vkCreateSemaphore = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2347    unsafe { FPTBL.create_semaphore = fp; }
2348    unsafe { (fp.0)(device, create_info, allocator, semaphore_out) }
2349}
2350#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2351unsafe extern "system" fn stub_destroy_semaphore(device: VkDevice, semaphore: VkSemaphore, allocator: *const VkAllocationCallbacks) {
2352    let fp: PFN_vkDestroySemaphore = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2353    unsafe { FPTBL.destroy_semaphore = fp; }
2354    unsafe { (fp.0)(device, semaphore, allocator) }
2355}
2356#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2357unsafe extern "system" fn stub_create_event(device: VkDevice, create_info: *const VkEventCreateInfo, allocator: *const VkAllocationCallbacks, event_out: *mut VkEvent) -> VkResult {
2358    let fp: PFN_vkCreateEvent = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2359    unsafe { FPTBL.create_event = fp; }
2360    unsafe { (fp.0)(device, create_info, allocator, event_out) }
2361}
2362#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2363unsafe extern "system" fn stub_destroy_event(device: VkDevice, event: VkEvent, allocator: *const VkAllocationCallbacks) {
2364    let fp: PFN_vkDestroyEvent = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2365    unsafe { FPTBL.destroy_event = fp; }
2366    unsafe { (fp.0)(device, event, allocator) }
2367}
2368#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2369unsafe extern "system" fn stub_get_event_status(device: VkDevice, event: VkEvent) -> VkResult {
2370    let fp: PFN_vkGetEventStatus = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2371    unsafe { FPTBL.get_event_status = fp; }
2372    unsafe { (fp.0)(device, event) }
2373}
2374#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2375unsafe extern "system" fn stub_set_event(device: VkDevice, event: VkEvent) -> VkResult {
2376    let fp: PFN_vkSetEvent = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2377    unsafe { FPTBL.set_event = fp; }
2378    unsafe { (fp.0)(device, event) }
2379}
2380#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2381unsafe extern "system" fn stub_reset_event(device: VkDevice, event: VkEvent) -> VkResult {
2382    let fp: PFN_vkResetEvent = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2383    unsafe { FPTBL.reset_event = fp; }
2384    unsafe { (fp.0)(device, event) }
2385}
2386#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2387unsafe extern "system" fn stub_create_query_pool(device: VkDevice, create_info: *const VkQueryPoolCreateInfo, allocator: *const VkAllocationCallbacks, query_pool_out: *mut VkQueryPool) -> VkResult {
2388    let fp: PFN_vkCreateQueryPool = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2389    unsafe { FPTBL.create_query_pool = fp; }
2390    unsafe { (fp.0)(device, create_info, allocator, query_pool_out) }
2391}
2392#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2393unsafe extern "system" fn stub_destroy_query_pool(device: VkDevice, query_pool: VkQueryPool, allocator: *const VkAllocationCallbacks) {
2394    let fp: PFN_vkDestroyQueryPool = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2395    unsafe { FPTBL.destroy_query_pool = fp; }
2396    unsafe { (fp.0)(device, query_pool, allocator) }
2397}
2398#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2399unsafe extern "system" fn stub_get_query_pool_results(device: VkDevice, query_pool: VkQueryPool, first_query: u32, query_count: u32, data_size: usize, data_out: *mut c_void, stride: VkDeviceSize, flags: VkQueryResultFlags) -> VkResult {
2400    let fp: PFN_vkGetQueryPoolResults = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2401    unsafe { FPTBL.get_query_pool_results = fp; }
2402    unsafe { (fp.0)(device, query_pool, first_query, query_count, data_size, data_out, stride, flags) }
2403}
2404#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2405unsafe extern "system" fn stub_create_buffer(device: VkDevice, create_info: *const VkBufferCreateInfo, allocator: *const VkAllocationCallbacks, buffer_out: *mut VkBuffer) -> VkResult {
2406    let fp: PFN_vkCreateBuffer = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2407    unsafe { FPTBL.create_buffer = fp; }
2408    unsafe { (fp.0)(device, create_info, allocator, buffer_out) }
2409}
2410#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2411unsafe extern "system" fn stub_destroy_buffer(device: VkDevice, buffer: VkBuffer, allocator: *const VkAllocationCallbacks) {
2412    let fp: PFN_vkDestroyBuffer = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2413    unsafe { FPTBL.destroy_buffer = fp; }
2414    unsafe { (fp.0)(device, buffer, allocator) }
2415}
2416#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2417unsafe extern "system" fn stub_create_buffer_view(device: VkDevice, create_info: *const VkBufferViewCreateInfo, allocator: *const VkAllocationCallbacks, view_out: *mut VkBufferView) -> VkResult {
2418    let fp: PFN_vkCreateBufferView = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2419    unsafe { FPTBL.create_buffer_view = fp; }
2420    unsafe { (fp.0)(device, create_info, allocator, view_out) }
2421}
2422#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2423unsafe extern "system" fn stub_destroy_buffer_view(device: VkDevice, buffer_view: VkBufferView, allocator: *const VkAllocationCallbacks) {
2424    let fp: PFN_vkDestroyBufferView = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2425    unsafe { FPTBL.destroy_buffer_view = fp; }
2426    unsafe { (fp.0)(device, buffer_view, allocator) }
2427}
2428#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2429unsafe extern "system" fn stub_create_image(device: VkDevice, create_info: *const VkImageCreateInfo, allocator: *const VkAllocationCallbacks, image_out: *mut VkImage) -> VkResult {
2430    let fp: PFN_vkCreateImage = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2431    unsafe { FPTBL.create_image = fp; }
2432    unsafe { (fp.0)(device, create_info, allocator, image_out) }
2433}
2434#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2435unsafe extern "system" fn stub_destroy_image(device: VkDevice, image: VkImage, allocator: *const VkAllocationCallbacks) {
2436    let fp: PFN_vkDestroyImage = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2437    unsafe { FPTBL.destroy_image = fp; }
2438    unsafe { (fp.0)(device, image, allocator) }
2439}
2440#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2441unsafe extern "system" fn stub_get_image_subresource_layout(device: VkDevice, image: VkImage, subresource: *const VkImageSubresource, layout_out: *mut VkSubresourceLayout) {
2442    let fp: PFN_vkGetImageSubresourceLayout = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2443    unsafe { FPTBL.get_image_subresource_layout = fp; }
2444    unsafe { (fp.0)(device, image, subresource, layout_out) }
2445}
2446#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2447unsafe extern "system" fn stub_create_image_view(device: VkDevice, create_info: *const VkImageViewCreateInfo, allocator: *const VkAllocationCallbacks, view_out: *mut VkImageView) -> VkResult {
2448    let fp: PFN_vkCreateImageView = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2449    unsafe { FPTBL.create_image_view = fp; }
2450    unsafe { (fp.0)(device, create_info, allocator, view_out) }
2451}
2452#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2453unsafe extern "system" fn stub_destroy_image_view(device: VkDevice, image_view: VkImageView, allocator: *const VkAllocationCallbacks) {
2454    let fp: PFN_vkDestroyImageView = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2455    unsafe { FPTBL.destroy_image_view = fp; }
2456    unsafe { (fp.0)(device, image_view, allocator) }
2457}
2458#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2459unsafe extern "system" fn stub_create_shader_module(device: VkDevice, create_info: *const VkShaderModuleCreateInfo, allocator: *const VkAllocationCallbacks, shader_module_out: *mut VkShaderModule) -> VkResult {
2460    let fp: PFN_vkCreateShaderModule = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2461    unsafe { FPTBL.create_shader_module = fp; }
2462    unsafe { (fp.0)(device, create_info, allocator, shader_module_out) }
2463}
2464#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2465unsafe extern "system" fn stub_destroy_shader_module(device: VkDevice, shader_module: VkShaderModule, allocator: *const VkAllocationCallbacks) {
2466    let fp: PFN_vkDestroyShaderModule = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2467    unsafe { FPTBL.destroy_shader_module = fp; }
2468    unsafe { (fp.0)(device, shader_module, allocator) }
2469}
2470#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2471unsafe extern "system" fn stub_create_pipeline_cache(device: VkDevice, create_info: *const VkPipelineCacheCreateInfo, allocator: *const VkAllocationCallbacks, pipeline_cache_out: *mut VkPipelineCache) -> VkResult {
2472    let fp: PFN_vkCreatePipelineCache = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2473    unsafe { FPTBL.create_pipeline_cache = fp; }
2474    unsafe { (fp.0)(device, create_info, allocator, pipeline_cache_out) }
2475}
2476#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2477unsafe extern "system" fn stub_destroy_pipeline_cache(device: VkDevice, pipeline_cache: VkPipelineCache, allocator: *const VkAllocationCallbacks) {
2478    let fp: PFN_vkDestroyPipelineCache = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2479    unsafe { FPTBL.destroy_pipeline_cache = fp; }
2480    unsafe { (fp.0)(device, pipeline_cache, allocator) }
2481}
2482#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2483unsafe extern "system" fn stub_get_pipeline_cache_data(device: VkDevice, pipeline_cache: VkPipelineCache, data_size_out: *mut usize, data_out: *mut c_void) -> VkResult {
2484    let fp: PFN_vkGetPipelineCacheData = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2485    unsafe { FPTBL.get_pipeline_cache_data = fp; }
2486    unsafe { (fp.0)(device, pipeline_cache, data_size_out, data_out) }
2487}
2488#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2489unsafe extern "system" fn stub_merge_pipeline_caches(device: VkDevice, dst_cache: VkPipelineCache, src_cache_count: u32, src_caches: *const VkPipelineCache) -> VkResult {
2490    let fp: PFN_vkMergePipelineCaches = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2491    unsafe { FPTBL.merge_pipeline_caches = fp; }
2492    unsafe { (fp.0)(device, dst_cache, src_cache_count, src_caches) }
2493}
2494#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2495unsafe extern "system" fn stub_create_graphics_pipelines(device: VkDevice, pipeline_cache: Option<VkPipelineCache>, create_info_count: u32, create_infos: *const VkGraphicsPipelineCreateInfo, allocator: *const VkAllocationCallbacks, pipelines_out: *mut VkPipeline) -> VkResult {
2496    let fp: PFN_vkCreateGraphicsPipelines = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2497    unsafe { FPTBL.create_graphics_pipelines = fp; }
2498    unsafe { (fp.0)(device, pipeline_cache, create_info_count, create_infos, allocator, pipelines_out) }
2499}
2500#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2501unsafe extern "system" fn stub_create_compute_pipelines(device: VkDevice, pipeline_cache: Option<VkPipelineCache>, create_info_count: u32, create_infos: *const VkComputePipelineCreateInfo, allocator: *const VkAllocationCallbacks, pipelines_out: *mut VkPipeline) -> VkResult {
2502    let fp: PFN_vkCreateComputePipelines = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2503    unsafe { FPTBL.create_compute_pipelines = fp; }
2504    unsafe { (fp.0)(device, pipeline_cache, create_info_count, create_infos, allocator, pipelines_out) }
2505}
2506#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2507unsafe extern "system" fn stub_destroy_pipeline(device: VkDevice, pipeline: VkPipeline, allocator: *const VkAllocationCallbacks) {
2508    let fp: PFN_vkDestroyPipeline = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2509    unsafe { FPTBL.destroy_pipeline = fp; }
2510    unsafe { (fp.0)(device, pipeline, allocator) }
2511}
2512#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2513unsafe extern "system" fn stub_create_pipeline_layout(device: VkDevice, create_info: *const VkPipelineLayoutCreateInfo, allocator: *const VkAllocationCallbacks, pipeline_layout_out: *mut VkPipelineLayout) -> VkResult {
2514    let fp: PFN_vkCreatePipelineLayout = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2515    unsafe { FPTBL.create_pipeline_layout = fp; }
2516    unsafe { (fp.0)(device, create_info, allocator, pipeline_layout_out) }
2517}
2518#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2519unsafe extern "system" fn stub_destroy_pipeline_layout(device: VkDevice, pipeline_layout: VkPipelineLayout, allocator: *const VkAllocationCallbacks) {
2520    let fp: PFN_vkDestroyPipelineLayout = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2521    unsafe { FPTBL.destroy_pipeline_layout = fp; }
2522    unsafe { (fp.0)(device, pipeline_layout, allocator) }
2523}
2524#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2525unsafe extern "system" fn stub_create_sampler(device: VkDevice, create_info: *const VkSamplerCreateInfo, allocator: *const VkAllocationCallbacks, sampler_out: *mut VkSampler) -> VkResult {
2526    let fp: PFN_vkCreateSampler = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2527    unsafe { FPTBL.create_sampler = fp; }
2528    unsafe { (fp.0)(device, create_info, allocator, sampler_out) }
2529}
2530#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2531unsafe extern "system" fn stub_destroy_sampler(device: VkDevice, sampler: VkSampler, allocator: *const VkAllocationCallbacks) {
2532    let fp: PFN_vkDestroySampler = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2533    unsafe { FPTBL.destroy_sampler = fp; }
2534    unsafe { (fp.0)(device, sampler, allocator) }
2535}
2536#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2537unsafe extern "system" fn stub_create_descriptor_set_layout(device: VkDevice, create_info: *const VkDescriptorSetLayoutCreateInfo, allocator: *const VkAllocationCallbacks, set_layout_out: *mut VkDescriptorSetLayout) -> VkResult {
2538    let fp: PFN_vkCreateDescriptorSetLayout = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2539    unsafe { FPTBL.create_descriptor_set_layout = fp; }
2540    unsafe { (fp.0)(device, create_info, allocator, set_layout_out) }
2541}
2542#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2543unsafe extern "system" fn stub_destroy_descriptor_set_layout(device: VkDevice, descriptor_set_layout: VkDescriptorSetLayout, allocator: *const VkAllocationCallbacks) {
2544    let fp: PFN_vkDestroyDescriptorSetLayout = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2545    unsafe { FPTBL.destroy_descriptor_set_layout = fp; }
2546    unsafe { (fp.0)(device, descriptor_set_layout, allocator) }
2547}
2548#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2549unsafe extern "system" fn stub_create_descriptor_pool(device: VkDevice, create_info: *const VkDescriptorPoolCreateInfo, allocator: *const VkAllocationCallbacks, descriptor_pool_out: *mut VkDescriptorPool) -> VkResult {
2550    let fp: PFN_vkCreateDescriptorPool = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2551    unsafe { FPTBL.create_descriptor_pool = fp; }
2552    unsafe { (fp.0)(device, create_info, allocator, descriptor_pool_out) }
2553}
2554#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2555unsafe extern "system" fn stub_destroy_descriptor_pool(device: VkDevice, descriptor_pool: VkDescriptorPool, allocator: *const VkAllocationCallbacks) {
2556    let fp: PFN_vkDestroyDescriptorPool = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2557    unsafe { FPTBL.destroy_descriptor_pool = fp; }
2558    unsafe { (fp.0)(device, descriptor_pool, allocator) }
2559}
2560#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2561unsafe extern "system" fn stub_reset_descriptor_pool(device: VkDevice, descriptor_pool: VkDescriptorPool, flags: VkDescriptorPoolResetFlags) -> VkResult {
2562    let fp: PFN_vkResetDescriptorPool = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2563    unsafe { FPTBL.reset_descriptor_pool = fp; }
2564    unsafe { (fp.0)(device, descriptor_pool, flags) }
2565}
2566#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2567unsafe extern "system" fn stub_allocate_descriptor_sets(device: VkDevice, allocate_info: *const VkDescriptorSetAllocateInfo, descriptor_sets_out: *mut VkDescriptorSet) -> VkResult {
2568    let fp: PFN_vkAllocateDescriptorSets = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2569    unsafe { FPTBL.allocate_descriptor_sets = fp; }
2570    unsafe { (fp.0)(device, allocate_info, descriptor_sets_out) }
2571}
2572#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2573unsafe extern "system" fn stub_free_descriptor_sets(device: VkDevice, descriptor_pool: VkDescriptorPool, descriptor_set_count: u32, descriptor_sets: *const VkDescriptorSet) -> VkResult {
2574    let fp: PFN_vkFreeDescriptorSets = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2575    unsafe { FPTBL.free_descriptor_sets = fp; }
2576    unsafe { (fp.0)(device, descriptor_pool, descriptor_set_count, descriptor_sets) }
2577}
2578#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2579unsafe extern "system" fn stub_update_descriptor_sets(device: VkDevice, descriptor_write_count: u32, descriptor_writes: *const VkWriteDescriptorSet, descriptor_copy_count: u32, descriptor_copies: *const VkCopyDescriptorSet) {
2580    let fp: PFN_vkUpdateDescriptorSets = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2581    unsafe { FPTBL.update_descriptor_sets = fp; }
2582    unsafe { (fp.0)(device, descriptor_write_count, descriptor_writes, descriptor_copy_count, descriptor_copies) }
2583}
2584#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2585unsafe extern "system" fn stub_create_framebuffer(device: VkDevice, create_info: *const VkFramebufferCreateInfo, allocator: *const VkAllocationCallbacks, framebuffer_out: *mut VkFramebuffer) -> VkResult {
2586    let fp: PFN_vkCreateFramebuffer = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2587    unsafe { FPTBL.create_framebuffer = fp; }
2588    unsafe { (fp.0)(device, create_info, allocator, framebuffer_out) }
2589}
2590#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2591unsafe extern "system" fn stub_destroy_framebuffer(device: VkDevice, framebuffer: VkFramebuffer, allocator: *const VkAllocationCallbacks) {
2592    let fp: PFN_vkDestroyFramebuffer = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2593    unsafe { FPTBL.destroy_framebuffer = fp; }
2594    unsafe { (fp.0)(device, framebuffer, allocator) }
2595}
2596#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2597unsafe extern "system" fn stub_create_render_pass(device: VkDevice, create_info: *const VkRenderPassCreateInfo, allocator: *const VkAllocationCallbacks, render_pass_out: *mut VkRenderPass) -> VkResult {
2598    let fp: PFN_vkCreateRenderPass = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2599    unsafe { FPTBL.create_render_pass = fp; }
2600    unsafe { (fp.0)(device, create_info, allocator, render_pass_out) }
2601}
2602#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2603unsafe extern "system" fn stub_destroy_render_pass(device: VkDevice, render_pass: VkRenderPass, allocator: *const VkAllocationCallbacks) {
2604    let fp: PFN_vkDestroyRenderPass = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2605    unsafe { FPTBL.destroy_render_pass = fp; }
2606    unsafe { (fp.0)(device, render_pass, allocator) }
2607}
2608#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2609unsafe extern "system" fn stub_get_render_area_granularity(device: VkDevice, render_pass: VkRenderPass, granularity_out: *mut VkExtent2D) {
2610    let fp: PFN_vkGetRenderAreaGranularity = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2611    unsafe { FPTBL.get_render_area_granularity = fp; }
2612    unsafe { (fp.0)(device, render_pass, granularity_out) }
2613}
2614#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2615unsafe extern "system" fn stub_create_command_pool(device: VkDevice, create_info: *const VkCommandPoolCreateInfo, allocator: *const VkAllocationCallbacks, command_pool_out: *mut VkCommandPool) -> VkResult {
2616    let fp: PFN_vkCreateCommandPool = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2617    unsafe { FPTBL.create_command_pool = fp; }
2618    unsafe { (fp.0)(device, create_info, allocator, command_pool_out) }
2619}
2620#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2621unsafe extern "system" fn stub_destroy_command_pool(device: VkDevice, command_pool: VkCommandPool, allocator: *const VkAllocationCallbacks) {
2622    let fp: PFN_vkDestroyCommandPool = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2623    unsafe { FPTBL.destroy_command_pool = fp; }
2624    unsafe { (fp.0)(device, command_pool, allocator) }
2625}
2626#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2627unsafe extern "system" fn stub_reset_command_pool(device: VkDevice, command_pool: VkCommandPool, flags: VkCommandPoolResetFlags) -> VkResult {
2628    let fp: PFN_vkResetCommandPool = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2629    unsafe { FPTBL.reset_command_pool = fp; }
2630    unsafe { (fp.0)(device, command_pool, flags) }
2631}
2632#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2633unsafe extern "system" fn stub_allocate_command_buffers(device: VkDevice, allocate_info: *const VkCommandBufferAllocateInfo, command_buffers_out: *mut VkCommandBuffer) -> VkResult {
2634    let fp: PFN_vkAllocateCommandBuffers = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2635    unsafe { FPTBL.allocate_command_buffers = fp; }
2636    unsafe { (fp.0)(device, allocate_info, command_buffers_out) }
2637}
2638#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2639unsafe extern "system" fn stub_free_command_buffers(device: VkDevice, command_pool: VkCommandPool, command_buffer_count: u32, command_buffers: *const VkCommandBuffer) {
2640    let fp: PFN_vkFreeCommandBuffers = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2641    unsafe { FPTBL.free_command_buffers = fp; }
2642    unsafe { (fp.0)(device, command_pool, command_buffer_count, command_buffers) }
2643}
2644#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2645unsafe extern "system" fn stub_begin_command_buffer(command_buffer: VkCommandBuffer, begin_info: *const VkCommandBufferBeginInfo) -> VkResult {
2646    let fp: PFN_vkBeginCommandBuffer = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2647    unsafe { FPTBL.begin_command_buffer = fp; }
2648    unsafe { (fp.0)(command_buffer, begin_info) }
2649}
2650#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2651unsafe extern "system" fn stub_end_command_buffer(command_buffer: VkCommandBuffer) -> VkResult {
2652    let fp: PFN_vkEndCommandBuffer = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2653    unsafe { FPTBL.end_command_buffer = fp; }
2654    unsafe { (fp.0)(command_buffer) }
2655}
2656#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2657unsafe extern "system" fn stub_reset_command_buffer(command_buffer: VkCommandBuffer, flags: VkCommandBufferResetFlags) -> VkResult {
2658    let fp: PFN_vkResetCommandBuffer = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2659    unsafe { FPTBL.reset_command_buffer = fp; }
2660    unsafe { (fp.0)(command_buffer, flags) }
2661}
2662#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2663unsafe extern "system" fn stub_cmd_bind_pipeline(command_buffer: VkCommandBuffer, pipeline_bind_point: VkPipelineBindPoint, pipeline: VkPipeline) {
2664    let fp: PFN_vkCmdBindPipeline = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2665    unsafe { FPTBL.cmd_bind_pipeline = fp; }
2666    unsafe { (fp.0)(command_buffer, pipeline_bind_point, pipeline) }
2667}
2668#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2669unsafe extern "system" fn stub_cmd_set_viewport(command_buffer: VkCommandBuffer, first_viewport: u32, viewport_count: u32, viewports: *const VkViewport) {
2670    let fp: PFN_vkCmdSetViewport = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2671    unsafe { FPTBL.cmd_set_viewport = fp; }
2672    unsafe { (fp.0)(command_buffer, first_viewport, viewport_count, viewports) }
2673}
2674#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2675unsafe extern "system" fn stub_cmd_set_scissor(command_buffer: VkCommandBuffer, first_scissor: u32, scissor_count: u32, scissors: *const VkRect2D) {
2676    let fp: PFN_vkCmdSetScissor = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2677    unsafe { FPTBL.cmd_set_scissor = fp; }
2678    unsafe { (fp.0)(command_buffer, first_scissor, scissor_count, scissors) }
2679}
2680#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2681unsafe extern "system" fn stub_cmd_set_line_width(command_buffer: VkCommandBuffer, line_width: c_float) {
2682    let fp: PFN_vkCmdSetLineWidth = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2683    unsafe { FPTBL.cmd_set_line_width = fp; }
2684    unsafe { (fp.0)(command_buffer, line_width) }
2685}
2686#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2687unsafe extern "system" fn stub_cmd_set_depth_bias(command_buffer: VkCommandBuffer, depth_bias_constant_factor: c_float, depth_bias_clamp: c_float, depth_bias_slope_factor: c_float) {
2688    let fp: PFN_vkCmdSetDepthBias = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2689    unsafe { FPTBL.cmd_set_depth_bias = fp; }
2690    unsafe { (fp.0)(command_buffer, depth_bias_constant_factor, depth_bias_clamp, depth_bias_slope_factor) }
2691}
2692#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2693unsafe extern "system" fn stub_cmd_set_blend_constants(command_buffer: VkCommandBuffer, blend_constants: *const c_float) {
2694    let fp: PFN_vkCmdSetBlendConstants = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2695    unsafe { FPTBL.cmd_set_blend_constants = fp; }
2696    unsafe { (fp.0)(command_buffer, blend_constants) }
2697}
2698#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2699unsafe extern "system" fn stub_cmd_set_depth_bounds(command_buffer: VkCommandBuffer, min_depth_bounds: c_float, max_depth_bounds: c_float) {
2700    let fp: PFN_vkCmdSetDepthBounds = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2701    unsafe { FPTBL.cmd_set_depth_bounds = fp; }
2702    unsafe { (fp.0)(command_buffer, min_depth_bounds, max_depth_bounds) }
2703}
2704#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2705unsafe extern "system" fn stub_cmd_set_stencil_compare_mask(command_buffer: VkCommandBuffer, face_mask: VkStencilFaceFlags, compare_mask: u32) {
2706    let fp: PFN_vkCmdSetStencilCompareMask = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2707    unsafe { FPTBL.cmd_set_stencil_compare_mask = fp; }
2708    unsafe { (fp.0)(command_buffer, face_mask, compare_mask) }
2709}
2710#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2711unsafe extern "system" fn stub_cmd_set_stencil_write_mask(command_buffer: VkCommandBuffer, face_mask: VkStencilFaceFlags, write_mask: u32) {
2712    let fp: PFN_vkCmdSetStencilWriteMask = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2713    unsafe { FPTBL.cmd_set_stencil_write_mask = fp; }
2714    unsafe { (fp.0)(command_buffer, face_mask, write_mask) }
2715}
2716#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2717unsafe extern "system" fn stub_cmd_set_stencil_reference(command_buffer: VkCommandBuffer, face_mask: VkStencilFaceFlags, reference: u32) {
2718    let fp: PFN_vkCmdSetStencilReference = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2719    unsafe { FPTBL.cmd_set_stencil_reference = fp; }
2720    unsafe { (fp.0)(command_buffer, face_mask, reference) }
2721}
2722#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2723unsafe extern "system" fn stub_cmd_bind_descriptor_sets(command_buffer: VkCommandBuffer, pipeline_bind_point: VkPipelineBindPoint, layout: VkPipelineLayout, first_set: u32, descriptor_set_count: u32, descriptor_sets: *const VkDescriptorSet, dynamic_offset_count: u32, dynamic_offsets: *const u32) {
2724    let fp: PFN_vkCmdBindDescriptorSets = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2725    unsafe { FPTBL.cmd_bind_descriptor_sets = fp; }
2726    unsafe { (fp.0)(command_buffer, pipeline_bind_point, layout, first_set, descriptor_set_count, descriptor_sets, dynamic_offset_count, dynamic_offsets) }
2727}
2728#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2729unsafe extern "system" fn stub_cmd_bind_index_buffer(command_buffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, index_type: VkIndexType) {
2730    let fp: PFN_vkCmdBindIndexBuffer = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2731    unsafe { FPTBL.cmd_bind_index_buffer = fp; }
2732    unsafe { (fp.0)(command_buffer, buffer, offset, index_type) }
2733}
2734#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2735unsafe extern "system" fn stub_cmd_bind_vertex_buffers(command_buffer: VkCommandBuffer, first_binding: u32, binding_count: u32, buffers: *const VkBuffer, offsets: *const VkDeviceSize) {
2736    let fp: PFN_vkCmdBindVertexBuffers = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2737    unsafe { FPTBL.cmd_bind_vertex_buffers = fp; }
2738    unsafe { (fp.0)(command_buffer, first_binding, binding_count, buffers, offsets) }
2739}
2740#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2741unsafe extern "system" fn stub_cmd_draw(command_buffer: VkCommandBuffer, vertex_count: u32, instance_count: u32, first_vertex: u32, first_index: u32) {
2742    let fp: PFN_vkCmdDraw = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2743    unsafe { FPTBL.cmd_draw = fp; }
2744    unsafe { (fp.0)(command_buffer, vertex_count, instance_count, first_vertex, first_index) }
2745}
2746#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2747unsafe extern "system" fn stub_cmd_draw_indexed(command_buffer: VkCommandBuffer, index_count: u32, instance_count: u32, first_index: u32, vertex_offset: i32, first_instance: u32) {
2748    let fp: PFN_vkCmdDrawIndexed = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2749    unsafe { FPTBL.cmd_draw_indexed = fp; }
2750    unsafe { (fp.0)(command_buffer, index_count, instance_count, first_index, vertex_offset, first_instance) }
2751}
2752#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2753unsafe extern "system" fn stub_cmd_draw_indirect(command_buffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, draw_count: u32, stride: u32) {
2754    let fp: PFN_vkCmdDrawIndirect = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2755    unsafe { FPTBL.cmd_draw_indirect = fp; }
2756    unsafe { (fp.0)(command_buffer, buffer, offset, draw_count, stride) }
2757}
2758#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2759unsafe extern "system" fn stub_cmd_draw_indexed_indirect(command_buffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, draw_count: u32, stride: u32) {
2760    let fp: PFN_vkCmdDrawIndexedIndirect = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2761    unsafe { FPTBL.cmd_draw_indexed_indirect = fp; }
2762    unsafe { (fp.0)(command_buffer, buffer, offset, draw_count, stride) }
2763}
2764#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2765unsafe extern "system" fn stub_cmd_dispatch(command_buffer: VkCommandBuffer, group_count_x: u32, group_count_y: u32, group_count_z: u32) {
2766    let fp: PFN_vkCmdDispatch = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2767    unsafe { FPTBL.cmd_dispatch = fp; }
2768    unsafe { (fp.0)(command_buffer, group_count_x, group_count_y, group_count_z) }
2769}
2770#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2771unsafe extern "system" fn stub_cmd_dispatch_indirect(command_buffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize) {
2772    let fp: PFN_vkCmdDispatchIndirect = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2773    unsafe { FPTBL.cmd_dispatch_indirect = fp; }
2774    unsafe { (fp.0)(command_buffer, buffer, offset) }
2775}
2776#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2777unsafe extern "system" fn stub_cmd_copy_buffer(command_buffer: VkCommandBuffer, src_buffer: VkBuffer, dst_buffer: VkBuffer, region_count: u32, regions: *const VkBufferCopy) {
2778    let fp: PFN_vkCmdCopyBuffer = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2779    unsafe { FPTBL.cmd_copy_buffer = fp; }
2780    unsafe { (fp.0)(command_buffer, src_buffer, dst_buffer, region_count, regions) }
2781}
2782#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2783unsafe extern "system" fn stub_cmd_copy_image(command_buffer: VkCommandBuffer, src_image: VkImage, src_image_layout: VkImageLayout, dst_image: VkImage, dst_image_layout: VkImageLayout, region_count: u32, regions: *const VkImageCopy) {
2784    let fp: PFN_vkCmdCopyImage = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2785    unsafe { FPTBL.cmd_copy_image = fp; }
2786    unsafe { (fp.0)(command_buffer, src_image, src_image_layout, dst_image, dst_image_layout, region_count, regions) }
2787}
2788#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2789unsafe extern "system" fn stub_cmd_blit_image(command_buffer: VkCommandBuffer, src_image: VkImage, src_image_layout: VkImageLayout, dst_image: VkImage, dst_image_layout: VkImageLayout, region_count: u32, regions: *const VkImageBlit, filter: VkFilter) {
2790    let fp: PFN_vkCmdBlitImage = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2791    unsafe { FPTBL.cmd_blit_image = fp; }
2792    unsafe { (fp.0)(command_buffer, src_image, src_image_layout, dst_image, dst_image_layout, region_count, regions, filter) }
2793}
2794#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2795unsafe extern "system" fn stub_cmd_copy_buffer_to_image(command_buffer: VkCommandBuffer, src_buffer: VkBuffer, dst_image: VkImage, dst_image_layout: VkImageLayout, region_count: u32, regions: *const VkBufferImageCopy) {
2796    let fp: PFN_vkCmdCopyBufferToImage = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2797    unsafe { FPTBL.cmd_copy_buffer_to_image = fp; }
2798    unsafe { (fp.0)(command_buffer, src_buffer, dst_image, dst_image_layout, region_count, regions) }
2799}
2800#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2801unsafe extern "system" fn stub_cmd_copy_image_to_buffer(command_buffer: VkCommandBuffer, src_image: VkImage, src_image_layout: VkImageLayout, dst_buffer: VkBuffer, region_count: u32, regions: *const VkBufferImageCopy) {
2802    let fp: PFN_vkCmdCopyImageToBuffer = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2803    unsafe { FPTBL.cmd_copy_image_to_buffer = fp; }
2804    unsafe { (fp.0)(command_buffer, src_image, src_image_layout, dst_buffer, region_count, regions) }
2805}
2806#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2807unsafe extern "system" fn stub_cmd_update_buffer(command_buffer: VkCommandBuffer, dst_buffer: VkBuffer, dst_offset: VkDeviceSize, data_size: VkDeviceSize, data: *const c_void) {
2808    let fp: PFN_vkCmdUpdateBuffer = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2809    unsafe { FPTBL.cmd_update_buffer = fp; }
2810    unsafe { (fp.0)(command_buffer, dst_buffer, dst_offset, data_size, data) }
2811}
2812#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2813unsafe extern "system" fn stub_cmd_fill_buffer(command_buffer: VkCommandBuffer, dst_buffer: VkBuffer, dst_offset: VkDeviceSize, size: VkDeviceSize, data: u32) {
2814    let fp: PFN_vkCmdFillBuffer = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2815    unsafe { FPTBL.cmd_fill_buffer = fp; }
2816    unsafe { (fp.0)(command_buffer, dst_buffer, dst_offset, size, data) }
2817}
2818#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2819unsafe extern "system" fn stub_cmd_clear_color_image(command_buffer: VkCommandBuffer, image: VkImage, image_layout: VkImageLayout, color: *const VkClearColorValue, range_count: u32, ranges: *const VkImageSubresourceRange) {
2820    let fp: PFN_vkCmdClearColorImage = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2821    unsafe { FPTBL.cmd_clear_color_image = fp; }
2822    unsafe { (fp.0)(command_buffer, image, image_layout, color, range_count, ranges) }
2823}
2824#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2825unsafe extern "system" fn stub_cmd_clear_depth_stencil_image(command_buffer: VkCommandBuffer, image: VkImage, image_layout: VkImageLayout, depth_stencil: *const VkClearDepthStencilValue, range_count: u32, ranges: *const VkImageSubresourceRange) {
2826    let fp: PFN_vkCmdClearDepthStencilImage = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2827    unsafe { FPTBL.cmd_clear_depth_stencil_image = fp; }
2828    unsafe { (fp.0)(command_buffer, image, image_layout, depth_stencil, range_count, ranges) }
2829}
2830#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2831unsafe extern "system" fn stub_cmd_clear_attachments(command_buffer: VkCommandBuffer, attachment_count: u32, attachments: *const VkClearAttachment, rect_count: u32, rects: *const VkClearRect) {
2832    let fp: PFN_vkCmdClearAttachments = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2833    unsafe { FPTBL.cmd_clear_attachments = fp; }
2834    unsafe { (fp.0)(command_buffer, attachment_count, attachments, rect_count, rects) }
2835}
2836#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2837unsafe extern "system" fn stub_cmd_resolve_image(command_buffer: VkCommandBuffer, src_image: VkImage, src_image_layout: VkImageLayout, dst_image: VkImage, dst_image_layout: VkImageLayout, region_count: u32, regions: *const VkImageResolve) {
2838    let fp: PFN_vkCmdResolveImage = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2839    unsafe { FPTBL.cmd_resolve_image = fp; }
2840    unsafe { (fp.0)(command_buffer, src_image, src_image_layout, dst_image, dst_image_layout, region_count, regions) }
2841}
2842#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2843unsafe extern "system" fn stub_cmd_set_event(command_buffer: VkCommandBuffer, event: VkEvent, stage_mask: VkPipelineStageFlags) {
2844    let fp: PFN_vkCmdSetEvent = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2845    unsafe { FPTBL.cmd_set_event = fp; }
2846    unsafe { (fp.0)(command_buffer, event, stage_mask) }
2847}
2848#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2849unsafe extern "system" fn stub_cmd_reset_event(command_buffer: VkCommandBuffer, event: VkEvent, stage_mask: VkPipelineStageFlags) {
2850    let fp: PFN_vkCmdResetEvent = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2851    unsafe { FPTBL.cmd_reset_event = fp; }
2852    unsafe { (fp.0)(command_buffer, event, stage_mask) }
2853}
2854#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2855unsafe extern "system" fn stub_cmd_wait_events(command_buffer: VkCommandBuffer, event_count: u32, events: *const VkEvent, src_stage_mask: VkPipelineStageFlags, dst_stage_mask: VkPipelineStageFlags, memory_barrier_count: u32, memory_barriers: *const VkMemoryBarrier, buffer_memory_barrier_count: u32, buffer_memory_barriers: *const VkBufferMemoryBarrier, image_memory_barrier_count: u32, image_memory_barriers: *const VkImageMemoryBarrier) {
2856    let fp: PFN_vkCmdWaitEvents = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2857    unsafe { FPTBL.cmd_wait_events = fp; }
2858    unsafe { (fp.0)(command_buffer, event_count, events, src_stage_mask, dst_stage_mask, memory_barrier_count, memory_barriers, buffer_memory_barrier_count, buffer_memory_barriers, image_memory_barrier_count, image_memory_barriers) }
2859}
2860#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2861unsafe extern "system" fn stub_cmd_pipeline_barrier(command_buffer: VkCommandBuffer, src_stage_mask: VkPipelineStageFlags, dst_stage_mask: VkPipelineStageFlags, dependency_flags: VkDependencyFlags, memory_barrier_count: u32, memory_barriers: *const VkMemoryBarrier, buffer_memory_barrier_count: u32, buffer_memory_barriers: *const VkBufferMemoryBarrier, image_memory_barrier_count: u32, image_memory_barriers: *const VkImageMemoryBarrier) {
2862    let fp: PFN_vkCmdPipelineBarrier = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2863    unsafe { FPTBL.cmd_pipeline_barrier = fp; }
2864    unsafe { (fp.0)(command_buffer, src_stage_mask, dst_stage_mask, dependency_flags, memory_barrier_count, memory_barriers, buffer_memory_barrier_count, buffer_memory_barriers, image_memory_barrier_count, image_memory_barriers) }
2865}
2866#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2867unsafe extern "system" fn stub_cmd_begin_query(command_buffer: VkCommandBuffer, query_pool: VkQueryPool, query: u32, flags: VkQueryControlFlags) {
2868    let fp: PFN_vkCmdBeginQuery = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2869    unsafe { FPTBL.cmd_begin_query = fp; }
2870    unsafe { (fp.0)(command_buffer, query_pool, query, flags) }
2871}
2872#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2873unsafe extern "system" fn stub_cmd_end_query(command_buffer: VkCommandBuffer, query_pool: VkQueryPool, query: u32) {
2874    let fp: PFN_vkCmdEndQuery = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2875    unsafe { FPTBL.cmd_end_query = fp; }
2876    unsafe { (fp.0)(command_buffer, query_pool, query) }
2877}
2878#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2879unsafe extern "system" fn stub_cmd_reset_query_pool(command_buffer: VkCommandBuffer, query_pool: VkQueryPool, first_query: u32, query_count: u32) {
2880    let fp: PFN_vkCmdResetQueryPool = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2881    unsafe { FPTBL.cmd_reset_query_pool = fp; }
2882    unsafe { (fp.0)(command_buffer, query_pool, first_query, query_count) }
2883}
2884#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2885unsafe extern "system" fn stub_cmd_write_timestamp(command_buffer: VkCommandBuffer, pipeline_stage: VkPipelineStageFlags, query_pool: VkQueryPool, query: u32) {
2886    let fp: PFN_vkCmdWriteTimestamp = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2887    unsafe { FPTBL.cmd_write_timestamp = fp; }
2888    unsafe { (fp.0)(command_buffer, pipeline_stage, query_pool, query) }
2889}
2890#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2891unsafe extern "system" fn stub_cmd_copy_query_pool_results(command_buffer: VkCommandBuffer, query_pool: VkQueryPool, first_query: u32, query_count: u32, dst_buffer: VkBuffer, dst_offset: VkDeviceSize, stride: VkDeviceSize, flags: VkQueryResultFlags) {
2892    let fp: PFN_vkCmdCopyQueryPoolResults = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2893    unsafe { FPTBL.cmd_copy_query_pool_results = fp; }
2894    unsafe { (fp.0)(command_buffer, query_pool, first_query, query_count, dst_buffer, dst_offset, stride, flags) }
2895}
2896#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2897unsafe extern "system" fn stub_cmd_push_constants(command_buffer: VkCommandBuffer, layout: VkPipelineLayout, stage_flags: VkShaderStageFlags, offset: u32, size: u32, values: *const c_void) {
2898    let fp: PFN_vkCmdPushConstants = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2899    unsafe { FPTBL.cmd_push_constants = fp; }
2900    unsafe { (fp.0)(command_buffer, layout, stage_flags, offset, size, values) }
2901}
2902#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2903unsafe extern "system" fn stub_cmd_begin_render_pass(command_buffer: VkCommandBuffer, render_pass_begin_info: *const VkRenderPassBeginInfo, contents: VkSubpassContents) {
2904    let fp: PFN_vkCmdBeginRenderPass = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2905    unsafe { FPTBL.cmd_begin_render_pass = fp; }
2906    unsafe { (fp.0)(command_buffer, render_pass_begin_info, contents) }
2907}
2908#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2909unsafe extern "system" fn stub_cmd_next_subpass(command_buffer: VkCommandBuffer, contents: VkSubpassContents) {
2910    let fp: PFN_vkCmdNextSubpass = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2911    unsafe { FPTBL.cmd_next_subpass = fp; }
2912    unsafe { (fp.0)(command_buffer, contents) }
2913}
2914#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2915unsafe extern "system" fn stub_cmd_end_render_pass(command_buffer: VkCommandBuffer) {
2916    let fp: PFN_vkCmdEndRenderPass = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2917    unsafe { FPTBL.cmd_end_render_pass = fp; }
2918    unsafe { (fp.0)(command_buffer) }
2919}
2920#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2921unsafe extern "system" fn stub_cmd_execute_commands(command_buffer: VkCommandBuffer, command_buffer_count: u32, command_buffers: *const VkCommandBuffer) {
2922    let fp: PFN_vkCmdExecuteCommands = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2923    unsafe { FPTBL.cmd_execute_commands = fp; }
2924    unsafe { (fp.0)(command_buffer, command_buffer_count, command_buffers) }
2925}
2926#[cfg(feature = "Allow1_1APIs")]
2927#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2928unsafe extern "system" fn stub_enumerate_instance_version(api_version: *mut u32) -> VkResult {
2929    let fp: PFN_vkEnumerateInstanceVersion = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2930    unsafe { FPTBL.enumerate_instance_version = fp; }
2931    unsafe { (fp.0)(api_version) }
2932}
2933#[cfg(feature = "Allow1_1APIs")]
2934#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2935unsafe extern "system" fn stub_trim_command_pool(device: VkDevice, command_pool: VkCommandPool, flags: VkCommandPoolTrimFlags) {
2936    let fp: PFN_vkTrimCommandPool = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2937    unsafe { FPTBL.trim_command_pool = fp; }
2938    unsafe { (fp.0)(device, command_pool, flags) }
2939}
2940#[cfg(feature = "VK_KHR_surface")]
2941#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2942unsafe extern "system" fn stub_destroy_surface_khr(instance: VkInstance, surface: VkSurfaceKHR, allocator: *const VkAllocationCallbacks) {
2943    let fp: PFN_vkDestroySurfaceKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2944    unsafe { FPTBL.destroy_surface_khr = fp; }
2945    unsafe { (fp.0)(instance, surface, allocator) }
2946}
2947#[cfg(feature = "VK_KHR_surface")]
2948#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2949unsafe extern "system" fn stub_get_physical_device_surface_support_khr(physical_device: VkPhysicalDevice, queue_family_index: u32, surface: VkSurfaceKHR, supported_out: *mut VkBool32) -> VkResult {
2950    let fp: PFN_vkGetPhysicalDeviceSurfaceSupportKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2951    unsafe { FPTBL.get_physical_device_surface_support_khr = fp; }
2952    unsafe { (fp.0)(physical_device, queue_family_index, surface, supported_out) }
2953}
2954#[cfg(feature = "VK_KHR_surface")]
2955#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2956unsafe extern "system" fn stub_get_physical_device_surface_capabilities_khr(physical_device: VkPhysicalDevice, surface: VkSurfaceKHR, surface_capabilities_out: *mut VkSurfaceCapabilitiesKHR) -> VkResult {
2957    let fp: PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2958    unsafe { FPTBL.get_physical_device_surface_capabilities_khr = fp; }
2959    unsafe { (fp.0)(physical_device, surface, surface_capabilities_out) }
2960}
2961#[cfg(feature = "VK_KHR_surface")]
2962#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2963unsafe extern "system" fn stub_get_physical_device_surface_formats_khr(physical_device: VkPhysicalDevice, surface: VkSurfaceKHR, surface_format_count_out: *mut u32, surface_formats_out: *mut VkSurfaceFormatKHR) -> VkResult {
2964    let fp: PFN_vkGetPhysicalDeviceSurfaceFormatsKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2965    unsafe { FPTBL.get_physical_device_surface_formats_khr = fp; }
2966    unsafe { (fp.0)(physical_device, surface, surface_format_count_out, surface_formats_out) }
2967}
2968#[cfg(feature = "VK_KHR_surface")]
2969#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2970unsafe extern "system" fn stub_get_physical_device_surface_present_modes_khr(physical_device: VkPhysicalDevice, surface: VkSurfaceKHR, present_mode_count_out: *mut u32, present_modes_out: *mut VkPresentModeKHR) -> VkResult {
2971    let fp: PFN_vkGetPhysicalDeviceSurfacePresentModesKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2972    unsafe { FPTBL.get_physical_device_surface_present_modes_khr = fp; }
2973    unsafe { (fp.0)(physical_device, surface, present_mode_count_out, present_modes_out) }
2974}
2975#[cfg(feature = "VK_KHR_swapchain")]
2976#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2977unsafe extern "system" fn stub_create_swapchain_khr(device: VkDevice, create_info: *const VkSwapchainCreateInfoKHR, allocator: *const VkAllocationCallbacks, swapchain_out: *mut VkSwapchainKHR) -> VkResult {
2978    let fp: PFN_vkCreateSwapchainKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2979    unsafe { FPTBL.create_swapchain_khr = fp; }
2980    unsafe { (fp.0)(device, create_info, allocator, swapchain_out) }
2981}
2982#[cfg(feature = "VK_KHR_swapchain")]
2983#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2984unsafe extern "system" fn stub_destroy_swapchain_khr(device: VkDevice, swapchain: VkSwapchainKHR, allocator: *const VkAllocationCallbacks) {
2985    let fp: PFN_vkDestroySwapchainKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2986    unsafe { FPTBL.destroy_swapchain_khr = fp; }
2987    unsafe { (fp.0)(device, swapchain, allocator) }
2988}
2989#[cfg(feature = "VK_KHR_swapchain")]
2990#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2991unsafe extern "system" fn stub_get_swapchain_images_khr(device: VkDevice, swapchain: VkSwapchainKHR, swapchain_image_count_out: *mut u32, swapchain_images_out: *mut VkImage) -> VkResult {
2992    let fp: PFN_vkGetSwapchainImagesKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
2993    unsafe { FPTBL.get_swapchain_images_khr = fp; }
2994    unsafe { (fp.0)(device, swapchain, swapchain_image_count_out, swapchain_images_out) }
2995}
2996#[cfg(feature = "VK_KHR_swapchain")]
2997#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
2998unsafe extern "system" fn stub_acquire_next_image_khr(device: VkDevice, swapchain: VkSwapchainKHR, timeout: u64, semaphore: Option<VkSemaphore>, fence: Option<VkFence>, image_index_out: *mut u32) -> VkResult {
2999    let fp: PFN_vkAcquireNextImageKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3000    unsafe { FPTBL.acquire_next_image_khr = fp; }
3001    unsafe { (fp.0)(device, swapchain, timeout, semaphore, fence, image_index_out) }
3002}
3003#[cfg(feature = "VK_KHR_swapchain")]
3004#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3005unsafe extern "system" fn stub_queue_present_khr(queue: VkQueue, present_info: *const VkPresentInfoKHR) -> VkResult {
3006    let fp: PFN_vkQueuePresentKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3007    unsafe { FPTBL.queue_present_khr = fp; }
3008    unsafe { (fp.0)(queue, present_info) }
3009}
3010#[cfg(feature = "VK_KHR_xlib_surface")]
3011#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3012unsafe extern "system" fn stub_create_xlib_surface_khr(instance: VkInstance, create_info: *const VkXlibSurfaceCreateInfoKHR, allocator: *const VkAllocationCallbacks, surface_out: *mut VkSurfaceKHR) -> VkResult {
3013    let fp: PFN_vkCreateXlibSurfaceKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3014    unsafe { FPTBL.create_xlib_surface_khr = fp; }
3015    unsafe { (fp.0)(instance, create_info, allocator, surface_out) }
3016}
3017#[cfg(feature = "VK_KHR_xlib_surface")]
3018#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3019unsafe extern "system" fn stub_get_physical_device_xlib_presentation_support_khr(physical_device: VkPhysicalDevice, queue_family_index: u32, dpy: *mut x11::xlib::Display, visual_id: x11::xlib::VisualID) -> VkBool32 {
3020    let fp: PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3021    unsafe { FPTBL.get_physical_device_xlib_presentation_support_khr = fp; }
3022    unsafe { (fp.0)(physical_device, queue_family_index, dpy, visual_id) }
3023}
3024#[cfg(feature = "VK_KHR_xcb_surface")]
3025#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3026unsafe extern "system" fn stub_create_xcb_surface_khr(instance: VkInstance, create_info: *const VkXcbSurfaceCreateInfoKHR, allocator: *const VkAllocationCallbacks, surface_out: *mut VkSurfaceKHR) -> VkResult {
3027    let fp: PFN_vkCreateXcbSurfaceKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3028    unsafe { FPTBL.create_xcb_surface_khr = fp; }
3029    unsafe { (fp.0)(instance, create_info, allocator, surface_out) }
3030}
3031#[cfg(feature = "VK_KHR_xcb_surface")]
3032#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3033unsafe extern "system" fn stub_get_physical_device_xcb_presentation_support_khr(physical_device: VkPhysicalDevice, queue_family_index: u32, connection: *mut xcb::ffi::xcb_connection_t, visual_id: xcb::x::Visualid) -> VkBool32 {
3034    let fp: PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3035    unsafe { FPTBL.get_physical_device_xcb_presentation_support_khr = fp; }
3036    unsafe { (fp.0)(physical_device, queue_family_index, connection, visual_id) }
3037}
3038#[cfg(feature = "VK_KHR_wayland_surface")]
3039#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3040unsafe extern "system" fn stub_create_wayland_surface_khr(instance: VkInstance, create_info: *const VkWaylandSurfaceCreateInfoKHR, allocator: *const VkAllocationCallbacks, surface_out: *mut VkSurfaceKHR) -> VkResult {
3041    let fp: PFN_vkCreateWaylandSurfaceKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3042    unsafe { FPTBL.create_wayland_surface_khr = fp; }
3043    unsafe { (fp.0)(instance, create_info, allocator, surface_out) }
3044}
3045#[cfg(feature = "VK_KHR_wayland_surface")]
3046#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3047unsafe extern "system" fn stub_get_physical_device_wayland_presentation_support_khr(physical_device: VkPhysicalDevice, queue_family_index: u32, display: *mut c_void) -> VkBool32 {
3048    let fp: PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3049    unsafe { FPTBL.get_physical_device_wayland_presentation_support_khr = fp; }
3050    unsafe { (fp.0)(physical_device, queue_family_index, display) }
3051}
3052#[cfg(feature = "VK_KHR_android_surface")]
3053#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3054unsafe extern "system" fn stub_create_android_surface_khr(instance: VkInstance, create_info: *const VkAndroidSurfaceCreateInfoKHR, allocator: *const VkAllocationCallbacks, surface_out: *mut VkSurfaceKHR) -> VkResult {
3055    let fp: PFN_vkCreateAndroidSurfaceKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3056    unsafe { FPTBL.create_android_surface_khr = fp; }
3057    unsafe { (fp.0)(instance, create_info, allocator, surface_out) }
3058}
3059#[cfg(feature = "VK_KHR_win32_surface")]
3060#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3061unsafe extern "system" fn stub_create_win32_surface_khr(instance: VkInstance, create_info: *const VkWin32SurfaceCreateInfoKHR, allocator: *const VkAllocationCallbacks, surface_out: *mut VkSurfaceKHR) -> VkResult {
3062    let fp: PFN_vkCreateWin32SurfaceKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3063    unsafe { FPTBL.create_win32_surface_khr = fp; }
3064    unsafe { (fp.0)(instance, create_info, allocator, surface_out) }
3065}
3066#[cfg(feature = "VK_KHR_win32_surface")]
3067#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3068unsafe extern "system" fn stub_get_physical_device_win32_presentation_support_khr(physical_device: VkPhysicalDevice, queue_family_index: u32) -> VkBool32 {
3069    let fp: PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3070    unsafe { FPTBL.get_physical_device_win32_presentation_support_khr = fp; }
3071    unsafe { (fp.0)(physical_device, queue_family_index) }
3072}
3073#[cfg(feature = "VK_MVK_macos_surface")]
3074#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3075unsafe extern "system" fn stub_create_macos_surface_mvk(instance: VkInstance, create_info: *const VkMacOSSurfaceCreateInfoMVK, allocator: *const VkAllocationCallbacks, surface_out: *mut VkSurfaceKHR) -> VkResult {
3076    let fp: PFN_vkCreateMacOSSurfaceMVK = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3077    unsafe { FPTBL.create_macos_surface_mvk = fp; }
3078    unsafe { (fp.0)(instance, create_info, allocator, surface_out) }
3079}
3080#[cfg(feature = "VK_EXT_metal_surface")]
3081#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3082unsafe extern "system" fn stub_create_metal_surface_ext(instance: VkInstance, create_info: *const VkMetalSurfaceCreateInfoEXT, allocator: *const VkAllocationCallbacks, surface_out: *mut VkSurfaceKHR) -> VkResult {
3083    let fp: PFN_vkCreateMetalSurfaceEXT = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3084    unsafe { FPTBL.create_metal_surface_ext = fp; }
3085    unsafe { (fp.0)(instance, create_info, allocator, surface_out) }
3086}
3087#[cfg(feature = "VK_KHR_display")]
3088#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3089unsafe extern "system" fn stub_get_physical_device_display_properties_khr(physical_device: VkPhysicalDevice, property_count_out: *mut u32, properties_out: *mut VkDisplayPropertiesKHR) -> VkResult {
3090    let fp: PFN_vkGetPhysicalDeviceDisplayPropertiesKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3091    unsafe { FPTBL.get_physical_device_display_properties_khr = fp; }
3092    unsafe { (fp.0)(physical_device, property_count_out, properties_out) }
3093}
3094#[cfg(feature = "VK_KHR_display")]
3095#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3096unsafe extern "system" fn stub_get_physical_device_display_plane_properties_khr(physical_device: VkPhysicalDevice, property_count_out: *mut u32, properties_out: *mut VkDisplayPlanePropertiesKHR) -> VkResult {
3097    let fp: PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3098    unsafe { FPTBL.get_physical_device_display_plane_properties_khr = fp; }
3099    unsafe { (fp.0)(physical_device, property_count_out, properties_out) }
3100}
3101#[cfg(feature = "VK_KHR_display")]
3102#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3103unsafe extern "system" fn stub_get_display_plane_supported_displays_khr(physical_device: VkPhysicalDevice, plane_index: u32, display_count_out: *mut u32, displays_out: *mut VkDisplayKHR) -> VkResult {
3104    let fp: PFN_vkGetDisplayPlaneSupportedDisplaysKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3105    unsafe { FPTBL.get_display_plane_supported_displays_khr = fp; }
3106    unsafe { (fp.0)(physical_device, plane_index, display_count_out, displays_out) }
3107}
3108#[cfg(feature = "VK_KHR_display")]
3109#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3110unsafe extern "system" fn stub_get_display_mode_properties_khr(physical_device: VkPhysicalDevice, display: VkDisplayKHR, property_count_out: *mut u32, properties_out: *mut VkDisplayModePropertiesKHR) -> VkResult {
3111    let fp: PFN_vkGetDisplayModePropertiesKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3112    unsafe { FPTBL.get_display_mode_properties_khr = fp; }
3113    unsafe { (fp.0)(physical_device, display, property_count_out, properties_out) }
3114}
3115#[cfg(feature = "VK_KHR_display")]
3116#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3117unsafe extern "system" fn stub_create_display_mode_khr(physical_device: VkPhysicalDevice, display: VkDisplayKHR, create_info: *const VkDisplayModeCreateInfoKHR, allocator: *const VkAllocationCallbacks, mode_out: *mut VkDisplayModeKHR) -> VkResult {
3118    let fp: PFN_vkCreateDisplayModeKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3119    unsafe { FPTBL.create_display_mode_khr = fp; }
3120    unsafe { (fp.0)(physical_device, display, create_info, allocator, mode_out) }
3121}
3122#[cfg(feature = "VK_KHR_display")]
3123#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3124unsafe extern "system" fn stub_get_display_plane_capabilities_khr(physcial_device: VkPhysicalDevice, mode: VkDisplayModeKHR, plane_index: u32, capabilities_out: *mut VkDisplayPlaneCapabilitiesKHR) -> VkResult {
3125    let fp: PFN_vkGetDisplayPlaneCapabilitiesKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3126    unsafe { FPTBL.get_display_plane_capabilities_khr = fp; }
3127    unsafe { (fp.0)(physcial_device, mode, plane_index, capabilities_out) }
3128}
3129#[cfg(all(feature = "VK_KHR_display", feature = "VK_KHR_surface"))]
3130#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3131unsafe extern "system" fn stub_create_display_plane_surface_khr(instance: VkInstance, create_info: *const VkDisplaySurfaceCreateInfoKHR, allocator: *const VkAllocationCallbacks, surface_out: *mut VkSurfaceKHR) -> VkResult {
3132    let fp: PFN_vkCreateDisplayPlaneSurfaceKHR = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3133    unsafe { FPTBL.create_display_plane_surface_khr = fp; }
3134    unsafe { (fp.0)(instance, create_info, allocator, surface_out) }
3135}
3136#[cfg(feature = "Allow1_1APIs")]
3137#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3138unsafe extern "system" fn stub_get_physical_device_features2(physical_device: VkPhysicalDevice, features_out: *mut VkPhysicalDeviceFeatures2) {
3139    let fp: PFN_vkGetPhysicalDeviceFeatures2 = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3140    unsafe { FPTBL.get_physical_device_features2 = fp; }
3141    unsafe { (fp.0)(physical_device, features_out) }
3142}
3143#[cfg(feature = "Allow1_1APIs")]
3144#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3145unsafe extern "system" fn stub_get_physical_device_format_properties2(physical_device: VkPhysicalDevice, format: VkFormat, format_properties_out: *mut VkFormatProperties2) {
3146    let fp: PFN_vkGetPhysicalDeviceFormatProperties2 = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3147    unsafe { FPTBL.get_physical_device_format_properties2 = fp; }
3148    unsafe { (fp.0)(physical_device, format, format_properties_out) }
3149}
3150#[cfg(feature = "Allow1_1APIs")]
3151#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3152unsafe extern "system" fn stub_get_physical_device_image_format_properties2(physical_device: VkPhysicalDevice, image_format_info: *const VkPhysicalDeviceImageFormatInfo2, image_format_properties_out: *mut VkImageFormatProperties2) -> VkResult {
3153    let fp: PFN_vkGetPhysicalDeviceImageFormatProperties2 = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3154    unsafe { FPTBL.get_physical_device_image_format_properties2 = fp; }
3155    unsafe { (fp.0)(physical_device, image_format_info, image_format_properties_out) }
3156}
3157#[cfg(feature = "Allow1_1APIs")]
3158#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3159unsafe extern "system" fn stub_get_physical_device_memory_properties2(physical_device: VkPhysicalDevice, memory_properties_out: *mut VkPhysicalDeviceMemoryProperties2) {
3160    let fp: PFN_vkGetPhysicalDeviceMemoryProperties2 = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3161    unsafe { FPTBL.get_physical_device_memory_properties2 = fp; }
3162    unsafe { (fp.0)(physical_device, memory_properties_out) }
3163}
3164#[cfg(feature = "Allow1_1APIs")]
3165#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3166unsafe extern "system" fn stub_get_physical_device_properties2(physical_device: VkPhysicalDevice, properties_out: *mut VkPhysicalDeviceProperties2) {
3167    let fp: PFN_vkGetPhysicalDeviceProperties2 = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3168    unsafe { FPTBL.get_physical_device_properties2 = fp; }
3169    unsafe { (fp.0)(physical_device, properties_out) }
3170}
3171#[cfg(feature = "Allow1_1APIs")]
3172#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3173unsafe extern "system" fn stub_get_physical_device_queue_family_properties2(physical_device: VkPhysicalDevice, queue_family_property_count: *mut u32, queue_family_properties_out: *mut VkQueueFamilyProperties2) {
3174    let fp: PFN_vkGetPhysicalDeviceQueueFamilyProperties2 = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3175    unsafe { FPTBL.get_physical_device_queue_family_properties2 = fp; }
3176    unsafe { (fp.0)(physical_device, queue_family_property_count, queue_family_properties_out) }
3177}
3178#[cfg(feature = "Allow1_1APIs")]
3179#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3180unsafe extern "system" fn stub_get_physical_device_sparse_image_format_properties2(physical_device: VkPhysicalDevice, format_info: *const VkPhysicalDeviceSparseImageFormatInfo2, property_count: *mut u32, properties_out: *mut VkSparseImageFormatProperties2) {
3181    let fp: PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3182    unsafe { FPTBL.get_physical_device_sparse_image_format_properties2 = fp; }
3183    unsafe { (fp.0)(physical_device, format_info, property_count, properties_out) }
3184}
3185#[cfg(feature = "Allow1_1APIs")]
3186#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3187unsafe extern "system" fn stub_create_descriptor_update_template(device: VkDevice, create_info: *const VkDescriptorUpdateTemplateCreateInfo, allocator: *const VkAllocationCallbacks, descriptor_update_template_out: *mut VkDescriptorUpdateTemplate) -> VkResult {
3188    let fp: PFN_vkCreateDescriptorUpdateTemplate = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3189    unsafe { FPTBL.create_descriptor_update_template = fp; }
3190    unsafe { (fp.0)(device, create_info, allocator, descriptor_update_template_out) }
3191}
3192#[cfg(feature = "Allow1_1APIs")]
3193#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3194unsafe extern "system" fn stub_destroy_descriptor_update_template(device: VkDevice, descriptor_update_template: VkDescriptorUpdateTemplate, allocator: *const VkAllocationCallbacks) {
3195    let fp: PFN_vkDestroyDescriptorUpdateTemplate = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3196    unsafe { FPTBL.destroy_descriptor_update_template = fp; }
3197    unsafe { (fp.0)(device, descriptor_update_template, allocator) }
3198}
3199#[cfg(feature = "Allow1_1APIs")]
3200#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3201unsafe extern "system" fn stub_update_descriptor_set_with_template(device: VkDevice, descriptor_set: VkDescriptorSet, descriptor_update_template: VkDescriptorUpdateTemplate, data: *const core::ffi::c_void) {
3202    let fp: PFN_vkUpdateDescriptorSetWithTemplate = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3203    unsafe { FPTBL.update_descriptor_set_with_template = fp; }
3204    unsafe { (fp.0)(device, descriptor_set, descriptor_update_template, data) }
3205}
3206#[cfg(feature = "Allow1_1APIs")]
3207#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3208unsafe extern "system" fn stub_get_buffer_memory_requirements2(device: VkDevice, info: *const VkBufferMemoryRequirementsInfo2, memory_requirements: *mut VkMemoryRequirements2) {
3209    let fp: PFN_vkGetBufferMemoryRequirements2 = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3210    unsafe { FPTBL.get_buffer_memory_requirements2 = fp; }
3211    unsafe { (fp.0)(device, info, memory_requirements) }
3212}
3213#[cfg(feature = "Allow1_1APIs")]
3214#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3215unsafe extern "system" fn stub_get_image_memory_requirements2(device: VkDevice, info: *const VkImageMemoryRequirementsInfo2, memory_requirements: *mut VkMemoryRequirements2) {
3216    let fp: PFN_vkGetImageMemoryRequirements2 = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3217    unsafe { FPTBL.get_image_memory_requirements2 = fp; }
3218    unsafe { (fp.0)(device, info, memory_requirements) }
3219}
3220#[cfg(feature = "Allow1_1APIs")]
3221#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3222unsafe extern "system" fn stub_get_image_sparse_memory_requirements2(device: VkDevice, info: *const VkImageSparseMemoryRequirementsInfo2, sparse_memory_requirements_count: *mut u32, sparse_memory_requirements: *mut VkSparseImageMemoryRequirements2) {
3223    let fp: PFN_vkGetImageSparseMemoryRequirements2 = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3224    unsafe { FPTBL.get_image_sparse_memory_requirements2 = fp; }
3225    unsafe { (fp.0)(device, info, sparse_memory_requirements_count, sparse_memory_requirements) }
3226}
3227#[cfg(feature = "Allow1_1APIs")]
3228#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3229unsafe extern "system" fn stub_bind_buffer_memory2(device: VkDevice, bind_info_count: u32, bind_infos: *const VkBindBufferMemoryInfo) -> VkResult {
3230    let fp: PFN_vkBindBufferMemory2 = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3231    unsafe { FPTBL.bind_buffer_memory2 = fp; }
3232    unsafe { (fp.0)(device, bind_info_count, bind_infos) }
3233}
3234#[cfg(feature = "Allow1_1APIs")]
3235#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3236unsafe extern "system" fn stub_bind_image_memory2(device: VkDevice, bind_info_count: u32, bind_infos: *const VkBindImageMemoryInfo) -> VkResult {
3237    let fp: PFN_vkBindImageMemory2 = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3238    unsafe { FPTBL.bind_image_memory2 = fp; }
3239    unsafe { (fp.0)(device, bind_info_count, bind_infos) }
3240}
3241#[cfg(feature = "Allow1_2APIs")]
3242#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3243unsafe extern "system" fn stub_create_render_pass2(device: VkDevice, create_info: *const VkRenderPassCreateInfo2, allocator: *const VkAllocationCallbacks, out: *mut VkRenderPass) -> VkResult {
3244    let fp: PFN_vkCreateRenderPass2 = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3245    unsafe { FPTBL.create_render_pass2 = fp; }
3246    unsafe { (fp.0)(device, create_info, allocator, out) }
3247}
3248#[cfg(feature = "Allow1_2APIs")]
3249#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3250unsafe extern "system" fn stub_get_semaphore_counter_value(device: VkDevice, semaphore: VkSemaphore, value: *mut u64) -> VkResult {
3251    let fp: PFN_vkGetSemaphoreCounterValue = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3252    unsafe { FPTBL.get_semaphore_counter_value = fp; }
3253    unsafe { (fp.0)(device, semaphore, value) }
3254}
3255#[cfg(feature = "Allow1_2APIs")]
3256#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3257unsafe extern "system" fn stub_signal_semaphore(device: VkDevice, signal_info: *const VkSemaphoreSignalInfo) -> VkResult {
3258    let fp: PFN_vkSignalSemaphore = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3259    unsafe { FPTBL.signal_semaphore = fp; }
3260    unsafe { (fp.0)(device, signal_info) }
3261}
3262#[cfg(feature = "Allow1_2APIs")]
3263#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3264unsafe extern "system" fn stub_wait_semaphores(device: VkDevice, wait_info: *const VkSemaphoreWaitInfo, timeout: u64) -> VkResult {
3265    let fp: PFN_vkWaitSemaphores = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3266    unsafe { FPTBL.wait_semaphores = fp; }
3267    unsafe { (fp.0)(device, wait_info, timeout) }
3268}
3269#[cfg(feature = "Allow1_2APIs")]
3270#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3271unsafe extern "system" fn stub_cmd_begin_render_pass2(command_buffer: VkCommandBuffer, begin_info: *const VkRenderPassBeginInfo, begin_subpass_info: *const VkSubpassBeginInfo) {
3272    let fp: PFN_vkCmdBeginRenderPass2 = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3273    unsafe { FPTBL.cmd_begin_render_pass2 = fp; }
3274    unsafe { (fp.0)(command_buffer, begin_info, begin_subpass_info) }
3275}
3276#[cfg(feature = "Allow1_2APIs")]
3277#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3278unsafe extern "system" fn stub_cmd_next_subpass2(command_buffer: VkCommandBuffer, begin_subpass_info: *const VkSubpassBeginInfo, end_subpass_info: *const VkSubpassEndInfo) {
3279    let fp: PFN_vkCmdNextSubpass2 = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3280    unsafe { FPTBL.cmd_next_subpass2 = fp; }
3281    unsafe { (fp.0)(command_buffer, begin_subpass_info, end_subpass_info) }
3282}
3283#[cfg(feature = "Allow1_2APIs")]
3284#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3285unsafe extern "system" fn stub_cmd_end_render_pass2(command_buffer: VkCommandBuffer, end_subpass_info: *const VkSubpassEndInfo) {
3286    let fp: PFN_vkCmdEndRenderPass2 = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3287    unsafe { FPTBL.cmd_end_render_pass2 = fp; }
3288    unsafe { (fp.0)(command_buffer, end_subpass_info) }
3289}
3290#[cfg(feature = "Allow1_3APIs")]
3291#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3292unsafe extern "system" fn stub_cmd_pipeline_barrier2(command_buffer: VkCommandBuffer, dependency_info: *const VkDependencyInfo) {
3293    let fp: PFN_vkCmdPipelineBarrier2 = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3294    unsafe { FPTBL.cmd_pipeline_barrier2 = fp; }
3295    unsafe { (fp.0)(command_buffer, dependency_info) }
3296}
3297#[cfg(feature = "Allow1_3APIs")]
3298#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3299unsafe extern "system" fn stub_queue_submit2(queue: VkQueue, submit_count: u32, submits: *const VkSubmitInfo2, fence: Option<VkFence>) -> VkResult {
3300    let fp: PFN_vkQueueSubmit2 = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3301    unsafe { FPTBL.queue_submit2 = fp; }
3302    unsafe { (fp.0)(queue, submit_count, submits, fence) }
3303}
3304#[cfg(feature = "Allow1_4APIs")]
3305#[rustfmt::skip] #[cfg(any(feature = "DynamicLoaded", feature = "CustomResolver"))]
3306unsafe extern "system" fn stub_cmd_push_descriptor_set(command_buffer: VkCommandBuffer, pipeline_bind_point: VkPipelineBindPoint, layout: VkPipelineLayout, set: u32, descriptor_write_count: u32, descriptor_writes: *const VkWriteDescriptorSet) {
3307    let fp: PFN_vkCmdPushDescriptorSet = unsafe { crate::load_function_unconstrainted(crate::resolver::current_resolver()) };
3308    unsafe { FPTBL.cmd_push_descriptor_set = fp; }
3309    unsafe { (fp.0)(command_buffer, pipeline_bind_point, layout, set, descriptor_write_count, descriptor_writes) }
3310}
bedrock_vk/fns.rs

bedrock_vk/
fns.rs
