1 2 // This file is ***GENERATED***. Do Not Edit. 3 // See layer_chassis_generator.py for modifications. 4 5 /* Copyright (c) 2015-2019 The Khronos Group Inc. 6 * Copyright (c) 2015-2019 Valve Corporation 7 * Copyright (c) 2015-2019 LunarG, Inc. 8 * Copyright (c) 2015-2019 Google Inc. 9 * 10 * Licensed under the Apache License, Version 2.0 (the "License"); 11 * you may not use this file except in compliance with the License. 12 * You may obtain a copy of the License at 13 * 14 * http://www.apache.org/licenses/LICENSE-2.0 15 * 16 * Unless required by applicable law or agreed to in writing, software 17 * distributed under the License is distributed on an "AS IS" BASIS, 18 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 19 * See the License for the specific language governing permissions and 20 * limitations under the License. 21 * 22 * Author: Mark Lobodzinski <mark@lunarg.com> 23 */ 24 #pragma once 25 26 27 #define NOMINMAX 28 #include <atomic> 29 #include <mutex> 30 #include <cinttypes> 31 #include <stdio.h> 32 #include <stdlib.h> 33 #include <string.h> 34 #include <unordered_map> 35 #include <unordered_set> 36 #include <algorithm> 37 #include <memory> 38 39 #include "vk_loader_platform.h" 40 #include "vulkan/vulkan.h" 41 #include "vk_layer_config.h" 42 #include "vk_layer_data.h" 43 #include "vk_layer_logging.h" 44 #include "vk_object_types.h" 45 #include "vulkan/vk_layer.h" 46 #include "vk_enum_string_helper.h" 47 #include "vk_layer_extension_utils.h" 48 #include "vk_layer_utils.h" 49 #include "vulkan/vk_layer.h" 50 #include "vk_dispatch_table_helper.h" 51 #include "vk_extension_helper.h" 52 #include "vk_safe_struct.h" 53 #include "vk_typemap_helper.h" 54 55 56 extern std::atomic<uint64_t> global_unique_id; 57 extern vl_concurrent_unordered_map<uint64_t, uint64_t, 4> unique_id_mapping; 58 59 60 61 VKAPI_ATTR VkResult VKAPI_CALL CreateInstance( 62 const VkInstanceCreateInfo* pCreateInfo, 63 const VkAllocationCallbacks* pAllocator, 64 VkInstance* pInstance); 65 66 VKAPI_ATTR void VKAPI_CALL DestroyInstance( 67 VkInstance instance, 68 const VkAllocationCallbacks* pAllocator); 69 70 VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices( 71 VkInstance instance, 72 uint32_t* pPhysicalDeviceCount, 73 VkPhysicalDevice* pPhysicalDevices); 74 75 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures( 76 VkPhysicalDevice physicalDevice, 77 VkPhysicalDeviceFeatures* pFeatures); 78 79 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties( 80 VkPhysicalDevice physicalDevice, 81 VkFormat format, 82 VkFormatProperties* pFormatProperties); 83 84 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties( 85 VkPhysicalDevice physicalDevice, 86 VkFormat format, 87 VkImageType type, 88 VkImageTiling tiling, 89 VkImageUsageFlags usage, 90 VkImageCreateFlags flags, 91 VkImageFormatProperties* pImageFormatProperties); 92 93 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties( 94 VkPhysicalDevice physicalDevice, 95 VkPhysicalDeviceProperties* pProperties); 96 97 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties( 98 VkPhysicalDevice physicalDevice, 99 uint32_t* pQueueFamilyPropertyCount, 100 VkQueueFamilyProperties* pQueueFamilyProperties); 101 102 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties( 103 VkPhysicalDevice physicalDevice, 104 VkPhysicalDeviceMemoryProperties* pMemoryProperties); 105 106 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr( 107 VkInstance instance, 108 const char* pName); 109 110 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr( 111 VkDevice device, 112 const char* pName); 113 114 VKAPI_ATTR VkResult VKAPI_CALL CreateDevice( 115 VkPhysicalDevice physicalDevice, 116 const VkDeviceCreateInfo* pCreateInfo, 117 const VkAllocationCallbacks* pAllocator, 118 VkDevice* pDevice); 119 120 VKAPI_ATTR void VKAPI_CALL DestroyDevice( 121 VkDevice device, 122 const VkAllocationCallbacks* pAllocator); 123 124 VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties( 125 const char* pLayerName, 126 uint32_t* pPropertyCount, 127 VkExtensionProperties* pProperties); 128 129 VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties( 130 VkPhysicalDevice physicalDevice, 131 const char* pLayerName, 132 uint32_t* pPropertyCount, 133 VkExtensionProperties* pProperties); 134 135 VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties( 136 uint32_t* pPropertyCount, 137 VkLayerProperties* pProperties); 138 139 VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties( 140 VkPhysicalDevice physicalDevice, 141 uint32_t* pPropertyCount, 142 VkLayerProperties* pProperties); 143 144 VKAPI_ATTR void VKAPI_CALL GetDeviceQueue( 145 VkDevice device, 146 uint32_t queueFamilyIndex, 147 uint32_t queueIndex, 148 VkQueue* pQueue); 149 150 VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit( 151 VkQueue queue, 152 uint32_t submitCount, 153 const VkSubmitInfo* pSubmits, 154 VkFence fence); 155 156 VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle( 157 VkQueue queue); 158 159 VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle( 160 VkDevice device); 161 162 VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory( 163 VkDevice device, 164 const VkMemoryAllocateInfo* pAllocateInfo, 165 const VkAllocationCallbacks* pAllocator, 166 VkDeviceMemory* pMemory); 167 168 VKAPI_ATTR void VKAPI_CALL FreeMemory( 169 VkDevice device, 170 VkDeviceMemory memory, 171 const VkAllocationCallbacks* pAllocator); 172 173 VKAPI_ATTR VkResult VKAPI_CALL MapMemory( 174 VkDevice device, 175 VkDeviceMemory memory, 176 VkDeviceSize offset, 177 VkDeviceSize size, 178 VkMemoryMapFlags flags, 179 void** ppData); 180 181 VKAPI_ATTR void VKAPI_CALL UnmapMemory( 182 VkDevice device, 183 VkDeviceMemory memory); 184 185 VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges( 186 VkDevice device, 187 uint32_t memoryRangeCount, 188 const VkMappedMemoryRange* pMemoryRanges); 189 190 VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges( 191 VkDevice device, 192 uint32_t memoryRangeCount, 193 const VkMappedMemoryRange* pMemoryRanges); 194 195 VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment( 196 VkDevice device, 197 VkDeviceMemory memory, 198 VkDeviceSize* pCommittedMemoryInBytes); 199 200 VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory( 201 VkDevice device, 202 VkBuffer buffer, 203 VkDeviceMemory memory, 204 VkDeviceSize memoryOffset); 205 206 VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory( 207 VkDevice device, 208 VkImage image, 209 VkDeviceMemory memory, 210 VkDeviceSize memoryOffset); 211 212 VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements( 213 VkDevice device, 214 VkBuffer buffer, 215 VkMemoryRequirements* pMemoryRequirements); 216 217 VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements( 218 VkDevice device, 219 VkImage image, 220 VkMemoryRequirements* pMemoryRequirements); 221 222 VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements( 223 VkDevice device, 224 VkImage image, 225 uint32_t* pSparseMemoryRequirementCount, 226 VkSparseImageMemoryRequirements* pSparseMemoryRequirements); 227 228 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties( 229 VkPhysicalDevice physicalDevice, 230 VkFormat format, 231 VkImageType type, 232 VkSampleCountFlagBits samples, 233 VkImageUsageFlags usage, 234 VkImageTiling tiling, 235 uint32_t* pPropertyCount, 236 VkSparseImageFormatProperties* pProperties); 237 238 VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse( 239 VkQueue queue, 240 uint32_t bindInfoCount, 241 const VkBindSparseInfo* pBindInfo, 242 VkFence fence); 243 244 VKAPI_ATTR VkResult VKAPI_CALL CreateFence( 245 VkDevice device, 246 const VkFenceCreateInfo* pCreateInfo, 247 const VkAllocationCallbacks* pAllocator, 248 VkFence* pFence); 249 250 VKAPI_ATTR void VKAPI_CALL DestroyFence( 251 VkDevice device, 252 VkFence fence, 253 const VkAllocationCallbacks* pAllocator); 254 255 VKAPI_ATTR VkResult VKAPI_CALL ResetFences( 256 VkDevice device, 257 uint32_t fenceCount, 258 const VkFence* pFences); 259 260 VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus( 261 VkDevice device, 262 VkFence fence); 263 264 VKAPI_ATTR VkResult VKAPI_CALL WaitForFences( 265 VkDevice device, 266 uint32_t fenceCount, 267 const VkFence* pFences, 268 VkBool32 waitAll, 269 uint64_t timeout); 270 271 VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore( 272 VkDevice device, 273 const VkSemaphoreCreateInfo* pCreateInfo, 274 const VkAllocationCallbacks* pAllocator, 275 VkSemaphore* pSemaphore); 276 277 VKAPI_ATTR void VKAPI_CALL DestroySemaphore( 278 VkDevice device, 279 VkSemaphore semaphore, 280 const VkAllocationCallbacks* pAllocator); 281 282 VKAPI_ATTR VkResult VKAPI_CALL CreateEvent( 283 VkDevice device, 284 const VkEventCreateInfo* pCreateInfo, 285 const VkAllocationCallbacks* pAllocator, 286 VkEvent* pEvent); 287 288 VKAPI_ATTR void VKAPI_CALL DestroyEvent( 289 VkDevice device, 290 VkEvent event, 291 const VkAllocationCallbacks* pAllocator); 292 293 VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus( 294 VkDevice device, 295 VkEvent event); 296 297 VKAPI_ATTR VkResult VKAPI_CALL SetEvent( 298 VkDevice device, 299 VkEvent event); 300 301 VKAPI_ATTR VkResult VKAPI_CALL ResetEvent( 302 VkDevice device, 303 VkEvent event); 304 305 VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool( 306 VkDevice device, 307 const VkQueryPoolCreateInfo* pCreateInfo, 308 const VkAllocationCallbacks* pAllocator, 309 VkQueryPool* pQueryPool); 310 311 VKAPI_ATTR void VKAPI_CALL DestroyQueryPool( 312 VkDevice device, 313 VkQueryPool queryPool, 314 const VkAllocationCallbacks* pAllocator); 315 316 VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults( 317 VkDevice device, 318 VkQueryPool queryPool, 319 uint32_t firstQuery, 320 uint32_t queryCount, 321 size_t dataSize, 322 void* pData, 323 VkDeviceSize stride, 324 VkQueryResultFlags flags); 325 326 VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer( 327 VkDevice device, 328 const VkBufferCreateInfo* pCreateInfo, 329 const VkAllocationCallbacks* pAllocator, 330 VkBuffer* pBuffer); 331 332 VKAPI_ATTR void VKAPI_CALL DestroyBuffer( 333 VkDevice device, 334 VkBuffer buffer, 335 const VkAllocationCallbacks* pAllocator); 336 337 VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView( 338 VkDevice device, 339 const VkBufferViewCreateInfo* pCreateInfo, 340 const VkAllocationCallbacks* pAllocator, 341 VkBufferView* pView); 342 343 VKAPI_ATTR void VKAPI_CALL DestroyBufferView( 344 VkDevice device, 345 VkBufferView bufferView, 346 const VkAllocationCallbacks* pAllocator); 347 348 VKAPI_ATTR VkResult VKAPI_CALL CreateImage( 349 VkDevice device, 350 const VkImageCreateInfo* pCreateInfo, 351 const VkAllocationCallbacks* pAllocator, 352 VkImage* pImage); 353 354 VKAPI_ATTR void VKAPI_CALL DestroyImage( 355 VkDevice device, 356 VkImage image, 357 const VkAllocationCallbacks* pAllocator); 358 359 VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout( 360 VkDevice device, 361 VkImage image, 362 const VkImageSubresource* pSubresource, 363 VkSubresourceLayout* pLayout); 364 365 VKAPI_ATTR VkResult VKAPI_CALL CreateImageView( 366 VkDevice device, 367 const VkImageViewCreateInfo* pCreateInfo, 368 const VkAllocationCallbacks* pAllocator, 369 VkImageView* pView); 370 371 VKAPI_ATTR void VKAPI_CALL DestroyImageView( 372 VkDevice device, 373 VkImageView imageView, 374 const VkAllocationCallbacks* pAllocator); 375 376 VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule( 377 VkDevice device, 378 const VkShaderModuleCreateInfo* pCreateInfo, 379 const VkAllocationCallbacks* pAllocator, 380 VkShaderModule* pShaderModule); 381 382 VKAPI_ATTR void VKAPI_CALL DestroyShaderModule( 383 VkDevice device, 384 VkShaderModule shaderModule, 385 const VkAllocationCallbacks* pAllocator); 386 387 VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache( 388 VkDevice device, 389 const VkPipelineCacheCreateInfo* pCreateInfo, 390 const VkAllocationCallbacks* pAllocator, 391 VkPipelineCache* pPipelineCache); 392 393 VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache( 394 VkDevice device, 395 VkPipelineCache pipelineCache, 396 const VkAllocationCallbacks* pAllocator); 397 398 VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData( 399 VkDevice device, 400 VkPipelineCache pipelineCache, 401 size_t* pDataSize, 402 void* pData); 403 404 VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches( 405 VkDevice device, 406 VkPipelineCache dstCache, 407 uint32_t srcCacheCount, 408 const VkPipelineCache* pSrcCaches); 409 410 VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines( 411 VkDevice device, 412 VkPipelineCache pipelineCache, 413 uint32_t createInfoCount, 414 const VkGraphicsPipelineCreateInfo* pCreateInfos, 415 const VkAllocationCallbacks* pAllocator, 416 VkPipeline* pPipelines); 417 418 VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines( 419 VkDevice device, 420 VkPipelineCache pipelineCache, 421 uint32_t createInfoCount, 422 const VkComputePipelineCreateInfo* pCreateInfos, 423 const VkAllocationCallbacks* pAllocator, 424 VkPipeline* pPipelines); 425 426 VKAPI_ATTR void VKAPI_CALL DestroyPipeline( 427 VkDevice device, 428 VkPipeline pipeline, 429 const VkAllocationCallbacks* pAllocator); 430 431 VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout( 432 VkDevice device, 433 const VkPipelineLayoutCreateInfo* pCreateInfo, 434 const VkAllocationCallbacks* pAllocator, 435 VkPipelineLayout* pPipelineLayout); 436 437 VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout( 438 VkDevice device, 439 VkPipelineLayout pipelineLayout, 440 const VkAllocationCallbacks* pAllocator); 441 442 VKAPI_ATTR VkResult VKAPI_CALL CreateSampler( 443 VkDevice device, 444 const VkSamplerCreateInfo* pCreateInfo, 445 const VkAllocationCallbacks* pAllocator, 446 VkSampler* pSampler); 447 448 VKAPI_ATTR void VKAPI_CALL DestroySampler( 449 VkDevice device, 450 VkSampler sampler, 451 const VkAllocationCallbacks* pAllocator); 452 453 VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout( 454 VkDevice device, 455 const VkDescriptorSetLayoutCreateInfo* pCreateInfo, 456 const VkAllocationCallbacks* pAllocator, 457 VkDescriptorSetLayout* pSetLayout); 458 459 VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout( 460 VkDevice device, 461 VkDescriptorSetLayout descriptorSetLayout, 462 const VkAllocationCallbacks* pAllocator); 463 464 VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool( 465 VkDevice device, 466 const VkDescriptorPoolCreateInfo* pCreateInfo, 467 const VkAllocationCallbacks* pAllocator, 468 VkDescriptorPool* pDescriptorPool); 469 470 VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool( 471 VkDevice device, 472 VkDescriptorPool descriptorPool, 473 const VkAllocationCallbacks* pAllocator); 474 475 VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool( 476 VkDevice device, 477 VkDescriptorPool descriptorPool, 478 VkDescriptorPoolResetFlags flags); 479 480 VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets( 481 VkDevice device, 482 const VkDescriptorSetAllocateInfo* pAllocateInfo, 483 VkDescriptorSet* pDescriptorSets); 484 485 VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets( 486 VkDevice device, 487 VkDescriptorPool descriptorPool, 488 uint32_t descriptorSetCount, 489 const VkDescriptorSet* pDescriptorSets); 490 491 VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets( 492 VkDevice device, 493 uint32_t descriptorWriteCount, 494 const VkWriteDescriptorSet* pDescriptorWrites, 495 uint32_t descriptorCopyCount, 496 const VkCopyDescriptorSet* pDescriptorCopies); 497 498 VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer( 499 VkDevice device, 500 const VkFramebufferCreateInfo* pCreateInfo, 501 const VkAllocationCallbacks* pAllocator, 502 VkFramebuffer* pFramebuffer); 503 504 VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer( 505 VkDevice device, 506 VkFramebuffer framebuffer, 507 const VkAllocationCallbacks* pAllocator); 508 509 VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass( 510 VkDevice device, 511 const VkRenderPassCreateInfo* pCreateInfo, 512 const VkAllocationCallbacks* pAllocator, 513 VkRenderPass* pRenderPass); 514 515 VKAPI_ATTR void VKAPI_CALL DestroyRenderPass( 516 VkDevice device, 517 VkRenderPass renderPass, 518 const VkAllocationCallbacks* pAllocator); 519 520 VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity( 521 VkDevice device, 522 VkRenderPass renderPass, 523 VkExtent2D* pGranularity); 524 525 VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool( 526 VkDevice device, 527 const VkCommandPoolCreateInfo* pCreateInfo, 528 const VkAllocationCallbacks* pAllocator, 529 VkCommandPool* pCommandPool); 530 531 VKAPI_ATTR void VKAPI_CALL DestroyCommandPool( 532 VkDevice device, 533 VkCommandPool commandPool, 534 const VkAllocationCallbacks* pAllocator); 535 536 VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool( 537 VkDevice device, 538 VkCommandPool commandPool, 539 VkCommandPoolResetFlags flags); 540 541 VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers( 542 VkDevice device, 543 const VkCommandBufferAllocateInfo* pAllocateInfo, 544 VkCommandBuffer* pCommandBuffers); 545 546 VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers( 547 VkDevice device, 548 VkCommandPool commandPool, 549 uint32_t commandBufferCount, 550 const VkCommandBuffer* pCommandBuffers); 551 552 VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer( 553 VkCommandBuffer commandBuffer, 554 const VkCommandBufferBeginInfo* pBeginInfo); 555 556 VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer( 557 VkCommandBuffer commandBuffer); 558 559 VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer( 560 VkCommandBuffer commandBuffer, 561 VkCommandBufferResetFlags flags); 562 563 VKAPI_ATTR void VKAPI_CALL CmdBindPipeline( 564 VkCommandBuffer commandBuffer, 565 VkPipelineBindPoint pipelineBindPoint, 566 VkPipeline pipeline); 567 568 VKAPI_ATTR void VKAPI_CALL CmdSetViewport( 569 VkCommandBuffer commandBuffer, 570 uint32_t firstViewport, 571 uint32_t viewportCount, 572 const VkViewport* pViewports); 573 574 VKAPI_ATTR void VKAPI_CALL CmdSetScissor( 575 VkCommandBuffer commandBuffer, 576 uint32_t firstScissor, 577 uint32_t scissorCount, 578 const VkRect2D* pScissors); 579 580 VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth( 581 VkCommandBuffer commandBuffer, 582 float lineWidth); 583 584 VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias( 585 VkCommandBuffer commandBuffer, 586 float depthBiasConstantFactor, 587 float depthBiasClamp, 588 float depthBiasSlopeFactor); 589 590 VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants( 591 VkCommandBuffer commandBuffer, 592 const float blendConstants[4]); 593 594 VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds( 595 VkCommandBuffer commandBuffer, 596 float minDepthBounds, 597 float maxDepthBounds); 598 599 VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask( 600 VkCommandBuffer commandBuffer, 601 VkStencilFaceFlags faceMask, 602 uint32_t compareMask); 603 604 VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask( 605 VkCommandBuffer commandBuffer, 606 VkStencilFaceFlags faceMask, 607 uint32_t writeMask); 608 609 VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference( 610 VkCommandBuffer commandBuffer, 611 VkStencilFaceFlags faceMask, 612 uint32_t reference); 613 614 VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets( 615 VkCommandBuffer commandBuffer, 616 VkPipelineBindPoint pipelineBindPoint, 617 VkPipelineLayout layout, 618 uint32_t firstSet, 619 uint32_t descriptorSetCount, 620 const VkDescriptorSet* pDescriptorSets, 621 uint32_t dynamicOffsetCount, 622 const uint32_t* pDynamicOffsets); 623 624 VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer( 625 VkCommandBuffer commandBuffer, 626 VkBuffer buffer, 627 VkDeviceSize offset, 628 VkIndexType indexType); 629 630 VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers( 631 VkCommandBuffer commandBuffer, 632 uint32_t firstBinding, 633 uint32_t bindingCount, 634 const VkBuffer* pBuffers, 635 const VkDeviceSize* pOffsets); 636 637 VKAPI_ATTR void VKAPI_CALL CmdDraw( 638 VkCommandBuffer commandBuffer, 639 uint32_t vertexCount, 640 uint32_t instanceCount, 641 uint32_t firstVertex, 642 uint32_t firstInstance); 643 644 VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed( 645 VkCommandBuffer commandBuffer, 646 uint32_t indexCount, 647 uint32_t instanceCount, 648 uint32_t firstIndex, 649 int32_t vertexOffset, 650 uint32_t firstInstance); 651 652 VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect( 653 VkCommandBuffer commandBuffer, 654 VkBuffer buffer, 655 VkDeviceSize offset, 656 uint32_t drawCount, 657 uint32_t stride); 658 659 VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect( 660 VkCommandBuffer commandBuffer, 661 VkBuffer buffer, 662 VkDeviceSize offset, 663 uint32_t drawCount, 664 uint32_t stride); 665 666 VKAPI_ATTR void VKAPI_CALL CmdDispatch( 667 VkCommandBuffer commandBuffer, 668 uint32_t groupCountX, 669 uint32_t groupCountY, 670 uint32_t groupCountZ); 671 672 VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect( 673 VkCommandBuffer commandBuffer, 674 VkBuffer buffer, 675 VkDeviceSize offset); 676 677 VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer( 678 VkCommandBuffer commandBuffer, 679 VkBuffer srcBuffer, 680 VkBuffer dstBuffer, 681 uint32_t regionCount, 682 const VkBufferCopy* pRegions); 683 684 VKAPI_ATTR void VKAPI_CALL CmdCopyImage( 685 VkCommandBuffer commandBuffer, 686 VkImage srcImage, 687 VkImageLayout srcImageLayout, 688 VkImage dstImage, 689 VkImageLayout dstImageLayout, 690 uint32_t regionCount, 691 const VkImageCopy* pRegions); 692 693 VKAPI_ATTR void VKAPI_CALL CmdBlitImage( 694 VkCommandBuffer commandBuffer, 695 VkImage srcImage, 696 VkImageLayout srcImageLayout, 697 VkImage dstImage, 698 VkImageLayout dstImageLayout, 699 uint32_t regionCount, 700 const VkImageBlit* pRegions, 701 VkFilter filter); 702 703 VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage( 704 VkCommandBuffer commandBuffer, 705 VkBuffer srcBuffer, 706 VkImage dstImage, 707 VkImageLayout dstImageLayout, 708 uint32_t regionCount, 709 const VkBufferImageCopy* pRegions); 710 711 VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer( 712 VkCommandBuffer commandBuffer, 713 VkImage srcImage, 714 VkImageLayout srcImageLayout, 715 VkBuffer dstBuffer, 716 uint32_t regionCount, 717 const VkBufferImageCopy* pRegions); 718 719 VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer( 720 VkCommandBuffer commandBuffer, 721 VkBuffer dstBuffer, 722 VkDeviceSize dstOffset, 723 VkDeviceSize dataSize, 724 const void* pData); 725 726 VKAPI_ATTR void VKAPI_CALL CmdFillBuffer( 727 VkCommandBuffer commandBuffer, 728 VkBuffer dstBuffer, 729 VkDeviceSize dstOffset, 730 VkDeviceSize size, 731 uint32_t data); 732 733 VKAPI_ATTR void VKAPI_CALL CmdClearColorImage( 734 VkCommandBuffer commandBuffer, 735 VkImage image, 736 VkImageLayout imageLayout, 737 const VkClearColorValue* pColor, 738 uint32_t rangeCount, 739 const VkImageSubresourceRange* pRanges); 740 741 VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage( 742 VkCommandBuffer commandBuffer, 743 VkImage image, 744 VkImageLayout imageLayout, 745 const VkClearDepthStencilValue* pDepthStencil, 746 uint32_t rangeCount, 747 const VkImageSubresourceRange* pRanges); 748 749 VKAPI_ATTR void VKAPI_CALL CmdClearAttachments( 750 VkCommandBuffer commandBuffer, 751 uint32_t attachmentCount, 752 const VkClearAttachment* pAttachments, 753 uint32_t rectCount, 754 const VkClearRect* pRects); 755 756 VKAPI_ATTR void VKAPI_CALL CmdResolveImage( 757 VkCommandBuffer commandBuffer, 758 VkImage srcImage, 759 VkImageLayout srcImageLayout, 760 VkImage dstImage, 761 VkImageLayout dstImageLayout, 762 uint32_t regionCount, 763 const VkImageResolve* pRegions); 764 765 VKAPI_ATTR void VKAPI_CALL CmdSetEvent( 766 VkCommandBuffer commandBuffer, 767 VkEvent event, 768 VkPipelineStageFlags stageMask); 769 770 VKAPI_ATTR void VKAPI_CALL CmdResetEvent( 771 VkCommandBuffer commandBuffer, 772 VkEvent event, 773 VkPipelineStageFlags stageMask); 774 775 VKAPI_ATTR void VKAPI_CALL CmdWaitEvents( 776 VkCommandBuffer commandBuffer, 777 uint32_t eventCount, 778 const VkEvent* pEvents, 779 VkPipelineStageFlags srcStageMask, 780 VkPipelineStageFlags dstStageMask, 781 uint32_t memoryBarrierCount, 782 const VkMemoryBarrier* pMemoryBarriers, 783 uint32_t bufferMemoryBarrierCount, 784 const VkBufferMemoryBarrier* pBufferMemoryBarriers, 785 uint32_t imageMemoryBarrierCount, 786 const VkImageMemoryBarrier* pImageMemoryBarriers); 787 788 VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier( 789 VkCommandBuffer commandBuffer, 790 VkPipelineStageFlags srcStageMask, 791 VkPipelineStageFlags dstStageMask, 792 VkDependencyFlags dependencyFlags, 793 uint32_t memoryBarrierCount, 794 const VkMemoryBarrier* pMemoryBarriers, 795 uint32_t bufferMemoryBarrierCount, 796 const VkBufferMemoryBarrier* pBufferMemoryBarriers, 797 uint32_t imageMemoryBarrierCount, 798 const VkImageMemoryBarrier* pImageMemoryBarriers); 799 800 VKAPI_ATTR void VKAPI_CALL CmdBeginQuery( 801 VkCommandBuffer commandBuffer, 802 VkQueryPool queryPool, 803 uint32_t query, 804 VkQueryControlFlags flags); 805 806 VKAPI_ATTR void VKAPI_CALL CmdEndQuery( 807 VkCommandBuffer commandBuffer, 808 VkQueryPool queryPool, 809 uint32_t query); 810 811 VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool( 812 VkCommandBuffer commandBuffer, 813 VkQueryPool queryPool, 814 uint32_t firstQuery, 815 uint32_t queryCount); 816 817 VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp( 818 VkCommandBuffer commandBuffer, 819 VkPipelineStageFlagBits pipelineStage, 820 VkQueryPool queryPool, 821 uint32_t query); 822 823 VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults( 824 VkCommandBuffer commandBuffer, 825 VkQueryPool queryPool, 826 uint32_t firstQuery, 827 uint32_t queryCount, 828 VkBuffer dstBuffer, 829 VkDeviceSize dstOffset, 830 VkDeviceSize stride, 831 VkQueryResultFlags flags); 832 833 VKAPI_ATTR void VKAPI_CALL CmdPushConstants( 834 VkCommandBuffer commandBuffer, 835 VkPipelineLayout layout, 836 VkShaderStageFlags stageFlags, 837 uint32_t offset, 838 uint32_t size, 839 const void* pValues); 840 841 VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass( 842 VkCommandBuffer commandBuffer, 843 const VkRenderPassBeginInfo* pRenderPassBegin, 844 VkSubpassContents contents); 845 846 VKAPI_ATTR void VKAPI_CALL CmdNextSubpass( 847 VkCommandBuffer commandBuffer, 848 VkSubpassContents contents); 849 850 VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass( 851 VkCommandBuffer commandBuffer); 852 853 VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands( 854 VkCommandBuffer commandBuffer, 855 uint32_t commandBufferCount, 856 const VkCommandBuffer* pCommandBuffers); 857 858 859 VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2( 860 VkDevice device, 861 uint32_t bindInfoCount, 862 const VkBindBufferMemoryInfo* pBindInfos); 863 864 VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2( 865 VkDevice device, 866 uint32_t bindInfoCount, 867 const VkBindImageMemoryInfo* pBindInfos); 868 869 VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeatures( 870 VkDevice device, 871 uint32_t heapIndex, 872 uint32_t localDeviceIndex, 873 uint32_t remoteDeviceIndex, 874 VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); 875 876 VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMask( 877 VkCommandBuffer commandBuffer, 878 uint32_t deviceMask); 879 880 VKAPI_ATTR void VKAPI_CALL CmdDispatchBase( 881 VkCommandBuffer commandBuffer, 882 uint32_t baseGroupX, 883 uint32_t baseGroupY, 884 uint32_t baseGroupZ, 885 uint32_t groupCountX, 886 uint32_t groupCountY, 887 uint32_t groupCountZ); 888 889 VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroups( 890 VkInstance instance, 891 uint32_t* pPhysicalDeviceGroupCount, 892 VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); 893 894 VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2( 895 VkDevice device, 896 const VkImageMemoryRequirementsInfo2* pInfo, 897 VkMemoryRequirements2* pMemoryRequirements); 898 899 VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2( 900 VkDevice device, 901 const VkBufferMemoryRequirementsInfo2* pInfo, 902 VkMemoryRequirements2* pMemoryRequirements); 903 904 VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2( 905 VkDevice device, 906 const VkImageSparseMemoryRequirementsInfo2* pInfo, 907 uint32_t* pSparseMemoryRequirementCount, 908 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); 909 910 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2( 911 VkPhysicalDevice physicalDevice, 912 VkPhysicalDeviceFeatures2* pFeatures); 913 914 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2( 915 VkPhysicalDevice physicalDevice, 916 VkPhysicalDeviceProperties2* pProperties); 917 918 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2( 919 VkPhysicalDevice physicalDevice, 920 VkFormat format, 921 VkFormatProperties2* pFormatProperties); 922 923 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2( 924 VkPhysicalDevice physicalDevice, 925 const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, 926 VkImageFormatProperties2* pImageFormatProperties); 927 928 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2( 929 VkPhysicalDevice physicalDevice, 930 uint32_t* pQueueFamilyPropertyCount, 931 VkQueueFamilyProperties2* pQueueFamilyProperties); 932 933 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2( 934 VkPhysicalDevice physicalDevice, 935 VkPhysicalDeviceMemoryProperties2* pMemoryProperties); 936 937 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2( 938 VkPhysicalDevice physicalDevice, 939 const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, 940 uint32_t* pPropertyCount, 941 VkSparseImageFormatProperties2* pProperties); 942 943 VKAPI_ATTR void VKAPI_CALL TrimCommandPool( 944 VkDevice device, 945 VkCommandPool commandPool, 946 VkCommandPoolTrimFlags flags); 947 948 VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2( 949 VkDevice device, 950 const VkDeviceQueueInfo2* pQueueInfo, 951 VkQueue* pQueue); 952 953 VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversion( 954 VkDevice device, 955 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, 956 const VkAllocationCallbacks* pAllocator, 957 VkSamplerYcbcrConversion* pYcbcrConversion); 958 959 VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversion( 960 VkDevice device, 961 VkSamplerYcbcrConversion ycbcrConversion, 962 const VkAllocationCallbacks* pAllocator); 963 964 VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate( 965 VkDevice device, 966 const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, 967 const VkAllocationCallbacks* pAllocator, 968 VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); 969 970 VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate( 971 VkDevice device, 972 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 973 const VkAllocationCallbacks* pAllocator); 974 975 VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate( 976 VkDevice device, 977 VkDescriptorSet descriptorSet, 978 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 979 const void* pData); 980 981 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferProperties( 982 VkPhysicalDevice physicalDevice, 983 const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, 984 VkExternalBufferProperties* pExternalBufferProperties); 985 986 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFenceProperties( 987 VkPhysicalDevice physicalDevice, 988 const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, 989 VkExternalFenceProperties* pExternalFenceProperties); 990 991 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphoreProperties( 992 VkPhysicalDevice physicalDevice, 993 const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, 994 VkExternalSemaphoreProperties* pExternalSemaphoreProperties); 995 996 VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupport( 997 VkDevice device, 998 const VkDescriptorSetLayoutCreateInfo* pCreateInfo, 999 VkDescriptorSetLayoutSupport* pSupport); 1000 1001 1002 VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR( 1003 VkInstance instance, 1004 VkSurfaceKHR surface, 1005 const VkAllocationCallbacks* pAllocator); 1006 1007 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR( 1008 VkPhysicalDevice physicalDevice, 1009 uint32_t queueFamilyIndex, 1010 VkSurfaceKHR surface, 1011 VkBool32* pSupported); 1012 1013 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR( 1014 VkPhysicalDevice physicalDevice, 1015 VkSurfaceKHR surface, 1016 VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); 1017 1018 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR( 1019 VkPhysicalDevice physicalDevice, 1020 VkSurfaceKHR surface, 1021 uint32_t* pSurfaceFormatCount, 1022 VkSurfaceFormatKHR* pSurfaceFormats); 1023 1024 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR( 1025 VkPhysicalDevice physicalDevice, 1026 VkSurfaceKHR surface, 1027 uint32_t* pPresentModeCount, 1028 VkPresentModeKHR* pPresentModes); 1029 1030 1031 VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR( 1032 VkDevice device, 1033 const VkSwapchainCreateInfoKHR* pCreateInfo, 1034 const VkAllocationCallbacks* pAllocator, 1035 VkSwapchainKHR* pSwapchain); 1036 1037 VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR( 1038 VkDevice device, 1039 VkSwapchainKHR swapchain, 1040 const VkAllocationCallbacks* pAllocator); 1041 1042 VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR( 1043 VkDevice device, 1044 VkSwapchainKHR swapchain, 1045 uint32_t* pSwapchainImageCount, 1046 VkImage* pSwapchainImages); 1047 1048 VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR( 1049 VkDevice device, 1050 VkSwapchainKHR swapchain, 1051 uint64_t timeout, 1052 VkSemaphore semaphore, 1053 VkFence fence, 1054 uint32_t* pImageIndex); 1055 1056 VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR( 1057 VkQueue queue, 1058 const VkPresentInfoKHR* pPresentInfo); 1059 1060 VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupPresentCapabilitiesKHR( 1061 VkDevice device, 1062 VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); 1063 1064 VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHR( 1065 VkDevice device, 1066 VkSurfaceKHR surface, 1067 VkDeviceGroupPresentModeFlagsKHR* pModes); 1068 1069 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHR( 1070 VkPhysicalDevice physicalDevice, 1071 VkSurfaceKHR surface, 1072 uint32_t* pRectCount, 1073 VkRect2D* pRects); 1074 1075 VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHR( 1076 VkDevice device, 1077 const VkAcquireNextImageInfoKHR* pAcquireInfo, 1078 uint32_t* pImageIndex); 1079 1080 1081 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR( 1082 VkPhysicalDevice physicalDevice, 1083 uint32_t* pPropertyCount, 1084 VkDisplayPropertiesKHR* pProperties); 1085 1086 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR( 1087 VkPhysicalDevice physicalDevice, 1088 uint32_t* pPropertyCount, 1089 VkDisplayPlanePropertiesKHR* pProperties); 1090 1091 VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR( 1092 VkPhysicalDevice physicalDevice, 1093 uint32_t planeIndex, 1094 uint32_t* pDisplayCount, 1095 VkDisplayKHR* pDisplays); 1096 1097 VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR( 1098 VkPhysicalDevice physicalDevice, 1099 VkDisplayKHR display, 1100 uint32_t* pPropertyCount, 1101 VkDisplayModePropertiesKHR* pProperties); 1102 1103 VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR( 1104 VkPhysicalDevice physicalDevice, 1105 VkDisplayKHR display, 1106 const VkDisplayModeCreateInfoKHR* pCreateInfo, 1107 const VkAllocationCallbacks* pAllocator, 1108 VkDisplayModeKHR* pMode); 1109 1110 VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR( 1111 VkPhysicalDevice physicalDevice, 1112 VkDisplayModeKHR mode, 1113 uint32_t planeIndex, 1114 VkDisplayPlaneCapabilitiesKHR* pCapabilities); 1115 1116 VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR( 1117 VkInstance instance, 1118 const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, 1119 const VkAllocationCallbacks* pAllocator, 1120 VkSurfaceKHR* pSurface); 1121 1122 1123 VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR( 1124 VkDevice device, 1125 uint32_t swapchainCount, 1126 const VkSwapchainCreateInfoKHR* pCreateInfos, 1127 const VkAllocationCallbacks* pAllocator, 1128 VkSwapchainKHR* pSwapchains); 1129 1130 #ifdef VK_USE_PLATFORM_XLIB_KHR 1131 1132 VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR( 1133 VkInstance instance, 1134 const VkXlibSurfaceCreateInfoKHR* pCreateInfo, 1135 const VkAllocationCallbacks* pAllocator, 1136 VkSurfaceKHR* pSurface); 1137 1138 VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR( 1139 VkPhysicalDevice physicalDevice, 1140 uint32_t queueFamilyIndex, 1141 Display* dpy, 1142 VisualID visualID); 1143 #endif // VK_USE_PLATFORM_XLIB_KHR 1144 1145 #ifdef VK_USE_PLATFORM_XCB_KHR 1146 1147 VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR( 1148 VkInstance instance, 1149 const VkXcbSurfaceCreateInfoKHR* pCreateInfo, 1150 const VkAllocationCallbacks* pAllocator, 1151 VkSurfaceKHR* pSurface); 1152 1153 VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR( 1154 VkPhysicalDevice physicalDevice, 1155 uint32_t queueFamilyIndex, 1156 xcb_connection_t* connection, 1157 xcb_visualid_t visual_id); 1158 #endif // VK_USE_PLATFORM_XCB_KHR 1159 1160 #ifdef VK_USE_PLATFORM_WAYLAND_KHR 1161 1162 VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR( 1163 VkInstance instance, 1164 const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, 1165 const VkAllocationCallbacks* pAllocator, 1166 VkSurfaceKHR* pSurface); 1167 1168 VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR( 1169 VkPhysicalDevice physicalDevice, 1170 uint32_t queueFamilyIndex, 1171 struct wl_display* display); 1172 #endif // VK_USE_PLATFORM_WAYLAND_KHR 1173 1174 #ifdef VK_USE_PLATFORM_ANDROID_KHR 1175 1176 VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR( 1177 VkInstance instance, 1178 const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, 1179 const VkAllocationCallbacks* pAllocator, 1180 VkSurfaceKHR* pSurface); 1181 #endif // VK_USE_PLATFORM_ANDROID_KHR 1182 1183 #ifdef VK_USE_PLATFORM_WIN32_KHR 1184 1185 VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR( 1186 VkInstance instance, 1187 const VkWin32SurfaceCreateInfoKHR* pCreateInfo, 1188 const VkAllocationCallbacks* pAllocator, 1189 VkSurfaceKHR* pSurface); 1190 1191 VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR( 1192 VkPhysicalDevice physicalDevice, 1193 uint32_t queueFamilyIndex); 1194 #endif // VK_USE_PLATFORM_WIN32_KHR 1195 1196 1197 1198 1199 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR( 1200 VkPhysicalDevice physicalDevice, 1201 VkPhysicalDeviceFeatures2* pFeatures); 1202 1203 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR( 1204 VkPhysicalDevice physicalDevice, 1205 VkPhysicalDeviceProperties2* pProperties); 1206 1207 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR( 1208 VkPhysicalDevice physicalDevice, 1209 VkFormat format, 1210 VkFormatProperties2* pFormatProperties); 1211 1212 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR( 1213 VkPhysicalDevice physicalDevice, 1214 const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, 1215 VkImageFormatProperties2* pImageFormatProperties); 1216 1217 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR( 1218 VkPhysicalDevice physicalDevice, 1219 uint32_t* pQueueFamilyPropertyCount, 1220 VkQueueFamilyProperties2* pQueueFamilyProperties); 1221 1222 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR( 1223 VkPhysicalDevice physicalDevice, 1224 VkPhysicalDeviceMemoryProperties2* pMemoryProperties); 1225 1226 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR( 1227 VkPhysicalDevice physicalDevice, 1228 const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, 1229 uint32_t* pPropertyCount, 1230 VkSparseImageFormatProperties2* pProperties); 1231 1232 1233 VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHR( 1234 VkDevice device, 1235 uint32_t heapIndex, 1236 uint32_t localDeviceIndex, 1237 uint32_t remoteDeviceIndex, 1238 VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); 1239 1240 VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHR( 1241 VkCommandBuffer commandBuffer, 1242 uint32_t deviceMask); 1243 1244 VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHR( 1245 VkCommandBuffer commandBuffer, 1246 uint32_t baseGroupX, 1247 uint32_t baseGroupY, 1248 uint32_t baseGroupZ, 1249 uint32_t groupCountX, 1250 uint32_t groupCountY, 1251 uint32_t groupCountZ); 1252 1253 1254 1255 VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR( 1256 VkDevice device, 1257 VkCommandPool commandPool, 1258 VkCommandPoolTrimFlags flags); 1259 1260 1261 VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHR( 1262 VkInstance instance, 1263 uint32_t* pPhysicalDeviceGroupCount, 1264 VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); 1265 1266 1267 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR( 1268 VkPhysicalDevice physicalDevice, 1269 const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, 1270 VkExternalBufferProperties* pExternalBufferProperties); 1271 1272 1273 #ifdef VK_USE_PLATFORM_WIN32_KHR 1274 1275 VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR( 1276 VkDevice device, 1277 const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, 1278 HANDLE* pHandle); 1279 1280 VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR( 1281 VkDevice device, 1282 VkExternalMemoryHandleTypeFlagBits handleType, 1283 HANDLE handle, 1284 VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); 1285 #endif // VK_USE_PLATFORM_WIN32_KHR 1286 1287 1288 VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR( 1289 VkDevice device, 1290 const VkMemoryGetFdInfoKHR* pGetFdInfo, 1291 int* pFd); 1292 1293 VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR( 1294 VkDevice device, 1295 VkExternalMemoryHandleTypeFlagBits handleType, 1296 int fd, 1297 VkMemoryFdPropertiesKHR* pMemoryFdProperties); 1298 1299 #ifdef VK_USE_PLATFORM_WIN32_KHR 1300 #endif // VK_USE_PLATFORM_WIN32_KHR 1301 1302 1303 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR( 1304 VkPhysicalDevice physicalDevice, 1305 const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, 1306 VkExternalSemaphoreProperties* pExternalSemaphoreProperties); 1307 1308 1309 #ifdef VK_USE_PLATFORM_WIN32_KHR 1310 1311 VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHR( 1312 VkDevice device, 1313 const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); 1314 1315 VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR( 1316 VkDevice device, 1317 const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, 1318 HANDLE* pHandle); 1319 #endif // VK_USE_PLATFORM_WIN32_KHR 1320 1321 1322 VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR( 1323 VkDevice device, 1324 const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); 1325 1326 VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR( 1327 VkDevice device, 1328 const VkSemaphoreGetFdInfoKHR* pGetFdInfo, 1329 int* pFd); 1330 1331 1332 VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR( 1333 VkCommandBuffer commandBuffer, 1334 VkPipelineBindPoint pipelineBindPoint, 1335 VkPipelineLayout layout, 1336 uint32_t set, 1337 uint32_t descriptorWriteCount, 1338 const VkWriteDescriptorSet* pDescriptorWrites); 1339 1340 VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR( 1341 VkCommandBuffer commandBuffer, 1342 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 1343 VkPipelineLayout layout, 1344 uint32_t set, 1345 const void* pData); 1346 1347 1348 1349 1350 1351 VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR( 1352 VkDevice device, 1353 const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, 1354 const VkAllocationCallbacks* pAllocator, 1355 VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); 1356 1357 VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR( 1358 VkDevice device, 1359 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 1360 const VkAllocationCallbacks* pAllocator); 1361 1362 VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR( 1363 VkDevice device, 1364 VkDescriptorSet descriptorSet, 1365 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 1366 const void* pData); 1367 1368 1369 1370 VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2KHR( 1371 VkDevice device, 1372 const VkRenderPassCreateInfo2KHR* pCreateInfo, 1373 const VkAllocationCallbacks* pAllocator, 1374 VkRenderPass* pRenderPass); 1375 1376 VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2KHR( 1377 VkCommandBuffer commandBuffer, 1378 const VkRenderPassBeginInfo* pRenderPassBegin, 1379 const VkSubpassBeginInfoKHR* pSubpassBeginInfo); 1380 1381 VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2KHR( 1382 VkCommandBuffer commandBuffer, 1383 const VkSubpassBeginInfoKHR* pSubpassBeginInfo, 1384 const VkSubpassEndInfoKHR* pSubpassEndInfo); 1385 1386 VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2KHR( 1387 VkCommandBuffer commandBuffer, 1388 const VkSubpassEndInfoKHR* pSubpassEndInfo); 1389 1390 1391 VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR( 1392 VkDevice device, 1393 VkSwapchainKHR swapchain); 1394 1395 1396 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR( 1397 VkPhysicalDevice physicalDevice, 1398 const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, 1399 VkExternalFenceProperties* pExternalFenceProperties); 1400 1401 1402 #ifdef VK_USE_PLATFORM_WIN32_KHR 1403 1404 VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR( 1405 VkDevice device, 1406 const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); 1407 1408 VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR( 1409 VkDevice device, 1410 const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, 1411 HANDLE* pHandle); 1412 #endif // VK_USE_PLATFORM_WIN32_KHR 1413 1414 1415 VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR( 1416 VkDevice device, 1417 const VkImportFenceFdInfoKHR* pImportFenceFdInfo); 1418 1419 VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR( 1420 VkDevice device, 1421 const VkFenceGetFdInfoKHR* pGetFdInfo, 1422 int* pFd); 1423 1424 1425 1426 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR( 1427 VkPhysicalDevice physicalDevice, 1428 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, 1429 VkSurfaceCapabilities2KHR* pSurfaceCapabilities); 1430 1431 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR( 1432 VkPhysicalDevice physicalDevice, 1433 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, 1434 uint32_t* pSurfaceFormatCount, 1435 VkSurfaceFormat2KHR* pSurfaceFormats); 1436 1437 1438 1439 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayProperties2KHR( 1440 VkPhysicalDevice physicalDevice, 1441 uint32_t* pPropertyCount, 1442 VkDisplayProperties2KHR* pProperties); 1443 1444 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlaneProperties2KHR( 1445 VkPhysicalDevice physicalDevice, 1446 uint32_t* pPropertyCount, 1447 VkDisplayPlaneProperties2KHR* pProperties); 1448 1449 VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModeProperties2KHR( 1450 VkPhysicalDevice physicalDevice, 1451 VkDisplayKHR display, 1452 uint32_t* pPropertyCount, 1453 VkDisplayModeProperties2KHR* pProperties); 1454 1455 VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilities2KHR( 1456 VkPhysicalDevice physicalDevice, 1457 const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, 1458 VkDisplayPlaneCapabilities2KHR* pCapabilities); 1459 1460 1461 1462 1463 1464 VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR( 1465 VkDevice device, 1466 const VkImageMemoryRequirementsInfo2* pInfo, 1467 VkMemoryRequirements2* pMemoryRequirements); 1468 1469 VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR( 1470 VkDevice device, 1471 const VkBufferMemoryRequirementsInfo2* pInfo, 1472 VkMemoryRequirements2* pMemoryRequirements); 1473 1474 VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR( 1475 VkDevice device, 1476 const VkImageSparseMemoryRequirementsInfo2* pInfo, 1477 uint32_t* pSparseMemoryRequirementCount, 1478 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); 1479 1480 1481 1482 VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversionKHR( 1483 VkDevice device, 1484 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, 1485 const VkAllocationCallbacks* pAllocator, 1486 VkSamplerYcbcrConversion* pYcbcrConversion); 1487 1488 VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversionKHR( 1489 VkDevice device, 1490 VkSamplerYcbcrConversion ycbcrConversion, 1491 const VkAllocationCallbacks* pAllocator); 1492 1493 1494 VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHR( 1495 VkDevice device, 1496 uint32_t bindInfoCount, 1497 const VkBindBufferMemoryInfo* pBindInfos); 1498 1499 VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHR( 1500 VkDevice device, 1501 uint32_t bindInfoCount, 1502 const VkBindImageMemoryInfo* pBindInfos); 1503 1504 1505 VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupportKHR( 1506 VkDevice device, 1507 const VkDescriptorSetLayoutCreateInfo* pCreateInfo, 1508 VkDescriptorSetLayoutSupport* pSupport); 1509 1510 1511 VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountKHR( 1512 VkCommandBuffer commandBuffer, 1513 VkBuffer buffer, 1514 VkDeviceSize offset, 1515 VkBuffer countBuffer, 1516 VkDeviceSize countBufferOffset, 1517 uint32_t maxDrawCount, 1518 uint32_t stride); 1519 1520 VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountKHR( 1521 VkCommandBuffer commandBuffer, 1522 VkBuffer buffer, 1523 VkDeviceSize offset, 1524 VkBuffer countBuffer, 1525 VkDeviceSize countBufferOffset, 1526 uint32_t maxDrawCount, 1527 uint32_t stride); 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutablePropertiesKHR( 1540 VkDevice device, 1541 const VkPipelineInfoKHR* pPipelineInfo, 1542 uint32_t* pExecutableCount, 1543 VkPipelineExecutablePropertiesKHR* pProperties); 1544 1545 VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableStatisticsKHR( 1546 VkDevice device, 1547 const VkPipelineExecutableInfoKHR* pExecutableInfo, 1548 uint32_t* pStatisticCount, 1549 VkPipelineExecutableStatisticKHR* pStatistics); 1550 1551 VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableInternalRepresentationsKHR( 1552 VkDevice device, 1553 const VkPipelineExecutableInfoKHR* pExecutableInfo, 1554 uint32_t* pInternalRepresentationCount, 1555 VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations); 1556 1557 1558 VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT( 1559 VkInstance instance, 1560 const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, 1561 const VkAllocationCallbacks* pAllocator, 1562 VkDebugReportCallbackEXT* pCallback); 1563 1564 VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT( 1565 VkInstance instance, 1566 VkDebugReportCallbackEXT callback, 1567 const VkAllocationCallbacks* pAllocator); 1568 1569 VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT( 1570 VkInstance instance, 1571 VkDebugReportFlagsEXT flags, 1572 VkDebugReportObjectTypeEXT objectType, 1573 uint64_t object, 1574 size_t location, 1575 int32_t messageCode, 1576 const char* pLayerPrefix, 1577 const char* pMessage); 1578 1579 1580 1581 1582 1583 1584 1585 1586 VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT( 1587 VkDevice device, 1588 const VkDebugMarkerObjectTagInfoEXT* pTagInfo); 1589 1590 VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT( 1591 VkDevice device, 1592 const VkDebugMarkerObjectNameInfoEXT* pNameInfo); 1593 1594 VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT( 1595 VkCommandBuffer commandBuffer, 1596 const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); 1597 1598 VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT( 1599 VkCommandBuffer commandBuffer); 1600 1601 VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT( 1602 VkCommandBuffer commandBuffer, 1603 const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); 1604 1605 1606 1607 1608 VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffersEXT( 1609 VkCommandBuffer commandBuffer, 1610 uint32_t firstBinding, 1611 uint32_t bindingCount, 1612 const VkBuffer* pBuffers, 1613 const VkDeviceSize* pOffsets, 1614 const VkDeviceSize* pSizes); 1615 1616 VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedbackEXT( 1617 VkCommandBuffer commandBuffer, 1618 uint32_t firstCounterBuffer, 1619 uint32_t counterBufferCount, 1620 const VkBuffer* pCounterBuffers, 1621 const VkDeviceSize* pCounterBufferOffsets); 1622 1623 VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedbackEXT( 1624 VkCommandBuffer commandBuffer, 1625 uint32_t firstCounterBuffer, 1626 uint32_t counterBufferCount, 1627 const VkBuffer* pCounterBuffers, 1628 const VkDeviceSize* pCounterBufferOffsets); 1629 1630 VKAPI_ATTR void VKAPI_CALL CmdBeginQueryIndexedEXT( 1631 VkCommandBuffer commandBuffer, 1632 VkQueryPool queryPool, 1633 uint32_t query, 1634 VkQueryControlFlags flags, 1635 uint32_t index); 1636 1637 VKAPI_ATTR void VKAPI_CALL CmdEndQueryIndexedEXT( 1638 VkCommandBuffer commandBuffer, 1639 VkQueryPool queryPool, 1640 uint32_t query, 1641 uint32_t index); 1642 1643 VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectByteCountEXT( 1644 VkCommandBuffer commandBuffer, 1645 uint32_t instanceCount, 1646 uint32_t firstInstance, 1647 VkBuffer counterBuffer, 1648 VkDeviceSize counterBufferOffset, 1649 uint32_t counterOffset, 1650 uint32_t vertexStride); 1651 1652 1653 VKAPI_ATTR uint32_t VKAPI_CALL GetImageViewHandleNVX( 1654 VkDevice device, 1655 const VkImageViewHandleInfoNVX* pInfo); 1656 1657 1658 VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD( 1659 VkCommandBuffer commandBuffer, 1660 VkBuffer buffer, 1661 VkDeviceSize offset, 1662 VkBuffer countBuffer, 1663 VkDeviceSize countBufferOffset, 1664 uint32_t maxDrawCount, 1665 uint32_t stride); 1666 1667 VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD( 1668 VkCommandBuffer commandBuffer, 1669 VkBuffer buffer, 1670 VkDeviceSize offset, 1671 VkBuffer countBuffer, 1672 VkDeviceSize countBufferOffset, 1673 uint32_t maxDrawCount, 1674 uint32_t stride); 1675 1676 1677 1678 1679 1680 1681 VKAPI_ATTR VkResult VKAPI_CALL GetShaderInfoAMD( 1682 VkDevice device, 1683 VkPipeline pipeline, 1684 VkShaderStageFlagBits shaderStage, 1685 VkShaderInfoTypeAMD infoType, 1686 size_t* pInfoSize, 1687 void* pInfo); 1688 1689 1690 #ifdef VK_USE_PLATFORM_GGP 1691 1692 VKAPI_ATTR VkResult VKAPI_CALL CreateStreamDescriptorSurfaceGGP( 1693 VkInstance instance, 1694 const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, 1695 const VkAllocationCallbacks* pAllocator, 1696 VkSurfaceKHR* pSurface); 1697 #endif // VK_USE_PLATFORM_GGP 1698 1699 1700 1701 1702 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV( 1703 VkPhysicalDevice physicalDevice, 1704 VkFormat format, 1705 VkImageType type, 1706 VkImageTiling tiling, 1707 VkImageUsageFlags usage, 1708 VkImageCreateFlags flags, 1709 VkExternalMemoryHandleTypeFlagsNV externalHandleType, 1710 VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); 1711 1712 1713 #ifdef VK_USE_PLATFORM_WIN32_KHR 1714 1715 VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV( 1716 VkDevice device, 1717 VkDeviceMemory memory, 1718 VkExternalMemoryHandleTypeFlagsNV handleType, 1719 HANDLE* pHandle); 1720 #endif // VK_USE_PLATFORM_WIN32_KHR 1721 1722 #ifdef VK_USE_PLATFORM_WIN32_KHR 1723 #endif // VK_USE_PLATFORM_WIN32_KHR 1724 1725 1726 #ifdef VK_USE_PLATFORM_VI_NN 1727 1728 VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN( 1729 VkInstance instance, 1730 const VkViSurfaceCreateInfoNN* pCreateInfo, 1731 const VkAllocationCallbacks* pAllocator, 1732 VkSurfaceKHR* pSurface); 1733 #endif // VK_USE_PLATFORM_VI_NN 1734 1735 1736 1737 1738 1739 1740 VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRenderingEXT( 1741 VkCommandBuffer commandBuffer, 1742 const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); 1743 1744 VKAPI_ATTR void VKAPI_CALL CmdEndConditionalRenderingEXT( 1745 VkCommandBuffer commandBuffer); 1746 1747 1748 VKAPI_ATTR void VKAPI_CALL CmdProcessCommandsNVX( 1749 VkCommandBuffer commandBuffer, 1750 const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo); 1751 1752 VKAPI_ATTR void VKAPI_CALL CmdReserveSpaceForCommandsNVX( 1753 VkCommandBuffer commandBuffer, 1754 const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo); 1755 1756 VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNVX( 1757 VkDevice device, 1758 const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, 1759 const VkAllocationCallbacks* pAllocator, 1760 VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout); 1761 1762 VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNVX( 1763 VkDevice device, 1764 VkIndirectCommandsLayoutNVX indirectCommandsLayout, 1765 const VkAllocationCallbacks* pAllocator); 1766 1767 VKAPI_ATTR VkResult VKAPI_CALL CreateObjectTableNVX( 1768 VkDevice device, 1769 const VkObjectTableCreateInfoNVX* pCreateInfo, 1770 const VkAllocationCallbacks* pAllocator, 1771 VkObjectTableNVX* pObjectTable); 1772 1773 VKAPI_ATTR void VKAPI_CALL DestroyObjectTableNVX( 1774 VkDevice device, 1775 VkObjectTableNVX objectTable, 1776 const VkAllocationCallbacks* pAllocator); 1777 1778 VKAPI_ATTR VkResult VKAPI_CALL RegisterObjectsNVX( 1779 VkDevice device, 1780 VkObjectTableNVX objectTable, 1781 uint32_t objectCount, 1782 const VkObjectTableEntryNVX* const* ppObjectTableEntries, 1783 const uint32_t* pObjectIndices); 1784 1785 VKAPI_ATTR VkResult VKAPI_CALL UnregisterObjectsNVX( 1786 VkDevice device, 1787 VkObjectTableNVX objectTable, 1788 uint32_t objectCount, 1789 const VkObjectEntryTypeNVX* pObjectEntryTypes, 1790 const uint32_t* pObjectIndices); 1791 1792 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceGeneratedCommandsPropertiesNVX( 1793 VkPhysicalDevice physicalDevice, 1794 VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, 1795 VkDeviceGeneratedCommandsLimitsNVX* pLimits); 1796 1797 1798 VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV( 1799 VkCommandBuffer commandBuffer, 1800 uint32_t firstViewport, 1801 uint32_t viewportCount, 1802 const VkViewportWScalingNV* pViewportWScalings); 1803 1804 1805 VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT( 1806 VkPhysicalDevice physicalDevice, 1807 VkDisplayKHR display); 1808 1809 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT 1810 1811 VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT( 1812 VkPhysicalDevice physicalDevice, 1813 Display* dpy, 1814 VkDisplayKHR display); 1815 1816 VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT( 1817 VkPhysicalDevice physicalDevice, 1818 Display* dpy, 1819 RROutput rrOutput, 1820 VkDisplayKHR* pDisplay); 1821 #endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT 1822 1823 1824 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT( 1825 VkPhysicalDevice physicalDevice, 1826 VkSurfaceKHR surface, 1827 VkSurfaceCapabilities2EXT* pSurfaceCapabilities); 1828 1829 1830 VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT( 1831 VkDevice device, 1832 VkDisplayKHR display, 1833 const VkDisplayPowerInfoEXT* pDisplayPowerInfo); 1834 1835 VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT( 1836 VkDevice device, 1837 const VkDeviceEventInfoEXT* pDeviceEventInfo, 1838 const VkAllocationCallbacks* pAllocator, 1839 VkFence* pFence); 1840 1841 VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT( 1842 VkDevice device, 1843 VkDisplayKHR display, 1844 const VkDisplayEventInfoEXT* pDisplayEventInfo, 1845 const VkAllocationCallbacks* pAllocator, 1846 VkFence* pFence); 1847 1848 VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT( 1849 VkDevice device, 1850 VkSwapchainKHR swapchain, 1851 VkSurfaceCounterFlagBitsEXT counter, 1852 uint64_t* pCounterValue); 1853 1854 1855 VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE( 1856 VkDevice device, 1857 VkSwapchainKHR swapchain, 1858 VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); 1859 1860 VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE( 1861 VkDevice device, 1862 VkSwapchainKHR swapchain, 1863 uint32_t* pPresentationTimingCount, 1864 VkPastPresentationTimingGOOGLE* pPresentationTimings); 1865 1866 1867 1868 1869 1870 1871 1872 VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT( 1873 VkCommandBuffer commandBuffer, 1874 uint32_t firstDiscardRectangle, 1875 uint32_t discardRectangleCount, 1876 const VkRect2D* pDiscardRectangles); 1877 1878 1879 1880 1881 1882 VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT( 1883 VkDevice device, 1884 uint32_t swapchainCount, 1885 const VkSwapchainKHR* pSwapchains, 1886 const VkHdrMetadataEXT* pMetadata); 1887 1888 #ifdef VK_USE_PLATFORM_IOS_MVK 1889 1890 VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK( 1891 VkInstance instance, 1892 const VkIOSSurfaceCreateInfoMVK* pCreateInfo, 1893 const VkAllocationCallbacks* pAllocator, 1894 VkSurfaceKHR* pSurface); 1895 #endif // VK_USE_PLATFORM_IOS_MVK 1896 1897 #ifdef VK_USE_PLATFORM_MACOS_MVK 1898 1899 VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK( 1900 VkInstance instance, 1901 const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, 1902 const VkAllocationCallbacks* pAllocator, 1903 VkSurfaceKHR* pSurface); 1904 #endif // VK_USE_PLATFORM_MACOS_MVK 1905 1906 1907 1908 1909 VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT( 1910 VkDevice device, 1911 const VkDebugUtilsObjectNameInfoEXT* pNameInfo); 1912 1913 VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT( 1914 VkDevice device, 1915 const VkDebugUtilsObjectTagInfoEXT* pTagInfo); 1916 1917 VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT( 1918 VkQueue queue, 1919 const VkDebugUtilsLabelEXT* pLabelInfo); 1920 1921 VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT( 1922 VkQueue queue); 1923 1924 VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT( 1925 VkQueue queue, 1926 const VkDebugUtilsLabelEXT* pLabelInfo); 1927 1928 VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT( 1929 VkCommandBuffer commandBuffer, 1930 const VkDebugUtilsLabelEXT* pLabelInfo); 1931 1932 VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT( 1933 VkCommandBuffer commandBuffer); 1934 1935 VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT( 1936 VkCommandBuffer commandBuffer, 1937 const VkDebugUtilsLabelEXT* pLabelInfo); 1938 1939 VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT( 1940 VkInstance instance, 1941 const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, 1942 const VkAllocationCallbacks* pAllocator, 1943 VkDebugUtilsMessengerEXT* pMessenger); 1944 1945 VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT( 1946 VkInstance instance, 1947 VkDebugUtilsMessengerEXT messenger, 1948 const VkAllocationCallbacks* pAllocator); 1949 1950 VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT( 1951 VkInstance instance, 1952 VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, 1953 VkDebugUtilsMessageTypeFlagsEXT messageTypes, 1954 const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); 1955 1956 #ifdef VK_USE_PLATFORM_ANDROID_KHR 1957 1958 VKAPI_ATTR VkResult VKAPI_CALL GetAndroidHardwareBufferPropertiesANDROID( 1959 VkDevice device, 1960 const struct AHardwareBuffer* buffer, 1961 VkAndroidHardwareBufferPropertiesANDROID* pProperties); 1962 1963 VKAPI_ATTR VkResult VKAPI_CALL GetMemoryAndroidHardwareBufferANDROID( 1964 VkDevice device, 1965 const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, 1966 struct AHardwareBuffer** pBuffer); 1967 #endif // VK_USE_PLATFORM_ANDROID_KHR 1968 1969 1970 1971 1972 1973 1974 1975 1976 VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEXT( 1977 VkCommandBuffer commandBuffer, 1978 const VkSampleLocationsInfoEXT* pSampleLocationsInfo); 1979 1980 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMultisamplePropertiesEXT( 1981 VkPhysicalDevice physicalDevice, 1982 VkSampleCountFlagBits samples, 1983 VkMultisamplePropertiesEXT* pMultisampleProperties); 1984 1985 1986 1987 1988 1989 1990 1991 1992 VKAPI_ATTR VkResult VKAPI_CALL GetImageDrmFormatModifierPropertiesEXT( 1993 VkDevice device, 1994 VkImage image, 1995 VkImageDrmFormatModifierPropertiesEXT* pProperties); 1996 1997 1998 VKAPI_ATTR VkResult VKAPI_CALL CreateValidationCacheEXT( 1999 VkDevice device, 2000 const VkValidationCacheCreateInfoEXT* pCreateInfo, 2001 const VkAllocationCallbacks* pAllocator, 2002 VkValidationCacheEXT* pValidationCache); 2003 2004 VKAPI_ATTR void VKAPI_CALL DestroyValidationCacheEXT( 2005 VkDevice device, 2006 VkValidationCacheEXT validationCache, 2007 const VkAllocationCallbacks* pAllocator); 2008 2009 VKAPI_ATTR VkResult VKAPI_CALL MergeValidationCachesEXT( 2010 VkDevice device, 2011 VkValidationCacheEXT dstCache, 2012 uint32_t srcCacheCount, 2013 const VkValidationCacheEXT* pSrcCaches); 2014 2015 VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT( 2016 VkDevice device, 2017 VkValidationCacheEXT validationCache, 2018 size_t* pDataSize, 2019 void* pData); 2020 2021 2022 2023 2024 VKAPI_ATTR void VKAPI_CALL CmdBindShadingRateImageNV( 2025 VkCommandBuffer commandBuffer, 2026 VkImageView imageView, 2027 VkImageLayout imageLayout); 2028 2029 VKAPI_ATTR void VKAPI_CALL CmdSetViewportShadingRatePaletteNV( 2030 VkCommandBuffer commandBuffer, 2031 uint32_t firstViewport, 2032 uint32_t viewportCount, 2033 const VkShadingRatePaletteNV* pShadingRatePalettes); 2034 2035 VKAPI_ATTR void VKAPI_CALL CmdSetCoarseSampleOrderNV( 2036 VkCommandBuffer commandBuffer, 2037 VkCoarseSampleOrderTypeNV sampleOrderType, 2038 uint32_t customSampleOrderCount, 2039 const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); 2040 2041 2042 VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureNV( 2043 VkDevice device, 2044 const VkAccelerationStructureCreateInfoNV* pCreateInfo, 2045 const VkAllocationCallbacks* pAllocator, 2046 VkAccelerationStructureNV* pAccelerationStructure); 2047 2048 VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureNV( 2049 VkDevice device, 2050 VkAccelerationStructureNV accelerationStructure, 2051 const VkAllocationCallbacks* pAllocator); 2052 2053 VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureMemoryRequirementsNV( 2054 VkDevice device, 2055 const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, 2056 VkMemoryRequirements2KHR* pMemoryRequirements); 2057 2058 VKAPI_ATTR VkResult VKAPI_CALL BindAccelerationStructureMemoryNV( 2059 VkDevice device, 2060 uint32_t bindInfoCount, 2061 const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); 2062 2063 VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructureNV( 2064 VkCommandBuffer commandBuffer, 2065 const VkAccelerationStructureInfoNV* pInfo, 2066 VkBuffer instanceData, 2067 VkDeviceSize instanceOffset, 2068 VkBool32 update, 2069 VkAccelerationStructureNV dst, 2070 VkAccelerationStructureNV src, 2071 VkBuffer scratch, 2072 VkDeviceSize scratchOffset); 2073 2074 VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureNV( 2075 VkCommandBuffer commandBuffer, 2076 VkAccelerationStructureNV dst, 2077 VkAccelerationStructureNV src, 2078 VkCopyAccelerationStructureModeNV mode); 2079 2080 VKAPI_ATTR void VKAPI_CALL CmdTraceRaysNV( 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 2097 VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesNV( 2098 VkDevice device, 2099 VkPipelineCache pipelineCache, 2100 uint32_t createInfoCount, 2101 const VkRayTracingPipelineCreateInfoNV* pCreateInfos, 2102 const VkAllocationCallbacks* pAllocator, 2103 VkPipeline* pPipelines); 2104 2105 VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesNV( 2106 VkDevice device, 2107 VkPipeline pipeline, 2108 uint32_t firstGroup, 2109 uint32_t groupCount, 2110 size_t dataSize, 2111 void* pData); 2112 2113 VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureHandleNV( 2114 VkDevice device, 2115 VkAccelerationStructureNV accelerationStructure, 2116 size_t dataSize, 2117 void* pData); 2118 2119 VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesNV( 2120 VkCommandBuffer commandBuffer, 2121 uint32_t accelerationStructureCount, 2122 const VkAccelerationStructureNV* pAccelerationStructures, 2123 VkQueryType queryType, 2124 VkQueryPool queryPool, 2125 uint32_t firstQuery); 2126 2127 VKAPI_ATTR VkResult VKAPI_CALL CompileDeferredNV( 2128 VkDevice device, 2129 VkPipeline pipeline, 2130 uint32_t shader); 2131 2132 2133 2134 2135 2136 VKAPI_ATTR VkResult VKAPI_CALL GetMemoryHostPointerPropertiesEXT( 2137 VkDevice device, 2138 VkExternalMemoryHandleTypeFlagBits handleType, 2139 const void* pHostPointer, 2140 VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); 2141 2142 2143 VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD( 2144 VkCommandBuffer commandBuffer, 2145 VkPipelineStageFlagBits pipelineStage, 2146 VkBuffer dstBuffer, 2147 VkDeviceSize dstOffset, 2148 uint32_t marker); 2149 2150 2151 2152 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT( 2153 VkPhysicalDevice physicalDevice, 2154 uint32_t* pTimeDomainCount, 2155 VkTimeDomainEXT* pTimeDomains); 2156 2157 VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT( 2158 VkDevice device, 2159 uint32_t timestampCount, 2160 const VkCalibratedTimestampInfoEXT* pTimestampInfos, 2161 uint64_t* pTimestamps, 2162 uint64_t* pMaxDeviation); 2163 2164 2165 2166 2167 #ifdef VK_USE_PLATFORM_GGP 2168 #endif // VK_USE_PLATFORM_GGP 2169 2170 2171 2172 2173 2174 VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksNV( 2175 VkCommandBuffer commandBuffer, 2176 uint32_t taskCount, 2177 uint32_t firstTask); 2178 2179 VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectNV( 2180 VkCommandBuffer commandBuffer, 2181 VkBuffer buffer, 2182 VkDeviceSize offset, 2183 uint32_t drawCount, 2184 uint32_t stride); 2185 2186 VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountNV( 2187 VkCommandBuffer commandBuffer, 2188 VkBuffer buffer, 2189 VkDeviceSize offset, 2190 VkBuffer countBuffer, 2191 VkDeviceSize countBufferOffset, 2192 uint32_t maxDrawCount, 2193 uint32_t stride); 2194 2195 2196 2197 2198 VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorNV( 2199 VkCommandBuffer commandBuffer, 2200 uint32_t firstExclusiveScissor, 2201 uint32_t exclusiveScissorCount, 2202 const VkRect2D* pExclusiveScissors); 2203 2204 2205 VKAPI_ATTR void VKAPI_CALL CmdSetCheckpointNV( 2206 VkCommandBuffer commandBuffer, 2207 const void* pCheckpointMarker); 2208 2209 VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointDataNV( 2210 VkQueue queue, 2211 uint32_t* pCheckpointDataCount, 2212 VkCheckpointDataNV* pCheckpointData); 2213 2214 2215 2216 VKAPI_ATTR VkResult VKAPI_CALL InitializePerformanceApiINTEL( 2217 VkDevice device, 2218 const VkInitializePerformanceApiInfoINTEL* pInitializeInfo); 2219 2220 VKAPI_ATTR void VKAPI_CALL UninitializePerformanceApiINTEL( 2221 VkDevice device); 2222 2223 VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceMarkerINTEL( 2224 VkCommandBuffer commandBuffer, 2225 const VkPerformanceMarkerInfoINTEL* pMarkerInfo); 2226 2227 VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceStreamMarkerINTEL( 2228 VkCommandBuffer commandBuffer, 2229 const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo); 2230 2231 VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceOverrideINTEL( 2232 VkCommandBuffer commandBuffer, 2233 const VkPerformanceOverrideInfoINTEL* pOverrideInfo); 2234 2235 VKAPI_ATTR VkResult VKAPI_CALL AcquirePerformanceConfigurationINTEL( 2236 VkDevice device, 2237 const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, 2238 VkPerformanceConfigurationINTEL* pConfiguration); 2239 2240 VKAPI_ATTR VkResult VKAPI_CALL ReleasePerformanceConfigurationINTEL( 2241 VkDevice device, 2242 VkPerformanceConfigurationINTEL configuration); 2243 2244 VKAPI_ATTR VkResult VKAPI_CALL QueueSetPerformanceConfigurationINTEL( 2245 VkQueue queue, 2246 VkPerformanceConfigurationINTEL configuration); 2247 2248 VKAPI_ATTR VkResult VKAPI_CALL GetPerformanceParameterINTEL( 2249 VkDevice device, 2250 VkPerformanceParameterTypeINTEL parameter, 2251 VkPerformanceValueINTEL* pValue); 2252 2253 2254 2255 VKAPI_ATTR void VKAPI_CALL SetLocalDimmingAMD( 2256 VkDevice device, 2257 VkSwapchainKHR swapChain, 2258 VkBool32 localDimmingEnable); 2259 2260 #ifdef VK_USE_PLATFORM_FUCHSIA 2261 2262 VKAPI_ATTR VkResult VKAPI_CALL CreateImagePipeSurfaceFUCHSIA( 2263 VkInstance instance, 2264 const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, 2265 const VkAllocationCallbacks* pAllocator, 2266 VkSurfaceKHR* pSurface); 2267 #endif // VK_USE_PLATFORM_FUCHSIA 2268 2269 #ifdef VK_USE_PLATFORM_METAL_EXT 2270 2271 VKAPI_ATTR VkResult VKAPI_CALL CreateMetalSurfaceEXT( 2272 VkInstance instance, 2273 const VkMetalSurfaceCreateInfoEXT* pCreateInfo, 2274 const VkAllocationCallbacks* pAllocator, 2275 VkSurfaceKHR* pSurface); 2276 #endif // VK_USE_PLATFORM_METAL_EXT 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressEXT( 2290 VkDevice device, 2291 const VkBufferDeviceAddressInfoEXT* pInfo); 2292 2293 2294 2295 2296 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesNV( 2297 VkPhysicalDevice physicalDevice, 2298 uint32_t* pPropertyCount, 2299 VkCooperativeMatrixPropertiesNV* pProperties); 2300 2301 2302 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( 2303 VkPhysicalDevice physicalDevice, 2304 uint32_t* pCombinationCount, 2305 VkFramebufferMixedSamplesCombinationNV* pCombinations); 2306 2307 2308 2309 #ifdef VK_USE_PLATFORM_WIN32_KHR 2310 2311 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModes2EXT( 2312 VkPhysicalDevice physicalDevice, 2313 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, 2314 uint32_t* pPresentModeCount, 2315 VkPresentModeKHR* pPresentModes); 2316 2317 VKAPI_ATTR VkResult VKAPI_CALL AcquireFullScreenExclusiveModeEXT( 2318 VkDevice device, 2319 VkSwapchainKHR swapchain); 2320 2321 VKAPI_ATTR VkResult VKAPI_CALL ReleaseFullScreenExclusiveModeEXT( 2322 VkDevice device, 2323 VkSwapchainKHR swapchain); 2324 2325 VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModes2EXT( 2326 VkDevice device, 2327 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, 2328 VkDeviceGroupPresentModeFlagsKHR* pModes); 2329 #endif // VK_USE_PLATFORM_WIN32_KHR 2330 2331 2332 VKAPI_ATTR VkResult VKAPI_CALL CreateHeadlessSurfaceEXT( 2333 VkInstance instance, 2334 const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, 2335 const VkAllocationCallbacks* pAllocator, 2336 VkSurfaceKHR* pSurface); 2337 2338 2339 VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEXT( 2340 VkCommandBuffer commandBuffer, 2341 uint32_t lineStippleFactor, 2342 uint16_t lineStipplePattern); 2343 2344 2345 VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT( 2346 VkDevice device, 2347 VkQueryPool queryPool, 2348 uint32_t firstQuery, 2349 uint32_t queryCount); 2350 2351 2352 2353 2354 2355 2356 2357 // Layer object type identifiers 2358 enum LayerObjectTypeId { 2359 LayerObjectTypeInstance, // Container for an instance dispatch object 2360 LayerObjectTypeDevice, // Container for a device dispatch object 2361 LayerObjectTypeThreading, // Instance or device threading layer object 2362 LayerObjectTypeParameterValidation, // Instance or device parameter validation layer object 2363 LayerObjectTypeObjectTracker, // Instance or device object tracker layer object 2364 LayerObjectTypeCoreValidation, // Instance or device core validation layer object 2365 LayerObjectTypeBestPractices, // Instance or device best practices layer object 2366 }; 2367 2368 struct TEMPLATE_STATE { 2369 VkDescriptorUpdateTemplateKHR desc_update_template; 2370 safe_VkDescriptorUpdateTemplateCreateInfo create_info; 2371 TEMPLATE_STATETEMPLATE_STATE2372 TEMPLATE_STATE(VkDescriptorUpdateTemplateKHR update_template, safe_VkDescriptorUpdateTemplateCreateInfo *pCreateInfo) 2373 : desc_update_template(update_template), create_info(*pCreateInfo) {} 2374 }; 2375 2376 class LAYER_PHYS_DEV_PROPERTIES { 2377 public: 2378 VkPhysicalDeviceProperties properties; 2379 std::vector<VkQueueFamilyProperties> queue_family_properties; 2380 }; 2381 2382 typedef enum ValidationCheckDisables { 2383 VALIDATION_CHECK_DISABLE_COMMAND_BUFFER_STATE, 2384 VALIDATION_CHECK_DISABLE_OBJECT_IN_USE, 2385 VALIDATION_CHECK_DISABLE_IDLE_DESCRIPTOR_SET, 2386 VALIDATION_CHECK_DISABLE_PUSH_CONSTANT_RANGE, 2387 VALIDATION_CHECK_DISABLE_QUERY_VALIDATION, 2388 VALIDATION_CHECK_DISABLE_IMAGE_LAYOUT_VALIDATION, 2389 } ValidationCheckDisables; 2390 2391 typedef enum VkValidationFeatureEnable { 2392 VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES, 2393 } VkValidationFeatureEnable; 2394 2395 2396 // CHECK_DISABLED struct is a container for bools that can block validation checks from being performed. 2397 // These bools are all "false" by default meaning that all checks are enabled. Enum values can be specified 2398 // via the vk_layer_setting.txt config file or at CreateInstance time via the VK_EXT_validation_features extension 2399 // that can selectively disable checks. 2400 struct CHECK_DISABLED { 2401 bool command_buffer_state; // Skip command buffer state validation 2402 bool object_in_use; // Skip all object in_use checking 2403 bool idle_descriptor_set; // Skip check to verify that descriptor set is not in-use 2404 bool push_constant_range; // Skip push constant range checks 2405 bool query_validation; // Disable all core validation query-related checks 2406 bool image_layout_validation; // Disable image layout validation 2407 bool object_tracking; // Disable object lifetime validation 2408 bool core_checks; // Disable core validation checks 2409 bool thread_safety; // Disable thread safety validation 2410 bool stateless_checks; // Disable stateless validation checks 2411 bool handle_wrapping; // Disable unique handles/handle wrapping 2412 bool shader_validation; // Skip validation for shaders 2413 SetAllCHECK_DISABLED2414 void SetAll(bool value) { std::fill(&command_buffer_state, &shader_validation + 1, value); } 2415 }; 2416 2417 struct CHECK_ENABLED { 2418 bool gpu_validation; 2419 bool gpu_validation_reserve_binding_slot; 2420 bool best_practices; 2421 SetAllCHECK_ENABLED2422 void SetAll(bool value) { std::fill(&gpu_validation, &gpu_validation_reserve_binding_slot + 1, value); } 2423 }; 2424 2425 // Layer chassis validation object base class definition 2426 class ValidationObject { 2427 public: 2428 uint32_t api_version; 2429 debug_report_data* report_data = nullptr; 2430 std::vector<VkDebugReportCallbackEXT> logging_callback; 2431 std::vector<VkDebugUtilsMessengerEXT> logging_messenger; 2432 2433 VkLayerInstanceDispatchTable instance_dispatch_table; 2434 VkLayerDispatchTable device_dispatch_table; 2435 2436 InstanceExtensions instance_extensions; 2437 DeviceExtensions device_extensions = {}; 2438 CHECK_DISABLED disabled = {}; 2439 CHECK_ENABLED enabled = {}; 2440 2441 VkInstance instance = VK_NULL_HANDLE; 2442 VkPhysicalDevice physical_device = VK_NULL_HANDLE; 2443 VkDevice device = VK_NULL_HANDLE; 2444 LAYER_PHYS_DEV_PROPERTIES phys_dev_properties = {}; 2445 2446 std::vector<ValidationObject*> object_dispatch; 2447 LayerObjectTypeId container_type; 2448 2449 std::string layer_name = "CHASSIS"; 2450 2451 // Constructor ValidationObject()2452 ValidationObject(){}; 2453 // Destructor ~ValidationObject()2454 virtual ~ValidationObject() {}; 2455 2456 std::mutex validation_object_mutex; write_lock()2457 virtual std::unique_lock<std::mutex> write_lock() { 2458 return std::unique_lock<std::mutex>(validation_object_mutex); 2459 } 2460 GetValidationObject(std::vector<ValidationObject * > & object_dispatch,LayerObjectTypeId object_type)2461 ValidationObject* GetValidationObject(std::vector<ValidationObject*>& object_dispatch, LayerObjectTypeId object_type) { 2462 for (auto validation_object : object_dispatch) { 2463 if (validation_object->container_type == object_type) { 2464 return validation_object; 2465 } 2466 } 2467 return nullptr; 2468 }; 2469 2470 // Handle Wrapping Data 2471 // Reverse map display handles 2472 vl_concurrent_unordered_map<VkDisplayKHR, uint64_t, 0> display_id_reverse_mapping; 2473 // Wrapping Descriptor Template Update structures requires access to the template createinfo structs 2474 std::unordered_map<uint64_t, std::unique_ptr<TEMPLATE_STATE>> desc_template_createinfo_map; 2475 struct SubpassesUsageStates { 2476 std::unordered_set<uint32_t> subpasses_using_color_attachment; 2477 std::unordered_set<uint32_t> subpasses_using_depthstencil_attachment; 2478 }; 2479 // Uses unwrapped handles 2480 std::unordered_map<VkRenderPass, SubpassesUsageStates> renderpasses_states; 2481 // Map of wrapped swapchain handles to arrays of wrapped swapchain image IDs 2482 // Each swapchain has an immutable list of wrapped swapchain image IDs -- always return these IDs if they exist 2483 std::unordered_map<VkSwapchainKHR, std::vector<VkImage>> swapchain_wrapped_image_handle_map; 2484 // Map of wrapped descriptor pools to set of wrapped descriptor sets allocated from each pool 2485 std::unordered_map<VkDescriptorPool, std::unordered_set<VkDescriptorSet>> pool_descriptor_sets_map; 2486 2487 2488 // Unwrap a handle. 2489 template <typename HandleType> Unwrap(HandleType wrappedHandle)2490 HandleType Unwrap(HandleType wrappedHandle) { 2491 auto iter = unique_id_mapping.find(reinterpret_cast<uint64_t const &>(wrappedHandle)); 2492 if (iter == unique_id_mapping.end()) 2493 return (HandleType)0; 2494 return (HandleType)iter->second; 2495 } 2496 2497 // Wrap a newly created handle with a new unique ID, and return the new ID. 2498 template <typename HandleType> WrapNew(HandleType newlyCreatedHandle)2499 HandleType WrapNew(HandleType newlyCreatedHandle) { 2500 auto unique_id = global_unique_id++; 2501 unique_id_mapping.insert_or_assign(unique_id, reinterpret_cast<uint64_t const &>(newlyCreatedHandle)); 2502 return (HandleType)unique_id; 2503 } 2504 2505 // Specialized handling for VkDisplayKHR. Adds an entry to enable reverse-lookup. WrapDisplay(VkDisplayKHR newlyCreatedHandle,ValidationObject * map_data)2506 VkDisplayKHR WrapDisplay(VkDisplayKHR newlyCreatedHandle, ValidationObject *map_data) { 2507 auto unique_id = global_unique_id++; 2508 unique_id_mapping.insert_or_assign(unique_id, reinterpret_cast<uint64_t const &>(newlyCreatedHandle)); 2509 map_data->display_id_reverse_mapping.insert_or_assign(newlyCreatedHandle, unique_id); 2510 return (VkDisplayKHR)unique_id; 2511 } 2512 2513 // VkDisplayKHR objects don't have a single point of creation, so we need to see if one already exists in the map before 2514 // creating another. MaybeWrapDisplay(VkDisplayKHR handle,ValidationObject * map_data)2515 VkDisplayKHR MaybeWrapDisplay(VkDisplayKHR handle, ValidationObject *map_data) { 2516 // See if this display is already known 2517 auto it = map_data->display_id_reverse_mapping.find(handle); 2518 if (it != map_data->display_id_reverse_mapping.end()) return (VkDisplayKHR)it->second; 2519 // Unknown, so wrap 2520 return WrapDisplay(handle, map_data); 2521 } 2522 2523 // Pre/post hook point declarations PreCallValidateCreateInstance(const VkInstanceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkInstance * pInstance)2524 virtual bool PreCallValidateCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) { return false; }; PreCallRecordCreateInstance(const VkInstanceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkInstance * pInstance)2525 virtual void PreCallRecordCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) {}; PostCallRecordCreateInstance(const VkInstanceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkInstance * pInstance,VkResult result)2526 virtual void PostCallRecordCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance, VkResult result) {}; PreCallValidateDestroyInstance(VkInstance instance,const VkAllocationCallbacks * pAllocator)2527 virtual bool PreCallValidateDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) { return false; }; PreCallRecordDestroyInstance(VkInstance instance,const VkAllocationCallbacks * pAllocator)2528 virtual void PreCallRecordDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {}; PostCallRecordDestroyInstance(VkInstance instance,const VkAllocationCallbacks * pAllocator)2529 virtual void PostCallRecordDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {}; PreCallValidateEnumeratePhysicalDevices(VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)2530 virtual bool PreCallValidateEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) { return false; }; PreCallRecordEnumeratePhysicalDevices(VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)2531 virtual void PreCallRecordEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) {}; PostCallRecordEnumeratePhysicalDevices(VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices,VkResult result)2532 virtual void PostCallRecordEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices, VkResult result) {}; PreCallValidateGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)2533 virtual bool PreCallValidateGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) { return false; }; PreCallRecordGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)2534 virtual void PreCallRecordGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {}; PostCallRecordGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)2535 virtual void PostCallRecordGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {}; PreCallValidateGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)2536 virtual bool PreCallValidateGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) { return false; }; PreCallRecordGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)2537 virtual void PreCallRecordGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {}; PostCallRecordGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)2538 virtual void PostCallRecordGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {}; PreCallValidateGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)2539 virtual bool PreCallValidateGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) { return false; }; PreCallRecordGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)2540 virtual void PreCallRecordGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {}; PostCallRecordGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties,VkResult result)2541 virtual void PostCallRecordGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties, VkResult result) {}; PreCallValidateGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)2542 virtual bool PreCallValidateGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) { return false; }; PreCallRecordGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)2543 virtual void PreCallRecordGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {}; PostCallRecordGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)2544 virtual void PostCallRecordGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {}; PreCallValidateGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)2545 virtual bool PreCallValidateGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) { return false; }; PreCallRecordGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)2546 virtual void PreCallRecordGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) {}; PostCallRecordGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)2547 virtual void PostCallRecordGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) {}; PreCallValidateGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)2548 virtual bool PreCallValidateGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) { return false; }; PreCallRecordGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)2549 virtual void PreCallRecordGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {}; PostCallRecordGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)2550 virtual void PostCallRecordGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {}; PreCallValidateGetInstanceProcAddr(VkInstance instance,const char * pName)2551 virtual bool PreCallValidateGetInstanceProcAddr(VkInstance instance, const char* pName) { return false; }; PreCallRecordGetInstanceProcAddr(VkInstance instance,const char * pName)2552 virtual void PreCallRecordGetInstanceProcAddr(VkInstance instance, const char* pName) {}; PostCallRecordGetInstanceProcAddr(VkInstance instance,const char * pName)2553 virtual void PostCallRecordGetInstanceProcAddr(VkInstance instance, const char* pName) {}; PreCallValidateGetDeviceProcAddr(VkDevice device,const char * pName)2554 virtual bool PreCallValidateGetDeviceProcAddr(VkDevice device, const char* pName) { return false; }; PreCallRecordGetDeviceProcAddr(VkDevice device,const char * pName)2555 virtual void PreCallRecordGetDeviceProcAddr(VkDevice device, const char* pName) {}; PostCallRecordGetDeviceProcAddr(VkDevice device,const char * pName)2556 virtual void PostCallRecordGetDeviceProcAddr(VkDevice device, const char* pName) {}; PreCallValidateCreateDevice(VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)2557 virtual bool PreCallValidateCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) { return false; }; PreCallRecordCreateDevice(VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)2558 virtual void PreCallRecordCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {}; PostCallRecordCreateDevice(VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice,VkResult result)2559 virtual void PostCallRecordCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice, VkResult result) {}; PreCallValidateDestroyDevice(VkDevice device,const VkAllocationCallbacks * pAllocator)2560 virtual bool PreCallValidateDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) { return false; }; PreCallRecordDestroyDevice(VkDevice device,const VkAllocationCallbacks * pAllocator)2561 virtual void PreCallRecordDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {}; PostCallRecordDestroyDevice(VkDevice device,const VkAllocationCallbacks * pAllocator)2562 virtual void PostCallRecordDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {}; PreCallValidateEnumerateInstanceExtensionProperties(const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)2563 virtual bool PreCallValidateEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) { return false; }; PreCallRecordEnumerateInstanceExtensionProperties(const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)2564 virtual void PreCallRecordEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {}; PostCallRecordEnumerateInstanceExtensionProperties(const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties,VkResult result)2565 virtual void PostCallRecordEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, VkResult result) {}; PreCallValidateEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)2566 virtual bool PreCallValidateEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) { return false; }; PreCallRecordEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties)2567 virtual void PreCallRecordEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {}; PostCallRecordEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties,VkResult result)2568 virtual void PostCallRecordEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, VkResult result) {}; PreCallValidateEnumerateInstanceLayerProperties(uint32_t * pPropertyCount,VkLayerProperties * pProperties)2569 virtual bool PreCallValidateEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) { return false; }; PreCallRecordEnumerateInstanceLayerProperties(uint32_t * pPropertyCount,VkLayerProperties * pProperties)2570 virtual void PreCallRecordEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) {}; PostCallRecordEnumerateInstanceLayerProperties(uint32_t * pPropertyCount,VkLayerProperties * pProperties,VkResult result)2571 virtual void PostCallRecordEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties, VkResult result) {}; PreCallValidateEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)2572 virtual bool PreCallValidateEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) { return false; }; PreCallRecordEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties)2573 virtual void PreCallRecordEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) {}; PostCallRecordEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties,VkResult result)2574 virtual void PostCallRecordEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties, VkResult result) {}; PreCallValidateGetDeviceQueue(VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)2575 virtual bool PreCallValidateGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) { return false; }; PreCallRecordGetDeviceQueue(VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)2576 virtual void PreCallRecordGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {}; PostCallRecordGetDeviceQueue(VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)2577 virtual void PostCallRecordGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {}; PreCallValidateQueueSubmit(VkQueue queue,uint32_t submitCount,const VkSubmitInfo * pSubmits,VkFence fence)2578 virtual bool PreCallValidateQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) { return false; }; PreCallRecordQueueSubmit(VkQueue queue,uint32_t submitCount,const VkSubmitInfo * pSubmits,VkFence fence)2579 virtual void PreCallRecordQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) {}; PostCallRecordQueueSubmit(VkQueue queue,uint32_t submitCount,const VkSubmitInfo * pSubmits,VkFence fence,VkResult result)2580 virtual void PostCallRecordQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence, VkResult result) {}; PreCallValidateQueueWaitIdle(VkQueue queue)2581 virtual bool PreCallValidateQueueWaitIdle(VkQueue queue) { return false; }; PreCallRecordQueueWaitIdle(VkQueue queue)2582 virtual void PreCallRecordQueueWaitIdle(VkQueue queue) {}; PostCallRecordQueueWaitIdle(VkQueue queue,VkResult result)2583 virtual void PostCallRecordQueueWaitIdle(VkQueue queue, VkResult result) {}; PreCallValidateDeviceWaitIdle(VkDevice device)2584 virtual bool PreCallValidateDeviceWaitIdle(VkDevice device) { return false; }; PreCallRecordDeviceWaitIdle(VkDevice device)2585 virtual void PreCallRecordDeviceWaitIdle(VkDevice device) {}; PostCallRecordDeviceWaitIdle(VkDevice device,VkResult result)2586 virtual void PostCallRecordDeviceWaitIdle(VkDevice device, VkResult result) {}; PreCallValidateAllocateMemory(VkDevice device,const VkMemoryAllocateInfo * pAllocateInfo,const VkAllocationCallbacks * pAllocator,VkDeviceMemory * pMemory)2587 virtual bool PreCallValidateAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) { return false; }; PreCallRecordAllocateMemory(VkDevice device,const VkMemoryAllocateInfo * pAllocateInfo,const VkAllocationCallbacks * pAllocator,VkDeviceMemory * pMemory)2588 virtual void PreCallRecordAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) {}; PostCallRecordAllocateMemory(VkDevice device,const VkMemoryAllocateInfo * pAllocateInfo,const VkAllocationCallbacks * pAllocator,VkDeviceMemory * pMemory,VkResult result)2589 virtual void PostCallRecordAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory, VkResult result) {}; PreCallValidateFreeMemory(VkDevice device,VkDeviceMemory memory,const VkAllocationCallbacks * pAllocator)2590 virtual bool PreCallValidateFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) { return false; }; PreCallRecordFreeMemory(VkDevice device,VkDeviceMemory memory,const VkAllocationCallbacks * pAllocator)2591 virtual void PreCallRecordFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) {}; PostCallRecordFreeMemory(VkDevice device,VkDeviceMemory memory,const VkAllocationCallbacks * pAllocator)2592 virtual void PostCallRecordFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) {}; PreCallValidateMapMemory(VkDevice device,VkDeviceMemory memory,VkDeviceSize offset,VkDeviceSize size,VkMemoryMapFlags flags,void ** ppData)2593 virtual bool PreCallValidateMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) { return false; }; PreCallRecordMapMemory(VkDevice device,VkDeviceMemory memory,VkDeviceSize offset,VkDeviceSize size,VkMemoryMapFlags flags,void ** ppData)2594 virtual void PreCallRecordMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {}; PostCallRecordMapMemory(VkDevice device,VkDeviceMemory memory,VkDeviceSize offset,VkDeviceSize size,VkMemoryMapFlags flags,void ** ppData,VkResult result)2595 virtual void PostCallRecordMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData, VkResult result) {}; PreCallValidateUnmapMemory(VkDevice device,VkDeviceMemory memory)2596 virtual bool PreCallValidateUnmapMemory(VkDevice device, VkDeviceMemory memory) { return false; }; PreCallRecordUnmapMemory(VkDevice device,VkDeviceMemory memory)2597 virtual void PreCallRecordUnmapMemory(VkDevice device, VkDeviceMemory memory) {}; PostCallRecordUnmapMemory(VkDevice device,VkDeviceMemory memory)2598 virtual void PostCallRecordUnmapMemory(VkDevice device, VkDeviceMemory memory) {}; PreCallValidateFlushMappedMemoryRanges(VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges)2599 virtual bool PreCallValidateFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { return false; }; PreCallRecordFlushMappedMemoryRanges(VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges)2600 virtual void PreCallRecordFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {}; PostCallRecordFlushMappedMemoryRanges(VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges,VkResult result)2601 virtual void PostCallRecordFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges, VkResult result) {}; PreCallValidateInvalidateMappedMemoryRanges(VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges)2602 virtual bool PreCallValidateInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { return false; }; PreCallRecordInvalidateMappedMemoryRanges(VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges)2603 virtual void PreCallRecordInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {}; PostCallRecordInvalidateMappedMemoryRanges(VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges,VkResult result)2604 virtual void PostCallRecordInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges, VkResult result) {}; PreCallValidateGetDeviceMemoryCommitment(VkDevice device,VkDeviceMemory memory,VkDeviceSize * pCommittedMemoryInBytes)2605 virtual bool PreCallValidateGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) { return false; }; PreCallRecordGetDeviceMemoryCommitment(VkDevice device,VkDeviceMemory memory,VkDeviceSize * pCommittedMemoryInBytes)2606 virtual void PreCallRecordGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {}; PostCallRecordGetDeviceMemoryCommitment(VkDevice device,VkDeviceMemory memory,VkDeviceSize * pCommittedMemoryInBytes)2607 virtual void PostCallRecordGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {}; PreCallValidateBindBufferMemory(VkDevice device,VkBuffer buffer,VkDeviceMemory memory,VkDeviceSize memoryOffset)2608 virtual bool PreCallValidateBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) { return false; }; PreCallRecordBindBufferMemory(VkDevice device,VkBuffer buffer,VkDeviceMemory memory,VkDeviceSize memoryOffset)2609 virtual void PreCallRecordBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) {}; PostCallRecordBindBufferMemory(VkDevice device,VkBuffer buffer,VkDeviceMemory memory,VkDeviceSize memoryOffset,VkResult result)2610 virtual void PostCallRecordBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset, VkResult result) {}; PreCallValidateBindImageMemory(VkDevice device,VkImage image,VkDeviceMemory memory,VkDeviceSize memoryOffset)2611 virtual bool PreCallValidateBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) { return false; }; PreCallRecordBindImageMemory(VkDevice device,VkImage image,VkDeviceMemory memory,VkDeviceSize memoryOffset)2612 virtual void PreCallRecordBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {}; PostCallRecordBindImageMemory(VkDevice device,VkImage image,VkDeviceMemory memory,VkDeviceSize memoryOffset,VkResult result)2613 virtual void PostCallRecordBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset, VkResult result) {}; PreCallValidateGetBufferMemoryRequirements(VkDevice device,VkBuffer buffer,VkMemoryRequirements * pMemoryRequirements)2614 virtual bool PreCallValidateGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) { return false; }; PreCallRecordGetBufferMemoryRequirements(VkDevice device,VkBuffer buffer,VkMemoryRequirements * pMemoryRequirements)2615 virtual void PreCallRecordGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {}; PostCallRecordGetBufferMemoryRequirements(VkDevice device,VkBuffer buffer,VkMemoryRequirements * pMemoryRequirements)2616 virtual void PostCallRecordGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {}; PreCallValidateGetImageMemoryRequirements(VkDevice device,VkImage image,VkMemoryRequirements * pMemoryRequirements)2617 virtual bool PreCallValidateGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) { return false; }; PreCallRecordGetImageMemoryRequirements(VkDevice device,VkImage image,VkMemoryRequirements * pMemoryRequirements)2618 virtual void PreCallRecordGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {}; PostCallRecordGetImageMemoryRequirements(VkDevice device,VkImage image,VkMemoryRequirements * pMemoryRequirements)2619 virtual void PostCallRecordGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {}; PreCallValidateGetImageSparseMemoryRequirements(VkDevice device,VkImage image,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements * pSparseMemoryRequirements)2620 virtual bool PreCallValidateGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) { return false; }; PreCallRecordGetImageSparseMemoryRequirements(VkDevice device,VkImage image,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements * pSparseMemoryRequirements)2621 virtual void PreCallRecordGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {}; PostCallRecordGetImageSparseMemoryRequirements(VkDevice device,VkImage image,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements * pSparseMemoryRequirements)2622 virtual void PostCallRecordGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {}; PreCallValidateGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties)2623 virtual bool PreCallValidateGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) { return false; }; PreCallRecordGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties)2624 virtual void PreCallRecordGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {}; PostCallRecordGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties)2625 virtual void PostCallRecordGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {}; PreCallValidateQueueBindSparse(VkQueue queue,uint32_t bindInfoCount,const VkBindSparseInfo * pBindInfo,VkFence fence)2626 virtual bool PreCallValidateQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) { return false; }; PreCallRecordQueueBindSparse(VkQueue queue,uint32_t bindInfoCount,const VkBindSparseInfo * pBindInfo,VkFence fence)2627 virtual void PreCallRecordQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) {}; PostCallRecordQueueBindSparse(VkQueue queue,uint32_t bindInfoCount,const VkBindSparseInfo * pBindInfo,VkFence fence,VkResult result)2628 virtual void PostCallRecordQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence, VkResult result) {}; PreCallValidateCreateFence(VkDevice device,const VkFenceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkFence * pFence)2629 virtual bool PreCallValidateCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { return false; }; PreCallRecordCreateFence(VkDevice device,const VkFenceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkFence * pFence)2630 virtual void PreCallRecordCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {}; PostCallRecordCreateFence(VkDevice device,const VkFenceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkFence * pFence,VkResult result)2631 virtual void PostCallRecordCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence, VkResult result) {}; PreCallValidateDestroyFence(VkDevice device,VkFence fence,const VkAllocationCallbacks * pAllocator)2632 virtual bool PreCallValidateDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) { return false; }; PreCallRecordDestroyFence(VkDevice device,VkFence fence,const VkAllocationCallbacks * pAllocator)2633 virtual void PreCallRecordDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) {}; PostCallRecordDestroyFence(VkDevice device,VkFence fence,const VkAllocationCallbacks * pAllocator)2634 virtual void PostCallRecordDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) {}; PreCallValidateResetFences(VkDevice device,uint32_t fenceCount,const VkFence * pFences)2635 virtual bool PreCallValidateResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) { return false; }; PreCallRecordResetFences(VkDevice device,uint32_t fenceCount,const VkFence * pFences)2636 virtual void PreCallRecordResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {}; PostCallRecordResetFences(VkDevice device,uint32_t fenceCount,const VkFence * pFences,VkResult result)2637 virtual void PostCallRecordResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkResult result) {}; PreCallValidateGetFenceStatus(VkDevice device,VkFence fence)2638 virtual bool PreCallValidateGetFenceStatus(VkDevice device, VkFence fence) { return false; }; PreCallRecordGetFenceStatus(VkDevice device,VkFence fence)2639 virtual void PreCallRecordGetFenceStatus(VkDevice device, VkFence fence) {}; PostCallRecordGetFenceStatus(VkDevice device,VkFence fence,VkResult result)2640 virtual void PostCallRecordGetFenceStatus(VkDevice device, VkFence fence, VkResult result) {}; PreCallValidateWaitForFences(VkDevice device,uint32_t fenceCount,const VkFence * pFences,VkBool32 waitAll,uint64_t timeout)2641 virtual bool PreCallValidateWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) { return false; }; PreCallRecordWaitForFences(VkDevice device,uint32_t fenceCount,const VkFence * pFences,VkBool32 waitAll,uint64_t timeout)2642 virtual void PreCallRecordWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) {}; PostCallRecordWaitForFences(VkDevice device,uint32_t fenceCount,const VkFence * pFences,VkBool32 waitAll,uint64_t timeout,VkResult result)2643 virtual void PostCallRecordWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout, VkResult result) {}; PreCallValidateCreateSemaphore(VkDevice device,const VkSemaphoreCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSemaphore * pSemaphore)2644 virtual bool PreCallValidateCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) { return false; }; PreCallRecordCreateSemaphore(VkDevice device,const VkSemaphoreCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSemaphore * pSemaphore)2645 virtual void PreCallRecordCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) {}; PostCallRecordCreateSemaphore(VkDevice device,const VkSemaphoreCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSemaphore * pSemaphore,VkResult result)2646 virtual void PostCallRecordCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore, VkResult result) {}; PreCallValidateDestroySemaphore(VkDevice device,VkSemaphore semaphore,const VkAllocationCallbacks * pAllocator)2647 virtual bool PreCallValidateDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) { return false; }; PreCallRecordDestroySemaphore(VkDevice device,VkSemaphore semaphore,const VkAllocationCallbacks * pAllocator)2648 virtual void PreCallRecordDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) {}; PostCallRecordDestroySemaphore(VkDevice device,VkSemaphore semaphore,const VkAllocationCallbacks * pAllocator)2649 virtual void PostCallRecordDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) {}; PreCallValidateCreateEvent(VkDevice device,const VkEventCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkEvent * pEvent)2650 virtual bool PreCallValidateCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) { return false; }; PreCallRecordCreateEvent(VkDevice device,const VkEventCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkEvent * pEvent)2651 virtual void PreCallRecordCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {}; PostCallRecordCreateEvent(VkDevice device,const VkEventCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkEvent * pEvent,VkResult result)2652 virtual void PostCallRecordCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent, VkResult result) {}; PreCallValidateDestroyEvent(VkDevice device,VkEvent event,const VkAllocationCallbacks * pAllocator)2653 virtual bool PreCallValidateDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) { return false; }; PreCallRecordDestroyEvent(VkDevice device,VkEvent event,const VkAllocationCallbacks * pAllocator)2654 virtual void PreCallRecordDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) {}; PostCallRecordDestroyEvent(VkDevice device,VkEvent event,const VkAllocationCallbacks * pAllocator)2655 virtual void PostCallRecordDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) {}; PreCallValidateGetEventStatus(VkDevice device,VkEvent event)2656 virtual bool PreCallValidateGetEventStatus(VkDevice device, VkEvent event) { return false; }; PreCallRecordGetEventStatus(VkDevice device,VkEvent event)2657 virtual void PreCallRecordGetEventStatus(VkDevice device, VkEvent event) {}; PostCallRecordGetEventStatus(VkDevice device,VkEvent event,VkResult result)2658 virtual void PostCallRecordGetEventStatus(VkDevice device, VkEvent event, VkResult result) {}; PreCallValidateSetEvent(VkDevice device,VkEvent event)2659 virtual bool PreCallValidateSetEvent(VkDevice device, VkEvent event) { return false; }; PreCallRecordSetEvent(VkDevice device,VkEvent event)2660 virtual void PreCallRecordSetEvent(VkDevice device, VkEvent event) {}; PostCallRecordSetEvent(VkDevice device,VkEvent event,VkResult result)2661 virtual void PostCallRecordSetEvent(VkDevice device, VkEvent event, VkResult result) {}; PreCallValidateResetEvent(VkDevice device,VkEvent event)2662 virtual bool PreCallValidateResetEvent(VkDevice device, VkEvent event) { return false; }; PreCallRecordResetEvent(VkDevice device,VkEvent event)2663 virtual void PreCallRecordResetEvent(VkDevice device, VkEvent event) {}; PostCallRecordResetEvent(VkDevice device,VkEvent event,VkResult result)2664 virtual void PostCallRecordResetEvent(VkDevice device, VkEvent event, VkResult result) {}; PreCallValidateCreateQueryPool(VkDevice device,const VkQueryPoolCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkQueryPool * pQueryPool)2665 virtual bool PreCallValidateCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) { return false; }; PreCallRecordCreateQueryPool(VkDevice device,const VkQueryPoolCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkQueryPool * pQueryPool)2666 virtual void PreCallRecordCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) {}; PostCallRecordCreateQueryPool(VkDevice device,const VkQueryPoolCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkQueryPool * pQueryPool,VkResult result)2667 virtual void PostCallRecordCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool, VkResult result) {}; PreCallValidateDestroyQueryPool(VkDevice device,VkQueryPool queryPool,const VkAllocationCallbacks * pAllocator)2668 virtual bool PreCallValidateDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) { return false; }; PreCallRecordDestroyQueryPool(VkDevice device,VkQueryPool queryPool,const VkAllocationCallbacks * pAllocator)2669 virtual void PreCallRecordDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) {}; PostCallRecordDestroyQueryPool(VkDevice device,VkQueryPool queryPool,const VkAllocationCallbacks * pAllocator)2670 virtual void PostCallRecordDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) {}; PreCallValidateGetQueryPoolResults(VkDevice device,VkQueryPool queryPool,uint32_t firstQuery,uint32_t queryCount,size_t dataSize,void * pData,VkDeviceSize stride,VkQueryResultFlags flags)2671 virtual bool PreCallValidateGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) { return false; }; PreCallRecordGetQueryPoolResults(VkDevice device,VkQueryPool queryPool,uint32_t firstQuery,uint32_t queryCount,size_t dataSize,void * pData,VkDeviceSize stride,VkQueryResultFlags flags)2672 virtual void PreCallRecordGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {}; PostCallRecordGetQueryPoolResults(VkDevice device,VkQueryPool queryPool,uint32_t firstQuery,uint32_t queryCount,size_t dataSize,void * pData,VkDeviceSize stride,VkQueryResultFlags flags,VkResult result)2673 virtual void PostCallRecordGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags, VkResult result) {}; PreCallValidateCreateBuffer(VkDevice device,const VkBufferCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkBuffer * pBuffer)2674 virtual bool PreCallValidateCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) { return false; }; PreCallRecordCreateBuffer(VkDevice device,const VkBufferCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkBuffer * pBuffer)2675 virtual void PreCallRecordCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {}; PostCallRecordCreateBuffer(VkDevice device,const VkBufferCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkBuffer * pBuffer,VkResult result)2676 virtual void PostCallRecordCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer, VkResult result) {}; PreCallValidateDestroyBuffer(VkDevice device,VkBuffer buffer,const VkAllocationCallbacks * pAllocator)2677 virtual bool PreCallValidateDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) { return false; }; PreCallRecordDestroyBuffer(VkDevice device,VkBuffer buffer,const VkAllocationCallbacks * pAllocator)2678 virtual void PreCallRecordDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) {}; PostCallRecordDestroyBuffer(VkDevice device,VkBuffer buffer,const VkAllocationCallbacks * pAllocator)2679 virtual void PostCallRecordDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) {}; PreCallValidateCreateBufferView(VkDevice device,const VkBufferViewCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkBufferView * pView)2680 virtual bool PreCallValidateCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) { return false; }; PreCallRecordCreateBufferView(VkDevice device,const VkBufferViewCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkBufferView * pView)2681 virtual void PreCallRecordCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) {}; PostCallRecordCreateBufferView(VkDevice device,const VkBufferViewCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkBufferView * pView,VkResult result)2682 virtual void PostCallRecordCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView, VkResult result) {}; PreCallValidateDestroyBufferView(VkDevice device,VkBufferView bufferView,const VkAllocationCallbacks * pAllocator)2683 virtual bool PreCallValidateDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) { return false; }; PreCallRecordDestroyBufferView(VkDevice device,VkBufferView bufferView,const VkAllocationCallbacks * pAllocator)2684 virtual void PreCallRecordDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) {}; PostCallRecordDestroyBufferView(VkDevice device,VkBufferView bufferView,const VkAllocationCallbacks * pAllocator)2685 virtual void PostCallRecordDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) {}; PreCallValidateCreateImage(VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImage * pImage)2686 virtual bool PreCallValidateCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) { return false; }; PreCallRecordCreateImage(VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImage * pImage)2687 virtual void PreCallRecordCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) {}; PostCallRecordCreateImage(VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImage * pImage,VkResult result)2688 virtual void PostCallRecordCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage, VkResult result) {}; PreCallValidateDestroyImage(VkDevice device,VkImage image,const VkAllocationCallbacks * pAllocator)2689 virtual bool PreCallValidateDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) { return false; }; PreCallRecordDestroyImage(VkDevice device,VkImage image,const VkAllocationCallbacks * pAllocator)2690 virtual void PreCallRecordDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) {}; PostCallRecordDestroyImage(VkDevice device,VkImage image,const VkAllocationCallbacks * pAllocator)2691 virtual void PostCallRecordDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) {}; PreCallValidateGetImageSubresourceLayout(VkDevice device,VkImage image,const VkImageSubresource * pSubresource,VkSubresourceLayout * pLayout)2692 virtual bool PreCallValidateGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) { return false; }; PreCallRecordGetImageSubresourceLayout(VkDevice device,VkImage image,const VkImageSubresource * pSubresource,VkSubresourceLayout * pLayout)2693 virtual void PreCallRecordGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {}; PostCallRecordGetImageSubresourceLayout(VkDevice device,VkImage image,const VkImageSubresource * pSubresource,VkSubresourceLayout * pLayout)2694 virtual void PostCallRecordGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {}; PreCallValidateCreateImageView(VkDevice device,const VkImageViewCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImageView * pView)2695 virtual bool PreCallValidateCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) { return false; }; PreCallRecordCreateImageView(VkDevice device,const VkImageViewCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImageView * pView)2696 virtual void PreCallRecordCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) {}; PostCallRecordCreateImageView(VkDevice device,const VkImageViewCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImageView * pView,VkResult result)2697 virtual void PostCallRecordCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView, VkResult result) {}; PreCallValidateDestroyImageView(VkDevice device,VkImageView imageView,const VkAllocationCallbacks * pAllocator)2698 virtual bool PreCallValidateDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) { return false; }; PreCallRecordDestroyImageView(VkDevice device,VkImageView imageView,const VkAllocationCallbacks * pAllocator)2699 virtual void PreCallRecordDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) {}; PostCallRecordDestroyImageView(VkDevice device,VkImageView imageView,const VkAllocationCallbacks * pAllocator)2700 virtual void PostCallRecordDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) {}; PreCallValidateCreateShaderModule(VkDevice device,const VkShaderModuleCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkShaderModule * pShaderModule)2701 virtual bool PreCallValidateCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) { return false; }; PreCallRecordCreateShaderModule(VkDevice device,const VkShaderModuleCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkShaderModule * pShaderModule)2702 virtual void PreCallRecordCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) {}; PostCallRecordCreateShaderModule(VkDevice device,const VkShaderModuleCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkShaderModule * pShaderModule,VkResult result)2703 virtual void PostCallRecordCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule, VkResult result) {}; PreCallValidateDestroyShaderModule(VkDevice device,VkShaderModule shaderModule,const VkAllocationCallbacks * pAllocator)2704 virtual bool PreCallValidateDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) { return false; }; PreCallRecordDestroyShaderModule(VkDevice device,VkShaderModule shaderModule,const VkAllocationCallbacks * pAllocator)2705 virtual void PreCallRecordDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) {}; PostCallRecordDestroyShaderModule(VkDevice device,VkShaderModule shaderModule,const VkAllocationCallbacks * pAllocator)2706 virtual void PostCallRecordDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) {}; PreCallValidateCreatePipelineCache(VkDevice device,const VkPipelineCacheCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkPipelineCache * pPipelineCache)2707 virtual bool PreCallValidateCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) { return false; }; PreCallRecordCreatePipelineCache(VkDevice device,const VkPipelineCacheCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkPipelineCache * pPipelineCache)2708 virtual void PreCallRecordCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) {}; PostCallRecordCreatePipelineCache(VkDevice device,const VkPipelineCacheCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkPipelineCache * pPipelineCache,VkResult result)2709 virtual void PostCallRecordCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache, VkResult result) {}; PreCallValidateDestroyPipelineCache(VkDevice device,VkPipelineCache pipelineCache,const VkAllocationCallbacks * pAllocator)2710 virtual bool PreCallValidateDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) { return false; }; PreCallRecordDestroyPipelineCache(VkDevice device,VkPipelineCache pipelineCache,const VkAllocationCallbacks * pAllocator)2711 virtual void PreCallRecordDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) {}; PostCallRecordDestroyPipelineCache(VkDevice device,VkPipelineCache pipelineCache,const VkAllocationCallbacks * pAllocator)2712 virtual void PostCallRecordDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) {}; PreCallValidateGetPipelineCacheData(VkDevice device,VkPipelineCache pipelineCache,size_t * pDataSize,void * pData)2713 virtual bool PreCallValidateGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) { return false; }; PreCallRecordGetPipelineCacheData(VkDevice device,VkPipelineCache pipelineCache,size_t * pDataSize,void * pData)2714 virtual void PreCallRecordGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {}; PostCallRecordGetPipelineCacheData(VkDevice device,VkPipelineCache pipelineCache,size_t * pDataSize,void * pData,VkResult result)2715 virtual void PostCallRecordGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData, VkResult result) {}; PreCallValidateMergePipelineCaches(VkDevice device,VkPipelineCache dstCache,uint32_t srcCacheCount,const VkPipelineCache * pSrcCaches)2716 virtual bool PreCallValidateMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) { return false; }; PreCallRecordMergePipelineCaches(VkDevice device,VkPipelineCache dstCache,uint32_t srcCacheCount,const VkPipelineCache * pSrcCaches)2717 virtual void PreCallRecordMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) {}; PostCallRecordMergePipelineCaches(VkDevice device,VkPipelineCache dstCache,uint32_t srcCacheCount,const VkPipelineCache * pSrcCaches,VkResult result)2718 virtual void PostCallRecordMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches, VkResult result) {}; PreCallValidateCreateGraphicsPipelines(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkGraphicsPipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2719 virtual bool PreCallValidateCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { return false; }; PreCallRecordCreateGraphicsPipelines(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkGraphicsPipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2720 virtual void PreCallRecordCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {}; PostCallRecordCreateGraphicsPipelines(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkGraphicsPipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines,VkResult result)2721 virtual void PostCallRecordCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result) {}; PreCallValidateCreateComputePipelines(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkComputePipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2722 virtual bool PreCallValidateCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { return false; }; PreCallRecordCreateComputePipelines(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkComputePipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)2723 virtual void PreCallRecordCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {}; PostCallRecordCreateComputePipelines(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkComputePipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines,VkResult result)2724 virtual void PostCallRecordCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result) {}; PreCallValidateDestroyPipeline(VkDevice device,VkPipeline pipeline,const VkAllocationCallbacks * pAllocator)2725 virtual bool PreCallValidateDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) { return false; }; PreCallRecordDestroyPipeline(VkDevice device,VkPipeline pipeline,const VkAllocationCallbacks * pAllocator)2726 virtual void PreCallRecordDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) {}; PostCallRecordDestroyPipeline(VkDevice device,VkPipeline pipeline,const VkAllocationCallbacks * pAllocator)2727 virtual void PostCallRecordDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) {}; PreCallValidateCreatePipelineLayout(VkDevice device,const VkPipelineLayoutCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkPipelineLayout * pPipelineLayout)2728 virtual bool PreCallValidateCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) { return false; }; PreCallRecordCreatePipelineLayout(VkDevice device,const VkPipelineLayoutCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkPipelineLayout * pPipelineLayout)2729 virtual void PreCallRecordCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) {}; PostCallRecordCreatePipelineLayout(VkDevice device,const VkPipelineLayoutCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkPipelineLayout * pPipelineLayout,VkResult result)2730 virtual void PostCallRecordCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout, VkResult result) {}; PreCallValidateDestroyPipelineLayout(VkDevice device,VkPipelineLayout pipelineLayout,const VkAllocationCallbacks * pAllocator)2731 virtual bool PreCallValidateDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) { return false; }; PreCallRecordDestroyPipelineLayout(VkDevice device,VkPipelineLayout pipelineLayout,const VkAllocationCallbacks * pAllocator)2732 virtual void PreCallRecordDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) {}; PostCallRecordDestroyPipelineLayout(VkDevice device,VkPipelineLayout pipelineLayout,const VkAllocationCallbacks * pAllocator)2733 virtual void PostCallRecordDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) {}; PreCallValidateCreateSampler(VkDevice device,const VkSamplerCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSampler * pSampler)2734 virtual bool PreCallValidateCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) { return false; }; PreCallRecordCreateSampler(VkDevice device,const VkSamplerCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSampler * pSampler)2735 virtual void PreCallRecordCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) {}; PostCallRecordCreateSampler(VkDevice device,const VkSamplerCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSampler * pSampler,VkResult result)2736 virtual void PostCallRecordCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler, VkResult result) {}; PreCallValidateDestroySampler(VkDevice device,VkSampler sampler,const VkAllocationCallbacks * pAllocator)2737 virtual bool PreCallValidateDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) { return false; }; PreCallRecordDestroySampler(VkDevice device,VkSampler sampler,const VkAllocationCallbacks * pAllocator)2738 virtual void PreCallRecordDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) {}; PostCallRecordDestroySampler(VkDevice device,VkSampler sampler,const VkAllocationCallbacks * pAllocator)2739 virtual void PostCallRecordDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) {}; PreCallValidateCreateDescriptorSetLayout(VkDevice device,const VkDescriptorSetLayoutCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDescriptorSetLayout * pSetLayout)2740 virtual bool PreCallValidateCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) { return false; }; PreCallRecordCreateDescriptorSetLayout(VkDevice device,const VkDescriptorSetLayoutCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDescriptorSetLayout * pSetLayout)2741 virtual void PreCallRecordCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {}; PostCallRecordCreateDescriptorSetLayout(VkDevice device,const VkDescriptorSetLayoutCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDescriptorSetLayout * pSetLayout,VkResult result)2742 virtual void PostCallRecordCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout, VkResult result) {}; PreCallValidateDestroyDescriptorSetLayout(VkDevice device,VkDescriptorSetLayout descriptorSetLayout,const VkAllocationCallbacks * pAllocator)2743 virtual bool PreCallValidateDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) { return false; }; PreCallRecordDestroyDescriptorSetLayout(VkDevice device,VkDescriptorSetLayout descriptorSetLayout,const VkAllocationCallbacks * pAllocator)2744 virtual void PreCallRecordDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) {}; PostCallRecordDestroyDescriptorSetLayout(VkDevice device,VkDescriptorSetLayout descriptorSetLayout,const VkAllocationCallbacks * pAllocator)2745 virtual void PostCallRecordDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) {}; PreCallValidateCreateDescriptorPool(VkDevice device,const VkDescriptorPoolCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDescriptorPool * pDescriptorPool)2746 virtual bool PreCallValidateCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) { return false; }; PreCallRecordCreateDescriptorPool(VkDevice device,const VkDescriptorPoolCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDescriptorPool * pDescriptorPool)2747 virtual void PreCallRecordCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) {}; PostCallRecordCreateDescriptorPool(VkDevice device,const VkDescriptorPoolCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDescriptorPool * pDescriptorPool,VkResult result)2748 virtual void PostCallRecordCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool, VkResult result) {}; PreCallValidateDestroyDescriptorPool(VkDevice device,VkDescriptorPool descriptorPool,const VkAllocationCallbacks * pAllocator)2749 virtual bool PreCallValidateDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) { return false; }; PreCallRecordDestroyDescriptorPool(VkDevice device,VkDescriptorPool descriptorPool,const VkAllocationCallbacks * pAllocator)2750 virtual void PreCallRecordDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) {}; PostCallRecordDestroyDescriptorPool(VkDevice device,VkDescriptorPool descriptorPool,const VkAllocationCallbacks * pAllocator)2751 virtual void PostCallRecordDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) {}; PreCallValidateResetDescriptorPool(VkDevice device,VkDescriptorPool descriptorPool,VkDescriptorPoolResetFlags flags)2752 virtual bool PreCallValidateResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) { return false; }; PreCallRecordResetDescriptorPool(VkDevice device,VkDescriptorPool descriptorPool,VkDescriptorPoolResetFlags flags)2753 virtual void PreCallRecordResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {}; PostCallRecordResetDescriptorPool(VkDevice device,VkDescriptorPool descriptorPool,VkDescriptorPoolResetFlags flags,VkResult result)2754 virtual void PostCallRecordResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags, VkResult result) {}; PreCallValidateAllocateDescriptorSets(VkDevice device,const VkDescriptorSetAllocateInfo * pAllocateInfo,VkDescriptorSet * pDescriptorSets)2755 virtual bool PreCallValidateAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) { return false; }; PreCallRecordAllocateDescriptorSets(VkDevice device,const VkDescriptorSetAllocateInfo * pAllocateInfo,VkDescriptorSet * pDescriptorSets)2756 virtual void PreCallRecordAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) {}; PostCallRecordAllocateDescriptorSets(VkDevice device,const VkDescriptorSetAllocateInfo * pAllocateInfo,VkDescriptorSet * pDescriptorSets,VkResult result)2757 virtual void PostCallRecordAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets, VkResult result) {}; PreCallValidateFreeDescriptorSets(VkDevice device,VkDescriptorPool descriptorPool,uint32_t descriptorSetCount,const VkDescriptorSet * pDescriptorSets)2758 virtual bool PreCallValidateFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) { return false; }; PreCallRecordFreeDescriptorSets(VkDevice device,VkDescriptorPool descriptorPool,uint32_t descriptorSetCount,const VkDescriptorSet * pDescriptorSets)2759 virtual void PreCallRecordFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) {}; PostCallRecordFreeDescriptorSets(VkDevice device,VkDescriptorPool descriptorPool,uint32_t descriptorSetCount,const VkDescriptorSet * pDescriptorSets,VkResult result)2760 virtual void PostCallRecordFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, VkResult result) {}; PreCallValidateUpdateDescriptorSets(VkDevice device,uint32_t descriptorWriteCount,const VkWriteDescriptorSet * pDescriptorWrites,uint32_t descriptorCopyCount,const VkCopyDescriptorSet * pDescriptorCopies)2761 virtual bool PreCallValidateUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) { return false; }; PreCallRecordUpdateDescriptorSets(VkDevice device,uint32_t descriptorWriteCount,const VkWriteDescriptorSet * pDescriptorWrites,uint32_t descriptorCopyCount,const VkCopyDescriptorSet * pDescriptorCopies)2762 virtual void PreCallRecordUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) {}; PostCallRecordUpdateDescriptorSets(VkDevice device,uint32_t descriptorWriteCount,const VkWriteDescriptorSet * pDescriptorWrites,uint32_t descriptorCopyCount,const VkCopyDescriptorSet * pDescriptorCopies)2763 virtual void PostCallRecordUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) {}; PreCallValidateCreateFramebuffer(VkDevice device,const VkFramebufferCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkFramebuffer * pFramebuffer)2764 virtual bool PreCallValidateCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) { return false; }; PreCallRecordCreateFramebuffer(VkDevice device,const VkFramebufferCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkFramebuffer * pFramebuffer)2765 virtual void PreCallRecordCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) {}; PostCallRecordCreateFramebuffer(VkDevice device,const VkFramebufferCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkFramebuffer * pFramebuffer,VkResult result)2766 virtual void PostCallRecordCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer, VkResult result) {}; PreCallValidateDestroyFramebuffer(VkDevice device,VkFramebuffer framebuffer,const VkAllocationCallbacks * pAllocator)2767 virtual bool PreCallValidateDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) { return false; }; PreCallRecordDestroyFramebuffer(VkDevice device,VkFramebuffer framebuffer,const VkAllocationCallbacks * pAllocator)2768 virtual void PreCallRecordDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) {}; PostCallRecordDestroyFramebuffer(VkDevice device,VkFramebuffer framebuffer,const VkAllocationCallbacks * pAllocator)2769 virtual void PostCallRecordDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) {}; PreCallValidateCreateRenderPass(VkDevice device,const VkRenderPassCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass)2770 virtual bool PreCallValidateCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { return false; }; PreCallRecordCreateRenderPass(VkDevice device,const VkRenderPassCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass)2771 virtual void PreCallRecordCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {}; PostCallRecordCreateRenderPass(VkDevice device,const VkRenderPassCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass,VkResult result)2772