1 #ifndef __mock_icd_h_
2 #define __mock_icd_h_ 1
3
4 /*
5 ** Copyright (c) 2015-2018 The Khronos Group Inc.
6 **
7 ** Licensed under the Apache License, Version 2.0 (the "License");
8 ** you may not use this file except in compliance with the License.
9 ** You may obtain a copy of the License at
10 **
11 ** http://www.apache.org/licenses/LICENSE-2.0
12 **
13 ** Unless required by applicable law or agreed to in writing, software
14 ** distributed under the License is distributed on an "AS IS" BASIS,
15 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 ** See the License for the specific language governing permissions and
17 ** limitations under the License.
18 */
19
20 /*
21 ** This header is generated from the Khronos Vulkan XML API Registry.
22 **
23 */
24
25 #include <unordered_map>
26 #include <mutex>
27 #include <string>
28 #include <cstring>
29 #include "vulkan/vk_icd.h"
30 namespace vkmock {
31
32
33 using mutex_t = std::mutex;
34 using lock_guard_t = std::lock_guard<mutex_t>;
35 using unique_lock_t = std::unique_lock<mutex_t>;
36
37 static mutex_t global_lock;
38 static uint64_t global_unique_handle = 1;
39 static const uint32_t SUPPORTED_LOADER_ICD_INTERFACE_VERSION = 5;
40 static uint32_t loader_interface_version = 0;
41 static bool negotiate_loader_icd_interface_called = false;
CreateDispObjHandle()42 static void* CreateDispObjHandle() {
43 auto handle = new VK_LOADER_DATA;
44 set_loader_magic_value(handle);
45 return handle;
46 }
DestroyDispObjHandle(void * handle)47 static void DestroyDispObjHandle(void* handle) {
48 delete reinterpret_cast<VK_LOADER_DATA*>(handle);
49 }
50
51 // Map of instance extension name to version
52 static const std::unordered_map<std::string, uint32_t> instance_extension_map = {
53 {"VK_KHR_surface", 25},
54 {"VK_KHR_display", 23},
55 {"VK_KHR_xlib_surface", 6},
56 {"VK_KHR_xcb_surface", 6},
57 {"VK_KHR_wayland_surface", 6},
58 {"VK_KHR_android_surface", 6},
59 {"VK_KHR_win32_surface", 6},
60 {"VK_EXT_debug_report", 10},
61 {"VK_GGP_stream_descriptor_surface", 1},
62 {"VK_NV_external_memory_capabilities", 1},
63 {"VK_KHR_get_physical_device_properties2", 2},
64 {"VK_EXT_validation_flags", 2},
65 {"VK_NN_vi_surface", 1},
66 {"VK_KHR_device_group_creation", 1},
67 {"VK_KHR_external_memory_capabilities", 1},
68 {"VK_KHR_external_semaphore_capabilities", 1},
69 {"VK_EXT_direct_mode_display", 1},
70 {"VK_EXT_acquire_xlib_display", 1},
71 {"VK_EXT_display_surface_counter", 1},
72 {"VK_EXT_swapchain_colorspace", 4},
73 {"VK_KHR_external_fence_capabilities", 1},
74 {"VK_KHR_get_surface_capabilities2", 1},
75 {"VK_KHR_get_display_properties2", 1},
76 {"VK_MVK_ios_surface", 3},
77 {"VK_MVK_macos_surface", 3},
78 {"VK_EXT_debug_utils", 2},
79 {"VK_FUCHSIA_imagepipe_surface", 1},
80 {"VK_EXT_metal_surface", 1},
81 {"VK_KHR_surface_protected_capabilities", 1},
82 {"VK_EXT_validation_features", 5},
83 {"VK_EXT_headless_surface", 1},
84 {"VK_EXT_acquire_drm_display", 1},
85 {"VK_EXT_directfb_surface", 1},
86 {"VK_QNX_screen_surface", 1},
87 {"VK_GOOGLE_surfaceless_query", 1},
88 };
89 // Map of device extension name to version
90 static const std::unordered_map<std::string, uint32_t> device_extension_map = {
91 {"VK_KHR_swapchain", 70},
92 {"VK_KHR_display_swapchain", 10},
93 {"VK_NV_glsl_shader", 1},
94 {"VK_EXT_depth_range_unrestricted", 1},
95 {"VK_KHR_sampler_mirror_clamp_to_edge", 3},
96 {"VK_IMG_filter_cubic", 1},
97 {"VK_AMD_rasterization_order", 1},
98 {"VK_AMD_shader_trinary_minmax", 1},
99 {"VK_AMD_shader_explicit_vertex_parameter", 1},
100 {"VK_EXT_debug_marker", 4},
101 {"VK_KHR_video_queue", 2},
102 {"VK_KHR_video_decode_queue", 2},
103 {"VK_AMD_gcn_shader", 1},
104 {"VK_NV_dedicated_allocation", 1},
105 {"VK_EXT_transform_feedback", 1},
106 {"VK_NVX_binary_import", 1},
107 {"VK_NVX_image_view_handle", 2},
108 {"VK_AMD_draw_indirect_count", 2},
109 {"VK_AMD_negative_viewport_height", 1},
110 {"VK_AMD_gpu_shader_half_float", 2},
111 {"VK_AMD_shader_ballot", 1},
112 {"VK_EXT_video_encode_h264", 3},
113 {"VK_EXT_video_encode_h265", 3},
114 {"VK_EXT_video_decode_h264", 3},
115 {"VK_AMD_texture_gather_bias_lod", 1},
116 {"VK_AMD_shader_info", 1},
117 {"VK_KHR_dynamic_rendering", 1},
118 {"VK_AMD_shader_image_load_store_lod", 1},
119 {"VK_NV_corner_sampled_image", 2},
120 {"VK_KHR_multiview", 1},
121 {"VK_IMG_format_pvrtc", 1},
122 {"VK_NV_external_memory", 1},
123 {"VK_NV_external_memory_win32", 1},
124 {"VK_NV_win32_keyed_mutex", 2},
125 {"VK_KHR_device_group", 4},
126 {"VK_KHR_shader_draw_parameters", 1},
127 {"VK_EXT_shader_subgroup_ballot", 1},
128 {"VK_EXT_shader_subgroup_vote", 1},
129 {"VK_EXT_texture_compression_astc_hdr", 1},
130 {"VK_EXT_astc_decode_mode", 1},
131 {"VK_KHR_maintenance1", 2},
132 {"VK_KHR_external_memory", 1},
133 {"VK_KHR_external_memory_win32", 1},
134 {"VK_KHR_external_memory_fd", 1},
135 {"VK_KHR_win32_keyed_mutex", 1},
136 {"VK_KHR_external_semaphore", 1},
137 {"VK_KHR_external_semaphore_win32", 1},
138 {"VK_KHR_external_semaphore_fd", 1},
139 {"VK_KHR_push_descriptor", 2},
140 {"VK_EXT_conditional_rendering", 2},
141 {"VK_KHR_shader_float16_int8", 1},
142 {"VK_KHR_16bit_storage", 1},
143 {"VK_KHR_incremental_present", 2},
144 {"VK_KHR_descriptor_update_template", 1},
145 {"VK_NV_clip_space_w_scaling", 1},
146 {"VK_EXT_display_control", 1},
147 {"VK_GOOGLE_display_timing", 1},
148 {"VK_NV_sample_mask_override_coverage", 1},
149 {"VK_NV_geometry_shader_passthrough", 1},
150 {"VK_NV_viewport_array2", 1},
151 {"VK_NVX_multiview_per_view_attributes", 1},
152 {"VK_NV_viewport_swizzle", 1},
153 {"VK_EXT_discard_rectangles", 1},
154 {"VK_EXT_conservative_rasterization", 1},
155 {"VK_EXT_depth_clip_enable", 1},
156 {"VK_EXT_hdr_metadata", 2},
157 {"VK_KHR_imageless_framebuffer", 1},
158 {"VK_KHR_create_renderpass2", 1},
159 {"VK_KHR_shared_presentable_image", 1},
160 {"VK_KHR_external_fence", 1},
161 {"VK_KHR_external_fence_win32", 1},
162 {"VK_KHR_external_fence_fd", 1},
163 {"VK_KHR_performance_query", 1},
164 {"VK_KHR_maintenance2", 1},
165 {"VK_KHR_variable_pointers", 1},
166 {"VK_EXT_external_memory_dma_buf", 1},
167 {"VK_EXT_queue_family_foreign", 1},
168 {"VK_KHR_dedicated_allocation", 3},
169 {"VK_ANDROID_external_memory_android_hardware_buffer", 4},
170 {"VK_EXT_sampler_filter_minmax", 2},
171 {"VK_KHR_storage_buffer_storage_class", 1},
172 {"VK_AMD_gpu_shader_int16", 2},
173 {"VK_AMD_mixed_attachment_samples", 1},
174 {"VK_AMD_shader_fragment_mask", 1},
175 {"VK_EXT_inline_uniform_block", 1},
176 {"VK_EXT_shader_stencil_export", 1},
177 {"VK_EXT_sample_locations", 1},
178 {"VK_KHR_relaxed_block_layout", 1},
179 {"VK_KHR_get_memory_requirements2", 1},
180 {"VK_KHR_image_format_list", 1},
181 {"VK_EXT_blend_operation_advanced", 2},
182 {"VK_NV_fragment_coverage_to_color", 1},
183 {"VK_KHR_acceleration_structure", 13},
184 {"VK_KHR_ray_tracing_pipeline", 1},
185 {"VK_KHR_ray_query", 1},
186 {"VK_NV_framebuffer_mixed_samples", 1},
187 {"VK_NV_fill_rectangle", 1},
188 {"VK_NV_shader_sm_builtins", 1},
189 {"VK_EXT_post_depth_coverage", 1},
190 {"VK_KHR_sampler_ycbcr_conversion", 14},
191 {"VK_KHR_bind_memory2", 1},
192 {"VK_EXT_image_drm_format_modifier", 2},
193 {"VK_EXT_descriptor_indexing", 2},
194 {"VK_EXT_shader_viewport_index_layer", 1},
195 {"VK_NV_shading_rate_image", 3},
196 {"VK_NV_ray_tracing", 3},
197 {"VK_NV_representative_fragment_test", 2},
198 {"VK_KHR_maintenance3", 1},
199 {"VK_KHR_draw_indirect_count", 1},
200 {"VK_EXT_filter_cubic", 3},
201 {"VK_QCOM_render_pass_shader_resolve", 4},
202 {"VK_EXT_global_priority", 2},
203 {"VK_KHR_shader_subgroup_extended_types", 1},
204 {"VK_KHR_8bit_storage", 1},
205 {"VK_EXT_external_memory_host", 1},
206 {"VK_AMD_buffer_marker", 1},
207 {"VK_KHR_shader_atomic_int64", 1},
208 {"VK_KHR_shader_clock", 1},
209 {"VK_AMD_pipeline_compiler_control", 1},
210 {"VK_EXT_calibrated_timestamps", 2},
211 {"VK_AMD_shader_core_properties", 2},
212 {"VK_EXT_video_decode_h265", 1},
213 {"VK_AMD_memory_overallocation_behavior", 1},
214 {"VK_EXT_vertex_attribute_divisor", 3},
215 {"VK_GGP_frame_token", 1},
216 {"VK_EXT_pipeline_creation_feedback", 1},
217 {"VK_KHR_driver_properties", 1},
218 {"VK_KHR_shader_float_controls", 4},
219 {"VK_NV_shader_subgroup_partitioned", 1},
220 {"VK_KHR_depth_stencil_resolve", 1},
221 {"VK_KHR_swapchain_mutable_format", 1},
222 {"VK_NV_compute_shader_derivatives", 1},
223 {"VK_NV_mesh_shader", 1},
224 {"VK_NV_fragment_shader_barycentric", 1},
225 {"VK_NV_shader_image_footprint", 2},
226 {"VK_NV_scissor_exclusive", 1},
227 {"VK_NV_device_diagnostic_checkpoints", 2},
228 {"VK_KHR_timeline_semaphore", 2},
229 {"VK_INTEL_shader_integer_functions2", 1},
230 {"VK_INTEL_performance_query", 2},
231 {"VK_KHR_vulkan_memory_model", 3},
232 {"VK_EXT_pci_bus_info", 2},
233 {"VK_AMD_display_native_hdr", 1},
234 {"VK_KHR_shader_terminate_invocation", 1},
235 {"VK_EXT_fragment_density_map", 2},
236 {"VK_EXT_scalar_block_layout", 1},
237 {"VK_GOOGLE_hlsl_functionality1", 1},
238 {"VK_GOOGLE_decorate_string", 1},
239 {"VK_EXT_subgroup_size_control", 2},
240 {"VK_KHR_fragment_shading_rate", 2},
241 {"VK_AMD_shader_core_properties2", 1},
242 {"VK_AMD_device_coherent_memory", 1},
243 {"VK_EXT_shader_image_atomic_int64", 1},
244 {"VK_KHR_spirv_1_4", 1},
245 {"VK_EXT_memory_budget", 1},
246 {"VK_EXT_memory_priority", 1},
247 {"VK_NV_dedicated_allocation_image_aliasing", 1},
248 {"VK_KHR_separate_depth_stencil_layouts", 1},
249 {"VK_EXT_buffer_device_address", 2},
250 {"VK_EXT_tooling_info", 1},
251 {"VK_EXT_separate_stencil_usage", 1},
252 {"VK_KHR_present_wait", 1},
253 {"VK_NV_cooperative_matrix", 1},
254 {"VK_NV_coverage_reduction_mode", 1},
255 {"VK_EXT_fragment_shader_interlock", 1},
256 {"VK_EXT_ycbcr_image_arrays", 1},
257 {"VK_KHR_uniform_buffer_standard_layout", 1},
258 {"VK_EXT_provoking_vertex", 1},
259 {"VK_EXT_full_screen_exclusive", 4},
260 {"VK_KHR_buffer_device_address", 1},
261 {"VK_EXT_line_rasterization", 1},
262 {"VK_EXT_shader_atomic_float", 1},
263 {"VK_EXT_host_query_reset", 1},
264 {"VK_EXT_index_type_uint8", 1},
265 {"VK_EXT_extended_dynamic_state", 1},
266 {"VK_KHR_deferred_host_operations", 4},
267 {"VK_KHR_pipeline_executable_properties", 1},
268 {"VK_EXT_shader_atomic_float2", 1},
269 {"VK_EXT_shader_demote_to_helper_invocation", 1},
270 {"VK_NV_device_generated_commands", 3},
271 {"VK_NV_inherited_viewport_scissor", 1},
272 {"VK_KHR_shader_integer_dot_product", 1},
273 {"VK_EXT_texel_buffer_alignment", 1},
274 {"VK_QCOM_render_pass_transform", 2},
275 {"VK_EXT_device_memory_report", 2},
276 {"VK_EXT_robustness2", 1},
277 {"VK_EXT_custom_border_color", 12},
278 {"VK_GOOGLE_user_type", 1},
279 {"VK_KHR_pipeline_library", 1},
280 {"VK_KHR_shader_non_semantic_info", 1},
281 {"VK_KHR_present_id", 1},
282 {"VK_EXT_private_data", 1},
283 {"VK_EXT_pipeline_creation_cache_control", 3},
284 {"VK_KHR_video_encode_queue", 3},
285 {"VK_NV_device_diagnostics_config", 1},
286 {"VK_QCOM_render_pass_store_ops", 2},
287 {"VK_KHR_synchronization2", 1},
288 {"VK_KHR_shader_subgroup_uniform_control_flow", 1},
289 {"VK_KHR_zero_initialize_workgroup_memory", 1},
290 {"VK_NV_fragment_shading_rate_enums", 1},
291 {"VK_NV_ray_tracing_motion_blur", 1},
292 {"VK_EXT_ycbcr_2plane_444_formats", 1},
293 {"VK_EXT_fragment_density_map2", 1},
294 {"VK_QCOM_rotated_copy_commands", 1},
295 {"VK_EXT_image_robustness", 1},
296 {"VK_KHR_workgroup_memory_explicit_layout", 1},
297 {"VK_KHR_copy_commands2", 1},
298 {"VK_EXT_4444_formats", 1},
299 {"VK_ARM_rasterization_order_attachment_access", 1},
300 {"VK_EXT_rgba10x6_formats", 1},
301 {"VK_NV_acquire_winrt_display", 1},
302 {"VK_VALVE_mutable_descriptor_type", 1},
303 {"VK_EXT_vertex_input_dynamic_state", 2},
304 {"VK_EXT_physical_device_drm", 1},
305 {"VK_EXT_depth_clip_control", 1},
306 {"VK_EXT_primitive_topology_list_restart", 1},
307 {"VK_KHR_format_feature_flags2", 1},
308 {"VK_FUCHSIA_external_memory", 1},
309 {"VK_FUCHSIA_external_semaphore", 1},
310 {"VK_FUCHSIA_buffer_collection", 2},
311 {"VK_HUAWEI_subpass_shading", 2},
312 {"VK_HUAWEI_invocation_mask", 1},
313 {"VK_NV_external_memory_rdma", 1},
314 {"VK_EXT_extended_dynamic_state2", 1},
315 {"VK_EXT_color_write_enable", 1},
316 {"VK_EXT_global_priority_query", 1},
317 {"VK_EXT_image_view_min_lod", 1},
318 {"VK_EXT_multi_draw", 1},
319 {"VK_EXT_load_store_op_none", 1},
320 {"VK_EXT_border_color_swizzle", 1},
321 {"VK_EXT_pageable_device_local_memory", 1},
322 {"VK_KHR_maintenance4", 2},
323 {"VK_QCOM_fragment_density_map_offset", 1},
324 {"VK_NV_linear_color_attachment", 1},
325 };
326
327
328 static VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(
329 const VkInstanceCreateInfo* pCreateInfo,
330 const VkAllocationCallbacks* pAllocator,
331 VkInstance* pInstance);
332
333 static VKAPI_ATTR void VKAPI_CALL DestroyInstance(
334 VkInstance instance,
335 const VkAllocationCallbacks* pAllocator);
336
337 static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(
338 VkInstance instance,
339 uint32_t* pPhysicalDeviceCount,
340 VkPhysicalDevice* pPhysicalDevices);
341
342 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures(
343 VkPhysicalDevice physicalDevice,
344 VkPhysicalDeviceFeatures* pFeatures);
345
346 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties(
347 VkPhysicalDevice physicalDevice,
348 VkFormat format,
349 VkFormatProperties* pFormatProperties);
350
351 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties(
352 VkPhysicalDevice physicalDevice,
353 VkFormat format,
354 VkImageType type,
355 VkImageTiling tiling,
356 VkImageUsageFlags usage,
357 VkImageCreateFlags flags,
358 VkImageFormatProperties* pImageFormatProperties);
359
360 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties(
361 VkPhysicalDevice physicalDevice,
362 VkPhysicalDeviceProperties* pProperties);
363
364 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(
365 VkPhysicalDevice physicalDevice,
366 uint32_t* pQueueFamilyPropertyCount,
367 VkQueueFamilyProperties* pQueueFamilyProperties);
368
369 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties(
370 VkPhysicalDevice physicalDevice,
371 VkPhysicalDeviceMemoryProperties* pMemoryProperties);
372
373 static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(
374 VkInstance instance,
375 const char* pName);
376
377 static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(
378 VkDevice device,
379 const char* pName);
380
381 static VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(
382 VkPhysicalDevice physicalDevice,
383 const VkDeviceCreateInfo* pCreateInfo,
384 const VkAllocationCallbacks* pAllocator,
385 VkDevice* pDevice);
386
387 static VKAPI_ATTR void VKAPI_CALL DestroyDevice(
388 VkDevice device,
389 const VkAllocationCallbacks* pAllocator);
390
391 static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(
392 const char* pLayerName,
393 uint32_t* pPropertyCount,
394 VkExtensionProperties* pProperties);
395
396 static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(
397 VkPhysicalDevice physicalDevice,
398 const char* pLayerName,
399 uint32_t* pPropertyCount,
400 VkExtensionProperties* pProperties);
401
402 static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(
403 uint32_t* pPropertyCount,
404 VkLayerProperties* pProperties);
405
406 static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(
407 VkPhysicalDevice physicalDevice,
408 uint32_t* pPropertyCount,
409 VkLayerProperties* pProperties);
410
411 static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(
412 VkDevice device,
413 uint32_t queueFamilyIndex,
414 uint32_t queueIndex,
415 VkQueue* pQueue);
416
417 static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(
418 VkQueue queue,
419 uint32_t submitCount,
420 const VkSubmitInfo* pSubmits,
421 VkFence fence);
422
423 static VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle(
424 VkQueue queue);
425
426 static VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle(
427 VkDevice device);
428
429 static VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(
430 VkDevice device,
431 const VkMemoryAllocateInfo* pAllocateInfo,
432 const VkAllocationCallbacks* pAllocator,
433 VkDeviceMemory* pMemory);
434
435 static VKAPI_ATTR void VKAPI_CALL FreeMemory(
436 VkDevice device,
437 VkDeviceMemory memory,
438 const VkAllocationCallbacks* pAllocator);
439
440 static VKAPI_ATTR VkResult VKAPI_CALL MapMemory(
441 VkDevice device,
442 VkDeviceMemory memory,
443 VkDeviceSize offset,
444 VkDeviceSize size,
445 VkMemoryMapFlags flags,
446 void** ppData);
447
448 static VKAPI_ATTR void VKAPI_CALL UnmapMemory(
449 VkDevice device,
450 VkDeviceMemory memory);
451
452 static VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges(
453 VkDevice device,
454 uint32_t memoryRangeCount,
455 const VkMappedMemoryRange* pMemoryRanges);
456
457 static VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges(
458 VkDevice device,
459 uint32_t memoryRangeCount,
460 const VkMappedMemoryRange* pMemoryRanges);
461
462 static VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment(
463 VkDevice device,
464 VkDeviceMemory memory,
465 VkDeviceSize* pCommittedMemoryInBytes);
466
467 static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(
468 VkDevice device,
469 VkBuffer buffer,
470 VkDeviceMemory memory,
471 VkDeviceSize memoryOffset);
472
473 static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(
474 VkDevice device,
475 VkImage image,
476 VkDeviceMemory memory,
477 VkDeviceSize memoryOffset);
478
479 static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements(
480 VkDevice device,
481 VkBuffer buffer,
482 VkMemoryRequirements* pMemoryRequirements);
483
484 static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements(
485 VkDevice device,
486 VkImage image,
487 VkMemoryRequirements* pMemoryRequirements);
488
489 static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements(
490 VkDevice device,
491 VkImage image,
492 uint32_t* pSparseMemoryRequirementCount,
493 VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
494
495 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties(
496 VkPhysicalDevice physicalDevice,
497 VkFormat format,
498 VkImageType type,
499 VkSampleCountFlagBits samples,
500 VkImageUsageFlags usage,
501 VkImageTiling tiling,
502 uint32_t* pPropertyCount,
503 VkSparseImageFormatProperties* pProperties);
504
505 static VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse(
506 VkQueue queue,
507 uint32_t bindInfoCount,
508 const VkBindSparseInfo* pBindInfo,
509 VkFence fence);
510
511 static VKAPI_ATTR VkResult VKAPI_CALL CreateFence(
512 VkDevice device,
513 const VkFenceCreateInfo* pCreateInfo,
514 const VkAllocationCallbacks* pAllocator,
515 VkFence* pFence);
516
517 static VKAPI_ATTR void VKAPI_CALL DestroyFence(
518 VkDevice device,
519 VkFence fence,
520 const VkAllocationCallbacks* pAllocator);
521
522 static VKAPI_ATTR VkResult VKAPI_CALL ResetFences(
523 VkDevice device,
524 uint32_t fenceCount,
525 const VkFence* pFences);
526
527 static VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus(
528 VkDevice device,
529 VkFence fence);
530
531 static VKAPI_ATTR VkResult VKAPI_CALL WaitForFences(
532 VkDevice device,
533 uint32_t fenceCount,
534 const VkFence* pFences,
535 VkBool32 waitAll,
536 uint64_t timeout);
537
538 static VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore(
539 VkDevice device,
540 const VkSemaphoreCreateInfo* pCreateInfo,
541 const VkAllocationCallbacks* pAllocator,
542 VkSemaphore* pSemaphore);
543
544 static VKAPI_ATTR void VKAPI_CALL DestroySemaphore(
545 VkDevice device,
546 VkSemaphore semaphore,
547 const VkAllocationCallbacks* pAllocator);
548
549 static VKAPI_ATTR VkResult VKAPI_CALL CreateEvent(
550 VkDevice device,
551 const VkEventCreateInfo* pCreateInfo,
552 const VkAllocationCallbacks* pAllocator,
553 VkEvent* pEvent);
554
555 static VKAPI_ATTR void VKAPI_CALL DestroyEvent(
556 VkDevice device,
557 VkEvent event,
558 const VkAllocationCallbacks* pAllocator);
559
560 static VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus(
561 VkDevice device,
562 VkEvent event);
563
564 static VKAPI_ATTR VkResult VKAPI_CALL SetEvent(
565 VkDevice device,
566 VkEvent event);
567
568 static VKAPI_ATTR VkResult VKAPI_CALL ResetEvent(
569 VkDevice device,
570 VkEvent event);
571
572 static VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool(
573 VkDevice device,
574 const VkQueryPoolCreateInfo* pCreateInfo,
575 const VkAllocationCallbacks* pAllocator,
576 VkQueryPool* pQueryPool);
577
578 static VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(
579 VkDevice device,
580 VkQueryPool queryPool,
581 const VkAllocationCallbacks* pAllocator);
582
583 static VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults(
584 VkDevice device,
585 VkQueryPool queryPool,
586 uint32_t firstQuery,
587 uint32_t queryCount,
588 size_t dataSize,
589 void* pData,
590 VkDeviceSize stride,
591 VkQueryResultFlags flags);
592
593 static VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(
594 VkDevice device,
595 const VkBufferCreateInfo* pCreateInfo,
596 const VkAllocationCallbacks* pAllocator,
597 VkBuffer* pBuffer);
598
599 static VKAPI_ATTR void VKAPI_CALL DestroyBuffer(
600 VkDevice device,
601 VkBuffer buffer,
602 const VkAllocationCallbacks* pAllocator);
603
604 static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView(
605 VkDevice device,
606 const VkBufferViewCreateInfo* pCreateInfo,
607 const VkAllocationCallbacks* pAllocator,
608 VkBufferView* pView);
609
610 static VKAPI_ATTR void VKAPI_CALL DestroyBufferView(
611 VkDevice device,
612 VkBufferView bufferView,
613 const VkAllocationCallbacks* pAllocator);
614
615 static VKAPI_ATTR VkResult VKAPI_CALL CreateImage(
616 VkDevice device,
617 const VkImageCreateInfo* pCreateInfo,
618 const VkAllocationCallbacks* pAllocator,
619 VkImage* pImage);
620
621 static VKAPI_ATTR void VKAPI_CALL DestroyImage(
622 VkDevice device,
623 VkImage image,
624 const VkAllocationCallbacks* pAllocator);
625
626 static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout(
627 VkDevice device,
628 VkImage image,
629 const VkImageSubresource* pSubresource,
630 VkSubresourceLayout* pLayout);
631
632 static VKAPI_ATTR VkResult VKAPI_CALL CreateImageView(
633 VkDevice device,
634 const VkImageViewCreateInfo* pCreateInfo,
635 const VkAllocationCallbacks* pAllocator,
636 VkImageView* pView);
637
638 static VKAPI_ATTR void VKAPI_CALL DestroyImageView(
639 VkDevice device,
640 VkImageView imageView,
641 const VkAllocationCallbacks* pAllocator);
642
643 static VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(
644 VkDevice device,
645 const VkShaderModuleCreateInfo* pCreateInfo,
646 const VkAllocationCallbacks* pAllocator,
647 VkShaderModule* pShaderModule);
648
649 static VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(
650 VkDevice device,
651 VkShaderModule shaderModule,
652 const VkAllocationCallbacks* pAllocator);
653
654 static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache(
655 VkDevice device,
656 const VkPipelineCacheCreateInfo* pCreateInfo,
657 const VkAllocationCallbacks* pAllocator,
658 VkPipelineCache* pPipelineCache);
659
660 static VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache(
661 VkDevice device,
662 VkPipelineCache pipelineCache,
663 const VkAllocationCallbacks* pAllocator);
664
665 static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData(
666 VkDevice device,
667 VkPipelineCache pipelineCache,
668 size_t* pDataSize,
669 void* pData);
670
671 static VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches(
672 VkDevice device,
673 VkPipelineCache dstCache,
674 uint32_t srcCacheCount,
675 const VkPipelineCache* pSrcCaches);
676
677 static VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(
678 VkDevice device,
679 VkPipelineCache pipelineCache,
680 uint32_t createInfoCount,
681 const VkGraphicsPipelineCreateInfo* pCreateInfos,
682 const VkAllocationCallbacks* pAllocator,
683 VkPipeline* pPipelines);
684
685 static VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(
686 VkDevice device,
687 VkPipelineCache pipelineCache,
688 uint32_t createInfoCount,
689 const VkComputePipelineCreateInfo* pCreateInfos,
690 const VkAllocationCallbacks* pAllocator,
691 VkPipeline* pPipelines);
692
693 static VKAPI_ATTR void VKAPI_CALL DestroyPipeline(
694 VkDevice device,
695 VkPipeline pipeline,
696 const VkAllocationCallbacks* pAllocator);
697
698 static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(
699 VkDevice device,
700 const VkPipelineLayoutCreateInfo* pCreateInfo,
701 const VkAllocationCallbacks* pAllocator,
702 VkPipelineLayout* pPipelineLayout);
703
704 static VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(
705 VkDevice device,
706 VkPipelineLayout pipelineLayout,
707 const VkAllocationCallbacks* pAllocator);
708
709 static VKAPI_ATTR VkResult VKAPI_CALL CreateSampler(
710 VkDevice device,
711 const VkSamplerCreateInfo* pCreateInfo,
712 const VkAllocationCallbacks* pAllocator,
713 VkSampler* pSampler);
714
715 static VKAPI_ATTR void VKAPI_CALL DestroySampler(
716 VkDevice device,
717 VkSampler sampler,
718 const VkAllocationCallbacks* pAllocator);
719
720 static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(
721 VkDevice device,
722 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
723 const VkAllocationCallbacks* pAllocator,
724 VkDescriptorSetLayout* pSetLayout);
725
726 static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(
727 VkDevice device,
728 VkDescriptorSetLayout descriptorSetLayout,
729 const VkAllocationCallbacks* pAllocator);
730
731 static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(
732 VkDevice device,
733 const VkDescriptorPoolCreateInfo* pCreateInfo,
734 const VkAllocationCallbacks* pAllocator,
735 VkDescriptorPool* pDescriptorPool);
736
737 static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(
738 VkDevice device,
739 VkDescriptorPool descriptorPool,
740 const VkAllocationCallbacks* pAllocator);
741
742 static VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool(
743 VkDevice device,
744 VkDescriptorPool descriptorPool,
745 VkDescriptorPoolResetFlags flags);
746
747 static VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(
748 VkDevice device,
749 const VkDescriptorSetAllocateInfo* pAllocateInfo,
750 VkDescriptorSet* pDescriptorSets);
751
752 static VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(
753 VkDevice device,
754 VkDescriptorPool descriptorPool,
755 uint32_t descriptorSetCount,
756 const VkDescriptorSet* pDescriptorSets);
757
758 static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(
759 VkDevice device,
760 uint32_t descriptorWriteCount,
761 const VkWriteDescriptorSet* pDescriptorWrites,
762 uint32_t descriptorCopyCount,
763 const VkCopyDescriptorSet* pDescriptorCopies);
764
765 static VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer(
766 VkDevice device,
767 const VkFramebufferCreateInfo* pCreateInfo,
768 const VkAllocationCallbacks* pAllocator,
769 VkFramebuffer* pFramebuffer);
770
771 static VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(
772 VkDevice device,
773 VkFramebuffer framebuffer,
774 const VkAllocationCallbacks* pAllocator);
775
776 static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass(
777 VkDevice device,
778 const VkRenderPassCreateInfo* pCreateInfo,
779 const VkAllocationCallbacks* pAllocator,
780 VkRenderPass* pRenderPass);
781
782 static VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(
783 VkDevice device,
784 VkRenderPass renderPass,
785 const VkAllocationCallbacks* pAllocator);
786
787 static VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity(
788 VkDevice device,
789 VkRenderPass renderPass,
790 VkExtent2D* pGranularity);
791
792 static VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool(
793 VkDevice device,
794 const VkCommandPoolCreateInfo* pCreateInfo,
795 const VkAllocationCallbacks* pAllocator,
796 VkCommandPool* pCommandPool);
797
798 static VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(
799 VkDevice device,
800 VkCommandPool commandPool,
801 const VkAllocationCallbacks* pAllocator);
802
803 static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(
804 VkDevice device,
805 VkCommandPool commandPool,
806 VkCommandPoolResetFlags flags);
807
808 static VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(
809 VkDevice device,
810 const VkCommandBufferAllocateInfo* pAllocateInfo,
811 VkCommandBuffer* pCommandBuffers);
812
813 static VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(
814 VkDevice device,
815 VkCommandPool commandPool,
816 uint32_t commandBufferCount,
817 const VkCommandBuffer* pCommandBuffers);
818
819 static VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(
820 VkCommandBuffer commandBuffer,
821 const VkCommandBufferBeginInfo* pBeginInfo);
822
823 static VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(
824 VkCommandBuffer commandBuffer);
825
826 static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(
827 VkCommandBuffer commandBuffer,
828 VkCommandBufferResetFlags flags);
829
830 static VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(
831 VkCommandBuffer commandBuffer,
832 VkPipelineBindPoint pipelineBindPoint,
833 VkPipeline pipeline);
834
835 static VKAPI_ATTR void VKAPI_CALL CmdSetViewport(
836 VkCommandBuffer commandBuffer,
837 uint32_t firstViewport,
838 uint32_t viewportCount,
839 const VkViewport* pViewports);
840
841 static VKAPI_ATTR void VKAPI_CALL CmdSetScissor(
842 VkCommandBuffer commandBuffer,
843 uint32_t firstScissor,
844 uint32_t scissorCount,
845 const VkRect2D* pScissors);
846
847 static VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth(
848 VkCommandBuffer commandBuffer,
849 float lineWidth);
850
851 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(
852 VkCommandBuffer commandBuffer,
853 float depthBiasConstantFactor,
854 float depthBiasClamp,
855 float depthBiasSlopeFactor);
856
857 static VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(
858 VkCommandBuffer commandBuffer,
859 const float blendConstants[4]);
860
861 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds(
862 VkCommandBuffer commandBuffer,
863 float minDepthBounds,
864 float maxDepthBounds);
865
866 static VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(
867 VkCommandBuffer commandBuffer,
868 VkStencilFaceFlags faceMask,
869 uint32_t compareMask);
870
871 static VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(
872 VkCommandBuffer commandBuffer,
873 VkStencilFaceFlags faceMask,
874 uint32_t writeMask);
875
876 static VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference(
877 VkCommandBuffer commandBuffer,
878 VkStencilFaceFlags faceMask,
879 uint32_t reference);
880
881 static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets(
882 VkCommandBuffer commandBuffer,
883 VkPipelineBindPoint pipelineBindPoint,
884 VkPipelineLayout layout,
885 uint32_t firstSet,
886 uint32_t descriptorSetCount,
887 const VkDescriptorSet* pDescriptorSets,
888 uint32_t dynamicOffsetCount,
889 const uint32_t* pDynamicOffsets);
890
891 static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(
892 VkCommandBuffer commandBuffer,
893 VkBuffer buffer,
894 VkDeviceSize offset,
895 VkIndexType indexType);
896
897 static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(
898 VkCommandBuffer commandBuffer,
899 uint32_t firstBinding,
900 uint32_t bindingCount,
901 const VkBuffer* pBuffers,
902 const VkDeviceSize* pOffsets);
903
904 static VKAPI_ATTR void VKAPI_CALL CmdDraw(
905 VkCommandBuffer commandBuffer,
906 uint32_t vertexCount,
907 uint32_t instanceCount,
908 uint32_t firstVertex,
909 uint32_t firstInstance);
910
911 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(
912 VkCommandBuffer commandBuffer,
913 uint32_t indexCount,
914 uint32_t instanceCount,
915 uint32_t firstIndex,
916 int32_t vertexOffset,
917 uint32_t firstInstance);
918
919 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(
920 VkCommandBuffer commandBuffer,
921 VkBuffer buffer,
922 VkDeviceSize offset,
923 uint32_t drawCount,
924 uint32_t stride);
925
926 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(
927 VkCommandBuffer commandBuffer,
928 VkBuffer buffer,
929 VkDeviceSize offset,
930 uint32_t drawCount,
931 uint32_t stride);
932
933 static VKAPI_ATTR void VKAPI_CALL CmdDispatch(
934 VkCommandBuffer commandBuffer,
935 uint32_t groupCountX,
936 uint32_t groupCountY,
937 uint32_t groupCountZ);
938
939 static VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(
940 VkCommandBuffer commandBuffer,
941 VkBuffer buffer,
942 VkDeviceSize offset);
943
944 static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(
945 VkCommandBuffer commandBuffer,
946 VkBuffer srcBuffer,
947 VkBuffer dstBuffer,
948 uint32_t regionCount,
949 const VkBufferCopy* pRegions);
950
951 static VKAPI_ATTR void VKAPI_CALL CmdCopyImage(
952 VkCommandBuffer commandBuffer,
953 VkImage srcImage,
954 VkImageLayout srcImageLayout,
955 VkImage dstImage,
956 VkImageLayout dstImageLayout,
957 uint32_t regionCount,
958 const VkImageCopy* pRegions);
959
960 static VKAPI_ATTR void VKAPI_CALL CmdBlitImage(
961 VkCommandBuffer commandBuffer,
962 VkImage srcImage,
963 VkImageLayout srcImageLayout,
964 VkImage dstImage,
965 VkImageLayout dstImageLayout,
966 uint32_t regionCount,
967 const VkImageBlit* pRegions,
968 VkFilter filter);
969
970 static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(
971 VkCommandBuffer commandBuffer,
972 VkBuffer srcBuffer,
973 VkImage dstImage,
974 VkImageLayout dstImageLayout,
975 uint32_t regionCount,
976 const VkBufferImageCopy* pRegions);
977
978 static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(
979 VkCommandBuffer commandBuffer,
980 VkImage srcImage,
981 VkImageLayout srcImageLayout,
982 VkBuffer dstBuffer,
983 uint32_t regionCount,
984 const VkBufferImageCopy* pRegions);
985
986 static VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(
987 VkCommandBuffer commandBuffer,
988 VkBuffer dstBuffer,
989 VkDeviceSize dstOffset,
990 VkDeviceSize dataSize,
991 const void* pData);
992
993 static VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(
994 VkCommandBuffer commandBuffer,
995 VkBuffer dstBuffer,
996 VkDeviceSize dstOffset,
997 VkDeviceSize size,
998 uint32_t data);
999
1000 static VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(
1001 VkCommandBuffer commandBuffer,
1002 VkImage image,
1003 VkImageLayout imageLayout,
1004 const VkClearColorValue* pColor,
1005 uint32_t rangeCount,
1006 const VkImageSubresourceRange* pRanges);
1007
1008 static VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(
1009 VkCommandBuffer commandBuffer,
1010 VkImage image,
1011 VkImageLayout imageLayout,
1012 const VkClearDepthStencilValue* pDepthStencil,
1013 uint32_t rangeCount,
1014 const VkImageSubresourceRange* pRanges);
1015
1016 static VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(
1017 VkCommandBuffer commandBuffer,
1018 uint32_t attachmentCount,
1019 const VkClearAttachment* pAttachments,
1020 uint32_t rectCount,
1021 const VkClearRect* pRects);
1022
1023 static VKAPI_ATTR void VKAPI_CALL CmdResolveImage(
1024 VkCommandBuffer commandBuffer,
1025 VkImage srcImage,
1026 VkImageLayout srcImageLayout,
1027 VkImage dstImage,
1028 VkImageLayout dstImageLayout,
1029 uint32_t regionCount,
1030 const VkImageResolve* pRegions);
1031
1032 static VKAPI_ATTR void VKAPI_CALL CmdSetEvent(
1033 VkCommandBuffer commandBuffer,
1034 VkEvent event,
1035 VkPipelineStageFlags stageMask);
1036
1037 static VKAPI_ATTR void VKAPI_CALL CmdResetEvent(
1038 VkCommandBuffer commandBuffer,
1039 VkEvent event,
1040 VkPipelineStageFlags stageMask);
1041
1042 static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents(
1043 VkCommandBuffer commandBuffer,
1044 uint32_t eventCount,
1045 const VkEvent* pEvents,
1046 VkPipelineStageFlags srcStageMask,
1047 VkPipelineStageFlags dstStageMask,
1048 uint32_t memoryBarrierCount,
1049 const VkMemoryBarrier* pMemoryBarriers,
1050 uint32_t bufferMemoryBarrierCount,
1051 const VkBufferMemoryBarrier* pBufferMemoryBarriers,
1052 uint32_t imageMemoryBarrierCount,
1053 const VkImageMemoryBarrier* pImageMemoryBarriers);
1054
1055 static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier(
1056 VkCommandBuffer commandBuffer,
1057 VkPipelineStageFlags srcStageMask,
1058 VkPipelineStageFlags dstStageMask,
1059 VkDependencyFlags dependencyFlags,
1060 uint32_t memoryBarrierCount,
1061 const VkMemoryBarrier* pMemoryBarriers,
1062 uint32_t bufferMemoryBarrierCount,
1063 const VkBufferMemoryBarrier* pBufferMemoryBarriers,
1064 uint32_t imageMemoryBarrierCount,
1065 const VkImageMemoryBarrier* pImageMemoryBarriers);
1066
1067 static VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(
1068 VkCommandBuffer commandBuffer,
1069 VkQueryPool queryPool,
1070 uint32_t query,
1071 VkQueryControlFlags flags);
1072
1073 static VKAPI_ATTR void VKAPI_CALL CmdEndQuery(
1074 VkCommandBuffer commandBuffer,
1075 VkQueryPool queryPool,
1076 uint32_t query);
1077
1078 static VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(
1079 VkCommandBuffer commandBuffer,
1080 VkQueryPool queryPool,
1081 uint32_t firstQuery,
1082 uint32_t queryCount);
1083
1084 static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(
1085 VkCommandBuffer commandBuffer,
1086 VkPipelineStageFlagBits pipelineStage,
1087 VkQueryPool queryPool,
1088 uint32_t query);
1089
1090 static VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults(
1091 VkCommandBuffer commandBuffer,
1092 VkQueryPool queryPool,
1093 uint32_t firstQuery,
1094 uint32_t queryCount,
1095 VkBuffer dstBuffer,
1096 VkDeviceSize dstOffset,
1097 VkDeviceSize stride,
1098 VkQueryResultFlags flags);
1099
1100 static VKAPI_ATTR void VKAPI_CALL CmdPushConstants(
1101 VkCommandBuffer commandBuffer,
1102 VkPipelineLayout layout,
1103 VkShaderStageFlags stageFlags,
1104 uint32_t offset,
1105 uint32_t size,
1106 const void* pValues);
1107
1108 static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(
1109 VkCommandBuffer commandBuffer,
1110 const VkRenderPassBeginInfo* pRenderPassBegin,
1111 VkSubpassContents contents);
1112
1113 static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(
1114 VkCommandBuffer commandBuffer,
1115 VkSubpassContents contents);
1116
1117 static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass(
1118 VkCommandBuffer commandBuffer);
1119
1120 static VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(
1121 VkCommandBuffer commandBuffer,
1122 uint32_t commandBufferCount,
1123 const VkCommandBuffer* pCommandBuffers);
1124
1125
1126 static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceVersion(
1127 uint32_t* pApiVersion);
1128
1129 static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2(
1130 VkDevice device,
1131 uint32_t bindInfoCount,
1132 const VkBindBufferMemoryInfo* pBindInfos);
1133
1134 static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2(
1135 VkDevice device,
1136 uint32_t bindInfoCount,
1137 const VkBindImageMemoryInfo* pBindInfos);
1138
1139 static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeatures(
1140 VkDevice device,
1141 uint32_t heapIndex,
1142 uint32_t localDeviceIndex,
1143 uint32_t remoteDeviceIndex,
1144 VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
1145
1146 static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMask(
1147 VkCommandBuffer commandBuffer,
1148 uint32_t deviceMask);
1149
1150 static VKAPI_ATTR void VKAPI_CALL CmdDispatchBase(
1151 VkCommandBuffer commandBuffer,
1152 uint32_t baseGroupX,
1153 uint32_t baseGroupY,
1154 uint32_t baseGroupZ,
1155 uint32_t groupCountX,
1156 uint32_t groupCountY,
1157 uint32_t groupCountZ);
1158
1159 static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroups(
1160 VkInstance instance,
1161 uint32_t* pPhysicalDeviceGroupCount,
1162 VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
1163
1164 static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2(
1165 VkDevice device,
1166 const VkImageMemoryRequirementsInfo2* pInfo,
1167 VkMemoryRequirements2* pMemoryRequirements);
1168
1169 static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2(
1170 VkDevice device,
1171 const VkBufferMemoryRequirementsInfo2* pInfo,
1172 VkMemoryRequirements2* pMemoryRequirements);
1173
1174 static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2(
1175 VkDevice device,
1176 const VkImageSparseMemoryRequirementsInfo2* pInfo,
1177 uint32_t* pSparseMemoryRequirementCount,
1178 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
1179
1180 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2(
1181 VkPhysicalDevice physicalDevice,
1182 VkPhysicalDeviceFeatures2* pFeatures);
1183
1184 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2(
1185 VkPhysicalDevice physicalDevice,
1186 VkPhysicalDeviceProperties2* pProperties);
1187
1188 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2(
1189 VkPhysicalDevice physicalDevice,
1190 VkFormat format,
1191 VkFormatProperties2* pFormatProperties);
1192
1193 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2(
1194 VkPhysicalDevice physicalDevice,
1195 const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
1196 VkImageFormatProperties2* pImageFormatProperties);
1197
1198 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2(
1199 VkPhysicalDevice physicalDevice,
1200 uint32_t* pQueueFamilyPropertyCount,
1201 VkQueueFamilyProperties2* pQueueFamilyProperties);
1202
1203 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2(
1204 VkPhysicalDevice physicalDevice,
1205 VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
1206
1207 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2(
1208 VkPhysicalDevice physicalDevice,
1209 const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
1210 uint32_t* pPropertyCount,
1211 VkSparseImageFormatProperties2* pProperties);
1212
1213 static VKAPI_ATTR void VKAPI_CALL TrimCommandPool(
1214 VkDevice device,
1215 VkCommandPool commandPool,
1216 VkCommandPoolTrimFlags flags);
1217
1218 static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2(
1219 VkDevice device,
1220 const VkDeviceQueueInfo2* pQueueInfo,
1221 VkQueue* pQueue);
1222
1223 static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversion(
1224 VkDevice device,
1225 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
1226 const VkAllocationCallbacks* pAllocator,
1227 VkSamplerYcbcrConversion* pYcbcrConversion);
1228
1229 static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversion(
1230 VkDevice device,
1231 VkSamplerYcbcrConversion ycbcrConversion,
1232 const VkAllocationCallbacks* pAllocator);
1233
1234 static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate(
1235 VkDevice device,
1236 const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
1237 const VkAllocationCallbacks* pAllocator,
1238 VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
1239
1240 static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate(
1241 VkDevice device,
1242 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
1243 const VkAllocationCallbacks* pAllocator);
1244
1245 static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate(
1246 VkDevice device,
1247 VkDescriptorSet descriptorSet,
1248 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
1249 const void* pData);
1250
1251 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferProperties(
1252 VkPhysicalDevice physicalDevice,
1253 const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
1254 VkExternalBufferProperties* pExternalBufferProperties);
1255
1256 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFenceProperties(
1257 VkPhysicalDevice physicalDevice,
1258 const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
1259 VkExternalFenceProperties* pExternalFenceProperties);
1260
1261 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphoreProperties(
1262 VkPhysicalDevice physicalDevice,
1263 const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
1264 VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
1265
1266 static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupport(
1267 VkDevice device,
1268 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
1269 VkDescriptorSetLayoutSupport* pSupport);
1270
1271
1272 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCount(
1273 VkCommandBuffer commandBuffer,
1274 VkBuffer buffer,
1275 VkDeviceSize offset,
1276 VkBuffer countBuffer,
1277 VkDeviceSize countBufferOffset,
1278 uint32_t maxDrawCount,
1279 uint32_t stride);
1280
1281 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCount(
1282 VkCommandBuffer commandBuffer,
1283 VkBuffer buffer,
1284 VkDeviceSize offset,
1285 VkBuffer countBuffer,
1286 VkDeviceSize countBufferOffset,
1287 uint32_t maxDrawCount,
1288 uint32_t stride);
1289
1290 static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2(
1291 VkDevice device,
1292 const VkRenderPassCreateInfo2* pCreateInfo,
1293 const VkAllocationCallbacks* pAllocator,
1294 VkRenderPass* pRenderPass);
1295
1296 static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2(
1297 VkCommandBuffer commandBuffer,
1298 const VkRenderPassBeginInfo* pRenderPassBegin,
1299 const VkSubpassBeginInfo* pSubpassBeginInfo);
1300
1301 static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2(
1302 VkCommandBuffer commandBuffer,
1303 const VkSubpassBeginInfo* pSubpassBeginInfo,
1304 const VkSubpassEndInfo* pSubpassEndInfo);
1305
1306 static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2(
1307 VkCommandBuffer commandBuffer,
1308 const VkSubpassEndInfo* pSubpassEndInfo);
1309
1310 static VKAPI_ATTR void VKAPI_CALL ResetQueryPool(
1311 VkDevice device,
1312 VkQueryPool queryPool,
1313 uint32_t firstQuery,
1314 uint32_t queryCount);
1315
1316 static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValue(
1317 VkDevice device,
1318 VkSemaphore semaphore,
1319 uint64_t* pValue);
1320
1321 static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphores(
1322 VkDevice device,
1323 const VkSemaphoreWaitInfo* pWaitInfo,
1324 uint64_t timeout);
1325
1326 static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphore(
1327 VkDevice device,
1328 const VkSemaphoreSignalInfo* pSignalInfo);
1329
1330 static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddress(
1331 VkDevice device,
1332 const VkBufferDeviceAddressInfo* pInfo);
1333
1334 static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddress(
1335 VkDevice device,
1336 const VkBufferDeviceAddressInfo* pInfo);
1337
1338 static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddress(
1339 VkDevice device,
1340 const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
1341
1342
1343 static VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(
1344 VkInstance instance,
1345 VkSurfaceKHR surface,
1346 const VkAllocationCallbacks* pAllocator);
1347
1348 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR(
1349 VkPhysicalDevice physicalDevice,
1350 uint32_t queueFamilyIndex,
1351 VkSurfaceKHR surface,
1352 VkBool32* pSupported);
1353
1354 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(
1355 VkPhysicalDevice physicalDevice,
1356 VkSurfaceKHR surface,
1357 VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
1358
1359 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR(
1360 VkPhysicalDevice physicalDevice,
1361 VkSurfaceKHR surface,
1362 uint32_t* pSurfaceFormatCount,
1363 VkSurfaceFormatKHR* pSurfaceFormats);
1364
1365 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR(
1366 VkPhysicalDevice physicalDevice,
1367 VkSurfaceKHR surface,
1368 uint32_t* pPresentModeCount,
1369 VkPresentModeKHR* pPresentModes);
1370
1371
1372 static VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(
1373 VkDevice device,
1374 const VkSwapchainCreateInfoKHR* pCreateInfo,
1375 const VkAllocationCallbacks* pAllocator,
1376 VkSwapchainKHR* pSwapchain);
1377
1378 static VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(
1379 VkDevice device,
1380 VkSwapchainKHR swapchain,
1381 const VkAllocationCallbacks* pAllocator);
1382
1383 static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(
1384 VkDevice device,
1385 VkSwapchainKHR swapchain,
1386 uint32_t* pSwapchainImageCount,
1387 VkImage* pSwapchainImages);
1388
1389 static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(
1390 VkDevice device,
1391 VkSwapchainKHR swapchain,
1392 uint64_t timeout,
1393 VkSemaphore semaphore,
1394 VkFence fence,
1395 uint32_t* pImageIndex);
1396
1397 static VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(
1398 VkQueue queue,
1399 const VkPresentInfoKHR* pPresentInfo);
1400
1401 static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupPresentCapabilitiesKHR(
1402 VkDevice device,
1403 VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);
1404
1405 static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHR(
1406 VkDevice device,
1407 VkSurfaceKHR surface,
1408 VkDeviceGroupPresentModeFlagsKHR* pModes);
1409
1410 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHR(
1411 VkPhysicalDevice physicalDevice,
1412 VkSurfaceKHR surface,
1413 uint32_t* pRectCount,
1414 VkRect2D* pRects);
1415
1416 static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHR(
1417 VkDevice device,
1418 const VkAcquireNextImageInfoKHR* pAcquireInfo,
1419 uint32_t* pImageIndex);
1420
1421
1422 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR(
1423 VkPhysicalDevice physicalDevice,
1424 uint32_t* pPropertyCount,
1425 VkDisplayPropertiesKHR* pProperties);
1426
1427 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR(
1428 VkPhysicalDevice physicalDevice,
1429 uint32_t* pPropertyCount,
1430 VkDisplayPlanePropertiesKHR* pProperties);
1431
1432 static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR(
1433 VkPhysicalDevice physicalDevice,
1434 uint32_t planeIndex,
1435 uint32_t* pDisplayCount,
1436 VkDisplayKHR* pDisplays);
1437
1438 static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR(
1439 VkPhysicalDevice physicalDevice,
1440 VkDisplayKHR display,
1441 uint32_t* pPropertyCount,
1442 VkDisplayModePropertiesKHR* pProperties);
1443
1444 static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR(
1445 VkPhysicalDevice physicalDevice,
1446 VkDisplayKHR display,
1447 const VkDisplayModeCreateInfoKHR* pCreateInfo,
1448 const VkAllocationCallbacks* pAllocator,
1449 VkDisplayModeKHR* pMode);
1450
1451 static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR(
1452 VkPhysicalDevice physicalDevice,
1453 VkDisplayModeKHR mode,
1454 uint32_t planeIndex,
1455 VkDisplayPlaneCapabilitiesKHR* pCapabilities);
1456
1457 static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR(
1458 VkInstance instance,
1459 const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
1460 const VkAllocationCallbacks* pAllocator,
1461 VkSurfaceKHR* pSurface);
1462
1463
1464 static VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(
1465 VkDevice device,
1466 uint32_t swapchainCount,
1467 const VkSwapchainCreateInfoKHR* pCreateInfos,
1468 const VkAllocationCallbacks* pAllocator,
1469 VkSwapchainKHR* pSwapchains);
1470
1471 #ifdef VK_USE_PLATFORM_XLIB_KHR
1472
1473 static VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR(
1474 VkInstance instance,
1475 const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
1476 const VkAllocationCallbacks* pAllocator,
1477 VkSurfaceKHR* pSurface);
1478
1479 static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR(
1480 VkPhysicalDevice physicalDevice,
1481 uint32_t queueFamilyIndex,
1482 Display* dpy,
1483 VisualID visualID);
1484 #endif /* VK_USE_PLATFORM_XLIB_KHR */
1485
1486 #ifdef VK_USE_PLATFORM_XCB_KHR
1487
1488 static VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR(
1489 VkInstance instance,
1490 const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
1491 const VkAllocationCallbacks* pAllocator,
1492 VkSurfaceKHR* pSurface);
1493
1494 static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR(
1495 VkPhysicalDevice physicalDevice,
1496 uint32_t queueFamilyIndex,
1497 xcb_connection_t* connection,
1498 xcb_visualid_t visual_id);
1499 #endif /* VK_USE_PLATFORM_XCB_KHR */
1500
1501 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
1502
1503 static VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR(
1504 VkInstance instance,
1505 const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
1506 const VkAllocationCallbacks* pAllocator,
1507 VkSurfaceKHR* pSurface);
1508
1509 static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR(
1510 VkPhysicalDevice physicalDevice,
1511 uint32_t queueFamilyIndex,
1512 struct wl_display* display);
1513 #endif /* VK_USE_PLATFORM_WAYLAND_KHR */
1514
1515 #ifdef VK_USE_PLATFORM_ANDROID_KHR
1516
1517 static VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR(
1518 VkInstance instance,
1519 const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
1520 const VkAllocationCallbacks* pAllocator,
1521 VkSurfaceKHR* pSurface);
1522 #endif /* VK_USE_PLATFORM_ANDROID_KHR */
1523
1524 #ifdef VK_USE_PLATFORM_WIN32_KHR
1525
1526 static VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR(
1527 VkInstance instance,
1528 const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
1529 const VkAllocationCallbacks* pAllocator,
1530 VkSurfaceKHR* pSurface);
1531
1532 static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR(
1533 VkPhysicalDevice physicalDevice,
1534 uint32_t queueFamilyIndex);
1535 #endif /* VK_USE_PLATFORM_WIN32_KHR */
1536
1537
1538 #ifdef VK_ENABLE_BETA_EXTENSIONS
1539
1540 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoCapabilitiesKHR(
1541 VkPhysicalDevice physicalDevice,
1542 const VkVideoProfileKHR* pVideoProfile,
1543 VkVideoCapabilitiesKHR* pCapabilities);
1544
1545 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoFormatPropertiesKHR(
1546 VkPhysicalDevice physicalDevice,
1547 const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo,
1548 uint32_t* pVideoFormatPropertyCount,
1549 VkVideoFormatPropertiesKHR* pVideoFormatProperties);
1550
1551 static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionKHR(
1552 VkDevice device,
1553 const VkVideoSessionCreateInfoKHR* pCreateInfo,
1554 const VkAllocationCallbacks* pAllocator,
1555 VkVideoSessionKHR* pVideoSession);
1556
1557 static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionKHR(
1558 VkDevice device,
1559 VkVideoSessionKHR videoSession,
1560 const VkAllocationCallbacks* pAllocator);
1561
1562 static VKAPI_ATTR VkResult VKAPI_CALL GetVideoSessionMemoryRequirementsKHR(
1563 VkDevice device,
1564 VkVideoSessionKHR videoSession,
1565 uint32_t* pVideoSessionMemoryRequirementsCount,
1566 VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements);
1567
1568 static VKAPI_ATTR VkResult VKAPI_CALL BindVideoSessionMemoryKHR(
1569 VkDevice device,
1570 VkVideoSessionKHR videoSession,
1571 uint32_t videoSessionBindMemoryCount,
1572 const VkVideoBindMemoryKHR* pVideoSessionBindMemories);
1573
1574 static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionParametersKHR(
1575 VkDevice device,
1576 const VkVideoSessionParametersCreateInfoKHR* pCreateInfo,
1577 const VkAllocationCallbacks* pAllocator,
1578 VkVideoSessionParametersKHR* pVideoSessionParameters);
1579
1580 static VKAPI_ATTR VkResult VKAPI_CALL UpdateVideoSessionParametersKHR(
1581 VkDevice device,
1582 VkVideoSessionParametersKHR videoSessionParameters,
1583 const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo);
1584
1585 static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionParametersKHR(
1586 VkDevice device,
1587 VkVideoSessionParametersKHR videoSessionParameters,
1588 const VkAllocationCallbacks* pAllocator);
1589
1590 static VKAPI_ATTR void VKAPI_CALL CmdBeginVideoCodingKHR(
1591 VkCommandBuffer commandBuffer,
1592 const VkVideoBeginCodingInfoKHR* pBeginInfo);
1593
1594 static VKAPI_ATTR void VKAPI_CALL CmdEndVideoCodingKHR(
1595 VkCommandBuffer commandBuffer,
1596 const VkVideoEndCodingInfoKHR* pEndCodingInfo);
1597
1598 static VKAPI_ATTR void VKAPI_CALL CmdControlVideoCodingKHR(
1599 VkCommandBuffer commandBuffer,
1600 const VkVideoCodingControlInfoKHR* pCodingControlInfo);
1601 #endif /* VK_ENABLE_BETA_EXTENSIONS */
1602
1603 #ifdef VK_ENABLE_BETA_EXTENSIONS
1604
1605 static VKAPI_ATTR void VKAPI_CALL CmdDecodeVideoKHR(
1606 VkCommandBuffer commandBuffer,
1607 const VkVideoDecodeInfoKHR* pFrameInfo);
1608 #endif /* VK_ENABLE_BETA_EXTENSIONS */
1609
1610
1611 static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderingKHR(
1612 VkCommandBuffer commandBuffer,
1613 const VkRenderingInfoKHR* pRenderingInfo);
1614
1615 static VKAPI_ATTR void VKAPI_CALL CmdEndRenderingKHR(
1616 VkCommandBuffer commandBuffer);
1617
1618
1619
1620 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR(
1621 VkPhysicalDevice physicalDevice,
1622 VkPhysicalDeviceFeatures2* pFeatures);
1623
1624 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR(
1625 VkPhysicalDevice physicalDevice,
1626 VkPhysicalDeviceProperties2* pProperties);
1627
1628 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR(
1629 VkPhysicalDevice physicalDevice,
1630 VkFormat format,
1631 VkFormatProperties2* pFormatProperties);
1632
1633 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR(
1634 VkPhysicalDevice physicalDevice,
1635 const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
1636 VkImageFormatProperties2* pImageFormatProperties);
1637
1638 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(
1639 VkPhysicalDevice physicalDevice,
1640 uint32_t* pQueueFamilyPropertyCount,
1641 VkQueueFamilyProperties2* pQueueFamilyProperties);
1642
1643 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR(
1644 VkPhysicalDevice physicalDevice,
1645 VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
1646
1647 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR(
1648 VkPhysicalDevice physicalDevice,
1649 const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
1650 uint32_t* pPropertyCount,
1651 VkSparseImageFormatProperties2* pProperties);
1652
1653
1654 static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHR(
1655 VkDevice device,
1656 uint32_t heapIndex,
1657 uint32_t localDeviceIndex,
1658 uint32_t remoteDeviceIndex,
1659 VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
1660
1661 static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHR(
1662 VkCommandBuffer commandBuffer,
1663 uint32_t deviceMask);
1664
1665 static VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHR(
1666 VkCommandBuffer commandBuffer,
1667 uint32_t baseGroupX,
1668 uint32_t baseGroupY,
1669 uint32_t baseGroupZ,
1670 uint32_t groupCountX,
1671 uint32_t groupCountY,
1672 uint32_t groupCountZ);
1673
1674
1675
1676 static VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(
1677 VkDevice device,
1678 VkCommandPool commandPool,
1679 VkCommandPoolTrimFlags flags);
1680
1681
1682 static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHR(
1683 VkInstance instance,
1684 uint32_t* pPhysicalDeviceGroupCount,
1685 VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
1686
1687
1688 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR(
1689 VkPhysicalDevice physicalDevice,
1690 const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
1691 VkExternalBufferProperties* pExternalBufferProperties);
1692
1693
1694 #ifdef VK_USE_PLATFORM_WIN32_KHR
1695
1696 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR(
1697 VkDevice device,
1698 const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
1699 HANDLE* pHandle);
1700
1701 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR(
1702 VkDevice device,
1703 VkExternalMemoryHandleTypeFlagBits handleType,
1704 HANDLE handle,
1705 VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
1706 #endif /* VK_USE_PLATFORM_WIN32_KHR */
1707
1708
1709 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR(
1710 VkDevice device,
1711 const VkMemoryGetFdInfoKHR* pGetFdInfo,
1712 int* pFd);
1713
1714 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR(
1715 VkDevice device,
1716 VkExternalMemoryHandleTypeFlagBits handleType,
1717 int fd,
1718 VkMemoryFdPropertiesKHR* pMemoryFdProperties);
1719
1720 #ifdef VK_USE_PLATFORM_WIN32_KHR
1721 #endif /* VK_USE_PLATFORM_WIN32_KHR */
1722
1723
1724 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR(
1725 VkPhysicalDevice physicalDevice,
1726 const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
1727 VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
1728
1729
1730 #ifdef VK_USE_PLATFORM_WIN32_KHR
1731
1732 static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHR(
1733 VkDevice device,
1734 const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
1735
1736 static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR(
1737 VkDevice device,
1738 const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
1739 HANDLE* pHandle);
1740 #endif /* VK_USE_PLATFORM_WIN32_KHR */
1741
1742
1743 static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR(
1744 VkDevice device,
1745 const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
1746
1747 static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR(
1748 VkDevice device,
1749 const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
1750 int* pFd);
1751
1752
1753 static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(
1754 VkCommandBuffer commandBuffer,
1755 VkPipelineBindPoint pipelineBindPoint,
1756 VkPipelineLayout layout,
1757 uint32_t set,
1758 uint32_t descriptorWriteCount,
1759 const VkWriteDescriptorSet* pDescriptorWrites);
1760
1761 static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(
1762 VkCommandBuffer commandBuffer,
1763 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
1764 VkPipelineLayout layout,
1765 uint32_t set,
1766 const void* pData);
1767
1768
1769
1770
1771
1772 static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(
1773 VkDevice device,
1774 const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
1775 const VkAllocationCallbacks* pAllocator,
1776 VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
1777
1778 static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(
1779 VkDevice device,
1780 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
1781 const VkAllocationCallbacks* pAllocator);
1782
1783 static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR(
1784 VkDevice device,
1785 VkDescriptorSet descriptorSet,
1786 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
1787 const void* pData);
1788
1789
1790
1791 static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2KHR(
1792 VkDevice device,
1793 const VkRenderPassCreateInfo2* pCreateInfo,
1794 const VkAllocationCallbacks* pAllocator,
1795 VkRenderPass* pRenderPass);
1796
1797 static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2KHR(
1798 VkCommandBuffer commandBuffer,
1799 const VkRenderPassBeginInfo* pRenderPassBegin,
1800 const VkSubpassBeginInfo* pSubpassBeginInfo);
1801
1802 static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2KHR(
1803 VkCommandBuffer commandBuffer,
1804 const VkSubpassBeginInfo* pSubpassBeginInfo,
1805 const VkSubpassEndInfo* pSubpassEndInfo);
1806
1807 static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2KHR(
1808 VkCommandBuffer commandBuffer,
1809 const VkSubpassEndInfo* pSubpassEndInfo);
1810
1811
1812 static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR(
1813 VkDevice device,
1814 VkSwapchainKHR swapchain);
1815
1816
1817 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR(
1818 VkPhysicalDevice physicalDevice,
1819 const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
1820 VkExternalFenceProperties* pExternalFenceProperties);
1821
1822
1823 #ifdef VK_USE_PLATFORM_WIN32_KHR
1824
1825 static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR(
1826 VkDevice device,
1827 const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
1828
1829 static VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR(
1830 VkDevice device,
1831 const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
1832 HANDLE* pHandle);
1833 #endif /* VK_USE_PLATFORM_WIN32_KHR */
1834
1835
1836 static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR(
1837 VkDevice device,
1838 const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
1839
1840 static VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR(
1841 VkDevice device,
1842 const VkFenceGetFdInfoKHR* pGetFdInfo,
1843 int* pFd);
1844
1845
1846 static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
1847 VkPhysicalDevice physicalDevice,
1848 uint32_t queueFamilyIndex,
1849 uint32_t* pCounterCount,
1850 VkPerformanceCounterKHR* pCounters,
1851 VkPerformanceCounterDescriptionKHR* pCounterDescriptions);
1852
1853 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
1854 VkPhysicalDevice physicalDevice,
1855 const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo,
1856 uint32_t* pNumPasses);
1857
1858 static VKAPI_ATTR VkResult VKAPI_CALL AcquireProfilingLockKHR(
1859 VkDevice device,
1860 const VkAcquireProfilingLockInfoKHR* pInfo);
1861
1862 static VKAPI_ATTR void VKAPI_CALL ReleaseProfilingLockKHR(
1863 VkDevice device);
1864
1865
1866
1867 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(
1868 VkPhysicalDevice physicalDevice,
1869 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
1870 VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
1871
1872 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(
1873 VkPhysicalDevice physicalDevice,
1874 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
1875 uint32_t* pSurfaceFormatCount,
1876 VkSurfaceFormat2KHR* pSurfaceFormats);
1877
1878
1879
1880 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayProperties2KHR(
1881 VkPhysicalDevice physicalDevice,
1882 uint32_t* pPropertyCount,
1883 VkDisplayProperties2KHR* pProperties);
1884
1885 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlaneProperties2KHR(
1886 VkPhysicalDevice physicalDevice,
1887 uint32_t* pPropertyCount,
1888 VkDisplayPlaneProperties2KHR* pProperties);
1889
1890 static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModeProperties2KHR(
1891 VkPhysicalDevice physicalDevice,
1892 VkDisplayKHR display,
1893 uint32_t* pPropertyCount,
1894 VkDisplayModeProperties2KHR* pProperties);
1895
1896 static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilities2KHR(
1897 VkPhysicalDevice physicalDevice,
1898 const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
1899 VkDisplayPlaneCapabilities2KHR* pCapabilities);
1900
1901
1902
1903
1904
1905 static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR(
1906 VkDevice device,
1907 const VkImageMemoryRequirementsInfo2* pInfo,
1908 VkMemoryRequirements2* pMemoryRequirements);
1909
1910 static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR(
1911 VkDevice device,
1912 const VkBufferMemoryRequirementsInfo2* pInfo,
1913 VkMemoryRequirements2* pMemoryRequirements);
1914
1915 static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR(
1916 VkDevice device,
1917 const VkImageSparseMemoryRequirementsInfo2* pInfo,
1918 uint32_t* pSparseMemoryRequirementCount,
1919 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
1920
1921
1922
1923 static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversionKHR(
1924 VkDevice device,
1925 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
1926 const VkAllocationCallbacks* pAllocator,
1927 VkSamplerYcbcrConversion* pYcbcrConversion);
1928
1929 static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversionKHR(
1930 VkDevice device,
1931 VkSamplerYcbcrConversion ycbcrConversion,
1932 const VkAllocationCallbacks* pAllocator);
1933
1934
1935 static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHR(
1936 VkDevice device,
1937 uint32_t bindInfoCount,
1938 const VkBindBufferMemoryInfo* pBindInfos);
1939
1940 static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHR(
1941 VkDevice device,
1942 uint32_t bindInfoCount,
1943 const VkBindImageMemoryInfo* pBindInfos);
1944
1945 #ifdef VK_ENABLE_BETA_EXTENSIONS
1946 #endif /* VK_ENABLE_BETA_EXTENSIONS */
1947
1948
1949 static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupportKHR(
1950 VkDevice device,
1951 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
1952 VkDescriptorSetLayoutSupport* pSupport);
1953
1954
1955 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountKHR(
1956 VkCommandBuffer commandBuffer,
1957 VkBuffer buffer,
1958 VkDeviceSize offset,
1959 VkBuffer countBuffer,
1960 VkDeviceSize countBufferOffset,
1961 uint32_t maxDrawCount,
1962 uint32_t stride);
1963
1964 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountKHR(
1965 VkCommandBuffer commandBuffer,
1966 VkBuffer buffer,
1967 VkDeviceSize offset,
1968 VkBuffer countBuffer,
1969 VkDeviceSize countBufferOffset,
1970 uint32_t maxDrawCount,
1971 uint32_t stride);
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982 static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValueKHR(
1983 VkDevice device,
1984 VkSemaphore semaphore,
1985 uint64_t* pValue);
1986
1987 static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphoresKHR(
1988 VkDevice device,
1989 const VkSemaphoreWaitInfo* pWaitInfo,
1990 uint64_t timeout);
1991
1992 static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphoreKHR(
1993 VkDevice device,
1994 const VkSemaphoreSignalInfo* pSignalInfo);
1995
1996
1997
1998
1999 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceFragmentShadingRatesKHR(
2000 VkPhysicalDevice physicalDevice,
2001 uint32_t* pFragmentShadingRateCount,
2002 VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates);
2003
2004 static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateKHR(
2005 VkCommandBuffer commandBuffer,
2006 const VkExtent2D* pFragmentSize,
2007 const VkFragmentShadingRateCombinerOpKHR combinerOps[2]);
2008
2009
2010
2011
2012
2013 static VKAPI_ATTR VkResult VKAPI_CALL WaitForPresentKHR(
2014 VkDevice device,
2015 VkSwapchainKHR swapchain,
2016 uint64_t presentId,
2017 uint64_t timeout);
2018
2019
2020
2021 static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressKHR(
2022 VkDevice device,
2023 const VkBufferDeviceAddressInfo* pInfo);
2024
2025 static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddressKHR(
2026 VkDevice device,
2027 const VkBufferDeviceAddressInfo* pInfo);
2028
2029 static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddressKHR(
2030 VkDevice device,
2031 const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
2032
2033
2034 static VKAPI_ATTR VkResult VKAPI_CALL CreateDeferredOperationKHR(
2035 VkDevice device,
2036 const VkAllocationCallbacks* pAllocator,
2037 VkDeferredOperationKHR* pDeferredOperation);
2038
2039 static VKAPI_ATTR void VKAPI_CALL DestroyDeferredOperationKHR(
2040 VkDevice device,
2041 VkDeferredOperationKHR operation,
2042 const VkAllocationCallbacks* pAllocator);
2043
2044 static VKAPI_ATTR uint32_t VKAPI_CALL GetDeferredOperationMaxConcurrencyKHR(
2045 VkDevice device,
2046 VkDeferredOperationKHR operation);
2047
2048 static VKAPI_ATTR VkResult VKAPI_CALL GetDeferredOperationResultKHR(
2049 VkDevice device,
2050 VkDeferredOperationKHR operation);
2051
2052 static VKAPI_ATTR VkResult VKAPI_CALL DeferredOperationJoinKHR(
2053 VkDevice device,
2054 VkDeferredOperationKHR operation);
2055
2056
2057 static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutablePropertiesKHR(
2058 VkDevice device,
2059 const VkPipelineInfoKHR* pPipelineInfo,
2060 uint32_t* pExecutableCount,
2061 VkPipelineExecutablePropertiesKHR* pProperties);
2062
2063 static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableStatisticsKHR(
2064 VkDevice device,
2065 const VkPipelineExecutableInfoKHR* pExecutableInfo,
2066 uint32_t* pStatisticCount,
2067 VkPipelineExecutableStatisticKHR* pStatistics);
2068
2069 static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableInternalRepresentationsKHR(
2070 VkDevice device,
2071 const VkPipelineExecutableInfoKHR* pExecutableInfo,
2072 uint32_t* pInternalRepresentationCount,
2073 VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
2074
2075
2076
2077
2078
2079 #ifdef VK_ENABLE_BETA_EXTENSIONS
2080
2081 static VKAPI_ATTR void VKAPI_CALL CmdEncodeVideoKHR(
2082 VkCommandBuffer commandBuffer,
2083 const VkVideoEncodeInfoKHR* pEncodeInfo);
2084 #endif /* VK_ENABLE_BETA_EXTENSIONS */
2085
2086
2087 static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2KHR(
2088 VkCommandBuffer commandBuffer,
2089 VkEvent event,
2090 const VkDependencyInfoKHR* pDependencyInfo);
2091
2092 static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2KHR(
2093 VkCommandBuffer commandBuffer,
2094 VkEvent event,
2095 VkPipelineStageFlags2KHR stageMask);
2096
2097 static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2KHR(
2098 VkCommandBuffer commandBuffer,
2099 uint32_t eventCount,
2100 const VkEvent* pEvents,
2101 const VkDependencyInfoKHR* pDependencyInfos);
2102
2103 static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2KHR(
2104 VkCommandBuffer commandBuffer,
2105 const VkDependencyInfoKHR* pDependencyInfo);
2106
2107 static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2KHR(
2108 VkCommandBuffer commandBuffer,
2109 VkPipelineStageFlags2KHR stage,
2110 VkQueryPool queryPool,
2111 uint32_t query);
2112
2113 static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2KHR(
2114 VkQueue queue,
2115 uint32_t submitCount,
2116 const VkSubmitInfo2KHR* pSubmits,
2117 VkFence fence);
2118
2119 static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarker2AMD(
2120 VkCommandBuffer commandBuffer,
2121 VkPipelineStageFlags2KHR stage,
2122 VkBuffer dstBuffer,
2123 VkDeviceSize dstOffset,
2124 uint32_t marker);
2125
2126 static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointData2NV(
2127 VkQueue queue,
2128 uint32_t* pCheckpointDataCount,
2129 VkCheckpointData2NV* pCheckpointData);
2130
2131
2132
2133
2134
2135 static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2KHR(
2136 VkCommandBuffer commandBuffer,
2137 const VkCopyBufferInfo2KHR* pCopyBufferInfo);
2138
2139 static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2KHR(
2140 VkCommandBuffer commandBuffer,
2141 const VkCopyImageInfo2KHR* pCopyImageInfo);
2142
2143 static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2KHR(
2144 VkCommandBuffer commandBuffer,
2145 const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo);
2146
2147 static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2KHR(
2148 VkCommandBuffer commandBuffer,
2149 const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo);
2150
2151 static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2KHR(
2152 VkCommandBuffer commandBuffer,
2153 const VkBlitImageInfo2KHR* pBlitImageInfo);
2154
2155 static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2KHR(
2156 VkCommandBuffer commandBuffer,
2157 const VkResolveImageInfo2KHR* pResolveImageInfo);
2158
2159
2160
2161 static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirementsKHR(
2162 VkDevice device,
2163 const VkDeviceBufferMemoryRequirementsKHR* pInfo,
2164 VkMemoryRequirements2* pMemoryRequirements);
2165
2166 static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirementsKHR(
2167 VkDevice device,
2168 const VkDeviceImageMemoryRequirementsKHR* pInfo,
2169 VkMemoryRequirements2* pMemoryRequirements);
2170
2171 static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirementsKHR(
2172 VkDevice device,
2173 const VkDeviceImageMemoryRequirementsKHR* pInfo,
2174 uint32_t* pSparseMemoryRequirementCount,
2175 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
2176
2177
2178 static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(
2179 VkInstance instance,
2180 const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
2181 const VkAllocationCallbacks* pAllocator,
2182 VkDebugReportCallbackEXT* pCallback);
2183
2184 static VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(
2185 VkInstance instance,
2186 VkDebugReportCallbackEXT callback,
2187 const VkAllocationCallbacks* pAllocator);
2188
2189 static VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(
2190 VkInstance instance,
2191 VkDebugReportFlagsEXT flags,
2192 VkDebugReportObjectTypeEXT objectType,
2193 uint64_t object,
2194 size_t location,
2195 int32_t messageCode,
2196 const char* pLayerPrefix,
2197 const char* pMessage);
2198
2199
2200
2201
2202
2203
2204
2205
2206 static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(
2207 VkDevice device,
2208 const VkDebugMarkerObjectTagInfoEXT* pTagInfo);
2209
2210 static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(
2211 VkDevice device,
2212 const VkDebugMarkerObjectNameInfoEXT* pNameInfo);
2213
2214 static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT(
2215 VkCommandBuffer commandBuffer,
2216 const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
2217
2218 static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT(
2219 VkCommandBuffer commandBuffer);
2220
2221 static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT(
2222 VkCommandBuffer commandBuffer,
2223 const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
2224
2225
2226
2227
2228 static VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffersEXT(
2229 VkCommandBuffer commandBuffer,
2230 uint32_t firstBinding,
2231 uint32_t bindingCount,
2232 const VkBuffer* pBuffers,
2233 const VkDeviceSize* pOffsets,
2234 const VkDeviceSize* pSizes);
2235
2236 static VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedbackEXT(
2237 VkCommandBuffer commandBuffer,
2238 uint32_t firstCounterBuffer,
2239 uint32_t counterBufferCount,
2240 const VkBuffer* pCounterBuffers,
2241 const VkDeviceSize* pCounterBufferOffsets);
2242
2243 static VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedbackEXT(
2244 VkCommandBuffer commandBuffer,
2245 uint32_t firstCounterBuffer,
2246 uint32_t counterBufferCount,
2247 const VkBuffer* pCounterBuffers,
2248 const VkDeviceSize* pCounterBufferOffsets);
2249
2250 static VKAPI_ATTR void VKAPI_CALL CmdBeginQueryIndexedEXT(
2251 VkCommandBuffer commandBuffer,
2252 VkQueryPool queryPool,
2253 uint32_t query,
2254 VkQueryControlFlags flags,
2255 uint32_t index);
2256
2257 static VKAPI_ATTR void VKAPI_CALL CmdEndQueryIndexedEXT(
2258 VkCommandBuffer commandBuffer,
2259 VkQueryPool queryPool,
2260 uint32_t query,
2261 uint32_t index);
2262
2263 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectByteCountEXT(
2264 VkCommandBuffer commandBuffer,
2265 uint32_t instanceCount,
2266 uint32_t firstInstance,
2267 VkBuffer counterBuffer,
2268 VkDeviceSize counterBufferOffset,
2269 uint32_t counterOffset,
2270 uint32_t vertexStride);
2271
2272
2273 static VKAPI_ATTR VkResult VKAPI_CALL CreateCuModuleNVX(
2274 VkDevice device,
2275 const VkCuModuleCreateInfoNVX* pCreateInfo,
2276 const VkAllocationCallbacks* pAllocator,
2277 VkCuModuleNVX* pModule);
2278
2279 static VKAPI_ATTR VkResult VKAPI_CALL CreateCuFunctionNVX(
2280 VkDevice device,
2281 const VkCuFunctionCreateInfoNVX* pCreateInfo,
2282 const VkAllocationCallbacks* pAllocator,
2283 VkCuFunctionNVX* pFunction);
2284
2285 static VKAPI_ATTR void VKAPI_CALL DestroyCuModuleNVX(
2286 VkDevice device,
2287 VkCuModuleNVX module,
2288 const VkAllocationCallbacks* pAllocator);
2289
2290 static VKAPI_ATTR void VKAPI_CALL DestroyCuFunctionNVX(
2291 VkDevice device,
2292 VkCuFunctionNVX function,
2293 const VkAllocationCallbacks* pAllocator);
2294
2295 static VKAPI_ATTR void VKAPI_CALL CmdCuLaunchKernelNVX(
2296 VkCommandBuffer commandBuffer,
2297 const VkCuLaunchInfoNVX* pLaunchInfo);
2298
2299
2300 static VKAPI_ATTR uint32_t VKAPI_CALL GetImageViewHandleNVX(
2301 VkDevice device,
2302 const VkImageViewHandleInfoNVX* pInfo);
2303
2304 static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewAddressNVX(
2305 VkDevice device,
2306 VkImageView imageView,
2307 VkImageViewAddressPropertiesNVX* pProperties);
2308
2309
2310 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD(
2311 VkCommandBuffer commandBuffer,
2312 VkBuffer buffer,
2313 VkDeviceSize offset,
2314 VkBuffer countBuffer,
2315 VkDeviceSize countBufferOffset,
2316 uint32_t maxDrawCount,
2317 uint32_t stride);
2318
2319 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD(
2320 VkCommandBuffer commandBuffer,
2321 VkBuffer buffer,
2322 VkDeviceSize offset,
2323 VkBuffer countBuffer,
2324 VkDeviceSize countBufferOffset,
2325 uint32_t maxDrawCount,
2326 uint32_t stride);
2327
2328
2329
2330
2331 #ifdef VK_ENABLE_BETA_EXTENSIONS
2332 #endif /* VK_ENABLE_BETA_EXTENSIONS */
2333
2334 #ifdef VK_ENABLE_BETA_EXTENSIONS
2335 #endif /* VK_ENABLE_BETA_EXTENSIONS */
2336
2337 #ifdef VK_ENABLE_BETA_EXTENSIONS
2338 #endif /* VK_ENABLE_BETA_EXTENSIONS */
2339
2340
2341
2342 static VKAPI_ATTR VkResult VKAPI_CALL GetShaderInfoAMD(
2343 VkDevice device,
2344 VkPipeline pipeline,
2345 VkShaderStageFlagBits shaderStage,
2346 VkShaderInfoTypeAMD infoType,
2347 size_t* pInfoSize,
2348 void* pInfo);
2349
2350
2351 #ifdef VK_USE_PLATFORM_GGP
2352
2353 static VKAPI_ATTR VkResult VKAPI_CALL CreateStreamDescriptorSurfaceGGP(
2354 VkInstance instance,
2355 const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
2356 const VkAllocationCallbacks* pAllocator,
2357 VkSurfaceKHR* pSurface);
2358 #endif /* VK_USE_PLATFORM_GGP */
2359
2360
2361
2362
2363 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV(
2364 VkPhysicalDevice physicalDevice,
2365 VkFormat format,
2366 VkImageType type,
2367 VkImageTiling tiling,
2368 VkImageUsageFlags usage,
2369 VkImageCreateFlags flags,
2370 VkExternalMemoryHandleTypeFlagsNV externalHandleType,
2371 VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
2372
2373
2374 #ifdef VK_USE_PLATFORM_WIN32_KHR
2375
2376 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV(
2377 VkDevice device,
2378 VkDeviceMemory memory,
2379 VkExternalMemoryHandleTypeFlagsNV handleType,
2380 HANDLE* pHandle);
2381 #endif /* VK_USE_PLATFORM_WIN32_KHR */
2382
2383 #ifdef VK_USE_PLATFORM_WIN32_KHR
2384 #endif /* VK_USE_PLATFORM_WIN32_KHR */
2385
2386
2387 #ifdef VK_USE_PLATFORM_VI_NN
2388
2389 static VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN(
2390 VkInstance instance,
2391 const VkViSurfaceCreateInfoNN* pCreateInfo,
2392 const VkAllocationCallbacks* pAllocator,
2393 VkSurfaceKHR* pSurface);
2394 #endif /* VK_USE_PLATFORM_VI_NN */
2395
2396
2397
2398
2399
2400
2401 static VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRenderingEXT(
2402 VkCommandBuffer commandBuffer,
2403 const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
2404
2405 static VKAPI_ATTR void VKAPI_CALL CmdEndConditionalRenderingEXT(
2406 VkCommandBuffer commandBuffer);
2407
2408
2409 static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV(
2410 VkCommandBuffer commandBuffer,
2411 uint32_t firstViewport,
2412 uint32_t viewportCount,
2413 const VkViewportWScalingNV* pViewportWScalings);
2414
2415
2416 static VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(
2417 VkPhysicalDevice physicalDevice,
2418 VkDisplayKHR display);
2419
2420 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
2421
2422 static VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT(
2423 VkPhysicalDevice physicalDevice,
2424 Display* dpy,
2425 VkDisplayKHR display);
2426
2427 static VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(
2428 VkPhysicalDevice physicalDevice,
2429 Display* dpy,
2430 RROutput rrOutput,
2431 VkDisplayKHR* pDisplay);
2432 #endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */
2433
2434
2435 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(
2436 VkPhysicalDevice physicalDevice,
2437 VkSurfaceKHR surface,
2438 VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
2439
2440
2441 static VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT(
2442 VkDevice device,
2443 VkDisplayKHR display,
2444 const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
2445
2446 static VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT(
2447 VkDevice device,
2448 const VkDeviceEventInfoEXT* pDeviceEventInfo,
2449 const VkAllocationCallbacks* pAllocator,
2450 VkFence* pFence);
2451
2452 static VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT(
2453 VkDevice device,
2454 VkDisplayKHR display,
2455 const VkDisplayEventInfoEXT* pDisplayEventInfo,
2456 const VkAllocationCallbacks* pAllocator,
2457 VkFence* pFence);
2458
2459 static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT(
2460 VkDevice device,
2461 VkSwapchainKHR swapchain,
2462 VkSurfaceCounterFlagBitsEXT counter,
2463 uint64_t* pCounterValue);
2464
2465
2466 static VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE(
2467 VkDevice device,
2468 VkSwapchainKHR swapchain,
2469 VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
2470
2471 static VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE(
2472 VkDevice device,
2473 VkSwapchainKHR swapchain,
2474 uint32_t* pPresentationTimingCount,
2475 VkPastPresentationTimingGOOGLE* pPresentationTimings);
2476
2477
2478
2479
2480
2481
2482
2483 static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT(
2484 VkCommandBuffer commandBuffer,
2485 uint32_t firstDiscardRectangle,
2486 uint32_t discardRectangleCount,
2487 const VkRect2D* pDiscardRectangles);
2488
2489
2490
2491
2492
2493 static VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT(
2494 VkDevice device,
2495 uint32_t swapchainCount,
2496 const VkSwapchainKHR* pSwapchains,
2497 const VkHdrMetadataEXT* pMetadata);
2498
2499 #ifdef VK_USE_PLATFORM_IOS_MVK
2500
2501 static VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK(
2502 VkInstance instance,
2503 const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
2504 const VkAllocationCallbacks* pAllocator,
2505 VkSurfaceKHR* pSurface);
2506 #endif /* VK_USE_PLATFORM_IOS_MVK */
2507
2508 #ifdef VK_USE_PLATFORM_MACOS_MVK
2509
2510 static VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK(
2511 VkInstance instance,
2512 const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
2513 const VkAllocationCallbacks* pAllocator,
2514 VkSurfaceKHR* pSurface);
2515 #endif /* VK_USE_PLATFORM_MACOS_MVK */
2516
2517
2518
2519
2520 static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT(
2521 VkDevice device,
2522 const VkDebugUtilsObjectNameInfoEXT* pNameInfo);
2523
2524 static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT(
2525 VkDevice device,
2526 const VkDebugUtilsObjectTagInfoEXT* pTagInfo);
2527
2528 static VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT(
2529 VkQueue queue,
2530 const VkDebugUtilsLabelEXT* pLabelInfo);
2531
2532 static VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT(
2533 VkQueue queue);
2534
2535 static VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT(
2536 VkQueue queue,
2537 const VkDebugUtilsLabelEXT* pLabelInfo);
2538
2539 static VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT(
2540 VkCommandBuffer commandBuffer,
2541 const VkDebugUtilsLabelEXT* pLabelInfo);
2542
2543 static VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT(
2544 VkCommandBuffer commandBuffer);
2545
2546 static VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT(
2547 VkCommandBuffer commandBuffer,
2548 const VkDebugUtilsLabelEXT* pLabelInfo);
2549
2550 static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT(
2551 VkInstance instance,
2552 const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
2553 const VkAllocationCallbacks* pAllocator,
2554 VkDebugUtilsMessengerEXT* pMessenger);
2555
2556 static VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT(
2557 VkInstance instance,
2558 VkDebugUtilsMessengerEXT messenger,
2559 const VkAllocationCallbacks* pAllocator);
2560
2561 static VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT(
2562 VkInstance instance,
2563 VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
2564 VkDebugUtilsMessageTypeFlagsEXT messageTypes,
2565 const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
2566
2567 #ifdef VK_USE_PLATFORM_ANDROID_KHR
2568
2569 static VKAPI_ATTR VkResult VKAPI_CALL GetAndroidHardwareBufferPropertiesANDROID(
2570 VkDevice device,
2571 const struct AHardwareBuffer* buffer,
2572 VkAndroidHardwareBufferPropertiesANDROID* pProperties);
2573
2574 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryAndroidHardwareBufferANDROID(
2575 VkDevice device,
2576 const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
2577 struct AHardwareBuffer** pBuffer);
2578 #endif /* VK_USE_PLATFORM_ANDROID_KHR */
2579
2580
2581
2582
2583
2584
2585
2586
2587 static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEXT(
2588 VkCommandBuffer commandBuffer,
2589 const VkSampleLocationsInfoEXT* pSampleLocationsInfo);
2590
2591 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMultisamplePropertiesEXT(
2592 VkPhysicalDevice physicalDevice,
2593 VkSampleCountFlagBits samples,
2594 VkMultisamplePropertiesEXT* pMultisampleProperties);
2595
2596
2597
2598
2599
2600
2601
2602
2603 static VKAPI_ATTR VkResult VKAPI_CALL GetImageDrmFormatModifierPropertiesEXT(
2604 VkDevice device,
2605 VkImage image,
2606 VkImageDrmFormatModifierPropertiesEXT* pProperties);
2607
2608
2609 static VKAPI_ATTR VkResult VKAPI_CALL CreateValidationCacheEXT(
2610 VkDevice device,
2611 const VkValidationCacheCreateInfoEXT* pCreateInfo,
2612 const VkAllocationCallbacks* pAllocator,
2613 VkValidationCacheEXT* pValidationCache);
2614
2615 static VKAPI_ATTR void VKAPI_CALL DestroyValidationCacheEXT(
2616 VkDevice device,
2617 VkValidationCacheEXT validationCache,
2618 const VkAllocationCallbacks* pAllocator);
2619
2620 static VKAPI_ATTR VkResult VKAPI_CALL MergeValidationCachesEXT(
2621 VkDevice device,
2622 VkValidationCacheEXT dstCache,
2623 uint32_t srcCacheCount,
2624 const VkValidationCacheEXT* pSrcCaches);
2625
2626 static VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT(
2627 VkDevice device,
2628 VkValidationCacheEXT validationCache,
2629 size_t* pDataSize,
2630 void* pData);
2631
2632
2633
2634
2635 static VKAPI_ATTR void VKAPI_CALL CmdBindShadingRateImageNV(
2636 VkCommandBuffer commandBuffer,
2637 VkImageView imageView,
2638 VkImageLayout imageLayout);
2639
2640 static VKAPI_ATTR void VKAPI_CALL CmdSetViewportShadingRatePaletteNV(
2641 VkCommandBuffer commandBuffer,
2642 uint32_t firstViewport,
2643 uint32_t viewportCount,
2644 const VkShadingRatePaletteNV* pShadingRatePalettes);
2645
2646 static VKAPI_ATTR void VKAPI_CALL CmdSetCoarseSampleOrderNV(
2647 VkCommandBuffer commandBuffer,
2648 VkCoarseSampleOrderTypeNV sampleOrderType,
2649 uint32_t customSampleOrderCount,
2650 const VkCoarseSampleOrderCustomNV* pCustomSampleOrders);
2651
2652
2653 static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureNV(
2654 VkDevice device,
2655 const VkAccelerationStructureCreateInfoNV* pCreateInfo,
2656 const VkAllocationCallbacks* pAllocator,
2657 VkAccelerationStructureNV* pAccelerationStructure);
2658
2659 static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureNV(
2660 VkDevice device,
2661 VkAccelerationStructureNV accelerationStructure,
2662 const VkAllocationCallbacks* pAllocator);
2663
2664 static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureMemoryRequirementsNV(
2665 VkDevice device,
2666 const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
2667 VkMemoryRequirements2KHR* pMemoryRequirements);
2668
2669 static VKAPI_ATTR VkResult VKAPI_CALL BindAccelerationStructureMemoryNV(
2670 VkDevice device,
2671 uint32_t bindInfoCount,
2672 const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);
2673
2674 static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructureNV(
2675 VkCommandBuffer commandBuffer,
2676 const VkAccelerationStructureInfoNV* pInfo,
2677 VkBuffer instanceData,
2678 VkDeviceSize instanceOffset,
2679 VkBool32 update,
2680 VkAccelerationStructureNV dst,
2681 VkAccelerationStructureNV src,
2682 VkBuffer scratch,
2683 VkDeviceSize scratchOffset);
2684
2685 static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureNV(
2686 VkCommandBuffer commandBuffer,
2687 VkAccelerationStructureNV dst,
2688 VkAccelerationStructureNV src,
2689 VkCopyAccelerationStructureModeKHR mode);
2690
2691 static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysNV(
2692 VkCommandBuffer commandBuffer,
2693 VkBuffer raygenShaderBindingTableBuffer,
2694 VkDeviceSize raygenShaderBindingOffset,
2695 VkBuffer missShaderBindingTableBuffer,
2696 VkDeviceSize missShaderBindingOffset,
2697 VkDeviceSize missShaderBindingStride,
2698 VkBuffer hitShaderBindingTableBuffer,
2699 VkDeviceSize hitShaderBindingOffset,
2700 VkDeviceSize hitShaderBindingStride,
2701 VkBuffer callableShaderBindingTableBuffer,
2702 VkDeviceSize callableShaderBindingOffset,
2703 VkDeviceSize callableShaderBindingStride,
2704 uint32_t width,
2705 uint32_t height,
2706 uint32_t depth);
2707
2708 static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesNV(
2709 VkDevice device,
2710 VkPipelineCache pipelineCache,
2711 uint32_t createInfoCount,
2712 const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
2713 const VkAllocationCallbacks* pAllocator,
2714 VkPipeline* pPipelines);
2715
2716 static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesKHR(
2717 VkDevice device,
2718 VkPipeline pipeline,
2719 uint32_t firstGroup,
2720 uint32_t groupCount,
2721 size_t dataSize,
2722 void* pData);
2723
2724 static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesNV(
2725 VkDevice device,
2726 VkPipeline pipeline,
2727 uint32_t firstGroup,
2728 uint32_t groupCount,
2729 size_t dataSize,
2730 void* pData);
2731
2732 static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureHandleNV(
2733 VkDevice device,
2734 VkAccelerationStructureNV accelerationStructure,
2735 size_t dataSize,
2736 void* pData);
2737
2738 static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesNV(
2739 VkCommandBuffer commandBuffer,
2740 uint32_t accelerationStructureCount,
2741 const VkAccelerationStructureNV* pAccelerationStructures,
2742 VkQueryType queryType,
2743 VkQueryPool queryPool,
2744 uint32_t firstQuery);
2745
2746 static VKAPI_ATTR VkResult VKAPI_CALL CompileDeferredNV(
2747 VkDevice device,
2748 VkPipeline pipeline,
2749 uint32_t shader);
2750
2751
2752
2753
2754
2755
2756 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryHostPointerPropertiesEXT(
2757 VkDevice device,
2758 VkExternalMemoryHandleTypeFlagBits handleType,
2759 const void* pHostPointer,
2760 VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);
2761
2762
2763 static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD(
2764 VkCommandBuffer commandBuffer,
2765 VkPipelineStageFlagBits pipelineStage,
2766 VkBuffer dstBuffer,
2767 VkDeviceSize dstOffset,
2768 uint32_t marker);
2769
2770
2771
2772 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT(
2773 VkPhysicalDevice physicalDevice,
2774 uint32_t* pTimeDomainCount,
2775 VkTimeDomainEXT* pTimeDomains);
2776
2777 static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT(
2778 VkDevice device,
2779 uint32_t timestampCount,
2780 const VkCalibratedTimestampInfoEXT* pTimestampInfos,
2781 uint64_t* pTimestamps,
2782 uint64_t* pMaxDeviation);
2783
2784
2785 #ifdef VK_ENABLE_BETA_EXTENSIONS
2786 #endif /* VK_ENABLE_BETA_EXTENSIONS */
2787
2788
2789
2790 #ifdef VK_USE_PLATFORM_GGP
2791 #endif /* VK_USE_PLATFORM_GGP */
2792
2793
2794
2795
2796
2797 static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksNV(
2798 VkCommandBuffer commandBuffer,
2799 uint32_t taskCount,
2800 uint32_t firstTask);
2801
2802 static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectNV(
2803 VkCommandBuffer commandBuffer,
2804 VkBuffer buffer,
2805 VkDeviceSize offset,
2806 uint32_t drawCount,
2807 uint32_t stride);
2808
2809 static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountNV(
2810 VkCommandBuffer commandBuffer,
2811 VkBuffer buffer,
2812 VkDeviceSize offset,
2813 VkBuffer countBuffer,
2814 VkDeviceSize countBufferOffset,
2815 uint32_t maxDrawCount,
2816 uint32_t stride);
2817
2818
2819
2820
2821 static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorNV(
2822 VkCommandBuffer commandBuffer,
2823 uint32_t firstExclusiveScissor,
2824 uint32_t exclusiveScissorCount,
2825 const VkRect2D* pExclusiveScissors);
2826
2827
2828 static VKAPI_ATTR void VKAPI_CALL CmdSetCheckpointNV(
2829 VkCommandBuffer commandBuffer,
2830 const void* pCheckpointMarker);
2831
2832 static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointDataNV(
2833 VkQueue queue,
2834 uint32_t* pCheckpointDataCount,
2835 VkCheckpointDataNV* pCheckpointData);
2836
2837
2838
2839 static VKAPI_ATTR VkResult VKAPI_CALL InitializePerformanceApiINTEL(
2840 VkDevice device,
2841 const VkInitializePerformanceApiInfoINTEL* pInitializeInfo);
2842
2843 static VKAPI_ATTR void VKAPI_CALL UninitializePerformanceApiINTEL(
2844 VkDevice device);
2845
2846 static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceMarkerINTEL(
2847 VkCommandBuffer commandBuffer,
2848 const VkPerformanceMarkerInfoINTEL* pMarkerInfo);
2849
2850 static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceStreamMarkerINTEL(
2851 VkCommandBuffer commandBuffer,
2852 const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo);
2853
2854 static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceOverrideINTEL(
2855 VkCommandBuffer commandBuffer,
2856 const VkPerformanceOverrideInfoINTEL* pOverrideInfo);
2857
2858 static VKAPI_ATTR VkResult VKAPI_CALL AcquirePerformanceConfigurationINTEL(
2859 VkDevice device,
2860 const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
2861 VkPerformanceConfigurationINTEL* pConfiguration);
2862
2863 static VKAPI_ATTR VkResult VKAPI_CALL ReleasePerformanceConfigurationINTEL(
2864 VkDevice device,
2865 VkPerformanceConfigurationINTEL configuration);
2866
2867 static VKAPI_ATTR VkResult VKAPI_CALL QueueSetPerformanceConfigurationINTEL(
2868 VkQueue queue,
2869 VkPerformanceConfigurationINTEL configuration);
2870
2871 static VKAPI_ATTR VkResult VKAPI_CALL GetPerformanceParameterINTEL(
2872 VkDevice device,
2873 VkPerformanceParameterTypeINTEL parameter,
2874 VkPerformanceValueINTEL* pValue);
2875
2876
2877
2878 static VKAPI_ATTR void VKAPI_CALL SetLocalDimmingAMD(
2879 VkDevice device,
2880 VkSwapchainKHR swapChain,
2881 VkBool32 localDimmingEnable);
2882
2883 #ifdef VK_USE_PLATFORM_FUCHSIA
2884
2885 static VKAPI_ATTR VkResult VKAPI_CALL CreateImagePipeSurfaceFUCHSIA(
2886 VkInstance instance,
2887 const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
2888 const VkAllocationCallbacks* pAllocator,
2889 VkSurfaceKHR* pSurface);
2890 #endif /* VK_USE_PLATFORM_FUCHSIA */
2891
2892 #ifdef VK_USE_PLATFORM_METAL_EXT
2893
2894 static VKAPI_ATTR VkResult VKAPI_CALL CreateMetalSurfaceEXT(
2895 VkInstance instance,
2896 const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
2897 const VkAllocationCallbacks* pAllocator,
2898 VkSurfaceKHR* pSurface);
2899 #endif /* VK_USE_PLATFORM_METAL_EXT */
2900
2901
2902
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913 static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressEXT(
2914 VkDevice device,
2915 const VkBufferDeviceAddressInfo* pInfo);
2916
2917
2918 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolPropertiesEXT(
2919 VkPhysicalDevice physicalDevice,
2920 uint32_t* pToolCount,
2921 VkPhysicalDeviceToolPropertiesEXT* pToolProperties);
2922
2923
2924
2925
2926 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesNV(
2927 VkPhysicalDevice physicalDevice,
2928 uint32_t* pPropertyCount,
2929 VkCooperativeMatrixPropertiesNV* pProperties);
2930
2931
2932 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
2933 VkPhysicalDevice physicalDevice,
2934 uint32_t* pCombinationCount,
2935 VkFramebufferMixedSamplesCombinationNV* pCombinations);
2936
2937
2938
2939
2940 #ifdef VK_USE_PLATFORM_WIN32_KHR
2941
2942 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModes2EXT(
2943 VkPhysicalDevice physicalDevice,
2944 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
2945 uint32_t* pPresentModeCount,
2946 VkPresentModeKHR* pPresentModes);
2947
2948 static VKAPI_ATTR VkResult VKAPI_CALL AcquireFullScreenExclusiveModeEXT(
2949 VkDevice device,
2950 VkSwapchainKHR swapchain);
2951
2952 static VKAPI_ATTR VkResult VKAPI_CALL ReleaseFullScreenExclusiveModeEXT(
2953 VkDevice device,
2954 VkSwapchainKHR swapchain);
2955
2956 static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModes2EXT(
2957 VkDevice device,
2958 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
2959 VkDeviceGroupPresentModeFlagsKHR* pModes);
2960 #endif /* VK_USE_PLATFORM_WIN32_KHR */
2961
2962
2963 static VKAPI_ATTR VkResult VKAPI_CALL CreateHeadlessSurfaceEXT(
2964 VkInstance instance,
2965 const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
2966 const VkAllocationCallbacks* pAllocator,
2967 VkSurfaceKHR* pSurface);
2968
2969
2970 static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEXT(
2971 VkCommandBuffer commandBuffer,
2972 uint32_t lineStippleFactor,
2973 uint16_t lineStipplePattern);
2974
2975
2976
2977 static VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT(
2978 VkDevice device,
2979 VkQueryPool queryPool,
2980 uint32_t firstQuery,
2981 uint32_t queryCount);
2982
2983
2984
2985 static VKAPI_ATTR void VKAPI_CALL CmdSetCullModeEXT(
2986 VkCommandBuffer commandBuffer,
2987 VkCullModeFlags cullMode);
2988
2989 static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFaceEXT(
2990 VkCommandBuffer commandBuffer,
2991 VkFrontFace frontFace);
2992
2993 static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopologyEXT(
2994 VkCommandBuffer commandBuffer,
2995 VkPrimitiveTopology primitiveTopology);
2996
2997 static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCountEXT(
2998 VkCommandBuffer commandBuffer,
2999 uint32_t viewportCount,
3000 const VkViewport* pViewports);
3001
3002 static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCountEXT(
3003 VkCommandBuffer commandBuffer,
3004 uint32_t scissorCount,
3005 const VkRect2D* pScissors);
3006
3007 static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2EXT(
3008 VkCommandBuffer commandBuffer,
3009 uint32_t firstBinding,
3010 uint32_t bindingCount,
3011 const VkBuffer* pBuffers,
3012 const VkDeviceSize* pOffsets,
3013 const VkDeviceSize* pSizes,
3014 const VkDeviceSize* pStrides);
3015
3016 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnableEXT(
3017 VkCommandBuffer commandBuffer,
3018 VkBool32 depthTestEnable);
3019
3020 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnableEXT(
3021 VkCommandBuffer commandBuffer,
3022 VkBool32 depthWriteEnable);
3023
3024 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOpEXT(
3025 VkCommandBuffer commandBuffer,
3026 VkCompareOp depthCompareOp);
3027
3028 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnableEXT(
3029 VkCommandBuffer commandBuffer,
3030 VkBool32 depthBoundsTestEnable);
3031
3032 static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnableEXT(
3033 VkCommandBuffer commandBuffer,
3034 VkBool32 stencilTestEnable);
3035
3036 static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOpEXT(
3037 VkCommandBuffer commandBuffer,
3038 VkStencilFaceFlags faceMask,
3039 VkStencilOp failOp,
3040 VkStencilOp passOp,
3041 VkStencilOp depthFailOp,
3042 VkCompareOp compareOp);
3043
3044
3045
3046
3047 static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsNV(
3048 VkDevice device,
3049 const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo,
3050 VkMemoryRequirements2* pMemoryRequirements);
3051
3052 static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsNV(
3053 VkCommandBuffer commandBuffer,
3054 const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo);
3055
3056 static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsNV(
3057 VkCommandBuffer commandBuffer,
3058 VkBool32 isPreprocessed,
3059 const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo);
3060
3061 static VKAPI_ATTR void VKAPI_CALL CmdBindPipelineShaderGroupNV(
3062 VkCommandBuffer commandBuffer,
3063 VkPipelineBindPoint pipelineBindPoint,
3064 VkPipeline pipeline,
3065 uint32_t groupIndex);
3066
3067 static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNV(
3068 VkDevice device,
3069 const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
3070 const VkAllocationCallbacks* pAllocator,
3071 VkIndirectCommandsLayoutNV* pIndirectCommandsLayout);
3072
3073 static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNV(
3074 VkDevice device,
3075 VkIndirectCommandsLayoutNV indirectCommandsLayout,
3076 const VkAllocationCallbacks* pAllocator);
3077
3078
3079
3080
3081
3082
3083 static VKAPI_ATTR VkResult VKAPI_CALL AcquireDrmDisplayEXT(
3084 VkPhysicalDevice physicalDevice,
3085 int32_t drmFd,
3086 VkDisplayKHR display);
3087
3088 static VKAPI_ATTR VkResult VKAPI_CALL GetDrmDisplayEXT(
3089 VkPhysicalDevice physicalDevice,
3090 int32_t drmFd,
3091 uint32_t connectorId,
3092 VkDisplayKHR* display);
3093
3094
3095
3096
3097
3098 static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlotEXT(
3099 VkDevice device,
3100 const VkPrivateDataSlotCreateInfoEXT* pCreateInfo,
3101 const VkAllocationCallbacks* pAllocator,
3102 VkPrivateDataSlotEXT* pPrivateDataSlot);
3103
3104 static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlotEXT(
3105 VkDevice device,
3106 VkPrivateDataSlotEXT privateDataSlot,
3107 const VkAllocationCallbacks* pAllocator);
3108
3109 static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateDataEXT(
3110 VkDevice device,
3111 VkObjectType objectType,
3112 uint64_t objectHandle,
3113 VkPrivateDataSlotEXT privateDataSlot,
3114 uint64_t data);
3115
3116 static VKAPI_ATTR void VKAPI_CALL GetPrivateDataEXT(
3117 VkDevice device,
3118 VkObjectType objectType,
3119 uint64_t objectHandle,
3120 VkPrivateDataSlotEXT privateDataSlot,
3121 uint64_t* pData);
3122
3123
3124
3125
3126
3127 static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateEnumNV(
3128 VkCommandBuffer commandBuffer,
3129 VkFragmentShadingRateNV shadingRate,
3130 const VkFragmentShadingRateCombinerOpKHR combinerOps[2]);
3131
3132
3133
3134
3135
3136
3137
3138
3139
3140 #ifdef VK_USE_PLATFORM_WIN32_KHR
3141
3142 static VKAPI_ATTR VkResult VKAPI_CALL AcquireWinrtDisplayNV(
3143 VkPhysicalDevice physicalDevice,
3144 VkDisplayKHR display);
3145
3146 static VKAPI_ATTR VkResult VKAPI_CALL GetWinrtDisplayNV(
3147 VkPhysicalDevice physicalDevice,
3148 uint32_t deviceRelativeId,
3149 VkDisplayKHR* pDisplay);
3150 #endif /* VK_USE_PLATFORM_WIN32_KHR */
3151
3152 #ifdef VK_USE_PLATFORM_DIRECTFB_EXT
3153
3154 static VKAPI_ATTR VkResult VKAPI_CALL CreateDirectFBSurfaceEXT(
3155 VkInstance instance,
3156 const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo,
3157 const VkAllocationCallbacks* pAllocator,
3158 VkSurfaceKHR* pSurface);
3159
3160 static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceDirectFBPresentationSupportEXT(
3161 VkPhysicalDevice physicalDevice,
3162 uint32_t queueFamilyIndex,
3163 IDirectFB* dfb);
3164 #endif /* VK_USE_PLATFORM_DIRECTFB_EXT */
3165
3166
3167
3168 static VKAPI_ATTR void VKAPI_CALL CmdSetVertexInputEXT(
3169 VkCommandBuffer commandBuffer,
3170 uint32_t vertexBindingDescriptionCount,
3171 const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions,
3172 uint32_t vertexAttributeDescriptionCount,
3173 const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions);
3174
3175
3176
3177
3178 #ifdef VK_USE_PLATFORM_FUCHSIA
3179
3180 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandleFUCHSIA(
3181 VkDevice device,
3182 const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
3183 zx_handle_t* pZirconHandle);
3184
3185 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandlePropertiesFUCHSIA(
3186 VkDevice device,
3187 VkExternalMemoryHandleTypeFlagBits handleType,
3188 zx_handle_t zirconHandle,
3189 VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties);
3190 #endif /* VK_USE_PLATFORM_FUCHSIA */
3191
3192 #ifdef VK_USE_PLATFORM_FUCHSIA
3193
3194 static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreZirconHandleFUCHSIA(
3195 VkDevice device,
3196 const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo);
3197
3198 static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreZirconHandleFUCHSIA(
3199 VkDevice device,
3200 const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
3201 zx_handle_t* pZirconHandle);
3202 #endif /* VK_USE_PLATFORM_FUCHSIA */
3203
3204 #ifdef VK_USE_PLATFORM_FUCHSIA
3205
3206 static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferCollectionFUCHSIA(
3207 VkDevice device,
3208 const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo,
3209 const VkAllocationCallbacks* pAllocator,
3210 VkBufferCollectionFUCHSIA* pCollection);
3211
3212 static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionImageConstraintsFUCHSIA(
3213 VkDevice device,
3214 VkBufferCollectionFUCHSIA collection,
3215 const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo);
3216
3217 static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionBufferConstraintsFUCHSIA(
3218 VkDevice device,
3219 VkBufferCollectionFUCHSIA collection,
3220 const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo);
3221
3222 static VKAPI_ATTR void VKAPI_CALL DestroyBufferCollectionFUCHSIA(
3223 VkDevice device,
3224 VkBufferCollectionFUCHSIA collection,
3225 const VkAllocationCallbacks* pAllocator);
3226
3227 static VKAPI_ATTR VkResult VKAPI_CALL GetBufferCollectionPropertiesFUCHSIA(
3228 VkDevice device,
3229 VkBufferCollectionFUCHSIA collection,
3230 VkBufferCollectionPropertiesFUCHSIA* pProperties);
3231 #endif /* VK_USE_PLATFORM_FUCHSIA */
3232
3233
3234 static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(
3235 VkDevice device,
3236 VkRenderPass renderpass,
3237 VkExtent2D* pMaxWorkgroupSize);
3238
3239 static VKAPI_ATTR void VKAPI_CALL CmdSubpassShadingHUAWEI(
3240 VkCommandBuffer commandBuffer);
3241
3242
3243 static VKAPI_ATTR void VKAPI_CALL CmdBindInvocationMaskHUAWEI(
3244 VkCommandBuffer commandBuffer,
3245 VkImageView imageView,
3246 VkImageLayout imageLayout);
3247
3248
3249 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryRemoteAddressNV(
3250 VkDevice device,
3251 const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo,
3252 VkRemoteAddressNV* pAddress);
3253
3254
3255 static VKAPI_ATTR void VKAPI_CALL CmdSetPatchControlPointsEXT(
3256 VkCommandBuffer commandBuffer,
3257 uint32_t patchControlPoints);
3258
3259 static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnableEXT(
3260 VkCommandBuffer commandBuffer,
3261 VkBool32 rasterizerDiscardEnable);
3262
3263 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnableEXT(
3264 VkCommandBuffer commandBuffer,
3265 VkBool32 depthBiasEnable);
3266
3267 static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEXT(
3268 VkCommandBuffer commandBuffer,
3269 VkLogicOp logicOp);
3270
3271 static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnableEXT(
3272 VkCommandBuffer commandBuffer,
3273 VkBool32 primitiveRestartEnable);
3274
3275 #ifdef VK_USE_PLATFORM_SCREEN_QNX
3276
3277 static VKAPI_ATTR VkResult VKAPI_CALL CreateScreenSurfaceQNX(
3278 VkInstance instance,
3279 const VkScreenSurfaceCreateInfoQNX* pCreateInfo,
3280 const VkAllocationCallbacks* pAllocator,
3281 VkSurfaceKHR* pSurface);
3282
3283 static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceScreenPresentationSupportQNX(
3284 VkPhysicalDevice physicalDevice,
3285 uint32_t queueFamilyIndex,
3286 struct _screen_window* window);
3287 #endif /* VK_USE_PLATFORM_SCREEN_QNX */
3288
3289
3290 static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteEnableEXT(
3291 VkCommandBuffer commandBuffer,
3292 uint32_t attachmentCount,
3293 const VkBool32* pColorWriteEnables);
3294
3295
3296
3297
3298 static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiEXT(
3299 VkCommandBuffer commandBuffer,
3300 uint32_t drawCount,
3301 const VkMultiDrawInfoEXT* pVertexInfo,
3302 uint32_t instanceCount,
3303 uint32_t firstInstance,
3304 uint32_t stride);
3305
3306 static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiIndexedEXT(
3307 VkCommandBuffer commandBuffer,
3308 uint32_t drawCount,
3309 const VkMultiDrawIndexedInfoEXT* pIndexInfo,
3310 uint32_t instanceCount,
3311 uint32_t firstInstance,
3312 uint32_t stride,
3313 const int32_t* pVertexOffset);
3314
3315
3316
3317
3318 static VKAPI_ATTR void VKAPI_CALL SetDeviceMemoryPriorityEXT(
3319 VkDevice device,
3320 VkDeviceMemory memory,
3321 float priority);
3322
3323
3324
3325
3326
3327 static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR(
3328 VkDevice device,
3329 const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
3330 const VkAllocationCallbacks* pAllocator,
3331 VkAccelerationStructureKHR* pAccelerationStructure);
3332
3333 static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureKHR(
3334 VkDevice device,
3335 VkAccelerationStructureKHR accelerationStructure,
3336 const VkAllocationCallbacks* pAllocator);
3337
3338 static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresKHR(
3339 VkCommandBuffer commandBuffer,
3340 uint32_t infoCount,
3341 const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
3342 const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
3343
3344 static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresIndirectKHR(
3345 VkCommandBuffer commandBuffer,
3346 uint32_t infoCount,
3347 const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
3348 const VkDeviceAddress* pIndirectDeviceAddresses,
3349 const uint32_t* pIndirectStrides,
3350 const uint32_t* const* ppMaxPrimitiveCounts);
3351
3352 static VKAPI_ATTR VkResult VKAPI_CALL BuildAccelerationStructuresKHR(
3353 VkDevice device,
3354 VkDeferredOperationKHR deferredOperation,
3355 uint32_t infoCount,
3356 const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
3357 const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
3358
3359 static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureKHR(
3360 VkDevice device,
3361 VkDeferredOperationKHR deferredOperation,
3362 const VkCopyAccelerationStructureInfoKHR* pInfo);
3363
3364 static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureToMemoryKHR(
3365 VkDevice device,
3366 VkDeferredOperationKHR deferredOperation,
3367 const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
3368
3369 static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToAccelerationStructureKHR(
3370 VkDevice device,
3371 VkDeferredOperationKHR deferredOperation,
3372 const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
3373
3374 static VKAPI_ATTR VkResult VKAPI_CALL WriteAccelerationStructuresPropertiesKHR(
3375 VkDevice device,
3376 uint32_t accelerationStructureCount,
3377 const VkAccelerationStructureKHR* pAccelerationStructures,
3378 VkQueryType queryType,
3379 size_t dataSize,
3380 void* pData,
3381 size_t stride);
3382
3383 static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureKHR(
3384 VkCommandBuffer commandBuffer,
3385 const VkCopyAccelerationStructureInfoKHR* pInfo);
3386
3387 static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureToMemoryKHR(
3388 VkCommandBuffer commandBuffer,
3389 const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
3390
3391 static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToAccelerationStructureKHR(
3392 VkCommandBuffer commandBuffer,
3393 const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
3394
3395 static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetAccelerationStructureDeviceAddressKHR(
3396 VkDevice device,
3397 const VkAccelerationStructureDeviceAddressInfoKHR* pInfo);
3398
3399 static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesKHR(
3400 VkCommandBuffer commandBuffer,
3401 uint32_t accelerationStructureCount,
3402 const VkAccelerationStructureKHR* pAccelerationStructures,
3403 VkQueryType queryType,
3404 VkQueryPool queryPool,
3405 uint32_t firstQuery);
3406
3407 static VKAPI_ATTR void VKAPI_CALL GetDeviceAccelerationStructureCompatibilityKHR(
3408 VkDevice device,
3409 const VkAccelerationStructureVersionInfoKHR* pVersionInfo,
3410 VkAccelerationStructureCompatibilityKHR* pCompatibility);
3411
3412 static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureBuildSizesKHR(
3413 VkDevice device,
3414 VkAccelerationStructureBuildTypeKHR buildType,
3415 const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo,
3416 const uint32_t* pMaxPrimitiveCounts,
3417 VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo);
3418
3419
3420 static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysKHR(
3421 VkCommandBuffer commandBuffer,
3422 const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
3423 const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
3424 const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
3425 const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
3426 uint32_t width,
3427 uint32_t height,
3428 uint32_t depth);
3429
3430 static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesKHR(
3431 VkDevice device,
3432 VkDeferredOperationKHR deferredOperation,
3433 VkPipelineCache pipelineCache,
3434 uint32_t createInfoCount,
3435 const VkRayTracingPipelineCreateInfoKHR* pCreateInfos,
3436 const VkAllocationCallbacks* pAllocator,
3437 VkPipeline* pPipelines);
3438
3439 static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingCaptureReplayShaderGroupHandlesKHR(
3440 VkDevice device,
3441 VkPipeline pipeline,
3442 uint32_t firstGroup,
3443 uint32_t groupCount,
3444 size_t dataSize,
3445 void* pData);
3446
3447 static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirectKHR(
3448 VkCommandBuffer commandBuffer,
3449 const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
3450 const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
3451 const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
3452 const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
3453 VkDeviceAddress indirectDeviceAddress);
3454
3455 static VKAPI_ATTR VkDeviceSize VKAPI_CALL GetRayTracingShaderGroupStackSizeKHR(
3456 VkDevice device,
3457 VkPipeline pipeline,
3458 uint32_t group,
3459 VkShaderGroupShaderKHR groupShader);
3460
3461 static VKAPI_ATTR void VKAPI_CALL CmdSetRayTracingPipelineStackSizeKHR(
3462 VkCommandBuffer commandBuffer,
3463 uint32_t pipelineStackSize);
3464
3465
3466 // Map of all APIs to be intercepted by this layer
3467 static const std::unordered_map<std::string, void*> name_to_funcptr_map = {
3468 {"vkCreateInstance", (void*)CreateInstance},
3469 {"vkDestroyInstance", (void*)DestroyInstance},
3470 {"vkEnumeratePhysicalDevices", (void*)EnumeratePhysicalDevices},
3471 {"vkGetPhysicalDeviceFeatures", (void*)GetPhysicalDeviceFeatures},
3472 {"vkGetPhysicalDeviceFormatProperties", (void*)GetPhysicalDeviceFormatProperties},
3473 {"vkGetPhysicalDeviceImageFormatProperties", (void*)GetPhysicalDeviceImageFormatProperties},
3474 {"vkGetPhysicalDeviceProperties", (void*)GetPhysicalDeviceProperties},
3475 {"vkGetPhysicalDeviceQueueFamilyProperties", (void*)GetPhysicalDeviceQueueFamilyProperties},
3476 {"vkGetPhysicalDeviceMemoryProperties", (void*)GetPhysicalDeviceMemoryProperties},
3477 {"vkGetInstanceProcAddr", (void*)GetInstanceProcAddr},
3478 {"vkGetDeviceProcAddr", (void*)GetDeviceProcAddr},
3479 {"vkCreateDevice", (void*)CreateDevice},
3480 {"vkDestroyDevice", (void*)DestroyDevice},
3481 {"vkEnumerateInstanceExtensionProperties", (void*)EnumerateInstanceExtensionProperties},
3482 {"vkEnumerateDeviceExtensionProperties", (void*)EnumerateDeviceExtensionProperties},
3483 {"vkEnumerateInstanceLayerProperties", (void*)EnumerateInstanceLayerProperties},
3484 {"vkEnumerateDeviceLayerProperties", (void*)EnumerateDeviceLayerProperties},
3485 {"vkGetDeviceQueue", (void*)GetDeviceQueue},
3486 {"vkQueueSubmit", (void*)QueueSubmit},
3487 {"vkQueueWaitIdle", (void*)QueueWaitIdle},
3488 {"vkDeviceWaitIdle", (void*)DeviceWaitIdle},
3489 {"vkAllocateMemory", (void*)AllocateMemory},
3490 {"vkFreeMemory", (void*)FreeMemory},
3491 {"vkMapMemory", (void*)MapMemory},
3492 {"vkUnmapMemory", (void*)UnmapMemory},
3493 {"vkFlushMappedMemoryRanges", (void*)FlushMappedMemoryRanges},
3494 {"vkInvalidateMappedMemoryRanges", (void*)InvalidateMappedMemoryRanges},
3495 {"vkGetDeviceMemoryCommitment", (void*)GetDeviceMemoryCommitment},
3496 {"vkBindBufferMemory", (void*)BindBufferMemory},
3497 {"vkBindImageMemory", (void*)BindImageMemory},
3498 {"vkGetBufferMemoryRequirements", (void*)GetBufferMemoryRequirements},
3499 {"vkGetImageMemoryRequirements", (void*)GetImageMemoryRequirements},
3500 {"vkGetImageSparseMemoryRequirements", (void*)GetImageSparseMemoryRequirements},
3501 {"vkGetPhysicalDeviceSparseImageFormatProperties", (void*)GetPhysicalDeviceSparseImageFormatProperties},
3502 {"vkQueueBindSparse", (void*)QueueBindSparse},
3503 {"vkCreateFence", (void*)CreateFence},
3504 {"vkDestroyFence", (void*)DestroyFence},
3505 {"vkResetFences", (void*)ResetFences},
3506 {"vkGetFenceStatus", (void*)GetFenceStatus},
3507 {"vkWaitForFences", (void*)WaitForFences},
3508 {"vkCreateSemaphore", (void*)CreateSemaphore},
3509 {"vkDestroySemaphore", (void*)DestroySemaphore},
3510 {"vkCreateEvent", (void*)CreateEvent},
3511 {"vkDestroyEvent", (void*)DestroyEvent},
3512 {"vkGetEventStatus", (void*)GetEventStatus},
3513 {"vkSetEvent", (void*)SetEvent},
3514 {"vkResetEvent", (void*)ResetEvent},
3515 {"vkCreateQueryPool", (void*)CreateQueryPool},
3516 {"vkDestroyQueryPool", (void*)DestroyQueryPool},
3517 {"vkGetQueryPoolResults", (void*)GetQueryPoolResults},
3518 {"vkCreateBuffer", (void*)CreateBuffer},
3519 {"vkDestroyBuffer", (void*)DestroyBuffer},
3520 {"vkCreateBufferView", (void*)CreateBufferView},
3521 {"vkDestroyBufferView", (void*)DestroyBufferView},
3522 {"vkCreateImage", (void*)CreateImage},
3523 {"vkDestroyImage", (void*)DestroyImage},
3524 {"vkGetImageSubresourceLayout", (void*)GetImageSubresourceLayout},
3525 {"vkCreateImageView", (void*)CreateImageView},
3526 {"vkDestroyImageView", (void*)DestroyImageView},
3527 {"vkCreateShaderModule", (void*)CreateShaderModule},
3528 {"vkDestroyShaderModule", (void*)DestroyShaderModule},
3529 {"vkCreatePipelineCache", (void*)CreatePipelineCache},
3530 {"vkDestroyPipelineCache", (void*)DestroyPipelineCache},
3531 {"vkGetPipelineCacheData", (void*)GetPipelineCacheData},
3532 {"vkMergePipelineCaches", (void*)MergePipelineCaches},
3533 {"vkCreateGraphicsPipelines", (void*)CreateGraphicsPipelines},
3534 {"vkCreateComputePipelines", (void*)CreateComputePipelines},
3535 {"vkDestroyPipeline", (void*)DestroyPipeline},
3536 {"vkCreatePipelineLayout", (void*)CreatePipelineLayout},
3537 {"vkDestroyPipelineLayout", (void*)DestroyPipelineLayout},
3538 {"vkCreateSampler", (void*)CreateSampler},
3539 {"vkDestroySampler", (void*)DestroySampler},
3540 {"vkCreateDescriptorSetLayout", (void*)CreateDescriptorSetLayout},
3541 {"vkDestroyDescriptorSetLayout", (void*)DestroyDescriptorSetLayout},
3542 {"vkCreateDescriptorPool", (void*)CreateDescriptorPool},
3543 {"vkDestroyDescriptorPool", (void*)DestroyDescriptorPool},
3544 {"vkResetDescriptorPool", (void*)ResetDescriptorPool},
3545 {"vkAllocateDescriptorSets", (void*)AllocateDescriptorSets},
3546 {"vkFreeDescriptorSets", (void*)FreeDescriptorSets},
3547 {"vkUpdateDescriptorSets", (void*)UpdateDescriptorSets},
3548 {"vkCreateFramebuffer", (void*)CreateFramebuffer},
3549 {"vkDestroyFramebuffer", (void*)DestroyFramebuffer},
3550 {"vkCreateRenderPass", (void*)CreateRenderPass},
3551 {"vkDestroyRenderPass", (void*)DestroyRenderPass},
3552 {"vkGetRenderAreaGranularity", (void*)GetRenderAreaGranularity},
3553 {"vkCreateCommandPool", (void*)CreateCommandPool},
3554 {"vkDestroyCommandPool", (void*)DestroyCommandPool},
3555 {"vkResetCommandPool", (void*)ResetCommandPool},
3556 {"vkAllocateCommandBuffers", (void*)AllocateCommandBuffers},
3557 {"vkFreeCommandBuffers", (void*)FreeCommandBuffers},
3558 {"vkBeginCommandBuffer", (void*)BeginCommandBuffer},
3559 {"vkEndCommandBuffer", (void*)EndCommandBuffer},
3560 {"vkResetCommandBuffer", (void*)ResetCommandBuffer},
3561 {"vkCmdBindPipeline", (void*)CmdBindPipeline},
3562 {"vkCmdSetViewport", (void*)CmdSetViewport},
3563 {"vkCmdSetScissor", (void*)CmdSetScissor},
3564 {"vkCmdSetLineWidth", (void*)CmdSetLineWidth},
3565 {"vkCmdSetDepthBias", (void*)CmdSetDepthBias},
3566 {"vkCmdSetBlendConstants", (void*)CmdSetBlendConstants},
3567 {"vkCmdSetDepthBounds", (void*)CmdSetDepthBounds},
3568 {"vkCmdSetStencilCompareMask", (void*)CmdSetStencilCompareMask},
3569 {"vkCmdSetStencilWriteMask", (void*)CmdSetStencilWriteMask},
3570 {"vkCmdSetStencilReference", (void*)CmdSetStencilReference},
3571 {"vkCmdBindDescriptorSets", (void*)CmdBindDescriptorSets},
3572 {"vkCmdBindIndexBuffer", (void*)CmdBindIndexBuffer},
3573 {"vkCmdBindVertexBuffers", (void*)CmdBindVertexBuffers},
3574 {"vkCmdDraw", (void*)CmdDraw},
3575 {"vkCmdDrawIndexed", (void*)CmdDrawIndexed},
3576 {"vkCmdDrawIndirect", (void*)CmdDrawIndirect},
3577 {"vkCmdDrawIndexedIndirect", (void*)CmdDrawIndexedIndirect},
3578 {"vkCmdDispatch", (void*)CmdDispatch},
3579 {"vkCmdDispatchIndirect", (void*)CmdDispatchIndirect},
3580 {"vkCmdCopyBuffer", (void*)CmdCopyBuffer},
3581 {"vkCmdCopyImage", (void*)CmdCopyImage},
3582 {"vkCmdBlitImage", (void*)CmdBlitImage},
3583 {"vkCmdCopyBufferToImage", (void*)CmdCopyBufferToImage},
3584 {"vkCmdCopyImageToBuffer", (void*)CmdCopyImageToBuffer},
3585 {"vkCmdUpdateBuffer", (void*)CmdUpdateBuffer},
3586 {"vkCmdFillBuffer", (void*)CmdFillBuffer},
3587 {"vkCmdClearColorImage", (void*)CmdClearColorImage},
3588 {"vkCmdClearDepthStencilImage", (void*)CmdClearDepthStencilImage},
3589 {"vkCmdClearAttachments", (void*)CmdClearAttachments},
3590 {"vkCmdResolveImage", (void*)CmdResolveImage},
3591 {"vkCmdSetEvent", (void*)CmdSetEvent},
3592 {"vkCmdResetEvent", (void*)CmdResetEvent},
3593 {"vkCmdWaitEvents", (void*)CmdWaitEvents},
3594 {"vkCmdPipelineBarrier", (void*)CmdPipelineBarrier},
3595 {"vkCmdBeginQuery", (void*)CmdBeginQuery},
3596 {"vkCmdEndQuery", (void*)CmdEndQuery},
3597 {"vkCmdResetQueryPool", (void*)CmdResetQueryPool},
3598 {"vkCmdWriteTimestamp", (void*)CmdWriteTimestamp},
3599 {"vkCmdCopyQueryPoolResults", (void*)CmdCopyQueryPoolResults},
3600 {"vkCmdPushConstants", (void*)CmdPushConstants},
3601 {"vkCmdBeginRenderPass", (void*)CmdBeginRenderPass},
3602 {"vkCmdNextSubpass", (void*)CmdNextSubpass},
3603 {"vkCmdEndRenderPass", (void*)CmdEndRenderPass},
3604 {"vkCmdExecuteCommands", (void*)CmdExecuteCommands},
3605 {"vkEnumerateInstanceVersion", (void*)EnumerateInstanceVersion},
3606 {"vkBindBufferMemory2", (void*)BindBufferMemory2},
3607 {"vkBindImageMemory2", (void*)BindImageMemory2},
3608 {"vkGetDeviceGroupPeerMemoryFeatures", (void*)GetDeviceGroupPeerMemoryFeatures},
3609 {"vkCmdSetDeviceMask", (void*)CmdSetDeviceMask},
3610 {"vkCmdDispatchBase", (void*)CmdDispatchBase},
3611 {"vkEnumeratePhysicalDeviceGroups", (void*)EnumeratePhysicalDeviceGroups},
3612 {"vkGetImageMemoryRequirements2", (void*)GetImageMemoryRequirements2},
3613 {"vkGetBufferMemoryRequirements2", (void*)GetBufferMemoryRequirements2},
3614 {"vkGetImageSparseMemoryRequirements2", (void*)GetImageSparseMemoryRequirements2},
3615 {"vkGetPhysicalDeviceFeatures2", (void*)GetPhysicalDeviceFeatures2},
3616 {"vkGetPhysicalDeviceProperties2", (void*)GetPhysicalDeviceProperties2},
3617 {"vkGetPhysicalDeviceFormatProperties2", (void*)GetPhysicalDeviceFormatProperties2},
3618 {"vkGetPhysicalDeviceImageFormatProperties2", (void*)GetPhysicalDeviceImageFormatProperties2},
3619 {"vkGetPhysicalDeviceQueueFamilyProperties2", (void*)GetPhysicalDeviceQueueFamilyProperties2},
3620 {"vkGetPhysicalDeviceMemoryProperties2", (void*)GetPhysicalDeviceMemoryProperties2},
3621 {"vkGetPhysicalDeviceSparseImageFormatProperties2", (void*)GetPhysicalDeviceSparseImageFormatProperties2},
3622 {"vkTrimCommandPool", (void*)TrimCommandPool},
3623 {"vkGetDeviceQueue2", (void*)GetDeviceQueue2},
3624 {"vkCreateSamplerYcbcrConversion", (void*)CreateSamplerYcbcrConversion},
3625 {"vkDestroySamplerYcbcrConversion", (void*)DestroySamplerYcbcrConversion},
3626 {"vkCreateDescriptorUpdateTemplate", (void*)CreateDescriptorUpdateTemplate},
3627 {"vkDestroyDescriptorUpdateTemplate", (void*)DestroyDescriptorUpdateTemplate},
3628 {"vkUpdateDescriptorSetWithTemplate", (void*)UpdateDescriptorSetWithTemplate},
3629 {"vkGetPhysicalDeviceExternalBufferProperties", (void*)GetPhysicalDeviceExternalBufferProperties},
3630 {"vkGetPhysicalDeviceExternalFenceProperties", (void*)GetPhysicalDeviceExternalFenceProperties},
3631 {"vkGetPhysicalDeviceExternalSemaphoreProperties", (void*)GetPhysicalDeviceExternalSemaphoreProperties},
3632 {"vkGetDescriptorSetLayoutSupport", (void*)GetDescriptorSetLayoutSupport},
3633 {"vkCmdDrawIndirectCount", (void*)CmdDrawIndirectCount},
3634 {"vkCmdDrawIndexedIndirectCount", (void*)CmdDrawIndexedIndirectCount},
3635 {"vkCreateRenderPass2", (void*)CreateRenderPass2},
3636 {"vkCmdBeginRenderPass2", (void*)CmdBeginRenderPass2},
3637 {"vkCmdNextSubpass2", (void*)CmdNextSubpass2},
3638 {"vkCmdEndRenderPass2", (void*)CmdEndRenderPass2},
3639 {"vkResetQueryPool", (void*)ResetQueryPool},
3640 {"vkGetSemaphoreCounterValue", (void*)GetSemaphoreCounterValue},
3641 {"vkWaitSemaphores", (void*)WaitSemaphores},
3642 {"vkSignalSemaphore", (void*)SignalSemaphore},
3643 {"vkGetBufferDeviceAddress", (void*)GetBufferDeviceAddress},
3644 {"vkGetBufferOpaqueCaptureAddress", (void*)GetBufferOpaqueCaptureAddress},
3645 {"vkGetDeviceMemoryOpaqueCaptureAddress", (void*)GetDeviceMemoryOpaqueCaptureAddress},
3646 {"vkDestroySurfaceKHR", (void*)DestroySurfaceKHR},
3647 {"vkGetPhysicalDeviceSurfaceSupportKHR", (void*)GetPhysicalDeviceSurfaceSupportKHR},
3648 {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", (void*)GetPhysicalDeviceSurfaceCapabilitiesKHR},
3649 {"vkGetPhysicalDeviceSurfaceFormatsKHR", (void*)GetPhysicalDeviceSurfaceFormatsKHR},
3650 {"vkGetPhysicalDeviceSurfacePresentModesKHR", (void*)GetPhysicalDeviceSurfacePresentModesKHR},
3651 {"vkCreateSwapchainKHR", (void*)CreateSwapchainKHR},
3652 {"vkDestroySwapchainKHR", (void*)DestroySwapchainKHR},
3653 {"vkGetSwapchainImagesKHR", (void*)GetSwapchainImagesKHR},
3654 {"vkAcquireNextImageKHR", (void*)AcquireNextImageKHR},
3655 {"vkQueuePresentKHR", (void*)QueuePresentKHR},
3656 {"vkGetDeviceGroupPresentCapabilitiesKHR", (void*)GetDeviceGroupPresentCapabilitiesKHR},
3657 {"vkGetDeviceGroupSurfacePresentModesKHR", (void*)GetDeviceGroupSurfacePresentModesKHR},
3658 {"vkGetPhysicalDevicePresentRectanglesKHR", (void*)GetPhysicalDevicePresentRectanglesKHR},
3659 {"vkAcquireNextImage2KHR", (void*)AcquireNextImage2KHR},
3660 {"vkGetPhysicalDeviceDisplayPropertiesKHR", (void*)GetPhysicalDeviceDisplayPropertiesKHR},
3661 {"vkGetPhysicalDeviceDisplayPlanePropertiesKHR", (void*)GetPhysicalDeviceDisplayPlanePropertiesKHR},
3662 {"vkGetDisplayPlaneSupportedDisplaysKHR", (void*)GetDisplayPlaneSupportedDisplaysKHR},
3663 {"vkGetDisplayModePropertiesKHR", (void*)GetDisplayModePropertiesKHR},
3664 {"vkCreateDisplayModeKHR", (void*)CreateDisplayModeKHR},
3665 {"vkGetDisplayPlaneCapabilitiesKHR", (void*)GetDisplayPlaneCapabilitiesKHR},
3666 {"vkCreateDisplayPlaneSurfaceKHR", (void*)CreateDisplayPlaneSurfaceKHR},
3667 {"vkCreateSharedSwapchainsKHR", (void*)CreateSharedSwapchainsKHR},
3668 #ifdef VK_USE_PLATFORM_XLIB_KHR
3669 {"vkCreateXlibSurfaceKHR", (void*)CreateXlibSurfaceKHR},
3670 #endif
3671 #ifdef VK_USE_PLATFORM_XLIB_KHR
3672 {"vkGetPhysicalDeviceXlibPresentationSupportKHR", (void*)GetPhysicalDeviceXlibPresentationSupportKHR},
3673 #endif
3674 #ifdef VK_USE_PLATFORM_XCB_KHR
3675 {"vkCreateXcbSurfaceKHR", (void*)CreateXcbSurfaceKHR},
3676 #endif
3677 #ifdef VK_USE_PLATFORM_XCB_KHR
3678 {"vkGetPhysicalDeviceXcbPresentationSupportKHR", (void*)GetPhysicalDeviceXcbPresentationSupportKHR},
3679 #endif
3680 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
3681 {"vkCreateWaylandSurfaceKHR", (void*)CreateWaylandSurfaceKHR},
3682 #endif
3683 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
3684 {"vkGetPhysicalDeviceWaylandPresentationSupportKHR", (void*)GetPhysicalDeviceWaylandPresentationSupportKHR},
3685 #endif
3686 #ifdef VK_USE_PLATFORM_ANDROID_KHR
3687 {"vkCreateAndroidSurfaceKHR", (void*)CreateAndroidSurfaceKHR},
3688 #endif
3689 #ifdef VK_USE_PLATFORM_WIN32_KHR
3690 {"vkCreateWin32SurfaceKHR", (void*)CreateWin32SurfaceKHR},
3691 #endif
3692 #ifdef VK_USE_PLATFORM_WIN32_KHR
3693 {"vkGetPhysicalDeviceWin32PresentationSupportKHR", (void*)GetPhysicalDeviceWin32PresentationSupportKHR},
3694 #endif
3695 #ifdef VK_ENABLE_BETA_EXTENSIONS
3696 {"vkGetPhysicalDeviceVideoCapabilitiesKHR", (void*)GetPhysicalDeviceVideoCapabilitiesKHR},
3697 #endif
3698 #ifdef VK_ENABLE_BETA_EXTENSIONS
3699 {"vkGetPhysicalDeviceVideoFormatPropertiesKHR", (void*)GetPhysicalDeviceVideoFormatPropertiesKHR},
3700 #endif
3701 #ifdef VK_ENABLE_BETA_EXTENSIONS
3702 {"vkCreateVideoSessionKHR", (void*)CreateVideoSessionKHR},
3703 #endif
3704 #ifdef VK_ENABLE_BETA_EXTENSIONS
3705 {"vkDestroyVideoSessionKHR", (void*)DestroyVideoSessionKHR},
3706 #endif
3707 #ifdef VK_ENABLE_BETA_EXTENSIONS
3708 {"vkGetVideoSessionMemoryRequirementsKHR", (void*)GetVideoSessionMemoryRequirementsKHR},
3709 #endif
3710 #ifdef VK_ENABLE_BETA_EXTENSIONS
3711 {"vkBindVideoSessionMemoryKHR", (void*)BindVideoSessionMemoryKHR},
3712 #endif
3713 #ifdef VK_ENABLE_BETA_EXTENSIONS
3714 {"vkCreateVideoSessionParametersKHR", (void*)CreateVideoSessionParametersKHR},
3715 #endif
3716 #ifdef VK_ENABLE_BETA_EXTENSIONS
3717 {"vkUpdateVideoSessionParametersKHR", (void*)UpdateVideoSessionParametersKHR},
3718 #endif
3719 #ifdef VK_ENABLE_BETA_EXTENSIONS
3720 {"vkDestroyVideoSessionParametersKHR", (void*)DestroyVideoSessionParametersKHR},
3721 #endif
3722 #ifdef VK_ENABLE_BETA_EXTENSIONS
3723 {"vkCmdBeginVideoCodingKHR", (void*)CmdBeginVideoCodingKHR},
3724 #endif
3725 #ifdef VK_ENABLE_BETA_EXTENSIONS
3726 {"vkCmdEndVideoCodingKHR", (void*)CmdEndVideoCodingKHR},
3727 #endif
3728 #ifdef VK_ENABLE_BETA_EXTENSIONS
3729 {"vkCmdControlVideoCodingKHR", (void*)CmdControlVideoCodingKHR},
3730 #endif
3731 #ifdef VK_ENABLE_BETA_EXTENSIONS
3732 {"vkCmdDecodeVideoKHR", (void*)CmdDecodeVideoKHR},
3733 #endif
3734 {"vkCmdBeginRenderingKHR", (void*)CmdBeginRenderingKHR},
3735 {"vkCmdEndRenderingKHR", (void*)CmdEndRenderingKHR},
3736 {"vkGetPhysicalDeviceFeatures2KHR", (void*)GetPhysicalDeviceFeatures2KHR},
3737 {"vkGetPhysicalDeviceProperties2KHR", (void*)GetPhysicalDeviceProperties2KHR},
3738 {"vkGetPhysicalDeviceFormatProperties2KHR", (void*)GetPhysicalDeviceFormatProperties2KHR},
3739 {"vkGetPhysicalDeviceImageFormatProperties2KHR", (void*)GetPhysicalDeviceImageFormatProperties2KHR},
3740 {"vkGetPhysicalDeviceQueueFamilyProperties2KHR", (void*)GetPhysicalDeviceQueueFamilyProperties2KHR},
3741 {"vkGetPhysicalDeviceMemoryProperties2KHR", (void*)GetPhysicalDeviceMemoryProperties2KHR},
3742 {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", (void*)GetPhysicalDeviceSparseImageFormatProperties2KHR},
3743 {"vkGetDeviceGroupPeerMemoryFeaturesKHR", (void*)GetDeviceGroupPeerMemoryFeaturesKHR},
3744 {"vkCmdSetDeviceMaskKHR", (void*)CmdSetDeviceMaskKHR},
3745 {"vkCmdDispatchBaseKHR", (void*)CmdDispatchBaseKHR},
3746 {"vkTrimCommandPoolKHR", (void*)TrimCommandPoolKHR},
3747 {"vkEnumeratePhysicalDeviceGroupsKHR", (void*)EnumeratePhysicalDeviceGroupsKHR},
3748 {"vkGetPhysicalDeviceExternalBufferPropertiesKHR", (void*)GetPhysicalDeviceExternalBufferPropertiesKHR},
3749 #ifdef VK_USE_PLATFORM_WIN32_KHR
3750 {"vkGetMemoryWin32HandleKHR", (void*)GetMemoryWin32HandleKHR},
3751 #endif
3752 #ifdef VK_USE_PLATFORM_WIN32_KHR
3753 {"vkGetMemoryWin32HandlePropertiesKHR", (void*)GetMemoryWin32HandlePropertiesKHR},
3754 #endif
3755 {"vkGetMemoryFdKHR", (void*)GetMemoryFdKHR},
3756 {"vkGetMemoryFdPropertiesKHR", (void*)GetMemoryFdPropertiesKHR},
3757 {"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", (void*)GetPhysicalDeviceExternalSemaphorePropertiesKHR},
3758 #ifdef VK_USE_PLATFORM_WIN32_KHR
3759 {"vkImportSemaphoreWin32HandleKHR", (void*)ImportSemaphoreWin32HandleKHR},
3760 #endif
3761 #ifdef VK_USE_PLATFORM_WIN32_KHR
3762 {"vkGetSemaphoreWin32HandleKHR", (void*)GetSemaphoreWin32HandleKHR},
3763 #endif
3764 {"vkImportSemaphoreFdKHR", (void*)ImportSemaphoreFdKHR},
3765 {"vkGetSemaphoreFdKHR", (void*)GetSemaphoreFdKHR},
3766 {"vkCmdPushDescriptorSetKHR", (void*)CmdPushDescriptorSetKHR},
3767 {"vkCmdPushDescriptorSetWithTemplateKHR", (void*)CmdPushDescriptorSetWithTemplateKHR},
3768 {"vkCreateDescriptorUpdateTemplateKHR", (void*)CreateDescriptorUpdateTemplateKHR},
3769 {"vkDestroyDescriptorUpdateTemplateKHR", (void*)DestroyDescriptorUpdateTemplateKHR},
3770 {"vkUpdateDescriptorSetWithTemplateKHR", (void*)UpdateDescriptorSetWithTemplateKHR},
3771 {"vkCreateRenderPass2KHR", (void*)CreateRenderPass2KHR},
3772 {"vkCmdBeginRenderPass2KHR", (void*)CmdBeginRenderPass2KHR},
3773 {"vkCmdNextSubpass2KHR", (void*)CmdNextSubpass2KHR},
3774 {"vkCmdEndRenderPass2KHR", (void*)CmdEndRenderPass2KHR},
3775 {"vkGetSwapchainStatusKHR", (void*)GetSwapchainStatusKHR},
3776 {"vkGetPhysicalDeviceExternalFencePropertiesKHR", (void*)GetPhysicalDeviceExternalFencePropertiesKHR},
3777 #ifdef VK_USE_PLATFORM_WIN32_KHR
3778 {"vkImportFenceWin32HandleKHR", (void*)ImportFenceWin32HandleKHR},
3779 #endif
3780 #ifdef VK_USE_PLATFORM_WIN32_KHR
3781 {"vkGetFenceWin32HandleKHR", (void*)GetFenceWin32HandleKHR},
3782 #endif
3783 {"vkImportFenceFdKHR", (void*)ImportFenceFdKHR},
3784 {"vkGetFenceFdKHR", (void*)GetFenceFdKHR},
3785 {"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR", (void*)EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR},
3786 {"vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR", (void*)GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR},
3787 {"vkAcquireProfilingLockKHR", (void*)AcquireProfilingLockKHR},
3788 {"vkReleaseProfilingLockKHR", (void*)ReleaseProfilingLockKHR},
3789 {"vkGetPhysicalDeviceSurfaceCapabilities2KHR", (void*)GetPhysicalDeviceSurfaceCapabilities2KHR},
3790 {"vkGetPhysicalDeviceSurfaceFormats2KHR", (void*)GetPhysicalDeviceSurfaceFormats2KHR},
3791 {"vkGetPhysicalDeviceDisplayProperties2KHR", (void*)GetPhysicalDeviceDisplayProperties2KHR},
3792 {"vkGetPhysicalDeviceDisplayPlaneProperties2KHR", (void*)GetPhysicalDeviceDisplayPlaneProperties2KHR},
3793 {"vkGetDisplayModeProperties2KHR", (void*)GetDisplayModeProperties2KHR},
3794 {"vkGetDisplayPlaneCapabilities2KHR", (void*)GetDisplayPlaneCapabilities2KHR},
3795 {"vkGetImageMemoryRequirements2KHR", (void*)GetImageMemoryRequirements2KHR},
3796 {"vkGetBufferMemoryRequirements2KHR", (void*)GetBufferMemoryRequirements2KHR},
3797 {"vkGetImageSparseMemoryRequirements2KHR", (void*)GetImageSparseMemoryRequirements2KHR},
3798 {"vkCreateSamplerYcbcrConversionKHR", (void*)CreateSamplerYcbcrConversionKHR},
3799 {"vkDestroySamplerYcbcrConversionKHR", (void*)DestroySamplerYcbcrConversionKHR},
3800 {"vkBindBufferMemory2KHR", (void*)BindBufferMemory2KHR},
3801 {"vkBindImageMemory2KHR", (void*)BindImageMemory2KHR},
3802 {"vkGetDescriptorSetLayoutSupportKHR", (void*)GetDescriptorSetLayoutSupportKHR},
3803 {"vkCmdDrawIndirectCountKHR", (void*)CmdDrawIndirectCountKHR},
3804 {"vkCmdDrawIndexedIndirectCountKHR", (void*)CmdDrawIndexedIndirectCountKHR},
3805 {"vkGetSemaphoreCounterValueKHR", (void*)GetSemaphoreCounterValueKHR},
3806 {"vkWaitSemaphoresKHR", (void*)WaitSemaphoresKHR},
3807 {"vkSignalSemaphoreKHR", (void*)SignalSemaphoreKHR},
3808 {"vkGetPhysicalDeviceFragmentShadingRatesKHR", (void*)GetPhysicalDeviceFragmentShadingRatesKHR},
3809 {"vkCmdSetFragmentShadingRateKHR", (void*)CmdSetFragmentShadingRateKHR},
3810 {"vkWaitForPresentKHR", (void*)WaitForPresentKHR},
3811 {"vkGetBufferDeviceAddressKHR", (void*)GetBufferDeviceAddressKHR},
3812 {"vkGetBufferOpaqueCaptureAddressKHR", (void*)GetBufferOpaqueCaptureAddressKHR},
3813 {"vkGetDeviceMemoryOpaqueCaptureAddressKHR", (void*)GetDeviceMemoryOpaqueCaptureAddressKHR},
3814 {"vkCreateDeferredOperationKHR", (void*)CreateDeferredOperationKHR},
3815 {"vkDestroyDeferredOperationKHR", (void*)DestroyDeferredOperationKHR},
3816 {"vkGetDeferredOperationMaxConcurrencyKHR", (void*)GetDeferredOperationMaxConcurrencyKHR},
3817 {"vkGetDeferredOperationResultKHR", (void*)GetDeferredOperationResultKHR},
3818 {"vkDeferredOperationJoinKHR", (void*)DeferredOperationJoinKHR},
3819 {"vkGetPipelineExecutablePropertiesKHR", (void*)GetPipelineExecutablePropertiesKHR},
3820 {"vkGetPipelineExecutableStatisticsKHR", (void*)GetPipelineExecutableStatisticsKHR},
3821 {"vkGetPipelineExecutableInternalRepresentationsKHR", (void*)GetPipelineExecutableInternalRepresentationsKHR},
3822 #ifdef VK_ENABLE_BETA_EXTENSIONS
3823 {"vkCmdEncodeVideoKHR", (void*)CmdEncodeVideoKHR},
3824 #endif
3825 {"vkCmdSetEvent2KHR", (void*)CmdSetEvent2KHR},
3826 {"vkCmdResetEvent2KHR", (void*)CmdResetEvent2KHR},
3827 {"vkCmdWaitEvents2KHR", (void*)CmdWaitEvents2KHR},
3828 {"vkCmdPipelineBarrier2KHR", (void*)CmdPipelineBarrier2KHR},
3829 {"vkCmdWriteTimestamp2KHR", (void*)CmdWriteTimestamp2KHR},
3830 {"vkQueueSubmit2KHR", (void*)QueueSubmit2KHR},
3831 {"vkCmdWriteBufferMarker2AMD", (void*)CmdWriteBufferMarker2AMD},
3832 {"vkGetQueueCheckpointData2NV", (void*)GetQueueCheckpointData2NV},
3833 {"vkCmdCopyBuffer2KHR", (void*)CmdCopyBuffer2KHR},
3834 {"vkCmdCopyImage2KHR", (void*)CmdCopyImage2KHR},
3835 {"vkCmdCopyBufferToImage2KHR", (void*)CmdCopyBufferToImage2KHR},
3836 {"vkCmdCopyImageToBuffer2KHR", (void*)CmdCopyImageToBuffer2KHR},
3837 {"vkCmdBlitImage2KHR", (void*)CmdBlitImage2KHR},
3838 {"vkCmdResolveImage2KHR", (void*)CmdResolveImage2KHR},
3839 {"vkGetDeviceBufferMemoryRequirementsKHR", (void*)GetDeviceBufferMemoryRequirementsKHR},
3840 {"vkGetDeviceImageMemoryRequirementsKHR", (void*)GetDeviceImageMemoryRequirementsKHR},
3841 {"vkGetDeviceImageSparseMemoryRequirementsKHR", (void*)GetDeviceImageSparseMemoryRequirementsKHR},
3842 {"vkCreateDebugReportCallbackEXT", (void*)CreateDebugReportCallbackEXT},
3843 {"vkDestroyDebugReportCallbackEXT", (void*)DestroyDebugReportCallbackEXT},
3844 {"vkDebugReportMessageEXT", (void*)DebugReportMessageEXT},
3845 {"vkDebugMarkerSetObjectTagEXT", (void*)DebugMarkerSetObjectTagEXT},
3846 {"vkDebugMarkerSetObjectNameEXT", (void*)DebugMarkerSetObjectNameEXT},
3847 {"vkCmdDebugMarkerBeginEXT", (void*)CmdDebugMarkerBeginEXT},
3848 {"vkCmdDebugMarkerEndEXT", (void*)CmdDebugMarkerEndEXT},
3849 {"vkCmdDebugMarkerInsertEXT", (void*)CmdDebugMarkerInsertEXT},
3850 {"vkCmdBindTransformFeedbackBuffersEXT", (void*)CmdBindTransformFeedbackBuffersEXT},
3851 {"vkCmdBeginTransformFeedbackEXT", (void*)CmdBeginTransformFeedbackEXT},
3852 {"vkCmdEndTransformFeedbackEXT", (void*)CmdEndTransformFeedbackEXT},
3853 {"vkCmdBeginQueryIndexedEXT", (void*)CmdBeginQueryIndexedEXT},
3854 {"vkCmdEndQueryIndexedEXT", (void*)CmdEndQueryIndexedEXT},
3855 {"vkCmdDrawIndirectByteCountEXT", (void*)CmdDrawIndirectByteCountEXT},
3856 {"vkCreateCuModuleNVX", (void*)CreateCuModuleNVX},
3857 {"vkCreateCuFunctionNVX", (void*)CreateCuFunctionNVX},
3858 {"vkDestroyCuModuleNVX", (void*)DestroyCuModuleNVX},
3859 {"vkDestroyCuFunctionNVX", (void*)DestroyCuFunctionNVX},
3860 {"vkCmdCuLaunchKernelNVX", (void*)CmdCuLaunchKernelNVX},
3861 {"vkGetImageViewHandleNVX", (void*)GetImageViewHandleNVX},
3862 {"vkGetImageViewAddressNVX", (void*)GetImageViewAddressNVX},
3863 {"vkCmdDrawIndirectCountAMD", (void*)CmdDrawIndirectCountAMD},
3864 {"vkCmdDrawIndexedIndirectCountAMD", (void*)CmdDrawIndexedIndirectCountAMD},
3865 {"vkGetShaderInfoAMD", (void*)GetShaderInfoAMD},
3866 #ifdef VK_USE_PLATFORM_GGP
3867 {"vkCreateStreamDescriptorSurfaceGGP", (void*)CreateStreamDescriptorSurfaceGGP},
3868 #endif
3869 {"vkGetPhysicalDeviceExternalImageFormatPropertiesNV", (void*)GetPhysicalDeviceExternalImageFormatPropertiesNV},
3870 #ifdef VK_USE_PLATFORM_WIN32_KHR
3871 {"vkGetMemoryWin32HandleNV", (void*)GetMemoryWin32HandleNV},
3872 #endif
3873 #ifdef VK_USE_PLATFORM_VI_NN
3874 {"vkCreateViSurfaceNN", (void*)CreateViSurfaceNN},
3875 #endif
3876 {"vkCmdBeginConditionalRenderingEXT", (void*)CmdBeginConditionalRenderingEXT},
3877 {"vkCmdEndConditionalRenderingEXT", (void*)CmdEndConditionalRenderingEXT},
3878 {"vkCmdSetViewportWScalingNV", (void*)CmdSetViewportWScalingNV},
3879 {"vkReleaseDisplayEXT", (void*)ReleaseDisplayEXT},
3880 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
3881 {"vkAcquireXlibDisplayEXT", (void*)AcquireXlibDisplayEXT},
3882 #endif
3883 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
3884 {"vkGetRandROutputDisplayEXT", (void*)GetRandROutputDisplayEXT},
3885 #endif
3886 {"vkGetPhysicalDeviceSurfaceCapabilities2EXT", (void*)GetPhysicalDeviceSurfaceCapabilities2EXT},
3887 {"vkDisplayPowerControlEXT", (void*)DisplayPowerControlEXT},
3888 {"vkRegisterDeviceEventEXT", (void*)RegisterDeviceEventEXT},
3889 {"vkRegisterDisplayEventEXT", (void*)RegisterDisplayEventEXT},
3890 {"vkGetSwapchainCounterEXT", (void*)GetSwapchainCounterEXT},
3891 {"vkGetRefreshCycleDurationGOOGLE", (void*)GetRefreshCycleDurationGOOGLE},
3892 {"vkGetPastPresentationTimingGOOGLE", (void*)GetPastPresentationTimingGOOGLE},
3893 {"vkCmdSetDiscardRectangleEXT", (void*)CmdSetDiscardRectangleEXT},
3894 {"vkSetHdrMetadataEXT", (void*)SetHdrMetadataEXT},
3895 #ifdef VK_USE_PLATFORM_IOS_MVK
3896 {"vkCreateIOSSurfaceMVK", (void*)CreateIOSSurfaceMVK},
3897 #endif
3898 #ifdef VK_USE_PLATFORM_MACOS_MVK
3899 {"vkCreateMacOSSurfaceMVK", (void*)CreateMacOSSurfaceMVK},
3900 #endif
3901 {"vkSetDebugUtilsObjectNameEXT", (void*)SetDebugUtilsObjectNameEXT},
3902 {"vkSetDebugUtilsObjectTagEXT", (void*)SetDebugUtilsObjectTagEXT},
3903 {"vkQueueBeginDebugUtilsLabelEXT", (void*)QueueBeginDebugUtilsLabelEXT},
3904 {"vkQueueEndDebugUtilsLabelEXT", (void*)QueueEndDebugUtilsLabelEXT},
3905 {"vkQueueInsertDebugUtilsLabelEXT", (void*)QueueInsertDebugUtilsLabelEXT},
3906 {"vkCmdBeginDebugUtilsLabelEXT", (void*)CmdBeginDebugUtilsLabelEXT},
3907 {"vkCmdEndDebugUtilsLabelEXT", (void*)CmdEndDebugUtilsLabelEXT},
3908 {"vkCmdInsertDebugUtilsLabelEXT", (void*)CmdInsertDebugUtilsLabelEXT},
3909 {"vkCreateDebugUtilsMessengerEXT", (void*)CreateDebugUtilsMessengerEXT},
3910 {"vkDestroyDebugUtilsMessengerEXT", (void*)DestroyDebugUtilsMessengerEXT},
3911 {"vkSubmitDebugUtilsMessageEXT", (void*)SubmitDebugUtilsMessageEXT},
3912 #ifdef VK_USE_PLATFORM_ANDROID_KHR
3913 {"vkGetAndroidHardwareBufferPropertiesANDROID", (void*)GetAndroidHardwareBufferPropertiesANDROID},
3914 #endif
3915 #ifdef VK_USE_PLATFORM_ANDROID_KHR
3916 {"vkGetMemoryAndroidHardwareBufferANDROID", (void*)GetMemoryAndroidHardwareBufferANDROID},
3917 #endif
3918 {"vkCmdSetSampleLocationsEXT", (void*)CmdSetSampleLocationsEXT},
3919 {"vkGetPhysicalDeviceMultisamplePropertiesEXT", (void*)GetPhysicalDeviceMultisamplePropertiesEXT},
3920 {"vkGetImageDrmFormatModifierPropertiesEXT", (void*)GetImageDrmFormatModifierPropertiesEXT},
3921 {"vkCreateValidationCacheEXT", (void*)CreateValidationCacheEXT},
3922 {"vkDestroyValidationCacheEXT", (void*)DestroyValidationCacheEXT},
3923 {"vkMergeValidationCachesEXT", (void*)MergeValidationCachesEXT},
3924 {"vkGetValidationCacheDataEXT", (void*)GetValidationCacheDataEXT},
3925 {"vkCmdBindShadingRateImageNV", (void*)CmdBindShadingRateImageNV},
3926 {"vkCmdSetViewportShadingRatePaletteNV", (void*)CmdSetViewportShadingRatePaletteNV},
3927 {"vkCmdSetCoarseSampleOrderNV", (void*)CmdSetCoarseSampleOrderNV},
3928 {"vkCreateAccelerationStructureNV", (void*)CreateAccelerationStructureNV},
3929 {"vkDestroyAccelerationStructureNV", (void*)DestroyAccelerationStructureNV},
3930 {"vkGetAccelerationStructureMemoryRequirementsNV", (void*)GetAccelerationStructureMemoryRequirementsNV},
3931 {"vkBindAccelerationStructureMemoryNV", (void*)BindAccelerationStructureMemoryNV},
3932 {"vkCmdBuildAccelerationStructureNV", (void*)CmdBuildAccelerationStructureNV},
3933 {"vkCmdCopyAccelerationStructureNV", (void*)CmdCopyAccelerationStructureNV},
3934 {"vkCmdTraceRaysNV", (void*)CmdTraceRaysNV},
3935 {"vkCreateRayTracingPipelinesNV", (void*)CreateRayTracingPipelinesNV},
3936 {"vkGetRayTracingShaderGroupHandlesKHR", (void*)GetRayTracingShaderGroupHandlesKHR},
3937 {"vkGetRayTracingShaderGroupHandlesNV", (void*)GetRayTracingShaderGroupHandlesNV},
3938 {"vkGetAccelerationStructureHandleNV", (void*)GetAccelerationStructureHandleNV},
3939 {"vkCmdWriteAccelerationStructuresPropertiesNV", (void*)CmdWriteAccelerationStructuresPropertiesNV},
3940 {"vkCompileDeferredNV", (void*)CompileDeferredNV},
3941 {"vkGetMemoryHostPointerPropertiesEXT", (void*)GetMemoryHostPointerPropertiesEXT},
3942 {"vkCmdWriteBufferMarkerAMD", (void*)CmdWriteBufferMarkerAMD},
3943 {"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", (void*)GetPhysicalDeviceCalibrateableTimeDomainsEXT},
3944 {"vkGetCalibratedTimestampsEXT", (void*)GetCalibratedTimestampsEXT},
3945 {"vkCmdDrawMeshTasksNV", (void*)CmdDrawMeshTasksNV},
3946 {"vkCmdDrawMeshTasksIndirectNV", (void*)CmdDrawMeshTasksIndirectNV},
3947 {"vkCmdDrawMeshTasksIndirectCountNV", (void*)CmdDrawMeshTasksIndirectCountNV},
3948 {"vkCmdSetExclusiveScissorNV", (void*)CmdSetExclusiveScissorNV},
3949 {"vkCmdSetCheckpointNV", (void*)CmdSetCheckpointNV},
3950 {"vkGetQueueCheckpointDataNV", (void*)GetQueueCheckpointDataNV},
3951 {"vkInitializePerformanceApiINTEL", (void*)InitializePerformanceApiINTEL},
3952 {"vkUninitializePerformanceApiINTEL", (void*)UninitializePerformanceApiINTEL},
3953 {"vkCmdSetPerformanceMarkerINTEL", (void*)CmdSetPerformanceMarkerINTEL},
3954 {"vkCmdSetPerformanceStreamMarkerINTEL", (void*)CmdSetPerformanceStreamMarkerINTEL},
3955 {"vkCmdSetPerformanceOverrideINTEL", (void*)CmdSetPerformanceOverrideINTEL},
3956 {"vkAcquirePerformanceConfigurationINTEL", (void*)AcquirePerformanceConfigurationINTEL},
3957 {"vkReleasePerformanceConfigurationINTEL", (void*)ReleasePerformanceConfigurationINTEL},
3958 {"vkQueueSetPerformanceConfigurationINTEL", (void*)QueueSetPerformanceConfigurationINTEL},
3959 {"vkGetPerformanceParameterINTEL", (void*)GetPerformanceParameterINTEL},
3960 {"vkSetLocalDimmingAMD", (void*)SetLocalDimmingAMD},
3961 #ifdef VK_USE_PLATFORM_FUCHSIA
3962 {"vkCreateImagePipeSurfaceFUCHSIA", (void*)CreateImagePipeSurfaceFUCHSIA},
3963 #endif
3964 #ifdef VK_USE_PLATFORM_METAL_EXT
3965 {"vkCreateMetalSurfaceEXT", (void*)CreateMetalSurfaceEXT},
3966 #endif
3967 {"vkGetBufferDeviceAddressEXT", (void*)GetBufferDeviceAddressEXT},
3968 {"vkGetPhysicalDeviceToolPropertiesEXT", (void*)GetPhysicalDeviceToolPropertiesEXT},
3969 {"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", (void*)GetPhysicalDeviceCooperativeMatrixPropertiesNV},
3970 {"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV", (void*)GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV},
3971 #ifdef VK_USE_PLATFORM_WIN32_KHR
3972 {"vkGetPhysicalDeviceSurfacePresentModes2EXT", (void*)GetPhysicalDeviceSurfacePresentModes2EXT},
3973 #endif
3974 #ifdef VK_USE_PLATFORM_WIN32_KHR
3975 {"vkAcquireFullScreenExclusiveModeEXT", (void*)AcquireFullScreenExclusiveModeEXT},
3976 #endif
3977 #ifdef VK_USE_PLATFORM_WIN32_KHR
3978 {"vkReleaseFullScreenExclusiveModeEXT", (void*)ReleaseFullScreenExclusiveModeEXT},
3979 #endif
3980 #ifdef VK_USE_PLATFORM_WIN32_KHR
3981 {"vkGetDeviceGroupSurfacePresentModes2EXT", (void*)GetDeviceGroupSurfacePresentModes2EXT},
3982 #endif
3983 {"vkCreateHeadlessSurfaceEXT", (void*)CreateHeadlessSurfaceEXT},
3984 {"vkCmdSetLineStippleEXT", (void*)CmdSetLineStippleEXT},
3985 {"vkResetQueryPoolEXT", (void*)ResetQueryPoolEXT},
3986 {"vkCmdSetCullModeEXT", (void*)CmdSetCullModeEXT},
3987 {"vkCmdSetFrontFaceEXT", (void*)CmdSetFrontFaceEXT},
3988 {"vkCmdSetPrimitiveTopologyEXT", (void*)CmdSetPrimitiveTopologyEXT},
3989 {"vkCmdSetViewportWithCountEXT", (void*)CmdSetViewportWithCountEXT},
3990 {"vkCmdSetScissorWithCountEXT", (void*)CmdSetScissorWithCountEXT},
3991 {"vkCmdBindVertexBuffers2EXT", (void*)CmdBindVertexBuffers2EXT},
3992 {"vkCmdSetDepthTestEnableEXT", (void*)CmdSetDepthTestEnableEXT},
3993 {"vkCmdSetDepthWriteEnableEXT", (void*)CmdSetDepthWriteEnableEXT},
3994 {"vkCmdSetDepthCompareOpEXT", (void*)CmdSetDepthCompareOpEXT},
3995 {"vkCmdSetDepthBoundsTestEnableEXT", (void*)CmdSetDepthBoundsTestEnableEXT},
3996 {"vkCmdSetStencilTestEnableEXT", (void*)CmdSetStencilTestEnableEXT},
3997 {"vkCmdSetStencilOpEXT", (void*)CmdSetStencilOpEXT},
3998 {"vkGetGeneratedCommandsMemoryRequirementsNV", (void*)GetGeneratedCommandsMemoryRequirementsNV},
3999 {"vkCmdPreprocessGeneratedCommandsNV", (void*)CmdPreprocessGeneratedCommandsNV},
4000 {"vkCmdExecuteGeneratedCommandsNV", (void*)CmdExecuteGeneratedCommandsNV},
4001 {"vkCmdBindPipelineShaderGroupNV", (void*)CmdBindPipelineShaderGroupNV},
4002 {"vkCreateIndirectCommandsLayoutNV", (void*)CreateIndirectCommandsLayoutNV},
4003 {"vkDestroyIndirectCommandsLayoutNV", (void*)DestroyIndirectCommandsLayoutNV},
4004 {"vkAcquireDrmDisplayEXT", (void*)AcquireDrmDisplayEXT},
4005 {"vkGetDrmDisplayEXT", (void*)GetDrmDisplayEXT},
4006 {"vkCreatePrivateDataSlotEXT", (void*)CreatePrivateDataSlotEXT},
4007 {"vkDestroyPrivateDataSlotEXT", (void*)DestroyPrivateDataSlotEXT},
4008 {"vkSetPrivateDataEXT", (void*)SetPrivateDataEXT},
4009 {"vkGetPrivateDataEXT", (void*)GetPrivateDataEXT},
4010 {"vkCmdSetFragmentShadingRateEnumNV", (void*)CmdSetFragmentShadingRateEnumNV},
4011 #ifdef VK_USE_PLATFORM_WIN32_KHR
4012 {"vkAcquireWinrtDisplayNV", (void*)AcquireWinrtDisplayNV},
4013 #endif
4014 #ifdef VK_USE_PLATFORM_WIN32_KHR
4015 {"vkGetWinrtDisplayNV", (void*)GetWinrtDisplayNV},
4016 #endif
4017 #ifdef VK_USE_PLATFORM_DIRECTFB_EXT
4018 {"vkCreateDirectFBSurfaceEXT", (void*)CreateDirectFBSurfaceEXT},
4019 #endif
4020 #ifdef VK_USE_PLATFORM_DIRECTFB_EXT
4021 {"vkGetPhysicalDeviceDirectFBPresentationSupportEXT", (void*)GetPhysicalDeviceDirectFBPresentationSupportEXT},
4022 #endif
4023 {"vkCmdSetVertexInputEXT", (void*)CmdSetVertexInputEXT},
4024 #ifdef VK_USE_PLATFORM_FUCHSIA
4025 {"vkGetMemoryZirconHandleFUCHSIA", (void*)GetMemoryZirconHandleFUCHSIA},
4026 #endif
4027 #ifdef VK_USE_PLATFORM_FUCHSIA
4028 {"vkGetMemoryZirconHandlePropertiesFUCHSIA", (void*)GetMemoryZirconHandlePropertiesFUCHSIA},
4029 #endif
4030 #ifdef VK_USE_PLATFORM_FUCHSIA
4031 {"vkImportSemaphoreZirconHandleFUCHSIA", (void*)ImportSemaphoreZirconHandleFUCHSIA},
4032 #endif
4033 #ifdef VK_USE_PLATFORM_FUCHSIA
4034 {"vkGetSemaphoreZirconHandleFUCHSIA", (void*)GetSemaphoreZirconHandleFUCHSIA},
4035 #endif
4036 #ifdef VK_USE_PLATFORM_FUCHSIA
4037 {"vkCreateBufferCollectionFUCHSIA", (void*)CreateBufferCollectionFUCHSIA},
4038 #endif
4039 #ifdef VK_USE_PLATFORM_FUCHSIA
4040 {"vkSetBufferCollectionImageConstraintsFUCHSIA", (void*)SetBufferCollectionImageConstraintsFUCHSIA},
4041 #endif
4042 #ifdef VK_USE_PLATFORM_FUCHSIA
4043 {"vkSetBufferCollectionBufferConstraintsFUCHSIA", (void*)SetBufferCollectionBufferConstraintsFUCHSIA},
4044 #endif
4045 #ifdef VK_USE_PLATFORM_FUCHSIA
4046 {"vkDestroyBufferCollectionFUCHSIA", (void*)DestroyBufferCollectionFUCHSIA},
4047 #endif
4048 #ifdef VK_USE_PLATFORM_FUCHSIA
4049 {"vkGetBufferCollectionPropertiesFUCHSIA", (void*)GetBufferCollectionPropertiesFUCHSIA},
4050 #endif
4051 {"vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI", (void*)GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI},
4052 {"vkCmdSubpassShadingHUAWEI", (void*)CmdSubpassShadingHUAWEI},
4053 {"vkCmdBindInvocationMaskHUAWEI", (void*)CmdBindInvocationMaskHUAWEI},
4054 {"vkGetMemoryRemoteAddressNV", (void*)GetMemoryRemoteAddressNV},
4055 {"vkCmdSetPatchControlPointsEXT", (void*)CmdSetPatchControlPointsEXT},
4056 {"vkCmdSetRasterizerDiscardEnableEXT", (void*)CmdSetRasterizerDiscardEnableEXT},
4057 {"vkCmdSetDepthBiasEnableEXT", (void*)CmdSetDepthBiasEnableEXT},
4058 {"vkCmdSetLogicOpEXT", (void*)CmdSetLogicOpEXT},
4059 {"vkCmdSetPrimitiveRestartEnableEXT", (void*)CmdSetPrimitiveRestartEnableEXT},
4060 #ifdef VK_USE_PLATFORM_SCREEN_QNX
4061 {"vkCreateScreenSurfaceQNX", (void*)CreateScreenSurfaceQNX},
4062 #endif
4063 #ifdef VK_USE_PLATFORM_SCREEN_QNX
4064 {"vkGetPhysicalDeviceScreenPresentationSupportQNX", (void*)GetPhysicalDeviceScreenPresentationSupportQNX},
4065 #endif
4066 {"vkCmdSetColorWriteEnableEXT", (void*)CmdSetColorWriteEnableEXT},
4067 {"vkCmdDrawMultiEXT", (void*)CmdDrawMultiEXT},
4068 {"vkCmdDrawMultiIndexedEXT", (void*)CmdDrawMultiIndexedEXT},
4069 {"vkSetDeviceMemoryPriorityEXT", (void*)SetDeviceMemoryPriorityEXT},
4070 {"vkCreateAccelerationStructureKHR", (void*)CreateAccelerationStructureKHR},
4071 {"vkDestroyAccelerationStructureKHR", (void*)DestroyAccelerationStructureKHR},
4072 {"vkCmdBuildAccelerationStructuresKHR", (void*)CmdBuildAccelerationStructuresKHR},
4073 {"vkCmdBuildAccelerationStructuresIndirectKHR", (void*)CmdBuildAccelerationStructuresIndirectKHR},
4074 {"vkBuildAccelerationStructuresKHR", (void*)BuildAccelerationStructuresKHR},
4075 {"vkCopyAccelerationStructureKHR", (void*)CopyAccelerationStructureKHR},
4076 {"vkCopyAccelerationStructureToMemoryKHR", (void*)CopyAccelerationStructureToMemoryKHR},
4077 {"vkCopyMemoryToAccelerationStructureKHR", (void*)CopyMemoryToAccelerationStructureKHR},
4078 {"vkWriteAccelerationStructuresPropertiesKHR", (void*)WriteAccelerationStructuresPropertiesKHR},
4079 {"vkCmdCopyAccelerationStructureKHR", (void*)CmdCopyAccelerationStructureKHR},
4080 {"vkCmdCopyAccelerationStructureToMemoryKHR", (void*)CmdCopyAccelerationStructureToMemoryKHR},
4081 {"vkCmdCopyMemoryToAccelerationStructureKHR", (void*)CmdCopyMemoryToAccelerationStructureKHR},
4082 {"vkGetAccelerationStructureDeviceAddressKHR", (void*)GetAccelerationStructureDeviceAddressKHR},
4083 {"vkCmdWriteAccelerationStructuresPropertiesKHR", (void*)CmdWriteAccelerationStructuresPropertiesKHR},
4084 {"vkGetDeviceAccelerationStructureCompatibilityKHR", (void*)GetDeviceAccelerationStructureCompatibilityKHR},
4085 {"vkGetAccelerationStructureBuildSizesKHR", (void*)GetAccelerationStructureBuildSizesKHR},
4086 {"vkCmdTraceRaysKHR", (void*)CmdTraceRaysKHR},
4087 {"vkCreateRayTracingPipelinesKHR", (void*)CreateRayTracingPipelinesKHR},
4088 {"vkGetRayTracingCaptureReplayShaderGroupHandlesKHR", (void*)GetRayTracingCaptureReplayShaderGroupHandlesKHR},
4089 {"vkCmdTraceRaysIndirectKHR", (void*)CmdTraceRaysIndirectKHR},
4090 {"vkGetRayTracingShaderGroupStackSizeKHR", (void*)GetRayTracingShaderGroupStackSizeKHR},
4091 {"vkCmdSetRayTracingPipelineStackSizeKHR", (void*)CmdSetRayTracingPipelineStackSizeKHR},
4092 };
4093
4094
4095 } // namespace vkmock
4096
4097 #endif
4098