1 #ifndef __thread_check_h_ 2 #define __thread_check_h_ 1 3 4 namespace threading { 5 6 /* 7 ** Copyright (c) 2015-2016 The Khronos Group Inc. 8 ** 9 ** Licensed under the Apache License, Version 2.0 (the "License"); 10 ** you may not use this file except in compliance with the License. 11 ** You may obtain a copy of the License at 12 ** 13 ** http://www.apache.org/licenses/LICENSE-2.0 14 ** 15 ** Unless required by applicable law or agreed to in writing, software 16 ** distributed under the License is distributed on an "AS IS" BASIS, 17 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 18 ** See the License for the specific language governing permissions and 19 ** limitations under the License. 20 */ 21 22 /* 23 ** This header is generated from the Khronos Vulkan XML API Registry. 24 ** 25 */ 26 27 28 29 // declare only 30 VKAPI_ATTR VkResult VKAPI_CALL CreateInstance( 31 const VkInstanceCreateInfo* pCreateInfo, 32 const VkAllocationCallbacks* pAllocator, 33 VkInstance* pInstance); 34 35 // declare only 36 VKAPI_ATTR void VKAPI_CALL DestroyInstance( 37 VkInstance instance, 38 const VkAllocationCallbacks* pAllocator); 39 40 VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices( 41 VkInstance instance, 42 uint32_t* pPhysicalDeviceCount, 43 VkPhysicalDevice* pPhysicalDevices) 44 { 45 dispatch_key key = get_dispatch_key(instance); 46 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 47 VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table; 48 VkResult result; 49 startReadObject(my_data, instance); 50 51 result = pTable->EnumeratePhysicalDevices(instance,pPhysicalDeviceCount,pPhysicalDevices); 52 finishReadObject(my_data, instance); 53 54 return result; 55 } 56 57 // declare only 58 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr( 59 VkInstance instance, 60 const char* pName); 61 62 // declare only 63 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr( 64 VkDevice device, 65 const char* pName); 66 67 // declare only 68 VKAPI_ATTR VkResult VKAPI_CALL CreateDevice( 69 VkPhysicalDevice physicalDevice, 70 const VkDeviceCreateInfo* pCreateInfo, 71 const VkAllocationCallbacks* pAllocator, 72 VkDevice* pDevice); 73 74 // declare only 75 VKAPI_ATTR void VKAPI_CALL DestroyDevice( 76 VkDevice device, 77 const VkAllocationCallbacks* pAllocator); 78 79 VKAPI_ATTR void VKAPI_CALL GetDeviceQueue( 80 VkDevice device, 81 uint32_t queueFamilyIndex, 82 uint32_t queueIndex, 83 VkQueue* pQueue) 84 { 85 dispatch_key key = get_dispatch_key(device); 86 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 87 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 88 startReadObject(my_data, device); 89 90 pTable->GetDeviceQueue(device,queueFamilyIndex,queueIndex,pQueue); 91 finishReadObject(my_data, device); 92 93 } 94 95 VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit( 96 VkQueue queue, 97 uint32_t submitCount, 98 const VkSubmitInfo* pSubmits, 99 VkFence fence) 100 { 101 dispatch_key key = get_dispatch_key(queue); 102 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 103 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 104 VkResult result; 105 startWriteObject(my_data, queue); 106 for (uint32_t index=0;index<submitCount;index++) { 107 for(uint32_t index2=0;index2<pSubmits[index].waitSemaphoreCount;index2++) startWriteObject(my_data, pSubmits[index].pWaitSemaphores[index2]); 108 for(uint32_t index2=0;index2<pSubmits[index].signalSemaphoreCount;index2++) startWriteObject(my_data, pSubmits[index].pSignalSemaphores[index2]); 109 } 110 startWriteObject(my_data, fence); 111 // Host access to queue must be externally synchronized 112 // Host access to pSubmits[].pWaitSemaphores[],pSubmits[].pSignalSemaphores[] must be externally synchronized 113 // Host access to fence must be externally synchronized 114 115 result = pTable->QueueSubmit(queue,submitCount,pSubmits,fence); 116 finishWriteObject(my_data, queue); 117 for (uint32_t index=0;index<submitCount;index++) { 118 for(uint32_t index2=0;index2<pSubmits[index].waitSemaphoreCount;index2++) finishWriteObject(my_data, pSubmits[index].pWaitSemaphores[index2]); 119 for(uint32_t index2=0;index2<pSubmits[index].signalSemaphoreCount;index2++) finishWriteObject(my_data, pSubmits[index].pSignalSemaphores[index2]); 120 } 121 finishWriteObject(my_data, fence); 122 // Host access to queue must be externally synchronized 123 // Host access to pSubmits[].pWaitSemaphores[],pSubmits[].pSignalSemaphores[] must be externally synchronized 124 // Host access to fence must be externally synchronized 125 126 return result; 127 } 128 129 VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle( 130 VkQueue queue) 131 { 132 dispatch_key key = get_dispatch_key(queue); 133 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 134 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 135 VkResult result; 136 startReadObject(my_data, queue); 137 138 result = pTable->QueueWaitIdle(queue); 139 finishReadObject(my_data, queue); 140 141 return result; 142 } 143 144 VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle( 145 VkDevice device) 146 { 147 dispatch_key key = get_dispatch_key(device); 148 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 149 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 150 VkResult result; 151 startReadObject(my_data, device); 152 // all sname:VkQueue objects created from pname:device must be externally synchronized between host accesses 153 154 result = pTable->DeviceWaitIdle(device); 155 finishReadObject(my_data, device); 156 // all sname:VkQueue objects created from pname:device must be externally synchronized between host accesses 157 158 return result; 159 } 160 161 VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory( 162 VkDevice device, 163 const VkMemoryAllocateInfo* pAllocateInfo, 164 const VkAllocationCallbacks* pAllocator, 165 VkDeviceMemory* pMemory) 166 { 167 dispatch_key key = get_dispatch_key(device); 168 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 169 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 170 VkResult result; 171 startReadObject(my_data, device); 172 173 result = pTable->AllocateMemory(device,pAllocateInfo,pAllocator,pMemory); 174 finishReadObject(my_data, device); 175 176 return result; 177 } 178 179 VKAPI_ATTR void VKAPI_CALL FreeMemory( 180 VkDevice device, 181 VkDeviceMemory memory, 182 const VkAllocationCallbacks* pAllocator) 183 { 184 dispatch_key key = get_dispatch_key(device); 185 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 186 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 187 startReadObject(my_data, device); 188 startWriteObject(my_data, memory); 189 // Host access to memory must be externally synchronized 190 191 pTable->FreeMemory(device,memory,pAllocator); 192 finishReadObject(my_data, device); 193 finishWriteObject(my_data, memory); 194 // Host access to memory must be externally synchronized 195 196 } 197 198 VKAPI_ATTR VkResult VKAPI_CALL MapMemory( 199 VkDevice device, 200 VkDeviceMemory memory, 201 VkDeviceSize offset, 202 VkDeviceSize size, 203 VkMemoryMapFlags flags, 204 void** ppData) 205 { 206 dispatch_key key = get_dispatch_key(device); 207 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 208 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 209 VkResult result; 210 startReadObject(my_data, device); 211 startWriteObject(my_data, memory); 212 // Host access to memory must be externally synchronized 213 214 result = pTable->MapMemory(device,memory,offset,size,flags,ppData); 215 finishReadObject(my_data, device); 216 finishWriteObject(my_data, memory); 217 // Host access to memory must be externally synchronized 218 219 return result; 220 } 221 222 VKAPI_ATTR void VKAPI_CALL UnmapMemory( 223 VkDevice device, 224 VkDeviceMemory memory) 225 { 226 dispatch_key key = get_dispatch_key(device); 227 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 228 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 229 startReadObject(my_data, device); 230 startWriteObject(my_data, memory); 231 // Host access to memory must be externally synchronized 232 233 pTable->UnmapMemory(device,memory); 234 finishReadObject(my_data, device); 235 finishWriteObject(my_data, memory); 236 // Host access to memory must be externally synchronized 237 238 } 239 240 VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges( 241 VkDevice device, 242 uint32_t memoryRangeCount, 243 const VkMappedMemoryRange* pMemoryRanges) 244 { 245 dispatch_key key = get_dispatch_key(device); 246 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 247 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 248 VkResult result; 249 startReadObject(my_data, device); 250 251 result = pTable->FlushMappedMemoryRanges(device,memoryRangeCount,pMemoryRanges); 252 finishReadObject(my_data, device); 253 254 return result; 255 } 256 257 VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges( 258 VkDevice device, 259 uint32_t memoryRangeCount, 260 const VkMappedMemoryRange* pMemoryRanges) 261 { 262 dispatch_key key = get_dispatch_key(device); 263 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 264 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 265 VkResult result; 266 startReadObject(my_data, device); 267 268 result = pTable->InvalidateMappedMemoryRanges(device,memoryRangeCount,pMemoryRanges); 269 finishReadObject(my_data, device); 270 271 return result; 272 } 273 274 VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment( 275 VkDevice device, 276 VkDeviceMemory memory, 277 VkDeviceSize* pCommittedMemoryInBytes) 278 { 279 dispatch_key key = get_dispatch_key(device); 280 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 281 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 282 startReadObject(my_data, device); 283 startReadObject(my_data, memory); 284 285 pTable->GetDeviceMemoryCommitment(device,memory,pCommittedMemoryInBytes); 286 finishReadObject(my_data, device); 287 finishReadObject(my_data, memory); 288 289 } 290 291 VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory( 292 VkDevice device, 293 VkBuffer buffer, 294 VkDeviceMemory memory, 295 VkDeviceSize memoryOffset) 296 { 297 dispatch_key key = get_dispatch_key(device); 298 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 299 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 300 VkResult result; 301 startReadObject(my_data, device); 302 startWriteObject(my_data, buffer); 303 startReadObject(my_data, memory); 304 // Host access to buffer must be externally synchronized 305 306 result = pTable->BindBufferMemory(device,buffer,memory,memoryOffset); 307 finishReadObject(my_data, device); 308 finishWriteObject(my_data, buffer); 309 finishReadObject(my_data, memory); 310 // Host access to buffer must be externally synchronized 311 312 return result; 313 } 314 315 VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory( 316 VkDevice device, 317 VkImage image, 318 VkDeviceMemory memory, 319 VkDeviceSize memoryOffset) 320 { 321 dispatch_key key = get_dispatch_key(device); 322 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 323 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 324 VkResult result; 325 startReadObject(my_data, device); 326 startWriteObject(my_data, image); 327 startReadObject(my_data, memory); 328 // Host access to image must be externally synchronized 329 330 result = pTable->BindImageMemory(device,image,memory,memoryOffset); 331 finishReadObject(my_data, device); 332 finishWriteObject(my_data, image); 333 finishReadObject(my_data, memory); 334 // Host access to image must be externally synchronized 335 336 return result; 337 } 338 339 VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements( 340 VkDevice device, 341 VkBuffer buffer, 342 VkMemoryRequirements* pMemoryRequirements) 343 { 344 dispatch_key key = get_dispatch_key(device); 345 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 346 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 347 startReadObject(my_data, device); 348 startReadObject(my_data, buffer); 349 350 pTable->GetBufferMemoryRequirements(device,buffer,pMemoryRequirements); 351 finishReadObject(my_data, device); 352 finishReadObject(my_data, buffer); 353 354 } 355 356 VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements( 357 VkDevice device, 358 VkImage image, 359 VkMemoryRequirements* pMemoryRequirements) 360 { 361 dispatch_key key = get_dispatch_key(device); 362 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 363 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 364 startReadObject(my_data, device); 365 startReadObject(my_data, image); 366 367 pTable->GetImageMemoryRequirements(device,image,pMemoryRequirements); 368 finishReadObject(my_data, device); 369 finishReadObject(my_data, image); 370 371 } 372 373 VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements( 374 VkDevice device, 375 VkImage image, 376 uint32_t* pSparseMemoryRequirementCount, 377 VkSparseImageMemoryRequirements* pSparseMemoryRequirements) 378 { 379 dispatch_key key = get_dispatch_key(device); 380 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 381 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 382 startReadObject(my_data, device); 383 startReadObject(my_data, image); 384 385 pTable->GetImageSparseMemoryRequirements(device,image,pSparseMemoryRequirementCount,pSparseMemoryRequirements); 386 finishReadObject(my_data, device); 387 finishReadObject(my_data, image); 388 389 } 390 391 VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse( 392 VkQueue queue, 393 uint32_t bindInfoCount, 394 const VkBindSparseInfo* pBindInfo, 395 VkFence fence) 396 { 397 dispatch_key key = get_dispatch_key(queue); 398 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 399 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 400 VkResult result; 401 startWriteObject(my_data, queue); 402 for (uint32_t index=0;index<bindInfoCount;index++) { 403 for(uint32_t index2=0;index2<pBindInfo[index].waitSemaphoreCount;index2++) startWriteObject(my_data, pBindInfo[index].pWaitSemaphores[index2]); 404 for(uint32_t index2=0;index2<pBindInfo[index].signalSemaphoreCount;index2++) startWriteObject(my_data, pBindInfo[index].pSignalSemaphores[index2]); 405 for(uint32_t index2=0;index2<pBindInfo[index].bufferBindCount;index2++) startWriteObject(my_data, pBindInfo[index].pBufferBinds[index2].buffer); 406 for(uint32_t index2=0;index2<pBindInfo[index].imageOpaqueBindCount;index2++) startWriteObject(my_data, pBindInfo[index].pImageOpaqueBinds[index2].image); 407 for(uint32_t index2=0;index2<pBindInfo[index].imageBindCount;index2++) startWriteObject(my_data, pBindInfo[index].pImageBinds[index2].image); 408 } 409 startWriteObject(my_data, fence); 410 // Host access to queue must be externally synchronized 411 // Host access to pBindInfo[].pWaitSemaphores[],pBindInfo[].pSignalSemaphores[],pBindInfo[].pBufferBinds[].buffer,pBindInfo[].pImageOpaqueBinds[].image,pBindInfo[].pImageBinds[].image must be externally synchronized 412 // Host access to fence must be externally synchronized 413 414 result = pTable->QueueBindSparse(queue,bindInfoCount,pBindInfo,fence); 415 finishWriteObject(my_data, queue); 416 for (uint32_t index=0;index<bindInfoCount;index++) { 417 for(uint32_t index2=0;index2<pBindInfo[index].waitSemaphoreCount;index2++) finishWriteObject(my_data, pBindInfo[index].pWaitSemaphores[index2]); 418 for(uint32_t index2=0;index2<pBindInfo[index].signalSemaphoreCount;index2++) finishWriteObject(my_data, pBindInfo[index].pSignalSemaphores[index2]); 419 for(uint32_t index2=0;index2<pBindInfo[index].bufferBindCount;index2++) finishWriteObject(my_data, pBindInfo[index].pBufferBinds[index2].buffer); 420 for(uint32_t index2=0;index2<pBindInfo[index].imageOpaqueBindCount;index2++) finishWriteObject(my_data, pBindInfo[index].pImageOpaqueBinds[index2].image); 421 for(uint32_t index2=0;index2<pBindInfo[index].imageBindCount;index2++) finishWriteObject(my_data, pBindInfo[index].pImageBinds[index2].image); 422 } 423 finishWriteObject(my_data, fence); 424 // Host access to queue must be externally synchronized 425 // Host access to pBindInfo[].pWaitSemaphores[],pBindInfo[].pSignalSemaphores[],pBindInfo[].pBufferBinds[].buffer,pBindInfo[].pImageOpaqueBinds[].image,pBindInfo[].pImageBinds[].image must be externally synchronized 426 // Host access to fence must be externally synchronized 427 428 return result; 429 } 430 431 VKAPI_ATTR VkResult VKAPI_CALL CreateFence( 432 VkDevice device, 433 const VkFenceCreateInfo* pCreateInfo, 434 const VkAllocationCallbacks* pAllocator, 435 VkFence* pFence) 436 { 437 dispatch_key key = get_dispatch_key(device); 438 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 439 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 440 VkResult result; 441 startReadObject(my_data, device); 442 443 result = pTable->CreateFence(device,pCreateInfo,pAllocator,pFence); 444 finishReadObject(my_data, device); 445 446 return result; 447 } 448 449 VKAPI_ATTR void VKAPI_CALL DestroyFence( 450 VkDevice device, 451 VkFence fence, 452 const VkAllocationCallbacks* pAllocator) 453 { 454 dispatch_key key = get_dispatch_key(device); 455 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 456 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 457 startReadObject(my_data, device); 458 startWriteObject(my_data, fence); 459 // Host access to fence must be externally synchronized 460 461 pTable->DestroyFence(device,fence,pAllocator); 462 finishReadObject(my_data, device); 463 finishWriteObject(my_data, fence); 464 // Host access to fence must be externally synchronized 465 466 } 467 468 VKAPI_ATTR VkResult VKAPI_CALL ResetFences( 469 VkDevice device, 470 uint32_t fenceCount, 471 const VkFence* pFences) 472 { 473 dispatch_key key = get_dispatch_key(device); 474 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 475 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 476 VkResult result; 477 startReadObject(my_data, device); 478 for (uint32_t index=0;index<fenceCount;index++) { 479 startWriteObject(my_data, pFences[index]); 480 } 481 // Host access to each member of pFences must be externally synchronized 482 483 result = pTable->ResetFences(device,fenceCount,pFences); 484 finishReadObject(my_data, device); 485 for (uint32_t index=0;index<fenceCount;index++) { 486 finishWriteObject(my_data, pFences[index]); 487 } 488 // Host access to each member of pFences must be externally synchronized 489 490 return result; 491 } 492 493 VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus( 494 VkDevice device, 495 VkFence fence) 496 { 497 dispatch_key key = get_dispatch_key(device); 498 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 499 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 500 VkResult result; 501 startReadObject(my_data, device); 502 startReadObject(my_data, fence); 503 504 result = pTable->GetFenceStatus(device,fence); 505 finishReadObject(my_data, device); 506 finishReadObject(my_data, fence); 507 508 return result; 509 } 510 511 VKAPI_ATTR VkResult VKAPI_CALL WaitForFences( 512 VkDevice device, 513 uint32_t fenceCount, 514 const VkFence* pFences, 515 VkBool32 waitAll, 516 uint64_t timeout) 517 { 518 dispatch_key key = get_dispatch_key(device); 519 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 520 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 521 VkResult result; 522 startReadObject(my_data, device); 523 for (uint32_t index=0;index<fenceCount;index++) { 524 startReadObject(my_data, pFences[index]); 525 } 526 527 result = pTable->WaitForFences(device,fenceCount,pFences,waitAll,timeout); 528 finishReadObject(my_data, device); 529 for (uint32_t index=0;index<fenceCount;index++) { 530 finishReadObject(my_data, pFences[index]); 531 } 532 533 return result; 534 } 535 536 VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore( 537 VkDevice device, 538 const VkSemaphoreCreateInfo* pCreateInfo, 539 const VkAllocationCallbacks* pAllocator, 540 VkSemaphore* pSemaphore) 541 { 542 dispatch_key key = get_dispatch_key(device); 543 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 544 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 545 VkResult result; 546 startReadObject(my_data, device); 547 548 result = pTable->CreateSemaphore(device,pCreateInfo,pAllocator,pSemaphore); 549 finishReadObject(my_data, device); 550 551 return result; 552 } 553 554 VKAPI_ATTR void VKAPI_CALL DestroySemaphore( 555 VkDevice device, 556 VkSemaphore semaphore, 557 const VkAllocationCallbacks* pAllocator) 558 { 559 dispatch_key key = get_dispatch_key(device); 560 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 561 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 562 startReadObject(my_data, device); 563 startWriteObject(my_data, semaphore); 564 // Host access to semaphore must be externally synchronized 565 566 pTable->DestroySemaphore(device,semaphore,pAllocator); 567 finishReadObject(my_data, device); 568 finishWriteObject(my_data, semaphore); 569 // Host access to semaphore must be externally synchronized 570 571 } 572 573 VKAPI_ATTR VkResult VKAPI_CALL CreateEvent( 574 VkDevice device, 575 const VkEventCreateInfo* pCreateInfo, 576 const VkAllocationCallbacks* pAllocator, 577 VkEvent* pEvent) 578 { 579 dispatch_key key = get_dispatch_key(device); 580 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 581 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 582 VkResult result; 583 startReadObject(my_data, device); 584 585 result = pTable->CreateEvent(device,pCreateInfo,pAllocator,pEvent); 586 finishReadObject(my_data, device); 587 588 return result; 589 } 590 591 VKAPI_ATTR void VKAPI_CALL DestroyEvent( 592 VkDevice device, 593 VkEvent event, 594 const VkAllocationCallbacks* pAllocator) 595 { 596 dispatch_key key = get_dispatch_key(device); 597 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 598 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 599 startReadObject(my_data, device); 600 startWriteObject(my_data, event); 601 // Host access to event must be externally synchronized 602 603 pTable->DestroyEvent(device,event,pAllocator); 604 finishReadObject(my_data, device); 605 finishWriteObject(my_data, event); 606 // Host access to event must be externally synchronized 607 608 } 609 610 VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus( 611 VkDevice device, 612 VkEvent event) 613 { 614 dispatch_key key = get_dispatch_key(device); 615 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 616 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 617 VkResult result; 618 startReadObject(my_data, device); 619 startReadObject(my_data, event); 620 621 result = pTable->GetEventStatus(device,event); 622 finishReadObject(my_data, device); 623 finishReadObject(my_data, event); 624 625 return result; 626 } 627 628 VKAPI_ATTR VkResult VKAPI_CALL SetEvent( 629 VkDevice device, 630 VkEvent event) 631 { 632 dispatch_key key = get_dispatch_key(device); 633 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 634 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 635 VkResult result; 636 startReadObject(my_data, device); 637 startWriteObject(my_data, event); 638 // Host access to event must be externally synchronized 639 640 result = pTable->SetEvent(device,event); 641 finishReadObject(my_data, device); 642 finishWriteObject(my_data, event); 643 // Host access to event must be externally synchronized 644 645 return result; 646 } 647 648 VKAPI_ATTR VkResult VKAPI_CALL ResetEvent( 649 VkDevice device, 650 VkEvent event) 651 { 652 dispatch_key key = get_dispatch_key(device); 653 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 654 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 655 VkResult result; 656 startReadObject(my_data, device); 657 startWriteObject(my_data, event); 658 // Host access to event must be externally synchronized 659 660 result = pTable->ResetEvent(device,event); 661 finishReadObject(my_data, device); 662 finishWriteObject(my_data, event); 663 // Host access to event must be externally synchronized 664 665 return result; 666 } 667 668 VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool( 669 VkDevice device, 670 const VkQueryPoolCreateInfo* pCreateInfo, 671 const VkAllocationCallbacks* pAllocator, 672 VkQueryPool* pQueryPool) 673 { 674 dispatch_key key = get_dispatch_key(device); 675 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 676 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 677 VkResult result; 678 startReadObject(my_data, device); 679 680 result = pTable->CreateQueryPool(device,pCreateInfo,pAllocator,pQueryPool); 681 finishReadObject(my_data, device); 682 683 return result; 684 } 685 686 VKAPI_ATTR void VKAPI_CALL DestroyQueryPool( 687 VkDevice device, 688 VkQueryPool queryPool, 689 const VkAllocationCallbacks* pAllocator) 690 { 691 dispatch_key key = get_dispatch_key(device); 692 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 693 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 694 startReadObject(my_data, device); 695 startWriteObject(my_data, queryPool); 696 // Host access to queryPool must be externally synchronized 697 698 pTable->DestroyQueryPool(device,queryPool,pAllocator); 699 finishReadObject(my_data, device); 700 finishWriteObject(my_data, queryPool); 701 // Host access to queryPool must be externally synchronized 702 703 } 704 705 VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults( 706 VkDevice device, 707 VkQueryPool queryPool, 708 uint32_t firstQuery, 709 uint32_t queryCount, 710 size_t dataSize, 711 void* pData, 712 VkDeviceSize stride, 713 VkQueryResultFlags flags) 714 { 715 dispatch_key key = get_dispatch_key(device); 716 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 717 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 718 VkResult result; 719 startReadObject(my_data, device); 720 startReadObject(my_data, queryPool); 721 722 result = pTable->GetQueryPoolResults(device,queryPool,firstQuery,queryCount,dataSize,pData,stride,flags); 723 finishReadObject(my_data, device); 724 finishReadObject(my_data, queryPool); 725 726 return result; 727 } 728 729 VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer( 730 VkDevice device, 731 const VkBufferCreateInfo* pCreateInfo, 732 const VkAllocationCallbacks* pAllocator, 733 VkBuffer* pBuffer) 734 { 735 dispatch_key key = get_dispatch_key(device); 736 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 737 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 738 VkResult result; 739 startReadObject(my_data, device); 740 741 result = pTable->CreateBuffer(device,pCreateInfo,pAllocator,pBuffer); 742 finishReadObject(my_data, device); 743 744 return result; 745 } 746 747 VKAPI_ATTR void VKAPI_CALL DestroyBuffer( 748 VkDevice device, 749 VkBuffer buffer, 750 const VkAllocationCallbacks* pAllocator) 751 { 752 dispatch_key key = get_dispatch_key(device); 753 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 754 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 755 startReadObject(my_data, device); 756 startWriteObject(my_data, buffer); 757 // Host access to buffer must be externally synchronized 758 759 pTable->DestroyBuffer(device,buffer,pAllocator); 760 finishReadObject(my_data, device); 761 finishWriteObject(my_data, buffer); 762 // Host access to buffer must be externally synchronized 763 764 } 765 766 VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView( 767 VkDevice device, 768 const VkBufferViewCreateInfo* pCreateInfo, 769 const VkAllocationCallbacks* pAllocator, 770 VkBufferView* pView) 771 { 772 dispatch_key key = get_dispatch_key(device); 773 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 774 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 775 VkResult result; 776 startReadObject(my_data, device); 777 778 result = pTable->CreateBufferView(device,pCreateInfo,pAllocator,pView); 779 finishReadObject(my_data, device); 780 781 return result; 782 } 783 784 VKAPI_ATTR void VKAPI_CALL DestroyBufferView( 785 VkDevice device, 786 VkBufferView bufferView, 787 const VkAllocationCallbacks* pAllocator) 788 { 789 dispatch_key key = get_dispatch_key(device); 790 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 791 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 792 startReadObject(my_data, device); 793 startWriteObject(my_data, bufferView); 794 // Host access to bufferView must be externally synchronized 795 796 pTable->DestroyBufferView(device,bufferView,pAllocator); 797 finishReadObject(my_data, device); 798 finishWriteObject(my_data, bufferView); 799 // Host access to bufferView must be externally synchronized 800 801 } 802 803 VKAPI_ATTR VkResult VKAPI_CALL CreateImage( 804 VkDevice device, 805 const VkImageCreateInfo* pCreateInfo, 806 const VkAllocationCallbacks* pAllocator, 807 VkImage* pImage) 808 { 809 dispatch_key key = get_dispatch_key(device); 810 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 811 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 812 VkResult result; 813 startReadObject(my_data, device); 814 815 result = pTable->CreateImage(device,pCreateInfo,pAllocator,pImage); 816 finishReadObject(my_data, device); 817 818 return result; 819 } 820 821 VKAPI_ATTR void VKAPI_CALL DestroyImage( 822 VkDevice device, 823 VkImage image, 824 const VkAllocationCallbacks* pAllocator) 825 { 826 dispatch_key key = get_dispatch_key(device); 827 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 828 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 829 startReadObject(my_data, device); 830 startWriteObject(my_data, image); 831 // Host access to image must be externally synchronized 832 833 pTable->DestroyImage(device,image,pAllocator); 834 finishReadObject(my_data, device); 835 finishWriteObject(my_data, image); 836 // Host access to image must be externally synchronized 837 838 } 839 840 VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout( 841 VkDevice device, 842 VkImage image, 843 const VkImageSubresource* pSubresource, 844 VkSubresourceLayout* pLayout) 845 { 846 dispatch_key key = get_dispatch_key(device); 847 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 848 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 849 startReadObject(my_data, device); 850 startReadObject(my_data, image); 851 852 pTable->GetImageSubresourceLayout(device,image,pSubresource,pLayout); 853 finishReadObject(my_data, device); 854 finishReadObject(my_data, image); 855 856 } 857 858 VKAPI_ATTR VkResult VKAPI_CALL CreateImageView( 859 VkDevice device, 860 const VkImageViewCreateInfo* pCreateInfo, 861 const VkAllocationCallbacks* pAllocator, 862 VkImageView* pView) 863 { 864 dispatch_key key = get_dispatch_key(device); 865 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 866 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 867 VkResult result; 868 startReadObject(my_data, device); 869 870 result = pTable->CreateImageView(device,pCreateInfo,pAllocator,pView); 871 finishReadObject(my_data, device); 872 873 return result; 874 } 875 876 VKAPI_ATTR void VKAPI_CALL DestroyImageView( 877 VkDevice device, 878 VkImageView imageView, 879 const VkAllocationCallbacks* pAllocator) 880 { 881 dispatch_key key = get_dispatch_key(device); 882 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 883 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 884 startReadObject(my_data, device); 885 startWriteObject(my_data, imageView); 886 // Host access to imageView must be externally synchronized 887 888 pTable->DestroyImageView(device,imageView,pAllocator); 889 finishReadObject(my_data, device); 890 finishWriteObject(my_data, imageView); 891 // Host access to imageView must be externally synchronized 892 893 } 894 895 VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule( 896 VkDevice device, 897 const VkShaderModuleCreateInfo* pCreateInfo, 898 const VkAllocationCallbacks* pAllocator, 899 VkShaderModule* pShaderModule) 900 { 901 dispatch_key key = get_dispatch_key(device); 902 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 903 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 904 VkResult result; 905 startReadObject(my_data, device); 906 907 result = pTable->CreateShaderModule(device,pCreateInfo,pAllocator,pShaderModule); 908 finishReadObject(my_data, device); 909 910 return result; 911 } 912 913 VKAPI_ATTR void VKAPI_CALL DestroyShaderModule( 914 VkDevice device, 915 VkShaderModule shaderModule, 916 const VkAllocationCallbacks* pAllocator) 917 { 918 dispatch_key key = get_dispatch_key(device); 919 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 920 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 921 startReadObject(my_data, device); 922 startWriteObject(my_data, shaderModule); 923 // Host access to shaderModule must be externally synchronized 924 925 pTable->DestroyShaderModule(device,shaderModule,pAllocator); 926 finishReadObject(my_data, device); 927 finishWriteObject(my_data, shaderModule); 928 // Host access to shaderModule must be externally synchronized 929 930 } 931 932 VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache( 933 VkDevice device, 934 const VkPipelineCacheCreateInfo* pCreateInfo, 935 const VkAllocationCallbacks* pAllocator, 936 VkPipelineCache* pPipelineCache) 937 { 938 dispatch_key key = get_dispatch_key(device); 939 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 940 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 941 VkResult result; 942 startReadObject(my_data, device); 943 944 result = pTable->CreatePipelineCache(device,pCreateInfo,pAllocator,pPipelineCache); 945 finishReadObject(my_data, device); 946 947 return result; 948 } 949 950 VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache( 951 VkDevice device, 952 VkPipelineCache pipelineCache, 953 const VkAllocationCallbacks* pAllocator) 954 { 955 dispatch_key key = get_dispatch_key(device); 956 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 957 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 958 startReadObject(my_data, device); 959 startWriteObject(my_data, pipelineCache); 960 // Host access to pipelineCache must be externally synchronized 961 962 pTable->DestroyPipelineCache(device,pipelineCache,pAllocator); 963 finishReadObject(my_data, device); 964 finishWriteObject(my_data, pipelineCache); 965 // Host access to pipelineCache must be externally synchronized 966 967 } 968 969 VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData( 970 VkDevice device, 971 VkPipelineCache pipelineCache, 972 size_t* pDataSize, 973 void* pData) 974 { 975 dispatch_key key = get_dispatch_key(device); 976 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 977 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 978 VkResult result; 979 startReadObject(my_data, device); 980 startReadObject(my_data, pipelineCache); 981 982 result = pTable->GetPipelineCacheData(device,pipelineCache,pDataSize,pData); 983 finishReadObject(my_data, device); 984 finishReadObject(my_data, pipelineCache); 985 986 return result; 987 } 988 989 VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches( 990 VkDevice device, 991 VkPipelineCache dstCache, 992 uint32_t srcCacheCount, 993 const VkPipelineCache* pSrcCaches) 994 { 995 dispatch_key key = get_dispatch_key(device); 996 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 997 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 998 VkResult result; 999 startReadObject(my_data, device); 1000 startWriteObject(my_data, dstCache); 1001 for (uint32_t index=0;index<srcCacheCount;index++) { 1002 startReadObject(my_data, pSrcCaches[index]); 1003 } 1004 // Host access to dstCache must be externally synchronized 1005 1006 result = pTable->MergePipelineCaches(device,dstCache,srcCacheCount,pSrcCaches); 1007 finishReadObject(my_data, device); 1008 finishWriteObject(my_data, dstCache); 1009 for (uint32_t index=0;index<srcCacheCount;index++) { 1010 finishReadObject(my_data, pSrcCaches[index]); 1011 } 1012 // Host access to dstCache must be externally synchronized 1013 1014 return result; 1015 } 1016 1017 VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines( 1018 VkDevice device, 1019 VkPipelineCache pipelineCache, 1020 uint32_t createInfoCount, 1021 const VkGraphicsPipelineCreateInfo* pCreateInfos, 1022 const VkAllocationCallbacks* pAllocator, 1023 VkPipeline* pPipelines) 1024 { 1025 dispatch_key key = get_dispatch_key(device); 1026 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1027 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1028 VkResult result; 1029 startReadObject(my_data, device); 1030 startReadObject(my_data, pipelineCache); 1031 1032 result = pTable->CreateGraphicsPipelines(device,pipelineCache,createInfoCount,pCreateInfos,pAllocator,pPipelines); 1033 finishReadObject(my_data, device); 1034 finishReadObject(my_data, pipelineCache); 1035 1036 return result; 1037 } 1038 1039 VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines( 1040 VkDevice device, 1041 VkPipelineCache pipelineCache, 1042 uint32_t createInfoCount, 1043 const VkComputePipelineCreateInfo* pCreateInfos, 1044 const VkAllocationCallbacks* pAllocator, 1045 VkPipeline* pPipelines) 1046 { 1047 dispatch_key key = get_dispatch_key(device); 1048 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1049 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1050 VkResult result; 1051 startReadObject(my_data, device); 1052 startReadObject(my_data, pipelineCache); 1053 1054 result = pTable->CreateComputePipelines(device,pipelineCache,createInfoCount,pCreateInfos,pAllocator,pPipelines); 1055 finishReadObject(my_data, device); 1056 finishReadObject(my_data, pipelineCache); 1057 1058 return result; 1059 } 1060 1061 VKAPI_ATTR void VKAPI_CALL DestroyPipeline( 1062 VkDevice device, 1063 VkPipeline pipeline, 1064 const VkAllocationCallbacks* pAllocator) 1065 { 1066 dispatch_key key = get_dispatch_key(device); 1067 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1068 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1069 startReadObject(my_data, device); 1070 startWriteObject(my_data, pipeline); 1071 // Host access to pipeline must be externally synchronized 1072 1073 pTable->DestroyPipeline(device,pipeline,pAllocator); 1074 finishReadObject(my_data, device); 1075 finishWriteObject(my_data, pipeline); 1076 // Host access to pipeline must be externally synchronized 1077 1078 } 1079 1080 VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout( 1081 VkDevice device, 1082 const VkPipelineLayoutCreateInfo* pCreateInfo, 1083 const VkAllocationCallbacks* pAllocator, 1084 VkPipelineLayout* pPipelineLayout) 1085 { 1086 dispatch_key key = get_dispatch_key(device); 1087 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1088 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1089 VkResult result; 1090 startReadObject(my_data, device); 1091 1092 result = pTable->CreatePipelineLayout(device,pCreateInfo,pAllocator,pPipelineLayout); 1093 finishReadObject(my_data, device); 1094 1095 return result; 1096 } 1097 1098 VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout( 1099 VkDevice device, 1100 VkPipelineLayout pipelineLayout, 1101 const VkAllocationCallbacks* pAllocator) 1102 { 1103 dispatch_key key = get_dispatch_key(device); 1104 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1105 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1106 startReadObject(my_data, device); 1107 startWriteObject(my_data, pipelineLayout); 1108 // Host access to pipelineLayout must be externally synchronized 1109 1110 pTable->DestroyPipelineLayout(device,pipelineLayout,pAllocator); 1111 finishReadObject(my_data, device); 1112 finishWriteObject(my_data, pipelineLayout); 1113 // Host access to pipelineLayout must be externally synchronized 1114 1115 } 1116 1117 VKAPI_ATTR VkResult VKAPI_CALL CreateSampler( 1118 VkDevice device, 1119 const VkSamplerCreateInfo* pCreateInfo, 1120 const VkAllocationCallbacks* pAllocator, 1121 VkSampler* pSampler) 1122 { 1123 dispatch_key key = get_dispatch_key(device); 1124 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1125 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1126 VkResult result; 1127 startReadObject(my_data, device); 1128 1129 result = pTable->CreateSampler(device,pCreateInfo,pAllocator,pSampler); 1130 finishReadObject(my_data, device); 1131 1132 return result; 1133 } 1134 1135 VKAPI_ATTR void VKAPI_CALL DestroySampler( 1136 VkDevice device, 1137 VkSampler sampler, 1138 const VkAllocationCallbacks* pAllocator) 1139 { 1140 dispatch_key key = get_dispatch_key(device); 1141 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1142 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1143 startReadObject(my_data, device); 1144 startWriteObject(my_data, sampler); 1145 // Host access to sampler must be externally synchronized 1146 1147 pTable->DestroySampler(device,sampler,pAllocator); 1148 finishReadObject(my_data, device); 1149 finishWriteObject(my_data, sampler); 1150 // Host access to sampler must be externally synchronized 1151 1152 } 1153 1154 VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout( 1155 VkDevice device, 1156 const VkDescriptorSetLayoutCreateInfo* pCreateInfo, 1157 const VkAllocationCallbacks* pAllocator, 1158 VkDescriptorSetLayout* pSetLayout) 1159 { 1160 dispatch_key key = get_dispatch_key(device); 1161 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1162 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1163 VkResult result; 1164 startReadObject(my_data, device); 1165 1166 result = pTable->CreateDescriptorSetLayout(device,pCreateInfo,pAllocator,pSetLayout); 1167 finishReadObject(my_data, device); 1168 1169 return result; 1170 } 1171 1172 VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout( 1173 VkDevice device, 1174 VkDescriptorSetLayout descriptorSetLayout, 1175 const VkAllocationCallbacks* pAllocator) 1176 { 1177 dispatch_key key = get_dispatch_key(device); 1178 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1179 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1180 startReadObject(my_data, device); 1181 startWriteObject(my_data, descriptorSetLayout); 1182 // Host access to descriptorSetLayout must be externally synchronized 1183 1184 pTable->DestroyDescriptorSetLayout(device,descriptorSetLayout,pAllocator); 1185 finishReadObject(my_data, device); 1186 finishWriteObject(my_data, descriptorSetLayout); 1187 // Host access to descriptorSetLayout must be externally synchronized 1188 1189 } 1190 1191 VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool( 1192 VkDevice device, 1193 const VkDescriptorPoolCreateInfo* pCreateInfo, 1194 const VkAllocationCallbacks* pAllocator, 1195 VkDescriptorPool* pDescriptorPool) 1196 { 1197 dispatch_key key = get_dispatch_key(device); 1198 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1199 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1200 VkResult result; 1201 startReadObject(my_data, device); 1202 1203 result = pTable->CreateDescriptorPool(device,pCreateInfo,pAllocator,pDescriptorPool); 1204 finishReadObject(my_data, device); 1205 1206 return result; 1207 } 1208 1209 VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool( 1210 VkDevice device, 1211 VkDescriptorPool descriptorPool, 1212 const VkAllocationCallbacks* pAllocator) 1213 { 1214 dispatch_key key = get_dispatch_key(device); 1215 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1216 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1217 startReadObject(my_data, device); 1218 startWriteObject(my_data, descriptorPool); 1219 // Host access to descriptorPool must be externally synchronized 1220 1221 pTable->DestroyDescriptorPool(device,descriptorPool,pAllocator); 1222 finishReadObject(my_data, device); 1223 finishWriteObject(my_data, descriptorPool); 1224 // Host access to descriptorPool must be externally synchronized 1225 1226 } 1227 1228 VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool( 1229 VkDevice device, 1230 VkDescriptorPool descriptorPool, 1231 VkDescriptorPoolResetFlags flags) 1232 { 1233 dispatch_key key = get_dispatch_key(device); 1234 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1235 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1236 VkResult result; 1237 startReadObject(my_data, device); 1238 startWriteObject(my_data, descriptorPool); 1239 // Host access to descriptorPool must be externally synchronized 1240 // any sname:VkDescriptorSet objects allocated from pname:descriptorPool must be externally synchronized between host accesses 1241 1242 result = pTable->ResetDescriptorPool(device,descriptorPool,flags); 1243 finishReadObject(my_data, device); 1244 finishWriteObject(my_data, descriptorPool); 1245 // Host access to descriptorPool must be externally synchronized 1246 // any sname:VkDescriptorSet objects allocated from pname:descriptorPool must be externally synchronized between host accesses 1247 1248 return result; 1249 } 1250 1251 VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets( 1252 VkDevice device, 1253 const VkDescriptorSetAllocateInfo* pAllocateInfo, 1254 VkDescriptorSet* pDescriptorSets) 1255 { 1256 dispatch_key key = get_dispatch_key(device); 1257 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1258 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1259 VkResult result; 1260 startReadObject(my_data, device); 1261 startWriteObject(my_data, pAllocateInfo->descriptorPool); 1262 // Host access to pAllocateInfo->descriptorPool must be externally synchronized 1263 1264 result = pTable->AllocateDescriptorSets(device,pAllocateInfo,pDescriptorSets); 1265 finishReadObject(my_data, device); 1266 finishWriteObject(my_data, pAllocateInfo->descriptorPool); 1267 // Host access to pAllocateInfo->descriptorPool must be externally synchronized 1268 1269 return result; 1270 } 1271 1272 VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets( 1273 VkDevice device, 1274 VkDescriptorPool descriptorPool, 1275 uint32_t descriptorSetCount, 1276 const VkDescriptorSet* pDescriptorSets) 1277 { 1278 dispatch_key key = get_dispatch_key(device); 1279 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1280 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1281 VkResult result; 1282 startReadObject(my_data, device); 1283 startWriteObject(my_data, descriptorPool); 1284 for (uint32_t index=0;index<descriptorSetCount;index++) { 1285 startWriteObject(my_data, pDescriptorSets[index]); 1286 } 1287 // Host access to descriptorPool must be externally synchronized 1288 // Host access to each member of pDescriptorSets must be externally synchronized 1289 1290 result = pTable->FreeDescriptorSets(device,descriptorPool,descriptorSetCount,pDescriptorSets); 1291 finishReadObject(my_data, device); 1292 finishWriteObject(my_data, descriptorPool); 1293 for (uint32_t index=0;index<descriptorSetCount;index++) { 1294 finishWriteObject(my_data, pDescriptorSets[index]); 1295 } 1296 // Host access to descriptorPool must be externally synchronized 1297 // Host access to each member of pDescriptorSets must be externally synchronized 1298 1299 return result; 1300 } 1301 1302 VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets( 1303 VkDevice device, 1304 uint32_t descriptorWriteCount, 1305 const VkWriteDescriptorSet* pDescriptorWrites, 1306 uint32_t descriptorCopyCount, 1307 const VkCopyDescriptorSet* pDescriptorCopies) 1308 { 1309 dispatch_key key = get_dispatch_key(device); 1310 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1311 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1312 startReadObject(my_data, device); 1313 for (uint32_t index=0;index<descriptorWriteCount;index++) { 1314 startWriteObject(my_data, pDescriptorWrites[index].dstSet); 1315 } 1316 for (uint32_t index=0;index<descriptorCopyCount;index++) { 1317 startWriteObject(my_data, pDescriptorCopies[index].dstSet); 1318 } 1319 // Host access to pDescriptorWrites[].dstSet must be externally synchronized 1320 // Host access to pDescriptorCopies[].dstSet must be externally synchronized 1321 1322 pTable->UpdateDescriptorSets(device,descriptorWriteCount,pDescriptorWrites,descriptorCopyCount,pDescriptorCopies); 1323 finishReadObject(my_data, device); 1324 for (uint32_t index=0;index<descriptorWriteCount;index++) { 1325 finishWriteObject(my_data, pDescriptorWrites[index].dstSet); 1326 } 1327 for (uint32_t index=0;index<descriptorCopyCount;index++) { 1328 finishWriteObject(my_data, pDescriptorCopies[index].dstSet); 1329 } 1330 // Host access to pDescriptorWrites[].dstSet must be externally synchronized 1331 // Host access to pDescriptorCopies[].dstSet must be externally synchronized 1332 1333 } 1334 1335 VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer( 1336 VkDevice device, 1337 const VkFramebufferCreateInfo* pCreateInfo, 1338 const VkAllocationCallbacks* pAllocator, 1339 VkFramebuffer* pFramebuffer) 1340 { 1341 dispatch_key key = get_dispatch_key(device); 1342 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1343 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1344 VkResult result; 1345 startReadObject(my_data, device); 1346 1347 result = pTable->CreateFramebuffer(device,pCreateInfo,pAllocator,pFramebuffer); 1348 finishReadObject(my_data, device); 1349 1350 return result; 1351 } 1352 1353 VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer( 1354 VkDevice device, 1355 VkFramebuffer framebuffer, 1356 const VkAllocationCallbacks* pAllocator) 1357 { 1358 dispatch_key key = get_dispatch_key(device); 1359 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1360 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1361 startReadObject(my_data, device); 1362 startWriteObject(my_data, framebuffer); 1363 // Host access to framebuffer must be externally synchronized 1364 1365 pTable->DestroyFramebuffer(device,framebuffer,pAllocator); 1366 finishReadObject(my_data, device); 1367 finishWriteObject(my_data, framebuffer); 1368 // Host access to framebuffer must be externally synchronized 1369 1370 } 1371 1372 VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass( 1373 VkDevice device, 1374 const VkRenderPassCreateInfo* pCreateInfo, 1375 const VkAllocationCallbacks* pAllocator, 1376 VkRenderPass* pRenderPass) 1377 { 1378 dispatch_key key = get_dispatch_key(device); 1379 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1380 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1381 VkResult result; 1382 startReadObject(my_data, device); 1383 1384 result = pTable->CreateRenderPass(device,pCreateInfo,pAllocator,pRenderPass); 1385 finishReadObject(my_data, device); 1386 1387 return result; 1388 } 1389 1390 VKAPI_ATTR void VKAPI_CALL DestroyRenderPass( 1391 VkDevice device, 1392 VkRenderPass renderPass, 1393 const VkAllocationCallbacks* pAllocator) 1394 { 1395 dispatch_key key = get_dispatch_key(device); 1396 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1397 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1398 startReadObject(my_data, device); 1399 startWriteObject(my_data, renderPass); 1400 // Host access to renderPass must be externally synchronized 1401 1402 pTable->DestroyRenderPass(device,renderPass,pAllocator); 1403 finishReadObject(my_data, device); 1404 finishWriteObject(my_data, renderPass); 1405 // Host access to renderPass must be externally synchronized 1406 1407 } 1408 1409 VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity( 1410 VkDevice device, 1411 VkRenderPass renderPass, 1412 VkExtent2D* pGranularity) 1413 { 1414 dispatch_key key = get_dispatch_key(device); 1415 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1416 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1417 startReadObject(my_data, device); 1418 startReadObject(my_data, renderPass); 1419 1420 pTable->GetRenderAreaGranularity(device,renderPass,pGranularity); 1421 finishReadObject(my_data, device); 1422 finishReadObject(my_data, renderPass); 1423 1424 } 1425 1426 VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool( 1427 VkDevice device, 1428 const VkCommandPoolCreateInfo* pCreateInfo, 1429 const VkAllocationCallbacks* pAllocator, 1430 VkCommandPool* pCommandPool) 1431 { 1432 dispatch_key key = get_dispatch_key(device); 1433 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1434 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1435 VkResult result; 1436 startReadObject(my_data, device); 1437 1438 result = pTable->CreateCommandPool(device,pCreateInfo,pAllocator,pCommandPool); 1439 finishReadObject(my_data, device); 1440 1441 return result; 1442 } 1443 1444 VKAPI_ATTR void VKAPI_CALL DestroyCommandPool( 1445 VkDevice device, 1446 VkCommandPool commandPool, 1447 const VkAllocationCallbacks* pAllocator) 1448 { 1449 dispatch_key key = get_dispatch_key(device); 1450 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1451 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1452 startReadObject(my_data, device); 1453 startWriteObject(my_data, commandPool); 1454 // Host access to commandPool must be externally synchronized 1455 1456 pTable->DestroyCommandPool(device,commandPool,pAllocator); 1457 finishReadObject(my_data, device); 1458 finishWriteObject(my_data, commandPool); 1459 // Host access to commandPool must be externally synchronized 1460 1461 } 1462 1463 VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool( 1464 VkDevice device, 1465 VkCommandPool commandPool, 1466 VkCommandPoolResetFlags flags) 1467 { 1468 dispatch_key key = get_dispatch_key(device); 1469 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1470 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1471 VkResult result; 1472 startReadObject(my_data, device); 1473 startWriteObject(my_data, commandPool); 1474 // Host access to commandPool must be externally synchronized 1475 1476 result = pTable->ResetCommandPool(device,commandPool,flags); 1477 finishReadObject(my_data, device); 1478 finishWriteObject(my_data, commandPool); 1479 // Host access to commandPool must be externally synchronized 1480 1481 return result; 1482 } 1483 1484 // declare only 1485 VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers( 1486 VkDevice device, 1487 const VkCommandBufferAllocateInfo* pAllocateInfo, 1488 VkCommandBuffer* pCommandBuffers); 1489 1490 // declare only 1491 VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers( 1492 VkDevice device, 1493 VkCommandPool commandPool, 1494 uint32_t commandBufferCount, 1495 const VkCommandBuffer* pCommandBuffers); 1496 1497 VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer( 1498 VkCommandBuffer commandBuffer, 1499 const VkCommandBufferBeginInfo* pBeginInfo) 1500 { 1501 dispatch_key key = get_dispatch_key(commandBuffer); 1502 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1503 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1504 VkResult result; 1505 startWriteObject(my_data, commandBuffer); 1506 // Host access to commandBuffer must be externally synchronized 1507 1508 result = pTable->BeginCommandBuffer(commandBuffer,pBeginInfo); 1509 finishWriteObject(my_data, commandBuffer); 1510 // Host access to commandBuffer must be externally synchronized 1511 1512 return result; 1513 } 1514 1515 VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer( 1516 VkCommandBuffer commandBuffer) 1517 { 1518 dispatch_key key = get_dispatch_key(commandBuffer); 1519 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1520 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1521 VkResult result; 1522 startWriteObject(my_data, commandBuffer); 1523 // Host access to commandBuffer must be externally synchronized 1524 1525 result = pTable->EndCommandBuffer(commandBuffer); 1526 finishWriteObject(my_data, commandBuffer); 1527 // Host access to commandBuffer must be externally synchronized 1528 1529 return result; 1530 } 1531 1532 VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer( 1533 VkCommandBuffer commandBuffer, 1534 VkCommandBufferResetFlags flags) 1535 { 1536 dispatch_key key = get_dispatch_key(commandBuffer); 1537 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1538 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1539 VkResult result; 1540 startWriteObject(my_data, commandBuffer); 1541 // Host access to commandBuffer must be externally synchronized 1542 1543 result = pTable->ResetCommandBuffer(commandBuffer,flags); 1544 finishWriteObject(my_data, commandBuffer); 1545 // Host access to commandBuffer must be externally synchronized 1546 1547 return result; 1548 } 1549 1550 VKAPI_ATTR void VKAPI_CALL CmdBindPipeline( 1551 VkCommandBuffer commandBuffer, 1552 VkPipelineBindPoint pipelineBindPoint, 1553 VkPipeline pipeline) 1554 { 1555 dispatch_key key = get_dispatch_key(commandBuffer); 1556 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1557 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1558 startWriteObject(my_data, commandBuffer); 1559 startReadObject(my_data, pipeline); 1560 // Host access to commandBuffer must be externally synchronized 1561 1562 pTable->CmdBindPipeline(commandBuffer,pipelineBindPoint,pipeline); 1563 finishWriteObject(my_data, commandBuffer); 1564 finishReadObject(my_data, pipeline); 1565 // Host access to commandBuffer must be externally synchronized 1566 1567 } 1568 1569 VKAPI_ATTR void VKAPI_CALL CmdSetViewport( 1570 VkCommandBuffer commandBuffer, 1571 uint32_t firstViewport, 1572 uint32_t viewportCount, 1573 const VkViewport* pViewports) 1574 { 1575 dispatch_key key = get_dispatch_key(commandBuffer); 1576 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1577 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1578 startWriteObject(my_data, commandBuffer); 1579 // Host access to commandBuffer must be externally synchronized 1580 1581 pTable->CmdSetViewport(commandBuffer,firstViewport,viewportCount,pViewports); 1582 finishWriteObject(my_data, commandBuffer); 1583 // Host access to commandBuffer must be externally synchronized 1584 1585 } 1586 1587 VKAPI_ATTR void VKAPI_CALL CmdSetScissor( 1588 VkCommandBuffer commandBuffer, 1589 uint32_t firstScissor, 1590 uint32_t scissorCount, 1591 const VkRect2D* pScissors) 1592 { 1593 dispatch_key key = get_dispatch_key(commandBuffer); 1594 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1595 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1596 startWriteObject(my_data, commandBuffer); 1597 // Host access to commandBuffer must be externally synchronized 1598 1599 pTable->CmdSetScissor(commandBuffer,firstScissor,scissorCount,pScissors); 1600 finishWriteObject(my_data, commandBuffer); 1601 // Host access to commandBuffer must be externally synchronized 1602 1603 } 1604 1605 VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth( 1606 VkCommandBuffer commandBuffer, 1607 float lineWidth) 1608 { 1609 dispatch_key key = get_dispatch_key(commandBuffer); 1610 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1611 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1612 startWriteObject(my_data, commandBuffer); 1613 // Host access to commandBuffer must be externally synchronized 1614 1615 pTable->CmdSetLineWidth(commandBuffer,lineWidth); 1616 finishWriteObject(my_data, commandBuffer); 1617 // Host access to commandBuffer must be externally synchronized 1618 1619 } 1620 1621 VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias( 1622 VkCommandBuffer commandBuffer, 1623 float depthBiasConstantFactor, 1624 float depthBiasClamp, 1625 float depthBiasSlopeFactor) 1626 { 1627 dispatch_key key = get_dispatch_key(commandBuffer); 1628 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1629 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1630 startWriteObject(my_data, commandBuffer); 1631 // Host access to commandBuffer must be externally synchronized 1632 1633 pTable->CmdSetDepthBias(commandBuffer,depthBiasConstantFactor,depthBiasClamp,depthBiasSlopeFactor); 1634 finishWriteObject(my_data, commandBuffer); 1635 // Host access to commandBuffer must be externally synchronized 1636 1637 } 1638 1639 VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants( 1640 VkCommandBuffer commandBuffer, 1641 const float blendConstants[4]) 1642 { 1643 dispatch_key key = get_dispatch_key(commandBuffer); 1644 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1645 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1646 startWriteObject(my_data, commandBuffer); 1647 // Host access to commandBuffer must be externally synchronized 1648 1649 pTable->CmdSetBlendConstants(commandBuffer,blendConstants); 1650 finishWriteObject(my_data, commandBuffer); 1651 // Host access to commandBuffer must be externally synchronized 1652 1653 } 1654 1655 VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds( 1656 VkCommandBuffer commandBuffer, 1657 float minDepthBounds, 1658 float maxDepthBounds) 1659 { 1660 dispatch_key key = get_dispatch_key(commandBuffer); 1661 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1662 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1663 startWriteObject(my_data, commandBuffer); 1664 // Host access to commandBuffer must be externally synchronized 1665 1666 pTable->CmdSetDepthBounds(commandBuffer,minDepthBounds,maxDepthBounds); 1667 finishWriteObject(my_data, commandBuffer); 1668 // Host access to commandBuffer must be externally synchronized 1669 1670 } 1671 1672 VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask( 1673 VkCommandBuffer commandBuffer, 1674 VkStencilFaceFlags faceMask, 1675 uint32_t compareMask) 1676 { 1677 dispatch_key key = get_dispatch_key(commandBuffer); 1678 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1679 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1680 startWriteObject(my_data, commandBuffer); 1681 // Host access to commandBuffer must be externally synchronized 1682 1683 pTable->CmdSetStencilCompareMask(commandBuffer,faceMask,compareMask); 1684 finishWriteObject(my_data, commandBuffer); 1685 // Host access to commandBuffer must be externally synchronized 1686 1687 } 1688 1689 VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask( 1690 VkCommandBuffer commandBuffer, 1691 VkStencilFaceFlags faceMask, 1692 uint32_t writeMask) 1693 { 1694 dispatch_key key = get_dispatch_key(commandBuffer); 1695 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1696 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1697 startWriteObject(my_data, commandBuffer); 1698 // Host access to commandBuffer must be externally synchronized 1699 1700 pTable->CmdSetStencilWriteMask(commandBuffer,faceMask,writeMask); 1701 finishWriteObject(my_data, commandBuffer); 1702 // Host access to commandBuffer must be externally synchronized 1703 1704 } 1705 1706 VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference( 1707 VkCommandBuffer commandBuffer, 1708 VkStencilFaceFlags faceMask, 1709 uint32_t reference) 1710 { 1711 dispatch_key key = get_dispatch_key(commandBuffer); 1712 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1713 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1714 startWriteObject(my_data, commandBuffer); 1715 // Host access to commandBuffer must be externally synchronized 1716 1717 pTable->CmdSetStencilReference(commandBuffer,faceMask,reference); 1718 finishWriteObject(my_data, commandBuffer); 1719 // Host access to commandBuffer must be externally synchronized 1720 1721 } 1722 1723 VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets( 1724 VkCommandBuffer commandBuffer, 1725 VkPipelineBindPoint pipelineBindPoint, 1726 VkPipelineLayout layout, 1727 uint32_t firstSet, 1728 uint32_t descriptorSetCount, 1729 const VkDescriptorSet* pDescriptorSets, 1730 uint32_t dynamicOffsetCount, 1731 const uint32_t* pDynamicOffsets) 1732 { 1733 dispatch_key key = get_dispatch_key(commandBuffer); 1734 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1735 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1736 startWriteObject(my_data, commandBuffer); 1737 startReadObject(my_data, layout); 1738 // Host access to commandBuffer must be externally synchronized 1739 1740 pTable->CmdBindDescriptorSets(commandBuffer,pipelineBindPoint,layout,firstSet,descriptorSetCount,pDescriptorSets,dynamicOffsetCount,pDynamicOffsets); 1741 finishWriteObject(my_data, commandBuffer); 1742 finishReadObject(my_data, layout); 1743 // Host access to commandBuffer must be externally synchronized 1744 1745 } 1746 1747 VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer( 1748 VkCommandBuffer commandBuffer, 1749 VkBuffer buffer, 1750 VkDeviceSize offset, 1751 VkIndexType indexType) 1752 { 1753 dispatch_key key = get_dispatch_key(commandBuffer); 1754 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1755 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1756 startWriteObject(my_data, commandBuffer); 1757 startReadObject(my_data, buffer); 1758 // Host access to commandBuffer must be externally synchronized 1759 1760 pTable->CmdBindIndexBuffer(commandBuffer,buffer,offset,indexType); 1761 finishWriteObject(my_data, commandBuffer); 1762 finishReadObject(my_data, buffer); 1763 // Host access to commandBuffer must be externally synchronized 1764 1765 } 1766 1767 VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers( 1768 VkCommandBuffer commandBuffer, 1769 uint32_t firstBinding, 1770 uint32_t bindingCount, 1771 const VkBuffer* pBuffers, 1772 const VkDeviceSize* pOffsets) 1773 { 1774 dispatch_key key = get_dispatch_key(commandBuffer); 1775 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1776 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1777 startWriteObject(my_data, commandBuffer); 1778 for (uint32_t index=0;index<bindingCount;index++) { 1779 startReadObject(my_data, pBuffers[index]); 1780 } 1781 // Host access to commandBuffer must be externally synchronized 1782 1783 pTable->CmdBindVertexBuffers(commandBuffer,firstBinding,bindingCount,pBuffers,pOffsets); 1784 finishWriteObject(my_data, commandBuffer); 1785 for (uint32_t index=0;index<bindingCount;index++) { 1786 finishReadObject(my_data, pBuffers[index]); 1787 } 1788 // Host access to commandBuffer must be externally synchronized 1789 1790 } 1791 1792 VKAPI_ATTR void VKAPI_CALL CmdDraw( 1793 VkCommandBuffer commandBuffer, 1794 uint32_t vertexCount, 1795 uint32_t instanceCount, 1796 uint32_t firstVertex, 1797 uint32_t firstInstance) 1798 { 1799 dispatch_key key = get_dispatch_key(commandBuffer); 1800 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1801 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1802 startWriteObject(my_data, commandBuffer); 1803 // Host access to commandBuffer must be externally synchronized 1804 1805 pTable->CmdDraw(commandBuffer,vertexCount,instanceCount,firstVertex,firstInstance); 1806 finishWriteObject(my_data, commandBuffer); 1807 // Host access to commandBuffer must be externally synchronized 1808 1809 } 1810 1811 VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed( 1812 VkCommandBuffer commandBuffer, 1813 uint32_t indexCount, 1814 uint32_t instanceCount, 1815 uint32_t firstIndex, 1816 int32_t vertexOffset, 1817 uint32_t firstInstance) 1818 { 1819 dispatch_key key = get_dispatch_key(commandBuffer); 1820 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1821 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1822 startWriteObject(my_data, commandBuffer); 1823 // Host access to commandBuffer must be externally synchronized 1824 1825 pTable->CmdDrawIndexed(commandBuffer,indexCount,instanceCount,firstIndex,vertexOffset,firstInstance); 1826 finishWriteObject(my_data, commandBuffer); 1827 // Host access to commandBuffer must be externally synchronized 1828 1829 } 1830 1831 VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect( 1832 VkCommandBuffer commandBuffer, 1833 VkBuffer buffer, 1834 VkDeviceSize offset, 1835 uint32_t drawCount, 1836 uint32_t stride) 1837 { 1838 dispatch_key key = get_dispatch_key(commandBuffer); 1839 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1840 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1841 startWriteObject(my_data, commandBuffer); 1842 startReadObject(my_data, buffer); 1843 // Host access to commandBuffer must be externally synchronized 1844 1845 pTable->CmdDrawIndirect(commandBuffer,buffer,offset,drawCount,stride); 1846 finishWriteObject(my_data, commandBuffer); 1847 finishReadObject(my_data, buffer); 1848 // Host access to commandBuffer must be externally synchronized 1849 1850 } 1851 1852 VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect( 1853 VkCommandBuffer commandBuffer, 1854 VkBuffer buffer, 1855 VkDeviceSize offset, 1856 uint32_t drawCount, 1857 uint32_t stride) 1858 { 1859 dispatch_key key = get_dispatch_key(commandBuffer); 1860 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1861 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1862 startWriteObject(my_data, commandBuffer); 1863 startReadObject(my_data, buffer); 1864 // Host access to commandBuffer must be externally synchronized 1865 1866 pTable->CmdDrawIndexedIndirect(commandBuffer,buffer,offset,drawCount,stride); 1867 finishWriteObject(my_data, commandBuffer); 1868 finishReadObject(my_data, buffer); 1869 // Host access to commandBuffer must be externally synchronized 1870 1871 } 1872 1873 VKAPI_ATTR void VKAPI_CALL CmdDispatch( 1874 VkCommandBuffer commandBuffer, 1875 uint32_t x, 1876 uint32_t y, 1877 uint32_t z) 1878 { 1879 dispatch_key key = get_dispatch_key(commandBuffer); 1880 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1881 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1882 startWriteObject(my_data, commandBuffer); 1883 // Host access to commandBuffer must be externally synchronized 1884 1885 pTable->CmdDispatch(commandBuffer,x,y,z); 1886 finishWriteObject(my_data, commandBuffer); 1887 // Host access to commandBuffer must be externally synchronized 1888 1889 } 1890 1891 VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect( 1892 VkCommandBuffer commandBuffer, 1893 VkBuffer buffer, 1894 VkDeviceSize offset) 1895 { 1896 dispatch_key key = get_dispatch_key(commandBuffer); 1897 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1898 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1899 startWriteObject(my_data, commandBuffer); 1900 startReadObject(my_data, buffer); 1901 // Host access to commandBuffer must be externally synchronized 1902 1903 pTable->CmdDispatchIndirect(commandBuffer,buffer,offset); 1904 finishWriteObject(my_data, commandBuffer); 1905 finishReadObject(my_data, buffer); 1906 // Host access to commandBuffer must be externally synchronized 1907 1908 } 1909 1910 VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer( 1911 VkCommandBuffer commandBuffer, 1912 VkBuffer srcBuffer, 1913 VkBuffer dstBuffer, 1914 uint32_t regionCount, 1915 const VkBufferCopy* pRegions) 1916 { 1917 dispatch_key key = get_dispatch_key(commandBuffer); 1918 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1919 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1920 startWriteObject(my_data, commandBuffer); 1921 startReadObject(my_data, srcBuffer); 1922 startReadObject(my_data, dstBuffer); 1923 // Host access to commandBuffer must be externally synchronized 1924 1925 pTable->CmdCopyBuffer(commandBuffer,srcBuffer,dstBuffer,regionCount,pRegions); 1926 finishWriteObject(my_data, commandBuffer); 1927 finishReadObject(my_data, srcBuffer); 1928 finishReadObject(my_data, dstBuffer); 1929 // Host access to commandBuffer must be externally synchronized 1930 1931 } 1932 1933 VKAPI_ATTR void VKAPI_CALL CmdCopyImage( 1934 VkCommandBuffer commandBuffer, 1935 VkImage srcImage, 1936 VkImageLayout srcImageLayout, 1937 VkImage dstImage, 1938 VkImageLayout dstImageLayout, 1939 uint32_t regionCount, 1940 const VkImageCopy* pRegions) 1941 { 1942 dispatch_key key = get_dispatch_key(commandBuffer); 1943 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1944 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1945 startWriteObject(my_data, commandBuffer); 1946 startReadObject(my_data, srcImage); 1947 startReadObject(my_data, dstImage); 1948 // Host access to commandBuffer must be externally synchronized 1949 1950 pTable->CmdCopyImage(commandBuffer,srcImage,srcImageLayout,dstImage,dstImageLayout,regionCount,pRegions); 1951 finishWriteObject(my_data, commandBuffer); 1952 finishReadObject(my_data, srcImage); 1953 finishReadObject(my_data, dstImage); 1954 // Host access to commandBuffer must be externally synchronized 1955 1956 } 1957 1958 VKAPI_ATTR void VKAPI_CALL CmdBlitImage( 1959 VkCommandBuffer commandBuffer, 1960 VkImage srcImage, 1961 VkImageLayout srcImageLayout, 1962 VkImage dstImage, 1963 VkImageLayout dstImageLayout, 1964 uint32_t regionCount, 1965 const VkImageBlit* pRegions, 1966 VkFilter filter) 1967 { 1968 dispatch_key key = get_dispatch_key(commandBuffer); 1969 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1970 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1971 startWriteObject(my_data, commandBuffer); 1972 startReadObject(my_data, srcImage); 1973 startReadObject(my_data, dstImage); 1974 // Host access to commandBuffer must be externally synchronized 1975 1976 pTable->CmdBlitImage(commandBuffer,srcImage,srcImageLayout,dstImage,dstImageLayout,regionCount,pRegions,filter); 1977 finishWriteObject(my_data, commandBuffer); 1978 finishReadObject(my_data, srcImage); 1979 finishReadObject(my_data, dstImage); 1980 // Host access to commandBuffer must be externally synchronized 1981 1982 } 1983 1984 VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage( 1985 VkCommandBuffer commandBuffer, 1986 VkBuffer srcBuffer, 1987 VkImage dstImage, 1988 VkImageLayout dstImageLayout, 1989 uint32_t regionCount, 1990 const VkBufferImageCopy* pRegions) 1991 { 1992 dispatch_key key = get_dispatch_key(commandBuffer); 1993 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1994 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 1995 startWriteObject(my_data, commandBuffer); 1996 startReadObject(my_data, srcBuffer); 1997 startReadObject(my_data, dstImage); 1998 // Host access to commandBuffer must be externally synchronized 1999 2000 pTable->CmdCopyBufferToImage(commandBuffer,srcBuffer,dstImage,dstImageLayout,regionCount,pRegions); 2001 finishWriteObject(my_data, commandBuffer); 2002 finishReadObject(my_data, srcBuffer); 2003 finishReadObject(my_data, dstImage); 2004 // Host access to commandBuffer must be externally synchronized 2005 2006 } 2007 2008 VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer( 2009 VkCommandBuffer commandBuffer, 2010 VkImage srcImage, 2011 VkImageLayout srcImageLayout, 2012 VkBuffer dstBuffer, 2013 uint32_t regionCount, 2014 const VkBufferImageCopy* pRegions) 2015 { 2016 dispatch_key key = get_dispatch_key(commandBuffer); 2017 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 2018 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 2019 startWriteObject(my_data, commandBuffer); 2020 startReadObject(my_data, srcImage); 2021 startReadObject(my_data, dstBuffer); 2022 // Host access to commandBuffer must be externally synchronized 2023 2024 pTable->CmdCopyImageToBuffer(commandBuffer,srcImage,srcImageLayout,dstBuffer,regionCount,pRegions); 2025 finishWriteObject(my_data, commandBuffer); 2026 finishReadObject(my_data, srcImage); 2027 finishReadObject(my_data, dstBuffer); 2028 // Host access to commandBuffer must be externally synchronized 2029 2030 } 2031 2032 VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer( 2033 VkCommandBuffer commandBuffer, 2034 VkBuffer dstBuffer, 2035 VkDeviceSize dstOffset, 2036 VkDeviceSize dataSize, 2037 const uint32_t* pData) 2038 { 2039 dispatch_key key = get_dispatch_key(commandBuffer); 2040 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 2041 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 2042 startWriteObject(my_data, commandBuffer); 2043 startReadObject(my_data, dstBuffer); 2044 // Host access to commandBuffer must be externally synchronized 2045 2046 pTable->CmdUpdateBuffer(commandBuffer,dstBuffer,dstOffset,dataSize,pData); 2047 finishWriteObject(my_data, commandBuffer); 2048 finishReadObject(my_data, dstBuffer); 2049 // Host access to commandBuffer must be externally synchronized 2050 2051 } 2052 2053 VKAPI_ATTR void VKAPI_CALL CmdFillBuffer( 2054 VkCommandBuffer commandBuffer, 2055 VkBuffer dstBuffer, 2056 VkDeviceSize dstOffset, 2057 VkDeviceSize size, 2058 uint32_t data) 2059 { 2060 dispatch_key key = get_dispatch_key(commandBuffer); 2061 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 2062 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 2063 startWriteObject(my_data, commandBuffer); 2064 startReadObject(my_data, dstBuffer); 2065 // Host access to commandBuffer must be externally synchronized 2066 2067 pTable->CmdFillBuffer(commandBuffer,dstBuffer,dstOffset,size,data); 2068 finishWriteObject(my_data, commandBuffer); 2069 finishReadObject(my_data, dstBuffer); 2070 // Host access to commandBuffer must be externally synchronized 2071 2072 } 2073 2074 VKAPI_ATTR void VKAPI_CALL CmdClearColorImage( 2075 VkCommandBuffer commandBuffer, 2076 VkImage image, 2077 VkImageLayout imageLayout, 2078 const VkClearColorValue* pColor, 2079 uint32_t rangeCount, 2080 const VkImageSubresourceRange* pRanges) 2081 { 2082 dispatch_key key = get_dispatch_key(commandBuffer); 2083 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 2084 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 2085 startWriteObject(my_data, commandBuffer); 2086 startReadObject(my_data, image); 2087 // Host access to commandBuffer must be externally synchronized 2088 2089 pTable->CmdClearColorImage(commandBuffer,image,imageLayout,pColor,rangeCount,pRanges); 2090 finishWriteObject(my_data, commandBuffer); 2091 finishReadObject(my_data, image); 2092 // Host access to commandBuffer must be externally synchronized 2093 2094 } 2095 2096 VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage( 2097 VkCommandBuffer commandBuffer, 2098 VkImage image, 2099 VkImageLayout imageLayout, 2100 const VkClearDepthStencilValue* pDepthStencil, 2101 uint32_t rangeCount, 2102 const VkImageSubresourceRange* pRanges) 2103 { 2104 dispatch_key key = get_dispatch_key(commandBuffer); 2105 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 2106 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 2107 startWriteObject(my_data, commandBuffer); 2108 startReadObject(my_data, image); 2109 // Host access to commandBuffer must be externally synchronized 2110 2111 pTable->CmdClearDepthStencilImage(commandBuffer,image,imageLayout,pDepthStencil,rangeCount,pRanges); 2112 finishWriteObject(my_data, commandBuffer); 2113 finishReadObject(my_data, image); 2114 // Host access to commandBuffer must be externally synchronized 2115 2116 } 2117 2118 VKAPI_ATTR void VKAPI_CALL CmdClearAttachments( 2119 VkCommandBuffer commandBuffer, 2120 uint32_t attachmentCount, 2121 const VkClearAttachment* pAttachments, 2122 uint32_t rectCount, 2123 const VkClearRect* pRects) 2124 { 2125 dispatch_key key = get_dispatch_key(commandBuffer); 2126 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 2127 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 2128 startWriteObject(my_data, commandBuffer); 2129 // Host access to commandBuffer must be externally synchronized 2130 2131 pTable->CmdClearAttachments(commandBuffer,attachmentCount,pAttachments,rectCount,pRects); 2132 finishWriteObject(my_data, commandBuffer); 2133 // Host access to commandBuffer must be externally synchronized 2134 2135 } 2136 2137 VKAPI_ATTR void VKAPI_CALL CmdResolveImage( 2138 VkCommandBuffer commandBuffer, 2139 VkImage srcImage, 2140 VkImageLayout srcImageLayout, 2141 VkImage dstImage, 2142 VkImageLayout dstImageLayout, 2143 uint32_t regionCount, 2144 const VkImageResolve* pRegions) 2145 { 2146 dispatch_key key = get_dispatch_key(commandBuffer); 2147 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 2148 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 2149 startWriteObject(my_data, commandBuffer); 2150 startReadObject(my_data, srcImage); 2151 startReadObject(my_data, dstImage); 2152 // Host access to commandBuffer must be externally synchronized 2153 2154 pTable->CmdResolveImage(commandBuffer,srcImage,srcImageLayout,dstImage,dstImageLayout,regionCount,pRegions); 2155 finishWriteObject(my_data, commandBuffer); 2156 finishReadObject(my_data, srcImage); 2157 finishReadObject(my_data, dstImage); 2158 // Host access to commandBuffer must be externally synchronized 2159 2160 } 2161 2162 VKAPI_ATTR void VKAPI_CALL CmdSetEvent( 2163 VkCommandBuffer commandBuffer, 2164 VkEvent event, 2165 VkPipelineStageFlags stageMask) 2166 { 2167 dispatch_key key = get_dispatch_key(commandBuffer); 2168 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 2169 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 2170 startWriteObject(my_data, commandBuffer); 2171 startReadObject(my_data, event); 2172 // Host access to commandBuffer must be externally synchronized 2173 2174 pTable->CmdSetEvent(commandBuffer,event,stageMask); 2175 finishWriteObject(my_data, commandBuffer); 2176 finishReadObject(my_data, event); 2177 // Host access to commandBuffer must be externally synchronized 2178 2179 } 2180 2181 VKAPI_ATTR void VKAPI_CALL CmdResetEvent( 2182 VkCommandBuffer commandBuffer, 2183 VkEvent event, 2184 VkPipelineStageFlags stageMask) 2185 { 2186 dispatch_key key = get_dispatch_key(commandBuffer); 2187 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 2188 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 2189 startWriteObject(my_data, commandBuffer); 2190 startReadObject(my_data, event); 2191 // Host access to commandBuffer must be externally synchronized 2192 2193 pTable->CmdResetEvent(commandBuffer,event,stageMask); 2194 finishWriteObject(my_data, commandBuffer); 2195 finishReadObject(my_data, event); 2196 // Host access to commandBuffer must be externally synchronized 2197 2198 } 2199 2200 VKAPI_ATTR void VKAPI_CALL CmdWaitEvents( 2201 VkCommandBuffer commandBuffer, 2202 uint32_t eventCount, 2203 const VkEvent* pEvents, 2204 VkPipelineStageFlags srcStageMask, 2205 VkPipelineStageFlags dstStageMask, 2206 uint32_t memoryBarrierCount, 2207 const VkMemoryBarrier* pMemoryBarriers, 2208 uint32_t bufferMemoryBarrierCount, 2209 const VkBufferMemoryBarrier* pBufferMemoryBarriers, 2210 uint32_t imageMemoryBarrierCount, 2211 const VkImageMemoryBarrier* pImageMemoryBarriers) 2212 { 2213 dispatch_key key = get_dispatch_key(commandBuffer); 2214 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 2215 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 2216 startWriteObject(my_data, commandBuffer); 2217 for (uint32_t index=0;index<eventCount;index++) { 2218 startReadObject(my_data, pEvents[index]); 2219 } 2220 // Host access to commandBuffer must be externally synchronized 2221 2222 pTable->CmdWaitEvents(commandBuffer,eventCount,pEvents,srcStageMask,dstStageMask,memoryBarrierCount,pMemoryBarriers,bufferMemoryBarrierCount,pBufferMemoryBarriers,imageMemoryBarrierCount,pImageMemoryBarriers); 2223 finishWriteObject(my_data, commandBuffer); 2224 for (uint32_t index=0;index<eventCount;index++) { 2225 finishReadObject(my_data, pEvents[index]); 2226 } 2227 // Host access to commandBuffer must be externally synchronized 2228 2229 } 2230 2231 VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier( 2232 VkCommandBuffer commandBuffer, 2233 VkPipelineStageFlags srcStageMask, 2234 VkPipelineStageFlags dstStageMask, 2235 VkDependencyFlags dependencyFlags, 2236 uint32_t memoryBarrierCount, 2237 const VkMemoryBarrier* pMemoryBarriers, 2238 uint32_t bufferMemoryBarrierCount, 2239 const VkBufferMemoryBarrier* pBufferMemoryBarriers, 2240 uint32_t imageMemoryBarrierCount, 2241 const VkImageMemoryBarrier* pImageMemoryBarriers) 2242 { 2243 dispatch_key key = get_dispatch_key(commandBuffer); 2244 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 2245 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 2246 startWriteObject(my_data, commandBuffer); 2247 // Host access to commandBuffer must be externally synchronized 2248 2249 pTable->CmdPipelineBarrier(commandBuffer,srcStageMask,dstStageMask,dependencyFlags,memoryBarrierCount,pMemoryBarriers,bufferMemoryBarrierCount,pBufferMemoryBarriers,imageMemoryBarrierCount,pImageMemoryBarriers); 2250 finishWriteObject(my_data, commandBuffer); 2251 // Host access to commandBuffer must be externally synchronized 2252 2253 } 2254 2255 VKAPI_ATTR void VKAPI_CALL CmdBeginQuery( 2256 VkCommandBuffer commandBuffer, 2257 VkQueryPool queryPool, 2258 uint32_t query, 2259 VkQueryControlFlags flags) 2260 { 2261 dispatch_key key = get_dispatch_key(commandBuffer); 2262 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 2263 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 2264 startWriteObject(my_data, commandBuffer); 2265 startReadObject(my_data, queryPool); 2266 // Host access to commandBuffer must be externally synchronized 2267 2268 pTable->CmdBeginQuery(commandBuffer,queryPool,query,flags); 2269 finishWriteObject(my_data, commandBuffer); 2270 finishReadObject(my_data, queryPool); 2271 // Host access to commandBuffer must be externally synchronized 2272 2273 } 2274 2275 VKAPI_ATTR void VKAPI_CALL CmdEndQuery( 2276 VkCommandBuffer commandBuffer, 2277 VkQueryPool queryPool, 2278 uint32_t query) 2279 { 2280 dispatch_key key = get_dispatch_key(commandBuffer); 2281 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 2282 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 2283 startWriteObject(my_data, commandBuffer); 2284 startReadObject(my_data, queryPool); 2285 // Host access to commandBuffer must be externally synchronized 2286 2287 pTable->CmdEndQuery(commandBuffer,queryPool,query); 2288 finishWriteObject(my_data, commandBuffer); 2289 finishReadObject(my_data, queryPool); 2290 // Host access to commandBuffer must be externally synchronized 2291 2292 } 2293 2294 VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool( 2295 VkCommandBuffer commandBuffer, 2296 VkQueryPool queryPool, 2297 uint32_t firstQuery, 2298 uint32_t queryCount) 2299 { 2300 dispatch_key key = get_dispatch_key(commandBuffer); 2301 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 2302 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 2303 startWriteObject(my_data, commandBuffer); 2304 startReadObject(my_data, queryPool); 2305 // Host access to commandBuffer must be externally synchronized 2306 2307 pTable->CmdResetQueryPool(commandBuffer,queryPool,firstQuery,queryCount); 2308 finishWriteObject(my_data, commandBuffer); 2309 finishReadObject(my_data, queryPool); 2310 // Host access to commandBuffer must be externally synchronized 2311 2312 } 2313 2314 VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp( 2315 VkCommandBuffer commandBuffer, 2316 VkPipelineStageFlagBits pipelineStage, 2317 VkQueryPool queryPool, 2318 uint32_t query) 2319 { 2320 dispatch_key key = get_dispatch_key(commandBuffer); 2321 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 2322 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 2323 startWriteObject(my_data, commandBuffer); 2324 startReadObject(my_data, queryPool); 2325 // Host access to commandBuffer must be externally synchronized 2326 2327 pTable->CmdWriteTimestamp(commandBuffer,pipelineStage,queryPool,query); 2328 finishWriteObject(my_data, commandBuffer); 2329 finishReadObject(my_data, queryPool); 2330 // Host access to commandBuffer must be externally synchronized 2331 2332 } 2333 2334 VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults( 2335 VkCommandBuffer commandBuffer, 2336 VkQueryPool queryPool, 2337 uint32_t firstQuery, 2338 uint32_t queryCount, 2339 VkBuffer dstBuffer, 2340 VkDeviceSize dstOffset, 2341 VkDeviceSize stride, 2342 VkQueryResultFlags flags) 2343 { 2344 dispatch_key key = get_dispatch_key(commandBuffer); 2345 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 2346 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 2347 startWriteObject(my_data, commandBuffer); 2348 startReadObject(my_data, queryPool); 2349 startReadObject(my_data, dstBuffer); 2350 // Host access to commandBuffer must be externally synchronized 2351 2352 pTable->CmdCopyQueryPoolResults(commandBuffer,queryPool,firstQuery,queryCount,dstBuffer,dstOffset,stride,flags); 2353 finishWriteObject(my_data, commandBuffer); 2354 finishReadObject(my_data, queryPool); 2355 finishReadObject(my_data, dstBuffer); 2356 // Host access to commandBuffer must be externally synchronized 2357 2358 } 2359 2360 VKAPI_ATTR void VKAPI_CALL CmdPushConstants( 2361 VkCommandBuffer commandBuffer, 2362 VkPipelineLayout layout, 2363 VkShaderStageFlags stageFlags, 2364 uint32_t offset, 2365 uint32_t size, 2366 const void* pValues) 2367 { 2368 dispatch_key key = get_dispatch_key(commandBuffer); 2369 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 2370 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 2371 startWriteObject(my_data, commandBuffer); 2372 startReadObject(my_data, layout); 2373 // Host access to commandBuffer must be externally synchronized 2374 2375 pTable->CmdPushConstants(commandBuffer,layout,stageFlags,offset,size,pValues); 2376 finishWriteObject(my_data, commandBuffer); 2377 finishReadObject(my_data, layout); 2378 // Host access to commandBuffer must be externally synchronized 2379 2380 } 2381 2382 VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass( 2383 VkCommandBuffer commandBuffer, 2384 const VkRenderPassBeginInfo* pRenderPassBegin, 2385 VkSubpassContents contents) 2386 { 2387 dispatch_key key = get_dispatch_key(commandBuffer); 2388 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 2389 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 2390 startWriteObject(my_data, commandBuffer); 2391 // Host access to commandBuffer must be externally synchronized 2392 2393 pTable->CmdBeginRenderPass(commandBuffer,pRenderPassBegin,contents); 2394 finishWriteObject(my_data, commandBuffer); 2395 // Host access to commandBuffer must be externally synchronized 2396 2397 } 2398 2399 VKAPI_ATTR void VKAPI_CALL CmdNextSubpass( 2400 VkCommandBuffer commandBuffer, 2401 VkSubpassContents contents) 2402 { 2403 dispatch_key key = get_dispatch_key(commandBuffer); 2404 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 2405 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 2406 startWriteObject(my_data, commandBuffer); 2407 // Host access to commandBuffer must be externally synchronized 2408 2409 pTable->CmdNextSubpass(commandBuffer,contents); 2410 finishWriteObject(my_data, commandBuffer); 2411 // Host access to commandBuffer must be externally synchronized 2412 2413 } 2414 2415 VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass( 2416 VkCommandBuffer commandBuffer) 2417 { 2418 dispatch_key key = get_dispatch_key(commandBuffer); 2419 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 2420 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 2421 startWriteObject(my_data, commandBuffer); 2422 // Host access to commandBuffer must be externally synchronized 2423 2424 pTable->CmdEndRenderPass(commandBuffer); 2425 finishWriteObject(my_data, commandBuffer); 2426 // Host access to commandBuffer must be externally synchronized 2427 2428 } 2429 2430 VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands( 2431 VkCommandBuffer commandBuffer, 2432 uint32_t commandBufferCount, 2433 const VkCommandBuffer* pCommandBuffers) 2434 { 2435 dispatch_key key = get_dispatch_key(commandBuffer); 2436 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 2437 VkLayerDispatchTable *pTable = my_data->device_dispatch_table; 2438 startWriteObject(my_data, commandBuffer); 2439 for (uint32_t index=0;index<commandBufferCount;index++) { 2440 startReadObject(my_data, pCommandBuffers[index]); 2441 } 2442 // Host access to commandBuffer must be externally synchronized 2443 2444 pTable->CmdExecuteCommands(commandBuffer,commandBufferCount,pCommandBuffers); 2445 finishWriteObject(my_data, commandBuffer); 2446 for (uint32_t index=0;index<commandBufferCount;index++) { 2447 finishReadObject(my_data, pCommandBuffers[index]); 2448 } 2449 // Host access to commandBuffer must be externally synchronized 2450 2451 } 2452 2453 // TODO - not wrapping KHR function vkDestroySurfaceKHR 2454 // TODO - not wrapping KHR function vkGetPhysicalDeviceSurfaceSupportKHR 2455 // TODO - not wrapping KHR function vkGetPhysicalDeviceSurfaceCapabilitiesKHR 2456 // TODO - not wrapping KHR function vkGetPhysicalDeviceSurfaceFormatsKHR 2457 // TODO - not wrapping KHR function vkGetPhysicalDeviceSurfacePresentModesKHR 2458 2459 // TODO - not wrapping KHR function vkCreateSwapchainKHR 2460 // TODO - not wrapping KHR function vkDestroySwapchainKHR 2461 // TODO - not wrapping KHR function vkGetSwapchainImagesKHR 2462 // TODO - not wrapping KHR function vkAcquireNextImageKHR 2463 // TODO - not wrapping KHR function vkQueuePresentKHR 2464 2465 // TODO - not wrapping KHR function vkGetPhysicalDeviceDisplayPropertiesKHR 2466 // TODO - not wrapping KHR function vkGetPhysicalDeviceDisplayPlanePropertiesKHR 2467 // TODO - not wrapping KHR function vkGetDisplayPlaneSupportedDisplaysKHR 2468 // TODO - not wrapping KHR function vkGetDisplayModePropertiesKHR 2469 // TODO - not wrapping KHR function vkCreateDisplayModeKHR 2470 // TODO - not wrapping KHR function vkGetDisplayPlaneCapabilitiesKHR 2471 // TODO - not wrapping KHR function vkCreateDisplayPlaneSurfaceKHR 2472 2473 // TODO - not wrapping KHR function vkCreateSharedSwapchainsKHR 2474 2475 #ifdef VK_USE_PLATFORM_XLIB_KHR 2476 // TODO - not wrapping KHR function vkCreateXlibSurfaceKHR 2477 // TODO - not wrapping KHR function vkGetPhysicalDeviceXlibPresentationSupportKHR 2478 #endif /* VK_USE_PLATFORM_XLIB_KHR */ 2479 2480 #ifdef VK_USE_PLATFORM_XCB_KHR 2481 // TODO - not wrapping KHR function vkCreateXcbSurfaceKHR 2482 // TODO - not wrapping KHR function vkGetPhysicalDeviceXcbPresentationSupportKHR 2483 #endif /* VK_USE_PLATFORM_XCB_KHR */ 2484 2485 #ifdef VK_USE_PLATFORM_WAYLAND_KHR 2486 // TODO - not wrapping KHR function vkCreateWaylandSurfaceKHR 2487 // TODO - not wrapping KHR function vkGetPhysicalDeviceWaylandPresentationSupportKHR 2488 #endif /* VK_USE_PLATFORM_WAYLAND_KHR */ 2489 2490 #ifdef VK_USE_PLATFORM_MIR_KHR 2491 // TODO - not wrapping KHR function vkCreateMirSurfaceKHR 2492 // TODO - not wrapping KHR function vkGetPhysicalDeviceMirPresentationSupportKHR 2493 #endif /* VK_USE_PLATFORM_MIR_KHR */ 2494 2495 #ifdef VK_USE_PLATFORM_ANDROID_KHR 2496 // TODO - not wrapping KHR function vkCreateAndroidSurfaceKHR 2497 #endif /* VK_USE_PLATFORM_ANDROID_KHR */ 2498 2499 #ifdef VK_USE_PLATFORM_WIN32_KHR 2500 // TODO - not wrapping KHR function vkCreateWin32SurfaceKHR 2501 // TODO - not wrapping KHR function vkGetPhysicalDeviceWin32PresentationSupportKHR 2502 #endif /* VK_USE_PLATFORM_WIN32_KHR */ 2503 2504 2505 2506 // declare only 2507 VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT( 2508 VkInstance instance, 2509 const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, 2510 const VkAllocationCallbacks* pAllocator, 2511 VkDebugReportCallbackEXT* pCallback); 2512 2513 // declare only 2514 VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT( 2515 VkInstance instance, 2516 VkDebugReportCallbackEXT callback, 2517 const VkAllocationCallbacks* pAllocator); 2518 2519 VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT( 2520 VkInstance instance, 2521 VkDebugReportFlagsEXT flags, 2522 VkDebugReportObjectTypeEXT objectType, 2523 uint64_t object, 2524 size_t location, 2525 int32_t messageCode, 2526 const char* pLayerPrefix, 2527 const char* pMessage) 2528 { 2529 dispatch_key key = get_dispatch_key(instance); 2530 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 2531 VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table; 2532 startReadObject(my_data, instance); 2533 2534 pTable->DebugReportMessageEXT(instance,flags,objectType,object,location,messageCode,pLayerPrefix,pMessage); 2535 finishReadObject(my_data, instance); 2536 2537 } 2538 2539 2540 2541 2542 // TODO - not wrapping EXT function vkDebugMarkerSetObjectTagEXT 2543 // TODO - not wrapping EXT function vkDebugMarkerSetObjectNameEXT 2544 // TODO - not wrapping EXT function vkCmdDebugMarkerBeginEXT 2545 // TODO - not wrapping EXT function vkCmdDebugMarkerEndEXT 2546 // TODO - not wrapping EXT function vkCmdDebugMarkerInsertEXT 2547 2548 // intercepts 2549 struct { const char* name; PFN_vkVoidFunction pFunc;} procmap[] = { 2550 {"vkCreateInstance", reinterpret_cast<PFN_vkVoidFunction>(CreateInstance)}, 2551 {"vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(DestroyInstance)}, 2552 {"vkEnumeratePhysicalDevices", reinterpret_cast<PFN_vkVoidFunction>(EnumeratePhysicalDevices)}, 2553 {"vkGetInstanceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(GetInstanceProcAddr)}, 2554 {"vkGetDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(GetDeviceProcAddr)}, 2555 {"vkCreateDevice", reinterpret_cast<PFN_vkVoidFunction>(CreateDevice)}, 2556 {"vkDestroyDevice", reinterpret_cast<PFN_vkVoidFunction>(DestroyDevice)}, 2557 {"vkGetDeviceQueue", reinterpret_cast<PFN_vkVoidFunction>(GetDeviceQueue)}, 2558 {"vkQueueSubmit", reinterpret_cast<PFN_vkVoidFunction>(QueueSubmit)}, 2559 {"vkQueueWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(QueueWaitIdle)}, 2560 {"vkDeviceWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(DeviceWaitIdle)}, 2561 {"vkAllocateMemory", reinterpret_cast<PFN_vkVoidFunction>(AllocateMemory)}, 2562 {"vkFreeMemory", reinterpret_cast<PFN_vkVoidFunction>(FreeMemory)}, 2563 {"vkMapMemory", reinterpret_cast<PFN_vkVoidFunction>(MapMemory)}, 2564 {"vkUnmapMemory", reinterpret_cast<PFN_vkVoidFunction>(UnmapMemory)}, 2565 {"vkFlushMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(FlushMappedMemoryRanges)}, 2566 {"vkInvalidateMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(InvalidateMappedMemoryRanges)}, 2567 {"vkGetDeviceMemoryCommitment", reinterpret_cast<PFN_vkVoidFunction>(GetDeviceMemoryCommitment)}, 2568 {"vkBindBufferMemory", reinterpret_cast<PFN_vkVoidFunction>(BindBufferMemory)}, 2569 {"vkBindImageMemory", reinterpret_cast<PFN_vkVoidFunction>(BindImageMemory)}, 2570 {"vkGetBufferMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(GetBufferMemoryRequirements)}, 2571 {"vkGetImageMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(GetImageMemoryRequirements)}, 2572 {"vkGetImageSparseMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(GetImageSparseMemoryRequirements)}, 2573 {"vkQueueBindSparse", reinterpret_cast<PFN_vkVoidFunction>(QueueBindSparse)}, 2574 {"vkCreateFence", reinterpret_cast<PFN_vkVoidFunction>(CreateFence)}, 2575 {"vkDestroyFence", reinterpret_cast<PFN_vkVoidFunction>(DestroyFence)}, 2576 {"vkResetFences", reinterpret_cast<PFN_vkVoidFunction>(ResetFences)}, 2577 {"vkGetFenceStatus", reinterpret_cast<PFN_vkVoidFunction>(GetFenceStatus)}, 2578 {"vkWaitForFences", reinterpret_cast<PFN_vkVoidFunction>(WaitForFences)}, 2579 {"vkCreateSemaphore", reinterpret_cast<PFN_vkVoidFunction>(CreateSemaphore)}, 2580 {"vkDestroySemaphore", reinterpret_cast<PFN_vkVoidFunction>(DestroySemaphore)}, 2581 {"vkCreateEvent", reinterpret_cast<PFN_vkVoidFunction>(CreateEvent)}, 2582 {"vkDestroyEvent", reinterpret_cast<PFN_vkVoidFunction>(DestroyEvent)}, 2583 {"vkGetEventStatus", reinterpret_cast<PFN_vkVoidFunction>(GetEventStatus)}, 2584 {"vkSetEvent", reinterpret_cast<PFN_vkVoidFunction>(SetEvent)}, 2585 {"vkResetEvent", reinterpret_cast<PFN_vkVoidFunction>(ResetEvent)}, 2586 {"vkCreateQueryPool", reinterpret_cast<PFN_vkVoidFunction>(CreateQueryPool)}, 2587 {"vkDestroyQueryPool", reinterpret_cast<PFN_vkVoidFunction>(DestroyQueryPool)}, 2588 {"vkGetQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(GetQueryPoolResults)}, 2589 {"vkCreateBuffer", reinterpret_cast<PFN_vkVoidFunction>(CreateBuffer)}, 2590 {"vkDestroyBuffer", reinterpret_cast<PFN_vkVoidFunction>(DestroyBuffer)}, 2591 {"vkCreateBufferView", reinterpret_cast<PFN_vkVoidFunction>(CreateBufferView)}, 2592 {"vkDestroyBufferView", reinterpret_cast<PFN_vkVoidFunction>(DestroyBufferView)}, 2593 {"vkCreateImage", reinterpret_cast<PFN_vkVoidFunction>(CreateImage)}, 2594 {"vkDestroyImage", reinterpret_cast<PFN_vkVoidFunction>(DestroyImage)}, 2595 {"vkGetImageSubresourceLayout", reinterpret_cast<PFN_vkVoidFunction>(GetImageSubresourceLayout)}, 2596 {"vkCreateImageView", reinterpret_cast<PFN_vkVoidFunction>(CreateImageView)}, 2597 {"vkDestroyImageView", reinterpret_cast<PFN_vkVoidFunction>(DestroyImageView)}, 2598 {"vkCreateShaderModule", reinterpret_cast<PFN_vkVoidFunction>(CreateShaderModule)}, 2599 {"vkDestroyShaderModule", reinterpret_cast<PFN_vkVoidFunction>(DestroyShaderModule)}, 2600 {"vkCreatePipelineCache", reinterpret_cast<PFN_vkVoidFunction>(CreatePipelineCache)}, 2601 {"vkDestroyPipelineCache", reinterpret_cast<PFN_vkVoidFunction>(DestroyPipelineCache)}, 2602 {"vkGetPipelineCacheData", reinterpret_cast<PFN_vkVoidFunction>(GetPipelineCacheData)}, 2603 {"vkMergePipelineCaches", reinterpret_cast<PFN_vkVoidFunction>(MergePipelineCaches)}, 2604 {"vkCreateGraphicsPipelines", reinterpret_cast<PFN_vkVoidFunction>(CreateGraphicsPipelines)}, 2605 {"vkCreateComputePipelines", reinterpret_cast<PFN_vkVoidFunction>(CreateComputePipelines)}, 2606 {"vkDestroyPipeline", reinterpret_cast<PFN_vkVoidFunction>(DestroyPipeline)}, 2607 {"vkCreatePipelineLayout", reinterpret_cast<PFN_vkVoidFunction>(CreatePipelineLayout)}, 2608 {"vkDestroyPipelineLayout", reinterpret_cast<PFN_vkVoidFunction>(DestroyPipelineLayout)}, 2609 {"vkCreateSampler", reinterpret_cast<PFN_vkVoidFunction>(CreateSampler)}, 2610 {"vkDestroySampler", reinterpret_cast<PFN_vkVoidFunction>(DestroySampler)}, 2611 {"vkCreateDescriptorSetLayout", reinterpret_cast<PFN_vkVoidFunction>(CreateDescriptorSetLayout)}, 2612 {"vkDestroyDescriptorSetLayout", reinterpret_cast<PFN_vkVoidFunction>(DestroyDescriptorSetLayout)}, 2613 {"vkCreateDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(CreateDescriptorPool)}, 2614 {"vkDestroyDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(DestroyDescriptorPool)}, 2615 {"vkResetDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(ResetDescriptorPool)}, 2616 {"vkAllocateDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(AllocateDescriptorSets)}, 2617 {"vkFreeDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(FreeDescriptorSets)}, 2618 {"vkUpdateDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(UpdateDescriptorSets)}, 2619 {"vkCreateFramebuffer", reinterpret_cast<PFN_vkVoidFunction>(CreateFramebuffer)}, 2620 {"vkDestroyFramebuffer", reinterpret_cast<PFN_vkVoidFunction>(DestroyFramebuffer)}, 2621 {"vkCreateRenderPass", reinterpret_cast<PFN_vkVoidFunction>(CreateRenderPass)}, 2622 {"vkDestroyRenderPass", reinterpret_cast<PFN_vkVoidFunction>(DestroyRenderPass)}, 2623 {"vkGetRenderAreaGranularity", reinterpret_cast<PFN_vkVoidFunction>(GetRenderAreaGranularity)}, 2624 {"vkCreateCommandPool", reinterpret_cast<PFN_vkVoidFunction>(CreateCommandPool)}, 2625 {"vkDestroyCommandPool", reinterpret_cast<PFN_vkVoidFunction>(DestroyCommandPool)}, 2626 {"vkResetCommandPool", reinterpret_cast<PFN_vkVoidFunction>(ResetCommandPool)}, 2627 {"vkAllocateCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(AllocateCommandBuffers)}, 2628 {"vkFreeCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(FreeCommandBuffers)}, 2629 {"vkBeginCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(BeginCommandBuffer)}, 2630 {"vkEndCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(EndCommandBuffer)}, 2631 {"vkResetCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(ResetCommandBuffer)}, 2632 {"vkCmdBindPipeline", reinterpret_cast<PFN_vkVoidFunction>(CmdBindPipeline)}, 2633 {"vkCmdSetViewport", reinterpret_cast<PFN_vkVoidFunction>(CmdSetViewport)}, 2634 {"vkCmdSetScissor", reinterpret_cast<PFN_vkVoidFunction>(CmdSetScissor)}, 2635 {"vkCmdSetLineWidth", reinterpret_cast<PFN_vkVoidFunction>(CmdSetLineWidth)}, 2636 {"vkCmdSetDepthBias", reinterpret_cast<PFN_vkVoidFunction>(CmdSetDepthBias)}, 2637 {"vkCmdSetBlendConstants", reinterpret_cast<PFN_vkVoidFunction>(CmdSetBlendConstants)}, 2638 {"vkCmdSetDepthBounds", reinterpret_cast<PFN_vkVoidFunction>(CmdSetDepthBounds)}, 2639 {"vkCmdSetStencilCompareMask", reinterpret_cast<PFN_vkVoidFunction>(CmdSetStencilCompareMask)}, 2640 {"vkCmdSetStencilWriteMask", reinterpret_cast<PFN_vkVoidFunction>(CmdSetStencilWriteMask)}, 2641 {"vkCmdSetStencilReference", reinterpret_cast<PFN_vkVoidFunction>(CmdSetStencilReference)}, 2642 {"vkCmdBindDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(CmdBindDescriptorSets)}, 2643 {"vkCmdBindIndexBuffer", reinterpret_cast<PFN_vkVoidFunction>(CmdBindIndexBuffer)}, 2644 {"vkCmdBindVertexBuffers", reinterpret_cast<PFN_vkVoidFunction>(CmdBindVertexBuffers)}, 2645 {"vkCmdDraw", reinterpret_cast<PFN_vkVoidFunction>(CmdDraw)}, 2646 {"vkCmdDrawIndexed", reinterpret_cast<PFN_vkVoidFunction>(CmdDrawIndexed)}, 2647 {"vkCmdDrawIndirect", reinterpret_cast<PFN_vkVoidFunction>(CmdDrawIndirect)}, 2648 {"vkCmdDrawIndexedIndirect", reinterpret_cast<PFN_vkVoidFunction>(CmdDrawIndexedIndirect)}, 2649 {"vkCmdDispatch", reinterpret_cast<PFN_vkVoidFunction>(CmdDispatch)}, 2650 {"vkCmdDispatchIndirect", reinterpret_cast<PFN_vkVoidFunction>(CmdDispatchIndirect)}, 2651 {"vkCmdCopyBuffer", reinterpret_cast<PFN_vkVoidFunction>(CmdCopyBuffer)}, 2652 {"vkCmdCopyImage", reinterpret_cast<PFN_vkVoidFunction>(CmdCopyImage)}, 2653 {"vkCmdBlitImage", reinterpret_cast<PFN_vkVoidFunction>(CmdBlitImage)}, 2654 {"vkCmdCopyBufferToImage", reinterpret_cast<PFN_vkVoidFunction>(CmdCopyBufferToImage)}, 2655 {"vkCmdCopyImageToBuffer", reinterpret_cast<PFN_vkVoidFunction>(CmdCopyImageToBuffer)}, 2656 {"vkCmdUpdateBuffer", reinterpret_cast<PFN_vkVoidFunction>(CmdUpdateBuffer)}, 2657 {"vkCmdFillBuffer", reinterpret_cast<PFN_vkVoidFunction>(CmdFillBuffer)}, 2658 {"vkCmdClearColorImage", reinterpret_cast<PFN_vkVoidFunction>(CmdClearColorImage)}, 2659 {"vkCmdClearDepthStencilImage", reinterpret_cast<PFN_vkVoidFunction>(CmdClearDepthStencilImage)}, 2660 {"vkCmdClearAttachments", reinterpret_cast<PFN_vkVoidFunction>(CmdClearAttachments)}, 2661 {"vkCmdResolveImage", reinterpret_cast<PFN_vkVoidFunction>(CmdResolveImage)}, 2662 {"vkCmdSetEvent", reinterpret_cast<PFN_vkVoidFunction>(CmdSetEvent)}, 2663 {"vkCmdResetEvent", reinterpret_cast<PFN_vkVoidFunction>(CmdResetEvent)}, 2664 {"vkCmdWaitEvents", reinterpret_cast<PFN_vkVoidFunction>(CmdWaitEvents)}, 2665 {"vkCmdPipelineBarrier", reinterpret_cast<PFN_vkVoidFunction>(CmdPipelineBarrier)}, 2666 {"vkCmdBeginQuery", reinterpret_cast<PFN_vkVoidFunction>(CmdBeginQuery)}, 2667 {"vkCmdEndQuery", reinterpret_cast<PFN_vkVoidFunction>(CmdEndQuery)}, 2668 {"vkCmdResetQueryPool", reinterpret_cast<PFN_vkVoidFunction>(CmdResetQueryPool)}, 2669 {"vkCmdWriteTimestamp", reinterpret_cast<PFN_vkVoidFunction>(CmdWriteTimestamp)}, 2670 {"vkCmdCopyQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(CmdCopyQueryPoolResults)}, 2671 {"vkCmdPushConstants", reinterpret_cast<PFN_vkVoidFunction>(CmdPushConstants)}, 2672 {"vkCmdBeginRenderPass", reinterpret_cast<PFN_vkVoidFunction>(CmdBeginRenderPass)}, 2673 {"vkCmdNextSubpass", reinterpret_cast<PFN_vkVoidFunction>(CmdNextSubpass)}, 2674 {"vkCmdEndRenderPass", reinterpret_cast<PFN_vkVoidFunction>(CmdEndRenderPass)}, 2675 {"vkCmdExecuteCommands", reinterpret_cast<PFN_vkVoidFunction>(CmdExecuteCommands)}, 2676 {"vkCreateDebugReportCallbackEXT", reinterpret_cast<PFN_vkVoidFunction>(CreateDebugReportCallbackEXT)}, 2677 {"vkDestroyDebugReportCallbackEXT", reinterpret_cast<PFN_vkVoidFunction>(DestroyDebugReportCallbackEXT)}, 2678 {"vkDebugReportMessageEXT", reinterpret_cast<PFN_vkVoidFunction>(DebugReportMessageEXT)}, 2679 }; 2680 2681 2682 } // namespace threading 2683 2684 #endif 2685
