• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* *** THIS FILE IS GENERATED - DO NOT EDIT! ***
2  * See parameter_validation_generator.py for modifications
3  *
4  * Copyright (c) 2015-2019 The Khronos Group Inc.
5  * Copyright (c) 2015-2019 LunarG, Inc.
6  * Copyright (C) 2015-2019 Google Inc.
7  *
8  * Licensed under the Apache License, Version 2.0 (the "License");
9  * you may not use this file except in compliance with the License.
10  * Copyright (c) 2015-2017 Valve Corporation
11  * You may obtain a copy of the License at
12  *
13  *     http://www.apache.org/licenses/LICENSE-2.0
14  *
15  * Unless required by applicable law or agreed to in writing, software
16  * distributed under the License is distributed on an "AS IS" BASIS,
17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18  * See the License for the specific language governing permissions and
19  * limitations under the License.
20  *
21  * Author: Mark Lobodzinski <mark@LunarG.com>
22  * Author: Dave Houlton <daveh@LunarG.com>
23  */
24 
25 
26 bool PreCallValidateCreateInstance(
27     const VkInstanceCreateInfo*                 pCreateInfo,
28     const VkAllocationCallbacks*                pAllocator,
29     VkInstance*                                 pInstance);
30 bool PreCallValidateDestroyInstance(
31     VkInstance                                  instance,
32     const VkAllocationCallbacks*                pAllocator);
33 bool PreCallValidateEnumeratePhysicalDevices(
34     VkInstance                                  instance,
35     uint32_t*                                   pPhysicalDeviceCount,
36     VkPhysicalDevice*                           pPhysicalDevices);
37 bool PreCallValidateGetPhysicalDeviceFeatures(
38     VkPhysicalDevice                            physicalDevice,
39     VkPhysicalDeviceFeatures*                   pFeatures);
40 bool PreCallValidateGetPhysicalDeviceFormatProperties(
41     VkPhysicalDevice                            physicalDevice,
42     VkFormat                                    format,
43     VkFormatProperties*                         pFormatProperties);
44 bool PreCallValidateGetPhysicalDeviceImageFormatProperties(
45     VkPhysicalDevice                            physicalDevice,
46     VkFormat                                    format,
47     VkImageType                                 type,
48     VkImageTiling                               tiling,
49     VkImageUsageFlags                           usage,
50     VkImageCreateFlags                          flags,
51     VkImageFormatProperties*                    pImageFormatProperties);
52 bool PreCallValidateGetPhysicalDeviceProperties(
53     VkPhysicalDevice                            physicalDevice,
54     VkPhysicalDeviceProperties*                 pProperties);
55 bool PreCallValidateGetPhysicalDeviceQueueFamilyProperties(
56     VkPhysicalDevice                            physicalDevice,
57     uint32_t*                                   pQueueFamilyPropertyCount,
58     VkQueueFamilyProperties*                    pQueueFamilyProperties);
59 bool PreCallValidateGetPhysicalDeviceMemoryProperties(
60     VkPhysicalDevice                            physicalDevice,
61     VkPhysicalDeviceMemoryProperties*           pMemoryProperties);
62 bool PreCallValidateCreateDevice(
63     VkPhysicalDevice                            physicalDevice,
64     const VkDeviceCreateInfo*                   pCreateInfo,
65     const VkAllocationCallbacks*                pAllocator,
66     VkDevice*                                   pDevice);
67 bool PreCallValidateDestroyDevice(
68     VkDevice                                    device,
69     const VkAllocationCallbacks*                pAllocator);
70 bool PreCallValidateGetDeviceQueue(
71     VkDevice                                    device,
72     uint32_t                                    queueFamilyIndex,
73     uint32_t                                    queueIndex,
74     VkQueue*                                    pQueue);
75 bool PreCallValidateQueueSubmit(
76     VkQueue                                     queue,
77     uint32_t                                    submitCount,
78     const VkSubmitInfo*                         pSubmits,
79     VkFence                                     fence);
80 bool PreCallValidateQueueWaitIdle(
81     VkQueue                                     queue);
82 bool PreCallValidateDeviceWaitIdle(
83     VkDevice                                    device);
84 bool PreCallValidateAllocateMemory(
85     VkDevice                                    device,
86     const VkMemoryAllocateInfo*                 pAllocateInfo,
87     const VkAllocationCallbacks*                pAllocator,
88     VkDeviceMemory*                             pMemory);
89 bool PreCallValidateFreeMemory(
90     VkDevice                                    device,
91     VkDeviceMemory                              memory,
92     const VkAllocationCallbacks*                pAllocator);
93 bool PreCallValidateMapMemory(
94     VkDevice                                    device,
95     VkDeviceMemory                              memory,
96     VkDeviceSize                                offset,
97     VkDeviceSize                                size,
98     VkMemoryMapFlags                            flags,
99     void**                                      ppData);
100 bool PreCallValidateUnmapMemory(
101     VkDevice                                    device,
102     VkDeviceMemory                              memory);
103 bool PreCallValidateFlushMappedMemoryRanges(
104     VkDevice                                    device,
105     uint32_t                                    memoryRangeCount,
106     const VkMappedMemoryRange*                  pMemoryRanges);
107 bool PreCallValidateInvalidateMappedMemoryRanges(
108     VkDevice                                    device,
109     uint32_t                                    memoryRangeCount,
110     const VkMappedMemoryRange*                  pMemoryRanges);
111 bool PreCallValidateGetDeviceMemoryCommitment(
112     VkDevice                                    device,
113     VkDeviceMemory                              memory,
114     VkDeviceSize*                               pCommittedMemoryInBytes);
115 bool PreCallValidateBindBufferMemory(
116     VkDevice                                    device,
117     VkBuffer                                    buffer,
118     VkDeviceMemory                              memory,
119     VkDeviceSize                                memoryOffset);
120 bool PreCallValidateBindImageMemory(
121     VkDevice                                    device,
122     VkImage                                     image,
123     VkDeviceMemory                              memory,
124     VkDeviceSize                                memoryOffset);
125 bool PreCallValidateGetBufferMemoryRequirements(
126     VkDevice                                    device,
127     VkBuffer                                    buffer,
128     VkMemoryRequirements*                       pMemoryRequirements);
129 bool PreCallValidateGetImageMemoryRequirements(
130     VkDevice                                    device,
131     VkImage                                     image,
132     VkMemoryRequirements*                       pMemoryRequirements);
133 bool PreCallValidateGetImageSparseMemoryRequirements(
134     VkDevice                                    device,
135     VkImage                                     image,
136     uint32_t*                                   pSparseMemoryRequirementCount,
137     VkSparseImageMemoryRequirements*            pSparseMemoryRequirements);
138 bool PreCallValidateGetPhysicalDeviceSparseImageFormatProperties(
139     VkPhysicalDevice                            physicalDevice,
140     VkFormat                                    format,
141     VkImageType                                 type,
142     VkSampleCountFlagBits                       samples,
143     VkImageUsageFlags                           usage,
144     VkImageTiling                               tiling,
145     uint32_t*                                   pPropertyCount,
146     VkSparseImageFormatProperties*              pProperties);
147 bool PreCallValidateQueueBindSparse(
148     VkQueue                                     queue,
149     uint32_t                                    bindInfoCount,
150     const VkBindSparseInfo*                     pBindInfo,
151     VkFence                                     fence);
152 bool PreCallValidateCreateFence(
153     VkDevice                                    device,
154     const VkFenceCreateInfo*                    pCreateInfo,
155     const VkAllocationCallbacks*                pAllocator,
156     VkFence*                                    pFence);
157 bool PreCallValidateDestroyFence(
158     VkDevice                                    device,
159     VkFence                                     fence,
160     const VkAllocationCallbacks*                pAllocator);
161 bool PreCallValidateResetFences(
162     VkDevice                                    device,
163     uint32_t                                    fenceCount,
164     const VkFence*                              pFences);
165 bool PreCallValidateGetFenceStatus(
166     VkDevice                                    device,
167     VkFence                                     fence);
168 bool PreCallValidateWaitForFences(
169     VkDevice                                    device,
170     uint32_t                                    fenceCount,
171     const VkFence*                              pFences,
172     VkBool32                                    waitAll,
173     uint64_t                                    timeout);
174 bool PreCallValidateCreateSemaphore(
175     VkDevice                                    device,
176     const VkSemaphoreCreateInfo*                pCreateInfo,
177     const VkAllocationCallbacks*                pAllocator,
178     VkSemaphore*                                pSemaphore);
179 bool PreCallValidateDestroySemaphore(
180     VkDevice                                    device,
181     VkSemaphore                                 semaphore,
182     const VkAllocationCallbacks*                pAllocator);
183 bool PreCallValidateCreateEvent(
184     VkDevice                                    device,
185     const VkEventCreateInfo*                    pCreateInfo,
186     const VkAllocationCallbacks*                pAllocator,
187     VkEvent*                                    pEvent);
188 bool PreCallValidateDestroyEvent(
189     VkDevice                                    device,
190     VkEvent                                     event,
191     const VkAllocationCallbacks*                pAllocator);
192 bool PreCallValidateGetEventStatus(
193     VkDevice                                    device,
194     VkEvent                                     event);
195 bool PreCallValidateSetEvent(
196     VkDevice                                    device,
197     VkEvent                                     event);
198 bool PreCallValidateResetEvent(
199     VkDevice                                    device,
200     VkEvent                                     event);
201 bool PreCallValidateCreateQueryPool(
202     VkDevice                                    device,
203     const VkQueryPoolCreateInfo*                pCreateInfo,
204     const VkAllocationCallbacks*                pAllocator,
205     VkQueryPool*                                pQueryPool);
206 bool PreCallValidateDestroyQueryPool(
207     VkDevice                                    device,
208     VkQueryPool                                 queryPool,
209     const VkAllocationCallbacks*                pAllocator);
210 bool PreCallValidateGetQueryPoolResults(
211     VkDevice                                    device,
212     VkQueryPool                                 queryPool,
213     uint32_t                                    firstQuery,
214     uint32_t                                    queryCount,
215     size_t                                      dataSize,
216     void*                                       pData,
217     VkDeviceSize                                stride,
218     VkQueryResultFlags                          flags);
219 bool PreCallValidateCreateBuffer(
220     VkDevice                                    device,
221     const VkBufferCreateInfo*                   pCreateInfo,
222     const VkAllocationCallbacks*                pAllocator,
223     VkBuffer*                                   pBuffer);
224 bool PreCallValidateDestroyBuffer(
225     VkDevice                                    device,
226     VkBuffer                                    buffer,
227     const VkAllocationCallbacks*                pAllocator);
228 bool PreCallValidateCreateBufferView(
229     VkDevice                                    device,
230     const VkBufferViewCreateInfo*               pCreateInfo,
231     const VkAllocationCallbacks*                pAllocator,
232     VkBufferView*                               pView);
233 bool PreCallValidateDestroyBufferView(
234     VkDevice                                    device,
235     VkBufferView                                bufferView,
236     const VkAllocationCallbacks*                pAllocator);
237 bool PreCallValidateCreateImage(
238     VkDevice                                    device,
239     const VkImageCreateInfo*                    pCreateInfo,
240     const VkAllocationCallbacks*                pAllocator,
241     VkImage*                                    pImage);
242 bool PreCallValidateDestroyImage(
243     VkDevice                                    device,
244     VkImage                                     image,
245     const VkAllocationCallbacks*                pAllocator);
246 bool PreCallValidateGetImageSubresourceLayout(
247     VkDevice                                    device,
248     VkImage                                     image,
249     const VkImageSubresource*                   pSubresource,
250     VkSubresourceLayout*                        pLayout);
251 bool PreCallValidateCreateImageView(
252     VkDevice                                    device,
253     const VkImageViewCreateInfo*                pCreateInfo,
254     const VkAllocationCallbacks*                pAllocator,
255     VkImageView*                                pView);
256 bool PreCallValidateDestroyImageView(
257     VkDevice                                    device,
258     VkImageView                                 imageView,
259     const VkAllocationCallbacks*                pAllocator);
260 bool PreCallValidateCreateShaderModule(
261     VkDevice                                    device,
262     const VkShaderModuleCreateInfo*             pCreateInfo,
263     const VkAllocationCallbacks*                pAllocator,
264     VkShaderModule*                             pShaderModule);
265 bool PreCallValidateDestroyShaderModule(
266     VkDevice                                    device,
267     VkShaderModule                              shaderModule,
268     const VkAllocationCallbacks*                pAllocator);
269 bool PreCallValidateCreatePipelineCache(
270     VkDevice                                    device,
271     const VkPipelineCacheCreateInfo*            pCreateInfo,
272     const VkAllocationCallbacks*                pAllocator,
273     VkPipelineCache*                            pPipelineCache);
274 bool PreCallValidateDestroyPipelineCache(
275     VkDevice                                    device,
276     VkPipelineCache                             pipelineCache,
277     const VkAllocationCallbacks*                pAllocator);
278 bool PreCallValidateGetPipelineCacheData(
279     VkDevice                                    device,
280     VkPipelineCache                             pipelineCache,
281     size_t*                                     pDataSize,
282     void*                                       pData);
283 bool PreCallValidateMergePipelineCaches(
284     VkDevice                                    device,
285     VkPipelineCache                             dstCache,
286     uint32_t                                    srcCacheCount,
287     const VkPipelineCache*                      pSrcCaches);
288 bool PreCallValidateCreateGraphicsPipelines(
289     VkDevice                                    device,
290     VkPipelineCache                             pipelineCache,
291     uint32_t                                    createInfoCount,
292     const VkGraphicsPipelineCreateInfo*         pCreateInfos,
293     const VkAllocationCallbacks*                pAllocator,
294     VkPipeline*                                 pPipelines);
295 bool PreCallValidateCreateComputePipelines(
296     VkDevice                                    device,
297     VkPipelineCache                             pipelineCache,
298     uint32_t                                    createInfoCount,
299     const VkComputePipelineCreateInfo*          pCreateInfos,
300     const VkAllocationCallbacks*                pAllocator,
301     VkPipeline*                                 pPipelines);
302 bool PreCallValidateDestroyPipeline(
303     VkDevice                                    device,
304     VkPipeline                                  pipeline,
305     const VkAllocationCallbacks*                pAllocator);
306 bool PreCallValidateCreatePipelineLayout(
307     VkDevice                                    device,
308     const VkPipelineLayoutCreateInfo*           pCreateInfo,
309     const VkAllocationCallbacks*                pAllocator,
310     VkPipelineLayout*                           pPipelineLayout);
311 bool PreCallValidateDestroyPipelineLayout(
312     VkDevice                                    device,
313     VkPipelineLayout                            pipelineLayout,
314     const VkAllocationCallbacks*                pAllocator);
315 bool PreCallValidateCreateSampler(
316     VkDevice                                    device,
317     const VkSamplerCreateInfo*                  pCreateInfo,
318     const VkAllocationCallbacks*                pAllocator,
319     VkSampler*                                  pSampler);
320 bool PreCallValidateDestroySampler(
321     VkDevice                                    device,
322     VkSampler                                   sampler,
323     const VkAllocationCallbacks*                pAllocator);
324 bool PreCallValidateCreateDescriptorSetLayout(
325     VkDevice                                    device,
326     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
327     const VkAllocationCallbacks*                pAllocator,
328     VkDescriptorSetLayout*                      pSetLayout);
329 bool PreCallValidateDestroyDescriptorSetLayout(
330     VkDevice                                    device,
331     VkDescriptorSetLayout                       descriptorSetLayout,
332     const VkAllocationCallbacks*                pAllocator);
333 bool PreCallValidateCreateDescriptorPool(
334     VkDevice                                    device,
335     const VkDescriptorPoolCreateInfo*           pCreateInfo,
336     const VkAllocationCallbacks*                pAllocator,
337     VkDescriptorPool*                           pDescriptorPool);
338 bool PreCallValidateDestroyDescriptorPool(
339     VkDevice                                    device,
340     VkDescriptorPool                            descriptorPool,
341     const VkAllocationCallbacks*                pAllocator);
342 bool PreCallValidateResetDescriptorPool(
343     VkDevice                                    device,
344     VkDescriptorPool                            descriptorPool,
345     VkDescriptorPoolResetFlags                  flags);
346 bool PreCallValidateAllocateDescriptorSets(
347     VkDevice                                    device,
348     const VkDescriptorSetAllocateInfo*          pAllocateInfo,
349     VkDescriptorSet*                            pDescriptorSets);
350 bool PreCallValidateFreeDescriptorSets(
351     VkDevice                                    device,
352     VkDescriptorPool                            descriptorPool,
353     uint32_t                                    descriptorSetCount,
354     const VkDescriptorSet*                      pDescriptorSets);
355 bool PreCallValidateUpdateDescriptorSets(
356     VkDevice                                    device,
357     uint32_t                                    descriptorWriteCount,
358     const VkWriteDescriptorSet*                 pDescriptorWrites,
359     uint32_t                                    descriptorCopyCount,
360     const VkCopyDescriptorSet*                  pDescriptorCopies);
361 bool PreCallValidateCreateFramebuffer(
362     VkDevice                                    device,
363     const VkFramebufferCreateInfo*              pCreateInfo,
364     const VkAllocationCallbacks*                pAllocator,
365     VkFramebuffer*                              pFramebuffer);
366 bool PreCallValidateDestroyFramebuffer(
367     VkDevice                                    device,
368     VkFramebuffer                               framebuffer,
369     const VkAllocationCallbacks*                pAllocator);
370 bool PreCallValidateCreateRenderPass(
371     VkDevice                                    device,
372     const VkRenderPassCreateInfo*               pCreateInfo,
373     const VkAllocationCallbacks*                pAllocator,
374     VkRenderPass*                               pRenderPass);
375 bool PreCallValidateDestroyRenderPass(
376     VkDevice                                    device,
377     VkRenderPass                                renderPass,
378     const VkAllocationCallbacks*                pAllocator);
379 bool PreCallValidateGetRenderAreaGranularity(
380     VkDevice                                    device,
381     VkRenderPass                                renderPass,
382     VkExtent2D*                                 pGranularity);
383 bool PreCallValidateCreateCommandPool(
384     VkDevice                                    device,
385     const VkCommandPoolCreateInfo*              pCreateInfo,
386     const VkAllocationCallbacks*                pAllocator,
387     VkCommandPool*                              pCommandPool);
388 bool PreCallValidateDestroyCommandPool(
389     VkDevice                                    device,
390     VkCommandPool                               commandPool,
391     const VkAllocationCallbacks*                pAllocator);
392 bool PreCallValidateResetCommandPool(
393     VkDevice                                    device,
394     VkCommandPool                               commandPool,
395     VkCommandPoolResetFlags                     flags);
396 bool PreCallValidateAllocateCommandBuffers(
397     VkDevice                                    device,
398     const VkCommandBufferAllocateInfo*          pAllocateInfo,
399     VkCommandBuffer*                            pCommandBuffers);
400 bool PreCallValidateFreeCommandBuffers(
401     VkDevice                                    device,
402     VkCommandPool                               commandPool,
403     uint32_t                                    commandBufferCount,
404     const VkCommandBuffer*                      pCommandBuffers);
405 bool PreCallValidateBeginCommandBuffer(
406     VkCommandBuffer                             commandBuffer,
407     const VkCommandBufferBeginInfo*             pBeginInfo);
408 bool PreCallValidateEndCommandBuffer(
409     VkCommandBuffer                             commandBuffer);
410 bool PreCallValidateResetCommandBuffer(
411     VkCommandBuffer                             commandBuffer,
412     VkCommandBufferResetFlags                   flags);
413 bool PreCallValidateCmdBindPipeline(
414     VkCommandBuffer                             commandBuffer,
415     VkPipelineBindPoint                         pipelineBindPoint,
416     VkPipeline                                  pipeline);
417 bool PreCallValidateCmdSetViewport(
418     VkCommandBuffer                             commandBuffer,
419     uint32_t                                    firstViewport,
420     uint32_t                                    viewportCount,
421     const VkViewport*                           pViewports);
422 bool PreCallValidateCmdSetScissor(
423     VkCommandBuffer                             commandBuffer,
424     uint32_t                                    firstScissor,
425     uint32_t                                    scissorCount,
426     const VkRect2D*                             pScissors);
427 bool PreCallValidateCmdSetLineWidth(
428     VkCommandBuffer                             commandBuffer,
429     float                                       lineWidth);
430 bool PreCallValidateCmdSetDepthBias(
431     VkCommandBuffer                             commandBuffer,
432     float                                       depthBiasConstantFactor,
433     float                                       depthBiasClamp,
434     float                                       depthBiasSlopeFactor);
435 bool PreCallValidateCmdSetBlendConstants(
436     VkCommandBuffer                             commandBuffer,
437     const float                                 blendConstants[4]);
438 bool PreCallValidateCmdSetDepthBounds(
439     VkCommandBuffer                             commandBuffer,
440     float                                       minDepthBounds,
441     float                                       maxDepthBounds);
442 bool PreCallValidateCmdSetStencilCompareMask(
443     VkCommandBuffer                             commandBuffer,
444     VkStencilFaceFlags                          faceMask,
445     uint32_t                                    compareMask);
446 bool PreCallValidateCmdSetStencilWriteMask(
447     VkCommandBuffer                             commandBuffer,
448     VkStencilFaceFlags                          faceMask,
449     uint32_t                                    writeMask);
450 bool PreCallValidateCmdSetStencilReference(
451     VkCommandBuffer                             commandBuffer,
452     VkStencilFaceFlags                          faceMask,
453     uint32_t                                    reference);
454 bool PreCallValidateCmdBindDescriptorSets(
455     VkCommandBuffer                             commandBuffer,
456     VkPipelineBindPoint                         pipelineBindPoint,
457     VkPipelineLayout                            layout,
458     uint32_t                                    firstSet,
459     uint32_t                                    descriptorSetCount,
460     const VkDescriptorSet*                      pDescriptorSets,
461     uint32_t                                    dynamicOffsetCount,
462     const uint32_t*                             pDynamicOffsets);
463 bool PreCallValidateCmdBindIndexBuffer(
464     VkCommandBuffer                             commandBuffer,
465     VkBuffer                                    buffer,
466     VkDeviceSize                                offset,
467     VkIndexType                                 indexType);
468 bool PreCallValidateCmdBindVertexBuffers(
469     VkCommandBuffer                             commandBuffer,
470     uint32_t                                    firstBinding,
471     uint32_t                                    bindingCount,
472     const VkBuffer*                             pBuffers,
473     const VkDeviceSize*                         pOffsets);
474 bool PreCallValidateCmdDraw(
475     VkCommandBuffer                             commandBuffer,
476     uint32_t                                    vertexCount,
477     uint32_t                                    instanceCount,
478     uint32_t                                    firstVertex,
479     uint32_t                                    firstInstance);
480 bool PreCallValidateCmdDrawIndexed(
481     VkCommandBuffer                             commandBuffer,
482     uint32_t                                    indexCount,
483     uint32_t                                    instanceCount,
484     uint32_t                                    firstIndex,
485     int32_t                                     vertexOffset,
486     uint32_t                                    firstInstance);
487 bool PreCallValidateCmdDrawIndirect(
488     VkCommandBuffer                             commandBuffer,
489     VkBuffer                                    buffer,
490     VkDeviceSize                                offset,
491     uint32_t                                    drawCount,
492     uint32_t                                    stride);
493 bool PreCallValidateCmdDrawIndexedIndirect(
494     VkCommandBuffer                             commandBuffer,
495     VkBuffer                                    buffer,
496     VkDeviceSize                                offset,
497     uint32_t                                    drawCount,
498     uint32_t                                    stride);
499 bool PreCallValidateCmdDispatch(
500     VkCommandBuffer                             commandBuffer,
501     uint32_t                                    groupCountX,
502     uint32_t                                    groupCountY,
503     uint32_t                                    groupCountZ);
504 bool PreCallValidateCmdDispatchIndirect(
505     VkCommandBuffer                             commandBuffer,
506     VkBuffer                                    buffer,
507     VkDeviceSize                                offset);
508 bool PreCallValidateCmdCopyBuffer(
509     VkCommandBuffer                             commandBuffer,
510     VkBuffer                                    srcBuffer,
511     VkBuffer                                    dstBuffer,
512     uint32_t                                    regionCount,
513     const VkBufferCopy*                         pRegions);
514 bool PreCallValidateCmdCopyImage(
515     VkCommandBuffer                             commandBuffer,
516     VkImage                                     srcImage,
517     VkImageLayout                               srcImageLayout,
518     VkImage                                     dstImage,
519     VkImageLayout                               dstImageLayout,
520     uint32_t                                    regionCount,
521     const VkImageCopy*                          pRegions);
522 bool PreCallValidateCmdBlitImage(
523     VkCommandBuffer                             commandBuffer,
524     VkImage                                     srcImage,
525     VkImageLayout                               srcImageLayout,
526     VkImage                                     dstImage,
527     VkImageLayout                               dstImageLayout,
528     uint32_t                                    regionCount,
529     const VkImageBlit*                          pRegions,
530     VkFilter                                    filter);
531 bool PreCallValidateCmdCopyBufferToImage(
532     VkCommandBuffer                             commandBuffer,
533     VkBuffer                                    srcBuffer,
534     VkImage                                     dstImage,
535     VkImageLayout                               dstImageLayout,
536     uint32_t                                    regionCount,
537     const VkBufferImageCopy*                    pRegions);
538 bool PreCallValidateCmdCopyImageToBuffer(
539     VkCommandBuffer                             commandBuffer,
540     VkImage                                     srcImage,
541     VkImageLayout                               srcImageLayout,
542     VkBuffer                                    dstBuffer,
543     uint32_t                                    regionCount,
544     const VkBufferImageCopy*                    pRegions);
545 bool PreCallValidateCmdUpdateBuffer(
546     VkCommandBuffer                             commandBuffer,
547     VkBuffer                                    dstBuffer,
548     VkDeviceSize                                dstOffset,
549     VkDeviceSize                                dataSize,
550     const void*                                 pData);
551 bool PreCallValidateCmdFillBuffer(
552     VkCommandBuffer                             commandBuffer,
553     VkBuffer                                    dstBuffer,
554     VkDeviceSize                                dstOffset,
555     VkDeviceSize                                size,
556     uint32_t                                    data);
557 bool PreCallValidateCmdClearColorImage(
558     VkCommandBuffer                             commandBuffer,
559     VkImage                                     image,
560     VkImageLayout                               imageLayout,
561     const VkClearColorValue*                    pColor,
562     uint32_t                                    rangeCount,
563     const VkImageSubresourceRange*              pRanges);
564 bool PreCallValidateCmdClearDepthStencilImage(
565     VkCommandBuffer                             commandBuffer,
566     VkImage                                     image,
567     VkImageLayout                               imageLayout,
568     const VkClearDepthStencilValue*             pDepthStencil,
569     uint32_t                                    rangeCount,
570     const VkImageSubresourceRange*              pRanges);
571 bool PreCallValidateCmdClearAttachments(
572     VkCommandBuffer                             commandBuffer,
573     uint32_t                                    attachmentCount,
574     const VkClearAttachment*                    pAttachments,
575     uint32_t                                    rectCount,
576     const VkClearRect*                          pRects);
577 bool PreCallValidateCmdResolveImage(
578     VkCommandBuffer                             commandBuffer,
579     VkImage                                     srcImage,
580     VkImageLayout                               srcImageLayout,
581     VkImage                                     dstImage,
582     VkImageLayout                               dstImageLayout,
583     uint32_t                                    regionCount,
584     const VkImageResolve*                       pRegions);
585 bool PreCallValidateCmdSetEvent(
586     VkCommandBuffer                             commandBuffer,
587     VkEvent                                     event,
588     VkPipelineStageFlags                        stageMask);
589 bool PreCallValidateCmdResetEvent(
590     VkCommandBuffer                             commandBuffer,
591     VkEvent                                     event,
592     VkPipelineStageFlags                        stageMask);
593 bool PreCallValidateCmdWaitEvents(
594     VkCommandBuffer                             commandBuffer,
595     uint32_t                                    eventCount,
596     const VkEvent*                              pEvents,
597     VkPipelineStageFlags                        srcStageMask,
598     VkPipelineStageFlags                        dstStageMask,
599     uint32_t                                    memoryBarrierCount,
600     const VkMemoryBarrier*                      pMemoryBarriers,
601     uint32_t                                    bufferMemoryBarrierCount,
602     const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
603     uint32_t                                    imageMemoryBarrierCount,
604     const VkImageMemoryBarrier*                 pImageMemoryBarriers);
605 bool PreCallValidateCmdPipelineBarrier(
606     VkCommandBuffer                             commandBuffer,
607     VkPipelineStageFlags                        srcStageMask,
608     VkPipelineStageFlags                        dstStageMask,
609     VkDependencyFlags                           dependencyFlags,
610     uint32_t                                    memoryBarrierCount,
611     const VkMemoryBarrier*                      pMemoryBarriers,
612     uint32_t                                    bufferMemoryBarrierCount,
613     const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
614     uint32_t                                    imageMemoryBarrierCount,
615     const VkImageMemoryBarrier*                 pImageMemoryBarriers);
616 bool PreCallValidateCmdBeginQuery(
617     VkCommandBuffer                             commandBuffer,
618     VkQueryPool                                 queryPool,
619     uint32_t                                    query,
620     VkQueryControlFlags                         flags);
621 bool PreCallValidateCmdEndQuery(
622     VkCommandBuffer                             commandBuffer,
623     VkQueryPool                                 queryPool,
624     uint32_t                                    query);
625 bool PreCallValidateCmdResetQueryPool(
626     VkCommandBuffer                             commandBuffer,
627     VkQueryPool                                 queryPool,
628     uint32_t                                    firstQuery,
629     uint32_t                                    queryCount);
630 bool PreCallValidateCmdWriteTimestamp(
631     VkCommandBuffer                             commandBuffer,
632     VkPipelineStageFlagBits                     pipelineStage,
633     VkQueryPool                                 queryPool,
634     uint32_t                                    query);
635 bool PreCallValidateCmdCopyQueryPoolResults(
636     VkCommandBuffer                             commandBuffer,
637     VkQueryPool                                 queryPool,
638     uint32_t                                    firstQuery,
639     uint32_t                                    queryCount,
640     VkBuffer                                    dstBuffer,
641     VkDeviceSize                                dstOffset,
642     VkDeviceSize                                stride,
643     VkQueryResultFlags                          flags);
644 bool PreCallValidateCmdPushConstants(
645     VkCommandBuffer                             commandBuffer,
646     VkPipelineLayout                            layout,
647     VkShaderStageFlags                          stageFlags,
648     uint32_t                                    offset,
649     uint32_t                                    size,
650     const void*                                 pValues);
651 bool PreCallValidateCmdBeginRenderPass(
652     VkCommandBuffer                             commandBuffer,
653     const VkRenderPassBeginInfo*                pRenderPassBegin,
654     VkSubpassContents                           contents);
655 bool PreCallValidateCmdNextSubpass(
656     VkCommandBuffer                             commandBuffer,
657     VkSubpassContents                           contents);
658 bool PreCallValidateCmdEndRenderPass(
659     VkCommandBuffer                             commandBuffer);
660 bool PreCallValidateCmdExecuteCommands(
661     VkCommandBuffer                             commandBuffer,
662     uint32_t                                    commandBufferCount,
663     const VkCommandBuffer*                      pCommandBuffers);
664 bool PreCallValidateBindBufferMemory2(
665     VkDevice                                    device,
666     uint32_t                                    bindInfoCount,
667     const VkBindBufferMemoryInfo*               pBindInfos);
668 bool PreCallValidateBindImageMemory2(
669     VkDevice                                    device,
670     uint32_t                                    bindInfoCount,
671     const VkBindImageMemoryInfo*                pBindInfos);
672 bool PreCallValidateGetDeviceGroupPeerMemoryFeatures(
673     VkDevice                                    device,
674     uint32_t                                    heapIndex,
675     uint32_t                                    localDeviceIndex,
676     uint32_t                                    remoteDeviceIndex,
677     VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures);
678 bool PreCallValidateCmdSetDeviceMask(
679     VkCommandBuffer                             commandBuffer,
680     uint32_t                                    deviceMask);
681 bool PreCallValidateCmdDispatchBase(
682     VkCommandBuffer                             commandBuffer,
683     uint32_t                                    baseGroupX,
684     uint32_t                                    baseGroupY,
685     uint32_t                                    baseGroupZ,
686     uint32_t                                    groupCountX,
687     uint32_t                                    groupCountY,
688     uint32_t                                    groupCountZ);
689 bool PreCallValidateEnumeratePhysicalDeviceGroups(
690     VkInstance                                  instance,
691     uint32_t*                                   pPhysicalDeviceGroupCount,
692     VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);
693 bool PreCallValidateGetImageMemoryRequirements2(
694     VkDevice                                    device,
695     const VkImageMemoryRequirementsInfo2*       pInfo,
696     VkMemoryRequirements2*                      pMemoryRequirements);
697 bool PreCallValidateGetBufferMemoryRequirements2(
698     VkDevice                                    device,
699     const VkBufferMemoryRequirementsInfo2*      pInfo,
700     VkMemoryRequirements2*                      pMemoryRequirements);
701 bool PreCallValidateGetImageSparseMemoryRequirements2(
702     VkDevice                                    device,
703     const VkImageSparseMemoryRequirementsInfo2* pInfo,
704     uint32_t*                                   pSparseMemoryRequirementCount,
705     VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);
706 bool PreCallValidateGetPhysicalDeviceFeatures2(
707     VkPhysicalDevice                            physicalDevice,
708     VkPhysicalDeviceFeatures2*                  pFeatures);
709 bool PreCallValidateGetPhysicalDeviceProperties2(
710     VkPhysicalDevice                            physicalDevice,
711     VkPhysicalDeviceProperties2*                pProperties);
712 bool PreCallValidateGetPhysicalDeviceFormatProperties2(
713     VkPhysicalDevice                            physicalDevice,
714     VkFormat                                    format,
715     VkFormatProperties2*                        pFormatProperties);
716 bool PreCallValidateGetPhysicalDeviceImageFormatProperties2(
717     VkPhysicalDevice                            physicalDevice,
718     const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
719     VkImageFormatProperties2*                   pImageFormatProperties);
720 bool PreCallValidateGetPhysicalDeviceQueueFamilyProperties2(
721     VkPhysicalDevice                            physicalDevice,
722     uint32_t*                                   pQueueFamilyPropertyCount,
723     VkQueueFamilyProperties2*                   pQueueFamilyProperties);
724 bool PreCallValidateGetPhysicalDeviceMemoryProperties2(
725     VkPhysicalDevice                            physicalDevice,
726     VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);
727 bool PreCallValidateGetPhysicalDeviceSparseImageFormatProperties2(
728     VkPhysicalDevice                            physicalDevice,
729     const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
730     uint32_t*                                   pPropertyCount,
731     VkSparseImageFormatProperties2*             pProperties);
732 bool PreCallValidateTrimCommandPool(
733     VkDevice                                    device,
734     VkCommandPool                               commandPool,
735     VkCommandPoolTrimFlags                      flags);
736 bool PreCallValidateGetDeviceQueue2(
737     VkDevice                                    device,
738     const VkDeviceQueueInfo2*                   pQueueInfo,
739     VkQueue*                                    pQueue);
740 bool PreCallValidateCreateSamplerYcbcrConversion(
741     VkDevice                                    device,
742     const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
743     const VkAllocationCallbacks*                pAllocator,
744     VkSamplerYcbcrConversion*                   pYcbcrConversion);
745 bool PreCallValidateDestroySamplerYcbcrConversion(
746     VkDevice                                    device,
747     VkSamplerYcbcrConversion                    ycbcrConversion,
748     const VkAllocationCallbacks*                pAllocator);
749 bool PreCallValidateCreateDescriptorUpdateTemplate(
750     VkDevice                                    device,
751     const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
752     const VkAllocationCallbacks*                pAllocator,
753     VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate);
754 bool PreCallValidateDestroyDescriptorUpdateTemplate(
755     VkDevice                                    device,
756     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
757     const VkAllocationCallbacks*                pAllocator);
758 bool PreCallValidateUpdateDescriptorSetWithTemplate(
759     VkDevice                                    device,
760     VkDescriptorSet                             descriptorSet,
761     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
762     const void*                                 pData);
763 bool PreCallValidateGetPhysicalDeviceExternalBufferProperties(
764     VkPhysicalDevice                            physicalDevice,
765     const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
766     VkExternalBufferProperties*                 pExternalBufferProperties);
767 bool PreCallValidateGetPhysicalDeviceExternalFenceProperties(
768     VkPhysicalDevice                            physicalDevice,
769     const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
770     VkExternalFenceProperties*                  pExternalFenceProperties);
771 bool PreCallValidateGetPhysicalDeviceExternalSemaphoreProperties(
772     VkPhysicalDevice                            physicalDevice,
773     const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
774     VkExternalSemaphoreProperties*              pExternalSemaphoreProperties);
775 bool PreCallValidateGetDescriptorSetLayoutSupport(
776     VkDevice                                    device,
777     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
778     VkDescriptorSetLayoutSupport*               pSupport);
779 bool PreCallValidateDestroySurfaceKHR(
780     VkInstance                                  instance,
781     VkSurfaceKHR                                surface,
782     const VkAllocationCallbacks*                pAllocator);
783 bool PreCallValidateGetPhysicalDeviceSurfaceSupportKHR(
784     VkPhysicalDevice                            physicalDevice,
785     uint32_t                                    queueFamilyIndex,
786     VkSurfaceKHR                                surface,
787     VkBool32*                                   pSupported);
788 bool PreCallValidateGetPhysicalDeviceSurfaceCapabilitiesKHR(
789     VkPhysicalDevice                            physicalDevice,
790     VkSurfaceKHR                                surface,
791     VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities);
792 bool PreCallValidateGetPhysicalDeviceSurfaceFormatsKHR(
793     VkPhysicalDevice                            physicalDevice,
794     VkSurfaceKHR                                surface,
795     uint32_t*                                   pSurfaceFormatCount,
796     VkSurfaceFormatKHR*                         pSurfaceFormats);
797 bool PreCallValidateGetPhysicalDeviceSurfacePresentModesKHR(
798     VkPhysicalDevice                            physicalDevice,
799     VkSurfaceKHR                                surface,
800     uint32_t*                                   pPresentModeCount,
801     VkPresentModeKHR*                           pPresentModes);
802 bool PreCallValidateCreateSwapchainKHR(
803     VkDevice                                    device,
804     const VkSwapchainCreateInfoKHR*             pCreateInfo,
805     const VkAllocationCallbacks*                pAllocator,
806     VkSwapchainKHR*                             pSwapchain);
807 bool PreCallValidateDestroySwapchainKHR(
808     VkDevice                                    device,
809     VkSwapchainKHR                              swapchain,
810     const VkAllocationCallbacks*                pAllocator);
811 bool PreCallValidateGetSwapchainImagesKHR(
812     VkDevice                                    device,
813     VkSwapchainKHR                              swapchain,
814     uint32_t*                                   pSwapchainImageCount,
815     VkImage*                                    pSwapchainImages);
816 bool PreCallValidateAcquireNextImageKHR(
817     VkDevice                                    device,
818     VkSwapchainKHR                              swapchain,
819     uint64_t                                    timeout,
820     VkSemaphore                                 semaphore,
821     VkFence                                     fence,
822     uint32_t*                                   pImageIndex);
823 bool PreCallValidateQueuePresentKHR(
824     VkQueue                                     queue,
825     const VkPresentInfoKHR*                     pPresentInfo);
826 bool PreCallValidateGetDeviceGroupPresentCapabilitiesKHR(
827     VkDevice                                    device,
828     VkDeviceGroupPresentCapabilitiesKHR*        pDeviceGroupPresentCapabilities);
829 bool PreCallValidateGetDeviceGroupSurfacePresentModesKHR(
830     VkDevice                                    device,
831     VkSurfaceKHR                                surface,
832     VkDeviceGroupPresentModeFlagsKHR*           pModes);
833 bool PreCallValidateGetPhysicalDevicePresentRectanglesKHR(
834     VkPhysicalDevice                            physicalDevice,
835     VkSurfaceKHR                                surface,
836     uint32_t*                                   pRectCount,
837     VkRect2D*                                   pRects);
838 bool PreCallValidateAcquireNextImage2KHR(
839     VkDevice                                    device,
840     const VkAcquireNextImageInfoKHR*            pAcquireInfo,
841     uint32_t*                                   pImageIndex);
842 bool PreCallValidateGetPhysicalDeviceDisplayPropertiesKHR(
843     VkPhysicalDevice                            physicalDevice,
844     uint32_t*                                   pPropertyCount,
845     VkDisplayPropertiesKHR*                     pProperties);
846 bool PreCallValidateGetPhysicalDeviceDisplayPlanePropertiesKHR(
847     VkPhysicalDevice                            physicalDevice,
848     uint32_t*                                   pPropertyCount,
849     VkDisplayPlanePropertiesKHR*                pProperties);
850 bool PreCallValidateGetDisplayPlaneSupportedDisplaysKHR(
851     VkPhysicalDevice                            physicalDevice,
852     uint32_t                                    planeIndex,
853     uint32_t*                                   pDisplayCount,
854     VkDisplayKHR*                               pDisplays);
855 bool PreCallValidateGetDisplayModePropertiesKHR(
856     VkPhysicalDevice                            physicalDevice,
857     VkDisplayKHR                                display,
858     uint32_t*                                   pPropertyCount,
859     VkDisplayModePropertiesKHR*                 pProperties);
860 bool PreCallValidateCreateDisplayModeKHR(
861     VkPhysicalDevice                            physicalDevice,
862     VkDisplayKHR                                display,
863     const VkDisplayModeCreateInfoKHR*           pCreateInfo,
864     const VkAllocationCallbacks*                pAllocator,
865     VkDisplayModeKHR*                           pMode);
866 bool PreCallValidateGetDisplayPlaneCapabilitiesKHR(
867     VkPhysicalDevice                            physicalDevice,
868     VkDisplayModeKHR                            mode,
869     uint32_t                                    planeIndex,
870     VkDisplayPlaneCapabilitiesKHR*              pCapabilities);
871 bool PreCallValidateCreateDisplayPlaneSurfaceKHR(
872     VkInstance                                  instance,
873     const VkDisplaySurfaceCreateInfoKHR*        pCreateInfo,
874     const VkAllocationCallbacks*                pAllocator,
875     VkSurfaceKHR*                               pSurface);
876 bool PreCallValidateCreateSharedSwapchainsKHR(
877     VkDevice                                    device,
878     uint32_t                                    swapchainCount,
879     const VkSwapchainCreateInfoKHR*             pCreateInfos,
880     const VkAllocationCallbacks*                pAllocator,
881     VkSwapchainKHR*                             pSwapchains);
882 #ifdef VK_USE_PLATFORM_XLIB_KHR
883 bool PreCallValidateCreateXlibSurfaceKHR(
884     VkInstance                                  instance,
885     const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
886     const VkAllocationCallbacks*                pAllocator,
887     VkSurfaceKHR*                               pSurface);
888 #endif
889 #ifdef VK_USE_PLATFORM_XLIB_KHR
890 bool PreCallValidateGetPhysicalDeviceXlibPresentationSupportKHR(
891     VkPhysicalDevice                            physicalDevice,
892     uint32_t                                    queueFamilyIndex,
893     Display*                                    dpy,
894     VisualID                                    visualID);
895 #endif
896 #ifdef VK_USE_PLATFORM_XCB_KHR
897 bool PreCallValidateCreateXcbSurfaceKHR(
898     VkInstance                                  instance,
899     const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
900     const VkAllocationCallbacks*                pAllocator,
901     VkSurfaceKHR*                               pSurface);
902 #endif
903 #ifdef VK_USE_PLATFORM_XCB_KHR
904 bool PreCallValidateGetPhysicalDeviceXcbPresentationSupportKHR(
905     VkPhysicalDevice                            physicalDevice,
906     uint32_t                                    queueFamilyIndex,
907     xcb_connection_t*                           connection,
908     xcb_visualid_t                              visual_id);
909 #endif
910 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
911 bool PreCallValidateCreateWaylandSurfaceKHR(
912     VkInstance                                  instance,
913     const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
914     const VkAllocationCallbacks*                pAllocator,
915     VkSurfaceKHR*                               pSurface);
916 #endif
917 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
918 bool PreCallValidateGetPhysicalDeviceWaylandPresentationSupportKHR(
919     VkPhysicalDevice                            physicalDevice,
920     uint32_t                                    queueFamilyIndex,
921     struct wl_display*                          display);
922 #endif
923 #ifdef VK_USE_PLATFORM_ANDROID_KHR
924 bool PreCallValidateCreateAndroidSurfaceKHR(
925     VkInstance                                  instance,
926     const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
927     const VkAllocationCallbacks*                pAllocator,
928     VkSurfaceKHR*                               pSurface);
929 #endif
930 #ifdef VK_USE_PLATFORM_WIN32_KHR
931 bool PreCallValidateCreateWin32SurfaceKHR(
932     VkInstance                                  instance,
933     const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
934     const VkAllocationCallbacks*                pAllocator,
935     VkSurfaceKHR*                               pSurface);
936 #endif
937 #ifdef VK_USE_PLATFORM_WIN32_KHR
938 bool PreCallValidateGetPhysicalDeviceWin32PresentationSupportKHR(
939     VkPhysicalDevice                            physicalDevice,
940     uint32_t                                    queueFamilyIndex);
941 #endif
942 bool PreCallValidateGetPhysicalDeviceFeatures2KHR(
943     VkPhysicalDevice                            physicalDevice,
944     VkPhysicalDeviceFeatures2*                  pFeatures);
945 bool PreCallValidateGetPhysicalDeviceProperties2KHR(
946     VkPhysicalDevice                            physicalDevice,
947     VkPhysicalDeviceProperties2*                pProperties);
948 bool PreCallValidateGetPhysicalDeviceFormatProperties2KHR(
949     VkPhysicalDevice                            physicalDevice,
950     VkFormat                                    format,
951     VkFormatProperties2*                        pFormatProperties);
952 bool PreCallValidateGetPhysicalDeviceImageFormatProperties2KHR(
953     VkPhysicalDevice                            physicalDevice,
954     const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
955     VkImageFormatProperties2*                   pImageFormatProperties);
956 bool PreCallValidateGetPhysicalDeviceQueueFamilyProperties2KHR(
957     VkPhysicalDevice                            physicalDevice,
958     uint32_t*                                   pQueueFamilyPropertyCount,
959     VkQueueFamilyProperties2*                   pQueueFamilyProperties);
960 bool PreCallValidateGetPhysicalDeviceMemoryProperties2KHR(
961     VkPhysicalDevice                            physicalDevice,
962     VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);
963 bool PreCallValidateGetPhysicalDeviceSparseImageFormatProperties2KHR(
964     VkPhysicalDevice                            physicalDevice,
965     const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
966     uint32_t*                                   pPropertyCount,
967     VkSparseImageFormatProperties2*             pProperties);
968 bool PreCallValidateGetDeviceGroupPeerMemoryFeaturesKHR(
969     VkDevice                                    device,
970     uint32_t                                    heapIndex,
971     uint32_t                                    localDeviceIndex,
972     uint32_t                                    remoteDeviceIndex,
973     VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures);
974 bool PreCallValidateCmdSetDeviceMaskKHR(
975     VkCommandBuffer                             commandBuffer,
976     uint32_t                                    deviceMask);
977 bool PreCallValidateCmdDispatchBaseKHR(
978     VkCommandBuffer                             commandBuffer,
979     uint32_t                                    baseGroupX,
980     uint32_t                                    baseGroupY,
981     uint32_t                                    baseGroupZ,
982     uint32_t                                    groupCountX,
983     uint32_t                                    groupCountY,
984     uint32_t                                    groupCountZ);
985 bool PreCallValidateTrimCommandPoolKHR(
986     VkDevice                                    device,
987     VkCommandPool                               commandPool,
988     VkCommandPoolTrimFlags                      flags);
989 bool PreCallValidateEnumeratePhysicalDeviceGroupsKHR(
990     VkInstance                                  instance,
991     uint32_t*                                   pPhysicalDeviceGroupCount,
992     VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);
993 bool PreCallValidateGetPhysicalDeviceExternalBufferPropertiesKHR(
994     VkPhysicalDevice                            physicalDevice,
995     const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
996     VkExternalBufferProperties*                 pExternalBufferProperties);
997 #ifdef VK_USE_PLATFORM_WIN32_KHR
998 bool PreCallValidateGetMemoryWin32HandleKHR(
999     VkDevice                                    device,
1000     const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
1001     HANDLE*                                     pHandle);
1002 #endif
1003 #ifdef VK_USE_PLATFORM_WIN32_KHR
1004 bool PreCallValidateGetMemoryWin32HandlePropertiesKHR(
1005     VkDevice                                    device,
1006     VkExternalMemoryHandleTypeFlagBits          handleType,
1007     HANDLE                                      handle,
1008     VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties);
1009 #endif
1010 bool PreCallValidateGetMemoryFdKHR(
1011     VkDevice                                    device,
1012     const VkMemoryGetFdInfoKHR*                 pGetFdInfo,
1013     int*                                        pFd);
1014 bool PreCallValidateGetMemoryFdPropertiesKHR(
1015     VkDevice                                    device,
1016     VkExternalMemoryHandleTypeFlagBits          handleType,
1017     int                                         fd,
1018     VkMemoryFdPropertiesKHR*                    pMemoryFdProperties);
1019 bool PreCallValidateGetPhysicalDeviceExternalSemaphorePropertiesKHR(
1020     VkPhysicalDevice                            physicalDevice,
1021     const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
1022     VkExternalSemaphoreProperties*              pExternalSemaphoreProperties);
1023 #ifdef VK_USE_PLATFORM_WIN32_KHR
1024 bool PreCallValidateImportSemaphoreWin32HandleKHR(
1025     VkDevice                                    device,
1026     const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo);
1027 #endif
1028 #ifdef VK_USE_PLATFORM_WIN32_KHR
1029 bool PreCallValidateGetSemaphoreWin32HandleKHR(
1030     VkDevice                                    device,
1031     const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
1032     HANDLE*                                     pHandle);
1033 #endif
1034 bool PreCallValidateImportSemaphoreFdKHR(
1035     VkDevice                                    device,
1036     const VkImportSemaphoreFdInfoKHR*           pImportSemaphoreFdInfo);
1037 bool PreCallValidateGetSemaphoreFdKHR(
1038     VkDevice                                    device,
1039     const VkSemaphoreGetFdInfoKHR*              pGetFdInfo,
1040     int*                                        pFd);
1041 bool PreCallValidateCmdPushDescriptorSetKHR(
1042     VkCommandBuffer                             commandBuffer,
1043     VkPipelineBindPoint                         pipelineBindPoint,
1044     VkPipelineLayout                            layout,
1045     uint32_t                                    set,
1046     uint32_t                                    descriptorWriteCount,
1047     const VkWriteDescriptorSet*                 pDescriptorWrites);
1048 bool PreCallValidateCmdPushDescriptorSetWithTemplateKHR(
1049     VkCommandBuffer                             commandBuffer,
1050     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
1051     VkPipelineLayout                            layout,
1052     uint32_t                                    set,
1053     const void*                                 pData);
1054 bool PreCallValidateCreateDescriptorUpdateTemplateKHR(
1055     VkDevice                                    device,
1056     const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
1057     const VkAllocationCallbacks*                pAllocator,
1058     VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate);
1059 bool PreCallValidateDestroyDescriptorUpdateTemplateKHR(
1060     VkDevice                                    device,
1061     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
1062     const VkAllocationCallbacks*                pAllocator);
1063 bool PreCallValidateUpdateDescriptorSetWithTemplateKHR(
1064     VkDevice                                    device,
1065     VkDescriptorSet                             descriptorSet,
1066     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
1067     const void*                                 pData);
1068 bool PreCallValidateCreateRenderPass2KHR(
1069     VkDevice                                    device,
1070     const VkRenderPassCreateInfo2KHR*           pCreateInfo,
1071     const VkAllocationCallbacks*                pAllocator,
1072     VkRenderPass*                               pRenderPass);
1073 bool PreCallValidateCmdBeginRenderPass2KHR(
1074     VkCommandBuffer                             commandBuffer,
1075     const VkRenderPassBeginInfo*                pRenderPassBegin,
1076     const VkSubpassBeginInfoKHR*                pSubpassBeginInfo);
1077 bool PreCallValidateCmdNextSubpass2KHR(
1078     VkCommandBuffer                             commandBuffer,
1079     const VkSubpassBeginInfoKHR*                pSubpassBeginInfo,
1080     const VkSubpassEndInfoKHR*                  pSubpassEndInfo);
1081 bool PreCallValidateCmdEndRenderPass2KHR(
1082     VkCommandBuffer                             commandBuffer,
1083     const VkSubpassEndInfoKHR*                  pSubpassEndInfo);
1084 bool PreCallValidateGetSwapchainStatusKHR(
1085     VkDevice                                    device,
1086     VkSwapchainKHR                              swapchain);
1087 bool PreCallValidateGetPhysicalDeviceExternalFencePropertiesKHR(
1088     VkPhysicalDevice                            physicalDevice,
1089     const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
1090     VkExternalFenceProperties*                  pExternalFenceProperties);
1091 #ifdef VK_USE_PLATFORM_WIN32_KHR
1092 bool PreCallValidateImportFenceWin32HandleKHR(
1093     VkDevice                                    device,
1094     const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo);
1095 #endif
1096 #ifdef VK_USE_PLATFORM_WIN32_KHR
1097 bool PreCallValidateGetFenceWin32HandleKHR(
1098     VkDevice                                    device,
1099     const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
1100     HANDLE*                                     pHandle);
1101 #endif
1102 bool PreCallValidateImportFenceFdKHR(
1103     VkDevice                                    device,
1104     const VkImportFenceFdInfoKHR*               pImportFenceFdInfo);
1105 bool PreCallValidateGetFenceFdKHR(
1106     VkDevice                                    device,
1107     const VkFenceGetFdInfoKHR*                  pGetFdInfo,
1108     int*                                        pFd);
1109 bool PreCallValidateGetPhysicalDeviceSurfaceCapabilities2KHR(
1110     VkPhysicalDevice                            physicalDevice,
1111     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
1112     VkSurfaceCapabilities2KHR*                  pSurfaceCapabilities);
1113 bool PreCallValidateGetPhysicalDeviceSurfaceFormats2KHR(
1114     VkPhysicalDevice                            physicalDevice,
1115     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
1116     uint32_t*                                   pSurfaceFormatCount,
1117     VkSurfaceFormat2KHR*                        pSurfaceFormats);
1118 bool PreCallValidateGetPhysicalDeviceDisplayProperties2KHR(
1119     VkPhysicalDevice                            physicalDevice,
1120     uint32_t*                                   pPropertyCount,
1121     VkDisplayProperties2KHR*                    pProperties);
1122 bool PreCallValidateGetPhysicalDeviceDisplayPlaneProperties2KHR(
1123     VkPhysicalDevice                            physicalDevice,
1124     uint32_t*                                   pPropertyCount,
1125     VkDisplayPlaneProperties2KHR*               pProperties);
1126 bool PreCallValidateGetDisplayModeProperties2KHR(
1127     VkPhysicalDevice                            physicalDevice,
1128     VkDisplayKHR                                display,
1129     uint32_t*                                   pPropertyCount,
1130     VkDisplayModeProperties2KHR*                pProperties);
1131 bool PreCallValidateGetDisplayPlaneCapabilities2KHR(
1132     VkPhysicalDevice                            physicalDevice,
1133     const VkDisplayPlaneInfo2KHR*               pDisplayPlaneInfo,
1134     VkDisplayPlaneCapabilities2KHR*             pCapabilities);
1135 bool PreCallValidateGetImageMemoryRequirements2KHR(
1136     VkDevice                                    device,
1137     const VkImageMemoryRequirementsInfo2*       pInfo,
1138     VkMemoryRequirements2*                      pMemoryRequirements);
1139 bool PreCallValidateGetBufferMemoryRequirements2KHR(
1140     VkDevice                                    device,
1141     const VkBufferMemoryRequirementsInfo2*      pInfo,
1142     VkMemoryRequirements2*                      pMemoryRequirements);
1143 bool PreCallValidateGetImageSparseMemoryRequirements2KHR(
1144     VkDevice                                    device,
1145     const VkImageSparseMemoryRequirementsInfo2* pInfo,
1146     uint32_t*                                   pSparseMemoryRequirementCount,
1147     VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);
1148 bool PreCallValidateCreateSamplerYcbcrConversionKHR(
1149     VkDevice                                    device,
1150     const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
1151     const VkAllocationCallbacks*                pAllocator,
1152     VkSamplerYcbcrConversion*                   pYcbcrConversion);
1153 bool PreCallValidateDestroySamplerYcbcrConversionKHR(
1154     VkDevice                                    device,
1155     VkSamplerYcbcrConversion                    ycbcrConversion,
1156     const VkAllocationCallbacks*                pAllocator);
1157 bool PreCallValidateBindBufferMemory2KHR(
1158     VkDevice                                    device,
1159     uint32_t                                    bindInfoCount,
1160     const VkBindBufferMemoryInfo*               pBindInfos);
1161 bool PreCallValidateBindImageMemory2KHR(
1162     VkDevice                                    device,
1163     uint32_t                                    bindInfoCount,
1164     const VkBindImageMemoryInfo*                pBindInfos);
1165 bool PreCallValidateGetDescriptorSetLayoutSupportKHR(
1166     VkDevice                                    device,
1167     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
1168     VkDescriptorSetLayoutSupport*               pSupport);
1169 bool PreCallValidateCmdDrawIndirectCountKHR(
1170     VkCommandBuffer                             commandBuffer,
1171     VkBuffer                                    buffer,
1172     VkDeviceSize                                offset,
1173     VkBuffer                                    countBuffer,
1174     VkDeviceSize                                countBufferOffset,
1175     uint32_t                                    maxDrawCount,
1176     uint32_t                                    stride);
1177 bool PreCallValidateCmdDrawIndexedIndirectCountKHR(
1178     VkCommandBuffer                             commandBuffer,
1179     VkBuffer                                    buffer,
1180     VkDeviceSize                                offset,
1181     VkBuffer                                    countBuffer,
1182     VkDeviceSize                                countBufferOffset,
1183     uint32_t                                    maxDrawCount,
1184     uint32_t                                    stride);
1185 bool PreCallValidateGetPipelineExecutablePropertiesKHR(
1186     VkDevice                                    device,
1187     const VkPipelineInfoKHR*                    pPipelineInfo,
1188     uint32_t*                                   pExecutableCount,
1189     VkPipelineExecutablePropertiesKHR*          pProperties);
1190 bool PreCallValidateGetPipelineExecutableStatisticsKHR(
1191     VkDevice                                    device,
1192     const VkPipelineExecutableInfoKHR*          pExecutableInfo,
1193     uint32_t*                                   pStatisticCount,
1194     VkPipelineExecutableStatisticKHR*           pStatistics);
1195 bool PreCallValidateGetPipelineExecutableInternalRepresentationsKHR(
1196     VkDevice                                    device,
1197     const VkPipelineExecutableInfoKHR*          pExecutableInfo,
1198     uint32_t*                                   pInternalRepresentationCount,
1199     VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
1200 bool PreCallValidateCreateDebugReportCallbackEXT(
1201     VkInstance                                  instance,
1202     const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
1203     const VkAllocationCallbacks*                pAllocator,
1204     VkDebugReportCallbackEXT*                   pCallback);
1205 bool PreCallValidateDestroyDebugReportCallbackEXT(
1206     VkInstance                                  instance,
1207     VkDebugReportCallbackEXT                    callback,
1208     const VkAllocationCallbacks*                pAllocator);
1209 bool PreCallValidateDebugReportMessageEXT(
1210     VkInstance                                  instance,
1211     VkDebugReportFlagsEXT                       flags,
1212     VkDebugReportObjectTypeEXT                  objectType,
1213     uint64_t                                    object,
1214     size_t                                      location,
1215     int32_t                                     messageCode,
1216     const char*                                 pLayerPrefix,
1217     const char*                                 pMessage);
1218 bool PreCallValidateDebugMarkerSetObjectTagEXT(
1219     VkDevice                                    device,
1220     const VkDebugMarkerObjectTagInfoEXT*        pTagInfo);
1221 bool PreCallValidateDebugMarkerSetObjectNameEXT(
1222     VkDevice                                    device,
1223     const VkDebugMarkerObjectNameInfoEXT*       pNameInfo);
1224 bool PreCallValidateCmdDebugMarkerBeginEXT(
1225     VkCommandBuffer                             commandBuffer,
1226     const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
1227 bool PreCallValidateCmdDebugMarkerEndEXT(
1228     VkCommandBuffer                             commandBuffer);
1229 bool PreCallValidateCmdDebugMarkerInsertEXT(
1230     VkCommandBuffer                             commandBuffer,
1231     const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
1232 bool PreCallValidateCmdBindTransformFeedbackBuffersEXT(
1233     VkCommandBuffer                             commandBuffer,
1234     uint32_t                                    firstBinding,
1235     uint32_t                                    bindingCount,
1236     const VkBuffer*                             pBuffers,
1237     const VkDeviceSize*                         pOffsets,
1238     const VkDeviceSize*                         pSizes);
1239 bool PreCallValidateCmdBeginTransformFeedbackEXT(
1240     VkCommandBuffer                             commandBuffer,
1241     uint32_t                                    firstCounterBuffer,
1242     uint32_t                                    counterBufferCount,
1243     const VkBuffer*                             pCounterBuffers,
1244     const VkDeviceSize*                         pCounterBufferOffsets);
1245 bool PreCallValidateCmdEndTransformFeedbackEXT(
1246     VkCommandBuffer                             commandBuffer,
1247     uint32_t                                    firstCounterBuffer,
1248     uint32_t                                    counterBufferCount,
1249     const VkBuffer*                             pCounterBuffers,
1250     const VkDeviceSize*                         pCounterBufferOffsets);
1251 bool PreCallValidateCmdBeginQueryIndexedEXT(
1252     VkCommandBuffer                             commandBuffer,
1253     VkQueryPool                                 queryPool,
1254     uint32_t                                    query,
1255     VkQueryControlFlags                         flags,
1256     uint32_t                                    index);
1257 bool PreCallValidateCmdEndQueryIndexedEXT(
1258     VkCommandBuffer                             commandBuffer,
1259     VkQueryPool                                 queryPool,
1260     uint32_t                                    query,
1261     uint32_t                                    index);
1262 bool PreCallValidateCmdDrawIndirectByteCountEXT(
1263     VkCommandBuffer                             commandBuffer,
1264     uint32_t                                    instanceCount,
1265     uint32_t                                    firstInstance,
1266     VkBuffer                                    counterBuffer,
1267     VkDeviceSize                                counterBufferOffset,
1268     uint32_t                                    counterOffset,
1269     uint32_t                                    vertexStride);
1270 bool PreCallValidateGetImageViewHandleNVX(
1271     VkDevice                                    device,
1272     const VkImageViewHandleInfoNVX*             pInfo);
1273 bool PreCallValidateCmdDrawIndirectCountAMD(
1274     VkCommandBuffer                             commandBuffer,
1275     VkBuffer                                    buffer,
1276     VkDeviceSize                                offset,
1277     VkBuffer                                    countBuffer,
1278     VkDeviceSize                                countBufferOffset,
1279     uint32_t                                    maxDrawCount,
1280     uint32_t                                    stride);
1281 bool PreCallValidateCmdDrawIndexedIndirectCountAMD(
1282     VkCommandBuffer                             commandBuffer,
1283     VkBuffer                                    buffer,
1284     VkDeviceSize                                offset,
1285     VkBuffer                                    countBuffer,
1286     VkDeviceSize                                countBufferOffset,
1287     uint32_t                                    maxDrawCount,
1288     uint32_t                                    stride);
1289 bool PreCallValidateGetShaderInfoAMD(
1290     VkDevice                                    device,
1291     VkPipeline                                  pipeline,
1292     VkShaderStageFlagBits                       shaderStage,
1293     VkShaderInfoTypeAMD                         infoType,
1294     size_t*                                     pInfoSize,
1295     void*                                       pInfo);
1296 #ifdef VK_USE_PLATFORM_GGP
1297 bool PreCallValidateCreateStreamDescriptorSurfaceGGP(
1298     VkInstance                                  instance,
1299     const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
1300     const VkAllocationCallbacks*                pAllocator,
1301     VkSurfaceKHR*                               pSurface);
1302 #endif
1303 bool PreCallValidateGetPhysicalDeviceExternalImageFormatPropertiesNV(
1304     VkPhysicalDevice                            physicalDevice,
1305     VkFormat                                    format,
1306     VkImageType                                 type,
1307     VkImageTiling                               tiling,
1308     VkImageUsageFlags                           usage,
1309     VkImageCreateFlags                          flags,
1310     VkExternalMemoryHandleTypeFlagsNV           externalHandleType,
1311     VkExternalImageFormatPropertiesNV*          pExternalImageFormatProperties);
1312 #ifdef VK_USE_PLATFORM_WIN32_KHR
1313 bool PreCallValidateGetMemoryWin32HandleNV(
1314     VkDevice                                    device,
1315     VkDeviceMemory                              memory,
1316     VkExternalMemoryHandleTypeFlagsNV           handleType,
1317     HANDLE*                                     pHandle);
1318 #endif
1319 #ifdef VK_USE_PLATFORM_VI_NN
1320 bool PreCallValidateCreateViSurfaceNN(
1321     VkInstance                                  instance,
1322     const VkViSurfaceCreateInfoNN*              pCreateInfo,
1323     const VkAllocationCallbacks*                pAllocator,
1324     VkSurfaceKHR*                               pSurface);
1325 #endif
1326 bool PreCallValidateCmdBeginConditionalRenderingEXT(
1327     VkCommandBuffer                             commandBuffer,
1328     const VkConditionalRenderingBeginInfoEXT*   pConditionalRenderingBegin);
1329 bool PreCallValidateCmdEndConditionalRenderingEXT(
1330     VkCommandBuffer                             commandBuffer);
1331 bool PreCallValidateCmdProcessCommandsNVX(
1332     VkCommandBuffer                             commandBuffer,
1333     const VkCmdProcessCommandsInfoNVX*          pProcessCommandsInfo);
1334 bool PreCallValidateCmdReserveSpaceForCommandsNVX(
1335     VkCommandBuffer                             commandBuffer,
1336     const VkCmdReserveSpaceForCommandsInfoNVX*  pReserveSpaceInfo);
1337 bool PreCallValidateCreateIndirectCommandsLayoutNVX(
1338     VkDevice                                    device,
1339     const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
1340     const VkAllocationCallbacks*                pAllocator,
1341     VkIndirectCommandsLayoutNVX*                pIndirectCommandsLayout);
1342 bool PreCallValidateDestroyIndirectCommandsLayoutNVX(
1343     VkDevice                                    device,
1344     VkIndirectCommandsLayoutNVX                 indirectCommandsLayout,
1345     const VkAllocationCallbacks*                pAllocator);
1346 bool PreCallValidateCreateObjectTableNVX(
1347     VkDevice                                    device,
1348     const VkObjectTableCreateInfoNVX*           pCreateInfo,
1349     const VkAllocationCallbacks*                pAllocator,
1350     VkObjectTableNVX*                           pObjectTable);
1351 bool PreCallValidateDestroyObjectTableNVX(
1352     VkDevice                                    device,
1353     VkObjectTableNVX                            objectTable,
1354     const VkAllocationCallbacks*                pAllocator);
1355 bool PreCallValidateRegisterObjectsNVX(
1356     VkDevice                                    device,
1357     VkObjectTableNVX                            objectTable,
1358     uint32_t                                    objectCount,
1359     const VkObjectTableEntryNVX* const*         ppObjectTableEntries,
1360     const uint32_t*                             pObjectIndices);
1361 bool PreCallValidateUnregisterObjectsNVX(
1362     VkDevice                                    device,
1363     VkObjectTableNVX                            objectTable,
1364     uint32_t                                    objectCount,
1365     const VkObjectEntryTypeNVX*                 pObjectEntryTypes,
1366     const uint32_t*                             pObjectIndices);
1367 bool PreCallValidateGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
1368     VkPhysicalDevice                            physicalDevice,
1369     VkDeviceGeneratedCommandsFeaturesNVX*       pFeatures,
1370     VkDeviceGeneratedCommandsLimitsNVX*         pLimits);
1371 bool PreCallValidateCmdSetViewportWScalingNV(
1372     VkCommandBuffer                             commandBuffer,
1373     uint32_t                                    firstViewport,
1374     uint32_t                                    viewportCount,
1375     const VkViewportWScalingNV*                 pViewportWScalings);
1376 bool PreCallValidateReleaseDisplayEXT(
1377     VkPhysicalDevice                            physicalDevice,
1378     VkDisplayKHR                                display);
1379 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
1380 bool PreCallValidateAcquireXlibDisplayEXT(
1381     VkPhysicalDevice                            physicalDevice,
1382     Display*                                    dpy,
1383     VkDisplayKHR                                display);
1384 #endif
1385 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
1386 bool PreCallValidateGetRandROutputDisplayEXT(
1387     VkPhysicalDevice                            physicalDevice,
1388     Display*                                    dpy,
1389     RROutput                                    rrOutput,
1390     VkDisplayKHR*                               pDisplay);
1391 #endif
1392 bool PreCallValidateGetPhysicalDeviceSurfaceCapabilities2EXT(
1393     VkPhysicalDevice                            physicalDevice,
1394     VkSurfaceKHR                                surface,
1395     VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities);
1396 bool PreCallValidateDisplayPowerControlEXT(
1397     VkDevice                                    device,
1398     VkDisplayKHR                                display,
1399     const VkDisplayPowerInfoEXT*                pDisplayPowerInfo);
1400 bool PreCallValidateRegisterDeviceEventEXT(
1401     VkDevice                                    device,
1402     const VkDeviceEventInfoEXT*                 pDeviceEventInfo,
1403     const VkAllocationCallbacks*                pAllocator,
1404     VkFence*                                    pFence);
1405 bool PreCallValidateRegisterDisplayEventEXT(
1406     VkDevice                                    device,
1407     VkDisplayKHR                                display,
1408     const VkDisplayEventInfoEXT*                pDisplayEventInfo,
1409     const VkAllocationCallbacks*                pAllocator,
1410     VkFence*                                    pFence);
1411 bool PreCallValidateGetSwapchainCounterEXT(
1412     VkDevice                                    device,
1413     VkSwapchainKHR                              swapchain,
1414     VkSurfaceCounterFlagBitsEXT                 counter,
1415     uint64_t*                                   pCounterValue);
1416 bool PreCallValidateGetRefreshCycleDurationGOOGLE(
1417     VkDevice                                    device,
1418     VkSwapchainKHR                              swapchain,
1419     VkRefreshCycleDurationGOOGLE*               pDisplayTimingProperties);
1420 bool PreCallValidateGetPastPresentationTimingGOOGLE(
1421     VkDevice                                    device,
1422     VkSwapchainKHR                              swapchain,
1423     uint32_t*                                   pPresentationTimingCount,
1424     VkPastPresentationTimingGOOGLE*             pPresentationTimings);
1425 bool PreCallValidateCmdSetDiscardRectangleEXT(
1426     VkCommandBuffer                             commandBuffer,
1427     uint32_t                                    firstDiscardRectangle,
1428     uint32_t                                    discardRectangleCount,
1429     const VkRect2D*                             pDiscardRectangles);
1430 bool PreCallValidateSetHdrMetadataEXT(
1431     VkDevice                                    device,
1432     uint32_t                                    swapchainCount,
1433     const VkSwapchainKHR*                       pSwapchains,
1434     const VkHdrMetadataEXT*                     pMetadata);
1435 #ifdef VK_USE_PLATFORM_IOS_MVK
1436 bool PreCallValidateCreateIOSSurfaceMVK(
1437     VkInstance                                  instance,
1438     const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
1439     const VkAllocationCallbacks*                pAllocator,
1440     VkSurfaceKHR*                               pSurface);
1441 #endif
1442 #ifdef VK_USE_PLATFORM_MACOS_MVK
1443 bool PreCallValidateCreateMacOSSurfaceMVK(
1444     VkInstance                                  instance,
1445     const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
1446     const VkAllocationCallbacks*                pAllocator,
1447     VkSurfaceKHR*                               pSurface);
1448 #endif
1449 bool PreCallValidateSetDebugUtilsObjectNameEXT(
1450     VkDevice                                    device,
1451     const VkDebugUtilsObjectNameInfoEXT*        pNameInfo);
1452 bool PreCallValidateSetDebugUtilsObjectTagEXT(
1453     VkDevice                                    device,
1454     const VkDebugUtilsObjectTagInfoEXT*         pTagInfo);
1455 bool PreCallValidateQueueBeginDebugUtilsLabelEXT(
1456     VkQueue                                     queue,
1457     const VkDebugUtilsLabelEXT*                 pLabelInfo);
1458 bool PreCallValidateQueueEndDebugUtilsLabelEXT(
1459     VkQueue                                     queue);
1460 bool PreCallValidateQueueInsertDebugUtilsLabelEXT(
1461     VkQueue                                     queue,
1462     const VkDebugUtilsLabelEXT*                 pLabelInfo);
1463 bool PreCallValidateCmdBeginDebugUtilsLabelEXT(
1464     VkCommandBuffer                             commandBuffer,
1465     const VkDebugUtilsLabelEXT*                 pLabelInfo);
1466 bool PreCallValidateCmdEndDebugUtilsLabelEXT(
1467     VkCommandBuffer                             commandBuffer);
1468 bool PreCallValidateCmdInsertDebugUtilsLabelEXT(
1469     VkCommandBuffer                             commandBuffer,
1470     const VkDebugUtilsLabelEXT*                 pLabelInfo);
1471 bool PreCallValidateCreateDebugUtilsMessengerEXT(
1472     VkInstance                                  instance,
1473     const VkDebugUtilsMessengerCreateInfoEXT*   pCreateInfo,
1474     const VkAllocationCallbacks*                pAllocator,
1475     VkDebugUtilsMessengerEXT*                   pMessenger);
1476 bool PreCallValidateDestroyDebugUtilsMessengerEXT(
1477     VkInstance                                  instance,
1478     VkDebugUtilsMessengerEXT                    messenger,
1479     const VkAllocationCallbacks*                pAllocator);
1480 bool PreCallValidateSubmitDebugUtilsMessageEXT(
1481     VkInstance                                  instance,
1482     VkDebugUtilsMessageSeverityFlagBitsEXT      messageSeverity,
1483     VkDebugUtilsMessageTypeFlagsEXT             messageTypes,
1484     const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
1485 #ifdef VK_USE_PLATFORM_ANDROID_KHR
1486 bool PreCallValidateGetAndroidHardwareBufferPropertiesANDROID(
1487     VkDevice                                    device,
1488     const struct AHardwareBuffer*               buffer,
1489     VkAndroidHardwareBufferPropertiesANDROID*   pProperties);
1490 #endif
1491 #ifdef VK_USE_PLATFORM_ANDROID_KHR
1492 bool PreCallValidateGetMemoryAndroidHardwareBufferANDROID(
1493     VkDevice                                    device,
1494     const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
1495     struct AHardwareBuffer**                    pBuffer);
1496 #endif
1497 bool PreCallValidateCmdSetSampleLocationsEXT(
1498     VkCommandBuffer                             commandBuffer,
1499     const VkSampleLocationsInfoEXT*             pSampleLocationsInfo);
1500 bool PreCallValidateGetPhysicalDeviceMultisamplePropertiesEXT(
1501     VkPhysicalDevice                            physicalDevice,
1502     VkSampleCountFlagBits                       samples,
1503     VkMultisamplePropertiesEXT*                 pMultisampleProperties);
1504 bool PreCallValidateGetImageDrmFormatModifierPropertiesEXT(
1505     VkDevice                                    device,
1506     VkImage                                     image,
1507     VkImageDrmFormatModifierPropertiesEXT*      pProperties);
1508 bool PreCallValidateCreateValidationCacheEXT(
1509     VkDevice                                    device,
1510     const VkValidationCacheCreateInfoEXT*       pCreateInfo,
1511     const VkAllocationCallbacks*                pAllocator,
1512     VkValidationCacheEXT*                       pValidationCache);
1513 bool PreCallValidateDestroyValidationCacheEXT(
1514     VkDevice                                    device,
1515     VkValidationCacheEXT                        validationCache,
1516     const VkAllocationCallbacks*                pAllocator);
1517 bool PreCallValidateMergeValidationCachesEXT(
1518     VkDevice                                    device,
1519     VkValidationCacheEXT                        dstCache,
1520     uint32_t                                    srcCacheCount,
1521     const VkValidationCacheEXT*                 pSrcCaches);
1522 bool PreCallValidateGetValidationCacheDataEXT(
1523     VkDevice                                    device,
1524     VkValidationCacheEXT                        validationCache,
1525     size_t*                                     pDataSize,
1526     void*                                       pData);
1527 bool PreCallValidateCmdBindShadingRateImageNV(
1528     VkCommandBuffer                             commandBuffer,
1529     VkImageView                                 imageView,
1530     VkImageLayout                               imageLayout);
1531 bool PreCallValidateCmdSetViewportShadingRatePaletteNV(
1532     VkCommandBuffer                             commandBuffer,
1533     uint32_t                                    firstViewport,
1534     uint32_t                                    viewportCount,
1535     const VkShadingRatePaletteNV*               pShadingRatePalettes);
1536 bool PreCallValidateCmdSetCoarseSampleOrderNV(
1537     VkCommandBuffer                             commandBuffer,
1538     VkCoarseSampleOrderTypeNV                   sampleOrderType,
1539     uint32_t                                    customSampleOrderCount,
1540     const VkCoarseSampleOrderCustomNV*          pCustomSampleOrders);
1541 bool PreCallValidateCreateAccelerationStructureNV(
1542     VkDevice                                    device,
1543     const VkAccelerationStructureCreateInfoNV*  pCreateInfo,
1544     const VkAllocationCallbacks*                pAllocator,
1545     VkAccelerationStructureNV*                  pAccelerationStructure);
1546 bool PreCallValidateDestroyAccelerationStructureNV(
1547     VkDevice                                    device,
1548     VkAccelerationStructureNV                   accelerationStructure,
1549     const VkAllocationCallbacks*                pAllocator);
1550 bool PreCallValidateGetAccelerationStructureMemoryRequirementsNV(
1551     VkDevice                                    device,
1552     const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
1553     VkMemoryRequirements2KHR*                   pMemoryRequirements);
1554 bool PreCallValidateBindAccelerationStructureMemoryNV(
1555     VkDevice                                    device,
1556     uint32_t                                    bindInfoCount,
1557     const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);
1558 bool PreCallValidateCmdBuildAccelerationStructureNV(
1559     VkCommandBuffer                             commandBuffer,
1560     const VkAccelerationStructureInfoNV*        pInfo,
1561     VkBuffer                                    instanceData,
1562     VkDeviceSize                                instanceOffset,
1563     VkBool32                                    update,
1564     VkAccelerationStructureNV                   dst,
1565     VkAccelerationStructureNV                   src,
1566     VkBuffer                                    scratch,
1567     VkDeviceSize                                scratchOffset);
1568 bool PreCallValidateCmdCopyAccelerationStructureNV(
1569     VkCommandBuffer                             commandBuffer,
1570     VkAccelerationStructureNV                   dst,
1571     VkAccelerationStructureNV                   src,
1572     VkCopyAccelerationStructureModeNV           mode);
1573 bool PreCallValidateCmdTraceRaysNV(
1574     VkCommandBuffer                             commandBuffer,
1575     VkBuffer                                    raygenShaderBindingTableBuffer,
1576     VkDeviceSize                                raygenShaderBindingOffset,
1577     VkBuffer                                    missShaderBindingTableBuffer,
1578     VkDeviceSize                                missShaderBindingOffset,
1579     VkDeviceSize                                missShaderBindingStride,
1580     VkBuffer                                    hitShaderBindingTableBuffer,
1581     VkDeviceSize                                hitShaderBindingOffset,
1582     VkDeviceSize                                hitShaderBindingStride,
1583     VkBuffer                                    callableShaderBindingTableBuffer,
1584     VkDeviceSize                                callableShaderBindingOffset,
1585     VkDeviceSize                                callableShaderBindingStride,
1586     uint32_t                                    width,
1587     uint32_t                                    height,
1588     uint32_t                                    depth);
1589 bool PreCallValidateCreateRayTracingPipelinesNV(
1590     VkDevice                                    device,
1591     VkPipelineCache                             pipelineCache,
1592     uint32_t                                    createInfoCount,
1593     const VkRayTracingPipelineCreateInfoNV*     pCreateInfos,
1594     const VkAllocationCallbacks*                pAllocator,
1595     VkPipeline*                                 pPipelines);
1596 bool PreCallValidateGetRayTracingShaderGroupHandlesNV(
1597     VkDevice                                    device,
1598     VkPipeline                                  pipeline,
1599     uint32_t                                    firstGroup,
1600     uint32_t                                    groupCount,
1601     size_t                                      dataSize,
1602     void*                                       pData);
1603 bool PreCallValidateGetAccelerationStructureHandleNV(
1604     VkDevice                                    device,
1605     VkAccelerationStructureNV                   accelerationStructure,
1606     size_t                                      dataSize,
1607     void*                                       pData);
1608 bool PreCallValidateCmdWriteAccelerationStructuresPropertiesNV(
1609     VkCommandBuffer                             commandBuffer,
1610     uint32_t                                    accelerationStructureCount,
1611     const VkAccelerationStructureNV*            pAccelerationStructures,
1612     VkQueryType                                 queryType,
1613     VkQueryPool                                 queryPool,
1614     uint32_t                                    firstQuery);
1615 bool PreCallValidateCompileDeferredNV(
1616     VkDevice                                    device,
1617     VkPipeline                                  pipeline,
1618     uint32_t                                    shader);
1619 bool PreCallValidateGetMemoryHostPointerPropertiesEXT(
1620     VkDevice                                    device,
1621     VkExternalMemoryHandleTypeFlagBits          handleType,
1622     const void*                                 pHostPointer,
1623     VkMemoryHostPointerPropertiesEXT*           pMemoryHostPointerProperties);
1624 bool PreCallValidateCmdWriteBufferMarkerAMD(
1625     VkCommandBuffer                             commandBuffer,
1626     VkPipelineStageFlagBits                     pipelineStage,
1627     VkBuffer                                    dstBuffer,
1628     VkDeviceSize                                dstOffset,
1629     uint32_t                                    marker);
1630 bool PreCallValidateGetPhysicalDeviceCalibrateableTimeDomainsEXT(
1631     VkPhysicalDevice                            physicalDevice,
1632     uint32_t*                                   pTimeDomainCount,
1633     VkTimeDomainEXT*                            pTimeDomains);
1634 bool PreCallValidateGetCalibratedTimestampsEXT(
1635     VkDevice                                    device,
1636     uint32_t                                    timestampCount,
1637     const VkCalibratedTimestampInfoEXT*         pTimestampInfos,
1638     uint64_t*                                   pTimestamps,
1639     uint64_t*                                   pMaxDeviation);
1640 bool PreCallValidateCmdDrawMeshTasksNV(
1641     VkCommandBuffer                             commandBuffer,
1642     uint32_t                                    taskCount,
1643     uint32_t                                    firstTask);
1644 bool PreCallValidateCmdDrawMeshTasksIndirectNV(
1645     VkCommandBuffer                             commandBuffer,
1646     VkBuffer                                    buffer,
1647     VkDeviceSize                                offset,
1648     uint32_t                                    drawCount,
1649     uint32_t                                    stride);
1650 bool PreCallValidateCmdDrawMeshTasksIndirectCountNV(
1651     VkCommandBuffer                             commandBuffer,
1652     VkBuffer                                    buffer,
1653     VkDeviceSize                                offset,
1654     VkBuffer                                    countBuffer,
1655     VkDeviceSize                                countBufferOffset,
1656     uint32_t                                    maxDrawCount,
1657     uint32_t                                    stride);
1658 bool PreCallValidateCmdSetExclusiveScissorNV(
1659     VkCommandBuffer                             commandBuffer,
1660     uint32_t                                    firstExclusiveScissor,
1661     uint32_t                                    exclusiveScissorCount,
1662     const VkRect2D*                             pExclusiveScissors);
1663 bool PreCallValidateCmdSetCheckpointNV(
1664     VkCommandBuffer                             commandBuffer,
1665     const void*                                 pCheckpointMarker);
1666 bool PreCallValidateGetQueueCheckpointDataNV(
1667     VkQueue                                     queue,
1668     uint32_t*                                   pCheckpointDataCount,
1669     VkCheckpointDataNV*                         pCheckpointData);
1670 bool PreCallValidateInitializePerformanceApiINTEL(
1671     VkDevice                                    device,
1672     const VkInitializePerformanceApiInfoINTEL*  pInitializeInfo);
1673 bool PreCallValidateUninitializePerformanceApiINTEL(
1674     VkDevice                                    device);
1675 bool PreCallValidateCmdSetPerformanceMarkerINTEL(
1676     VkCommandBuffer                             commandBuffer,
1677     const VkPerformanceMarkerInfoINTEL*         pMarkerInfo);
1678 bool PreCallValidateCmdSetPerformanceStreamMarkerINTEL(
1679     VkCommandBuffer                             commandBuffer,
1680     const VkPerformanceStreamMarkerInfoINTEL*   pMarkerInfo);
1681 bool PreCallValidateCmdSetPerformanceOverrideINTEL(
1682     VkCommandBuffer                             commandBuffer,
1683     const VkPerformanceOverrideInfoINTEL*       pOverrideInfo);
1684 bool PreCallValidateAcquirePerformanceConfigurationINTEL(
1685     VkDevice                                    device,
1686     const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
1687     VkPerformanceConfigurationINTEL*            pConfiguration);
1688 bool PreCallValidateReleasePerformanceConfigurationINTEL(
1689     VkDevice                                    device,
1690     VkPerformanceConfigurationINTEL             configuration);
1691 bool PreCallValidateQueueSetPerformanceConfigurationINTEL(
1692     VkQueue                                     queue,
1693     VkPerformanceConfigurationINTEL             configuration);
1694 bool PreCallValidateGetPerformanceParameterINTEL(
1695     VkDevice                                    device,
1696     VkPerformanceParameterTypeINTEL             parameter,
1697     VkPerformanceValueINTEL*                    pValue);
1698 bool PreCallValidateSetLocalDimmingAMD(
1699     VkDevice                                    device,
1700     VkSwapchainKHR                              swapChain,
1701     VkBool32                                    localDimmingEnable);
1702 #ifdef VK_USE_PLATFORM_FUCHSIA
1703 bool PreCallValidateCreateImagePipeSurfaceFUCHSIA(
1704     VkInstance                                  instance,
1705     const VkImagePipeSurfaceCreateInfoFUCHSIA*  pCreateInfo,
1706     const VkAllocationCallbacks*                pAllocator,
1707     VkSurfaceKHR*                               pSurface);
1708 #endif
1709 #ifdef VK_USE_PLATFORM_METAL_EXT
1710 bool PreCallValidateCreateMetalSurfaceEXT(
1711     VkInstance                                  instance,
1712     const VkMetalSurfaceCreateInfoEXT*          pCreateInfo,
1713     const VkAllocationCallbacks*                pAllocator,
1714     VkSurfaceKHR*                               pSurface);
1715 #endif
1716 bool PreCallValidateGetBufferDeviceAddressEXT(
1717     VkDevice                                    device,
1718     const VkBufferDeviceAddressInfoEXT*         pInfo);
1719 bool PreCallValidateGetPhysicalDeviceCooperativeMatrixPropertiesNV(
1720     VkPhysicalDevice                            physicalDevice,
1721     uint32_t*                                   pPropertyCount,
1722     VkCooperativeMatrixPropertiesNV*            pProperties);
1723 bool PreCallValidateGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
1724     VkPhysicalDevice                            physicalDevice,
1725     uint32_t*                                   pCombinationCount,
1726     VkFramebufferMixedSamplesCombinationNV*     pCombinations);
1727 #ifdef VK_USE_PLATFORM_WIN32_KHR
1728 bool PreCallValidateGetPhysicalDeviceSurfacePresentModes2EXT(
1729     VkPhysicalDevice                            physicalDevice,
1730     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
1731     uint32_t*                                   pPresentModeCount,
1732     VkPresentModeKHR*                           pPresentModes);
1733 #endif
1734 #ifdef VK_USE_PLATFORM_WIN32_KHR
1735 bool PreCallValidateAcquireFullScreenExclusiveModeEXT(
1736     VkDevice                                    device,
1737     VkSwapchainKHR                              swapchain);
1738 #endif
1739 #ifdef VK_USE_PLATFORM_WIN32_KHR
1740 bool PreCallValidateReleaseFullScreenExclusiveModeEXT(
1741     VkDevice                                    device,
1742     VkSwapchainKHR                              swapchain);
1743 #endif
1744 bool PreCallValidateCreateHeadlessSurfaceEXT(
1745     VkInstance                                  instance,
1746     const VkHeadlessSurfaceCreateInfoEXT*       pCreateInfo,
1747     const VkAllocationCallbacks*                pAllocator,
1748     VkSurfaceKHR*                               pSurface);
1749 bool PreCallValidateCmdSetLineStippleEXT(
1750     VkCommandBuffer                             commandBuffer,
1751     uint32_t                                    lineStippleFactor,
1752     uint16_t                                    lineStipplePattern);
1753 bool PreCallValidateResetQueryPoolEXT(
1754     VkDevice                                    device,
1755     VkQueryPool                                 queryPool,
1756     uint32_t                                    firstQuery,
1757     uint32_t                                    queryCount);
1758