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