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