Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / vulkan-validation-layers / b836ac94fee5d423f724d327f39538912ed5a75a / . / layers / generated / layer_chassis_dispatch.h
blob: 5d013188cda23ec372ec485d56c45b39326275b7 [file] [log] [blame]
Mike Schuchardt440d4642019-06-20 17:14:57 -0700[diff] [blame]1
2
3// This file is ***GENERATED***. Do Not Edit.
4// See layer_chassis_dispatch_generator.py for modifications.
5
6/* Copyright (c) 2015-2019 The Khronos Group Inc.
7 * Copyright (c) 2015-2019 Valve Corporation
8 * Copyright (c) 2015-2019 LunarG, Inc.
9 * Copyright (c) 2015-2019 Google Inc.
10 *
11 * Licensed under the Apache License, Version 2.0 (the "License");
12 * you may not use this file except in compliance with the License.
13 * You may obtain a copy of the License at
14 *
15 * http://www.apache.org/licenses/LICENSE-2.0
16 *
17 * Unless required by applicable law or agreed to in writing, software
18 * distributed under the License is distributed on an "AS IS" BASIS,
19 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
20 * See the License for the specific language governing permissions and
21 * limitations under the License.
22 *
23 * Author: Mark Lobodzinski <mark@lunarg.com>
24 */
25#pragma once
26
27#if defined(LAYER_CHASSIS_CAN_WRAP_HANDLES)
28extern bool wrap_handles;
29#else
30extern bool wrap_handles;
31#endif
32VkResult DispatchCreateInstance(
33 const VkInstanceCreateInfo* pCreateInfo,
34 const VkAllocationCallbacks* pAllocator,
35 VkInstance* pInstance);
36void DispatchDestroyInstance(
37 VkInstance instance,
38 const VkAllocationCallbacks* pAllocator);
39VkResult DispatchEnumeratePhysicalDevices(
40 VkInstance instance,
41 uint32_t* pPhysicalDeviceCount,
42 VkPhysicalDevice* pPhysicalDevices);
43void DispatchGetPhysicalDeviceFeatures(
44 VkPhysicalDevice physicalDevice,
45 VkPhysicalDeviceFeatures* pFeatures);
46void DispatchGetPhysicalDeviceFormatProperties(
47 VkPhysicalDevice physicalDevice,
48 VkFormat format,
49 VkFormatProperties* pFormatProperties);
50VkResult DispatchGetPhysicalDeviceImageFormatProperties(
51 VkPhysicalDevice physicalDevice,
52 VkFormat format,
53 VkImageType type,
54 VkImageTiling tiling,
55 VkImageUsageFlags usage,
56 VkImageCreateFlags flags,
57 VkImageFormatProperties* pImageFormatProperties);
58void DispatchGetPhysicalDeviceProperties(
59 VkPhysicalDevice physicalDevice,
60 VkPhysicalDeviceProperties* pProperties);
61void DispatchGetPhysicalDeviceQueueFamilyProperties(
62 VkPhysicalDevice physicalDevice,
63 uint32_t* pQueueFamilyPropertyCount,
64 VkQueueFamilyProperties* pQueueFamilyProperties);
65void DispatchGetPhysicalDeviceMemoryProperties(
66 VkPhysicalDevice physicalDevice,
67 VkPhysicalDeviceMemoryProperties* pMemoryProperties);
68PFN_vkVoidFunction DispatchGetInstanceProcAddr(
69 VkInstance instance,
70 const char* pName);
71PFN_vkVoidFunction DispatchGetDeviceProcAddr(
72 VkDevice device,
73 const char* pName);
74VkResult DispatchCreateDevice(
75 VkPhysicalDevice physicalDevice,
76 const VkDeviceCreateInfo* pCreateInfo,
77 const VkAllocationCallbacks* pAllocator,
78 VkDevice* pDevice);
79void DispatchDestroyDevice(
80 VkDevice device,
81 const VkAllocationCallbacks* pAllocator);
82VkResult DispatchEnumerateInstanceExtensionProperties(
83 const char* pLayerName,
84 uint32_t* pPropertyCount,
85 VkExtensionProperties* pProperties);
86VkResult DispatchEnumerateDeviceExtensionProperties(
87 VkPhysicalDevice physicalDevice,
88 const char* pLayerName,
89 uint32_t* pPropertyCount,
90 VkExtensionProperties* pProperties);
91VkResult DispatchEnumerateInstanceLayerProperties(
92 uint32_t* pPropertyCount,
93 VkLayerProperties* pProperties);
94VkResult DispatchEnumerateDeviceLayerProperties(
95 VkPhysicalDevice physicalDevice,
96 uint32_t* pPropertyCount,
97 VkLayerProperties* pProperties);
98void DispatchGetDeviceQueue(
99 VkDevice device,
100 uint32_t queueFamilyIndex,
101 uint32_t queueIndex,
102 VkQueue* pQueue);
103VkResult DispatchQueueSubmit(
104 VkQueue queue,
105 uint32_t submitCount,
106 const VkSubmitInfo* pSubmits,
107 VkFence fence);
108VkResult DispatchQueueWaitIdle(
109 VkQueue queue);
110VkResult DispatchDeviceWaitIdle(
111 VkDevice device);
112VkResult DispatchAllocateMemory(
113 VkDevice device,
114 const VkMemoryAllocateInfo* pAllocateInfo,
115 const VkAllocationCallbacks* pAllocator,
116 VkDeviceMemory* pMemory);
117void DispatchFreeMemory(
118 VkDevice device,
119 VkDeviceMemory memory,
120 const VkAllocationCallbacks* pAllocator);
121VkResult DispatchMapMemory(
122 VkDevice device,
123 VkDeviceMemory memory,
124 VkDeviceSize offset,
125 VkDeviceSize size,
126 VkMemoryMapFlags flags,
127 void** ppData);
128void DispatchUnmapMemory(
129 VkDevice device,
130 VkDeviceMemory memory);
131VkResult DispatchFlushMappedMemoryRanges(
132 VkDevice device,
133 uint32_t memoryRangeCount,
134 const VkMappedMemoryRange* pMemoryRanges);
135VkResult DispatchInvalidateMappedMemoryRanges(
136 VkDevice device,
137 uint32_t memoryRangeCount,
138 const VkMappedMemoryRange* pMemoryRanges);
139void DispatchGetDeviceMemoryCommitment(
140 VkDevice device,
141 VkDeviceMemory memory,
142 VkDeviceSize* pCommittedMemoryInBytes);
143VkResult DispatchBindBufferMemory(
144 VkDevice device,
145 VkBuffer buffer,
146 VkDeviceMemory memory,
147 VkDeviceSize memoryOffset);
148VkResult DispatchBindImageMemory(
149 VkDevice device,
150 VkImage image,
151 VkDeviceMemory memory,
152 VkDeviceSize memoryOffset);
153void DispatchGetBufferMemoryRequirements(
154 VkDevice device,
155 VkBuffer buffer,
156 VkMemoryRequirements* pMemoryRequirements);
157void DispatchGetImageMemoryRequirements(
158 VkDevice device,
159 VkImage image,
160 VkMemoryRequirements* pMemoryRequirements);
161void DispatchGetImageSparseMemoryRequirements(
162 VkDevice device,
163 VkImage image,
164 uint32_t* pSparseMemoryRequirementCount,
165 VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
166void DispatchGetPhysicalDeviceSparseImageFormatProperties(
167 VkPhysicalDevice physicalDevice,
168 VkFormat format,
169 VkImageType type,
170 VkSampleCountFlagBits samples,
171 VkImageUsageFlags usage,
172 VkImageTiling tiling,
173 uint32_t* pPropertyCount,
174 VkSparseImageFormatProperties* pProperties);
175VkResult DispatchQueueBindSparse(
176 VkQueue queue,
177 uint32_t bindInfoCount,
178 const VkBindSparseInfo* pBindInfo,
179 VkFence fence);
180VkResult DispatchCreateFence(
181 VkDevice device,
182 const VkFenceCreateInfo* pCreateInfo,
183 const VkAllocationCallbacks* pAllocator,
184 VkFence* pFence);
185void DispatchDestroyFence(
186 VkDevice device,
187 VkFence fence,
188 const VkAllocationCallbacks* pAllocator);
189VkResult DispatchResetFences(
190 VkDevice device,
191 uint32_t fenceCount,
192 const VkFence* pFences);
193VkResult DispatchGetFenceStatus(
194 VkDevice device,
195 VkFence fence);
196VkResult DispatchWaitForFences(
197 VkDevice device,
198 uint32_t fenceCount,
199 const VkFence* pFences,
200 VkBool32 waitAll,
201 uint64_t timeout);
202VkResult DispatchCreateSemaphore(
203 VkDevice device,
204 const VkSemaphoreCreateInfo* pCreateInfo,
205 const VkAllocationCallbacks* pAllocator,
206 VkSemaphore* pSemaphore);
207void DispatchDestroySemaphore(
208 VkDevice device,
209 VkSemaphore semaphore,
210 const VkAllocationCallbacks* pAllocator);
211VkResult DispatchCreateEvent(
212 VkDevice device,
213 const VkEventCreateInfo* pCreateInfo,
214 const VkAllocationCallbacks* pAllocator,
215 VkEvent* pEvent);
216void DispatchDestroyEvent(
217 VkDevice device,
218 VkEvent event,
219 const VkAllocationCallbacks* pAllocator);
220VkResult DispatchGetEventStatus(
221 VkDevice device,
222 VkEvent event);
223VkResult DispatchSetEvent(
224 VkDevice device,
225 VkEvent event);
226VkResult DispatchResetEvent(
227 VkDevice device,
228 VkEvent event);
229VkResult DispatchCreateQueryPool(
230 VkDevice device,
231 const VkQueryPoolCreateInfo* pCreateInfo,
232 const VkAllocationCallbacks* pAllocator,
233 VkQueryPool* pQueryPool);
234void DispatchDestroyQueryPool(
235 VkDevice device,
236 VkQueryPool queryPool,
237 const VkAllocationCallbacks* pAllocator);
238VkResult DispatchGetQueryPoolResults(
239 VkDevice device,
240 VkQueryPool queryPool,
241 uint32_t firstQuery,
242 uint32_t queryCount,
243 size_t dataSize,
244 void* pData,
245 VkDeviceSize stride,
246 VkQueryResultFlags flags);
247VkResult DispatchCreateBuffer(
248 VkDevice device,
249 const VkBufferCreateInfo* pCreateInfo,
250 const VkAllocationCallbacks* pAllocator,
251 VkBuffer* pBuffer);
252void DispatchDestroyBuffer(
253 VkDevice device,
254 VkBuffer buffer,
255 const VkAllocationCallbacks* pAllocator);
256VkResult DispatchCreateBufferView(
257 VkDevice device,
258 const VkBufferViewCreateInfo* pCreateInfo,
259 const VkAllocationCallbacks* pAllocator,
260 VkBufferView* pView);
261void DispatchDestroyBufferView(
262 VkDevice device,
263 VkBufferView bufferView,
264 const VkAllocationCallbacks* pAllocator);
265VkResult DispatchCreateImage(
266 VkDevice device,
267 const VkImageCreateInfo* pCreateInfo,
268 const VkAllocationCallbacks* pAllocator,
269 VkImage* pImage);
270void DispatchDestroyImage(
271 VkDevice device,
272 VkImage image,
273 const VkAllocationCallbacks* pAllocator);
274void DispatchGetImageSubresourceLayout(
275 VkDevice device,
276 VkImage image,
277 const VkImageSubresource* pSubresource,
278 VkSubresourceLayout* pLayout);
279VkResult DispatchCreateImageView(
280 VkDevice device,
281 const VkImageViewCreateInfo* pCreateInfo,
282 const VkAllocationCallbacks* pAllocator,
283 VkImageView* pView);
284void DispatchDestroyImageView(
285 VkDevice device,
286 VkImageView imageView,
287 const VkAllocationCallbacks* pAllocator);
288VkResult DispatchCreateShaderModule(
289 VkDevice device,
290 const VkShaderModuleCreateInfo* pCreateInfo,
291 const VkAllocationCallbacks* pAllocator,
292 VkShaderModule* pShaderModule);
293void DispatchDestroyShaderModule(
294 VkDevice device,
295 VkShaderModule shaderModule,
296 const VkAllocationCallbacks* pAllocator);
297VkResult DispatchCreatePipelineCache(
298 VkDevice device,
299 const VkPipelineCacheCreateInfo* pCreateInfo,
300 const VkAllocationCallbacks* pAllocator,
301 VkPipelineCache* pPipelineCache);
302void DispatchDestroyPipelineCache(
303 VkDevice device,
304 VkPipelineCache pipelineCache,
305 const VkAllocationCallbacks* pAllocator);
306VkResult DispatchGetPipelineCacheData(
307 VkDevice device,
308 VkPipelineCache pipelineCache,
309 size_t* pDataSize,
310 void* pData);
311VkResult DispatchMergePipelineCaches(
312 VkDevice device,
313 VkPipelineCache dstCache,
314 uint32_t srcCacheCount,
315 const VkPipelineCache* pSrcCaches);
316VkResult DispatchCreateGraphicsPipelines(
317 VkDevice device,
318 VkPipelineCache pipelineCache,
319 uint32_t createInfoCount,
320 const VkGraphicsPipelineCreateInfo* pCreateInfos,
321 const VkAllocationCallbacks* pAllocator,
322 VkPipeline* pPipelines);
323VkResult DispatchCreateComputePipelines(
324 VkDevice device,
325 VkPipelineCache pipelineCache,
326 uint32_t createInfoCount,
327 const VkComputePipelineCreateInfo* pCreateInfos,
328 const VkAllocationCallbacks* pAllocator,
329 VkPipeline* pPipelines);
330void DispatchDestroyPipeline(
331 VkDevice device,
332 VkPipeline pipeline,
333 const VkAllocationCallbacks* pAllocator);
334VkResult DispatchCreatePipelineLayout(
335 VkDevice device,
336 const VkPipelineLayoutCreateInfo* pCreateInfo,
337 const VkAllocationCallbacks* pAllocator,
338 VkPipelineLayout* pPipelineLayout);
339void DispatchDestroyPipelineLayout(
340 VkDevice device,
341 VkPipelineLayout pipelineLayout,
342 const VkAllocationCallbacks* pAllocator);
343VkResult DispatchCreateSampler(
344 VkDevice device,
345 const VkSamplerCreateInfo* pCreateInfo,
346 const VkAllocationCallbacks* pAllocator,
347 VkSampler* pSampler);
348void DispatchDestroySampler(
349 VkDevice device,
350 VkSampler sampler,
351 const VkAllocationCallbacks* pAllocator);
352VkResult DispatchCreateDescriptorSetLayout(
353 VkDevice device,
354 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
355 const VkAllocationCallbacks* pAllocator,
356 VkDescriptorSetLayout* pSetLayout);
357void DispatchDestroyDescriptorSetLayout(
358 VkDevice device,
359 VkDescriptorSetLayout descriptorSetLayout,
360 const VkAllocationCallbacks* pAllocator);
361VkResult DispatchCreateDescriptorPool(
362 VkDevice device,
363 const VkDescriptorPoolCreateInfo* pCreateInfo,
364 const VkAllocationCallbacks* pAllocator,
365 VkDescriptorPool* pDescriptorPool);
366void DispatchDestroyDescriptorPool(
367 VkDevice device,
368 VkDescriptorPool descriptorPool,
369 const VkAllocationCallbacks* pAllocator);
370VkResult DispatchResetDescriptorPool(
371 VkDevice device,
372 VkDescriptorPool descriptorPool,
373 VkDescriptorPoolResetFlags flags);
374VkResult DispatchAllocateDescriptorSets(
375 VkDevice device,
376 const VkDescriptorSetAllocateInfo* pAllocateInfo,
377 VkDescriptorSet* pDescriptorSets);
378VkResult DispatchFreeDescriptorSets(
379 VkDevice device,
380 VkDescriptorPool descriptorPool,
381 uint32_t descriptorSetCount,
382 const VkDescriptorSet* pDescriptorSets);
383void DispatchUpdateDescriptorSets(
384 VkDevice device,
385 uint32_t descriptorWriteCount,
386 const VkWriteDescriptorSet* pDescriptorWrites,
387 uint32_t descriptorCopyCount,
388 const VkCopyDescriptorSet* pDescriptorCopies);
389VkResult DispatchCreateFramebuffer(
390 VkDevice device,
391 const VkFramebufferCreateInfo* pCreateInfo,
392 const VkAllocationCallbacks* pAllocator,
393 VkFramebuffer* pFramebuffer);
394void DispatchDestroyFramebuffer(
395 VkDevice device,
396 VkFramebuffer framebuffer,
397 const VkAllocationCallbacks* pAllocator);
398VkResult DispatchCreateRenderPass(
399 VkDevice device,
400 const VkRenderPassCreateInfo* pCreateInfo,
401 const VkAllocationCallbacks* pAllocator,
402 VkRenderPass* pRenderPass);
403void DispatchDestroyRenderPass(
404 VkDevice device,
405 VkRenderPass renderPass,
406 const VkAllocationCallbacks* pAllocator);
407void DispatchGetRenderAreaGranularity(
408 VkDevice device,
409 VkRenderPass renderPass,
410 VkExtent2D* pGranularity);
411VkResult DispatchCreateCommandPool(
412 VkDevice device,
413 const VkCommandPoolCreateInfo* pCreateInfo,
414 const VkAllocationCallbacks* pAllocator,
415 VkCommandPool* pCommandPool);
416void DispatchDestroyCommandPool(
417 VkDevice device,
418 VkCommandPool commandPool,
419 const VkAllocationCallbacks* pAllocator);
420VkResult DispatchResetCommandPool(
421 VkDevice device,
422 VkCommandPool commandPool,
423 VkCommandPoolResetFlags flags);
424VkResult DispatchAllocateCommandBuffers(
425 VkDevice device,
426 const VkCommandBufferAllocateInfo* pAllocateInfo,
427 VkCommandBuffer* pCommandBuffers);
428void DispatchFreeCommandBuffers(
429 VkDevice device,
430 VkCommandPool commandPool,
431 uint32_t commandBufferCount,
432 const VkCommandBuffer* pCommandBuffers);
433VkResult DispatchBeginCommandBuffer(
434 VkCommandBuffer commandBuffer,
435 const VkCommandBufferBeginInfo* pBeginInfo);
436VkResult DispatchEndCommandBuffer(
437 VkCommandBuffer commandBuffer);
438VkResult DispatchResetCommandBuffer(
439 VkCommandBuffer commandBuffer,
440 VkCommandBufferResetFlags flags);
441void DispatchCmdBindPipeline(
442 VkCommandBuffer commandBuffer,
443 VkPipelineBindPoint pipelineBindPoint,
444 VkPipeline pipeline);
445void DispatchCmdSetViewport(
446 VkCommandBuffer commandBuffer,
447 uint32_t firstViewport,
448 uint32_t viewportCount,
449 const VkViewport* pViewports);
450void DispatchCmdSetScissor(
451 VkCommandBuffer commandBuffer,
452 uint32_t firstScissor,
453 uint32_t scissorCount,
454 const VkRect2D* pScissors);
455void DispatchCmdSetLineWidth(
456 VkCommandBuffer commandBuffer,
457 float lineWidth);
458void DispatchCmdSetDepthBias(
459 VkCommandBuffer commandBuffer,
460 float depthBiasConstantFactor,
461 float depthBiasClamp,
462 float depthBiasSlopeFactor);
463void DispatchCmdSetBlendConstants(
464 VkCommandBuffer commandBuffer,
465 const float blendConstants[4]);
466void DispatchCmdSetDepthBounds(
467 VkCommandBuffer commandBuffer,
468 float minDepthBounds,
469 float maxDepthBounds);
470void DispatchCmdSetStencilCompareMask(
471 VkCommandBuffer commandBuffer,
472 VkStencilFaceFlags faceMask,
473 uint32_t compareMask);
474void DispatchCmdSetStencilWriteMask(
475 VkCommandBuffer commandBuffer,
476 VkStencilFaceFlags faceMask,
477 uint32_t writeMask);
478void DispatchCmdSetStencilReference(
479 VkCommandBuffer commandBuffer,
480 VkStencilFaceFlags faceMask,
481 uint32_t reference);
482void DispatchCmdBindDescriptorSets(
483 VkCommandBuffer commandBuffer,
484 VkPipelineBindPoint pipelineBindPoint,
485 VkPipelineLayout layout,
486 uint32_t firstSet,
487 uint32_t descriptorSetCount,
488 const VkDescriptorSet* pDescriptorSets,
489 uint32_t dynamicOffsetCount,
490 const uint32_t* pDynamicOffsets);
491void DispatchCmdBindIndexBuffer(
492 VkCommandBuffer commandBuffer,
493 VkBuffer buffer,
494 VkDeviceSize offset,
495 VkIndexType indexType);
496void DispatchCmdBindVertexBuffers(
497 VkCommandBuffer commandBuffer,
498 uint32_t firstBinding,
499 uint32_t bindingCount,
500 const VkBuffer* pBuffers,
501 const VkDeviceSize* pOffsets);
502void DispatchCmdDraw(
503 VkCommandBuffer commandBuffer,
504 uint32_t vertexCount,
505 uint32_t instanceCount,
506 uint32_t firstVertex,
507 uint32_t firstInstance);
508void DispatchCmdDrawIndexed(
509 VkCommandBuffer commandBuffer,
510 uint32_t indexCount,
511 uint32_t instanceCount,
512 uint32_t firstIndex,
513 int32_t vertexOffset,
514 uint32_t firstInstance);
515void DispatchCmdDrawIndirect(
516 VkCommandBuffer commandBuffer,
517 VkBuffer buffer,
518 VkDeviceSize offset,
519 uint32_t drawCount,
520 uint32_t stride);
521void DispatchCmdDrawIndexedIndirect(
522 VkCommandBuffer commandBuffer,
523 VkBuffer buffer,
524 VkDeviceSize offset,
525 uint32_t drawCount,
526 uint32_t stride);
527void DispatchCmdDispatch(
528 VkCommandBuffer commandBuffer,
529 uint32_t groupCountX,
530 uint32_t groupCountY,
531 uint32_t groupCountZ);
532void DispatchCmdDispatchIndirect(
533 VkCommandBuffer commandBuffer,
534 VkBuffer buffer,
535 VkDeviceSize offset);
536void DispatchCmdCopyBuffer(
537 VkCommandBuffer commandBuffer,
538 VkBuffer srcBuffer,
539 VkBuffer dstBuffer,
540 uint32_t regionCount,
541 const VkBufferCopy* pRegions);
542void DispatchCmdCopyImage(
543 VkCommandBuffer commandBuffer,
544 VkImage srcImage,
545 VkImageLayout srcImageLayout,
546 VkImage dstImage,
547 VkImageLayout dstImageLayout,
548 uint32_t regionCount,
549 const VkImageCopy* pRegions);
550void DispatchCmdBlitImage(
551 VkCommandBuffer commandBuffer,
552 VkImage srcImage,
553 VkImageLayout srcImageLayout,
554 VkImage dstImage,
555 VkImageLayout dstImageLayout,
556 uint32_t regionCount,
557 const VkImageBlit* pRegions,
558 VkFilter filter);
559void DispatchCmdCopyBufferToImage(
560 VkCommandBuffer commandBuffer,
561 VkBuffer srcBuffer,
562 VkImage dstImage,
563 VkImageLayout dstImageLayout,
564 uint32_t regionCount,
565 const VkBufferImageCopy* pRegions);
566void DispatchCmdCopyImageToBuffer(
567 VkCommandBuffer commandBuffer,
568 VkImage srcImage,
569 VkImageLayout srcImageLayout,
570 VkBuffer dstBuffer,
571 uint32_t regionCount,
572 const VkBufferImageCopy* pRegions);
573void DispatchCmdUpdateBuffer(
574 VkCommandBuffer commandBuffer,
575 VkBuffer dstBuffer,
576 VkDeviceSize dstOffset,
577 VkDeviceSize dataSize,
578 const void* pData);
579void DispatchCmdFillBuffer(
580 VkCommandBuffer commandBuffer,
581 VkBuffer dstBuffer,
582 VkDeviceSize dstOffset,
583 VkDeviceSize size,
584 uint32_t data);
585void DispatchCmdClearColorImage(
586 VkCommandBuffer commandBuffer,
587 VkImage image,
588 VkImageLayout imageLayout,
589 const VkClearColorValue* pColor,
590 uint32_t rangeCount,
591 const VkImageSubresourceRange* pRanges);
592void DispatchCmdClearDepthStencilImage(
593 VkCommandBuffer commandBuffer,
594 VkImage image,
595 VkImageLayout imageLayout,
596 const VkClearDepthStencilValue* pDepthStencil,
597 uint32_t rangeCount,
598 const VkImageSubresourceRange* pRanges);
599void DispatchCmdClearAttachments(
600 VkCommandBuffer commandBuffer,
601 uint32_t attachmentCount,
602 const VkClearAttachment* pAttachments,
603 uint32_t rectCount,
604 const VkClearRect* pRects);
605void DispatchCmdResolveImage(
606 VkCommandBuffer commandBuffer,
607 VkImage srcImage,
608 VkImageLayout srcImageLayout,
609 VkImage dstImage,
610 VkImageLayout dstImageLayout,
611 uint32_t regionCount,
612 const VkImageResolve* pRegions);
613void DispatchCmdSetEvent(
614 VkCommandBuffer commandBuffer,
615 VkEvent event,
616 VkPipelineStageFlags stageMask);
617void DispatchCmdResetEvent(
618 VkCommandBuffer commandBuffer,
619 VkEvent event,
620 VkPipelineStageFlags stageMask);
621void DispatchCmdWaitEvents(
622 VkCommandBuffer commandBuffer,
623 uint32_t eventCount,
624 const VkEvent* pEvents,
625 VkPipelineStageFlags srcStageMask,
626 VkPipelineStageFlags dstStageMask,
627 uint32_t memoryBarrierCount,
628 const VkMemoryBarrier* pMemoryBarriers,
629 uint32_t bufferMemoryBarrierCount,
630 const VkBufferMemoryBarrier* pBufferMemoryBarriers,
631 uint32_t imageMemoryBarrierCount,
632 const VkImageMemoryBarrier* pImageMemoryBarriers);
633void DispatchCmdPipelineBarrier(
634 VkCommandBuffer commandBuffer,
635 VkPipelineStageFlags srcStageMask,
636 VkPipelineStageFlags dstStageMask,
637 VkDependencyFlags dependencyFlags,
638 uint32_t memoryBarrierCount,
639 const VkMemoryBarrier* pMemoryBarriers,
640 uint32_t bufferMemoryBarrierCount,
641 const VkBufferMemoryBarrier* pBufferMemoryBarriers,
642 uint32_t imageMemoryBarrierCount,
643 const VkImageMemoryBarrier* pImageMemoryBarriers);
644void DispatchCmdBeginQuery(
645 VkCommandBuffer commandBuffer,
646 VkQueryPool queryPool,
647 uint32_t query,
648 VkQueryControlFlags flags);
649void DispatchCmdEndQuery(
650 VkCommandBuffer commandBuffer,
651 VkQueryPool queryPool,
652 uint32_t query);
653void DispatchCmdResetQueryPool(
654 VkCommandBuffer commandBuffer,
655 VkQueryPool queryPool,
656 uint32_t firstQuery,
657 uint32_t queryCount);
658void DispatchCmdWriteTimestamp(
659 VkCommandBuffer commandBuffer,
660 VkPipelineStageFlagBits pipelineStage,
661 VkQueryPool queryPool,
662 uint32_t query);
663void DispatchCmdCopyQueryPoolResults(
664 VkCommandBuffer commandBuffer,
665 VkQueryPool queryPool,
666 uint32_t firstQuery,
667 uint32_t queryCount,
668 VkBuffer dstBuffer,
669 VkDeviceSize dstOffset,
670 VkDeviceSize stride,
671 VkQueryResultFlags flags);
672void DispatchCmdPushConstants(
673 VkCommandBuffer commandBuffer,
674 VkPipelineLayout layout,
675 VkShaderStageFlags stageFlags,
676 uint32_t offset,
677 uint32_t size,
678 const void* pValues);
679void DispatchCmdBeginRenderPass(
680 VkCommandBuffer commandBuffer,
681 const VkRenderPassBeginInfo* pRenderPassBegin,
682 VkSubpassContents contents);
683void DispatchCmdNextSubpass(
684 VkCommandBuffer commandBuffer,
685 VkSubpassContents contents);
686void DispatchCmdEndRenderPass(
687 VkCommandBuffer commandBuffer);
688void DispatchCmdExecuteCommands(
689 VkCommandBuffer commandBuffer,
690 uint32_t commandBufferCount,
691 const VkCommandBuffer* pCommandBuffers);
692VkResult DispatchEnumerateInstanceVersion(
693 uint32_t* pApiVersion);
694VkResult DispatchBindBufferMemory2(
695 VkDevice device,
696 uint32_t bindInfoCount,
697 const VkBindBufferMemoryInfo* pBindInfos);
698VkResult DispatchBindImageMemory2(
699 VkDevice device,
700 uint32_t bindInfoCount,
701 const VkBindImageMemoryInfo* pBindInfos);
702void DispatchGetDeviceGroupPeerMemoryFeatures(
703 VkDevice device,
704 uint32_t heapIndex,
705 uint32_t localDeviceIndex,
706 uint32_t remoteDeviceIndex,
707 VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
708void DispatchCmdSetDeviceMask(
709 VkCommandBuffer commandBuffer,
710 uint32_t deviceMask);
711void DispatchCmdDispatchBase(
712 VkCommandBuffer commandBuffer,
713 uint32_t baseGroupX,
714 uint32_t baseGroupY,
715 uint32_t baseGroupZ,
716 uint32_t groupCountX,
717 uint32_t groupCountY,
718 uint32_t groupCountZ);
719VkResult DispatchEnumeratePhysicalDeviceGroups(
720 VkInstance instance,
721 uint32_t* pPhysicalDeviceGroupCount,
722 VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
723void DispatchGetImageMemoryRequirements2(
724 VkDevice device,
725 const VkImageMemoryRequirementsInfo2* pInfo,
726 VkMemoryRequirements2* pMemoryRequirements);
727void DispatchGetBufferMemoryRequirements2(
728 VkDevice device,
729 const VkBufferMemoryRequirementsInfo2* pInfo,
730 VkMemoryRequirements2* pMemoryRequirements);
731void DispatchGetImageSparseMemoryRequirements2(
732 VkDevice device,
733 const VkImageSparseMemoryRequirementsInfo2* pInfo,
734 uint32_t* pSparseMemoryRequirementCount,
735 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
736void DispatchGetPhysicalDeviceFeatures2(
737 VkPhysicalDevice physicalDevice,
738 VkPhysicalDeviceFeatures2* pFeatures);
739void DispatchGetPhysicalDeviceProperties2(
740 VkPhysicalDevice physicalDevice,
741 VkPhysicalDeviceProperties2* pProperties);
742void DispatchGetPhysicalDeviceFormatProperties2(
743 VkPhysicalDevice physicalDevice,
744 VkFormat format,
745 VkFormatProperties2* pFormatProperties);
746VkResult DispatchGetPhysicalDeviceImageFormatProperties2(
747 VkPhysicalDevice physicalDevice,
748 const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
749 VkImageFormatProperties2* pImageFormatProperties);
750void DispatchGetPhysicalDeviceQueueFamilyProperties2(
751 VkPhysicalDevice physicalDevice,
752 uint32_t* pQueueFamilyPropertyCount,
753 VkQueueFamilyProperties2* pQueueFamilyProperties);
754void DispatchGetPhysicalDeviceMemoryProperties2(
755 VkPhysicalDevice physicalDevice,
756 VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
757void DispatchGetPhysicalDeviceSparseImageFormatProperties2(
758 VkPhysicalDevice physicalDevice,
759 const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
760 uint32_t* pPropertyCount,
761 VkSparseImageFormatProperties2* pProperties);
762void DispatchTrimCommandPool(
763 VkDevice device,
764 VkCommandPool commandPool,
765 VkCommandPoolTrimFlags flags);
766void DispatchGetDeviceQueue2(
767 VkDevice device,
768 const VkDeviceQueueInfo2* pQueueInfo,
769 VkQueue* pQueue);
770VkResult DispatchCreateSamplerYcbcrConversion(
771 VkDevice device,
772 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
773 const VkAllocationCallbacks* pAllocator,
774 VkSamplerYcbcrConversion* pYcbcrConversion);
775void DispatchDestroySamplerYcbcrConversion(
776 VkDevice device,
777 VkSamplerYcbcrConversion ycbcrConversion,
778 const VkAllocationCallbacks* pAllocator);
779VkResult DispatchCreateDescriptorUpdateTemplate(
780 VkDevice device,
781 const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
782 const VkAllocationCallbacks* pAllocator,
783 VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
784void DispatchDestroyDescriptorUpdateTemplate(
785 VkDevice device,
786 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
787 const VkAllocationCallbacks* pAllocator);
788void DispatchUpdateDescriptorSetWithTemplate(
789 VkDevice device,
790 VkDescriptorSet descriptorSet,
791 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
792 const void* pData);
793void DispatchGetPhysicalDeviceExternalBufferProperties(
794 VkPhysicalDevice physicalDevice,
795 const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
796 VkExternalBufferProperties* pExternalBufferProperties);
797void DispatchGetPhysicalDeviceExternalFenceProperties(
798 VkPhysicalDevice physicalDevice,
799 const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
800 VkExternalFenceProperties* pExternalFenceProperties);
801void DispatchGetPhysicalDeviceExternalSemaphoreProperties(
802 VkPhysicalDevice physicalDevice,
803 const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
804 VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
805void DispatchGetDescriptorSetLayoutSupport(
806 VkDevice device,
807 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
808 VkDescriptorSetLayoutSupport* pSupport);
809void DispatchDestroySurfaceKHR(
810 VkInstance instance,
811 VkSurfaceKHR surface,
812 const VkAllocationCallbacks* pAllocator);
813VkResult DispatchGetPhysicalDeviceSurfaceSupportKHR(
814 VkPhysicalDevice physicalDevice,
815 uint32_t queueFamilyIndex,
816 VkSurfaceKHR surface,
817 VkBool32* pSupported);
818VkResult DispatchGetPhysicalDeviceSurfaceCapabilitiesKHR(
819 VkPhysicalDevice physicalDevice,
820 VkSurfaceKHR surface,
821 VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
822VkResult DispatchGetPhysicalDeviceSurfaceFormatsKHR(
823 VkPhysicalDevice physicalDevice,
824 VkSurfaceKHR surface,
825 uint32_t* pSurfaceFormatCount,
826 VkSurfaceFormatKHR* pSurfaceFormats);
827VkResult DispatchGetPhysicalDeviceSurfacePresentModesKHR(
828 VkPhysicalDevice physicalDevice,
829 VkSurfaceKHR surface,
830 uint32_t* pPresentModeCount,
831 VkPresentModeKHR* pPresentModes);
832VkResult DispatchCreateSwapchainKHR(
833 VkDevice device,
834 const VkSwapchainCreateInfoKHR* pCreateInfo,
835 const VkAllocationCallbacks* pAllocator,
836 VkSwapchainKHR* pSwapchain);
837void DispatchDestroySwapchainKHR(
838 VkDevice device,
839 VkSwapchainKHR swapchain,
840 const VkAllocationCallbacks* pAllocator);
841VkResult DispatchGetSwapchainImagesKHR(
842 VkDevice device,
843 VkSwapchainKHR swapchain,
844 uint32_t* pSwapchainImageCount,
845 VkImage* pSwapchainImages);
846VkResult DispatchAcquireNextImageKHR(
847 VkDevice device,
848 VkSwapchainKHR swapchain,
849 uint64_t timeout,
850 VkSemaphore semaphore,
851 VkFence fence,
852 uint32_t* pImageIndex);
853VkResult DispatchQueuePresentKHR(
854 VkQueue queue,
855 const VkPresentInfoKHR* pPresentInfo);
856VkResult DispatchGetDeviceGroupPresentCapabilitiesKHR(
857 VkDevice device,
858 VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);
859VkResult DispatchGetDeviceGroupSurfacePresentModesKHR(
860 VkDevice device,
861 VkSurfaceKHR surface,
862 VkDeviceGroupPresentModeFlagsKHR* pModes);
863VkResult DispatchGetPhysicalDevicePresentRectanglesKHR(
864 VkPhysicalDevice physicalDevice,
865 VkSurfaceKHR surface,
866 uint32_t* pRectCount,
867 VkRect2D* pRects);
868VkResult DispatchAcquireNextImage2KHR(
869 VkDevice device,
870 const VkAcquireNextImageInfoKHR* pAcquireInfo,
871 uint32_t* pImageIndex);
872VkResult DispatchGetPhysicalDeviceDisplayPropertiesKHR(
873 VkPhysicalDevice physicalDevice,
874 uint32_t* pPropertyCount,
875 VkDisplayPropertiesKHR* pProperties);
876VkResult DispatchGetPhysicalDeviceDisplayPlanePropertiesKHR(
877 VkPhysicalDevice physicalDevice,
878 uint32_t* pPropertyCount,
879 VkDisplayPlanePropertiesKHR* pProperties);
880VkResult DispatchGetDisplayPlaneSupportedDisplaysKHR(
881 VkPhysicalDevice physicalDevice,
882 uint32_t planeIndex,
883 uint32_t* pDisplayCount,
884 VkDisplayKHR* pDisplays);
885VkResult DispatchGetDisplayModePropertiesKHR(
886 VkPhysicalDevice physicalDevice,
887 VkDisplayKHR display,
888 uint32_t* pPropertyCount,
889 VkDisplayModePropertiesKHR* pProperties);
890VkResult DispatchCreateDisplayModeKHR(
891 VkPhysicalDevice physicalDevice,
892 VkDisplayKHR display,
893 const VkDisplayModeCreateInfoKHR* pCreateInfo,
894 const VkAllocationCallbacks* pAllocator,
895 VkDisplayModeKHR* pMode);
896VkResult DispatchGetDisplayPlaneCapabilitiesKHR(
897 VkPhysicalDevice physicalDevice,
898 VkDisplayModeKHR mode,
899 uint32_t planeIndex,
900 VkDisplayPlaneCapabilitiesKHR* pCapabilities);
901VkResult DispatchCreateDisplayPlaneSurfaceKHR(
902 VkInstance instance,
903 const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
904 const VkAllocationCallbacks* pAllocator,
905 VkSurfaceKHR* pSurface);
906VkResult DispatchCreateSharedSwapchainsKHR(
907 VkDevice device,
908 uint32_t swapchainCount,
909 const VkSwapchainCreateInfoKHR* pCreateInfos,
910 const VkAllocationCallbacks* pAllocator,
911 VkSwapchainKHR* pSwapchains);
912#ifdef VK_USE_PLATFORM_XLIB_KHR
913VkResult DispatchCreateXlibSurfaceKHR(
914 VkInstance instance,
915 const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
916 const VkAllocationCallbacks* pAllocator,
917 VkSurfaceKHR* pSurface);
918#endif // VK_USE_PLATFORM_XLIB_KHR
919#ifdef VK_USE_PLATFORM_XLIB_KHR
920VkBool32 DispatchGetPhysicalDeviceXlibPresentationSupportKHR(
921 VkPhysicalDevice physicalDevice,
922 uint32_t queueFamilyIndex,
923 Display* dpy,
924 VisualID visualID);
925#endif // VK_USE_PLATFORM_XLIB_KHR
926#ifdef VK_USE_PLATFORM_XCB_KHR
927VkResult DispatchCreateXcbSurfaceKHR(
928 VkInstance instance,
929 const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
930 const VkAllocationCallbacks* pAllocator,
931 VkSurfaceKHR* pSurface);
932#endif // VK_USE_PLATFORM_XCB_KHR
933#ifdef VK_USE_PLATFORM_XCB_KHR
934VkBool32 DispatchGetPhysicalDeviceXcbPresentationSupportKHR(
935 VkPhysicalDevice physicalDevice,
936 uint32_t queueFamilyIndex,
937 xcb_connection_t* connection,
938 xcb_visualid_t visual_id);
939#endif // VK_USE_PLATFORM_XCB_KHR
940#ifdef VK_USE_PLATFORM_WAYLAND_KHR
941VkResult DispatchCreateWaylandSurfaceKHR(
942 VkInstance instance,
943 const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
944 const VkAllocationCallbacks* pAllocator,
945 VkSurfaceKHR* pSurface);
946#endif // VK_USE_PLATFORM_WAYLAND_KHR
947#ifdef VK_USE_PLATFORM_WAYLAND_KHR
948VkBool32 DispatchGetPhysicalDeviceWaylandPresentationSupportKHR(
949 VkPhysicalDevice physicalDevice,
950 uint32_t queueFamilyIndex,
951 struct wl_display* display);
952#endif // VK_USE_PLATFORM_WAYLAND_KHR
953#ifdef VK_USE_PLATFORM_ANDROID_KHR
954VkResult DispatchCreateAndroidSurfaceKHR(
955 VkInstance instance,
956 const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
957 const VkAllocationCallbacks* pAllocator,
958 VkSurfaceKHR* pSurface);
959#endif // VK_USE_PLATFORM_ANDROID_KHR
960#ifdef VK_USE_PLATFORM_WIN32_KHR
961VkResult DispatchCreateWin32SurfaceKHR(
962 VkInstance instance,
963 const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
964 const VkAllocationCallbacks* pAllocator,
965 VkSurfaceKHR* pSurface);
966#endif // VK_USE_PLATFORM_WIN32_KHR
967#ifdef VK_USE_PLATFORM_WIN32_KHR
968VkBool32 DispatchGetPhysicalDeviceWin32PresentationSupportKHR(
969 VkPhysicalDevice physicalDevice,
970 uint32_t queueFamilyIndex);
971#endif // VK_USE_PLATFORM_WIN32_KHR
972void DispatchGetPhysicalDeviceFeatures2KHR(
973 VkPhysicalDevice physicalDevice,
974 VkPhysicalDeviceFeatures2* pFeatures);
975void DispatchGetPhysicalDeviceProperties2KHR(
976 VkPhysicalDevice physicalDevice,
977 VkPhysicalDeviceProperties2* pProperties);
978void DispatchGetPhysicalDeviceFormatProperties2KHR(
979 VkPhysicalDevice physicalDevice,
980 VkFormat format,
981 VkFormatProperties2* pFormatProperties);
982VkResult DispatchGetPhysicalDeviceImageFormatProperties2KHR(
983 VkPhysicalDevice physicalDevice,
984 const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
985 VkImageFormatProperties2* pImageFormatProperties);
986void DispatchGetPhysicalDeviceQueueFamilyProperties2KHR(
987 VkPhysicalDevice physicalDevice,
988 uint32_t* pQueueFamilyPropertyCount,
989 VkQueueFamilyProperties2* pQueueFamilyProperties);
990void DispatchGetPhysicalDeviceMemoryProperties2KHR(
991 VkPhysicalDevice physicalDevice,
992 VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
993void DispatchGetPhysicalDeviceSparseImageFormatProperties2KHR(
994 VkPhysicalDevice physicalDevice,
995 const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
996 uint32_t* pPropertyCount,
997 VkSparseImageFormatProperties2* pProperties);
998void DispatchGetDeviceGroupPeerMemoryFeaturesKHR(
999 VkDevice device,
1000 uint32_t heapIndex,
1001 uint32_t localDeviceIndex,
1002 uint32_t remoteDeviceIndex,
1003 VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
1004void DispatchCmdSetDeviceMaskKHR(
1005 VkCommandBuffer commandBuffer,
1006 uint32_t deviceMask);
1007void DispatchCmdDispatchBaseKHR(
1008 VkCommandBuffer commandBuffer,
1009 uint32_t baseGroupX,
1010 uint32_t baseGroupY,
1011 uint32_t baseGroupZ,
1012 uint32_t groupCountX,
1013 uint32_t groupCountY,
1014 uint32_t groupCountZ);
1015void DispatchTrimCommandPoolKHR(
1016 VkDevice device,
1017 VkCommandPool commandPool,
1018 VkCommandPoolTrimFlags flags);
1019VkResult DispatchEnumeratePhysicalDeviceGroupsKHR(
1020 VkInstance instance,
1021 uint32_t* pPhysicalDeviceGroupCount,
1022 VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
1023void DispatchGetPhysicalDeviceExternalBufferPropertiesKHR(
1024 VkPhysicalDevice physicalDevice,
1025 const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
1026 VkExternalBufferProperties* pExternalBufferProperties);
1027#ifdef VK_USE_PLATFORM_WIN32_KHR
1028VkResult DispatchGetMemoryWin32HandleKHR(
1029 VkDevice device,
1030 const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
1031 HANDLE* pHandle);
1032#endif // VK_USE_PLATFORM_WIN32_KHR
1033#ifdef VK_USE_PLATFORM_WIN32_KHR
1034VkResult DispatchGetMemoryWin32HandlePropertiesKHR(
1035 VkDevice device,
1036 VkExternalMemoryHandleTypeFlagBits handleType,
1037 HANDLE handle,
1038 VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
1039#endif // VK_USE_PLATFORM_WIN32_KHR
1040VkResult DispatchGetMemoryFdKHR(
1041 VkDevice device,
1042 const VkMemoryGetFdInfoKHR* pGetFdInfo,
1043 int* pFd);
1044VkResult DispatchGetMemoryFdPropertiesKHR(
1045 VkDevice device,
1046 VkExternalMemoryHandleTypeFlagBits handleType,
1047 int fd,
1048 VkMemoryFdPropertiesKHR* pMemoryFdProperties);
1049void DispatchGetPhysicalDeviceExternalSemaphorePropertiesKHR(
1050 VkPhysicalDevice physicalDevice,
1051 const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
1052 VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
1053#ifdef VK_USE_PLATFORM_WIN32_KHR
1054VkResult DispatchImportSemaphoreWin32HandleKHR(
1055 VkDevice device,
1056 const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
1057#endif // VK_USE_PLATFORM_WIN32_KHR
1058#ifdef VK_USE_PLATFORM_WIN32_KHR
1059VkResult DispatchGetSemaphoreWin32HandleKHR(
1060 VkDevice device,
1061 const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
1062 HANDLE* pHandle);
1063#endif // VK_USE_PLATFORM_WIN32_KHR
1064VkResult DispatchImportSemaphoreFdKHR(
1065 VkDevice device,
1066 const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
1067VkResult DispatchGetSemaphoreFdKHR(
1068 VkDevice device,
1069 const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
1070 int* pFd);
1071void DispatchCmdPushDescriptorSetKHR(
1072 VkCommandBuffer commandBuffer,
1073 VkPipelineBindPoint pipelineBindPoint,
1074 VkPipelineLayout layout,
1075 uint32_t set,
1076 uint32_t descriptorWriteCount,
1077 const VkWriteDescriptorSet* pDescriptorWrites);
1078void DispatchCmdPushDescriptorSetWithTemplateKHR(
1079 VkCommandBuffer commandBuffer,
1080 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
1081 VkPipelineLayout layout,
1082 uint32_t set,
1083 const void* pData);
1084VkResult DispatchCreateDescriptorUpdateTemplateKHR(
1085 VkDevice device,
1086 const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
1087 const VkAllocationCallbacks* pAllocator,
1088 VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
1089void DispatchDestroyDescriptorUpdateTemplateKHR(
1090 VkDevice device,
1091 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
1092 const VkAllocationCallbacks* pAllocator);
1093void DispatchUpdateDescriptorSetWithTemplateKHR(
1094 VkDevice device,
1095 VkDescriptorSet descriptorSet,
1096 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
1097 const void* pData);
1098VkResult DispatchCreateRenderPass2KHR(
1099 VkDevice device,
1100 const VkRenderPassCreateInfo2KHR* pCreateInfo,
1101 const VkAllocationCallbacks* pAllocator,
1102 VkRenderPass* pRenderPass);
1103void DispatchCmdBeginRenderPass2KHR(
1104 VkCommandBuffer commandBuffer,
1105 const VkRenderPassBeginInfo* pRenderPassBegin,
1106 const VkSubpassBeginInfoKHR* pSubpassBeginInfo);
1107void DispatchCmdNextSubpass2KHR(
1108 VkCommandBuffer commandBuffer,
1109 const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
1110 const VkSubpassEndInfoKHR* pSubpassEndInfo);
1111void DispatchCmdEndRenderPass2KHR(
1112 VkCommandBuffer commandBuffer,
1113 const VkSubpassEndInfoKHR* pSubpassEndInfo);
1114VkResult DispatchGetSwapchainStatusKHR(
1115 VkDevice device,
1116 VkSwapchainKHR swapchain);
1117void DispatchGetPhysicalDeviceExternalFencePropertiesKHR(
1118 VkPhysicalDevice physicalDevice,
1119 const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
1120 VkExternalFenceProperties* pExternalFenceProperties);
1121#ifdef VK_USE_PLATFORM_WIN32_KHR
1122VkResult DispatchImportFenceWin32HandleKHR(
1123 VkDevice device,
1124 const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
1125#endif // VK_USE_PLATFORM_WIN32_KHR
1126#ifdef VK_USE_PLATFORM_WIN32_KHR
1127VkResult DispatchGetFenceWin32HandleKHR(
1128 VkDevice device,
1129 const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
1130 HANDLE* pHandle);
1131#endif // VK_USE_PLATFORM_WIN32_KHR
1132VkResult DispatchImportFenceFdKHR(
1133 VkDevice device,
1134 const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
1135VkResult DispatchGetFenceFdKHR(
1136 VkDevice device,
1137 const VkFenceGetFdInfoKHR* pGetFdInfo,
1138 int* pFd);
1139VkResult DispatchGetPhysicalDeviceSurfaceCapabilities2KHR(
1140 VkPhysicalDevice physicalDevice,
1141 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
1142 VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
1143VkResult DispatchGetPhysicalDeviceSurfaceFormats2KHR(
1144 VkPhysicalDevice physicalDevice,
1145 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
1146 uint32_t* pSurfaceFormatCount,
1147 VkSurfaceFormat2KHR* pSurfaceFormats);
1148VkResult DispatchGetPhysicalDeviceDisplayProperties2KHR(
1149 VkPhysicalDevice physicalDevice,
1150 uint32_t* pPropertyCount,
1151 VkDisplayProperties2KHR* pProperties);
1152VkResult DispatchGetPhysicalDeviceDisplayPlaneProperties2KHR(
1153 VkPhysicalDevice physicalDevice,
1154 uint32_t* pPropertyCount,
1155 VkDisplayPlaneProperties2KHR* pProperties);
1156VkResult DispatchGetDisplayModeProperties2KHR(
1157 VkPhysicalDevice physicalDevice,
1158 VkDisplayKHR display,
1159 uint32_t* pPropertyCount,
1160 VkDisplayModeProperties2KHR* pProperties);
1161VkResult DispatchGetDisplayPlaneCapabilities2KHR(
1162 VkPhysicalDevice physicalDevice,
1163 const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
1164 VkDisplayPlaneCapabilities2KHR* pCapabilities);
1165void DispatchGetImageMemoryRequirements2KHR(
1166 VkDevice device,
1167 const VkImageMemoryRequirementsInfo2* pInfo,
1168 VkMemoryRequirements2* pMemoryRequirements);
1169void DispatchGetBufferMemoryRequirements2KHR(
1170 VkDevice device,
1171 const VkBufferMemoryRequirementsInfo2* pInfo,
1172 VkMemoryRequirements2* pMemoryRequirements);
1173void DispatchGetImageSparseMemoryRequirements2KHR(
1174 VkDevice device,
1175 const VkImageSparseMemoryRequirementsInfo2* pInfo,
1176 uint32_t* pSparseMemoryRequirementCount,
1177 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
1178VkResult DispatchCreateSamplerYcbcrConversionKHR(
1179 VkDevice device,
1180 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
1181 const VkAllocationCallbacks* pAllocator,
1182 VkSamplerYcbcrConversion* pYcbcrConversion);
1183void DispatchDestroySamplerYcbcrConversionKHR(
1184 VkDevice device,
1185 VkSamplerYcbcrConversion ycbcrConversion,
1186 const VkAllocationCallbacks* pAllocator);
1187VkResult DispatchBindBufferMemory2KHR(
1188 VkDevice device,
1189 uint32_t bindInfoCount,
1190 const VkBindBufferMemoryInfo* pBindInfos);
1191VkResult DispatchBindImageMemory2KHR(
1192 VkDevice device,
1193 uint32_t bindInfoCount,
1194 const VkBindImageMemoryInfo* pBindInfos);
1195void DispatchGetDescriptorSetLayoutSupportKHR(
1196 VkDevice device,
1197 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
1198 VkDescriptorSetLayoutSupport* pSupport);
1199void DispatchCmdDrawIndirectCountKHR(
1200 VkCommandBuffer commandBuffer,
1201 VkBuffer buffer,
1202 VkDeviceSize offset,
1203 VkBuffer countBuffer,
1204 VkDeviceSize countBufferOffset,
1205 uint32_t maxDrawCount,
1206 uint32_t stride);
1207void DispatchCmdDrawIndexedIndirectCountKHR(
1208 VkCommandBuffer commandBuffer,
1209 VkBuffer buffer,
1210 VkDeviceSize offset,
1211 VkBuffer countBuffer,
1212 VkDeviceSize countBufferOffset,
1213 uint32_t maxDrawCount,
1214 uint32_t stride);
1215VkResult DispatchCreateDebugReportCallbackEXT(
1216 VkInstance instance,
1217 const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
1218 const VkAllocationCallbacks* pAllocator,
1219 VkDebugReportCallbackEXT* pCallback);
1220void DispatchDestroyDebugReportCallbackEXT(
1221 VkInstance instance,
1222 VkDebugReportCallbackEXT callback,
1223 const VkAllocationCallbacks* pAllocator);
1224void DispatchDebugReportMessageEXT(
1225 VkInstance instance,
1226 VkDebugReportFlagsEXT flags,
1227 VkDebugReportObjectTypeEXT objectType,
1228 uint64_t object,
1229 size_t location,
1230 int32_t messageCode,
1231 const char* pLayerPrefix,
1232 const char* pMessage);
1233VkResult DispatchDebugMarkerSetObjectTagEXT(
1234 VkDevice device,
1235 const VkDebugMarkerObjectTagInfoEXT* pTagInfo);
1236VkResult DispatchDebugMarkerSetObjectNameEXT(
1237 VkDevice device,
1238 const VkDebugMarkerObjectNameInfoEXT* pNameInfo);
1239void DispatchCmdDebugMarkerBeginEXT(
1240 VkCommandBuffer commandBuffer,
1241 const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
1242void DispatchCmdDebugMarkerEndEXT(
1243 VkCommandBuffer commandBuffer);
1244void DispatchCmdDebugMarkerInsertEXT(
1245 VkCommandBuffer commandBuffer,
1246 const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
1247void DispatchCmdBindTransformFeedbackBuffersEXT(
1248 VkCommandBuffer commandBuffer,
1249 uint32_t firstBinding,
1250 uint32_t bindingCount,
1251 const VkBuffer* pBuffers,
1252 const VkDeviceSize* pOffsets,
1253 const VkDeviceSize* pSizes);
1254void DispatchCmdBeginTransformFeedbackEXT(
1255 VkCommandBuffer commandBuffer,
1256 uint32_t firstCounterBuffer,
1257 uint32_t counterBufferCount,
1258 const VkBuffer* pCounterBuffers,
1259 const VkDeviceSize* pCounterBufferOffsets);
1260void DispatchCmdEndTransformFeedbackEXT(
1261 VkCommandBuffer commandBuffer,
1262 uint32_t firstCounterBuffer,
1263 uint32_t counterBufferCount,
1264 const VkBuffer* pCounterBuffers,
1265 const VkDeviceSize* pCounterBufferOffsets);
1266void DispatchCmdBeginQueryIndexedEXT(
1267 VkCommandBuffer commandBuffer,
1268 VkQueryPool queryPool,
1269 uint32_t query,
1270 VkQueryControlFlags flags,
1271 uint32_t index);
1272void DispatchCmdEndQueryIndexedEXT(
1273 VkCommandBuffer commandBuffer,
1274 VkQueryPool queryPool,
1275 uint32_t query,
1276 uint32_t index);
1277void DispatchCmdDrawIndirectByteCountEXT(
1278 VkCommandBuffer commandBuffer,
1279 uint32_t instanceCount,
1280 uint32_t firstInstance,
1281 VkBuffer counterBuffer,
1282 VkDeviceSize counterBufferOffset,
1283 uint32_t counterOffset,
1284 uint32_t vertexStride);
1285uint32_t DispatchGetImageViewHandleNVX(
1286 VkDevice device,
1287 const VkImageViewHandleInfoNVX* pInfo);
1288void DispatchCmdDrawIndirectCountAMD(
1289 VkCommandBuffer commandBuffer,
1290 VkBuffer buffer,
1291 VkDeviceSize offset,
1292 VkBuffer countBuffer,
1293 VkDeviceSize countBufferOffset,
1294 uint32_t maxDrawCount,
1295 uint32_t stride);
1296void DispatchCmdDrawIndexedIndirectCountAMD(
1297 VkCommandBuffer commandBuffer,
1298 VkBuffer buffer,
1299 VkDeviceSize offset,
1300 VkBuffer countBuffer,
1301 VkDeviceSize countBufferOffset,
1302 uint32_t maxDrawCount,
1303 uint32_t stride);
1304VkResult DispatchGetShaderInfoAMD(
1305 VkDevice device,
1306 VkPipeline pipeline,
1307 VkShaderStageFlagBits shaderStage,
1308 VkShaderInfoTypeAMD infoType,
1309 size_t* pInfoSize,
1310 void* pInfo);
1311#ifdef VK_USE_PLATFORM_GGP
1312VkResult DispatchCreateStreamDescriptorSurfaceGGP(
1313 VkInstance instance,
1314 const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
1315 const VkAllocationCallbacks* pAllocator,
1316 VkSurfaceKHR* pSurface);
1317#endif // VK_USE_PLATFORM_GGP
1318VkResult DispatchGetPhysicalDeviceExternalImageFormatPropertiesNV(
1319 VkPhysicalDevice physicalDevice,
1320 VkFormat format,
1321 VkImageType type,
1322 VkImageTiling tiling,
1323 VkImageUsageFlags usage,
1324 VkImageCreateFlags flags,
1325 VkExternalMemoryHandleTypeFlagsNV externalHandleType,
1326 VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
1327#ifdef VK_USE_PLATFORM_WIN32_KHR
1328VkResult DispatchGetMemoryWin32HandleNV(
1329 VkDevice device,
1330 VkDeviceMemory memory,
1331 VkExternalMemoryHandleTypeFlagsNV handleType,
1332 HANDLE* pHandle);
1333#endif // VK_USE_PLATFORM_WIN32_KHR
1334#ifdef VK_USE_PLATFORM_VI_NN
1335VkResult DispatchCreateViSurfaceNN(
1336 VkInstance instance,
1337 const VkViSurfaceCreateInfoNN* pCreateInfo,
1338 const VkAllocationCallbacks* pAllocator,
1339 VkSurfaceKHR* pSurface);
1340#endif // VK_USE_PLATFORM_VI_NN
1341void DispatchCmdBeginConditionalRenderingEXT(
1342 VkCommandBuffer commandBuffer,
1343 const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
1344void DispatchCmdEndConditionalRenderingEXT(
1345 VkCommandBuffer commandBuffer);
1346void DispatchCmdProcessCommandsNVX(
1347 VkCommandBuffer commandBuffer,
1348 const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
1349void DispatchCmdReserveSpaceForCommandsNVX(
1350 VkCommandBuffer commandBuffer,
1351 const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
1352VkResult DispatchCreateIndirectCommandsLayoutNVX(
1353 VkDevice device,
1354 const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
1355 const VkAllocationCallbacks* pAllocator,
1356 VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
1357void DispatchDestroyIndirectCommandsLayoutNVX(
1358 VkDevice device,
1359 VkIndirectCommandsLayoutNVX indirectCommandsLayout,
1360 const VkAllocationCallbacks* pAllocator);
1361VkResult DispatchCreateObjectTableNVX(
1362 VkDevice device,
1363 const VkObjectTableCreateInfoNVX* pCreateInfo,
1364 const VkAllocationCallbacks* pAllocator,
1365 VkObjectTableNVX* pObjectTable);
1366void DispatchDestroyObjectTableNVX(
1367 VkDevice device,
1368 VkObjectTableNVX objectTable,
1369 const VkAllocationCallbacks* pAllocator);
1370VkResult DispatchRegisterObjectsNVX(
1371 VkDevice device,
1372 VkObjectTableNVX objectTable,
1373 uint32_t objectCount,
1374 const VkObjectTableEntryNVX* const* ppObjectTableEntries,
1375 const uint32_t* pObjectIndices);
1376VkResult DispatchUnregisterObjectsNVX(
1377 VkDevice device,
1378 VkObjectTableNVX objectTable,
1379 uint32_t objectCount,
1380 const VkObjectEntryTypeNVX* pObjectEntryTypes,
1381 const uint32_t* pObjectIndices);
1382void DispatchGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
1383 VkPhysicalDevice physicalDevice,
1384 VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
1385 VkDeviceGeneratedCommandsLimitsNVX* pLimits);
1386void DispatchCmdSetViewportWScalingNV(
1387 VkCommandBuffer commandBuffer,
1388 uint32_t firstViewport,
1389 uint32_t viewportCount,
1390 const VkViewportWScalingNV* pViewportWScalings);
1391VkResult DispatchReleaseDisplayEXT(
1392 VkPhysicalDevice physicalDevice,
1393 VkDisplayKHR display);
1394#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
1395VkResult DispatchAcquireXlibDisplayEXT(
1396 VkPhysicalDevice physicalDevice,
1397 Display* dpy,
1398 VkDisplayKHR display);
1399#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
1400#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
1401VkResult DispatchGetRandROutputDisplayEXT(
1402 VkPhysicalDevice physicalDevice,
1403 Display* dpy,
1404 RROutput rrOutput,
1405 VkDisplayKHR* pDisplay);
1406#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
1407VkResult DispatchGetPhysicalDeviceSurfaceCapabilities2EXT(
1408 VkPhysicalDevice physicalDevice,
1409 VkSurfaceKHR surface,
1410 VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
1411VkResult DispatchDisplayPowerControlEXT(
1412 VkDevice device,
1413 VkDisplayKHR display,
1414 const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
1415VkResult DispatchRegisterDeviceEventEXT(
1416 VkDevice device,
1417 const VkDeviceEventInfoEXT* pDeviceEventInfo,
1418 const VkAllocationCallbacks* pAllocator,
1419 VkFence* pFence);
1420VkResult DispatchRegisterDisplayEventEXT(
1421 VkDevice device,
1422 VkDisplayKHR display,
1423 const VkDisplayEventInfoEXT* pDisplayEventInfo,
1424 const VkAllocationCallbacks* pAllocator,
1425 VkFence* pFence);
1426VkResult DispatchGetSwapchainCounterEXT(
1427 VkDevice device,
1428 VkSwapchainKHR swapchain,
1429 VkSurfaceCounterFlagBitsEXT counter,
1430 uint64_t* pCounterValue);
1431VkResult DispatchGetRefreshCycleDurationGOOGLE(
1432 VkDevice device,
1433 VkSwapchainKHR swapchain,
1434 VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
1435VkResult DispatchGetPastPresentationTimingGOOGLE(
1436 VkDevice device,
1437 VkSwapchainKHR swapchain,
1438 uint32_t* pPresentationTimingCount,
1439 VkPastPresentationTimingGOOGLE* pPresentationTimings);
1440void DispatchCmdSetDiscardRectangleEXT(
1441 VkCommandBuffer commandBuffer,
1442 uint32_t firstDiscardRectangle,
1443 uint32_t discardRectangleCount,
1444 const VkRect2D* pDiscardRectangles);
1445void DispatchSetHdrMetadataEXT(
1446 VkDevice device,
1447 uint32_t swapchainCount,
1448 const VkSwapchainKHR* pSwapchains,
1449 const VkHdrMetadataEXT* pMetadata);
1450#ifdef VK_USE_PLATFORM_IOS_MVK
1451VkResult DispatchCreateIOSSurfaceMVK(
1452 VkInstance instance,
1453 const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
1454 const VkAllocationCallbacks* pAllocator,
1455 VkSurfaceKHR* pSurface);
1456#endif // VK_USE_PLATFORM_IOS_MVK
1457#ifdef VK_USE_PLATFORM_MACOS_MVK
1458VkResult DispatchCreateMacOSSurfaceMVK(
1459 VkInstance instance,
1460 const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
1461 const VkAllocationCallbacks* pAllocator,
1462 VkSurfaceKHR* pSurface);
1463#endif // VK_USE_PLATFORM_MACOS_MVK
1464VkResult DispatchSetDebugUtilsObjectNameEXT(
1465 VkDevice device,
1466 const VkDebugUtilsObjectNameInfoEXT* pNameInfo);
1467VkResult DispatchSetDebugUtilsObjectTagEXT(
1468 VkDevice device,
1469 const VkDebugUtilsObjectTagInfoEXT* pTagInfo);
1470void DispatchQueueBeginDebugUtilsLabelEXT(
1471 VkQueue queue,
1472 const VkDebugUtilsLabelEXT* pLabelInfo);
1473void DispatchQueueEndDebugUtilsLabelEXT(
1474 VkQueue queue);
1475void DispatchQueueInsertDebugUtilsLabelEXT(
1476 VkQueue queue,
1477 const VkDebugUtilsLabelEXT* pLabelInfo);
1478void DispatchCmdBeginDebugUtilsLabelEXT(
1479 VkCommandBuffer commandBuffer,
1480 const VkDebugUtilsLabelEXT* pLabelInfo);
1481void DispatchCmdEndDebugUtilsLabelEXT(
1482 VkCommandBuffer commandBuffer);
1483void DispatchCmdInsertDebugUtilsLabelEXT(
1484 VkCommandBuffer commandBuffer,
1485 const VkDebugUtilsLabelEXT* pLabelInfo);
1486VkResult DispatchCreateDebugUtilsMessengerEXT(
1487 VkInstance instance,
1488 const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
1489 const VkAllocationCallbacks* pAllocator,
1490 VkDebugUtilsMessengerEXT* pMessenger);
1491void DispatchDestroyDebugUtilsMessengerEXT(
1492 VkInstance instance,
1493 VkDebugUtilsMessengerEXT messenger,
1494 const VkAllocationCallbacks* pAllocator);
1495void DispatchSubmitDebugUtilsMessageEXT(
1496 VkInstance instance,
1497 VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
1498 VkDebugUtilsMessageTypeFlagsEXT messageTypes,
1499 const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
1500#ifdef VK_USE_PLATFORM_ANDROID_KHR
1501VkResult DispatchGetAndroidHardwareBufferPropertiesANDROID(
1502 VkDevice device,
1503 const struct AHardwareBuffer* buffer,
1504 VkAndroidHardwareBufferPropertiesANDROID* pProperties);
1505#endif // VK_USE_PLATFORM_ANDROID_KHR
1506#ifdef VK_USE_PLATFORM_ANDROID_KHR
1507VkResult DispatchGetMemoryAndroidHardwareBufferANDROID(
1508 VkDevice device,
1509 const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
1510 struct AHardwareBuffer** pBuffer);
1511#endif // VK_USE_PLATFORM_ANDROID_KHR
1512void DispatchCmdSetSampleLocationsEXT(
1513 VkCommandBuffer commandBuffer,
1514 const VkSampleLocationsInfoEXT* pSampleLocationsInfo);
1515void DispatchGetPhysicalDeviceMultisamplePropertiesEXT(
1516 VkPhysicalDevice physicalDevice,
1517 VkSampleCountFlagBits samples,
1518 VkMultisamplePropertiesEXT* pMultisampleProperties);
1519VkResult DispatchGetImageDrmFormatModifierPropertiesEXT(
1520 VkDevice device,
1521 VkImage image,
1522 VkImageDrmFormatModifierPropertiesEXT* pProperties);
1523VkResult DispatchCreateValidationCacheEXT(
1524 VkDevice device,
1525 const VkValidationCacheCreateInfoEXT* pCreateInfo,
1526 const VkAllocationCallbacks* pAllocator,
1527 VkValidationCacheEXT* pValidationCache);
1528void DispatchDestroyValidationCacheEXT(
1529 VkDevice device,
1530 VkValidationCacheEXT validationCache,
1531 const VkAllocationCallbacks* pAllocator);
1532VkResult DispatchMergeValidationCachesEXT(
1533 VkDevice device,
1534 VkValidationCacheEXT dstCache,
1535 uint32_t srcCacheCount,
1536 const VkValidationCacheEXT* pSrcCaches);
1537VkResult DispatchGetValidationCacheDataEXT(
1538 VkDevice device,
1539 VkValidationCacheEXT validationCache,
1540 size_t* pDataSize,
1541 void* pData);
1542void DispatchCmdBindShadingRateImageNV(
1543 VkCommandBuffer commandBuffer,
1544 VkImageView imageView,
1545 VkImageLayout imageLayout);
1546void DispatchCmdSetViewportShadingRatePaletteNV(
1547 VkCommandBuffer commandBuffer,
1548 uint32_t firstViewport,
1549 uint32_t viewportCount,
1550 const VkShadingRatePaletteNV* pShadingRatePalettes);
1551void DispatchCmdSetCoarseSampleOrderNV(
1552 VkCommandBuffer commandBuffer,
1553 VkCoarseSampleOrderTypeNV sampleOrderType,
1554 uint32_t customSampleOrderCount,
1555 const VkCoarseSampleOrderCustomNV* pCustomSampleOrders);
1556VkResult DispatchCreateAccelerationStructureNV(
1557 VkDevice device,
1558 const VkAccelerationStructureCreateInfoNV* pCreateInfo,
1559 const VkAllocationCallbacks* pAllocator,
1560 VkAccelerationStructureNV* pAccelerationStructure);
1561void DispatchDestroyAccelerationStructureNV(
1562 VkDevice device,
1563 VkAccelerationStructureNV accelerationStructure,
1564 const VkAllocationCallbacks* pAllocator);
1565void DispatchGetAccelerationStructureMemoryRequirementsNV(
1566 VkDevice device,
1567 const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
1568 VkMemoryRequirements2KHR* pMemoryRequirements);
1569VkResult DispatchBindAccelerationStructureMemoryNV(
1570 VkDevice device,
1571 uint32_t bindInfoCount,
1572 const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);
1573void DispatchCmdBuildAccelerationStructureNV(
1574 VkCommandBuffer commandBuffer,
1575 const VkAccelerationStructureInfoNV* pInfo,
1576 VkBuffer instanceData,
1577 VkDeviceSize instanceOffset,
1578 VkBool32 update,
1579 VkAccelerationStructureNV dst,
1580 VkAccelerationStructureNV src,
1581 VkBuffer scratch,
1582 VkDeviceSize scratchOffset);
1583void DispatchCmdCopyAccelerationStructureNV(
1584 VkCommandBuffer commandBuffer,
1585 VkAccelerationStructureNV dst,
1586 VkAccelerationStructureNV src,
1587 VkCopyAccelerationStructureModeNV mode);
1588void DispatchCmdTraceRaysNV(
1589 VkCommandBuffer commandBuffer,
1590 VkBuffer raygenShaderBindingTableBuffer,
1591 VkDeviceSize raygenShaderBindingOffset,
1592 VkBuffer missShaderBindingTableBuffer,
1593 VkDeviceSize missShaderBindingOffset,
1594 VkDeviceSize missShaderBindingStride,
1595 VkBuffer hitShaderBindingTableBuffer,
1596 VkDeviceSize hitShaderBindingOffset,
1597 VkDeviceSize hitShaderBindingStride,
1598 VkBuffer callableShaderBindingTableBuffer,
1599 VkDeviceSize callableShaderBindingOffset,
1600 VkDeviceSize callableShaderBindingStride,
1601 uint32_t width,
1602 uint32_t height,
1603 uint32_t depth);
1604VkResult DispatchCreateRayTracingPipelinesNV(
1605 VkDevice device,
1606 VkPipelineCache pipelineCache,
1607 uint32_t createInfoCount,
1608 const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
1609 const VkAllocationCallbacks* pAllocator,
1610 VkPipeline* pPipelines);
1611VkResult DispatchGetRayTracingShaderGroupHandlesNV(
1612 VkDevice device,
1613 VkPipeline pipeline,
1614 uint32_t firstGroup,
1615 uint32_t groupCount,
1616 size_t dataSize,
1617 void* pData);
1618VkResult DispatchGetAccelerationStructureHandleNV(
1619 VkDevice device,
1620 VkAccelerationStructureNV accelerationStructure,
1621 size_t dataSize,
1622 void* pData);
1623void DispatchCmdWriteAccelerationStructuresPropertiesNV(
1624 VkCommandBuffer commandBuffer,
1625 uint32_t accelerationStructureCount,
1626 const VkAccelerationStructureNV* pAccelerationStructures,
1627 VkQueryType queryType,
1628 VkQueryPool queryPool,
1629 uint32_t firstQuery);
1630VkResult DispatchCompileDeferredNV(
1631 VkDevice device,
1632 VkPipeline pipeline,
1633 uint32_t shader);
1634VkResult DispatchGetMemoryHostPointerPropertiesEXT(
1635 VkDevice device,
1636 VkExternalMemoryHandleTypeFlagBits handleType,
1637 const void* pHostPointer,
1638 VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);
1639void DispatchCmdWriteBufferMarkerAMD(
1640 VkCommandBuffer commandBuffer,
1641 VkPipelineStageFlagBits pipelineStage,
1642 VkBuffer dstBuffer,
1643 VkDeviceSize dstOffset,
1644 uint32_t marker);
1645VkResult DispatchGetPhysicalDeviceCalibrateableTimeDomainsEXT(
1646 VkPhysicalDevice physicalDevice,
1647 uint32_t* pTimeDomainCount,
1648 VkTimeDomainEXT* pTimeDomains);
1649VkResult DispatchGetCalibratedTimestampsEXT(
1650 VkDevice device,
1651 uint32_t timestampCount,
1652 const VkCalibratedTimestampInfoEXT* pTimestampInfos,
1653 uint64_t* pTimestamps,
1654 uint64_t* pMaxDeviation);
1655void DispatchCmdDrawMeshTasksNV(
1656 VkCommandBuffer commandBuffer,
1657 uint32_t taskCount,
1658 uint32_t firstTask);
1659void DispatchCmdDrawMeshTasksIndirectNV(
1660 VkCommandBuffer commandBuffer,
1661 VkBuffer buffer,
1662 VkDeviceSize offset,
1663 uint32_t drawCount,
1664 uint32_t stride);
1665void DispatchCmdDrawMeshTasksIndirectCountNV(
1666 VkCommandBuffer commandBuffer,
1667 VkBuffer buffer,
1668 VkDeviceSize offset,
1669 VkBuffer countBuffer,
1670 VkDeviceSize countBufferOffset,
1671 uint32_t maxDrawCount,
1672 uint32_t stride);
1673void DispatchCmdSetExclusiveScissorNV(
1674 VkCommandBuffer commandBuffer,
1675 uint32_t firstExclusiveScissor,
1676 uint32_t exclusiveScissorCount,
1677 const VkRect2D* pExclusiveScissors);
1678void DispatchCmdSetCheckpointNV(
1679 VkCommandBuffer commandBuffer,
1680 const void* pCheckpointMarker);
1681void DispatchGetQueueCheckpointDataNV(
1682 VkQueue queue,
1683 uint32_t* pCheckpointDataCount,
1684 VkCheckpointDataNV* pCheckpointData);
1685VkResult DispatchInitializePerformanceApiINTEL(
1686 VkDevice device,
1687 const VkInitializePerformanceApiInfoINTEL* pInitializeInfo);
1688void DispatchUninitializePerformanceApiINTEL(
1689 VkDevice device);
1690VkResult DispatchCmdSetPerformanceMarkerINTEL(
1691 VkCommandBuffer commandBuffer,
1692 const VkPerformanceMarkerInfoINTEL* pMarkerInfo);
1693VkResult DispatchCmdSetPerformanceStreamMarkerINTEL(
1694 VkCommandBuffer commandBuffer,
1695 const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo);
1696VkResult DispatchCmdSetPerformanceOverrideINTEL(
1697 VkCommandBuffer commandBuffer,
1698 const VkPerformanceOverrideInfoINTEL* pOverrideInfo);
1699VkResult DispatchAcquirePerformanceConfigurationINTEL(
1700 VkDevice device,
1701 const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
1702 VkPerformanceConfigurationINTEL* pConfiguration);
1703VkResult DispatchReleasePerformanceConfigurationINTEL(
1704 VkDevice device,
1705 VkPerformanceConfigurationINTEL configuration);
1706VkResult DispatchQueueSetPerformanceConfigurationINTEL(
1707 VkQueue queue,
1708 VkPerformanceConfigurationINTEL configuration);
1709VkResult DispatchGetPerformanceParameterINTEL(
1710 VkDevice device,
1711 VkPerformanceParameterTypeINTEL parameter,
1712 VkPerformanceValueINTEL* pValue);
1713void DispatchSetLocalDimmingAMD(
1714 VkDevice device,
1715 VkSwapchainKHR swapChain,
1716 VkBool32 localDimmingEnable);
1717#ifdef VK_USE_PLATFORM_FUCHSIA
1718VkResult DispatchCreateImagePipeSurfaceFUCHSIA(
1719 VkInstance instance,
1720 const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
1721 const VkAllocationCallbacks* pAllocator,
1722 VkSurfaceKHR* pSurface);
1723#endif // VK_USE_PLATFORM_FUCHSIA
1724#ifdef VK_USE_PLATFORM_METAL_EXT
1725VkResult DispatchCreateMetalSurfaceEXT(
1726 VkInstance instance,
1727 const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
1728 const VkAllocationCallbacks* pAllocator,
1729 VkSurfaceKHR* pSurface);
1730#endif // VK_USE_PLATFORM_METAL_EXT
1731VkDeviceAddress DispatchGetBufferDeviceAddressEXT(
1732 VkDevice device,
1733 const VkBufferDeviceAddressInfoEXT* pInfo);
1734VkResult DispatchGetPhysicalDeviceCooperativeMatrixPropertiesNV(
1735 VkPhysicalDevice physicalDevice,
1736 uint32_t* pPropertyCount,
1737 VkCooperativeMatrixPropertiesNV* pProperties);
1738VkResult DispatchGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
1739 VkPhysicalDevice physicalDevice,
1740 uint32_t* pCombinationCount,
1741 VkFramebufferMixedSamplesCombinationNV* pCombinations);
1742#ifdef VK_USE_PLATFORM_WIN32_KHR
1743VkResult DispatchGetPhysicalDeviceSurfacePresentModes2EXT(
1744 VkPhysicalDevice physicalDevice,
1745 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
1746 uint32_t* pPresentModeCount,
1747 VkPresentModeKHR* pPresentModes);
1748#endif // VK_USE_PLATFORM_WIN32_KHR
1749#ifdef VK_USE_PLATFORM_WIN32_KHR
1750VkResult DispatchAcquireFullScreenExclusiveModeEXT(
1751 VkDevice device,
1752 VkSwapchainKHR swapchain);
1753#endif // VK_USE_PLATFORM_WIN32_KHR
1754#ifdef VK_USE_PLATFORM_WIN32_KHR
1755VkResult DispatchReleaseFullScreenExclusiveModeEXT(
1756 VkDevice device,
1757 VkSwapchainKHR swapchain);
1758#endif // VK_USE_PLATFORM_WIN32_KHR
1759#ifdef VK_USE_PLATFORM_WIN32_KHR
1760VkResult DispatchGetDeviceGroupSurfacePresentModes2EXT(
1761 VkDevice device,
1762 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
1763 VkDeviceGroupPresentModeFlagsKHR* pModes);
1764#endif // VK_USE_PLATFORM_WIN32_KHR
1765VkResult DispatchCreateHeadlessSurfaceEXT(
1766 VkInstance instance,
1767 const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
1768 const VkAllocationCallbacks* pAllocator,
1769 VkSurfaceKHR* pSurface);
1770void DispatchResetQueryPoolEXT(
1771 VkDevice device,
1772 VkQueryPool queryPool,
1773 uint32_t firstQuery,
1774 uint32_t queryCount);