Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / vulkan-validation-layers / 3cc90bcf8cfef52366a93c62d66ec8eef09b7059 / . / layers / generated / layer_chassis_dispatch.h
blob: 2d46649313c5fae44ca69c1551a15cb56754c0dd [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);
Shannon McPherson3cc90bc2019-08-13 11:28:22 -0600[diff] [blame^]1215VkResult DispatchGetPipelineExecutablePropertiesKHR(
1216 VkDevice device,
1217 const VkPipelineInfoKHR* pPipelineInfo,
1218 uint32_t* pExecutableCount,
1219 VkPipelineExecutablePropertiesKHR* pProperties);
1220VkResult DispatchGetPipelineExecutableStatisticsKHR(
1221 VkDevice device,
1222 const VkPipelineExecutableInfoKHR* pExecutableInfo,
1223 uint32_t* pStatisticCount,
1224 VkPipelineExecutableStatisticKHR* pStatistics);
1225VkResult DispatchGetPipelineExecutableInternalRepresentationsKHR(
1226 VkDevice device,
1227 const VkPipelineExecutableInfoKHR* pExecutableInfo,
1228 uint32_t* pInternalRepresentationCount,
1229 VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
Mike Schuchardt440d4642019-06-20 17:14:57 -0700[diff] [blame]1230VkResult DispatchCreateDebugReportCallbackEXT(
1231 VkInstance instance,
1232 const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
1233 const VkAllocationCallbacks* pAllocator,
1234 VkDebugReportCallbackEXT* pCallback);
1235void DispatchDestroyDebugReportCallbackEXT(
1236 VkInstance instance,
1237 VkDebugReportCallbackEXT callback,
1238 const VkAllocationCallbacks* pAllocator);
1239void DispatchDebugReportMessageEXT(
1240 VkInstance instance,
1241 VkDebugReportFlagsEXT flags,
1242 VkDebugReportObjectTypeEXT objectType,
1243 uint64_t object,
1244 size_t location,
1245 int32_t messageCode,
1246 const char* pLayerPrefix,
1247 const char* pMessage);
1248VkResult DispatchDebugMarkerSetObjectTagEXT(
1249 VkDevice device,
1250 const VkDebugMarkerObjectTagInfoEXT* pTagInfo);
1251VkResult DispatchDebugMarkerSetObjectNameEXT(
1252 VkDevice device,
1253 const VkDebugMarkerObjectNameInfoEXT* pNameInfo);
1254void DispatchCmdDebugMarkerBeginEXT(
1255 VkCommandBuffer commandBuffer,
1256 const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
1257void DispatchCmdDebugMarkerEndEXT(
1258 VkCommandBuffer commandBuffer);
1259void DispatchCmdDebugMarkerInsertEXT(
1260 VkCommandBuffer commandBuffer,
1261 const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
1262void DispatchCmdBindTransformFeedbackBuffersEXT(
1263 VkCommandBuffer commandBuffer,
1264 uint32_t firstBinding,
1265 uint32_t bindingCount,
1266 const VkBuffer* pBuffers,
1267 const VkDeviceSize* pOffsets,
1268 const VkDeviceSize* pSizes);
1269void DispatchCmdBeginTransformFeedbackEXT(
1270 VkCommandBuffer commandBuffer,
1271 uint32_t firstCounterBuffer,
1272 uint32_t counterBufferCount,
1273 const VkBuffer* pCounterBuffers,
1274 const VkDeviceSize* pCounterBufferOffsets);
1275void DispatchCmdEndTransformFeedbackEXT(
1276 VkCommandBuffer commandBuffer,
1277 uint32_t firstCounterBuffer,
1278 uint32_t counterBufferCount,
1279 const VkBuffer* pCounterBuffers,
1280 const VkDeviceSize* pCounterBufferOffsets);
1281void DispatchCmdBeginQueryIndexedEXT(
1282 VkCommandBuffer commandBuffer,
1283 VkQueryPool queryPool,
1284 uint32_t query,
1285 VkQueryControlFlags flags,
1286 uint32_t index);
1287void DispatchCmdEndQueryIndexedEXT(
1288 VkCommandBuffer commandBuffer,
1289 VkQueryPool queryPool,
1290 uint32_t query,
1291 uint32_t index);
1292void DispatchCmdDrawIndirectByteCountEXT(
1293 VkCommandBuffer commandBuffer,
1294 uint32_t instanceCount,
1295 uint32_t firstInstance,
1296 VkBuffer counterBuffer,
1297 VkDeviceSize counterBufferOffset,
1298 uint32_t counterOffset,
1299 uint32_t vertexStride);
1300uint32_t DispatchGetImageViewHandleNVX(
1301 VkDevice device,
1302 const VkImageViewHandleInfoNVX* pInfo);
1303void DispatchCmdDrawIndirectCountAMD(
1304 VkCommandBuffer commandBuffer,
1305 VkBuffer buffer,
1306 VkDeviceSize offset,
1307 VkBuffer countBuffer,
1308 VkDeviceSize countBufferOffset,
1309 uint32_t maxDrawCount,
1310 uint32_t stride);
1311void DispatchCmdDrawIndexedIndirectCountAMD(
1312 VkCommandBuffer commandBuffer,
1313 VkBuffer buffer,
1314 VkDeviceSize offset,
1315 VkBuffer countBuffer,
1316 VkDeviceSize countBufferOffset,
1317 uint32_t maxDrawCount,
1318 uint32_t stride);
1319VkResult DispatchGetShaderInfoAMD(
1320 VkDevice device,
1321 VkPipeline pipeline,
1322 VkShaderStageFlagBits shaderStage,
1323 VkShaderInfoTypeAMD infoType,
1324 size_t* pInfoSize,
1325 void* pInfo);
1326#ifdef VK_USE_PLATFORM_GGP
1327VkResult DispatchCreateStreamDescriptorSurfaceGGP(
1328 VkInstance instance,
1329 const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
1330 const VkAllocationCallbacks* pAllocator,
1331 VkSurfaceKHR* pSurface);
1332#endif // VK_USE_PLATFORM_GGP
1333VkResult DispatchGetPhysicalDeviceExternalImageFormatPropertiesNV(
1334 VkPhysicalDevice physicalDevice,
1335 VkFormat format,
1336 VkImageType type,
1337 VkImageTiling tiling,
1338 VkImageUsageFlags usage,
1339 VkImageCreateFlags flags,
1340 VkExternalMemoryHandleTypeFlagsNV externalHandleType,
1341 VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
1342#ifdef VK_USE_PLATFORM_WIN32_KHR
1343VkResult DispatchGetMemoryWin32HandleNV(
1344 VkDevice device,
1345 VkDeviceMemory memory,
1346 VkExternalMemoryHandleTypeFlagsNV handleType,
1347 HANDLE* pHandle);
1348#endif // VK_USE_PLATFORM_WIN32_KHR
1349#ifdef VK_USE_PLATFORM_VI_NN
1350VkResult DispatchCreateViSurfaceNN(
1351 VkInstance instance,
1352 const VkViSurfaceCreateInfoNN* pCreateInfo,
1353 const VkAllocationCallbacks* pAllocator,
1354 VkSurfaceKHR* pSurface);
1355#endif // VK_USE_PLATFORM_VI_NN
1356void DispatchCmdBeginConditionalRenderingEXT(
1357 VkCommandBuffer commandBuffer,
1358 const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
1359void DispatchCmdEndConditionalRenderingEXT(
1360 VkCommandBuffer commandBuffer);
1361void DispatchCmdProcessCommandsNVX(
1362 VkCommandBuffer commandBuffer,
1363 const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
1364void DispatchCmdReserveSpaceForCommandsNVX(
1365 VkCommandBuffer commandBuffer,
1366 const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
1367VkResult DispatchCreateIndirectCommandsLayoutNVX(
1368 VkDevice device,
1369 const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
1370 const VkAllocationCallbacks* pAllocator,
1371 VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
1372void DispatchDestroyIndirectCommandsLayoutNVX(
1373 VkDevice device,
1374 VkIndirectCommandsLayoutNVX indirectCommandsLayout,
1375 const VkAllocationCallbacks* pAllocator);
1376VkResult DispatchCreateObjectTableNVX(
1377 VkDevice device,
1378 const VkObjectTableCreateInfoNVX* pCreateInfo,
1379 const VkAllocationCallbacks* pAllocator,
1380 VkObjectTableNVX* pObjectTable);
1381void DispatchDestroyObjectTableNVX(
1382 VkDevice device,
1383 VkObjectTableNVX objectTable,
1384 const VkAllocationCallbacks* pAllocator);
1385VkResult DispatchRegisterObjectsNVX(
1386 VkDevice device,
1387 VkObjectTableNVX objectTable,
1388 uint32_t objectCount,
1389 const VkObjectTableEntryNVX* const* ppObjectTableEntries,
1390 const uint32_t* pObjectIndices);
1391VkResult DispatchUnregisterObjectsNVX(
1392 VkDevice device,
1393 VkObjectTableNVX objectTable,
1394 uint32_t objectCount,
1395 const VkObjectEntryTypeNVX* pObjectEntryTypes,
1396 const uint32_t* pObjectIndices);
1397void DispatchGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
1398 VkPhysicalDevice physicalDevice,
1399 VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
1400 VkDeviceGeneratedCommandsLimitsNVX* pLimits);
1401void DispatchCmdSetViewportWScalingNV(
1402 VkCommandBuffer commandBuffer,
1403 uint32_t firstViewport,
1404 uint32_t viewportCount,
1405 const VkViewportWScalingNV* pViewportWScalings);
1406VkResult DispatchReleaseDisplayEXT(
1407 VkPhysicalDevice physicalDevice,
1408 VkDisplayKHR display);
1409#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
1410VkResult DispatchAcquireXlibDisplayEXT(
1411 VkPhysicalDevice physicalDevice,
1412 Display* dpy,
1413 VkDisplayKHR display);
1414#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
1415#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
1416VkResult DispatchGetRandROutputDisplayEXT(
1417 VkPhysicalDevice physicalDevice,
1418 Display* dpy,
1419 RROutput rrOutput,
1420 VkDisplayKHR* pDisplay);
1421#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
1422VkResult DispatchGetPhysicalDeviceSurfaceCapabilities2EXT(
1423 VkPhysicalDevice physicalDevice,
1424 VkSurfaceKHR surface,
1425 VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
1426VkResult DispatchDisplayPowerControlEXT(
1427 VkDevice device,
1428 VkDisplayKHR display,
1429 const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
1430VkResult DispatchRegisterDeviceEventEXT(
1431 VkDevice device,
1432 const VkDeviceEventInfoEXT* pDeviceEventInfo,
1433 const VkAllocationCallbacks* pAllocator,
1434 VkFence* pFence);
1435VkResult DispatchRegisterDisplayEventEXT(
1436 VkDevice device,
1437 VkDisplayKHR display,
1438 const VkDisplayEventInfoEXT* pDisplayEventInfo,
1439 const VkAllocationCallbacks* pAllocator,
1440 VkFence* pFence);
1441VkResult DispatchGetSwapchainCounterEXT(
1442 VkDevice device,
1443 VkSwapchainKHR swapchain,
1444 VkSurfaceCounterFlagBitsEXT counter,
1445 uint64_t* pCounterValue);
1446VkResult DispatchGetRefreshCycleDurationGOOGLE(
1447 VkDevice device,
1448 VkSwapchainKHR swapchain,
1449 VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
1450VkResult DispatchGetPastPresentationTimingGOOGLE(
1451 VkDevice device,
1452 VkSwapchainKHR swapchain,
1453 uint32_t* pPresentationTimingCount,
1454 VkPastPresentationTimingGOOGLE* pPresentationTimings);
1455void DispatchCmdSetDiscardRectangleEXT(
1456 VkCommandBuffer commandBuffer,
1457 uint32_t firstDiscardRectangle,
1458 uint32_t discardRectangleCount,
1459 const VkRect2D* pDiscardRectangles);
1460void DispatchSetHdrMetadataEXT(
1461 VkDevice device,
1462 uint32_t swapchainCount,
1463 const VkSwapchainKHR* pSwapchains,
1464 const VkHdrMetadataEXT* pMetadata);
1465#ifdef VK_USE_PLATFORM_IOS_MVK
1466VkResult DispatchCreateIOSSurfaceMVK(
1467 VkInstance instance,
1468 const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
1469 const VkAllocationCallbacks* pAllocator,
1470 VkSurfaceKHR* pSurface);
1471#endif // VK_USE_PLATFORM_IOS_MVK
1472#ifdef VK_USE_PLATFORM_MACOS_MVK
1473VkResult DispatchCreateMacOSSurfaceMVK(
1474 VkInstance instance,
1475 const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
1476 const VkAllocationCallbacks* pAllocator,
1477 VkSurfaceKHR* pSurface);
1478#endif // VK_USE_PLATFORM_MACOS_MVK
1479VkResult DispatchSetDebugUtilsObjectNameEXT(
1480 VkDevice device,
1481 const VkDebugUtilsObjectNameInfoEXT* pNameInfo);
1482VkResult DispatchSetDebugUtilsObjectTagEXT(
1483 VkDevice device,
1484 const VkDebugUtilsObjectTagInfoEXT* pTagInfo);
1485void DispatchQueueBeginDebugUtilsLabelEXT(
1486 VkQueue queue,
1487 const VkDebugUtilsLabelEXT* pLabelInfo);
1488void DispatchQueueEndDebugUtilsLabelEXT(
1489 VkQueue queue);
1490void DispatchQueueInsertDebugUtilsLabelEXT(
1491 VkQueue queue,
1492 const VkDebugUtilsLabelEXT* pLabelInfo);
1493void DispatchCmdBeginDebugUtilsLabelEXT(
1494 VkCommandBuffer commandBuffer,
1495 const VkDebugUtilsLabelEXT* pLabelInfo);
1496void DispatchCmdEndDebugUtilsLabelEXT(
1497 VkCommandBuffer commandBuffer);
1498void DispatchCmdInsertDebugUtilsLabelEXT(
1499 VkCommandBuffer commandBuffer,
1500 const VkDebugUtilsLabelEXT* pLabelInfo);
1501VkResult DispatchCreateDebugUtilsMessengerEXT(
1502 VkInstance instance,
1503 const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
1504 const VkAllocationCallbacks* pAllocator,
1505 VkDebugUtilsMessengerEXT* pMessenger);
1506void DispatchDestroyDebugUtilsMessengerEXT(
1507 VkInstance instance,
1508 VkDebugUtilsMessengerEXT messenger,
1509 const VkAllocationCallbacks* pAllocator);
1510void DispatchSubmitDebugUtilsMessageEXT(
1511 VkInstance instance,
1512 VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
1513 VkDebugUtilsMessageTypeFlagsEXT messageTypes,
1514 const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
1515#ifdef VK_USE_PLATFORM_ANDROID_KHR
1516VkResult DispatchGetAndroidHardwareBufferPropertiesANDROID(
1517 VkDevice device,
1518 const struct AHardwareBuffer* buffer,
1519 VkAndroidHardwareBufferPropertiesANDROID* pProperties);
1520#endif // VK_USE_PLATFORM_ANDROID_KHR
1521#ifdef VK_USE_PLATFORM_ANDROID_KHR
1522VkResult DispatchGetMemoryAndroidHardwareBufferANDROID(
1523 VkDevice device,
1524 const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
1525 struct AHardwareBuffer** pBuffer);
1526#endif // VK_USE_PLATFORM_ANDROID_KHR
1527void DispatchCmdSetSampleLocationsEXT(
1528 VkCommandBuffer commandBuffer,
1529 const VkSampleLocationsInfoEXT* pSampleLocationsInfo);
1530void DispatchGetPhysicalDeviceMultisamplePropertiesEXT(
1531 VkPhysicalDevice physicalDevice,
1532 VkSampleCountFlagBits samples,
1533 VkMultisamplePropertiesEXT* pMultisampleProperties);
1534VkResult DispatchGetImageDrmFormatModifierPropertiesEXT(
1535 VkDevice device,
1536 VkImage image,
1537 VkImageDrmFormatModifierPropertiesEXT* pProperties);
1538VkResult DispatchCreateValidationCacheEXT(
1539 VkDevice device,
1540 const VkValidationCacheCreateInfoEXT* pCreateInfo,
1541 const VkAllocationCallbacks* pAllocator,
1542 VkValidationCacheEXT* pValidationCache);
1543void DispatchDestroyValidationCacheEXT(
1544 VkDevice device,
1545 VkValidationCacheEXT validationCache,
1546 const VkAllocationCallbacks* pAllocator);
1547VkResult DispatchMergeValidationCachesEXT(
1548 VkDevice device,
1549 VkValidationCacheEXT dstCache,
1550 uint32_t srcCacheCount,
1551 const VkValidationCacheEXT* pSrcCaches);
1552VkResult DispatchGetValidationCacheDataEXT(
1553 VkDevice device,
1554 VkValidationCacheEXT validationCache,
1555 size_t* pDataSize,
1556 void* pData);
1557void DispatchCmdBindShadingRateImageNV(
1558 VkCommandBuffer commandBuffer,
1559 VkImageView imageView,
1560 VkImageLayout imageLayout);
1561void DispatchCmdSetViewportShadingRatePaletteNV(
1562 VkCommandBuffer commandBuffer,
1563 uint32_t firstViewport,
1564 uint32_t viewportCount,
1565 const VkShadingRatePaletteNV* pShadingRatePalettes);
1566void DispatchCmdSetCoarseSampleOrderNV(
1567 VkCommandBuffer commandBuffer,
1568 VkCoarseSampleOrderTypeNV sampleOrderType,
1569 uint32_t customSampleOrderCount,
1570 const VkCoarseSampleOrderCustomNV* pCustomSampleOrders);
1571VkResult DispatchCreateAccelerationStructureNV(
1572 VkDevice device,
1573 const VkAccelerationStructureCreateInfoNV* pCreateInfo,
1574 const VkAllocationCallbacks* pAllocator,
1575 VkAccelerationStructureNV* pAccelerationStructure);
1576void DispatchDestroyAccelerationStructureNV(
1577 VkDevice device,
1578 VkAccelerationStructureNV accelerationStructure,
1579 const VkAllocationCallbacks* pAllocator);
1580void DispatchGetAccelerationStructureMemoryRequirementsNV(
1581 VkDevice device,
1582 const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
1583 VkMemoryRequirements2KHR* pMemoryRequirements);
1584VkResult DispatchBindAccelerationStructureMemoryNV(
1585 VkDevice device,
1586 uint32_t bindInfoCount,
1587 const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);
1588void DispatchCmdBuildAccelerationStructureNV(
1589 VkCommandBuffer commandBuffer,
1590 const VkAccelerationStructureInfoNV* pInfo,
1591 VkBuffer instanceData,
1592 VkDeviceSize instanceOffset,
1593 VkBool32 update,
1594 VkAccelerationStructureNV dst,
1595 VkAccelerationStructureNV src,
1596 VkBuffer scratch,
1597 VkDeviceSize scratchOffset);
1598void DispatchCmdCopyAccelerationStructureNV(
1599 VkCommandBuffer commandBuffer,
1600 VkAccelerationStructureNV dst,
1601 VkAccelerationStructureNV src,
1602 VkCopyAccelerationStructureModeNV mode);
1603void DispatchCmdTraceRaysNV(
1604 VkCommandBuffer commandBuffer,
1605 VkBuffer raygenShaderBindingTableBuffer,
1606 VkDeviceSize raygenShaderBindingOffset,
1607 VkBuffer missShaderBindingTableBuffer,
1608 VkDeviceSize missShaderBindingOffset,
1609 VkDeviceSize missShaderBindingStride,
1610 VkBuffer hitShaderBindingTableBuffer,
1611 VkDeviceSize hitShaderBindingOffset,
1612 VkDeviceSize hitShaderBindingStride,
1613 VkBuffer callableShaderBindingTableBuffer,
1614 VkDeviceSize callableShaderBindingOffset,
1615 VkDeviceSize callableShaderBindingStride,
1616 uint32_t width,
1617 uint32_t height,
1618 uint32_t depth);
1619VkResult DispatchCreateRayTracingPipelinesNV(
1620 VkDevice device,
1621 VkPipelineCache pipelineCache,
1622 uint32_t createInfoCount,
1623 const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
1624 const VkAllocationCallbacks* pAllocator,
1625 VkPipeline* pPipelines);
1626VkResult DispatchGetRayTracingShaderGroupHandlesNV(
1627 VkDevice device,
1628 VkPipeline pipeline,
1629 uint32_t firstGroup,
1630 uint32_t groupCount,
1631 size_t dataSize,
1632 void* pData);
1633VkResult DispatchGetAccelerationStructureHandleNV(
1634 VkDevice device,
1635 VkAccelerationStructureNV accelerationStructure,
1636 size_t dataSize,
1637 void* pData);
1638void DispatchCmdWriteAccelerationStructuresPropertiesNV(
1639 VkCommandBuffer commandBuffer,
1640 uint32_t accelerationStructureCount,
1641 const VkAccelerationStructureNV* pAccelerationStructures,
1642 VkQueryType queryType,
1643 VkQueryPool queryPool,
1644 uint32_t firstQuery);
1645VkResult DispatchCompileDeferredNV(
1646 VkDevice device,
1647 VkPipeline pipeline,
1648 uint32_t shader);
1649VkResult DispatchGetMemoryHostPointerPropertiesEXT(
1650 VkDevice device,
1651 VkExternalMemoryHandleTypeFlagBits handleType,
1652 const void* pHostPointer,
1653 VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);
1654void DispatchCmdWriteBufferMarkerAMD(
1655 VkCommandBuffer commandBuffer,
1656 VkPipelineStageFlagBits pipelineStage,
1657 VkBuffer dstBuffer,
1658 VkDeviceSize dstOffset,
1659 uint32_t marker);
1660VkResult DispatchGetPhysicalDeviceCalibrateableTimeDomainsEXT(
1661 VkPhysicalDevice physicalDevice,
1662 uint32_t* pTimeDomainCount,
1663 VkTimeDomainEXT* pTimeDomains);
1664VkResult DispatchGetCalibratedTimestampsEXT(
1665 VkDevice device,
1666 uint32_t timestampCount,
1667 const VkCalibratedTimestampInfoEXT* pTimestampInfos,
1668 uint64_t* pTimestamps,
1669 uint64_t* pMaxDeviation);
1670void DispatchCmdDrawMeshTasksNV(
1671 VkCommandBuffer commandBuffer,
1672 uint32_t taskCount,
1673 uint32_t firstTask);
1674void DispatchCmdDrawMeshTasksIndirectNV(
1675 VkCommandBuffer commandBuffer,
1676 VkBuffer buffer,
1677 VkDeviceSize offset,
1678 uint32_t drawCount,
1679 uint32_t stride);
1680void DispatchCmdDrawMeshTasksIndirectCountNV(
1681 VkCommandBuffer commandBuffer,
1682 VkBuffer buffer,
1683 VkDeviceSize offset,
1684 VkBuffer countBuffer,
1685 VkDeviceSize countBufferOffset,
1686 uint32_t maxDrawCount,
1687 uint32_t stride);
1688void DispatchCmdSetExclusiveScissorNV(
1689 VkCommandBuffer commandBuffer,
1690 uint32_t firstExclusiveScissor,
1691 uint32_t exclusiveScissorCount,
1692 const VkRect2D* pExclusiveScissors);
1693void DispatchCmdSetCheckpointNV(
1694 VkCommandBuffer commandBuffer,
1695 const void* pCheckpointMarker);
1696void DispatchGetQueueCheckpointDataNV(
1697 VkQueue queue,
1698 uint32_t* pCheckpointDataCount,
1699 VkCheckpointDataNV* pCheckpointData);
1700VkResult DispatchInitializePerformanceApiINTEL(
1701 VkDevice device,
1702 const VkInitializePerformanceApiInfoINTEL* pInitializeInfo);
1703void DispatchUninitializePerformanceApiINTEL(
1704 VkDevice device);
1705VkResult DispatchCmdSetPerformanceMarkerINTEL(
1706 VkCommandBuffer commandBuffer,
1707 const VkPerformanceMarkerInfoINTEL* pMarkerInfo);
1708VkResult DispatchCmdSetPerformanceStreamMarkerINTEL(
1709 VkCommandBuffer commandBuffer,
1710 const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo);
1711VkResult DispatchCmdSetPerformanceOverrideINTEL(
1712 VkCommandBuffer commandBuffer,
1713 const VkPerformanceOverrideInfoINTEL* pOverrideInfo);
1714VkResult DispatchAcquirePerformanceConfigurationINTEL(
1715 VkDevice device,
1716 const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
1717 VkPerformanceConfigurationINTEL* pConfiguration);
1718VkResult DispatchReleasePerformanceConfigurationINTEL(
1719 VkDevice device,
1720 VkPerformanceConfigurationINTEL configuration);
1721VkResult DispatchQueueSetPerformanceConfigurationINTEL(
1722 VkQueue queue,
1723 VkPerformanceConfigurationINTEL configuration);
1724VkResult DispatchGetPerformanceParameterINTEL(
1725 VkDevice device,
1726 VkPerformanceParameterTypeINTEL parameter,
1727 VkPerformanceValueINTEL* pValue);
1728void DispatchSetLocalDimmingAMD(
1729 VkDevice device,
1730 VkSwapchainKHR swapChain,
1731 VkBool32 localDimmingEnable);
1732#ifdef VK_USE_PLATFORM_FUCHSIA
1733VkResult DispatchCreateImagePipeSurfaceFUCHSIA(
1734 VkInstance instance,
1735 const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
1736 const VkAllocationCallbacks* pAllocator,
1737 VkSurfaceKHR* pSurface);
1738#endif // VK_USE_PLATFORM_FUCHSIA
1739#ifdef VK_USE_PLATFORM_METAL_EXT
1740VkResult DispatchCreateMetalSurfaceEXT(
1741 VkInstance instance,
1742 const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
1743 const VkAllocationCallbacks* pAllocator,
1744 VkSurfaceKHR* pSurface);
1745#endif // VK_USE_PLATFORM_METAL_EXT
1746VkDeviceAddress DispatchGetBufferDeviceAddressEXT(
1747 VkDevice device,
1748 const VkBufferDeviceAddressInfoEXT* pInfo);
1749VkResult DispatchGetPhysicalDeviceCooperativeMatrixPropertiesNV(
1750 VkPhysicalDevice physicalDevice,
1751 uint32_t* pPropertyCount,
1752 VkCooperativeMatrixPropertiesNV* pProperties);
1753VkResult DispatchGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
1754 VkPhysicalDevice physicalDevice,
1755 uint32_t* pCombinationCount,
1756 VkFramebufferMixedSamplesCombinationNV* pCombinations);
1757#ifdef VK_USE_PLATFORM_WIN32_KHR
1758VkResult DispatchGetPhysicalDeviceSurfacePresentModes2EXT(
1759 VkPhysicalDevice physicalDevice,
1760 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
1761 uint32_t* pPresentModeCount,
1762 VkPresentModeKHR* pPresentModes);
1763#endif // VK_USE_PLATFORM_WIN32_KHR
1764#ifdef VK_USE_PLATFORM_WIN32_KHR
1765VkResult DispatchAcquireFullScreenExclusiveModeEXT(
1766 VkDevice device,
1767 VkSwapchainKHR swapchain);
1768#endif // VK_USE_PLATFORM_WIN32_KHR
1769#ifdef VK_USE_PLATFORM_WIN32_KHR
1770VkResult DispatchReleaseFullScreenExclusiveModeEXT(
1771 VkDevice device,
1772 VkSwapchainKHR swapchain);
1773#endif // VK_USE_PLATFORM_WIN32_KHR
1774#ifdef VK_USE_PLATFORM_WIN32_KHR
1775VkResult DispatchGetDeviceGroupSurfacePresentModes2EXT(
1776 VkDevice device,
1777 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
1778 VkDeviceGroupPresentModeFlagsKHR* pModes);
1779#endif // VK_USE_PLATFORM_WIN32_KHR
1780VkResult DispatchCreateHeadlessSurfaceEXT(
1781 VkInstance instance,
1782 const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
1783 const VkAllocationCallbacks* pAllocator,
1784 VkSurfaceKHR* pSurface);
Shannon McPherson3cc90bc2019-08-13 11:28:22 -0600[diff] [blame^]1785void DispatchCmdSetLineStippleEXT(
1786 VkCommandBuffer commandBuffer,
1787 uint32_t lineStippleFactor,
1788 uint16_t lineStipplePattern);
Mike Schuchardt440d4642019-06-20 17:14:57 -0700[diff] [blame]1789void DispatchResetQueryPoolEXT(
1790 VkDevice device,
1791 VkQueryPool queryPool,
1792 uint32_t firstQuery,
1793 uint32_t queryCount);