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 #722 30 #include "vk_loader_platform.h" 31 #include "vulkan/vulkan.h" 32 33 #include <stdio.h> 34 #include <stdlib.h> 35 #include <string.h> 36 #include <cinttypes> 37 38 #include <unordered_map> 39 40 #include "vulkan/vk_layer.h" 41 #include "vk_layer_config.h" 42 #include "vk_layer_table.h" 43 #include "vk_layer_data.h" 44 #include "vk_layer_logging.h" 45 46 #include "object_tracker.h" 47 48 49 namespace object_tracker { 50 51 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkInstanceMap; 52 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkPhysicalDeviceMap; 53 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkDeviceMap; 54 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkQueueMap; 55 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkCommandBufferMap; 56 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkCommandPoolMap; 57 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkFenceMap; 58 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkDeviceMemoryMap; 59 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkBufferMap; 60 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkImageMap; 61 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkSemaphoreMap; 62 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkEventMap; 63 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkQueryPoolMap; 64 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkBufferViewMap; 65 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkImageViewMap; 66 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkShaderModuleMap; 67 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkPipelineCacheMap; 68 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkPipelineLayoutMap; 69 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkPipelineMap; 70 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkDescriptorSetLayoutMap; 71 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkSamplerMap; 72 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkDescriptorPoolMap; 73 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkDescriptorSetMap; 74 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkRenderPassMap; 75 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkFramebufferMap; 76 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkSwapchainKHRMap; 77 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkSurfaceKHRMap; 78 std::unordered_map<uint64_t, OBJTRACK_NODE*> VkDebugReportCallbackEXTMap; 79 80 // CODEGEN : file ../vk-layer-generate.py line #781 81 static void create_instance(VkInstance dispatchable_object, VkInstance vkObj, VkDebugReportObjectTypeEXT objType) 82 { 83 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 84 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 85 (uint64_t)(vkObj)); 86 87 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 88 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 89 pNewObjNode->objType = objType; 90 pNewObjNode->status = OBJSTATUS_NONE; 91 pNewObjNode->vkObj = (uint64_t)(vkObj); 92 VkInstanceMap[(uint64_t)vkObj] = pNewObjNode; 93 uint32_t objIndex = objTypeToIndex(objType); 94 numObjs[objIndex]++; 95 numTotalObjs++; 96 } 97 98 // CODEGEN : file ../vk-layer-generate.py line #804 99 static void destroy_instance(VkInstance dispatchable_object, VkInstance object) 100 { 101 uint64_t object_handle = (uint64_t)(object); 102 auto it = VkInstanceMap.find(object_handle); 103 if (it != VkInstanceMap.end()) { 104 OBJTRACK_NODE* pNode = it->second; 105 uint32_t objIndex = objTypeToIndex(pNode->objType); 106 assert(numTotalObjs > 0); 107 numTotalObjs--; 108 assert(numObjs[objIndex] > 0); 109 numObjs[objIndex]--; 110 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 111 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 112 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 113 string_VkDebugReportObjectTypeEXT(pNode->objType)); 114 delete pNode; 115 VkInstanceMap.erase(it); 116 } else { 117 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 118 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 119 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 120 object_handle); 121 } 122 } 123 124 // CODEGEN : file ../vk-layer-generate.py line #781 125 static void create_physical_device(VkPhysicalDevice dispatchable_object, VkPhysicalDevice vkObj, VkDebugReportObjectTypeEXT objType) 126 { 127 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 128 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 129 (uint64_t)(vkObj)); 130 131 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 132 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 133 pNewObjNode->objType = objType; 134 pNewObjNode->status = OBJSTATUS_NONE; 135 pNewObjNode->vkObj = (uint64_t)(vkObj); 136 VkPhysicalDeviceMap[(uint64_t)vkObj] = pNewObjNode; 137 uint32_t objIndex = objTypeToIndex(objType); 138 numObjs[objIndex]++; 139 numTotalObjs++; 140 } 141 142 // CODEGEN : file ../vk-layer-generate.py line #804 143 static void destroy_physical_device(VkPhysicalDevice dispatchable_object, VkPhysicalDevice object) 144 { 145 uint64_t object_handle = (uint64_t)(object); 146 auto it = VkPhysicalDeviceMap.find(object_handle); 147 if (it != VkPhysicalDeviceMap.end()) { 148 OBJTRACK_NODE* pNode = it->second; 149 uint32_t objIndex = objTypeToIndex(pNode->objType); 150 assert(numTotalObjs > 0); 151 numTotalObjs--; 152 assert(numObjs[objIndex] > 0); 153 numObjs[objIndex]--; 154 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 155 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 156 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 157 string_VkDebugReportObjectTypeEXT(pNode->objType)); 158 delete pNode; 159 VkPhysicalDeviceMap.erase(it); 160 } else { 161 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 162 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 163 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 164 object_handle); 165 } 166 } 167 168 // CODEGEN : file ../vk-layer-generate.py line #781 169 static void create_device(VkDevice dispatchable_object, VkDevice vkObj, VkDebugReportObjectTypeEXT objType) 170 { 171 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 172 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 173 (uint64_t)(vkObj)); 174 175 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 176 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 177 pNewObjNode->objType = objType; 178 pNewObjNode->status = OBJSTATUS_NONE; 179 pNewObjNode->vkObj = (uint64_t)(vkObj); 180 VkDeviceMap[(uint64_t)vkObj] = pNewObjNode; 181 uint32_t objIndex = objTypeToIndex(objType); 182 numObjs[objIndex]++; 183 numTotalObjs++; 184 } 185 186 // CODEGEN : file ../vk-layer-generate.py line #804 187 static void destroy_device(VkDevice dispatchable_object, VkDevice object) 188 { 189 uint64_t object_handle = (uint64_t)(object); 190 auto it = VkDeviceMap.find(object_handle); 191 if (it != VkDeviceMap.end()) { 192 OBJTRACK_NODE* pNode = it->second; 193 uint32_t objIndex = objTypeToIndex(pNode->objType); 194 assert(numTotalObjs > 0); 195 numTotalObjs--; 196 assert(numObjs[objIndex] > 0); 197 numObjs[objIndex]--; 198 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 199 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 200 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 201 string_VkDebugReportObjectTypeEXT(pNode->objType)); 202 delete pNode; 203 VkDeviceMap.erase(it); 204 } else { 205 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 206 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 207 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 208 object_handle); 209 } 210 } 211 212 // CODEGEN : file ../vk-layer-generate.py line #781 213 static void create_queue(VkQueue dispatchable_object, VkQueue vkObj, VkDebugReportObjectTypeEXT objType) 214 { 215 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 216 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 217 (uint64_t)(vkObj)); 218 219 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 220 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 221 pNewObjNode->objType = objType; 222 pNewObjNode->status = OBJSTATUS_NONE; 223 pNewObjNode->vkObj = (uint64_t)(vkObj); 224 VkQueueMap[(uint64_t)vkObj] = pNewObjNode; 225 uint32_t objIndex = objTypeToIndex(objType); 226 numObjs[objIndex]++; 227 numTotalObjs++; 228 } 229 230 // CODEGEN : file ../vk-layer-generate.py line #804 231 static void destroy_queue(VkQueue dispatchable_object, VkQueue object) 232 { 233 uint64_t object_handle = (uint64_t)(object); 234 auto it = VkQueueMap.find(object_handle); 235 if (it != VkQueueMap.end()) { 236 OBJTRACK_NODE* pNode = it->second; 237 uint32_t objIndex = objTypeToIndex(pNode->objType); 238 assert(numTotalObjs > 0); 239 numTotalObjs--; 240 assert(numObjs[objIndex] > 0); 241 numObjs[objIndex]--; 242 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 243 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 244 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 245 string_VkDebugReportObjectTypeEXT(pNode->objType)); 246 delete pNode; 247 VkQueueMap.erase(it); 248 } else { 249 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 250 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 251 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 252 object_handle); 253 } 254 } 255 256 // CODEGEN : file ../vk-layer-generate.py line #781 257 static void create_command_buffer(VkCommandBuffer dispatchable_object, VkCommandBuffer vkObj, VkDebugReportObjectTypeEXT objType) 258 { 259 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 260 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 261 (uint64_t)(vkObj)); 262 263 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 264 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 265 pNewObjNode->objType = objType; 266 pNewObjNode->status = OBJSTATUS_NONE; 267 pNewObjNode->vkObj = (uint64_t)(vkObj); 268 VkCommandBufferMap[(uint64_t)vkObj] = pNewObjNode; 269 uint32_t objIndex = objTypeToIndex(objType); 270 numObjs[objIndex]++; 271 numTotalObjs++; 272 } 273 274 // CODEGEN : file ../vk-layer-generate.py line #804 275 static void destroy_command_buffer(VkCommandBuffer dispatchable_object, VkCommandBuffer object) 276 { 277 uint64_t object_handle = (uint64_t)(object); 278 auto it = VkCommandBufferMap.find(object_handle); 279 if (it != VkCommandBufferMap.end()) { 280 OBJTRACK_NODE* pNode = it->second; 281 uint32_t objIndex = objTypeToIndex(pNode->objType); 282 assert(numTotalObjs > 0); 283 numTotalObjs--; 284 assert(numObjs[objIndex] > 0); 285 numObjs[objIndex]--; 286 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 287 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 288 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 289 string_VkDebugReportObjectTypeEXT(pNode->objType)); 290 delete pNode; 291 VkCommandBufferMap.erase(it); 292 } else { 293 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 294 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 295 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 296 object_handle); 297 } 298 } 299 300 // CODEGEN : file ../vk-layer-generate.py line #781 301 static void create_command_pool(VkDevice dispatchable_object, VkCommandPool vkObj, VkDebugReportObjectTypeEXT objType) 302 { 303 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 304 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 305 (uint64_t)(vkObj)); 306 307 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 308 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 309 pNewObjNode->objType = objType; 310 pNewObjNode->status = OBJSTATUS_NONE; 311 pNewObjNode->vkObj = (uint64_t)(vkObj); 312 VkCommandPoolMap[(uint64_t)vkObj] = pNewObjNode; 313 uint32_t objIndex = objTypeToIndex(objType); 314 numObjs[objIndex]++; 315 numTotalObjs++; 316 } 317 318 // CODEGEN : file ../vk-layer-generate.py line #804 319 static void destroy_command_pool(VkDevice dispatchable_object, VkCommandPool object) 320 { 321 uint64_t object_handle = (uint64_t)(object); 322 auto it = VkCommandPoolMap.find(object_handle); 323 if (it != VkCommandPoolMap.end()) { 324 OBJTRACK_NODE* pNode = it->second; 325 uint32_t objIndex = objTypeToIndex(pNode->objType); 326 assert(numTotalObjs > 0); 327 numTotalObjs--; 328 assert(numObjs[objIndex] > 0); 329 numObjs[objIndex]--; 330 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 331 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 332 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 333 string_VkDebugReportObjectTypeEXT(pNode->objType)); 334 delete pNode; 335 VkCommandPoolMap.erase(it); 336 } else { 337 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 338 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 339 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 340 object_handle); 341 } 342 } 343 344 // CODEGEN : file ../vk-layer-generate.py line #781 345 static void create_fence(VkDevice dispatchable_object, VkFence vkObj, VkDebugReportObjectTypeEXT objType) 346 { 347 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 348 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 349 (uint64_t)(vkObj)); 350 351 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 352 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 353 pNewObjNode->objType = objType; 354 pNewObjNode->status = OBJSTATUS_NONE; 355 pNewObjNode->vkObj = (uint64_t)(vkObj); 356 VkFenceMap[(uint64_t)vkObj] = pNewObjNode; 357 uint32_t objIndex = objTypeToIndex(objType); 358 numObjs[objIndex]++; 359 numTotalObjs++; 360 } 361 362 // CODEGEN : file ../vk-layer-generate.py line #804 363 static void destroy_fence(VkDevice dispatchable_object, VkFence object) 364 { 365 uint64_t object_handle = (uint64_t)(object); 366 auto it = VkFenceMap.find(object_handle); 367 if (it != VkFenceMap.end()) { 368 OBJTRACK_NODE* pNode = it->second; 369 uint32_t objIndex = objTypeToIndex(pNode->objType); 370 assert(numTotalObjs > 0); 371 numTotalObjs--; 372 assert(numObjs[objIndex] > 0); 373 numObjs[objIndex]--; 374 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 375 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 376 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 377 string_VkDebugReportObjectTypeEXT(pNode->objType)); 378 delete pNode; 379 VkFenceMap.erase(it); 380 } else { 381 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 382 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 383 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 384 object_handle); 385 } 386 } 387 388 // CODEGEN : file ../vk-layer-generate.py line #781 389 static void create_device_memory(VkDevice dispatchable_object, VkDeviceMemory vkObj, VkDebugReportObjectTypeEXT objType) 390 { 391 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 392 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 393 (uint64_t)(vkObj)); 394 395 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 396 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 397 pNewObjNode->objType = objType; 398 pNewObjNode->status = OBJSTATUS_NONE; 399 pNewObjNode->vkObj = (uint64_t)(vkObj); 400 VkDeviceMemoryMap[(uint64_t)vkObj] = pNewObjNode; 401 uint32_t objIndex = objTypeToIndex(objType); 402 numObjs[objIndex]++; 403 numTotalObjs++; 404 } 405 406 // CODEGEN : file ../vk-layer-generate.py line #804 407 static void destroy_device_memory(VkDevice dispatchable_object, VkDeviceMemory object) 408 { 409 uint64_t object_handle = (uint64_t)(object); 410 auto it = VkDeviceMemoryMap.find(object_handle); 411 if (it != VkDeviceMemoryMap.end()) { 412 OBJTRACK_NODE* pNode = it->second; 413 uint32_t objIndex = objTypeToIndex(pNode->objType); 414 assert(numTotalObjs > 0); 415 numTotalObjs--; 416 assert(numObjs[objIndex] > 0); 417 numObjs[objIndex]--; 418 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 419 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 420 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 421 string_VkDebugReportObjectTypeEXT(pNode->objType)); 422 delete pNode; 423 VkDeviceMemoryMap.erase(it); 424 } else { 425 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 426 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 427 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 428 object_handle); 429 } 430 } 431 432 // CODEGEN : file ../vk-layer-generate.py line #781 433 static void create_buffer(VkDevice dispatchable_object, VkBuffer vkObj, VkDebugReportObjectTypeEXT objType) 434 { 435 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 436 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 437 (uint64_t)(vkObj)); 438 439 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 440 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 441 pNewObjNode->objType = objType; 442 pNewObjNode->status = OBJSTATUS_NONE; 443 pNewObjNode->vkObj = (uint64_t)(vkObj); 444 VkBufferMap[(uint64_t)vkObj] = pNewObjNode; 445 uint32_t objIndex = objTypeToIndex(objType); 446 numObjs[objIndex]++; 447 numTotalObjs++; 448 } 449 450 // CODEGEN : file ../vk-layer-generate.py line #804 451 static void destroy_buffer(VkDevice dispatchable_object, VkBuffer object) 452 { 453 uint64_t object_handle = (uint64_t)(object); 454 auto it = VkBufferMap.find(object_handle); 455 if (it != VkBufferMap.end()) { 456 OBJTRACK_NODE* pNode = it->second; 457 uint32_t objIndex = objTypeToIndex(pNode->objType); 458 assert(numTotalObjs > 0); 459 numTotalObjs--; 460 assert(numObjs[objIndex] > 0); 461 numObjs[objIndex]--; 462 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 463 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 464 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 465 string_VkDebugReportObjectTypeEXT(pNode->objType)); 466 delete pNode; 467 VkBufferMap.erase(it); 468 } else { 469 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 470 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 471 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 472 object_handle); 473 } 474 } 475 476 // CODEGEN : file ../vk-layer-generate.py line #781 477 static void create_image(VkDevice dispatchable_object, VkImage vkObj, VkDebugReportObjectTypeEXT objType) 478 { 479 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 480 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 481 (uint64_t)(vkObj)); 482 483 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 484 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 485 pNewObjNode->objType = objType; 486 pNewObjNode->status = OBJSTATUS_NONE; 487 pNewObjNode->vkObj = (uint64_t)(vkObj); 488 VkImageMap[(uint64_t)vkObj] = pNewObjNode; 489 uint32_t objIndex = objTypeToIndex(objType); 490 numObjs[objIndex]++; 491 numTotalObjs++; 492 } 493 494 // CODEGEN : file ../vk-layer-generate.py line #804 495 static void destroy_image(VkDevice dispatchable_object, VkImage object) 496 { 497 uint64_t object_handle = (uint64_t)(object); 498 auto it = VkImageMap.find(object_handle); 499 if (it != VkImageMap.end()) { 500 OBJTRACK_NODE* pNode = it->second; 501 uint32_t objIndex = objTypeToIndex(pNode->objType); 502 assert(numTotalObjs > 0); 503 numTotalObjs--; 504 assert(numObjs[objIndex] > 0); 505 numObjs[objIndex]--; 506 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 507 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 508 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 509 string_VkDebugReportObjectTypeEXT(pNode->objType)); 510 delete pNode; 511 VkImageMap.erase(it); 512 } else { 513 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 514 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 515 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 516 object_handle); 517 } 518 } 519 520 // CODEGEN : file ../vk-layer-generate.py line #781 521 static void create_semaphore(VkDevice dispatchable_object, VkSemaphore vkObj, VkDebugReportObjectTypeEXT objType) 522 { 523 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 524 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 525 (uint64_t)(vkObj)); 526 527 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 528 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 529 pNewObjNode->objType = objType; 530 pNewObjNode->status = OBJSTATUS_NONE; 531 pNewObjNode->vkObj = (uint64_t)(vkObj); 532 VkSemaphoreMap[(uint64_t)vkObj] = pNewObjNode; 533 uint32_t objIndex = objTypeToIndex(objType); 534 numObjs[objIndex]++; 535 numTotalObjs++; 536 } 537 538 // CODEGEN : file ../vk-layer-generate.py line #804 539 static void destroy_semaphore(VkDevice dispatchable_object, VkSemaphore object) 540 { 541 uint64_t object_handle = (uint64_t)(object); 542 auto it = VkSemaphoreMap.find(object_handle); 543 if (it != VkSemaphoreMap.end()) { 544 OBJTRACK_NODE* pNode = it->second; 545 uint32_t objIndex = objTypeToIndex(pNode->objType); 546 assert(numTotalObjs > 0); 547 numTotalObjs--; 548 assert(numObjs[objIndex] > 0); 549 numObjs[objIndex]--; 550 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 551 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 552 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 553 string_VkDebugReportObjectTypeEXT(pNode->objType)); 554 delete pNode; 555 VkSemaphoreMap.erase(it); 556 } else { 557 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 558 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 559 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 560 object_handle); 561 } 562 } 563 564 // CODEGEN : file ../vk-layer-generate.py line #781 565 static void create_event(VkDevice dispatchable_object, VkEvent vkObj, VkDebugReportObjectTypeEXT objType) 566 { 567 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 568 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 569 (uint64_t)(vkObj)); 570 571 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 572 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 573 pNewObjNode->objType = objType; 574 pNewObjNode->status = OBJSTATUS_NONE; 575 pNewObjNode->vkObj = (uint64_t)(vkObj); 576 VkEventMap[(uint64_t)vkObj] = pNewObjNode; 577 uint32_t objIndex = objTypeToIndex(objType); 578 numObjs[objIndex]++; 579 numTotalObjs++; 580 } 581 582 // CODEGEN : file ../vk-layer-generate.py line #804 583 static void destroy_event(VkDevice dispatchable_object, VkEvent object) 584 { 585 uint64_t object_handle = (uint64_t)(object); 586 auto it = VkEventMap.find(object_handle); 587 if (it != VkEventMap.end()) { 588 OBJTRACK_NODE* pNode = it->second; 589 uint32_t objIndex = objTypeToIndex(pNode->objType); 590 assert(numTotalObjs > 0); 591 numTotalObjs--; 592 assert(numObjs[objIndex] > 0); 593 numObjs[objIndex]--; 594 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 595 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 596 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 597 string_VkDebugReportObjectTypeEXT(pNode->objType)); 598 delete pNode; 599 VkEventMap.erase(it); 600 } else { 601 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 602 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 603 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 604 object_handle); 605 } 606 } 607 608 // CODEGEN : file ../vk-layer-generate.py line #781 609 static void create_query_pool(VkDevice dispatchable_object, VkQueryPool vkObj, VkDebugReportObjectTypeEXT objType) 610 { 611 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 612 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 613 (uint64_t)(vkObj)); 614 615 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 616 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 617 pNewObjNode->objType = objType; 618 pNewObjNode->status = OBJSTATUS_NONE; 619 pNewObjNode->vkObj = (uint64_t)(vkObj); 620 VkQueryPoolMap[(uint64_t)vkObj] = pNewObjNode; 621 uint32_t objIndex = objTypeToIndex(objType); 622 numObjs[objIndex]++; 623 numTotalObjs++; 624 } 625 626 // CODEGEN : file ../vk-layer-generate.py line #804 627 static void destroy_query_pool(VkDevice dispatchable_object, VkQueryPool object) 628 { 629 uint64_t object_handle = (uint64_t)(object); 630 auto it = VkQueryPoolMap.find(object_handle); 631 if (it != VkQueryPoolMap.end()) { 632 OBJTRACK_NODE* pNode = it->second; 633 uint32_t objIndex = objTypeToIndex(pNode->objType); 634 assert(numTotalObjs > 0); 635 numTotalObjs--; 636 assert(numObjs[objIndex] > 0); 637 numObjs[objIndex]--; 638 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 639 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 640 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 641 string_VkDebugReportObjectTypeEXT(pNode->objType)); 642 delete pNode; 643 VkQueryPoolMap.erase(it); 644 } else { 645 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 646 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 647 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 648 object_handle); 649 } 650 } 651 652 // CODEGEN : file ../vk-layer-generate.py line #781 653 static void create_buffer_view(VkDevice dispatchable_object, VkBufferView vkObj, VkDebugReportObjectTypeEXT objType) 654 { 655 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 656 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 657 (uint64_t)(vkObj)); 658 659 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 660 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 661 pNewObjNode->objType = objType; 662 pNewObjNode->status = OBJSTATUS_NONE; 663 pNewObjNode->vkObj = (uint64_t)(vkObj); 664 VkBufferViewMap[(uint64_t)vkObj] = pNewObjNode; 665 uint32_t objIndex = objTypeToIndex(objType); 666 numObjs[objIndex]++; 667 numTotalObjs++; 668 } 669 670 // CODEGEN : file ../vk-layer-generate.py line #804 671 static void destroy_buffer_view(VkDevice dispatchable_object, VkBufferView object) 672 { 673 uint64_t object_handle = (uint64_t)(object); 674 auto it = VkBufferViewMap.find(object_handle); 675 if (it != VkBufferViewMap.end()) { 676 OBJTRACK_NODE* pNode = it->second; 677 uint32_t objIndex = objTypeToIndex(pNode->objType); 678 assert(numTotalObjs > 0); 679 numTotalObjs--; 680 assert(numObjs[objIndex] > 0); 681 numObjs[objIndex]--; 682 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 683 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 684 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 685 string_VkDebugReportObjectTypeEXT(pNode->objType)); 686 delete pNode; 687 VkBufferViewMap.erase(it); 688 } else { 689 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 690 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 691 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 692 object_handle); 693 } 694 } 695 696 // CODEGEN : file ../vk-layer-generate.py line #781 697 static void create_image_view(VkDevice dispatchable_object, VkImageView vkObj, VkDebugReportObjectTypeEXT objType) 698 { 699 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 700 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 701 (uint64_t)(vkObj)); 702 703 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 704 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 705 pNewObjNode->objType = objType; 706 pNewObjNode->status = OBJSTATUS_NONE; 707 pNewObjNode->vkObj = (uint64_t)(vkObj); 708 VkImageViewMap[(uint64_t)vkObj] = pNewObjNode; 709 uint32_t objIndex = objTypeToIndex(objType); 710 numObjs[objIndex]++; 711 numTotalObjs++; 712 } 713 714 // CODEGEN : file ../vk-layer-generate.py line #804 715 static void destroy_image_view(VkDevice dispatchable_object, VkImageView object) 716 { 717 uint64_t object_handle = (uint64_t)(object); 718 auto it = VkImageViewMap.find(object_handle); 719 if (it != VkImageViewMap.end()) { 720 OBJTRACK_NODE* pNode = it->second; 721 uint32_t objIndex = objTypeToIndex(pNode->objType); 722 assert(numTotalObjs > 0); 723 numTotalObjs--; 724 assert(numObjs[objIndex] > 0); 725 numObjs[objIndex]--; 726 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 727 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 728 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 729 string_VkDebugReportObjectTypeEXT(pNode->objType)); 730 delete pNode; 731 VkImageViewMap.erase(it); 732 } else { 733 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 734 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 735 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 736 object_handle); 737 } 738 } 739 740 // CODEGEN : file ../vk-layer-generate.py line #781 741 static void create_shader_module(VkDevice dispatchable_object, VkShaderModule vkObj, VkDebugReportObjectTypeEXT objType) 742 { 743 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 744 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 745 (uint64_t)(vkObj)); 746 747 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 748 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 749 pNewObjNode->objType = objType; 750 pNewObjNode->status = OBJSTATUS_NONE; 751 pNewObjNode->vkObj = (uint64_t)(vkObj); 752 VkShaderModuleMap[(uint64_t)vkObj] = pNewObjNode; 753 uint32_t objIndex = objTypeToIndex(objType); 754 numObjs[objIndex]++; 755 numTotalObjs++; 756 } 757 758 // CODEGEN : file ../vk-layer-generate.py line #804 759 static void destroy_shader_module(VkDevice dispatchable_object, VkShaderModule object) 760 { 761 uint64_t object_handle = (uint64_t)(object); 762 auto it = VkShaderModuleMap.find(object_handle); 763 if (it != VkShaderModuleMap.end()) { 764 OBJTRACK_NODE* pNode = it->second; 765 uint32_t objIndex = objTypeToIndex(pNode->objType); 766 assert(numTotalObjs > 0); 767 numTotalObjs--; 768 assert(numObjs[objIndex] > 0); 769 numObjs[objIndex]--; 770 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 771 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 772 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 773 string_VkDebugReportObjectTypeEXT(pNode->objType)); 774 delete pNode; 775 VkShaderModuleMap.erase(it); 776 } else { 777 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 778 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 779 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 780 object_handle); 781 } 782 } 783 784 // CODEGEN : file ../vk-layer-generate.py line #781 785 static void create_pipeline_cache(VkDevice dispatchable_object, VkPipelineCache vkObj, VkDebugReportObjectTypeEXT objType) 786 { 787 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 788 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 789 (uint64_t)(vkObj)); 790 791 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 792 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 793 pNewObjNode->objType = objType; 794 pNewObjNode->status = OBJSTATUS_NONE; 795 pNewObjNode->vkObj = (uint64_t)(vkObj); 796 VkPipelineCacheMap[(uint64_t)vkObj] = pNewObjNode; 797 uint32_t objIndex = objTypeToIndex(objType); 798 numObjs[objIndex]++; 799 numTotalObjs++; 800 } 801 802 // CODEGEN : file ../vk-layer-generate.py line #804 803 static void destroy_pipeline_cache(VkDevice dispatchable_object, VkPipelineCache object) 804 { 805 uint64_t object_handle = (uint64_t)(object); 806 auto it = VkPipelineCacheMap.find(object_handle); 807 if (it != VkPipelineCacheMap.end()) { 808 OBJTRACK_NODE* pNode = it->second; 809 uint32_t objIndex = objTypeToIndex(pNode->objType); 810 assert(numTotalObjs > 0); 811 numTotalObjs--; 812 assert(numObjs[objIndex] > 0); 813 numObjs[objIndex]--; 814 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 815 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 816 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 817 string_VkDebugReportObjectTypeEXT(pNode->objType)); 818 delete pNode; 819 VkPipelineCacheMap.erase(it); 820 } else { 821 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 822 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 823 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 824 object_handle); 825 } 826 } 827 828 // CODEGEN : file ../vk-layer-generate.py line #781 829 static void create_pipeline_layout(VkDevice dispatchable_object, VkPipelineLayout vkObj, VkDebugReportObjectTypeEXT objType) 830 { 831 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 832 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 833 (uint64_t)(vkObj)); 834 835 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 836 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 837 pNewObjNode->objType = objType; 838 pNewObjNode->status = OBJSTATUS_NONE; 839 pNewObjNode->vkObj = (uint64_t)(vkObj); 840 VkPipelineLayoutMap[(uint64_t)vkObj] = pNewObjNode; 841 uint32_t objIndex = objTypeToIndex(objType); 842 numObjs[objIndex]++; 843 numTotalObjs++; 844 } 845 846 // CODEGEN : file ../vk-layer-generate.py line #804 847 static void destroy_pipeline_layout(VkDevice dispatchable_object, VkPipelineLayout object) 848 { 849 uint64_t object_handle = (uint64_t)(object); 850 auto it = VkPipelineLayoutMap.find(object_handle); 851 if (it != VkPipelineLayoutMap.end()) { 852 OBJTRACK_NODE* pNode = it->second; 853 uint32_t objIndex = objTypeToIndex(pNode->objType); 854 assert(numTotalObjs > 0); 855 numTotalObjs--; 856 assert(numObjs[objIndex] > 0); 857 numObjs[objIndex]--; 858 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 859 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 860 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 861 string_VkDebugReportObjectTypeEXT(pNode->objType)); 862 delete pNode; 863 VkPipelineLayoutMap.erase(it); 864 } else { 865 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 866 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 867 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 868 object_handle); 869 } 870 } 871 872 // CODEGEN : file ../vk-layer-generate.py line #781 873 static void create_pipeline(VkDevice dispatchable_object, VkPipeline vkObj, VkDebugReportObjectTypeEXT objType) 874 { 875 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 876 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 877 (uint64_t)(vkObj)); 878 879 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 880 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 881 pNewObjNode->objType = objType; 882 pNewObjNode->status = OBJSTATUS_NONE; 883 pNewObjNode->vkObj = (uint64_t)(vkObj); 884 VkPipelineMap[(uint64_t)vkObj] = pNewObjNode; 885 uint32_t objIndex = objTypeToIndex(objType); 886 numObjs[objIndex]++; 887 numTotalObjs++; 888 } 889 890 // CODEGEN : file ../vk-layer-generate.py line #804 891 static void destroy_pipeline(VkDevice dispatchable_object, VkPipeline object) 892 { 893 uint64_t object_handle = (uint64_t)(object); 894 auto it = VkPipelineMap.find(object_handle); 895 if (it != VkPipelineMap.end()) { 896 OBJTRACK_NODE* pNode = it->second; 897 uint32_t objIndex = objTypeToIndex(pNode->objType); 898 assert(numTotalObjs > 0); 899 numTotalObjs--; 900 assert(numObjs[objIndex] > 0); 901 numObjs[objIndex]--; 902 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 903 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 904 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 905 string_VkDebugReportObjectTypeEXT(pNode->objType)); 906 delete pNode; 907 VkPipelineMap.erase(it); 908 } else { 909 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 910 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 911 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 912 object_handle); 913 } 914 } 915 916 // CODEGEN : file ../vk-layer-generate.py line #781 917 static void create_descriptor_set_layout(VkDevice dispatchable_object, VkDescriptorSetLayout vkObj, VkDebugReportObjectTypeEXT objType) 918 { 919 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 920 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 921 (uint64_t)(vkObj)); 922 923 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 924 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 925 pNewObjNode->objType = objType; 926 pNewObjNode->status = OBJSTATUS_NONE; 927 pNewObjNode->vkObj = (uint64_t)(vkObj); 928 VkDescriptorSetLayoutMap[(uint64_t)vkObj] = pNewObjNode; 929 uint32_t objIndex = objTypeToIndex(objType); 930 numObjs[objIndex]++; 931 numTotalObjs++; 932 } 933 934 // CODEGEN : file ../vk-layer-generate.py line #804 935 static void destroy_descriptor_set_layout(VkDevice dispatchable_object, VkDescriptorSetLayout object) 936 { 937 uint64_t object_handle = (uint64_t)(object); 938 auto it = VkDescriptorSetLayoutMap.find(object_handle); 939 if (it != VkDescriptorSetLayoutMap.end()) { 940 OBJTRACK_NODE* pNode = it->second; 941 uint32_t objIndex = objTypeToIndex(pNode->objType); 942 assert(numTotalObjs > 0); 943 numTotalObjs--; 944 assert(numObjs[objIndex] > 0); 945 numObjs[objIndex]--; 946 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 947 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 948 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 949 string_VkDebugReportObjectTypeEXT(pNode->objType)); 950 delete pNode; 951 VkDescriptorSetLayoutMap.erase(it); 952 } else { 953 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 954 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 955 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 956 object_handle); 957 } 958 } 959 960 // CODEGEN : file ../vk-layer-generate.py line #781 961 static void create_sampler(VkDevice dispatchable_object, VkSampler vkObj, VkDebugReportObjectTypeEXT objType) 962 { 963 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 964 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 965 (uint64_t)(vkObj)); 966 967 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 968 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 969 pNewObjNode->objType = objType; 970 pNewObjNode->status = OBJSTATUS_NONE; 971 pNewObjNode->vkObj = (uint64_t)(vkObj); 972 VkSamplerMap[(uint64_t)vkObj] = pNewObjNode; 973 uint32_t objIndex = objTypeToIndex(objType); 974 numObjs[objIndex]++; 975 numTotalObjs++; 976 } 977 978 // CODEGEN : file ../vk-layer-generate.py line #804 979 static void destroy_sampler(VkDevice dispatchable_object, VkSampler object) 980 { 981 uint64_t object_handle = (uint64_t)(object); 982 auto it = VkSamplerMap.find(object_handle); 983 if (it != VkSamplerMap.end()) { 984 OBJTRACK_NODE* pNode = it->second; 985 uint32_t objIndex = objTypeToIndex(pNode->objType); 986 assert(numTotalObjs > 0); 987 numTotalObjs--; 988 assert(numObjs[objIndex] > 0); 989 numObjs[objIndex]--; 990 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 991 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 992 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 993 string_VkDebugReportObjectTypeEXT(pNode->objType)); 994 delete pNode; 995 VkSamplerMap.erase(it); 996 } else { 997 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 998 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 999 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 1000 object_handle); 1001 } 1002 } 1003 1004 // CODEGEN : file ../vk-layer-generate.py line #781 1005 static void create_descriptor_pool(VkDevice dispatchable_object, VkDescriptorPool vkObj, VkDebugReportObjectTypeEXT objType) 1006 { 1007 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 1008 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 1009 (uint64_t)(vkObj)); 1010 1011 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 1012 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 1013 pNewObjNode->objType = objType; 1014 pNewObjNode->status = OBJSTATUS_NONE; 1015 pNewObjNode->vkObj = (uint64_t)(vkObj); 1016 VkDescriptorPoolMap[(uint64_t)vkObj] = pNewObjNode; 1017 uint32_t objIndex = objTypeToIndex(objType); 1018 numObjs[objIndex]++; 1019 numTotalObjs++; 1020 } 1021 1022 // CODEGEN : file ../vk-layer-generate.py line #804 1023 static void destroy_descriptor_pool(VkDevice dispatchable_object, VkDescriptorPool object) 1024 { 1025 uint64_t object_handle = (uint64_t)(object); 1026 auto it = VkDescriptorPoolMap.find(object_handle); 1027 if (it != VkDescriptorPoolMap.end()) { 1028 OBJTRACK_NODE* pNode = it->second; 1029 uint32_t objIndex = objTypeToIndex(pNode->objType); 1030 assert(numTotalObjs > 0); 1031 numTotalObjs--; 1032 assert(numObjs[objIndex] > 0); 1033 numObjs[objIndex]--; 1034 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 1035 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 1036 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 1037 string_VkDebugReportObjectTypeEXT(pNode->objType)); 1038 delete pNode; 1039 VkDescriptorPoolMap.erase(it); 1040 } else { 1041 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 1042 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 1043 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 1044 object_handle); 1045 } 1046 } 1047 1048 // CODEGEN : file ../vk-layer-generate.py line #781 1049 static void create_descriptor_set(VkDevice dispatchable_object, VkDescriptorSet vkObj, VkDebugReportObjectTypeEXT objType) 1050 { 1051 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 1052 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 1053 (uint64_t)(vkObj)); 1054 1055 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 1056 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 1057 pNewObjNode->objType = objType; 1058 pNewObjNode->status = OBJSTATUS_NONE; 1059 pNewObjNode->vkObj = (uint64_t)(vkObj); 1060 VkDescriptorSetMap[(uint64_t)vkObj] = pNewObjNode; 1061 uint32_t objIndex = objTypeToIndex(objType); 1062 numObjs[objIndex]++; 1063 numTotalObjs++; 1064 } 1065 1066 // CODEGEN : file ../vk-layer-generate.py line #804 1067 static void destroy_descriptor_set(VkDevice dispatchable_object, VkDescriptorSet object) 1068 { 1069 uint64_t object_handle = (uint64_t)(object); 1070 auto it = VkDescriptorSetMap.find(object_handle); 1071 if (it != VkDescriptorSetMap.end()) { 1072 OBJTRACK_NODE* pNode = it->second; 1073 uint32_t objIndex = objTypeToIndex(pNode->objType); 1074 assert(numTotalObjs > 0); 1075 numTotalObjs--; 1076 assert(numObjs[objIndex] > 0); 1077 numObjs[objIndex]--; 1078 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 1079 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 1080 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 1081 string_VkDebugReportObjectTypeEXT(pNode->objType)); 1082 delete pNode; 1083 VkDescriptorSetMap.erase(it); 1084 } else { 1085 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 1086 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 1087 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 1088 object_handle); 1089 } 1090 } 1091 1092 // CODEGEN : file ../vk-layer-generate.py line #781 1093 static void create_render_pass(VkDevice dispatchable_object, VkRenderPass vkObj, VkDebugReportObjectTypeEXT objType) 1094 { 1095 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 1096 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 1097 (uint64_t)(vkObj)); 1098 1099 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 1100 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 1101 pNewObjNode->objType = objType; 1102 pNewObjNode->status = OBJSTATUS_NONE; 1103 pNewObjNode->vkObj = (uint64_t)(vkObj); 1104 VkRenderPassMap[(uint64_t)vkObj] = pNewObjNode; 1105 uint32_t objIndex = objTypeToIndex(objType); 1106 numObjs[objIndex]++; 1107 numTotalObjs++; 1108 } 1109 1110 // CODEGEN : file ../vk-layer-generate.py line #804 1111 static void destroy_render_pass(VkDevice dispatchable_object, VkRenderPass object) 1112 { 1113 uint64_t object_handle = (uint64_t)(object); 1114 auto it = VkRenderPassMap.find(object_handle); 1115 if (it != VkRenderPassMap.end()) { 1116 OBJTRACK_NODE* pNode = it->second; 1117 uint32_t objIndex = objTypeToIndex(pNode->objType); 1118 assert(numTotalObjs > 0); 1119 numTotalObjs--; 1120 assert(numObjs[objIndex] > 0); 1121 numObjs[objIndex]--; 1122 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 1123 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 1124 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 1125 string_VkDebugReportObjectTypeEXT(pNode->objType)); 1126 delete pNode; 1127 VkRenderPassMap.erase(it); 1128 } else { 1129 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 1130 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 1131 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 1132 object_handle); 1133 } 1134 } 1135 1136 // CODEGEN : file ../vk-layer-generate.py line #781 1137 static void create_framebuffer(VkDevice dispatchable_object, VkFramebuffer vkObj, VkDebugReportObjectTypeEXT objType) 1138 { 1139 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 1140 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 1141 (uint64_t)(vkObj)); 1142 1143 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 1144 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 1145 pNewObjNode->objType = objType; 1146 pNewObjNode->status = OBJSTATUS_NONE; 1147 pNewObjNode->vkObj = (uint64_t)(vkObj); 1148 VkFramebufferMap[(uint64_t)vkObj] = pNewObjNode; 1149 uint32_t objIndex = objTypeToIndex(objType); 1150 numObjs[objIndex]++; 1151 numTotalObjs++; 1152 } 1153 1154 // CODEGEN : file ../vk-layer-generate.py line #804 1155 static void destroy_framebuffer(VkDevice dispatchable_object, VkFramebuffer object) 1156 { 1157 uint64_t object_handle = (uint64_t)(object); 1158 auto it = VkFramebufferMap.find(object_handle); 1159 if (it != VkFramebufferMap.end()) { 1160 OBJTRACK_NODE* pNode = it->second; 1161 uint32_t objIndex = objTypeToIndex(pNode->objType); 1162 assert(numTotalObjs > 0); 1163 numTotalObjs--; 1164 assert(numObjs[objIndex] > 0); 1165 numObjs[objIndex]--; 1166 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 1167 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 1168 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 1169 string_VkDebugReportObjectTypeEXT(pNode->objType)); 1170 delete pNode; 1171 VkFramebufferMap.erase(it); 1172 } else { 1173 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 1174 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 1175 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 1176 object_handle); 1177 } 1178 } 1179 1180 // CODEGEN : file ../vk-layer-generate.py line #781 1181 static void create_swapchain_khr(VkDevice dispatchable_object, VkSwapchainKHR vkObj, VkDebugReportObjectTypeEXT objType) 1182 { 1183 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 1184 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 1185 (uint64_t)(vkObj)); 1186 1187 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 1188 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 1189 pNewObjNode->objType = objType; 1190 pNewObjNode->status = OBJSTATUS_NONE; 1191 pNewObjNode->vkObj = (uint64_t)(vkObj); 1192 VkSwapchainKHRMap[(uint64_t)vkObj] = pNewObjNode; 1193 uint32_t objIndex = objTypeToIndex(objType); 1194 numObjs[objIndex]++; 1195 numTotalObjs++; 1196 } 1197 1198 // CODEGEN : file ../vk-layer-generate.py line #804 1199 static void destroy_swapchain_khr(VkDevice dispatchable_object, VkSwapchainKHR object) 1200 { 1201 uint64_t object_handle = (uint64_t)(object); 1202 auto it = VkSwapchainKHRMap.find(object_handle); 1203 if (it != VkSwapchainKHRMap.end()) { 1204 OBJTRACK_NODE* pNode = it->second; 1205 uint32_t objIndex = objTypeToIndex(pNode->objType); 1206 assert(numTotalObjs > 0); 1207 numTotalObjs--; 1208 assert(numObjs[objIndex] > 0); 1209 numObjs[objIndex]--; 1210 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 1211 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 1212 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 1213 string_VkDebugReportObjectTypeEXT(pNode->objType)); 1214 delete pNode; 1215 VkSwapchainKHRMap.erase(it); 1216 } else { 1217 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 1218 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 1219 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 1220 object_handle); 1221 } 1222 } 1223 1224 // CODEGEN : file ../vk-layer-generate.py line #781 1225 static void create_surface_khr(VkDevice dispatchable_object, VkSurfaceKHR vkObj, VkDebugReportObjectTypeEXT objType) 1226 { 1227 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 1228 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 1229 (uint64_t)(vkObj)); 1230 1231 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 1232 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 1233 pNewObjNode->objType = objType; 1234 pNewObjNode->status = OBJSTATUS_NONE; 1235 pNewObjNode->vkObj = (uint64_t)(vkObj); 1236 VkSurfaceKHRMap[(uint64_t)vkObj] = pNewObjNode; 1237 uint32_t objIndex = objTypeToIndex(objType); 1238 numObjs[objIndex]++; 1239 numTotalObjs++; 1240 } 1241 1242 // CODEGEN : file ../vk-layer-generate.py line #804 1243 static void destroy_surface_khr(VkDevice dispatchable_object, VkSurfaceKHR object) 1244 { 1245 uint64_t object_handle = (uint64_t)(object); 1246 auto it = VkSurfaceKHRMap.find(object_handle); 1247 if (it != VkSurfaceKHRMap.end()) { 1248 OBJTRACK_NODE* pNode = it->second; 1249 uint32_t objIndex = objTypeToIndex(pNode->objType); 1250 assert(numTotalObjs > 0); 1251 numTotalObjs--; 1252 assert(numObjs[objIndex] > 0); 1253 numObjs[objIndex]--; 1254 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 1255 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 1256 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 1257 string_VkDebugReportObjectTypeEXT(pNode->objType)); 1258 delete pNode; 1259 VkSurfaceKHRMap.erase(it); 1260 } else { 1261 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 1262 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 1263 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 1264 object_handle); 1265 } 1266 } 1267 1268 // CODEGEN : file ../vk-layer-generate.py line #781 1269 static void create_debug_report_callback_ext(VkDevice dispatchable_object, VkDebugReportCallbackEXT vkObj, VkDebugReportObjectTypeEXT objType) 1270 { 1271 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objType,(uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", 1272 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), 1273 (uint64_t)(vkObj)); 1274 1275 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; 1276 pNewObjNode->belongsTo = (uint64_t)dispatchable_object; 1277 pNewObjNode->objType = objType; 1278 pNewObjNode->status = OBJSTATUS_NONE; 1279 pNewObjNode->vkObj = (uint64_t)(vkObj); 1280 VkDebugReportCallbackEXTMap[(uint64_t)vkObj] = pNewObjNode; 1281 uint32_t objIndex = objTypeToIndex(objType); 1282 numObjs[objIndex]++; 1283 numTotalObjs++; 1284 } 1285 1286 // CODEGEN : file ../vk-layer-generate.py line #804 1287 static void destroy_debug_report_callback_ext(VkDevice dispatchable_object, VkDebugReportCallbackEXT object) 1288 { 1289 uint64_t object_handle = (uint64_t)(object); 1290 auto it = VkDebugReportCallbackEXTMap.find(object_handle); 1291 if (it != VkDebugReportCallbackEXTMap.end()) { 1292 OBJTRACK_NODE* pNode = it->second; 1293 uint32_t objIndex = objTypeToIndex(pNode->objType); 1294 assert(numTotalObjs > 0); 1295 numTotalObjs--; 1296 assert(numObjs[objIndex] > 0); 1297 numObjs[objIndex]--; 1298 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", 1299 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", 1300 string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], 1301 string_VkDebugReportObjectTypeEXT(pNode->objType)); 1302 delete pNode; 1303 VkDebugReportCallbackEXTMap.erase(it); 1304 } else { 1305 log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT ) 0, 1306 object_handle, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", 1307 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", 1308 object_handle); 1309 } 1310 } 1311 1312 //['VkCommandBuffer', 'VkDevice', 'VkInstance', 'VkPhysicalDevice', 'VkQueue'] 1313 // CODEGEN : file ../vk-layer-generate.py line #842 1314 static bool validate_command_buffer(VkCommandBuffer dispatchable_object, VkCommandBuffer object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1315 { 1316 if (null_allowed && (object == VK_NULL_HANDLE)) 1317 return false; 1318 if (VkCommandBufferMap.find((uint64_t)object) == VkCommandBufferMap.end()) { 1319 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1320 "Invalid VkCommandBuffer Object 0x%" PRIx64 ,(uint64_t)(object)); 1321 } 1322 return false; 1323 } 1324 1325 // CODEGEN : file ../vk-layer-generate.py line #859 1326 static bool validate_buffer(VkCommandBuffer dispatchable_object, VkBuffer object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1327 { 1328 if (null_allowed && (object == VK_NULL_HANDLE)) 1329 return false; 1330 if (VkBufferMap.find((uint64_t)object) == VkBufferMap.end()) { 1331 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1332 "Invalid VkBuffer Object 0x%" PRIx64, (uint64_t)(object)); 1333 } 1334 return false; 1335 } 1336 // CODEGEN : file ../vk-layer-generate.py line #859 1337 static bool validate_descriptor_set(VkCommandBuffer dispatchable_object, VkDescriptorSet object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1338 { 1339 if (null_allowed && (object == VK_NULL_HANDLE)) 1340 return false; 1341 if (VkDescriptorSetMap.find((uint64_t)object) == VkDescriptorSetMap.end()) { 1342 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1343 "Invalid VkDescriptorSet Object 0x%" PRIx64, (uint64_t)(object)); 1344 } 1345 return false; 1346 } 1347 // CODEGEN : file ../vk-layer-generate.py line #859 1348 static bool validate_event(VkCommandBuffer dispatchable_object, VkEvent object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1349 { 1350 if (null_allowed && (object == VK_NULL_HANDLE)) 1351 return false; 1352 if (VkEventMap.find((uint64_t)object) == VkEventMap.end()) { 1353 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1354 "Invalid VkEvent Object 0x%" PRIx64, (uint64_t)(object)); 1355 } 1356 return false; 1357 } 1358 // CODEGEN : file ../vk-layer-generate.py line #859 1359 static bool validate_framebuffer(VkCommandBuffer dispatchable_object, VkFramebuffer object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1360 { 1361 if (null_allowed && (object == VK_NULL_HANDLE)) 1362 return false; 1363 if (VkFramebufferMap.find((uint64_t)object) == VkFramebufferMap.end()) { 1364 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1365 "Invalid VkFramebuffer Object 0x%" PRIx64, (uint64_t)(object)); 1366 } 1367 return false; 1368 } 1369 // CODEGEN : file ../vk-layer-generate.py line #859 1370 static bool validate_image(VkCommandBuffer dispatchable_object, VkImage object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1371 { 1372 if (null_allowed && (object == VK_NULL_HANDLE)) 1373 return false; 1374 // We need to validate normal image objects and those from the swapchain 1375 if ((VkImageMap.find((uint64_t)object) == VkImageMap.end()) && 1376 (swapchainImageMap.find((uint64_t)object) == swapchainImageMap.end())) { 1377 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1378 "Invalid VkImage Object 0x%" PRIx64, (uint64_t)(object)); 1379 } 1380 return false; 1381 } 1382 // CODEGEN : file ../vk-layer-generate.py line #859 1383 static bool validate_pipeline(VkCommandBuffer dispatchable_object, VkPipeline object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1384 { 1385 if (null_allowed && (object == VK_NULL_HANDLE)) 1386 return false; 1387 if (VkPipelineMap.find((uint64_t)object) == VkPipelineMap.end()) { 1388 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1389 "Invalid VkPipeline Object 0x%" PRIx64, (uint64_t)(object)); 1390 } 1391 return false; 1392 } 1393 // CODEGEN : file ../vk-layer-generate.py line #859 1394 static bool validate_pipeline_layout(VkCommandBuffer dispatchable_object, VkPipelineLayout object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1395 { 1396 if (null_allowed && (object == VK_NULL_HANDLE)) 1397 return false; 1398 if (VkPipelineLayoutMap.find((uint64_t)object) == VkPipelineLayoutMap.end()) { 1399 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1400 "Invalid VkPipelineLayout Object 0x%" PRIx64, (uint64_t)(object)); 1401 } 1402 return false; 1403 } 1404 // CODEGEN : file ../vk-layer-generate.py line #859 1405 static bool validate_query_pool(VkCommandBuffer dispatchable_object, VkQueryPool object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1406 { 1407 if (null_allowed && (object == VK_NULL_HANDLE)) 1408 return false; 1409 if (VkQueryPoolMap.find((uint64_t)object) == VkQueryPoolMap.end()) { 1410 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1411 "Invalid VkQueryPool Object 0x%" PRIx64, (uint64_t)(object)); 1412 } 1413 return false; 1414 } 1415 // CODEGEN : file ../vk-layer-generate.py line #859 1416 static bool validate_render_pass(VkCommandBuffer dispatchable_object, VkRenderPass object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1417 { 1418 if (null_allowed && (object == VK_NULL_HANDLE)) 1419 return false; 1420 if (VkRenderPassMap.find((uint64_t)object) == VkRenderPassMap.end()) { 1421 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1422 "Invalid VkRenderPass Object 0x%" PRIx64, (uint64_t)(object)); 1423 } 1424 return false; 1425 } 1426 1427 // CODEGEN : file ../vk-layer-generate.py line #842 1428 static bool validate_device(VkDevice dispatchable_object, VkDevice object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1429 { 1430 if (null_allowed && (object == VK_NULL_HANDLE)) 1431 return false; 1432 if (VkDeviceMap.find((uint64_t)object) == VkDeviceMap.end()) { 1433 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1434 "Invalid VkDevice Object 0x%" PRIx64 ,(uint64_t)(object)); 1435 } 1436 return false; 1437 } 1438 1439 // CODEGEN : file ../vk-layer-generate.py line #859 1440 static bool validate_buffer(VkDevice dispatchable_object, VkBuffer object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1441 { 1442 if (null_allowed && (object == VK_NULL_HANDLE)) 1443 return false; 1444 if (VkBufferMap.find((uint64_t)object) == VkBufferMap.end()) { 1445 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1446 "Invalid VkBuffer Object 0x%" PRIx64, (uint64_t)(object)); 1447 } 1448 return false; 1449 } 1450 // CODEGEN : file ../vk-layer-generate.py line #859 1451 static bool validate_buffer_view(VkDevice dispatchable_object, VkBufferView object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1452 { 1453 if (null_allowed && (object == VK_NULL_HANDLE)) 1454 return false; 1455 if (VkBufferViewMap.find((uint64_t)object) == VkBufferViewMap.end()) { 1456 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1457 "Invalid VkBufferView Object 0x%" PRIx64, (uint64_t)(object)); 1458 } 1459 return false; 1460 } 1461 // CODEGEN : file ../vk-layer-generate.py line #859 1462 static bool validate_command_buffer(VkDevice dispatchable_object, VkCommandBuffer object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1463 { 1464 if (null_allowed && (object == VK_NULL_HANDLE)) 1465 return false; 1466 if (VkCommandBufferMap.find((uint64_t)object) == VkCommandBufferMap.end()) { 1467 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1468 "Invalid VkCommandBuffer Object 0x%" PRIx64, (uint64_t)(object)); 1469 } 1470 return false; 1471 } 1472 // CODEGEN : file ../vk-layer-generate.py line #859 1473 static bool validate_command_pool(VkDevice dispatchable_object, VkCommandPool object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1474 { 1475 if (null_allowed && (object == VK_NULL_HANDLE)) 1476 return false; 1477 if (VkCommandPoolMap.find((uint64_t)object) == VkCommandPoolMap.end()) { 1478 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1479 "Invalid VkCommandPool Object 0x%" PRIx64, (uint64_t)(object)); 1480 } 1481 return false; 1482 } 1483 // CODEGEN : file ../vk-layer-generate.py line #859 1484 static bool validate_descriptor_pool(VkDevice dispatchable_object, VkDescriptorPool object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1485 { 1486 if (null_allowed && (object == VK_NULL_HANDLE)) 1487 return false; 1488 if (VkDescriptorPoolMap.find((uint64_t)object) == VkDescriptorPoolMap.end()) { 1489 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1490 "Invalid VkDescriptorPool Object 0x%" PRIx64, (uint64_t)(object)); 1491 } 1492 return false; 1493 } 1494 // CODEGEN : file ../vk-layer-generate.py line #859 1495 static bool validate_descriptor_set(VkDevice dispatchable_object, VkDescriptorSet object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1496 { 1497 if (null_allowed && (object == VK_NULL_HANDLE)) 1498 return false; 1499 if (VkDescriptorSetMap.find((uint64_t)object) == VkDescriptorSetMap.end()) { 1500 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1501 "Invalid VkDescriptorSet Object 0x%" PRIx64, (uint64_t)(object)); 1502 } 1503 return false; 1504 } 1505 // CODEGEN : file ../vk-layer-generate.py line #859 1506 static bool validate_descriptor_set_layout(VkDevice dispatchable_object, VkDescriptorSetLayout object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1507 { 1508 if (null_allowed && (object == VK_NULL_HANDLE)) 1509 return false; 1510 if (VkDescriptorSetLayoutMap.find((uint64_t)object) == VkDescriptorSetLayoutMap.end()) { 1511 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1512 "Invalid VkDescriptorSetLayout Object 0x%" PRIx64, (uint64_t)(object)); 1513 } 1514 return false; 1515 } 1516 // CODEGEN : file ../vk-layer-generate.py line #859 1517 static bool validate_device_memory(VkDevice dispatchable_object, VkDeviceMemory object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1518 { 1519 if (null_allowed && (object == VK_NULL_HANDLE)) 1520 return false; 1521 if (VkDeviceMemoryMap.find((uint64_t)object) == VkDeviceMemoryMap.end()) { 1522 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1523 "Invalid VkDeviceMemory Object 0x%" PRIx64, (uint64_t)(object)); 1524 } 1525 return false; 1526 } 1527 // CODEGEN : file ../vk-layer-generate.py line #859 1528 static bool validate_event(VkDevice dispatchable_object, VkEvent object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1529 { 1530 if (null_allowed && (object == VK_NULL_HANDLE)) 1531 return false; 1532 if (VkEventMap.find((uint64_t)object) == VkEventMap.end()) { 1533 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1534 "Invalid VkEvent Object 0x%" PRIx64, (uint64_t)(object)); 1535 } 1536 return false; 1537 } 1538 // CODEGEN : file ../vk-layer-generate.py line #859 1539 static bool validate_fence(VkDevice dispatchable_object, VkFence object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1540 { 1541 if (null_allowed && (object == VK_NULL_HANDLE)) 1542 return false; 1543 if (VkFenceMap.find((uint64_t)object) == VkFenceMap.end()) { 1544 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1545 "Invalid VkFence Object 0x%" PRIx64, (uint64_t)(object)); 1546 } 1547 return false; 1548 } 1549 // CODEGEN : file ../vk-layer-generate.py line #859 1550 static bool validate_framebuffer(VkDevice dispatchable_object, VkFramebuffer object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1551 { 1552 if (null_allowed && (object == VK_NULL_HANDLE)) 1553 return false; 1554 if (VkFramebufferMap.find((uint64_t)object) == VkFramebufferMap.end()) { 1555 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1556 "Invalid VkFramebuffer Object 0x%" PRIx64, (uint64_t)(object)); 1557 } 1558 return false; 1559 } 1560 // CODEGEN : file ../vk-layer-generate.py line #859 1561 static bool validate_image(VkDevice dispatchable_object, VkImage object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1562 { 1563 if (null_allowed && (object == VK_NULL_HANDLE)) 1564 return false; 1565 // We need to validate normal image objects and those from the swapchain 1566 if ((VkImageMap.find((uint64_t)object) == VkImageMap.end()) && 1567 (swapchainImageMap.find((uint64_t)object) == swapchainImageMap.end())) { 1568 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1569 "Invalid VkImage Object 0x%" PRIx64, (uint64_t)(object)); 1570 } 1571 return false; 1572 } 1573 // CODEGEN : file ../vk-layer-generate.py line #859 1574 static bool validate_image_view(VkDevice dispatchable_object, VkImageView object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1575 { 1576 if (null_allowed && (object == VK_NULL_HANDLE)) 1577 return false; 1578 if (VkImageViewMap.find((uint64_t)object) == VkImageViewMap.end()) { 1579 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1580 "Invalid VkImageView Object 0x%" PRIx64, (uint64_t)(object)); 1581 } 1582 return false; 1583 } 1584 // CODEGEN : file ../vk-layer-generate.py line #859 1585 static bool validate_pipeline(VkDevice dispatchable_object, VkPipeline object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1586 { 1587 if (null_allowed && (object == VK_NULL_HANDLE)) 1588 return false; 1589 if (VkPipelineMap.find((uint64_t)object) == VkPipelineMap.end()) { 1590 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1591 "Invalid VkPipeline Object 0x%" PRIx64, (uint64_t)(object)); 1592 } 1593 return false; 1594 } 1595 // CODEGEN : file ../vk-layer-generate.py line #859 1596 static bool validate_pipeline_cache(VkDevice dispatchable_object, VkPipelineCache object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1597 { 1598 if (null_allowed && (object == VK_NULL_HANDLE)) 1599 return false; 1600 if (VkPipelineCacheMap.find((uint64_t)object) == VkPipelineCacheMap.end()) { 1601 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1602 "Invalid VkPipelineCache Object 0x%" PRIx64, (uint64_t)(object)); 1603 } 1604 return false; 1605 } 1606 // CODEGEN : file ../vk-layer-generate.py line #859 1607 static bool validate_pipeline_layout(VkDevice dispatchable_object, VkPipelineLayout object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1608 { 1609 if (null_allowed && (object == VK_NULL_HANDLE)) 1610 return false; 1611 if (VkPipelineLayoutMap.find((uint64_t)object) == VkPipelineLayoutMap.end()) { 1612 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1613 "Invalid VkPipelineLayout Object 0x%" PRIx64, (uint64_t)(object)); 1614 } 1615 return false; 1616 } 1617 // CODEGEN : file ../vk-layer-generate.py line #859 1618 static bool validate_query_pool(VkDevice dispatchable_object, VkQueryPool object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1619 { 1620 if (null_allowed && (object == VK_NULL_HANDLE)) 1621 return false; 1622 if (VkQueryPoolMap.find((uint64_t)object) == VkQueryPoolMap.end()) { 1623 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1624 "Invalid VkQueryPool Object 0x%" PRIx64, (uint64_t)(object)); 1625 } 1626 return false; 1627 } 1628 // CODEGEN : file ../vk-layer-generate.py line #859 1629 static bool validate_queue(VkDevice dispatchable_object, VkQueue object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1630 { 1631 if (null_allowed && (object == VK_NULL_HANDLE)) 1632 return false; 1633 if (VkQueueMap.find((uint64_t)object) == VkQueueMap.end()) { 1634 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1635 "Invalid VkQueue Object 0x%" PRIx64, (uint64_t)(object)); 1636 } 1637 return false; 1638 } 1639 // CODEGEN : file ../vk-layer-generate.py line #859 1640 static bool validate_render_pass(VkDevice dispatchable_object, VkRenderPass object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1641 { 1642 if (null_allowed && (object == VK_NULL_HANDLE)) 1643 return false; 1644 if (VkRenderPassMap.find((uint64_t)object) == VkRenderPassMap.end()) { 1645 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1646 "Invalid VkRenderPass Object 0x%" PRIx64, (uint64_t)(object)); 1647 } 1648 return false; 1649 } 1650 // CODEGEN : file ../vk-layer-generate.py line #859 1651 static bool validate_sampler(VkDevice dispatchable_object, VkSampler object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1652 { 1653 if (null_allowed && (object == VK_NULL_HANDLE)) 1654 return false; 1655 if (VkSamplerMap.find((uint64_t)object) == VkSamplerMap.end()) { 1656 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1657 "Invalid VkSampler Object 0x%" PRIx64, (uint64_t)(object)); 1658 } 1659 return false; 1660 } 1661 // CODEGEN : file ../vk-layer-generate.py line #859 1662 static bool validate_semaphore(VkDevice dispatchable_object, VkSemaphore object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1663 { 1664 if (null_allowed && (object == VK_NULL_HANDLE)) 1665 return false; 1666 if (VkSemaphoreMap.find((uint64_t)object) == VkSemaphoreMap.end()) { 1667 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1668 "Invalid VkSemaphore Object 0x%" PRIx64, (uint64_t)(object)); 1669 } 1670 return false; 1671 } 1672 // CODEGEN : file ../vk-layer-generate.py line #859 1673 static bool validate_shader_module(VkDevice dispatchable_object, VkShaderModule object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1674 { 1675 if (null_allowed && (object == VK_NULL_HANDLE)) 1676 return false; 1677 if (VkShaderModuleMap.find((uint64_t)object) == VkShaderModuleMap.end()) { 1678 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1679 "Invalid VkShaderModule Object 0x%" PRIx64, (uint64_t)(object)); 1680 } 1681 return false; 1682 } 1683 // CODEGEN : file ../vk-layer-generate.py line #859 1684 static bool validate_surface_khr(VkDevice dispatchable_object, VkSurfaceKHR object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1685 { 1686 if (null_allowed && (object == VK_NULL_HANDLE)) 1687 return false; 1688 if (VkSurfaceKHRMap.find((uint64_t)object) == VkSurfaceKHRMap.end()) { 1689 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1690 "Invalid VkSurfaceKHR Object 0x%" PRIx64, (uint64_t)(object)); 1691 } 1692 return false; 1693 } 1694 // CODEGEN : file ../vk-layer-generate.py line #859 1695 static bool validate_swapchain_khr(VkDevice dispatchable_object, VkSwapchainKHR object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1696 { 1697 if (null_allowed && (object == VK_NULL_HANDLE)) 1698 return false; 1699 if (VkSwapchainKHRMap.find((uint64_t)object) == VkSwapchainKHRMap.end()) { 1700 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1701 "Invalid VkSwapchainKHR Object 0x%" PRIx64, (uint64_t)(object)); 1702 } 1703 return false; 1704 } 1705 1706 // CODEGEN : file ../vk-layer-generate.py line #842 1707 static bool validate_instance(VkInstance dispatchable_object, VkInstance object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1708 { 1709 if (null_allowed && (object == VK_NULL_HANDLE)) 1710 return false; 1711 if (VkInstanceMap.find((uint64_t)object) == VkInstanceMap.end()) { 1712 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1713 "Invalid VkInstance Object 0x%" PRIx64 ,(uint64_t)(object)); 1714 } 1715 return false; 1716 } 1717 1718 // CODEGEN : file ../vk-layer-generate.py line #859 1719 static bool validate_physical_device(VkInstance dispatchable_object, VkPhysicalDevice object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1720 { 1721 if (null_allowed && (object == VK_NULL_HANDLE)) 1722 return false; 1723 if (VkPhysicalDeviceMap.find((uint64_t)object) == VkPhysicalDeviceMap.end()) { 1724 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1725 "Invalid VkPhysicalDevice Object 0x%" PRIx64, (uint64_t)(object)); 1726 } 1727 return false; 1728 } 1729 // CODEGEN : file ../vk-layer-generate.py line #859 1730 static bool validate_surface_khr(VkInstance dispatchable_object, VkSurfaceKHR object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1731 { 1732 if (null_allowed && (object == VK_NULL_HANDLE)) 1733 return false; 1734 if (VkSurfaceKHRMap.find((uint64_t)object) == VkSurfaceKHRMap.end()) { 1735 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1736 "Invalid VkSurfaceKHR Object 0x%" PRIx64, (uint64_t)(object)); 1737 } 1738 return false; 1739 } 1740 1741 // CODEGEN : file ../vk-layer-generate.py line #842 1742 static bool validate_physical_device(VkPhysicalDevice dispatchable_object, VkPhysicalDevice object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1743 { 1744 if (null_allowed && (object == VK_NULL_HANDLE)) 1745 return false; 1746 if (VkPhysicalDeviceMap.find((uint64_t)object) == VkPhysicalDeviceMap.end()) { 1747 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1748 "Invalid VkPhysicalDevice Object 0x%" PRIx64 ,(uint64_t)(object)); 1749 } 1750 return false; 1751 } 1752 1753 // CODEGEN : file ../vk-layer-generate.py line #859 1754 static bool validate_device(VkPhysicalDevice dispatchable_object, VkDevice object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1755 { 1756 if (null_allowed && (object == VK_NULL_HANDLE)) 1757 return false; 1758 if (VkDeviceMap.find((uint64_t)object) == VkDeviceMap.end()) { 1759 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1760 "Invalid VkDevice Object 0x%" PRIx64, (uint64_t)(object)); 1761 } 1762 return false; 1763 } 1764 // CODEGEN : file ../vk-layer-generate.py line #859 1765 static bool validate_surface_khr(VkPhysicalDevice dispatchable_object, VkSurfaceKHR object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1766 { 1767 if (null_allowed && (object == VK_NULL_HANDLE)) 1768 return false; 1769 if (VkSurfaceKHRMap.find((uint64_t)object) == VkSurfaceKHRMap.end()) { 1770 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1771 "Invalid VkSurfaceKHR Object 0x%" PRIx64, (uint64_t)(object)); 1772 } 1773 return false; 1774 } 1775 1776 // CODEGEN : file ../vk-layer-generate.py line #842 1777 static bool validate_queue(VkQueue dispatchable_object, VkQueue object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1778 { 1779 if (null_allowed && (object == VK_NULL_HANDLE)) 1780 return false; 1781 if (VkQueueMap.find((uint64_t)object) == VkQueueMap.end()) { 1782 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1783 "Invalid VkQueue Object 0x%" PRIx64 ,(uint64_t)(object)); 1784 } 1785 return false; 1786 } 1787 1788 // CODEGEN : file ../vk-layer-generate.py line #859 1789 static bool validate_buffer(VkQueue dispatchable_object, VkBuffer object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1790 { 1791 if (null_allowed && (object == VK_NULL_HANDLE)) 1792 return false; 1793 if (VkBufferMap.find((uint64_t)object) == VkBufferMap.end()) { 1794 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1795 "Invalid VkBuffer Object 0x%" PRIx64, (uint64_t)(object)); 1796 } 1797 return false; 1798 } 1799 // CODEGEN : file ../vk-layer-generate.py line #859 1800 static bool validate_command_buffer(VkQueue dispatchable_object, VkCommandBuffer object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1801 { 1802 if (null_allowed && (object == VK_NULL_HANDLE)) 1803 return false; 1804 if (VkCommandBufferMap.find((uint64_t)object) == VkCommandBufferMap.end()) { 1805 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1806 "Invalid VkCommandBuffer Object 0x%" PRIx64, (uint64_t)(object)); 1807 } 1808 return false; 1809 } 1810 // CODEGEN : file ../vk-layer-generate.py line #859 1811 static bool validate_device_memory(VkQueue dispatchable_object, VkDeviceMemory object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1812 { 1813 if (null_allowed && (object == VK_NULL_HANDLE)) 1814 return false; 1815 if (VkDeviceMemoryMap.find((uint64_t)object) == VkDeviceMemoryMap.end()) { 1816 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1817 "Invalid VkDeviceMemory Object 0x%" PRIx64, (uint64_t)(object)); 1818 } 1819 return false; 1820 } 1821 // CODEGEN : file ../vk-layer-generate.py line #859 1822 static bool validate_fence(VkQueue dispatchable_object, VkFence object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1823 { 1824 if (null_allowed && (object == VK_NULL_HANDLE)) 1825 return false; 1826 if (VkFenceMap.find((uint64_t)object) == VkFenceMap.end()) { 1827 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1828 "Invalid VkFence Object 0x%" PRIx64, (uint64_t)(object)); 1829 } 1830 return false; 1831 } 1832 // CODEGEN : file ../vk-layer-generate.py line #859 1833 static bool validate_image(VkQueue dispatchable_object, VkImage object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1834 { 1835 if (null_allowed && (object == VK_NULL_HANDLE)) 1836 return false; 1837 // We need to validate normal image objects and those from the swapchain 1838 if ((VkImageMap.find((uint64_t)object) == VkImageMap.end()) && 1839 (swapchainImageMap.find((uint64_t)object) == swapchainImageMap.end())) { 1840 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1841 "Invalid VkImage Object 0x%" PRIx64, (uint64_t)(object)); 1842 } 1843 return false; 1844 } 1845 // CODEGEN : file ../vk-layer-generate.py line #859 1846 static bool validate_semaphore(VkQueue dispatchable_object, VkSemaphore object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1847 { 1848 if (null_allowed && (object == VK_NULL_HANDLE)) 1849 return false; 1850 if (VkSemaphoreMap.find((uint64_t)object) == VkSemaphoreMap.end()) { 1851 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1852 "Invalid VkSemaphore Object 0x%" PRIx64, (uint64_t)(object)); 1853 } 1854 return false; 1855 } 1856 // CODEGEN : file ../vk-layer-generate.py line #859 1857 static bool validate_swapchain_khr(VkQueue dispatchable_object, VkSwapchainKHR object, VkDebugReportObjectTypeEXT objType, bool null_allowed) 1858 { 1859 if (null_allowed && (object == VK_NULL_HANDLE)) 1860 return false; 1861 if (VkSwapchainKHRMap.find((uint64_t)object) == VkSwapchainKHRMap.end()) { 1862 return log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, objType, (uint64_t)(object), __LINE__, OBJTRACK_INVALID_OBJECT, "OBJTRACK", 1863 "Invalid VkSwapchainKHR Object 0x%" PRIx64, (uint64_t)(object)); 1864 } 1865 return false; 1866 } 1867 1868 1869 1870 // CODEGEN : file ../vk-layer-generate.py line #881 1871 VKAPI_ATTR void VKAPI_CALL DestroyInstance( 1872 VkInstance instance, 1873 const VkAllocationCallbacks* pAllocator) 1874 { 1875 std::unique_lock<std::mutex> lock(global_lock); 1876 1877 dispatch_key key = get_dispatch_key(instance); 1878 layer_data *my_data = get_my_data_ptr(key, layer_data_map); 1879 1880 // Enable the temporary callback(s) here to catch cleanup issues: 1881 bool callback_setup = false; 1882 if (my_data->num_tmp_callbacks > 0) { 1883 if (!layer_enable_tmp_callbacks(my_data->report_data, 1884 my_data->num_tmp_callbacks, 1885 my_data->tmp_dbg_create_infos, 1886 my_data->tmp_callbacks)) { 1887 callback_setup = true; 1888 } 1889 } 1890 1891 validate_instance(instance, instance, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, false); 1892 1893 destroy_instance(instance, instance); 1894 // Report any remaining objects in LL 1895 1896 for (auto iit = VkDeviceMap.begin(); iit != VkDeviceMap.end();) { 1897 OBJTRACK_NODE* pNode = iit->second; 1898 if (pNode->belongsTo == (uint64_t)instance) { 1899 log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 1900 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 1901 pNode->vkObj); 1902 for (auto idt = VkSemaphoreMap.begin(); idt != VkSemaphoreMap.end();) { 1903 OBJTRACK_NODE* pNode = idt->second; 1904 if (pNode->belongsTo == iit->first) { 1905 log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 1906 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 1907 pNode->vkObj); 1908 VkSemaphoreMap.erase(idt++); 1909 } else { 1910 ++idt; 1911 } 1912 } 1913 for (auto idt = VkCommandBufferMap.begin(); idt != VkCommandBufferMap.end();) { 1914 OBJTRACK_NODE* pNode = idt->second; 1915 if (pNode->belongsTo == iit->first) { 1916 log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 1917 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 1918 pNode->vkObj); 1919 VkCommandBufferMap.erase(idt++); 1920 } else { 1921 ++idt; 1922 } 1923 } 1924 for (auto idt = VkFenceMap.begin(); idt != VkFenceMap.end();) { 1925 OBJTRACK_NODE* pNode = idt->second; 1926 if (pNode->belongsTo == iit->first) { 1927 log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 1928 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 1929 pNode->vkObj); 1930 VkFenceMap.erase(idt++); 1931 } else { 1932 ++idt; 1933 } 1934 } 1935 for (auto idt = VkDeviceMemoryMap.begin(); idt != VkDeviceMemoryMap.end();) { 1936 OBJTRACK_NODE* pNode = idt->second; 1937 if (pNode->belongsTo == iit->first) { 1938 log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 1939 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 1940 pNode->vkObj); 1941 VkDeviceMemoryMap.erase(idt++); 1942 } else { 1943 ++idt; 1944 } 1945 } 1946 for (auto idt = VkBufferMap.begin(); idt != VkBufferMap.end();) { 1947 OBJTRACK_NODE* pNode = idt->second; 1948 if (pNode->belongsTo == iit->first) { 1949 log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 1950 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 1951 pNode->vkObj); 1952 VkBufferMap.erase(idt++); 1953 } else { 1954 ++idt; 1955 } 1956 } 1957 for (auto idt = VkImageMap.begin(); idt != VkImageMap.end();) { 1958 OBJTRACK_NODE* pNode = idt->second; 1959 if (pNode->belongsTo == iit->first) { 1960 log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 1961 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 1962 pNode->vkObj); 1963 VkImageMap.erase(idt++); 1964 } else { 1965 ++idt; 1966 } 1967 } 1968 for (auto idt = VkEventMap.begin(); idt != VkEventMap.end();) { 1969 OBJTRACK_NODE* pNode = idt->second; 1970 if (pNode->belongsTo == iit->first) { 1971 log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 1972 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 1973 pNode->vkObj); 1974 VkEventMap.erase(idt++); 1975 } else { 1976 ++idt; 1977 } 1978 } 1979 for (auto idt = VkQueryPoolMap.begin(); idt != VkQueryPoolMap.end();) { 1980 OBJTRACK_NODE* pNode = idt->second; 1981 if (pNode->belongsTo == iit->first) { 1982 log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 1983 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 1984 pNode->vkObj); 1985 VkQueryPoolMap.erase(idt++); 1986 } else { 1987 ++idt; 1988 } 1989 } 1990 for (auto idt = VkBufferViewMap.begin(); idt != VkBufferViewMap.end();) { 1991 OBJTRACK_NODE* pNode = idt->second; 1992 if (pNode->belongsTo == iit->first) { 1993 log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 1994 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 1995 pNode->vkObj); 1996 VkBufferViewMap.erase(idt++); 1997 } else { 1998 ++idt; 1999 } 2000 } 2001 for (auto idt = VkImageViewMap.begin(); idt != VkImageViewMap.end();) { 2002 OBJTRACK_NODE* pNode = idt->second; 2003 if (pNode->belongsTo == iit->first) { 2004 log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2005 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2006 pNode->vkObj); 2007 VkImageViewMap.erase(idt++); 2008 } else { 2009 ++idt; 2010 } 2011 } 2012 for (auto idt = VkShaderModuleMap.begin(); idt != VkShaderModuleMap.end();) { 2013 OBJTRACK_NODE* pNode = idt->second; 2014 if (pNode->belongsTo == iit->first) { 2015 log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2016 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2017 pNode->vkObj); 2018 VkShaderModuleMap.erase(idt++); 2019 } else { 2020 ++idt; 2021 } 2022 } 2023 for (auto idt = VkPipelineCacheMap.begin(); idt != VkPipelineCacheMap.end();) { 2024 OBJTRACK_NODE* pNode = idt->second; 2025 if (pNode->belongsTo == iit->first) { 2026 log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2027 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2028 pNode->vkObj); 2029 VkPipelineCacheMap.erase(idt++); 2030 } else { 2031 ++idt; 2032 } 2033 } 2034 for (auto idt = VkPipelineLayoutMap.begin(); idt != VkPipelineLayoutMap.end();) { 2035 OBJTRACK_NODE* pNode = idt->second; 2036 if (pNode->belongsTo == iit->first) { 2037 log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2038 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2039 pNode->vkObj); 2040 VkPipelineLayoutMap.erase(idt++); 2041 } else { 2042 ++idt; 2043 } 2044 } 2045 for (auto idt = VkRenderPassMap.begin(); idt != VkRenderPassMap.end();) { 2046 OBJTRACK_NODE* pNode = idt->second; 2047 if (pNode->belongsTo == iit->first) { 2048 log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2049 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2050 pNode->vkObj); 2051 VkRenderPassMap.erase(idt++); 2052 } else { 2053 ++idt; 2054 } 2055 } 2056 for (auto idt = VkPipelineMap.begin(); idt != VkPipelineMap.end();) { 2057 OBJTRACK_NODE* pNode = idt->second; 2058 if (pNode->belongsTo == iit->first) { 2059 log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2060 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2061 pNode->vkObj); 2062 VkPipelineMap.erase(idt++); 2063 } else { 2064 ++idt; 2065 } 2066 } 2067 for (auto idt = VkDescriptorSetLayoutMap.begin(); idt != VkDescriptorSetLayoutMap.end();) { 2068 OBJTRACK_NODE* pNode = idt->second; 2069 if (pNode->belongsTo == iit->first) { 2070 log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2071 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2072 pNode->vkObj); 2073 VkDescriptorSetLayoutMap.erase(idt++); 2074 } else { 2075 ++idt; 2076 } 2077 } 2078 for (auto idt = VkSamplerMap.begin(); idt != VkSamplerMap.end();) { 2079 OBJTRACK_NODE* pNode = idt->second; 2080 if (pNode->belongsTo == iit->first) { 2081 log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2082 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2083 pNode->vkObj); 2084 VkSamplerMap.erase(idt++); 2085 } else { 2086 ++idt; 2087 } 2088 } 2089 for (auto idt = VkDescriptorPoolMap.begin(); idt != VkDescriptorPoolMap.end();) { 2090 OBJTRACK_NODE* pNode = idt->second; 2091 if (pNode->belongsTo == iit->first) { 2092 log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2093 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2094 pNode->vkObj); 2095 VkDescriptorPoolMap.erase(idt++); 2096 } else { 2097 ++idt; 2098 } 2099 } 2100 for (auto idt = VkDescriptorSetMap.begin(); idt != VkDescriptorSetMap.end();) { 2101 OBJTRACK_NODE* pNode = idt->second; 2102 if (pNode->belongsTo == iit->first) { 2103 log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2104 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2105 pNode->vkObj); 2106 VkDescriptorSetMap.erase(idt++); 2107 } else { 2108 ++idt; 2109 } 2110 } 2111 for (auto idt = VkFramebufferMap.begin(); idt != VkFramebufferMap.end();) { 2112 OBJTRACK_NODE* pNode = idt->second; 2113 if (pNode->belongsTo == iit->first) { 2114 log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2115 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2116 pNode->vkObj); 2117 VkFramebufferMap.erase(idt++); 2118 } else { 2119 ++idt; 2120 } 2121 } 2122 for (auto idt = VkCommandPoolMap.begin(); idt != VkCommandPoolMap.end();) { 2123 OBJTRACK_NODE* pNode = idt->second; 2124 if (pNode->belongsTo == iit->first) { 2125 log_msg(mid(instance), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2126 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2127 pNode->vkObj); 2128 VkCommandPoolMap.erase(idt++); 2129 } else { 2130 ++idt; 2131 } 2132 } 2133 VkDeviceMap.erase(iit++); 2134 } else { 2135 ++iit; 2136 } 2137 } 2138 2139 VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(object_tracker_instance_table_map, instance); 2140 pInstanceTable->DestroyInstance(instance, pAllocator); 2141 2142 // Disable and cleanup the temporary callback(s): 2143 if (callback_setup) { 2144 layer_disable_tmp_callbacks(my_data->report_data, 2145 my_data->num_tmp_callbacks, 2146 my_data->tmp_callbacks); 2147 } 2148 if (my_data->num_tmp_callbacks > 0) { 2149 layer_free_tmp_callbacks(my_data->tmp_dbg_create_infos, 2150 my_data->tmp_callbacks); 2151 my_data->num_tmp_callbacks = 0; 2152 } 2153 2154 // Clean up logging callback, if any 2155 while (my_data->logging_callback.size() > 0) { 2156 VkDebugReportCallbackEXT callback = my_data->logging_callback.back(); 2157 layer_destroy_msg_callback(my_data->report_data, callback, pAllocator); 2158 my_data->logging_callback.pop_back(); 2159 } 2160 2161 layer_debug_report_destroy_instance(mid(instance)); 2162 layer_data_map.erase(key); 2163 2164 instanceExtMap.erase(pInstanceTable); 2165 lock.unlock(); 2166 object_tracker_instance_table_map.erase(key); 2167 } 2168 2169 2170 // CODEGEN : file ../vk-layer-generate.py line #968 2171 VKAPI_ATTR void VKAPI_CALL DestroyDevice( 2172 VkDevice device, 2173 const VkAllocationCallbacks* pAllocator) 2174 { 2175 std::unique_lock<std::mutex> lock(global_lock); 2176 validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 2177 2178 destroy_device(device, device); 2179 // Report any remaining objects associated with this VkDevice object in LL 2180 for (auto it = VkSemaphoreMap.begin(); it != VkSemaphoreMap.end();) { 2181 OBJTRACK_NODE* pNode = it->second; 2182 if (pNode->belongsTo == (uint64_t)device) { 2183 log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2184 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2185 pNode->vkObj); 2186 VkSemaphoreMap.erase(it++); 2187 } else { 2188 ++it; 2189 } 2190 } 2191 2192 for (auto it = VkFenceMap.begin(); it != VkFenceMap.end();) { 2193 OBJTRACK_NODE* pNode = it->second; 2194 if (pNode->belongsTo == (uint64_t)device) { 2195 log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2196 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2197 pNode->vkObj); 2198 VkFenceMap.erase(it++); 2199 } else { 2200 ++it; 2201 } 2202 } 2203 2204 for (auto it = VkDeviceMemoryMap.begin(); it != VkDeviceMemoryMap.end();) { 2205 OBJTRACK_NODE* pNode = it->second; 2206 if (pNode->belongsTo == (uint64_t)device) { 2207 log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2208 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2209 pNode->vkObj); 2210 VkDeviceMemoryMap.erase(it++); 2211 } else { 2212 ++it; 2213 } 2214 } 2215 2216 for (auto it = VkBufferMap.begin(); it != VkBufferMap.end();) { 2217 OBJTRACK_NODE* pNode = it->second; 2218 if (pNode->belongsTo == (uint64_t)device) { 2219 log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2220 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2221 pNode->vkObj); 2222 VkBufferMap.erase(it++); 2223 } else { 2224 ++it; 2225 } 2226 } 2227 2228 for (auto it = VkImageMap.begin(); it != VkImageMap.end();) { 2229 OBJTRACK_NODE* pNode = it->second; 2230 if (pNode->belongsTo == (uint64_t)device) { 2231 log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2232 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2233 pNode->vkObj); 2234 VkImageMap.erase(it++); 2235 } else { 2236 ++it; 2237 } 2238 } 2239 2240 for (auto it = VkEventMap.begin(); it != VkEventMap.end();) { 2241 OBJTRACK_NODE* pNode = it->second; 2242 if (pNode->belongsTo == (uint64_t)device) { 2243 log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2244 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2245 pNode->vkObj); 2246 VkEventMap.erase(it++); 2247 } else { 2248 ++it; 2249 } 2250 } 2251 2252 for (auto it = VkQueryPoolMap.begin(); it != VkQueryPoolMap.end();) { 2253 OBJTRACK_NODE* pNode = it->second; 2254 if (pNode->belongsTo == (uint64_t)device) { 2255 log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2256 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2257 pNode->vkObj); 2258 VkQueryPoolMap.erase(it++); 2259 } else { 2260 ++it; 2261 } 2262 } 2263 2264 for (auto it = VkBufferViewMap.begin(); it != VkBufferViewMap.end();) { 2265 OBJTRACK_NODE* pNode = it->second; 2266 if (pNode->belongsTo == (uint64_t)device) { 2267 log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2268 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2269 pNode->vkObj); 2270 VkBufferViewMap.erase(it++); 2271 } else { 2272 ++it; 2273 } 2274 } 2275 2276 for (auto it = VkImageViewMap.begin(); it != VkImageViewMap.end();) { 2277 OBJTRACK_NODE* pNode = it->second; 2278 if (pNode->belongsTo == (uint64_t)device) { 2279 log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2280 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2281 pNode->vkObj); 2282 VkImageViewMap.erase(it++); 2283 } else { 2284 ++it; 2285 } 2286 } 2287 2288 for (auto it = VkShaderModuleMap.begin(); it != VkShaderModuleMap.end();) { 2289 OBJTRACK_NODE* pNode = it->second; 2290 if (pNode->belongsTo == (uint64_t)device) { 2291 log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2292 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2293 pNode->vkObj); 2294 VkShaderModuleMap.erase(it++); 2295 } else { 2296 ++it; 2297 } 2298 } 2299 2300 for (auto it = VkPipelineCacheMap.begin(); it != VkPipelineCacheMap.end();) { 2301 OBJTRACK_NODE* pNode = it->second; 2302 if (pNode->belongsTo == (uint64_t)device) { 2303 log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2304 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2305 pNode->vkObj); 2306 VkPipelineCacheMap.erase(it++); 2307 } else { 2308 ++it; 2309 } 2310 } 2311 2312 for (auto it = VkPipelineLayoutMap.begin(); it != VkPipelineLayoutMap.end();) { 2313 OBJTRACK_NODE* pNode = it->second; 2314 if (pNode->belongsTo == (uint64_t)device) { 2315 log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2316 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2317 pNode->vkObj); 2318 VkPipelineLayoutMap.erase(it++); 2319 } else { 2320 ++it; 2321 } 2322 } 2323 2324 for (auto it = VkRenderPassMap.begin(); it != VkRenderPassMap.end();) { 2325 OBJTRACK_NODE* pNode = it->second; 2326 if (pNode->belongsTo == (uint64_t)device) { 2327 log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2328 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2329 pNode->vkObj); 2330 VkRenderPassMap.erase(it++); 2331 } else { 2332 ++it; 2333 } 2334 } 2335 2336 for (auto it = VkPipelineMap.begin(); it != VkPipelineMap.end();) { 2337 OBJTRACK_NODE* pNode = it->second; 2338 if (pNode->belongsTo == (uint64_t)device) { 2339 log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2340 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2341 pNode->vkObj); 2342 VkPipelineMap.erase(it++); 2343 } else { 2344 ++it; 2345 } 2346 } 2347 2348 for (auto it = VkDescriptorSetLayoutMap.begin(); it != VkDescriptorSetLayoutMap.end();) { 2349 OBJTRACK_NODE* pNode = it->second; 2350 if (pNode->belongsTo == (uint64_t)device) { 2351 log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2352 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2353 pNode->vkObj); 2354 VkDescriptorSetLayoutMap.erase(it++); 2355 } else { 2356 ++it; 2357 } 2358 } 2359 2360 for (auto it = VkSamplerMap.begin(); it != VkSamplerMap.end();) { 2361 OBJTRACK_NODE* pNode = it->second; 2362 if (pNode->belongsTo == (uint64_t)device) { 2363 log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2364 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2365 pNode->vkObj); 2366 VkSamplerMap.erase(it++); 2367 } else { 2368 ++it; 2369 } 2370 } 2371 2372 for (auto it = VkDescriptorPoolMap.begin(); it != VkDescriptorPoolMap.end();) { 2373 OBJTRACK_NODE* pNode = it->second; 2374 if (pNode->belongsTo == (uint64_t)device) { 2375 log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2376 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2377 pNode->vkObj); 2378 VkDescriptorPoolMap.erase(it++); 2379 } else { 2380 ++it; 2381 } 2382 } 2383 2384 for (auto it = VkFramebufferMap.begin(); it != VkFramebufferMap.end();) { 2385 OBJTRACK_NODE* pNode = it->second; 2386 if (pNode->belongsTo == (uint64_t)device) { 2387 log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2388 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2389 pNode->vkObj); 2390 VkFramebufferMap.erase(it++); 2391 } else { 2392 ++it; 2393 } 2394 } 2395 2396 for (auto it = VkCommandPoolMap.begin(); it != VkCommandPoolMap.end();) { 2397 OBJTRACK_NODE* pNode = it->second; 2398 if (pNode->belongsTo == (uint64_t)device) { 2399 log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, pNode->vkObj, __LINE__, OBJTRACK_OBJECT_LEAK, "OBJTRACK", 2400 "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDebugReportObjectTypeEXT(pNode->objType), 2401 pNode->vkObj); 2402 VkCommandPoolMap.erase(it++); 2403 } else { 2404 ++it; 2405 } 2406 } 2407 2408 // Clean up Queue's MemRef Linked Lists 2409 destroyQueueMemRefLists(); 2410 2411 lock.unlock(); 2412 2413 dispatch_key key = get_dispatch_key(device); 2414 VkLayerDispatchTable *pDisp = get_dispatch_table(object_tracker_device_table_map, device); 2415 pDisp->DestroyDevice(device, pAllocator); 2416 object_tracker_device_table_map.erase(key); 2417 2418 } 2419 2420 2421 // CODEGEN : file ../vk-layer-generate.py line #1216 2422 VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) 2423 { 2424 return explicit_CreateInstance(pCreateInfo, pAllocator, pInstance); 2425 } 2426 2427 2428 2429 // CODEGEN : file ../vk-layer-generate.py line #1216 2430 VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) 2431 { 2432 return explicit_EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); 2433 } 2434 2435 // CODEGEN : file ../vk-layer-generate.py line #1216 2436 2437 2438 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) 2439 { 2440 bool skipCall = false; 2441 { 2442 std::lock_guard<std::mutex> lock(global_lock); 2443 // objects to validate: ['physicalDevice'] 2444 // CODEGEN : file ../vk-layer-generate.py line #1099 2445 skipCall |= validate_physical_device(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false); 2446 } 2447 if (skipCall) 2448 return; 2449 get_dispatch_table(object_tracker_instance_table_map, physicalDevice)->GetPhysicalDeviceFeatures(physicalDevice, pFeatures); 2450 } 2451 2452 // CODEGEN : file ../vk-layer-generate.py line #1216 2453 2454 2455 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) 2456 { 2457 bool skipCall = false; 2458 { 2459 std::lock_guard<std::mutex> lock(global_lock); 2460 // objects to validate: ['physicalDevice'] 2461 // CODEGEN : file ../vk-layer-generate.py line #1099 2462 skipCall |= validate_physical_device(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false); 2463 } 2464 if (skipCall) 2465 return; 2466 get_dispatch_table(object_tracker_instance_table_map, physicalDevice)->GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); 2467 } 2468 2469 // CODEGEN : file ../vk-layer-generate.py line #1216 2470 2471 2472 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) 2473 { 2474 bool skipCall = false; 2475 { 2476 std::lock_guard<std::mutex> lock(global_lock); 2477 // objects to validate: ['physicalDevice'] 2478 // CODEGEN : file ../vk-layer-generate.py line #1099 2479 skipCall |= validate_physical_device(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false); 2480 } 2481 if (skipCall) 2482 return VK_ERROR_VALIDATION_FAILED_EXT; 2483 VkResult result = get_dispatch_table(object_tracker_instance_table_map, physicalDevice)->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); 2484 return result; 2485 } 2486 2487 // CODEGEN : file ../vk-layer-generate.py line #1216 2488 2489 2490 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) 2491 { 2492 bool skipCall = false; 2493 { 2494 std::lock_guard<std::mutex> lock(global_lock); 2495 // objects to validate: ['physicalDevice'] 2496 // CODEGEN : file ../vk-layer-generate.py line #1099 2497 skipCall |= validate_physical_device(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false); 2498 } 2499 if (skipCall) 2500 return; 2501 get_dispatch_table(object_tracker_instance_table_map, physicalDevice)->GetPhysicalDeviceProperties(physicalDevice, pProperties); 2502 } 2503 2504 // CODEGEN : file ../vk-layer-generate.py line #1216 2505 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) 2506 { 2507 return explicit_GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); 2508 } 2509 2510 // CODEGEN : file ../vk-layer-generate.py line #1216 2511 2512 2513 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) 2514 { 2515 bool skipCall = false; 2516 { 2517 std::lock_guard<std::mutex> lock(global_lock); 2518 // objects to validate: ['physicalDevice'] 2519 // CODEGEN : file ../vk-layer-generate.py line #1099 2520 skipCall |= validate_physical_device(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false); 2521 } 2522 if (skipCall) 2523 return; 2524 get_dispatch_table(object_tracker_instance_table_map, physicalDevice)->GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); 2525 } 2526 2527 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char* pName); 2528 2529 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char* pName); 2530 2531 // CODEGEN : file ../vk-layer-generate.py line #1216 2532 VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) 2533 { 2534 return explicit_CreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice); 2535 } 2536 2537 2538 2539 // CODEGEN : file ../vk-layer-generate.py line #1216 2540 VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) 2541 { 2542 return explicit_GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); 2543 } 2544 2545 // CODEGEN : file ../vk-layer-generate.py line #1216 2546 2547 2548 VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) 2549 { 2550 bool skipCall = false; 2551 { 2552 std::lock_guard<std::mutex> lock(global_lock); 2553 // objects to validate: ['fence', 'pSubmits[submitCount]', 'queue'] 2554 // CODEGEN : file ../vk-layer-generate.py line #1099 2555 skipCall |= validate_fence(queue, fence, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, true); 2556 if (pSubmits) { 2557 // CODEGEN : file ../vk-layer-generate.py line #1055 2558 for (uint32_t idx0=0; idx0<submitCount; ++idx0) { 2559 if (pSubmits[idx0].pCommandBuffers) { 2560 for (uint32_t idx1=0; idx1<pSubmits[idx0].commandBufferCount; ++idx1) { 2561 // CODEGEN : file ../vk-layer-generate.py line #1091 2562 skipCall |= validate_command_buffer(queue, pSubmits[idx0].pCommandBuffers[idx1], VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 2563 } 2564 } 2565 if (pSubmits[idx0].pSignalSemaphores) { 2566 for (uint32_t idx2=0; idx2<pSubmits[idx0].signalSemaphoreCount; ++idx2) { 2567 // CODEGEN : file ../vk-layer-generate.py line #1091 2568 skipCall |= validate_semaphore(queue, pSubmits[idx0].pSignalSemaphores[idx2], VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, false); 2569 } 2570 } 2571 if (pSubmits[idx0].pWaitSemaphores) { 2572 for (uint32_t idx3=0; idx3<pSubmits[idx0].waitSemaphoreCount; ++idx3) { 2573 // CODEGEN : file ../vk-layer-generate.py line #1091 2574 skipCall |= validate_semaphore(queue, pSubmits[idx0].pWaitSemaphores[idx3], VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, false); 2575 } 2576 } 2577 } 2578 } 2579 if (queue) { 2580 // CODEGEN : file ../vk-layer-generate.py line #1091 2581 skipCall |= validate_queue(queue, queue, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, false); 2582 } 2583 } 2584 if (skipCall) 2585 return VK_ERROR_VALIDATION_FAILED_EXT; 2586 VkResult result = get_dispatch_table(object_tracker_device_table_map, queue)->QueueSubmit(queue, submitCount, pSubmits, fence); 2587 return result; 2588 } 2589 2590 // CODEGEN : file ../vk-layer-generate.py line #1216 2591 2592 2593 VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle(VkQueue queue) 2594 { 2595 bool skipCall = false; 2596 { 2597 std::lock_guard<std::mutex> lock(global_lock); 2598 // objects to validate: ['queue'] 2599 // CODEGEN : file ../vk-layer-generate.py line #1099 2600 skipCall |= validate_queue(queue, queue, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, false); 2601 } 2602 if (skipCall) 2603 return VK_ERROR_VALIDATION_FAILED_EXT; 2604 VkResult result = get_dispatch_table(object_tracker_device_table_map, queue)->QueueWaitIdle(queue); 2605 return result; 2606 } 2607 2608 // CODEGEN : file ../vk-layer-generate.py line #1216 2609 2610 2611 VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle(VkDevice device) 2612 { 2613 bool skipCall = false; 2614 { 2615 std::lock_guard<std::mutex> lock(global_lock); 2616 // objects to validate: ['device'] 2617 // CODEGEN : file ../vk-layer-generate.py line #1099 2618 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 2619 } 2620 if (skipCall) 2621 return VK_ERROR_VALIDATION_FAILED_EXT; 2622 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->DeviceWaitIdle(device); 2623 return result; 2624 } 2625 2626 // CODEGEN : file ../vk-layer-generate.py line #1216 2627 2628 2629 VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) 2630 { 2631 bool skipCall = false; 2632 { 2633 std::lock_guard<std::mutex> lock(global_lock); 2634 // objects to validate: ['device'] 2635 // CODEGEN : file ../vk-layer-generate.py line #1099 2636 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 2637 } 2638 if (skipCall) 2639 return VK_ERROR_VALIDATION_FAILED_EXT; 2640 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory); 2641 { 2642 std::lock_guard<std::mutex> lock(global_lock); 2643 if (result == VK_SUCCESS) { 2644 create_device_memory(device, *pMemory, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT); 2645 } 2646 } 2647 return result; 2648 } 2649 2650 // CODEGEN : file ../vk-layer-generate.py line #1216 2651 VKAPI_ATTR void VKAPI_CALL FreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) 2652 { 2653 return explicit_FreeMemory(device, memory, pAllocator); 2654 } 2655 2656 // CODEGEN : file ../vk-layer-generate.py line #1216 2657 VKAPI_ATTR VkResult VKAPI_CALL MapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) 2658 { 2659 return explicit_MapMemory(device, memory, offset, size, flags, ppData); 2660 } 2661 2662 // CODEGEN : file ../vk-layer-generate.py line #1216 2663 VKAPI_ATTR void VKAPI_CALL UnmapMemory(VkDevice device, VkDeviceMemory memory) 2664 { 2665 return explicit_UnmapMemory(device, memory); 2666 } 2667 2668 // CODEGEN : file ../vk-layer-generate.py line #1216 2669 2670 2671 VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) 2672 { 2673 bool skipCall = false; 2674 { 2675 std::lock_guard<std::mutex> lock(global_lock); 2676 // objects to validate: ['device', 'pMemoryRanges[memoryRangeCount]'] 2677 // CODEGEN : file ../vk-layer-generate.py line #1099 2678 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 2679 if (pMemoryRanges) { 2680 // CODEGEN : file ../vk-layer-generate.py line #1055 2681 for (uint32_t idx0=0; idx0<memoryRangeCount; ++idx0) { 2682 if (pMemoryRanges[idx0].memory) { 2683 // CODEGEN : file ../vk-layer-generate.py line #1091 2684 skipCall |= validate_device_memory(device, pMemoryRanges[idx0].memory, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, false); 2685 } 2686 } 2687 } 2688 } 2689 if (skipCall) 2690 return VK_ERROR_VALIDATION_FAILED_EXT; 2691 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); 2692 return result; 2693 } 2694 2695 // CODEGEN : file ../vk-layer-generate.py line #1216 2696 2697 2698 VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) 2699 { 2700 bool skipCall = false; 2701 { 2702 std::lock_guard<std::mutex> lock(global_lock); 2703 // objects to validate: ['device', 'pMemoryRanges[memoryRangeCount]'] 2704 // CODEGEN : file ../vk-layer-generate.py line #1099 2705 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 2706 if (pMemoryRanges) { 2707 // CODEGEN : file ../vk-layer-generate.py line #1055 2708 for (uint32_t idx0=0; idx0<memoryRangeCount; ++idx0) { 2709 if (pMemoryRanges[idx0].memory) { 2710 // CODEGEN : file ../vk-layer-generate.py line #1091 2711 skipCall |= validate_device_memory(device, pMemoryRanges[idx0].memory, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, false); 2712 } 2713 } 2714 } 2715 } 2716 if (skipCall) 2717 return VK_ERROR_VALIDATION_FAILED_EXT; 2718 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); 2719 return result; 2720 } 2721 2722 // CODEGEN : file ../vk-layer-generate.py line #1216 2723 2724 2725 VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) 2726 { 2727 bool skipCall = false; 2728 { 2729 std::lock_guard<std::mutex> lock(global_lock); 2730 // objects to validate: ['device', 'memory'] 2731 // CODEGEN : file ../vk-layer-generate.py line #1099 2732 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 2733 // CODEGEN : file ../vk-layer-generate.py line #1099 2734 skipCall |= validate_device_memory(device, memory, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, false); 2735 } 2736 if (skipCall) 2737 return; 2738 get_dispatch_table(object_tracker_device_table_map, device)->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); 2739 } 2740 2741 // CODEGEN : file ../vk-layer-generate.py line #1216 2742 2743 2744 VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) 2745 { 2746 bool skipCall = false; 2747 { 2748 std::lock_guard<std::mutex> lock(global_lock); 2749 // objects to validate: ['buffer', 'device', 'memory'] 2750 // CODEGEN : file ../vk-layer-generate.py line #1099 2751 skipCall |= validate_buffer(device, buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false); 2752 // CODEGEN : file ../vk-layer-generate.py line #1099 2753 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 2754 // CODEGEN : file ../vk-layer-generate.py line #1099 2755 skipCall |= validate_device_memory(device, memory, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, false); 2756 } 2757 if (skipCall) 2758 return VK_ERROR_VALIDATION_FAILED_EXT; 2759 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->BindBufferMemory(device, buffer, memory, memoryOffset); 2760 return result; 2761 } 2762 2763 // CODEGEN : file ../vk-layer-generate.py line #1216 2764 2765 2766 VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) 2767 { 2768 bool skipCall = false; 2769 { 2770 std::lock_guard<std::mutex> lock(global_lock); 2771 // objects to validate: ['device', 'image', 'memory'] 2772 // CODEGEN : file ../vk-layer-generate.py line #1099 2773 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 2774 // CODEGEN : file ../vk-layer-generate.py line #1099 2775 skipCall |= validate_image(device, image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false); 2776 // CODEGEN : file ../vk-layer-generate.py line #1099 2777 skipCall |= validate_device_memory(device, memory, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, false); 2778 } 2779 if (skipCall) 2780 return VK_ERROR_VALIDATION_FAILED_EXT; 2781 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->BindImageMemory(device, image, memory, memoryOffset); 2782 return result; 2783 } 2784 2785 // CODEGEN : file ../vk-layer-generate.py line #1216 2786 2787 2788 VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) 2789 { 2790 bool skipCall = false; 2791 { 2792 std::lock_guard<std::mutex> lock(global_lock); 2793 // objects to validate: ['buffer', 'device'] 2794 // CODEGEN : file ../vk-layer-generate.py line #1099 2795 skipCall |= validate_buffer(device, buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false); 2796 // CODEGEN : file ../vk-layer-generate.py line #1099 2797 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 2798 } 2799 if (skipCall) 2800 return; 2801 get_dispatch_table(object_tracker_device_table_map, device)->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements); 2802 } 2803 2804 // CODEGEN : file ../vk-layer-generate.py line #1216 2805 2806 2807 VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) 2808 { 2809 bool skipCall = false; 2810 { 2811 std::lock_guard<std::mutex> lock(global_lock); 2812 // objects to validate: ['device', 'image'] 2813 // CODEGEN : file ../vk-layer-generate.py line #1099 2814 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 2815 // CODEGEN : file ../vk-layer-generate.py line #1099 2816 skipCall |= validate_image(device, image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false); 2817 } 2818 if (skipCall) 2819 return; 2820 get_dispatch_table(object_tracker_device_table_map, device)->GetImageMemoryRequirements(device, image, pMemoryRequirements); 2821 } 2822 2823 // CODEGEN : file ../vk-layer-generate.py line #1216 2824 2825 2826 VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) 2827 { 2828 bool skipCall = false; 2829 { 2830 std::lock_guard<std::mutex> lock(global_lock); 2831 // objects to validate: ['device', 'image'] 2832 // CODEGEN : file ../vk-layer-generate.py line #1099 2833 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 2834 // CODEGEN : file ../vk-layer-generate.py line #1099 2835 skipCall |= validate_image(device, image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false); 2836 } 2837 if (skipCall) 2838 return; 2839 get_dispatch_table(object_tracker_device_table_map, device)->GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); 2840 } 2841 2842 // CODEGEN : file ../vk-layer-generate.py line #1216 2843 2844 2845 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) 2846 { 2847 bool skipCall = false; 2848 { 2849 std::lock_guard<std::mutex> lock(global_lock); 2850 // objects to validate: ['physicalDevice'] 2851 // CODEGEN : file ../vk-layer-generate.py line #1099 2852 skipCall |= validate_physical_device(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false); 2853 } 2854 if (skipCall) 2855 return; 2856 get_dispatch_table(object_tracker_instance_table_map, physicalDevice)->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); 2857 } 2858 2859 // CODEGEN : file ../vk-layer-generate.py line #1216 2860 VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) 2861 { 2862 return explicit_QueueBindSparse(queue, bindInfoCount, pBindInfo, fence); 2863 } 2864 2865 // CODEGEN : file ../vk-layer-generate.py line #1216 2866 2867 2868 VKAPI_ATTR VkResult VKAPI_CALL CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) 2869 { 2870 bool skipCall = false; 2871 { 2872 std::lock_guard<std::mutex> lock(global_lock); 2873 // objects to validate: ['device'] 2874 // CODEGEN : file ../vk-layer-generate.py line #1099 2875 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 2876 } 2877 if (skipCall) 2878 return VK_ERROR_VALIDATION_FAILED_EXT; 2879 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->CreateFence(device, pCreateInfo, pAllocator, pFence); 2880 { 2881 std::lock_guard<std::mutex> lock(global_lock); 2882 if (result == VK_SUCCESS) { 2883 create_fence(device, *pFence, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT); 2884 } 2885 } 2886 return result; 2887 } 2888 2889 // CODEGEN : file ../vk-layer-generate.py line #1216 2890 2891 2892 // CODEGEN : file ../vk-layer-generate.py line #1251 2893 2894 2895 VKAPI_ATTR void VKAPI_CALL DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) 2896 { 2897 bool skipCall = false; 2898 { 2899 std::lock_guard<std::mutex> lock(global_lock); 2900 // objects to validate: ['device', 'fence'] 2901 // CODEGEN : file ../vk-layer-generate.py line #1099 2902 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 2903 // CODEGEN : file ../vk-layer-generate.py line #1099 2904 skipCall |= validate_fence(device, fence, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, false); 2905 } 2906 if (skipCall) 2907 return; 2908 { 2909 std::lock_guard<std::mutex> lock(global_lock); 2910 destroy_fence(device, fence); 2911 } 2912 get_dispatch_table(object_tracker_device_table_map, device)->DestroyFence(device, fence, pAllocator); 2913 } 2914 2915 // CODEGEN : file ../vk-layer-generate.py line #1216 2916 2917 2918 VKAPI_ATTR VkResult VKAPI_CALL ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) 2919 { 2920 bool skipCall = false; 2921 { 2922 std::lock_guard<std::mutex> lock(global_lock); 2923 // objects to validate: ['device', 'pFences[fenceCount]'] 2924 // CODEGEN : file ../vk-layer-generate.py line #1099 2925 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 2926 if (pFences) { 2927 for (uint32_t idx0=0; idx0<fenceCount; ++idx0) { 2928 // CODEGEN : file ../vk-layer-generate.py line #1091 2929 skipCall |= validate_fence(device, pFences[idx0], VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, false); 2930 } 2931 } 2932 } 2933 if (skipCall) 2934 return VK_ERROR_VALIDATION_FAILED_EXT; 2935 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->ResetFences(device, fenceCount, pFences); 2936 return result; 2937 } 2938 2939 // CODEGEN : file ../vk-layer-generate.py line #1216 2940 2941 2942 VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus(VkDevice device, VkFence fence) 2943 { 2944 bool skipCall = false; 2945 { 2946 std::lock_guard<std::mutex> lock(global_lock); 2947 // objects to validate: ['device', 'fence'] 2948 // CODEGEN : file ../vk-layer-generate.py line #1099 2949 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 2950 // CODEGEN : file ../vk-layer-generate.py line #1099 2951 skipCall |= validate_fence(device, fence, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, false); 2952 } 2953 if (skipCall) 2954 return VK_ERROR_VALIDATION_FAILED_EXT; 2955 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->GetFenceStatus(device, fence); 2956 return result; 2957 } 2958 2959 // CODEGEN : file ../vk-layer-generate.py line #1216 2960 2961 2962 VKAPI_ATTR VkResult VKAPI_CALL WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) 2963 { 2964 bool skipCall = false; 2965 { 2966 std::lock_guard<std::mutex> lock(global_lock); 2967 // objects to validate: ['device', 'pFences[fenceCount]'] 2968 // CODEGEN : file ../vk-layer-generate.py line #1099 2969 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 2970 if (pFences) { 2971 for (uint32_t idx0=0; idx0<fenceCount; ++idx0) { 2972 // CODEGEN : file ../vk-layer-generate.py line #1091 2973 skipCall |= validate_fence(device, pFences[idx0], VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, false); 2974 } 2975 } 2976 } 2977 if (skipCall) 2978 return VK_ERROR_VALIDATION_FAILED_EXT; 2979 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->WaitForFences(device, fenceCount, pFences, waitAll, timeout); 2980 return result; 2981 } 2982 2983 // CODEGEN : file ../vk-layer-generate.py line #1216 2984 2985 2986 VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) 2987 { 2988 bool skipCall = false; 2989 { 2990 std::lock_guard<std::mutex> lock(global_lock); 2991 // objects to validate: ['device'] 2992 // CODEGEN : file ../vk-layer-generate.py line #1099 2993 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 2994 } 2995 if (skipCall) 2996 return VK_ERROR_VALIDATION_FAILED_EXT; 2997 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); 2998 { 2999 std::lock_guard<std::mutex> lock(global_lock); 3000 if (result == VK_SUCCESS) { 3001 create_semaphore(device, *pSemaphore, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT); 3002 } 3003 } 3004 return result; 3005 } 3006 3007 // CODEGEN : file ../vk-layer-generate.py line #1216 3008 3009 3010 // CODEGEN : file ../vk-layer-generate.py line #1251 3011 3012 3013 VKAPI_ATTR void VKAPI_CALL DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) 3014 { 3015 bool skipCall = false; 3016 { 3017 std::lock_guard<std::mutex> lock(global_lock); 3018 // objects to validate: ['device', 'semaphore'] 3019 // CODEGEN : file ../vk-layer-generate.py line #1099 3020 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3021 // CODEGEN : file ../vk-layer-generate.py line #1099 3022 skipCall |= validate_semaphore(device, semaphore, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, false); 3023 } 3024 if (skipCall) 3025 return; 3026 { 3027 std::lock_guard<std::mutex> lock(global_lock); 3028 destroy_semaphore(device, semaphore); 3029 } 3030 get_dispatch_table(object_tracker_device_table_map, device)->DestroySemaphore(device, semaphore, pAllocator); 3031 } 3032 3033 // CODEGEN : file ../vk-layer-generate.py line #1216 3034 3035 3036 VKAPI_ATTR VkResult VKAPI_CALL CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) 3037 { 3038 bool skipCall = false; 3039 { 3040 std::lock_guard<std::mutex> lock(global_lock); 3041 // objects to validate: ['device'] 3042 // CODEGEN : file ../vk-layer-generate.py line #1099 3043 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3044 } 3045 if (skipCall) 3046 return VK_ERROR_VALIDATION_FAILED_EXT; 3047 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->CreateEvent(device, pCreateInfo, pAllocator, pEvent); 3048 { 3049 std::lock_guard<std::mutex> lock(global_lock); 3050 if (result == VK_SUCCESS) { 3051 create_event(device, *pEvent, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT); 3052 } 3053 } 3054 return result; 3055 } 3056 3057 // CODEGEN : file ../vk-layer-generate.py line #1216 3058 3059 3060 // CODEGEN : file ../vk-layer-generate.py line #1251 3061 3062 3063 VKAPI_ATTR void VKAPI_CALL DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) 3064 { 3065 bool skipCall = false; 3066 { 3067 std::lock_guard<std::mutex> lock(global_lock); 3068 // objects to validate: ['device', 'event'] 3069 // CODEGEN : file ../vk-layer-generate.py line #1099 3070 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3071 // CODEGEN : file ../vk-layer-generate.py line #1099 3072 skipCall |= validate_event(device, event, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, false); 3073 } 3074 if (skipCall) 3075 return; 3076 { 3077 std::lock_guard<std::mutex> lock(global_lock); 3078 destroy_event(device, event); 3079 } 3080 get_dispatch_table(object_tracker_device_table_map, device)->DestroyEvent(device, event, pAllocator); 3081 } 3082 3083 // CODEGEN : file ../vk-layer-generate.py line #1216 3084 3085 3086 VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus(VkDevice device, VkEvent event) 3087 { 3088 bool skipCall = false; 3089 { 3090 std::lock_guard<std::mutex> lock(global_lock); 3091 // objects to validate: ['device', 'event'] 3092 // CODEGEN : file ../vk-layer-generate.py line #1099 3093 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3094 // CODEGEN : file ../vk-layer-generate.py line #1099 3095 skipCall |= validate_event(device, event, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, false); 3096 } 3097 if (skipCall) 3098 return VK_ERROR_VALIDATION_FAILED_EXT; 3099 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->GetEventStatus(device, event); 3100 return result; 3101 } 3102 3103 // CODEGEN : file ../vk-layer-generate.py line #1216 3104 3105 3106 VKAPI_ATTR VkResult VKAPI_CALL SetEvent(VkDevice device, VkEvent event) 3107 { 3108 bool skipCall = false; 3109 { 3110 std::lock_guard<std::mutex> lock(global_lock); 3111 // objects to validate: ['device', 'event'] 3112 // CODEGEN : file ../vk-layer-generate.py line #1099 3113 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3114 // CODEGEN : file ../vk-layer-generate.py line #1099 3115 skipCall |= validate_event(device, event, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, false); 3116 } 3117 if (skipCall) 3118 return VK_ERROR_VALIDATION_FAILED_EXT; 3119 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->SetEvent(device, event); 3120 return result; 3121 } 3122 3123 // CODEGEN : file ../vk-layer-generate.py line #1216 3124 3125 3126 VKAPI_ATTR VkResult VKAPI_CALL ResetEvent(VkDevice device, VkEvent event) 3127 { 3128 bool skipCall = false; 3129 { 3130 std::lock_guard<std::mutex> lock(global_lock); 3131 // objects to validate: ['device', 'event'] 3132 // CODEGEN : file ../vk-layer-generate.py line #1099 3133 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3134 // CODEGEN : file ../vk-layer-generate.py line #1099 3135 skipCall |= validate_event(device, event, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, false); 3136 } 3137 if (skipCall) 3138 return VK_ERROR_VALIDATION_FAILED_EXT; 3139 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->ResetEvent(device, event); 3140 return result; 3141 } 3142 3143 // CODEGEN : file ../vk-layer-generate.py line #1216 3144 3145 3146 VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) 3147 { 3148 bool skipCall = false; 3149 { 3150 std::lock_guard<std::mutex> lock(global_lock); 3151 // objects to validate: ['device'] 3152 // CODEGEN : file ../vk-layer-generate.py line #1099 3153 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3154 } 3155 if (skipCall) 3156 return VK_ERROR_VALIDATION_FAILED_EXT; 3157 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); 3158 { 3159 std::lock_guard<std::mutex> lock(global_lock); 3160 if (result == VK_SUCCESS) { 3161 create_query_pool(device, *pQueryPool, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT); 3162 } 3163 } 3164 return result; 3165 } 3166 3167 // CODEGEN : file ../vk-layer-generate.py line #1216 3168 3169 3170 // CODEGEN : file ../vk-layer-generate.py line #1251 3171 3172 3173 VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) 3174 { 3175 bool skipCall = false; 3176 { 3177 std::lock_guard<std::mutex> lock(global_lock); 3178 // objects to validate: ['device', 'queryPool'] 3179 // CODEGEN : file ../vk-layer-generate.py line #1099 3180 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3181 // CODEGEN : file ../vk-layer-generate.py line #1099 3182 skipCall |= validate_query_pool(device, queryPool, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, false); 3183 } 3184 if (skipCall) 3185 return; 3186 { 3187 std::lock_guard<std::mutex> lock(global_lock); 3188 destroy_query_pool(device, queryPool); 3189 } 3190 get_dispatch_table(object_tracker_device_table_map, device)->DestroyQueryPool(device, queryPool, pAllocator); 3191 } 3192 3193 // CODEGEN : file ../vk-layer-generate.py line #1216 3194 3195 3196 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) 3197 { 3198 bool skipCall = false; 3199 { 3200 std::lock_guard<std::mutex> lock(global_lock); 3201 // objects to validate: ['device', 'queryPool'] 3202 // CODEGEN : file ../vk-layer-generate.py line #1099 3203 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3204 // CODEGEN : file ../vk-layer-generate.py line #1099 3205 skipCall |= validate_query_pool(device, queryPool, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, false); 3206 } 3207 if (skipCall) 3208 return VK_ERROR_VALIDATION_FAILED_EXT; 3209 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); 3210 return result; 3211 } 3212 3213 // CODEGEN : file ../vk-layer-generate.py line #1216 3214 3215 3216 VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) 3217 { 3218 bool skipCall = false; 3219 { 3220 std::lock_guard<std::mutex> lock(global_lock); 3221 // objects to validate: ['device'] 3222 // CODEGEN : file ../vk-layer-generate.py line #1099 3223 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3224 } 3225 if (skipCall) 3226 return VK_ERROR_VALIDATION_FAILED_EXT; 3227 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer); 3228 { 3229 std::lock_guard<std::mutex> lock(global_lock); 3230 if (result == VK_SUCCESS) { 3231 create_buffer(device, *pBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT); 3232 } 3233 } 3234 return result; 3235 } 3236 3237 // CODEGEN : file ../vk-layer-generate.py line #1216 3238 3239 3240 // CODEGEN : file ../vk-layer-generate.py line #1251 3241 3242 3243 VKAPI_ATTR void VKAPI_CALL DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) 3244 { 3245 bool skipCall = false; 3246 { 3247 std::lock_guard<std::mutex> lock(global_lock); 3248 // objects to validate: ['buffer', 'device'] 3249 // CODEGEN : file ../vk-layer-generate.py line #1099 3250 skipCall |= validate_buffer(device, buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false); 3251 // CODEGEN : file ../vk-layer-generate.py line #1099 3252 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3253 } 3254 if (skipCall) 3255 return; 3256 { 3257 std::lock_guard<std::mutex> lock(global_lock); 3258 destroy_buffer(device, buffer); 3259 } 3260 get_dispatch_table(object_tracker_device_table_map, device)->DestroyBuffer(device, buffer, pAllocator); 3261 } 3262 3263 // CODEGEN : file ../vk-layer-generate.py line #1216 3264 3265 3266 VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) 3267 { 3268 bool skipCall = false; 3269 { 3270 std::lock_guard<std::mutex> lock(global_lock); 3271 // objects to validate: ['device', 'pCreateInfo'] 3272 // CODEGEN : file ../vk-layer-generate.py line #1099 3273 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3274 if (pCreateInfo) { 3275 // CODEGEN : file ../vk-layer-generate.py line #1099 3276 skipCall |= validate_buffer(device, pCreateInfo->buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false); 3277 } 3278 } 3279 if (skipCall) 3280 return VK_ERROR_VALIDATION_FAILED_EXT; 3281 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->CreateBufferView(device, pCreateInfo, pAllocator, pView); 3282 { 3283 std::lock_guard<std::mutex> lock(global_lock); 3284 if (result == VK_SUCCESS) { 3285 create_buffer_view(device, *pView, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT); 3286 } 3287 } 3288 return result; 3289 } 3290 3291 // CODEGEN : file ../vk-layer-generate.py line #1216 3292 3293 3294 // CODEGEN : file ../vk-layer-generate.py line #1251 3295 3296 3297 VKAPI_ATTR void VKAPI_CALL DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) 3298 { 3299 bool skipCall = false; 3300 { 3301 std::lock_guard<std::mutex> lock(global_lock); 3302 // objects to validate: ['bufferView', 'device'] 3303 // CODEGEN : file ../vk-layer-generate.py line #1099 3304 skipCall |= validate_buffer_view(device, bufferView, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, false); 3305 // CODEGEN : file ../vk-layer-generate.py line #1099 3306 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3307 } 3308 if (skipCall) 3309 return; 3310 { 3311 std::lock_guard<std::mutex> lock(global_lock); 3312 destroy_buffer_view(device, bufferView); 3313 } 3314 get_dispatch_table(object_tracker_device_table_map, device)->DestroyBufferView(device, bufferView, pAllocator); 3315 } 3316 3317 // CODEGEN : file ../vk-layer-generate.py line #1216 3318 3319 3320 VKAPI_ATTR VkResult VKAPI_CALL CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) 3321 { 3322 bool skipCall = false; 3323 { 3324 std::lock_guard<std::mutex> lock(global_lock); 3325 // objects to validate: ['device'] 3326 // CODEGEN : file ../vk-layer-generate.py line #1099 3327 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3328 } 3329 if (skipCall) 3330 return VK_ERROR_VALIDATION_FAILED_EXT; 3331 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->CreateImage(device, pCreateInfo, pAllocator, pImage); 3332 { 3333 std::lock_guard<std::mutex> lock(global_lock); 3334 if (result == VK_SUCCESS) { 3335 create_image(device, *pImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT); 3336 } 3337 } 3338 return result; 3339 } 3340 3341 // CODEGEN : file ../vk-layer-generate.py line #1216 3342 3343 3344 // CODEGEN : file ../vk-layer-generate.py line #1251 3345 3346 3347 VKAPI_ATTR void VKAPI_CALL DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) 3348 { 3349 bool skipCall = false; 3350 { 3351 std::lock_guard<std::mutex> lock(global_lock); 3352 // objects to validate: ['device', 'image'] 3353 // CODEGEN : file ../vk-layer-generate.py line #1099 3354 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3355 // CODEGEN : file ../vk-layer-generate.py line #1099 3356 skipCall |= validate_image(device, image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false); 3357 } 3358 if (skipCall) 3359 return; 3360 { 3361 std::lock_guard<std::mutex> lock(global_lock); 3362 destroy_image(device, image); 3363 } 3364 get_dispatch_table(object_tracker_device_table_map, device)->DestroyImage(device, image, pAllocator); 3365 } 3366 3367 // CODEGEN : file ../vk-layer-generate.py line #1216 3368 3369 3370 VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) 3371 { 3372 bool skipCall = false; 3373 { 3374 std::lock_guard<std::mutex> lock(global_lock); 3375 // objects to validate: ['device', 'image'] 3376 // CODEGEN : file ../vk-layer-generate.py line #1099 3377 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3378 // CODEGEN : file ../vk-layer-generate.py line #1099 3379 skipCall |= validate_image(device, image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false); 3380 } 3381 if (skipCall) 3382 return; 3383 get_dispatch_table(object_tracker_device_table_map, device)->GetImageSubresourceLayout(device, image, pSubresource, pLayout); 3384 } 3385 3386 // CODEGEN : file ../vk-layer-generate.py line #1216 3387 3388 3389 VKAPI_ATTR VkResult VKAPI_CALL CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) 3390 { 3391 bool skipCall = false; 3392 { 3393 std::lock_guard<std::mutex> lock(global_lock); 3394 // objects to validate: ['device', 'pCreateInfo'] 3395 // CODEGEN : file ../vk-layer-generate.py line #1099 3396 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3397 if (pCreateInfo) { 3398 // CODEGEN : file ../vk-layer-generate.py line #1099 3399 skipCall |= validate_image(device, pCreateInfo->image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false); 3400 } 3401 } 3402 if (skipCall) 3403 return VK_ERROR_VALIDATION_FAILED_EXT; 3404 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->CreateImageView(device, pCreateInfo, pAllocator, pView); 3405 { 3406 std::lock_guard<std::mutex> lock(global_lock); 3407 if (result == VK_SUCCESS) { 3408 create_image_view(device, *pView, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT); 3409 } 3410 } 3411 return result; 3412 } 3413 3414 // CODEGEN : file ../vk-layer-generate.py line #1216 3415 3416 3417 // CODEGEN : file ../vk-layer-generate.py line #1251 3418 3419 3420 VKAPI_ATTR void VKAPI_CALL DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) 3421 { 3422 bool skipCall = false; 3423 { 3424 std::lock_guard<std::mutex> lock(global_lock); 3425 // objects to validate: ['device', 'imageView'] 3426 // CODEGEN : file ../vk-layer-generate.py line #1099 3427 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3428 // CODEGEN : file ../vk-layer-generate.py line #1099 3429 skipCall |= validate_image_view(device, imageView, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, false); 3430 } 3431 if (skipCall) 3432 return; 3433 { 3434 std::lock_guard<std::mutex> lock(global_lock); 3435 destroy_image_view(device, imageView); 3436 } 3437 get_dispatch_table(object_tracker_device_table_map, device)->DestroyImageView(device, imageView, pAllocator); 3438 } 3439 3440 // CODEGEN : file ../vk-layer-generate.py line #1216 3441 3442 3443 VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) 3444 { 3445 bool skipCall = false; 3446 { 3447 std::lock_guard<std::mutex> lock(global_lock); 3448 // objects to validate: ['device'] 3449 // CODEGEN : file ../vk-layer-generate.py line #1099 3450 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3451 } 3452 if (skipCall) 3453 return VK_ERROR_VALIDATION_FAILED_EXT; 3454 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule); 3455 { 3456 std::lock_guard<std::mutex> lock(global_lock); 3457 if (result == VK_SUCCESS) { 3458 create_shader_module(device, *pShaderModule, VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT); 3459 } 3460 } 3461 return result; 3462 } 3463 3464 // CODEGEN : file ../vk-layer-generate.py line #1216 3465 3466 3467 // CODEGEN : file ../vk-layer-generate.py line #1251 3468 3469 3470 VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) 3471 { 3472 bool skipCall = false; 3473 { 3474 std::lock_guard<std::mutex> lock(global_lock); 3475 // objects to validate: ['device', 'shaderModule'] 3476 // CODEGEN : file ../vk-layer-generate.py line #1099 3477 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3478 // CODEGEN : file ../vk-layer-generate.py line #1099 3479 skipCall |= validate_shader_module(device, shaderModule, VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, false); 3480 } 3481 if (skipCall) 3482 return; 3483 { 3484 std::lock_guard<std::mutex> lock(global_lock); 3485 destroy_shader_module(device, shaderModule); 3486 } 3487 get_dispatch_table(object_tracker_device_table_map, device)->DestroyShaderModule(device, shaderModule, pAllocator); 3488 } 3489 3490 // CODEGEN : file ../vk-layer-generate.py line #1216 3491 3492 3493 VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) 3494 { 3495 bool skipCall = false; 3496 { 3497 std::lock_guard<std::mutex> lock(global_lock); 3498 // objects to validate: ['device'] 3499 // CODEGEN : file ../vk-layer-generate.py line #1099 3500 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3501 } 3502 if (skipCall) 3503 return VK_ERROR_VALIDATION_FAILED_EXT; 3504 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); 3505 { 3506 std::lock_guard<std::mutex> lock(global_lock); 3507 if (result == VK_SUCCESS) { 3508 create_pipeline_cache(device, *pPipelineCache, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT); 3509 } 3510 } 3511 return result; 3512 } 3513 3514 // CODEGEN : file ../vk-layer-generate.py line #1216 3515 3516 3517 // CODEGEN : file ../vk-layer-generate.py line #1251 3518 3519 3520 VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) 3521 { 3522 bool skipCall = false; 3523 { 3524 std::lock_guard<std::mutex> lock(global_lock); 3525 // objects to validate: ['device', 'pipelineCache'] 3526 // CODEGEN : file ../vk-layer-generate.py line #1099 3527 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3528 // CODEGEN : file ../vk-layer-generate.py line #1099 3529 skipCall |= validate_pipeline_cache(device, pipelineCache, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, false); 3530 } 3531 if (skipCall) 3532 return; 3533 { 3534 std::lock_guard<std::mutex> lock(global_lock); 3535 destroy_pipeline_cache(device, pipelineCache); 3536 } 3537 get_dispatch_table(object_tracker_device_table_map, device)->DestroyPipelineCache(device, pipelineCache, pAllocator); 3538 } 3539 3540 // CODEGEN : file ../vk-layer-generate.py line #1216 3541 3542 3543 VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) 3544 { 3545 bool skipCall = false; 3546 { 3547 std::lock_guard<std::mutex> lock(global_lock); 3548 // objects to validate: ['device', 'pipelineCache'] 3549 // CODEGEN : file ../vk-layer-generate.py line #1099 3550 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3551 // CODEGEN : file ../vk-layer-generate.py line #1099 3552 skipCall |= validate_pipeline_cache(device, pipelineCache, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, false); 3553 } 3554 if (skipCall) 3555 return VK_ERROR_VALIDATION_FAILED_EXT; 3556 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->GetPipelineCacheData(device, pipelineCache, pDataSize, pData); 3557 return result; 3558 } 3559 3560 // CODEGEN : file ../vk-layer-generate.py line #1216 3561 3562 3563 VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) 3564 { 3565 bool skipCall = false; 3566 { 3567 std::lock_guard<std::mutex> lock(global_lock); 3568 // objects to validate: ['device', 'dstCache', 'pSrcCaches[srcCacheCount]'] 3569 // CODEGEN : file ../vk-layer-generate.py line #1099 3570 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3571 // CODEGEN : file ../vk-layer-generate.py line #1099 3572 skipCall |= validate_pipeline_cache(device, dstCache, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, false); 3573 if (pSrcCaches) { 3574 for (uint32_t idx0=0; idx0<srcCacheCount; ++idx0) { 3575 // CODEGEN : file ../vk-layer-generate.py line #1091 3576 skipCall |= validate_pipeline_cache(device, pSrcCaches[idx0], VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, false); 3577 } 3578 } 3579 } 3580 if (skipCall) 3581 return VK_ERROR_VALIDATION_FAILED_EXT; 3582 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); 3583 return result; 3584 } 3585 3586 // CODEGEN : file ../vk-layer-generate.py line #1216 3587 VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) 3588 { 3589 return explicit_CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); 3590 } 3591 3592 // CODEGEN : file ../vk-layer-generate.py line #1216 3593 VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) 3594 { 3595 return explicit_CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); 3596 } 3597 3598 // CODEGEN : file ../vk-layer-generate.py line #1216 3599 3600 3601 // CODEGEN : file ../vk-layer-generate.py line #1251 3602 3603 3604 VKAPI_ATTR void VKAPI_CALL DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) 3605 { 3606 bool skipCall = false; 3607 { 3608 std::lock_guard<std::mutex> lock(global_lock); 3609 // objects to validate: ['device', 'pipeline'] 3610 // CODEGEN : file ../vk-layer-generate.py line #1099 3611 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3612 // CODEGEN : file ../vk-layer-generate.py line #1099 3613 skipCall |= validate_pipeline(device, pipeline, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, false); 3614 } 3615 if (skipCall) 3616 return; 3617 { 3618 std::lock_guard<std::mutex> lock(global_lock); 3619 destroy_pipeline(device, pipeline); 3620 } 3621 get_dispatch_table(object_tracker_device_table_map, device)->DestroyPipeline(device, pipeline, pAllocator); 3622 } 3623 3624 // CODEGEN : file ../vk-layer-generate.py line #1216 3625 3626 3627 VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) 3628 { 3629 bool skipCall = false; 3630 { 3631 std::lock_guard<std::mutex> lock(global_lock); 3632 // objects to validate: ['device', 'pCreateInfo'] 3633 // CODEGEN : file ../vk-layer-generate.py line #1099 3634 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3635 if (pCreateInfo) { 3636 if (pCreateInfo->pSetLayouts) { 3637 for (uint32_t idx0=0; idx0<pCreateInfo->setLayoutCount; ++idx0) { 3638 // CODEGEN : file ../vk-layer-generate.py line #1091 3639 skipCall |= validate_descriptor_set_layout(device, pCreateInfo->pSetLayouts[idx0], VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, false); 3640 } 3641 } 3642 } 3643 } 3644 if (skipCall) 3645 return VK_ERROR_VALIDATION_FAILED_EXT; 3646 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); 3647 { 3648 std::lock_guard<std::mutex> lock(global_lock); 3649 if (result == VK_SUCCESS) { 3650 create_pipeline_layout(device, *pPipelineLayout, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT); 3651 } 3652 } 3653 return result; 3654 } 3655 3656 // CODEGEN : file ../vk-layer-generate.py line #1216 3657 3658 3659 // CODEGEN : file ../vk-layer-generate.py line #1251 3660 3661 3662 VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) 3663 { 3664 bool skipCall = false; 3665 { 3666 std::lock_guard<std::mutex> lock(global_lock); 3667 // objects to validate: ['device', 'pipelineLayout'] 3668 // CODEGEN : file ../vk-layer-generate.py line #1099 3669 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3670 // CODEGEN : file ../vk-layer-generate.py line #1099 3671 skipCall |= validate_pipeline_layout(device, pipelineLayout, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, false); 3672 } 3673 if (skipCall) 3674 return; 3675 { 3676 std::lock_guard<std::mutex> lock(global_lock); 3677 destroy_pipeline_layout(device, pipelineLayout); 3678 } 3679 get_dispatch_table(object_tracker_device_table_map, device)->DestroyPipelineLayout(device, pipelineLayout, pAllocator); 3680 } 3681 3682 // CODEGEN : file ../vk-layer-generate.py line #1216 3683 3684 3685 VKAPI_ATTR VkResult VKAPI_CALL CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) 3686 { 3687 bool skipCall = false; 3688 { 3689 std::lock_guard<std::mutex> lock(global_lock); 3690 // objects to validate: ['device'] 3691 // CODEGEN : file ../vk-layer-generate.py line #1099 3692 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3693 } 3694 if (skipCall) 3695 return VK_ERROR_VALIDATION_FAILED_EXT; 3696 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->CreateSampler(device, pCreateInfo, pAllocator, pSampler); 3697 { 3698 std::lock_guard<std::mutex> lock(global_lock); 3699 if (result == VK_SUCCESS) { 3700 create_sampler(device, *pSampler, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT); 3701 } 3702 } 3703 return result; 3704 } 3705 3706 // CODEGEN : file ../vk-layer-generate.py line #1216 3707 3708 3709 // CODEGEN : file ../vk-layer-generate.py line #1251 3710 3711 3712 VKAPI_ATTR void VKAPI_CALL DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) 3713 { 3714 bool skipCall = false; 3715 { 3716 std::lock_guard<std::mutex> lock(global_lock); 3717 // objects to validate: ['device', 'sampler'] 3718 // CODEGEN : file ../vk-layer-generate.py line #1099 3719 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3720 // CODEGEN : file ../vk-layer-generate.py line #1099 3721 skipCall |= validate_sampler(device, sampler, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, false); 3722 } 3723 if (skipCall) 3724 return; 3725 { 3726 std::lock_guard<std::mutex> lock(global_lock); 3727 destroy_sampler(device, sampler); 3728 } 3729 get_dispatch_table(object_tracker_device_table_map, device)->DestroySampler(device, sampler, pAllocator); 3730 } 3731 3732 // CODEGEN : file ../vk-layer-generate.py line #1216 3733 3734 3735 VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) 3736 { 3737 bool skipCall = false; 3738 { 3739 std::lock_guard<std::mutex> lock(global_lock); 3740 // objects to validate: ['device', 'pCreateInfo'] 3741 // CODEGEN : file ../vk-layer-generate.py line #1099 3742 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3743 if (pCreateInfo) { 3744 if (pCreateInfo->pBindings) { 3745 // CODEGEN : file ../vk-layer-generate.py line #1055 3746 for (uint32_t idx0=0; idx0<pCreateInfo->bindingCount; ++idx0) { 3747 if (pCreateInfo->pBindings[idx0].pImmutableSamplers) { 3748 for (uint32_t idx1=0; idx1<pCreateInfo->pBindings[idx0].descriptorCount; ++idx1) { 3749 // CODEGEN : file ../vk-layer-generate.py line #1091 3750 skipCall |= validate_sampler(device, pCreateInfo->pBindings[idx0].pImmutableSamplers[idx1], VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, false); 3751 } 3752 } 3753 } 3754 } 3755 } 3756 } 3757 if (skipCall) 3758 return VK_ERROR_VALIDATION_FAILED_EXT; 3759 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout); 3760 { 3761 std::lock_guard<std::mutex> lock(global_lock); 3762 if (result == VK_SUCCESS) { 3763 create_descriptor_set_layout(device, *pSetLayout, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT); 3764 } 3765 } 3766 return result; 3767 } 3768 3769 // CODEGEN : file ../vk-layer-generate.py line #1216 3770 3771 3772 // CODEGEN : file ../vk-layer-generate.py line #1251 3773 3774 3775 VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) 3776 { 3777 bool skipCall = false; 3778 { 3779 std::lock_guard<std::mutex> lock(global_lock); 3780 // objects to validate: ['descriptorSetLayout', 'device'] 3781 // CODEGEN : file ../vk-layer-generate.py line #1099 3782 skipCall |= validate_descriptor_set_layout(device, descriptorSetLayout, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, false); 3783 // CODEGEN : file ../vk-layer-generate.py line #1099 3784 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3785 } 3786 if (skipCall) 3787 return; 3788 { 3789 std::lock_guard<std::mutex> lock(global_lock); 3790 destroy_descriptor_set_layout(device, descriptorSetLayout); 3791 } 3792 get_dispatch_table(object_tracker_device_table_map, device)->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); 3793 } 3794 3795 // CODEGEN : file ../vk-layer-generate.py line #1216 3796 3797 3798 VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) 3799 { 3800 bool skipCall = false; 3801 { 3802 std::lock_guard<std::mutex> lock(global_lock); 3803 // objects to validate: ['device'] 3804 // CODEGEN : file ../vk-layer-generate.py line #1099 3805 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3806 } 3807 if (skipCall) 3808 return VK_ERROR_VALIDATION_FAILED_EXT; 3809 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); 3810 { 3811 std::lock_guard<std::mutex> lock(global_lock); 3812 if (result == VK_SUCCESS) { 3813 create_descriptor_pool(device, *pDescriptorPool, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT); 3814 } 3815 } 3816 return result; 3817 } 3818 3819 // CODEGEN : file ../vk-layer-generate.py line #1216 3820 VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) 3821 { 3822 return explicit_DestroyDescriptorPool(device, descriptorPool, pAllocator); 3823 } 3824 3825 // CODEGEN : file ../vk-layer-generate.py line #1216 3826 3827 3828 VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) 3829 { 3830 bool skipCall = false; 3831 { 3832 std::lock_guard<std::mutex> lock(global_lock); 3833 // objects to validate: ['descriptorPool', 'device'] 3834 // CODEGEN : file ../vk-layer-generate.py line #1099 3835 skipCall |= validate_descriptor_pool(device, descriptorPool, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, false); 3836 // CODEGEN : file ../vk-layer-generate.py line #1099 3837 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3838 } 3839 if (skipCall) 3840 return VK_ERROR_VALIDATION_FAILED_EXT; 3841 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->ResetDescriptorPool(device, descriptorPool, flags); 3842 return result; 3843 } 3844 3845 // CODEGEN : file ../vk-layer-generate.py line #1216 3846 VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) 3847 { 3848 return explicit_AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); 3849 } 3850 3851 // CODEGEN : file ../vk-layer-generate.py line #1216 3852 VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) 3853 { 3854 return explicit_FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); 3855 } 3856 3857 // CODEGEN : file ../vk-layer-generate.py line #1216 3858 3859 3860 VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) 3861 { 3862 bool skipCall = false; 3863 { 3864 std::lock_guard<std::mutex> lock(global_lock); 3865 // objects to validate: ['device', 'pDescriptorCopies[descriptorCopyCount]', 'pDescriptorWrites[descriptorWriteCount]'] 3866 // CODEGEN : file ../vk-layer-generate.py line #1099 3867 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3868 if (pDescriptorCopies) { 3869 // CODEGEN : file ../vk-layer-generate.py line #1055 3870 for (uint32_t idx0=0; idx0<descriptorCopyCount; ++idx0) { 3871 if (pDescriptorCopies[idx0].dstSet) { 3872 // CODEGEN : file ../vk-layer-generate.py line #1091 3873 skipCall |= validate_descriptor_set(device, pDescriptorCopies[idx0].dstSet, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, false); 3874 } 3875 if (pDescriptorCopies[idx0].srcSet) { 3876 // CODEGEN : file ../vk-layer-generate.py line #1091 3877 skipCall |= validate_descriptor_set(device, pDescriptorCopies[idx0].srcSet, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, false); 3878 } 3879 } 3880 } 3881 if (pDescriptorWrites) { 3882 // CODEGEN : file ../vk-layer-generate.py line #1055 3883 for (uint32_t idx1=0; idx1<descriptorWriteCount; ++idx1) { 3884 if (pDescriptorWrites[idx1].dstSet) { 3885 // CODEGEN : file ../vk-layer-generate.py line #1091 3886 skipCall |= validate_descriptor_set(device, pDescriptorWrites[idx1].dstSet, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, false); 3887 } 3888 if ((pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) || 3889 (pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) || 3890 (pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC) || 3891 (pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC) ) { 3892 // CODEGEN : file ../vk-layer-generate.py line #1055 3893 for (uint32_t idx2=0; idx2<pDescriptorWrites[idx1].descriptorCount; ++idx2) { 3894 if (pDescriptorWrites[idx1].pBufferInfo[idx2].buffer) { 3895 // CODEGEN : file ../vk-layer-generate.py line #1091 3896 skipCall |= validate_buffer(device, pDescriptorWrites[idx1].pBufferInfo[idx2].buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false); 3897 } 3898 } 3899 } 3900 if ((pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER) || 3901 (pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) || 3902 (pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT) || 3903 (pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE) || 3904 (pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) ) { 3905 // CODEGEN : file ../vk-layer-generate.py line #1055 3906 for (uint32_t idx3=0; idx3<pDescriptorWrites[idx1].descriptorCount; ++idx3) { 3907 if (pDescriptorWrites[idx1].pImageInfo[idx3].imageView) { 3908 // CODEGEN : file ../vk-layer-generate.py line #1091 3909 skipCall |= validate_image_view(device, pDescriptorWrites[idx1].pImageInfo[idx3].imageView, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, false); 3910 } 3911 if (pDescriptorWrites[idx1].pImageInfo[idx3].sampler) { 3912 // CODEGEN : file ../vk-layer-generate.py line #1091 3913 skipCall |= validate_sampler(device, pDescriptorWrites[idx1].pImageInfo[idx3].sampler, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, false); 3914 } 3915 } 3916 } 3917 if ((pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) || 3918 (pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER) ) { 3919 for (uint32_t idx4=0; idx4<pDescriptorWrites[idx1].descriptorCount; ++idx4) { 3920 // CODEGEN : file ../vk-layer-generate.py line #1091 3921 skipCall |= validate_buffer_view(device, pDescriptorWrites[idx1].pTexelBufferView[idx4], VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, true); 3922 } 3923 } 3924 } 3925 } 3926 } 3927 if (skipCall) 3928 return; 3929 get_dispatch_table(object_tracker_device_table_map, device)->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); 3930 } 3931 3932 // CODEGEN : file ../vk-layer-generate.py line #1216 3933 3934 3935 VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) 3936 { 3937 bool skipCall = false; 3938 { 3939 std::lock_guard<std::mutex> lock(global_lock); 3940 // objects to validate: ['device', 'pCreateInfo'] 3941 // CODEGEN : file ../vk-layer-generate.py line #1099 3942 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3943 if (pCreateInfo) { 3944 if (pCreateInfo->pAttachments) { 3945 for (uint32_t idx0=0; idx0<pCreateInfo->attachmentCount; ++idx0) { 3946 // CODEGEN : file ../vk-layer-generate.py line #1091 3947 skipCall |= validate_image_view(device, pCreateInfo->pAttachments[idx0], VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, false); 3948 } 3949 } 3950 if (pCreateInfo->renderPass) { 3951 // CODEGEN : file ../vk-layer-generate.py line #1091 3952 skipCall |= validate_render_pass(device, pCreateInfo->renderPass, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, false); 3953 } 3954 } 3955 } 3956 if (skipCall) 3957 return VK_ERROR_VALIDATION_FAILED_EXT; 3958 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); 3959 { 3960 std::lock_guard<std::mutex> lock(global_lock); 3961 if (result == VK_SUCCESS) { 3962 create_framebuffer(device, *pFramebuffer, VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT); 3963 } 3964 } 3965 return result; 3966 } 3967 3968 // CODEGEN : file ../vk-layer-generate.py line #1216 3969 3970 3971 // CODEGEN : file ../vk-layer-generate.py line #1251 3972 3973 3974 VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) 3975 { 3976 bool skipCall = false; 3977 { 3978 std::lock_guard<std::mutex> lock(global_lock); 3979 // objects to validate: ['device', 'framebuffer'] 3980 // CODEGEN : file ../vk-layer-generate.py line #1099 3981 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 3982 // CODEGEN : file ../vk-layer-generate.py line #1099 3983 skipCall |= validate_framebuffer(device, framebuffer, VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, false); 3984 } 3985 if (skipCall) 3986 return; 3987 { 3988 std::lock_guard<std::mutex> lock(global_lock); 3989 destroy_framebuffer(device, framebuffer); 3990 } 3991 get_dispatch_table(object_tracker_device_table_map, device)->DestroyFramebuffer(device, framebuffer, pAllocator); 3992 } 3993 3994 // CODEGEN : file ../vk-layer-generate.py line #1216 3995 3996 3997 VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) 3998 { 3999 bool skipCall = false; 4000 { 4001 std::lock_guard<std::mutex> lock(global_lock); 4002 // objects to validate: ['device'] 4003 // CODEGEN : file ../vk-layer-generate.py line #1099 4004 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 4005 } 4006 if (skipCall) 4007 return VK_ERROR_VALIDATION_FAILED_EXT; 4008 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); 4009 { 4010 std::lock_guard<std::mutex> lock(global_lock); 4011 if (result == VK_SUCCESS) { 4012 create_render_pass(device, *pRenderPass, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT); 4013 } 4014 } 4015 return result; 4016 } 4017 4018 // CODEGEN : file ../vk-layer-generate.py line #1216 4019 4020 4021 // CODEGEN : file ../vk-layer-generate.py line #1251 4022 4023 4024 VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) 4025 { 4026 bool skipCall = false; 4027 { 4028 std::lock_guard<std::mutex> lock(global_lock); 4029 // objects to validate: ['device', 'renderPass'] 4030 // CODEGEN : file ../vk-layer-generate.py line #1099 4031 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 4032 // CODEGEN : file ../vk-layer-generate.py line #1099 4033 skipCall |= validate_render_pass(device, renderPass, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, false); 4034 } 4035 if (skipCall) 4036 return; 4037 { 4038 std::lock_guard<std::mutex> lock(global_lock); 4039 destroy_render_pass(device, renderPass); 4040 } 4041 get_dispatch_table(object_tracker_device_table_map, device)->DestroyRenderPass(device, renderPass, pAllocator); 4042 } 4043 4044 // CODEGEN : file ../vk-layer-generate.py line #1216 4045 4046 4047 VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) 4048 { 4049 bool skipCall = false; 4050 { 4051 std::lock_guard<std::mutex> lock(global_lock); 4052 // objects to validate: ['device', 'renderPass'] 4053 // CODEGEN : file ../vk-layer-generate.py line #1099 4054 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 4055 // CODEGEN : file ../vk-layer-generate.py line #1099 4056 skipCall |= validate_render_pass(device, renderPass, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, false); 4057 } 4058 if (skipCall) 4059 return; 4060 get_dispatch_table(object_tracker_device_table_map, device)->GetRenderAreaGranularity(device, renderPass, pGranularity); 4061 } 4062 4063 // CODEGEN : file ../vk-layer-generate.py line #1216 4064 4065 4066 VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) 4067 { 4068 bool skipCall = false; 4069 { 4070 std::lock_guard<std::mutex> lock(global_lock); 4071 // objects to validate: ['device'] 4072 // CODEGEN : file ../vk-layer-generate.py line #1099 4073 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 4074 } 4075 if (skipCall) 4076 return VK_ERROR_VALIDATION_FAILED_EXT; 4077 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); 4078 { 4079 std::lock_guard<std::mutex> lock(global_lock); 4080 if (result == VK_SUCCESS) { 4081 create_command_pool(device, *pCommandPool, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT); 4082 } 4083 } 4084 return result; 4085 } 4086 4087 // CODEGEN : file ../vk-layer-generate.py line #1216 4088 VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) 4089 { 4090 return explicit_DestroyCommandPool(device, commandPool, pAllocator); 4091 } 4092 4093 // CODEGEN : file ../vk-layer-generate.py line #1216 4094 4095 4096 VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) 4097 { 4098 bool skipCall = false; 4099 { 4100 std::lock_guard<std::mutex> lock(global_lock); 4101 // objects to validate: ['commandPool', 'device'] 4102 // CODEGEN : file ../vk-layer-generate.py line #1099 4103 skipCall |= validate_command_pool(device, commandPool, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, false); 4104 // CODEGEN : file ../vk-layer-generate.py line #1099 4105 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 4106 } 4107 if (skipCall) 4108 return VK_ERROR_VALIDATION_FAILED_EXT; 4109 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->ResetCommandPool(device, commandPool, flags); 4110 return result; 4111 } 4112 4113 // CODEGEN : file ../vk-layer-generate.py line #1216 4114 VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) 4115 { 4116 return explicit_AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); 4117 } 4118 4119 // CODEGEN : file ../vk-layer-generate.py line #1216 4120 VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) 4121 { 4122 return explicit_FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); 4123 } 4124 4125 // CODEGEN : file ../vk-layer-generate.py line #1216 4126 4127 4128 VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) 4129 { 4130 bool skipCall = false; 4131 { 4132 std::lock_guard<std::mutex> lock(global_lock); 4133 // objects to validate: ['commandBuffer', 'pBeginInfo'] 4134 // CODEGEN : file ../vk-layer-generate.py line #1099 4135 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4136 if (pBeginInfo) { 4137 OBJTRACK_NODE* pNode = VkCommandBufferMap[(uint64_t)commandBuffer]; 4138 if ((pBeginInfo->pInheritanceInfo) && (pNode->status & OBJSTATUS_COMMAND_BUFFER_SECONDARY)) { 4139 // CODEGEN : file ../vk-layer-generate.py line #1099 4140 skipCall |= validate_framebuffer(commandBuffer, pBeginInfo->pInheritanceInfo->framebuffer, VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, true); 4141 // CODEGEN : file ../vk-layer-generate.py line #1099 4142 skipCall |= validate_render_pass(commandBuffer, pBeginInfo->pInheritanceInfo->renderPass, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, true); 4143 } 4144 } 4145 } 4146 if (skipCall) 4147 return VK_ERROR_VALIDATION_FAILED_EXT; 4148 VkResult result = get_dispatch_table(object_tracker_device_table_map, commandBuffer)->BeginCommandBuffer(commandBuffer, pBeginInfo); 4149 return result; 4150 } 4151 4152 // CODEGEN : file ../vk-layer-generate.py line #1216 4153 4154 4155 VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(VkCommandBuffer commandBuffer) 4156 { 4157 bool skipCall = false; 4158 { 4159 std::lock_guard<std::mutex> lock(global_lock); 4160 // objects to validate: ['commandBuffer'] 4161 // CODEGEN : file ../vk-layer-generate.py line #1099 4162 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4163 } 4164 if (skipCall) 4165 return VK_ERROR_VALIDATION_FAILED_EXT; 4166 VkResult result = get_dispatch_table(object_tracker_device_table_map, commandBuffer)->EndCommandBuffer(commandBuffer); 4167 return result; 4168 } 4169 4170 // CODEGEN : file ../vk-layer-generate.py line #1216 4171 4172 4173 VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) 4174 { 4175 bool skipCall = false; 4176 { 4177 std::lock_guard<std::mutex> lock(global_lock); 4178 // objects to validate: ['commandBuffer'] 4179 // CODEGEN : file ../vk-layer-generate.py line #1099 4180 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4181 } 4182 if (skipCall) 4183 return VK_ERROR_VALIDATION_FAILED_EXT; 4184 VkResult result = get_dispatch_table(object_tracker_device_table_map, commandBuffer)->ResetCommandBuffer(commandBuffer, flags); 4185 return result; 4186 } 4187 4188 // CODEGEN : file ../vk-layer-generate.py line #1216 4189 4190 4191 VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) 4192 { 4193 bool skipCall = false; 4194 { 4195 std::lock_guard<std::mutex> lock(global_lock); 4196 // objects to validate: ['commandBuffer', 'pipeline'] 4197 // CODEGEN : file ../vk-layer-generate.py line #1099 4198 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4199 // CODEGEN : file ../vk-layer-generate.py line #1099 4200 skipCall |= validate_pipeline(commandBuffer, pipeline, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, false); 4201 } 4202 if (skipCall) 4203 return; 4204 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); 4205 } 4206 4207 // CODEGEN : file ../vk-layer-generate.py line #1216 4208 4209 4210 VKAPI_ATTR void VKAPI_CALL CmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) 4211 { 4212 bool skipCall = false; 4213 { 4214 std::lock_guard<std::mutex> lock(global_lock); 4215 // objects to validate: ['commandBuffer'] 4216 // CODEGEN : file ../vk-layer-generate.py line #1099 4217 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4218 } 4219 if (skipCall) 4220 return; 4221 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); 4222 } 4223 4224 // CODEGEN : file ../vk-layer-generate.py line #1216 4225 4226 4227 VKAPI_ATTR void VKAPI_CALL CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) 4228 { 4229 bool skipCall = false; 4230 { 4231 std::lock_guard<std::mutex> lock(global_lock); 4232 // objects to validate: ['commandBuffer'] 4233 // CODEGEN : file ../vk-layer-generate.py line #1099 4234 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4235 } 4236 if (skipCall) 4237 return; 4238 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); 4239 } 4240 4241 // CODEGEN : file ../vk-layer-generate.py line #1216 4242 4243 4244 VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) 4245 { 4246 bool skipCall = false; 4247 { 4248 std::lock_guard<std::mutex> lock(global_lock); 4249 // objects to validate: ['commandBuffer'] 4250 // CODEGEN : file ../vk-layer-generate.py line #1099 4251 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4252 } 4253 if (skipCall) 4254 return; 4255 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdSetLineWidth(commandBuffer, lineWidth); 4256 } 4257 4258 // CODEGEN : file ../vk-layer-generate.py line #1216 4259 4260 4261 VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) 4262 { 4263 bool skipCall = false; 4264 { 4265 std::lock_guard<std::mutex> lock(global_lock); 4266 // objects to validate: ['commandBuffer'] 4267 // CODEGEN : file ../vk-layer-generate.py line #1099 4268 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4269 } 4270 if (skipCall) 4271 return; 4272 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); 4273 } 4274 4275 // CODEGEN : file ../vk-layer-generate.py line #1216 4276 4277 4278 VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) 4279 { 4280 bool skipCall = false; 4281 { 4282 std::lock_guard<std::mutex> lock(global_lock); 4283 // objects to validate: ['commandBuffer'] 4284 // CODEGEN : file ../vk-layer-generate.py line #1099 4285 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4286 } 4287 if (skipCall) 4288 return; 4289 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdSetBlendConstants(commandBuffer, blendConstants); 4290 } 4291 4292 // CODEGEN : file ../vk-layer-generate.py line #1216 4293 4294 4295 VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) 4296 { 4297 bool skipCall = false; 4298 { 4299 std::lock_guard<std::mutex> lock(global_lock); 4300 // objects to validate: ['commandBuffer'] 4301 // CODEGEN : file ../vk-layer-generate.py line #1099 4302 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4303 } 4304 if (skipCall) 4305 return; 4306 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); 4307 } 4308 4309 // CODEGEN : file ../vk-layer-generate.py line #1216 4310 4311 4312 VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) 4313 { 4314 bool skipCall = false; 4315 { 4316 std::lock_guard<std::mutex> lock(global_lock); 4317 // objects to validate: ['commandBuffer'] 4318 // CODEGEN : file ../vk-layer-generate.py line #1099 4319 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4320 } 4321 if (skipCall) 4322 return; 4323 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); 4324 } 4325 4326 // CODEGEN : file ../vk-layer-generate.py line #1216 4327 4328 4329 VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) 4330 { 4331 bool skipCall = false; 4332 { 4333 std::lock_guard<std::mutex> lock(global_lock); 4334 // objects to validate: ['commandBuffer'] 4335 // CODEGEN : file ../vk-layer-generate.py line #1099 4336 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4337 } 4338 if (skipCall) 4339 return; 4340 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); 4341 } 4342 4343 // CODEGEN : file ../vk-layer-generate.py line #1216 4344 4345 4346 VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) 4347 { 4348 bool skipCall = false; 4349 { 4350 std::lock_guard<std::mutex> lock(global_lock); 4351 // objects to validate: ['commandBuffer'] 4352 // CODEGEN : file ../vk-layer-generate.py line #1099 4353 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4354 } 4355 if (skipCall) 4356 return; 4357 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdSetStencilReference(commandBuffer, faceMask, reference); 4358 } 4359 4360 // CODEGEN : file ../vk-layer-generate.py line #1216 4361 4362 4363 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) 4364 { 4365 bool skipCall = false; 4366 { 4367 std::lock_guard<std::mutex> lock(global_lock); 4368 // objects to validate: ['commandBuffer', 'layout', 'pDescriptorSets[descriptorSetCount]'] 4369 // CODEGEN : file ../vk-layer-generate.py line #1099 4370 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4371 // CODEGEN : file ../vk-layer-generate.py line #1099 4372 skipCall |= validate_pipeline_layout(commandBuffer, layout, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, false); 4373 if (pDescriptorSets) { 4374 for (uint32_t idx0=0; idx0<descriptorSetCount; ++idx0) { 4375 // CODEGEN : file ../vk-layer-generate.py line #1091 4376 skipCall |= validate_descriptor_set(commandBuffer, pDescriptorSets[idx0], VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, false); 4377 } 4378 } 4379 } 4380 if (skipCall) 4381 return; 4382 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); 4383 } 4384 4385 // CODEGEN : file ../vk-layer-generate.py line #1216 4386 4387 4388 VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) 4389 { 4390 bool skipCall = false; 4391 { 4392 std::lock_guard<std::mutex> lock(global_lock); 4393 // objects to validate: ['buffer', 'commandBuffer'] 4394 // CODEGEN : file ../vk-layer-generate.py line #1099 4395 skipCall |= validate_buffer(commandBuffer, buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false); 4396 // CODEGEN : file ../vk-layer-generate.py line #1099 4397 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4398 } 4399 if (skipCall) 4400 return; 4401 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); 4402 } 4403 4404 // CODEGEN : file ../vk-layer-generate.py line #1216 4405 4406 4407 VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) 4408 { 4409 bool skipCall = false; 4410 { 4411 std::lock_guard<std::mutex> lock(global_lock); 4412 // objects to validate: ['commandBuffer', 'pBuffers[bindingCount]'] 4413 // CODEGEN : file ../vk-layer-generate.py line #1099 4414 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4415 if (pBuffers) { 4416 for (uint32_t idx0=0; idx0<bindingCount; ++idx0) { 4417 // CODEGEN : file ../vk-layer-generate.py line #1091 4418 skipCall |= validate_buffer(commandBuffer, pBuffers[idx0], VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false); 4419 } 4420 } 4421 } 4422 if (skipCall) 4423 return; 4424 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); 4425 } 4426 4427 // CODEGEN : file ../vk-layer-generate.py line #1216 4428 4429 4430 VKAPI_ATTR void VKAPI_CALL CmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) 4431 { 4432 bool skipCall = false; 4433 { 4434 std::lock_guard<std::mutex> lock(global_lock); 4435 // objects to validate: ['commandBuffer'] 4436 // CODEGEN : file ../vk-layer-generate.py line #1099 4437 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4438 } 4439 if (skipCall) 4440 return; 4441 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); 4442 } 4443 4444 // CODEGEN : file ../vk-layer-generate.py line #1216 4445 4446 4447 VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) 4448 { 4449 bool skipCall = false; 4450 { 4451 std::lock_guard<std::mutex> lock(global_lock); 4452 // objects to validate: ['commandBuffer'] 4453 // CODEGEN : file ../vk-layer-generate.py line #1099 4454 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4455 } 4456 if (skipCall) 4457 return; 4458 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); 4459 } 4460 4461 // CODEGEN : file ../vk-layer-generate.py line #1216 4462 4463 4464 VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) 4465 { 4466 bool skipCall = false; 4467 { 4468 std::lock_guard<std::mutex> lock(global_lock); 4469 // objects to validate: ['buffer', 'commandBuffer'] 4470 // CODEGEN : file ../vk-layer-generate.py line #1099 4471 skipCall |= validate_buffer(commandBuffer, buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false); 4472 // CODEGEN : file ../vk-layer-generate.py line #1099 4473 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4474 } 4475 if (skipCall) 4476 return; 4477 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); 4478 } 4479 4480 // CODEGEN : file ../vk-layer-generate.py line #1216 4481 4482 4483 VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) 4484 { 4485 bool skipCall = false; 4486 { 4487 std::lock_guard<std::mutex> lock(global_lock); 4488 // objects to validate: ['buffer', 'commandBuffer'] 4489 // CODEGEN : file ../vk-layer-generate.py line #1099 4490 skipCall |= validate_buffer(commandBuffer, buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false); 4491 // CODEGEN : file ../vk-layer-generate.py line #1099 4492 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4493 } 4494 if (skipCall) 4495 return; 4496 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); 4497 } 4498 4499 // CODEGEN : file ../vk-layer-generate.py line #1216 4500 4501 4502 VKAPI_ATTR void VKAPI_CALL CmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) 4503 { 4504 bool skipCall = false; 4505 { 4506 std::lock_guard<std::mutex> lock(global_lock); 4507 // objects to validate: ['commandBuffer'] 4508 // CODEGEN : file ../vk-layer-generate.py line #1099 4509 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4510 } 4511 if (skipCall) 4512 return; 4513 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdDispatch(commandBuffer, x, y, z); 4514 } 4515 4516 // CODEGEN : file ../vk-layer-generate.py line #1216 4517 4518 4519 VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) 4520 { 4521 bool skipCall = false; 4522 { 4523 std::lock_guard<std::mutex> lock(global_lock); 4524 // objects to validate: ['buffer', 'commandBuffer'] 4525 // CODEGEN : file ../vk-layer-generate.py line #1099 4526 skipCall |= validate_buffer(commandBuffer, buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false); 4527 // CODEGEN : file ../vk-layer-generate.py line #1099 4528 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4529 } 4530 if (skipCall) 4531 return; 4532 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdDispatchIndirect(commandBuffer, buffer, offset); 4533 } 4534 4535 // CODEGEN : file ../vk-layer-generate.py line #1216 4536 4537 4538 VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) 4539 { 4540 bool skipCall = false; 4541 { 4542 std::lock_guard<std::mutex> lock(global_lock); 4543 // objects to validate: ['commandBuffer', 'dstBuffer', 'srcBuffer'] 4544 // CODEGEN : file ../vk-layer-generate.py line #1099 4545 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4546 // CODEGEN : file ../vk-layer-generate.py line #1099 4547 skipCall |= validate_buffer(commandBuffer, dstBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false); 4548 // CODEGEN : file ../vk-layer-generate.py line #1099 4549 skipCall |= validate_buffer(commandBuffer, srcBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false); 4550 } 4551 if (skipCall) 4552 return; 4553 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); 4554 } 4555 4556 // CODEGEN : file ../vk-layer-generate.py line #1216 4557 4558 4559 VKAPI_ATTR void VKAPI_CALL CmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) 4560 { 4561 bool skipCall = false; 4562 { 4563 std::lock_guard<std::mutex> lock(global_lock); 4564 // objects to validate: ['commandBuffer', 'dstImage', 'srcImage'] 4565 // CODEGEN : file ../vk-layer-generate.py line #1099 4566 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4567 // CODEGEN : file ../vk-layer-generate.py line #1099 4568 skipCall |= validate_image(commandBuffer, dstImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false); 4569 // CODEGEN : file ../vk-layer-generate.py line #1099 4570 skipCall |= validate_image(commandBuffer, srcImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false); 4571 } 4572 if (skipCall) 4573 return; 4574 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); 4575 } 4576 4577 // CODEGEN : file ../vk-layer-generate.py line #1216 4578 4579 4580 VKAPI_ATTR void VKAPI_CALL CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) 4581 { 4582 bool skipCall = false; 4583 { 4584 std::lock_guard<std::mutex> lock(global_lock); 4585 // objects to validate: ['commandBuffer', 'dstImage', 'srcImage'] 4586 // CODEGEN : file ../vk-layer-generate.py line #1099 4587 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4588 // CODEGEN : file ../vk-layer-generate.py line #1099 4589 skipCall |= validate_image(commandBuffer, dstImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false); 4590 // CODEGEN : file ../vk-layer-generate.py line #1099 4591 skipCall |= validate_image(commandBuffer, srcImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false); 4592 } 4593 if (skipCall) 4594 return; 4595 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); 4596 } 4597 4598 // CODEGEN : file ../vk-layer-generate.py line #1216 4599 4600 4601 VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) 4602 { 4603 bool skipCall = false; 4604 { 4605 std::lock_guard<std::mutex> lock(global_lock); 4606 // objects to validate: ['commandBuffer', 'dstImage', 'srcBuffer'] 4607 // CODEGEN : file ../vk-layer-generate.py line #1099 4608 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4609 // CODEGEN : file ../vk-layer-generate.py line #1099 4610 skipCall |= validate_image(commandBuffer, dstImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false); 4611 // CODEGEN : file ../vk-layer-generate.py line #1099 4612 skipCall |= validate_buffer(commandBuffer, srcBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false); 4613 } 4614 if (skipCall) 4615 return; 4616 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); 4617 } 4618 4619 // CODEGEN : file ../vk-layer-generate.py line #1216 4620 4621 4622 VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) 4623 { 4624 bool skipCall = false; 4625 { 4626 std::lock_guard<std::mutex> lock(global_lock); 4627 // objects to validate: ['commandBuffer', 'dstBuffer', 'srcImage'] 4628 // CODEGEN : file ../vk-layer-generate.py line #1099 4629 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4630 // CODEGEN : file ../vk-layer-generate.py line #1099 4631 skipCall |= validate_buffer(commandBuffer, dstBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false); 4632 // CODEGEN : file ../vk-layer-generate.py line #1099 4633 skipCall |= validate_image(commandBuffer, srcImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false); 4634 } 4635 if (skipCall) 4636 return; 4637 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); 4638 } 4639 4640 // CODEGEN : file ../vk-layer-generate.py line #1216 4641 4642 4643 VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData) 4644 { 4645 bool skipCall = false; 4646 { 4647 std::lock_guard<std::mutex> lock(global_lock); 4648 // objects to validate: ['commandBuffer', 'dstBuffer'] 4649 // CODEGEN : file ../vk-layer-generate.py line #1099 4650 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4651 // CODEGEN : file ../vk-layer-generate.py line #1099 4652 skipCall |= validate_buffer(commandBuffer, dstBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false); 4653 } 4654 if (skipCall) 4655 return; 4656 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); 4657 } 4658 4659 // CODEGEN : file ../vk-layer-generate.py line #1216 4660 4661 4662 VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) 4663 { 4664 bool skipCall = false; 4665 { 4666 std::lock_guard<std::mutex> lock(global_lock); 4667 // objects to validate: ['commandBuffer', 'dstBuffer'] 4668 // CODEGEN : file ../vk-layer-generate.py line #1099 4669 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4670 // CODEGEN : file ../vk-layer-generate.py line #1099 4671 skipCall |= validate_buffer(commandBuffer, dstBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false); 4672 } 4673 if (skipCall) 4674 return; 4675 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); 4676 } 4677 4678 // CODEGEN : file ../vk-layer-generate.py line #1216 4679 4680 4681 VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) 4682 { 4683 bool skipCall = false; 4684 { 4685 std::lock_guard<std::mutex> lock(global_lock); 4686 // objects to validate: ['commandBuffer', 'image'] 4687 // CODEGEN : file ../vk-layer-generate.py line #1099 4688 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4689 // CODEGEN : file ../vk-layer-generate.py line #1099 4690 skipCall |= validate_image(commandBuffer, image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false); 4691 } 4692 if (skipCall) 4693 return; 4694 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); 4695 } 4696 4697 // CODEGEN : file ../vk-layer-generate.py line #1216 4698 4699 4700 VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) 4701 { 4702 bool skipCall = false; 4703 { 4704 std::lock_guard<std::mutex> lock(global_lock); 4705 // objects to validate: ['commandBuffer', 'image'] 4706 // CODEGEN : file ../vk-layer-generate.py line #1099 4707 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4708 // CODEGEN : file ../vk-layer-generate.py line #1099 4709 skipCall |= validate_image(commandBuffer, image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false); 4710 } 4711 if (skipCall) 4712 return; 4713 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); 4714 } 4715 4716 // CODEGEN : file ../vk-layer-generate.py line #1216 4717 4718 4719 VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) 4720 { 4721 bool skipCall = false; 4722 { 4723 std::lock_guard<std::mutex> lock(global_lock); 4724 // objects to validate: ['commandBuffer'] 4725 // CODEGEN : file ../vk-layer-generate.py line #1099 4726 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4727 } 4728 if (skipCall) 4729 return; 4730 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); 4731 } 4732 4733 // CODEGEN : file ../vk-layer-generate.py line #1216 4734 4735 4736 VKAPI_ATTR void VKAPI_CALL CmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) 4737 { 4738 bool skipCall = false; 4739 { 4740 std::lock_guard<std::mutex> lock(global_lock); 4741 // objects to validate: ['commandBuffer', 'dstImage', 'srcImage'] 4742 // CODEGEN : file ../vk-layer-generate.py line #1099 4743 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4744 // CODEGEN : file ../vk-layer-generate.py line #1099 4745 skipCall |= validate_image(commandBuffer, dstImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false); 4746 // CODEGEN : file ../vk-layer-generate.py line #1099 4747 skipCall |= validate_image(commandBuffer, srcImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false); 4748 } 4749 if (skipCall) 4750 return; 4751 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); 4752 } 4753 4754 // CODEGEN : file ../vk-layer-generate.py line #1216 4755 4756 4757 VKAPI_ATTR void VKAPI_CALL CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) 4758 { 4759 bool skipCall = false; 4760 { 4761 std::lock_guard<std::mutex> lock(global_lock); 4762 // objects to validate: ['commandBuffer', 'event'] 4763 // CODEGEN : file ../vk-layer-generate.py line #1099 4764 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4765 // CODEGEN : file ../vk-layer-generate.py line #1099 4766 skipCall |= validate_event(commandBuffer, event, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, false); 4767 } 4768 if (skipCall) 4769 return; 4770 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdSetEvent(commandBuffer, event, stageMask); 4771 } 4772 4773 // CODEGEN : file ../vk-layer-generate.py line #1216 4774 4775 4776 VKAPI_ATTR void VKAPI_CALL CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) 4777 { 4778 bool skipCall = false; 4779 { 4780 std::lock_guard<std::mutex> lock(global_lock); 4781 // objects to validate: ['commandBuffer', 'event'] 4782 // CODEGEN : file ../vk-layer-generate.py line #1099 4783 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4784 // CODEGEN : file ../vk-layer-generate.py line #1099 4785 skipCall |= validate_event(commandBuffer, event, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, false); 4786 } 4787 if (skipCall) 4788 return; 4789 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdResetEvent(commandBuffer, event, stageMask); 4790 } 4791 4792 // CODEGEN : file ../vk-layer-generate.py line #1216 4793 4794 4795 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) 4796 { 4797 bool skipCall = false; 4798 { 4799 std::lock_guard<std::mutex> lock(global_lock); 4800 // objects to validate: ['commandBuffer', 'pBufferMemoryBarriers[bufferMemoryBarrierCount]', 'pEvents[eventCount]', 'pImageMemoryBarriers[imageMemoryBarrierCount]'] 4801 // CODEGEN : file ../vk-layer-generate.py line #1099 4802 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4803 if (pBufferMemoryBarriers) { 4804 // CODEGEN : file ../vk-layer-generate.py line #1055 4805 for (uint32_t idx0=0; idx0<bufferMemoryBarrierCount; ++idx0) { 4806 if (pBufferMemoryBarriers[idx0].buffer) { 4807 // CODEGEN : file ../vk-layer-generate.py line #1091 4808 skipCall |= validate_buffer(commandBuffer, pBufferMemoryBarriers[idx0].buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false); 4809 } 4810 } 4811 } 4812 if (pEvents) { 4813 for (uint32_t idx1=0; idx1<eventCount; ++idx1) { 4814 // CODEGEN : file ../vk-layer-generate.py line #1091 4815 skipCall |= validate_event(commandBuffer, pEvents[idx1], VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, false); 4816 } 4817 } 4818 if (pImageMemoryBarriers) { 4819 // CODEGEN : file ../vk-layer-generate.py line #1055 4820 for (uint32_t idx2=0; idx2<imageMemoryBarrierCount; ++idx2) { 4821 if (pImageMemoryBarriers[idx2].image) { 4822 // CODEGEN : file ../vk-layer-generate.py line #1091 4823 skipCall |= validate_image(commandBuffer, pImageMemoryBarriers[idx2].image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false); 4824 } 4825 } 4826 } 4827 } 4828 if (skipCall) 4829 return; 4830 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); 4831 } 4832 4833 // CODEGEN : file ../vk-layer-generate.py line #1216 4834 4835 4836 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) 4837 { 4838 bool skipCall = false; 4839 { 4840 std::lock_guard<std::mutex> lock(global_lock); 4841 // objects to validate: ['commandBuffer', 'pBufferMemoryBarriers[bufferMemoryBarrierCount]', 'pImageMemoryBarriers[imageMemoryBarrierCount]'] 4842 // CODEGEN : file ../vk-layer-generate.py line #1099 4843 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4844 if (pBufferMemoryBarriers) { 4845 // CODEGEN : file ../vk-layer-generate.py line #1055 4846 for (uint32_t idx0=0; idx0<bufferMemoryBarrierCount; ++idx0) { 4847 if (pBufferMemoryBarriers[idx0].buffer) { 4848 // CODEGEN : file ../vk-layer-generate.py line #1091 4849 skipCall |= validate_buffer(commandBuffer, pBufferMemoryBarriers[idx0].buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false); 4850 } 4851 } 4852 } 4853 if (pImageMemoryBarriers) { 4854 // CODEGEN : file ../vk-layer-generate.py line #1055 4855 for (uint32_t idx1=0; idx1<imageMemoryBarrierCount; ++idx1) { 4856 if (pImageMemoryBarriers[idx1].image) { 4857 // CODEGEN : file ../vk-layer-generate.py line #1091 4858 skipCall |= validate_image(commandBuffer, pImageMemoryBarriers[idx1].image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false); 4859 } 4860 } 4861 } 4862 } 4863 if (skipCall) 4864 return; 4865 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); 4866 } 4867 4868 // CODEGEN : file ../vk-layer-generate.py line #1216 4869 4870 4871 VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) 4872 { 4873 bool skipCall = false; 4874 { 4875 std::lock_guard<std::mutex> lock(global_lock); 4876 // objects to validate: ['commandBuffer', 'queryPool'] 4877 // CODEGEN : file ../vk-layer-generate.py line #1099 4878 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4879 // CODEGEN : file ../vk-layer-generate.py line #1099 4880 skipCall |= validate_query_pool(commandBuffer, queryPool, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, false); 4881 } 4882 if (skipCall) 4883 return; 4884 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdBeginQuery(commandBuffer, queryPool, query, flags); 4885 } 4886 4887 // CODEGEN : file ../vk-layer-generate.py line #1216 4888 4889 4890 VKAPI_ATTR void VKAPI_CALL CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) 4891 { 4892 bool skipCall = false; 4893 { 4894 std::lock_guard<std::mutex> lock(global_lock); 4895 // objects to validate: ['commandBuffer', 'queryPool'] 4896 // CODEGEN : file ../vk-layer-generate.py line #1099 4897 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4898 // CODEGEN : file ../vk-layer-generate.py line #1099 4899 skipCall |= validate_query_pool(commandBuffer, queryPool, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, false); 4900 } 4901 if (skipCall) 4902 return; 4903 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdEndQuery(commandBuffer, queryPool, query); 4904 } 4905 4906 // CODEGEN : file ../vk-layer-generate.py line #1216 4907 4908 4909 VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) 4910 { 4911 bool skipCall = false; 4912 { 4913 std::lock_guard<std::mutex> lock(global_lock); 4914 // objects to validate: ['commandBuffer', 'queryPool'] 4915 // CODEGEN : file ../vk-layer-generate.py line #1099 4916 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4917 // CODEGEN : file ../vk-layer-generate.py line #1099 4918 skipCall |= validate_query_pool(commandBuffer, queryPool, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, false); 4919 } 4920 if (skipCall) 4921 return; 4922 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); 4923 } 4924 4925 // CODEGEN : file ../vk-layer-generate.py line #1216 4926 4927 4928 VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) 4929 { 4930 bool skipCall = false; 4931 { 4932 std::lock_guard<std::mutex> lock(global_lock); 4933 // objects to validate: ['commandBuffer', 'queryPool'] 4934 // CODEGEN : file ../vk-layer-generate.py line #1099 4935 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4936 // CODEGEN : file ../vk-layer-generate.py line #1099 4937 skipCall |= validate_query_pool(commandBuffer, queryPool, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, false); 4938 } 4939 if (skipCall) 4940 return; 4941 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); 4942 } 4943 4944 // CODEGEN : file ../vk-layer-generate.py line #1216 4945 4946 4947 VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) 4948 { 4949 bool skipCall = false; 4950 { 4951 std::lock_guard<std::mutex> lock(global_lock); 4952 // objects to validate: ['commandBuffer', 'dstBuffer', 'queryPool'] 4953 // CODEGEN : file ../vk-layer-generate.py line #1099 4954 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4955 // CODEGEN : file ../vk-layer-generate.py line #1099 4956 skipCall |= validate_buffer(commandBuffer, dstBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false); 4957 // CODEGEN : file ../vk-layer-generate.py line #1099 4958 skipCall |= validate_query_pool(commandBuffer, queryPool, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, false); 4959 } 4960 if (skipCall) 4961 return; 4962 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); 4963 } 4964 4965 // CODEGEN : file ../vk-layer-generate.py line #1216 4966 4967 4968 VKAPI_ATTR void VKAPI_CALL CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) 4969 { 4970 bool skipCall = false; 4971 { 4972 std::lock_guard<std::mutex> lock(global_lock); 4973 // objects to validate: ['commandBuffer', 'layout'] 4974 // CODEGEN : file ../vk-layer-generate.py line #1099 4975 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4976 // CODEGEN : file ../vk-layer-generate.py line #1099 4977 skipCall |= validate_pipeline_layout(commandBuffer, layout, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, false); 4978 } 4979 if (skipCall) 4980 return; 4981 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); 4982 } 4983 4984 // CODEGEN : file ../vk-layer-generate.py line #1216 4985 4986 4987 VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) 4988 { 4989 bool skipCall = false; 4990 { 4991 std::lock_guard<std::mutex> lock(global_lock); 4992 // objects to validate: ['commandBuffer', 'pRenderPassBegin'] 4993 // CODEGEN : file ../vk-layer-generate.py line #1099 4994 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 4995 if (pRenderPassBegin) { 4996 // CODEGEN : file ../vk-layer-generate.py line #1099 4997 skipCall |= validate_framebuffer(commandBuffer, pRenderPassBegin->framebuffer, VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, false); 4998 // CODEGEN : file ../vk-layer-generate.py line #1099 4999 skipCall |= validate_render_pass(commandBuffer, pRenderPassBegin->renderPass, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, false); 5000 } 5001 } 5002 if (skipCall) 5003 return; 5004 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); 5005 } 5006 5007 // CODEGEN : file ../vk-layer-generate.py line #1216 5008 5009 5010 VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) 5011 { 5012 bool skipCall = false; 5013 { 5014 std::lock_guard<std::mutex> lock(global_lock); 5015 // objects to validate: ['commandBuffer'] 5016 // CODEGEN : file ../vk-layer-generate.py line #1099 5017 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 5018 } 5019 if (skipCall) 5020 return; 5021 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdNextSubpass(commandBuffer, contents); 5022 } 5023 5024 // CODEGEN : file ../vk-layer-generate.py line #1216 5025 5026 5027 VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass(VkCommandBuffer commandBuffer) 5028 { 5029 bool skipCall = false; 5030 { 5031 std::lock_guard<std::mutex> lock(global_lock); 5032 // objects to validate: ['commandBuffer'] 5033 // CODEGEN : file ../vk-layer-generate.py line #1099 5034 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 5035 } 5036 if (skipCall) 5037 return; 5038 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdEndRenderPass(commandBuffer); 5039 } 5040 5041 // CODEGEN : file ../vk-layer-generate.py line #1216 5042 5043 5044 VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) 5045 { 5046 bool skipCall = false; 5047 { 5048 std::lock_guard<std::mutex> lock(global_lock); 5049 // objects to validate: ['commandBuffer', 'pCommandBuffers[commandBufferCount]'] 5050 // CODEGEN : file ../vk-layer-generate.py line #1099 5051 skipCall |= validate_command_buffer(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 5052 if (pCommandBuffers) { 5053 for (uint32_t idx0=0; idx0<commandBufferCount; ++idx0) { 5054 // CODEGEN : file ../vk-layer-generate.py line #1091 5055 skipCall |= validate_command_buffer(commandBuffer, pCommandBuffers[idx0], VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); 5056 } 5057 } 5058 } 5059 if (skipCall) 5060 return; 5061 get_dispatch_table(object_tracker_device_table_map, commandBuffer)->CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); 5062 } 5063 5064 // CODEGEN : file ../vk-layer-generate.py line #1216 5065 5066 5067 // CODEGEN : file ../vk-layer-generate.py line #1251 5068 5069 5070 VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) 5071 { 5072 bool skipCall = false; 5073 { 5074 std::lock_guard<std::mutex> lock(global_lock); 5075 // objects to validate: ['instance', 'surface'] 5076 // CODEGEN : file ../vk-layer-generate.py line #1099 5077 skipCall |= validate_instance(instance, instance, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, false); 5078 // CODEGEN : file ../vk-layer-generate.py line #1099 5079 skipCall |= validate_surface_khr(instance, surface, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, false); 5080 } 5081 if (skipCall) 5082 return; 5083 { 5084 std::lock_guard<std::mutex> lock(global_lock); 5085 destroy_surface_khr(instance, surface); 5086 } 5087 get_dispatch_table(object_tracker_instance_table_map, instance)->DestroySurfaceKHR(instance, surface, pAllocator); 5088 } 5089 5090 // CODEGEN : file ../vk-layer-generate.py line #1216 5091 5092 5093 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) 5094 { 5095 bool skipCall = false; 5096 { 5097 std::lock_guard<std::mutex> lock(global_lock); 5098 // objects to validate: ['physicalDevice', 'surface'] 5099 // CODEGEN : file ../vk-layer-generate.py line #1099 5100 skipCall |= validate_physical_device(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false); 5101 // CODEGEN : file ../vk-layer-generate.py line #1099 5102 skipCall |= validate_surface_khr(physicalDevice, surface, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, false); 5103 } 5104 if (skipCall) 5105 return VK_ERROR_VALIDATION_FAILED_EXT; 5106 VkResult result = get_dispatch_table(object_tracker_instance_table_map, physicalDevice)->GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); 5107 return result; 5108 } 5109 5110 // CODEGEN : file ../vk-layer-generate.py line #1216 5111 5112 5113 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) 5114 { 5115 bool skipCall = false; 5116 { 5117 std::lock_guard<std::mutex> lock(global_lock); 5118 // objects to validate: ['physicalDevice', 'surface'] 5119 // CODEGEN : file ../vk-layer-generate.py line #1099 5120 skipCall |= validate_physical_device(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false); 5121 // CODEGEN : file ../vk-layer-generate.py line #1099 5122 skipCall |= validate_surface_khr(physicalDevice, surface, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, false); 5123 } 5124 if (skipCall) 5125 return VK_ERROR_VALIDATION_FAILED_EXT; 5126 VkResult result = get_dispatch_table(object_tracker_instance_table_map, physicalDevice)->GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); 5127 return result; 5128 } 5129 5130 // CODEGEN : file ../vk-layer-generate.py line #1216 5131 5132 5133 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) 5134 { 5135 bool skipCall = false; 5136 { 5137 std::lock_guard<std::mutex> lock(global_lock); 5138 // objects to validate: ['physicalDevice', 'surface'] 5139 // CODEGEN : file ../vk-layer-generate.py line #1099 5140 skipCall |= validate_physical_device(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false); 5141 // CODEGEN : file ../vk-layer-generate.py line #1099 5142 skipCall |= validate_surface_khr(physicalDevice, surface, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, false); 5143 } 5144 if (skipCall) 5145 return VK_ERROR_VALIDATION_FAILED_EXT; 5146 VkResult result = get_dispatch_table(object_tracker_instance_table_map, physicalDevice)->GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); 5147 return result; 5148 } 5149 5150 // CODEGEN : file ../vk-layer-generate.py line #1216 5151 5152 5153 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) 5154 { 5155 bool skipCall = false; 5156 { 5157 std::lock_guard<std::mutex> lock(global_lock); 5158 // objects to validate: ['physicalDevice', 'surface'] 5159 // CODEGEN : file ../vk-layer-generate.py line #1099 5160 skipCall |= validate_physical_device(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false); 5161 // CODEGEN : file ../vk-layer-generate.py line #1099 5162 skipCall |= validate_surface_khr(physicalDevice, surface, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, false); 5163 } 5164 if (skipCall) 5165 return VK_ERROR_VALIDATION_FAILED_EXT; 5166 VkResult result = get_dispatch_table(object_tracker_instance_table_map, physicalDevice)->GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes); 5167 return result; 5168 } 5169 5170 // CODEGEN : file ../vk-layer-generate.py line #1216 5171 5172 5173 VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) 5174 { 5175 bool skipCall = false; 5176 { 5177 std::lock_guard<std::mutex> lock(global_lock); 5178 // objects to validate: ['device', 'pCreateInfo'] 5179 // CODEGEN : file ../vk-layer-generate.py line #1099 5180 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 5181 if (pCreateInfo) { 5182 // CODEGEN : file ../vk-layer-generate.py line #1099 5183 skipCall |= validate_swapchain_khr(device, pCreateInfo->oldSwapchain, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, true); 5184 // CODEGEN : file ../vk-layer-generate.py line #1099 5185 skipCall |= validate_surface_khr(device, pCreateInfo->surface, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, false); 5186 } 5187 } 5188 if (skipCall) 5189 return VK_ERROR_VALIDATION_FAILED_EXT; 5190 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); 5191 { 5192 std::lock_guard<std::mutex> lock(global_lock); 5193 if (result == VK_SUCCESS) { 5194 create_swapchain_khr(device, *pSwapchain, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT); 5195 } 5196 } 5197 return result; 5198 } 5199 5200 // CODEGEN : file ../vk-layer-generate.py line #1216 5201 VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) 5202 { 5203 return explicit_DestroySwapchainKHR(device, swapchain, pAllocator); 5204 } 5205 5206 // CODEGEN : file ../vk-layer-generate.py line #1216 5207 VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) 5208 { 5209 return explicit_GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); 5210 } 5211 5212 // CODEGEN : file ../vk-layer-generate.py line #1216 5213 5214 5215 VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) 5216 { 5217 bool skipCall = false; 5218 { 5219 std::lock_guard<std::mutex> lock(global_lock); 5220 // objects to validate: ['device', 'fence', 'semaphore', 'swapchain'] 5221 // CODEGEN : file ../vk-layer-generate.py line #1099 5222 skipCall |= validate_device(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); 5223 // CODEGEN : file ../vk-layer-generate.py line #1099 5224 skipCall |= validate_fence(device, fence, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, true); 5225 // CODEGEN : file ../vk-layer-generate.py line #1099 5226 skipCall |= validate_semaphore(device, semaphore, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, true); 5227 // CODEGEN : file ../vk-layer-generate.py line #1099 5228 skipCall |= validate_swapchain_khr(device, swapchain, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, false); 5229 } 5230 if (skipCall) 5231 return VK_ERROR_VALIDATION_FAILED_EXT; 5232 VkResult result = get_dispatch_table(object_tracker_device_table_map, device)->AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); 5233 return result; 5234 } 5235 5236 // CODEGEN : file ../vk-layer-generate.py line #1216 5237 5238 5239 VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) 5240 { 5241 bool skipCall = false; 5242 { 5243 std::lock_guard<std::mutex> lock(global_lock); 5244 // objects to validate: ['pPresentInfo', 'queue'] 5245 if (pPresentInfo) { 5246 if (pPresentInfo->pSwapchains) { 5247 for (uint32_t idx0=0; idx0<pPresentInfo->swapchainCount; ++idx0) { 5248 // CODEGEN : file ../vk-layer-generate.py line #1091 5249 skipCall |= validate_swapchain_khr(queue, pPresentInfo->pSwapchains[idx0], VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, false); 5250 } 5251 } 5252 if (pPresentInfo->pWaitSemaphores) { 5253 for (uint32_t idx1=0; idx1<pPresentInfo->waitSemaphoreCount; ++idx1) { 5254 // CODEGEN : file ../vk-layer-generate.py line #1091 5255 skipCall |= validate_semaphore(queue, pPresentInfo->pWaitSemaphores[idx1], VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, false); 5256 } 5257 } 5258 } 5259 // CODEGEN : file ../vk-layer-generate.py line #1099 5260 skipCall |= validate_queue(queue, queue, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, false); 5261 } 5262 if (skipCall) 5263 return VK_ERROR_VALIDATION_FAILED_EXT; 5264 VkResult result = get_dispatch_table(object_tracker_device_table_map, queue)->QueuePresentKHR(queue, pPresentInfo); 5265 return result; 5266 } 5267 5268 // CODEGEN : file ../vk-layer-generate.py line #1216 5269 5270 5271 #ifdef VK_USE_PLATFORM_ANDROID_KHR 5272 5273 VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) 5274 { 5275 bool skipCall = false; 5276 { 5277 std::lock_guard<std::mutex> lock(global_lock); 5278 // objects to validate: ['instance'] 5279 // CODEGEN : file ../vk-layer-generate.py line #1099 5280 skipCall |= validate_instance(instance, instance, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, false); 5281 } 5282 if (skipCall) 5283 return VK_ERROR_VALIDATION_FAILED_EXT; 5284 VkResult result = get_dispatch_table(object_tracker_instance_table_map, instance)->CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); 5285 { 5286 std::lock_guard<std::mutex> lock(global_lock); 5287 if (result == VK_SUCCESS) { 5288 create_surface_khr(instance, *pSurface, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT); 5289 } 5290 } 5291 return result; 5292 } 5293 5294 #endif // VK_USE_PLATFORM_ANDROID_KHR 5295 5296 // CODEGEN : file ../vk-layer-generate.py line #491 5297 static inline PFN_vkVoidFunction intercept_core_device_command(const char *name) 5298 { 5299 if (!name || name[0] != 'v' || name[1] != 'k') 5300 return NULL; 5301 5302 name += 2; 5303 if (!strcmp(name, "GetDeviceProcAddr")) 5304 return (PFN_vkVoidFunction) GetDeviceProcAddr; 5305 if (!strcmp(name, "DestroyDevice")) 5306 return (PFN_vkVoidFunction) DestroyDevice; 5307 if (!strcmp(name, "GetDeviceQueue")) 5308 return (PFN_vkVoidFunction) GetDeviceQueue; 5309 if (!strcmp(name, "QueueSubmit")) 5310 return (PFN_vkVoidFunction) QueueSubmit; 5311 if (!strcmp(name, "QueueWaitIdle")) 5312 return (PFN_vkVoidFunction) QueueWaitIdle; 5313 if (!strcmp(name, "DeviceWaitIdle")) 5314 return (PFN_vkVoidFunction) DeviceWaitIdle; 5315 if (!strcmp(name, "AllocateMemory")) 5316 return (PFN_vkVoidFunction) AllocateMemory; 5317 if (!strcmp(name, "FreeMemory")) 5318 return (PFN_vkVoidFunction) FreeMemory; 5319 if (!strcmp(name, "MapMemory")) 5320 return (PFN_vkVoidFunction) MapMemory; 5321 if (!strcmp(name, "UnmapMemory")) 5322 return (PFN_vkVoidFunction) UnmapMemory; 5323 if (!strcmp(name, "FlushMappedMemoryRanges")) 5324 return (PFN_vkVoidFunction) FlushMappedMemoryRanges; 5325 if (!strcmp(name, "InvalidateMappedMemoryRanges")) 5326 return (PFN_vkVoidFunction) InvalidateMappedMemoryRanges; 5327 if (!strcmp(name, "GetDeviceMemoryCommitment")) 5328 return (PFN_vkVoidFunction) GetDeviceMemoryCommitment; 5329 if (!strcmp(name, "BindBufferMemory")) 5330 return (PFN_vkVoidFunction) BindBufferMemory; 5331 if (!strcmp(name, "BindImageMemory")) 5332 return (PFN_vkVoidFunction) BindImageMemory; 5333 if (!strcmp(name, "GetBufferMemoryRequirements")) 5334 return (PFN_vkVoidFunction) GetBufferMemoryRequirements; 5335 if (!strcmp(name, "GetImageMemoryRequirements")) 5336 return (PFN_vkVoidFunction) GetImageMemoryRequirements; 5337 if (!strcmp(name, "GetImageSparseMemoryRequirements")) 5338 return (PFN_vkVoidFunction) GetImageSparseMemoryRequirements; 5339 if (!strcmp(name, "QueueBindSparse")) 5340 return (PFN_vkVoidFunction) QueueBindSparse; 5341 if (!strcmp(name, "CreateFence")) 5342 return (PFN_vkVoidFunction) CreateFence; 5343 if (!strcmp(name, "DestroyFence")) 5344 return (PFN_vkVoidFunction) DestroyFence; 5345 if (!strcmp(name, "ResetFences")) 5346 return (PFN_vkVoidFunction) ResetFences; 5347 if (!strcmp(name, "GetFenceStatus")) 5348 return (PFN_vkVoidFunction) GetFenceStatus; 5349 if (!strcmp(name, "WaitForFences")) 5350 return (PFN_vkVoidFunction) WaitForFences; 5351 if (!strcmp(name, "CreateSemaphore")) 5352 return (PFN_vkVoidFunction) CreateSemaphore; 5353 if (!strcmp(name, "DestroySemaphore")) 5354 return (PFN_vkVoidFunction) DestroySemaphore; 5355 if (!strcmp(name, "CreateEvent")) 5356 return (PFN_vkVoidFunction) CreateEvent; 5357 if (!strcmp(name, "DestroyEvent")) 5358 return (PFN_vkVoidFunction) DestroyEvent; 5359 if (!strcmp(name, "GetEventStatus")) 5360 return (PFN_vkVoidFunction) GetEventStatus; 5361 if (!strcmp(name, "SetEvent")) 5362 return (PFN_vkVoidFunction) SetEvent; 5363 if (!strcmp(name, "ResetEvent")) 5364 return (PFN_vkVoidFunction) ResetEvent; 5365 if (!strcmp(name, "CreateQueryPool")) 5366 return (PFN_vkVoidFunction) CreateQueryPool; 5367 if (!strcmp(name, "DestroyQueryPool")) 5368 return (PFN_vkVoidFunction) DestroyQueryPool; 5369 if (!strcmp(name, "GetQueryPoolResults")) 5370 return (PFN_vkVoidFunction) GetQueryPoolResults; 5371 if (!strcmp(name, "CreateBuffer")) 5372 return (PFN_vkVoidFunction) CreateBuffer; 5373 if (!strcmp(name, "DestroyBuffer")) 5374 return (PFN_vkVoidFunction) DestroyBuffer; 5375 if (!strcmp(name, "CreateBufferView")) 5376 return (PFN_vkVoidFunction) CreateBufferView; 5377 if (!strcmp(name, "DestroyBufferView")) 5378 return (PFN_vkVoidFunction) DestroyBufferView; 5379 if (!strcmp(name, "CreateImage")) 5380 return (PFN_vkVoidFunction) CreateImage; 5381 if (!strcmp(name, "DestroyImage")) 5382 return (PFN_vkVoidFunction) DestroyImage; 5383 if (!strcmp(name, "GetImageSubresourceLayout")) 5384 return (PFN_vkVoidFunction) GetImageSubresourceLayout; 5385 if (!strcmp(name, "CreateImageView")) 5386 return (PFN_vkVoidFunction) CreateImageView; 5387 if (!strcmp(name, "DestroyImageView")) 5388 return (PFN_vkVoidFunction) DestroyImageView; 5389 if (!strcmp(name, "CreateShaderModule")) 5390 return (PFN_vkVoidFunction) CreateShaderModule; 5391 if (!strcmp(name, "DestroyShaderModule")) 5392 return (PFN_vkVoidFunction) DestroyShaderModule; 5393 if (!strcmp(name, "CreatePipelineCache")) 5394 return (PFN_vkVoidFunction) CreatePipelineCache; 5395 if (!strcmp(name, "DestroyPipelineCache")) 5396 return (PFN_vkVoidFunction) DestroyPipelineCache; 5397 if (!strcmp(name, "GetPipelineCacheData")) 5398 return (PFN_vkVoidFunction) GetPipelineCacheData; 5399 if (!strcmp(name, "MergePipelineCaches")) 5400 return (PFN_vkVoidFunction) MergePipelineCaches; 5401 if (!strcmp(name, "CreateGraphicsPipelines")) 5402 return (PFN_vkVoidFunction) CreateGraphicsPipelines; 5403 if (!strcmp(name, "CreateComputePipelines")) 5404 return (PFN_vkVoidFunction) CreateComputePipelines; 5405 if (!strcmp(name, "DestroyPipeline")) 5406 return (PFN_vkVoidFunction) DestroyPipeline; 5407 if (!strcmp(name, "CreatePipelineLayout")) 5408 return (PFN_vkVoidFunction) CreatePipelineLayout; 5409 if (!strcmp(name, "DestroyPipelineLayout")) 5410 return (PFN_vkVoidFunction) DestroyPipelineLayout; 5411 if (!strcmp(name, "CreateSampler")) 5412 return (PFN_vkVoidFunction) CreateSampler; 5413 if (!strcmp(name, "DestroySampler")) 5414 return (PFN_vkVoidFunction) DestroySampler; 5415 if (!strcmp(name, "CreateDescriptorSetLayout")) 5416 return (PFN_vkVoidFunction) CreateDescriptorSetLayout; 5417 if (!strcmp(name, "DestroyDescriptorSetLayout")) 5418 return (PFN_vkVoidFunction) DestroyDescriptorSetLayout; 5419 if (!strcmp(name, "CreateDescriptorPool")) 5420 return (PFN_vkVoidFunction) CreateDescriptorPool; 5421 if (!strcmp(name, "DestroyDescriptorPool")) 5422 return (PFN_vkVoidFunction) DestroyDescriptorPool; 5423 if (!strcmp(name, "ResetDescriptorPool")) 5424 return (PFN_vkVoidFunction) ResetDescriptorPool; 5425 if (!strcmp(name, "AllocateDescriptorSets")) 5426 return (PFN_vkVoidFunction) AllocateDescriptorSets; 5427 if (!strcmp(name, "FreeDescriptorSets")) 5428 return (PFN_vkVoidFunction) FreeDescriptorSets; 5429 if (!strcmp(name, "UpdateDescriptorSets")) 5430 return (PFN_vkVoidFunction) UpdateDescriptorSets; 5431 if (!strcmp(name, "CreateFramebuffer")) 5432 return (PFN_vkVoidFunction) CreateFramebuffer; 5433 if (!strcmp(name, "DestroyFramebuffer")) 5434 return (PFN_vkVoidFunction) DestroyFramebuffer; 5435 if (!strcmp(name, "CreateRenderPass")) 5436 return (PFN_vkVoidFunction) CreateRenderPass; 5437 if (!strcmp(name, "DestroyRenderPass")) 5438 return (PFN_vkVoidFunction) DestroyRenderPass; 5439 if (!strcmp(name, "GetRenderAreaGranularity")) 5440 return (PFN_vkVoidFunction) GetRenderAreaGranularity; 5441 if (!strcmp(name, "CreateCommandPool")) 5442 return (PFN_vkVoidFunction) CreateCommandPool; 5443 if (!strcmp(name, "DestroyCommandPool")) 5444 return (PFN_vkVoidFunction) DestroyCommandPool; 5445 if (!strcmp(name, "ResetCommandPool")) 5446 return (PFN_vkVoidFunction) ResetCommandPool; 5447 if (!strcmp(name, "AllocateCommandBuffers")) 5448 return (PFN_vkVoidFunction) AllocateCommandBuffers; 5449 if (!strcmp(name, "FreeCommandBuffers")) 5450 return (PFN_vkVoidFunction) FreeCommandBuffers; 5451 if (!strcmp(name, "BeginCommandBuffer")) 5452 return (PFN_vkVoidFunction) BeginCommandBuffer; 5453 if (!strcmp(name, "EndCommandBuffer")) 5454 return (PFN_vkVoidFunction) EndCommandBuffer; 5455 if (!strcmp(name, "ResetCommandBuffer")) 5456 return (PFN_vkVoidFunction) ResetCommandBuffer; 5457 if (!strcmp(name, "CmdBindPipeline")) 5458 return (PFN_vkVoidFunction) CmdBindPipeline; 5459 if (!strcmp(name, "CmdSetViewport")) 5460 return (PFN_vkVoidFunction) CmdSetViewport; 5461 if (!strcmp(name, "CmdSetScissor")) 5462 return (PFN_vkVoidFunction) CmdSetScissor; 5463 if (!strcmp(name, "CmdSetLineWidth")) 5464 return (PFN_vkVoidFunction) CmdSetLineWidth; 5465 if (!strcmp(name, "CmdSetDepthBias")) 5466 return (PFN_vkVoidFunction) CmdSetDepthBias; 5467 if (!strcmp(name, "CmdSetBlendConstants")) 5468 return (PFN_vkVoidFunction) CmdSetBlendConstants; 5469 if (!strcmp(name, "CmdSetDepthBounds")) 5470 return (PFN_vkVoidFunction) CmdSetDepthBounds; 5471 if (!strcmp(name, "CmdSetStencilCompareMask")) 5472 return (PFN_vkVoidFunction) CmdSetStencilCompareMask; 5473 if (!strcmp(name, "CmdSetStencilWriteMask")) 5474 return (PFN_vkVoidFunction) CmdSetStencilWriteMask; 5475 if (!strcmp(name, "CmdSetStencilReference")) 5476 return (PFN_vkVoidFunction) CmdSetStencilReference; 5477 if (!strcmp(name, "CmdBindDescriptorSets")) 5478 return (PFN_vkVoidFunction) CmdBindDescriptorSets; 5479 if (!strcmp(name, "CmdBindIndexBuffer")) 5480 return (PFN_vkVoidFunction) CmdBindIndexBuffer; 5481 if (!strcmp(name, "CmdBindVertexBuffers")) 5482 return (PFN_vkVoidFunction) CmdBindVertexBuffers; 5483 if (!strcmp(name, "CmdDraw")) 5484 return (PFN_vkVoidFunction) CmdDraw; 5485 if (!strcmp(name, "CmdDrawIndexed")) 5486 return (PFN_vkVoidFunction) CmdDrawIndexed; 5487 if (!strcmp(name, "CmdDrawIndirect")) 5488 return (PFN_vkVoidFunction) CmdDrawIndirect; 5489 if (!strcmp(name, "CmdDrawIndexedIndirect")) 5490 return (PFN_vkVoidFunction) CmdDrawIndexedIndirect; 5491 if (!strcmp(name, "CmdDispatch")) 5492 return (PFN_vkVoidFunction) CmdDispatch; 5493 if (!strcmp(name, "CmdDispatchIndirect")) 5494 return (PFN_vkVoidFunction) CmdDispatchIndirect; 5495 if (!strcmp(name, "CmdCopyBuffer")) 5496 return (PFN_vkVoidFunction) CmdCopyBuffer; 5497 if (!strcmp(name, "CmdCopyImage")) 5498 return (PFN_vkVoidFunction) CmdCopyImage; 5499 if (!strcmp(name, "CmdBlitImage")) 5500 return (PFN_vkVoidFunction) CmdBlitImage; 5501 if (!strcmp(name, "CmdCopyBufferToImage")) 5502 return (PFN_vkVoidFunction) CmdCopyBufferToImage; 5503 if (!strcmp(name, "CmdCopyImageToBuffer")) 5504 return (PFN_vkVoidFunction) CmdCopyImageToBuffer; 5505 if (!strcmp(name, "CmdUpdateBuffer")) 5506 return (PFN_vkVoidFunction) CmdUpdateBuffer; 5507 if (!strcmp(name, "CmdFillBuffer")) 5508 return (PFN_vkVoidFunction) CmdFillBuffer; 5509 if (!strcmp(name, "CmdClearColorImage")) 5510 return (PFN_vkVoidFunction) CmdClearColorImage; 5511 if (!strcmp(name, "CmdClearDepthStencilImage")) 5512 return (PFN_vkVoidFunction) CmdClearDepthStencilImage; 5513 if (!strcmp(name, "CmdClearAttachments")) 5514 return (PFN_vkVoidFunction) CmdClearAttachments; 5515 if (!strcmp(name, "CmdResolveImage")) 5516 return (PFN_vkVoidFunction) CmdResolveImage; 5517 if (!strcmp(name, "CmdSetEvent")) 5518 return (PFN_vkVoidFunction) CmdSetEvent; 5519 if (!strcmp(name, "CmdResetEvent")) 5520 return (PFN_vkVoidFunction) CmdResetEvent; 5521 if (!strcmp(name, "CmdWaitEvents")) 5522 return (PFN_vkVoidFunction) CmdWaitEvents; 5523 if (!strcmp(name, "CmdPipelineBarrier")) 5524 return (PFN_vkVoidFunction) CmdPipelineBarrier; 5525 if (!strcmp(name, "CmdBeginQuery")) 5526 return (PFN_vkVoidFunction) CmdBeginQuery; 5527 if (!strcmp(name, "CmdEndQuery")) 5528 return (PFN_vkVoidFunction) CmdEndQuery; 5529 if (!strcmp(name, "CmdResetQueryPool")) 5530 return (PFN_vkVoidFunction) CmdResetQueryPool; 5531 if (!strcmp(name, "CmdWriteTimestamp")) 5532 return (PFN_vkVoidFunction) CmdWriteTimestamp; 5533 if (!strcmp(name, "CmdCopyQueryPoolResults")) 5534 return (PFN_vkVoidFunction) CmdCopyQueryPoolResults; 5535 if (!strcmp(name, "CmdPushConstants")) 5536 return (PFN_vkVoidFunction) CmdPushConstants; 5537 if (!strcmp(name, "CmdBeginRenderPass")) 5538 return (PFN_vkVoidFunction) CmdBeginRenderPass; 5539 if (!strcmp(name, "CmdNextSubpass")) 5540 return (PFN_vkVoidFunction) CmdNextSubpass; 5541 if (!strcmp(name, "CmdEndRenderPass")) 5542 return (PFN_vkVoidFunction) CmdEndRenderPass; 5543 if (!strcmp(name, "CmdExecuteCommands")) 5544 return (PFN_vkVoidFunction) CmdExecuteCommands; 5545 5546 return NULL; 5547 } 5548 static inline PFN_vkVoidFunction intercept_core_instance_command(const char *name) 5549 { 5550 if (!name || name[0] != 'v' || name[1] != 'k') 5551 return NULL; 5552 5553 // we should never be queried for these commands 5554 assert(strcmp(name, "vkEnumerateInstanceLayerProperties") && 5555 strcmp(name, "vkEnumerateInstanceExtensionProperties") && 5556 strcmp(name, "vkEnumerateDeviceLayerProperties")); 5557 5558 name += 2; 5559 if (!strcmp(name, "CreateInstance")) 5560 return (PFN_vkVoidFunction) CreateInstance; 5561 if (!strcmp(name, "DestroyInstance")) 5562 return (PFN_vkVoidFunction) DestroyInstance; 5563 if (!strcmp(name, "EnumeratePhysicalDevices")) 5564 return (PFN_vkVoidFunction) EnumeratePhysicalDevices; 5565 if (!strcmp(name, "GetPhysicalDeviceFeatures")) 5566 return (PFN_vkVoidFunction) GetPhysicalDeviceFeatures; 5567 if (!strcmp(name, "GetPhysicalDeviceFormatProperties")) 5568 return (PFN_vkVoidFunction) GetPhysicalDeviceFormatProperties; 5569 if (!strcmp(name, "GetPhysicalDeviceImageFormatProperties")) 5570 return (PFN_vkVoidFunction) GetPhysicalDeviceImageFormatProperties; 5571 if (!strcmp(name, "GetPhysicalDeviceProperties")) 5572 return (PFN_vkVoidFunction) GetPhysicalDeviceProperties; 5573 if (!strcmp(name, "GetPhysicalDeviceQueueFamilyProperties")) 5574 return (PFN_vkVoidFunction) GetPhysicalDeviceQueueFamilyProperties; 5575 if (!strcmp(name, "GetPhysicalDeviceMemoryProperties")) 5576 return (PFN_vkVoidFunction) GetPhysicalDeviceMemoryProperties; 5577 if (!strcmp(name, "GetInstanceProcAddr")) 5578 return (PFN_vkVoidFunction) GetInstanceProcAddr; 5579 if (!strcmp(name, "CreateDevice")) 5580 return (PFN_vkVoidFunction) CreateDevice; 5581 if (!strcmp(name, "GetPhysicalDeviceSparseImageFormatProperties")) 5582 return (PFN_vkVoidFunction) GetPhysicalDeviceSparseImageFormatProperties; 5583 5584 return NULL; 5585 } 5586 5587 // CODEGEN : file ../vk-layer-generate.py line #522 5588 // CODEGEN : file ../vk-layer-generate.py line #291 5589 VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT( 5590 VkInstance instance, 5591 const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, 5592 const VkAllocationCallbacks* pAllocator, 5593 VkDebugReportCallbackEXT* pCallback) 5594 { 5595 VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(object_tracker_instance_table_map, instance); 5596 VkResult result = pInstanceTable->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback); 5597 if (VK_SUCCESS == result) { 5598 layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map); 5599 result = layer_create_msg_callback(my_data->report_data, 5600 pCreateInfo, 5601 pAllocator, 5602 pCallback); 5603 } 5604 return result; 5605 } 5606 // CODEGEN : file ../vk-layer-generate.py line #322 5607 VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback, const VkAllocationCallbacks *pAllocator) 5608 { 5609 VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(object_tracker_instance_table_map, instance); 5610 pInstanceTable->DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator); 5611 layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map); 5612 layer_destroy_msg_callback(my_data->report_data, msgCallback, pAllocator); 5613 } 5614 // CODEGEN : file ../vk-layer-generate.py line #338 5615 VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location, int32_t msgCode, const char *pLayerPrefix, const char *pMsg) 5616 { 5617 VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(object_tracker_instance_table_map, instance); 5618 pInstanceTable->DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg); 5619 } 5620 5621 // CODEGEN : file ../vk-layer-generate.py line #535 5622 static inline PFN_vkVoidFunction intercept_wsi_enabled_command(const char *name, VkDevice dev) 5623 { 5624 if (dev) { 5625 layer_data *my_data = get_my_data_ptr(get_dispatch_key(dev), layer_data_map); 5626 if (!my_data->wsi_enabled) 5627 return nullptr; 5628 } 5629 5630 if (!strcmp("vkCreateSwapchainKHR", name)) 5631 return reinterpret_cast<PFN_vkVoidFunction>(CreateSwapchainKHR); 5632 if (!strcmp("vkDestroySwapchainKHR", name)) 5633 return reinterpret_cast<PFN_vkVoidFunction>(DestroySwapchainKHR); 5634 if (!strcmp("vkGetSwapchainImagesKHR", name)) 5635 return reinterpret_cast<PFN_vkVoidFunction>(GetSwapchainImagesKHR); 5636 if (!strcmp("vkAcquireNextImageKHR", name)) 5637 return reinterpret_cast<PFN_vkVoidFunction>(AcquireNextImageKHR); 5638 if (!strcmp("vkQueuePresentKHR", name)) 5639 return reinterpret_cast<PFN_vkVoidFunction>(QueuePresentKHR); 5640 5641 return nullptr; 5642 } 5643 5644 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char* funcName) 5645 { 5646 PFN_vkVoidFunction addr; 5647 addr = intercept_core_device_command(funcName); 5648 if (addr) 5649 return addr; 5650 assert(device); 5651 5652 addr = intercept_wsi_enabled_command(funcName, device); 5653 if (addr) 5654 return addr; 5655 5656 if (get_dispatch_table(object_tracker_device_table_map, device)->GetDeviceProcAddr == NULL) 5657 return NULL; 5658 return get_dispatch_table(object_tracker_device_table_map, device)->GetDeviceProcAddr(device, funcName); 5659 } 5660 5661 // CODEGEN : file ../vk-layer-generate.py line #567 5662 static inline PFN_vkVoidFunction intercept_msg_callback_get_proc_addr_command(const char *name, VkInstance instance) 5663 { 5664 layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map); 5665 return debug_report_get_instance_proc_addr(my_data->report_data, name); 5666 } 5667 5668 // CODEGEN : file ../vk-layer-generate.py line #567 5669 static inline PFN_vkVoidFunction intercept_wsi_enabled_command(const char *name, VkInstance instance) 5670 { 5671 VkLayerInstanceDispatchTable* pTable = get_dispatch_table(object_tracker_instance_table_map, instance); 5672 if (instanceExtMap.size() == 0 || !instanceExtMap[pTable].wsi_enabled) 5673 return nullptr; 5674 5675 if (!strcmp("vkDestroySurfaceKHR", name)) 5676 return reinterpret_cast<PFN_vkVoidFunction>(DestroySurfaceKHR); 5677 if (!strcmp("vkGetPhysicalDeviceSurfaceSupportKHR", name)) 5678 return reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceSupportKHR); 5679 if (!strcmp("vkGetPhysicalDeviceSurfaceCapabilitiesKHR", name)) 5680 return reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceCapabilitiesKHR); 5681 if (!strcmp("vkGetPhysicalDeviceSurfaceFormatsKHR", name)) 5682 return reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceFormatsKHR); 5683 if (!strcmp("vkGetPhysicalDeviceSurfacePresentModesKHR", name)) 5684 return reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfacePresentModesKHR); 5685 #ifdef VK_USE_PLATFORM_ANDROID_KHR 5686 if (!strcmp("vkCreateAndroidSurfaceKHR", name)) 5687 return reinterpret_cast<PFN_vkVoidFunction>(CreateAndroidSurfaceKHR); 5688 #endif // VK_USE_PLATFORM_ANDROID_KHR 5689 5690 return nullptr; 5691 } 5692 5693 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char* funcName) 5694 { 5695 PFN_vkVoidFunction addr; 5696 addr = intercept_core_instance_command(funcName); 5697 if (!addr) { 5698 addr = intercept_core_device_command(funcName); 5699 } 5700 if (!addr) { 5701 addr = intercept_wsi_enabled_command(funcName, VkDevice(VK_NULL_HANDLE)); 5702 } 5703 if (addr) { 5704 return addr; 5705 } 5706 assert(instance); 5707 5708 addr = intercept_msg_callback_get_proc_addr_command(funcName, instance); 5709 if (addr) 5710 return addr; 5711 5712 addr = intercept_wsi_enabled_command(funcName, instance); 5713 if (addr) 5714 return addr; 5715 5716 if (get_dispatch_table(object_tracker_instance_table_map, instance)->GetInstanceProcAddr == NULL) { 5717 return NULL; 5718 } 5719 return get_dispatch_table(object_tracker_instance_table_map, instance)->GetInstanceProcAddr(instance, funcName); 5720 } 5721 5722 5723 } // namespace object_tracker 5724 5725 // CODEGEN : file ../vk-layer-generate.py line #352 5726 // vk_layer_logging.h expects these to be defined 5727 5728 VKAPI_ATTR VkResult VKAPI_CALL 5729 vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, 5730 const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pMsgCallback) { 5731 return object_tracker::CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback); 5732 } 5733 5734 VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(VkInstance instance, 5735 VkDebugReportCallbackEXT msgCallback, 5736 const VkAllocationCallbacks *pAllocator) { 5737 object_tracker::DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator); 5738 } 5739 5740 VKAPI_ATTR void VKAPI_CALL 5741 vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objType, uint64_t object, 5742 size_t location, int32_t msgCode, const char *pLayerPrefix, const char *pMsg) { 5743 object_tracker::DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg); 5744 } 5745 5746 // CODEGEN : file ../vk-layer-generate.py line #377 5747 // loader-layer interface v0 5748 5749 static const VkExtensionProperties instance_extensions[] = { 5750 { 5751 VK_EXT_DEBUG_REPORT_EXTENSION_NAME, 5752 VK_EXT_DEBUG_REPORT_SPEC_VERSION 5753 } 5754 }; 5755 5756 static const VkLayerProperties globalLayerProps = { 5757 "VK_LAYER_LUNARG_object_tracker", 5758 VK_LAYER_API_VERSION, // specVersion 5759 1, // implementationVersion 5760 "LunarG Validation Layer" 5761 }; 5762 5763 VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, VkExtensionProperties* pProperties) 5764 { 5765 return util_GetExtensionProperties(1, instance_extensions, pCount, pProperties); 5766 } 5767 5768 VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties* pProperties) 5769 { 5770 return util_GetLayerProperties(1, &globalLayerProps, pCount, pProperties); 5771 } 5772 5773 VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, VkLayerProperties* pProperties) 5774 { 5775 return util_GetLayerProperties(1, &globalLayerProps, pCount, pProperties); 5776 } 5777 5778 VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice dev, const char *funcName) 5779 { 5780 return object_tracker::GetDeviceProcAddr(dev, funcName); 5781 } 5782 5783 VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *funcName) 5784 { 5785 if (!strcmp(funcName, "vkEnumerateInstanceLayerProperties")) 5786 return reinterpret_cast<PFN_vkVoidFunction>(vkEnumerateInstanceLayerProperties); 5787 if (!strcmp(funcName, "vkEnumerateDeviceLayerProperties")) 5788 return reinterpret_cast<PFN_vkVoidFunction>(vkEnumerateDeviceLayerProperties); 5789 if (!strcmp(funcName, "vkEnumerateInstanceExtensionProperties")) 5790 return reinterpret_cast<PFN_vkVoidFunction>(vkEnumerateInstanceExtensionProperties); 5791 if (!strcmp(funcName, "vkGetInstanceProcAddr")) 5792 return reinterpret_cast<PFN_vkVoidFunction>(vkGetInstanceProcAddr); 5793 5794 return object_tracker::GetInstanceProcAddr(instance, funcName); 5795 } 5796
