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