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