1 // Copyright (C) 2018 The Android Open Source Project 2 // Copyright (C) 2018 Google Inc. 3 // 4 // Licensed under the Apache License, Version 2.0 (the "License"); 5 // you may not use this file except in compliance with the License. 6 // You may obtain a copy of the License at 7 // 8 // http://www.apache.org/licenses/LICENSE-2.0 9 // 10 // Unless required by applicable law or agreed to in writing, software 11 // distributed under the License is distributed on an "AS IS" BASIS, 12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 // See the License for the specific language governing permissions and 14 // limitations under the License. 15 16 // Autogenerated module func_table 17 // (impl) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal 18 // Please do not modify directly; 19 // re-run android/scripts/generate-vulkan-sources.sh, 20 // or directly from Python by defining: 21 // VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml 22 // CEREAL_OUTPUT_DIR: Where to put the generated sources. 23 // python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR 24 25 #include "func_table.h" 26 27 28 #include "VkEncoder.h" 29 #include "HostConnection.h" 30 #include "ResourceTracker.h" 31 32 #include "goldfish_vk_private_defs.h" 33 34 // Stuff we are not going to use but if included, 35 // will cause compile errors. These are Android Vulkan 36 // required extensions, but the approach will be to 37 // implement them completely on the guest side. 38 #undef VK_KHR_android_surface 39 40 41 namespace goldfish_vk { 42 43 #ifdef VK_VERSION_1_0 44 static VkResult entry_vkCreateInstance( 45 const VkInstanceCreateInfo* pCreateInfo, 46 const VkAllocationCallbacks* pAllocator, 47 VkInstance* pInstance) 48 { 49 AEMU_SCOPED_TRACE("vkCreateInstance"); 50 auto vkEnc = HostConnection::get()->vkEncoder(); 51 VkResult vkCreateInstance_VkResult_return = (VkResult)0; 52 vkCreateInstance_VkResult_return = vkEnc->vkCreateInstance(pCreateInfo, pAllocator, pInstance); 53 return vkCreateInstance_VkResult_return; 54 } 55 static void entry_vkDestroyInstance( 56 VkInstance instance, 57 const VkAllocationCallbacks* pAllocator) 58 { 59 AEMU_SCOPED_TRACE("vkDestroyInstance"); 60 auto vkEnc = HostConnection::get()->vkEncoder(); 61 vkEnc->vkDestroyInstance(instance, pAllocator); 62 } 63 static VkResult entry_vkEnumeratePhysicalDevices( 64 VkInstance instance, 65 uint32_t* pPhysicalDeviceCount, 66 VkPhysicalDevice* pPhysicalDevices) 67 { 68 AEMU_SCOPED_TRACE("vkEnumeratePhysicalDevices"); 69 auto vkEnc = HostConnection::get()->vkEncoder(); 70 VkResult vkEnumeratePhysicalDevices_VkResult_return = (VkResult)0; 71 auto resources = ResourceTracker::get(); 72 vkEnumeratePhysicalDevices_VkResult_return = resources->on_vkEnumeratePhysicalDevices(vkEnc, VK_SUCCESS, instance, pPhysicalDeviceCount, pPhysicalDevices); 73 return vkEnumeratePhysicalDevices_VkResult_return; 74 } 75 static void entry_vkGetPhysicalDeviceFeatures( 76 VkPhysicalDevice physicalDevice, 77 VkPhysicalDeviceFeatures* pFeatures) 78 { 79 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures"); 80 auto vkEnc = HostConnection::get()->vkEncoder(); 81 vkEnc->vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures); 82 } 83 static void entry_vkGetPhysicalDeviceFormatProperties( 84 VkPhysicalDevice physicalDevice, 85 VkFormat format, 86 VkFormatProperties* pFormatProperties) 87 { 88 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties"); 89 auto vkEnc = HostConnection::get()->vkEncoder(); 90 vkEnc->vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); 91 } 92 static VkResult entry_vkGetPhysicalDeviceImageFormatProperties( 93 VkPhysicalDevice physicalDevice, 94 VkFormat format, 95 VkImageType type, 96 VkImageTiling tiling, 97 VkImageUsageFlags usage, 98 VkImageCreateFlags flags, 99 VkImageFormatProperties* pImageFormatProperties) 100 { 101 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties"); 102 auto vkEnc = HostConnection::get()->vkEncoder(); 103 VkResult vkGetPhysicalDeviceImageFormatProperties_VkResult_return = (VkResult)0; 104 vkGetPhysicalDeviceImageFormatProperties_VkResult_return = vkEnc->vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); 105 return vkGetPhysicalDeviceImageFormatProperties_VkResult_return; 106 } 107 static void entry_vkGetPhysicalDeviceProperties( 108 VkPhysicalDevice physicalDevice, 109 VkPhysicalDeviceProperties* pProperties) 110 { 111 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties"); 112 auto vkEnc = HostConnection::get()->vkEncoder(); 113 vkEnc->vkGetPhysicalDeviceProperties(physicalDevice, pProperties); 114 } 115 static void entry_vkGetPhysicalDeviceQueueFamilyProperties( 116 VkPhysicalDevice physicalDevice, 117 uint32_t* pQueueFamilyPropertyCount, 118 VkQueueFamilyProperties* pQueueFamilyProperties) 119 { 120 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties"); 121 auto vkEnc = HostConnection::get()->vkEncoder(); 122 vkEnc->vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); 123 } 124 static void entry_vkGetPhysicalDeviceMemoryProperties( 125 VkPhysicalDevice physicalDevice, 126 VkPhysicalDeviceMemoryProperties* pMemoryProperties) 127 { 128 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties"); 129 auto vkEnc = HostConnection::get()->vkEncoder(); 130 vkEnc->vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); 131 } 132 static PFN_vkVoidFunction entry_vkGetInstanceProcAddr( 133 VkInstance instance, 134 const char* pName) 135 { 136 AEMU_SCOPED_TRACE("vkGetInstanceProcAddr"); 137 auto vkEnc = HostConnection::get()->vkEncoder(); 138 PFN_vkVoidFunction vkGetInstanceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0; 139 vkGetInstanceProcAddr_PFN_vkVoidFunction_return = vkEnc->vkGetInstanceProcAddr(instance, pName); 140 return vkGetInstanceProcAddr_PFN_vkVoidFunction_return; 141 } 142 static PFN_vkVoidFunction entry_vkGetDeviceProcAddr( 143 VkDevice device, 144 const char* pName) 145 { 146 AEMU_SCOPED_TRACE("vkGetDeviceProcAddr"); 147 auto vkEnc = HostConnection::get()->vkEncoder(); 148 PFN_vkVoidFunction vkGetDeviceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0; 149 vkGetDeviceProcAddr_PFN_vkVoidFunction_return = vkEnc->vkGetDeviceProcAddr(device, pName); 150 return vkGetDeviceProcAddr_PFN_vkVoidFunction_return; 151 } 152 static VkResult entry_vkCreateDevice( 153 VkPhysicalDevice physicalDevice, 154 const VkDeviceCreateInfo* pCreateInfo, 155 const VkAllocationCallbacks* pAllocator, 156 VkDevice* pDevice) 157 { 158 AEMU_SCOPED_TRACE("vkCreateDevice"); 159 auto vkEnc = HostConnection::get()->vkEncoder(); 160 VkResult vkCreateDevice_VkResult_return = (VkResult)0; 161 vkCreateDevice_VkResult_return = vkEnc->vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice); 162 return vkCreateDevice_VkResult_return; 163 } 164 static void entry_vkDestroyDevice( 165 VkDevice device, 166 const VkAllocationCallbacks* pAllocator) 167 { 168 AEMU_SCOPED_TRACE("vkDestroyDevice"); 169 auto vkEnc = HostConnection::get()->vkEncoder(); 170 vkEnc->vkDestroyDevice(device, pAllocator); 171 } 172 static VkResult entry_vkEnumerateInstanceExtensionProperties( 173 const char* pLayerName, 174 uint32_t* pPropertyCount, 175 VkExtensionProperties* pProperties) 176 { 177 AEMU_SCOPED_TRACE("vkEnumerateInstanceExtensionProperties"); 178 auto vkEnc = HostConnection::get()->vkEncoder(); 179 VkResult vkEnumerateInstanceExtensionProperties_VkResult_return = (VkResult)0; 180 auto resources = ResourceTracker::get(); 181 vkEnumerateInstanceExtensionProperties_VkResult_return = resources->on_vkEnumerateInstanceExtensionProperties(vkEnc, VK_SUCCESS, pLayerName, pPropertyCount, pProperties); 182 return vkEnumerateInstanceExtensionProperties_VkResult_return; 183 } 184 static VkResult entry_vkEnumerateDeviceExtensionProperties( 185 VkPhysicalDevice physicalDevice, 186 const char* pLayerName, 187 uint32_t* pPropertyCount, 188 VkExtensionProperties* pProperties) 189 { 190 AEMU_SCOPED_TRACE("vkEnumerateDeviceExtensionProperties"); 191 auto vkEnc = HostConnection::get()->vkEncoder(); 192 VkResult vkEnumerateDeviceExtensionProperties_VkResult_return = (VkResult)0; 193 auto resources = ResourceTracker::get(); 194 vkEnumerateDeviceExtensionProperties_VkResult_return = resources->on_vkEnumerateDeviceExtensionProperties(vkEnc, VK_SUCCESS, physicalDevice, pLayerName, pPropertyCount, pProperties); 195 return vkEnumerateDeviceExtensionProperties_VkResult_return; 196 } 197 static VkResult entry_vkEnumerateInstanceLayerProperties( 198 uint32_t* pPropertyCount, 199 VkLayerProperties* pProperties) 200 { 201 AEMU_SCOPED_TRACE("vkEnumerateInstanceLayerProperties"); 202 auto vkEnc = HostConnection::get()->vkEncoder(); 203 VkResult vkEnumerateInstanceLayerProperties_VkResult_return = (VkResult)0; 204 vkEnumerateInstanceLayerProperties_VkResult_return = vkEnc->vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties); 205 return vkEnumerateInstanceLayerProperties_VkResult_return; 206 } 207 static VkResult entry_vkEnumerateDeviceLayerProperties( 208 VkPhysicalDevice physicalDevice, 209 uint32_t* pPropertyCount, 210 VkLayerProperties* pProperties) 211 { 212 AEMU_SCOPED_TRACE("vkEnumerateDeviceLayerProperties"); 213 auto vkEnc = HostConnection::get()->vkEncoder(); 214 VkResult vkEnumerateDeviceLayerProperties_VkResult_return = (VkResult)0; 215 vkEnumerateDeviceLayerProperties_VkResult_return = vkEnc->vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties); 216 return vkEnumerateDeviceLayerProperties_VkResult_return; 217 } 218 static void entry_vkGetDeviceQueue( 219 VkDevice device, 220 uint32_t queueFamilyIndex, 221 uint32_t queueIndex, 222 VkQueue* pQueue) 223 { 224 AEMU_SCOPED_TRACE("vkGetDeviceQueue"); 225 auto vkEnc = HostConnection::get()->vkEncoder(); 226 vkEnc->vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); 227 } 228 static VkResult entry_vkQueueSubmit( 229 VkQueue queue, 230 uint32_t submitCount, 231 const VkSubmitInfo* pSubmits, 232 VkFence fence) 233 { 234 AEMU_SCOPED_TRACE("vkQueueSubmit"); 235 auto vkEnc = HostConnection::get()->vkEncoder(); 236 VkResult vkQueueSubmit_VkResult_return = (VkResult)0; 237 auto resources = ResourceTracker::get(); 238 vkQueueSubmit_VkResult_return = resources->on_vkQueueSubmit(vkEnc, VK_SUCCESS, queue, submitCount, pSubmits, fence); 239 return vkQueueSubmit_VkResult_return; 240 } 241 static VkResult entry_vkQueueWaitIdle( 242 VkQueue queue) 243 { 244 AEMU_SCOPED_TRACE("vkQueueWaitIdle"); 245 auto vkEnc = HostConnection::get()->vkEncoder(); 246 VkResult vkQueueWaitIdle_VkResult_return = (VkResult)0; 247 vkQueueWaitIdle_VkResult_return = vkEnc->vkQueueWaitIdle(queue); 248 return vkQueueWaitIdle_VkResult_return; 249 } 250 static VkResult entry_vkDeviceWaitIdle( 251 VkDevice device) 252 { 253 AEMU_SCOPED_TRACE("vkDeviceWaitIdle"); 254 auto vkEnc = HostConnection::get()->vkEncoder(); 255 VkResult vkDeviceWaitIdle_VkResult_return = (VkResult)0; 256 vkDeviceWaitIdle_VkResult_return = vkEnc->vkDeviceWaitIdle(device); 257 return vkDeviceWaitIdle_VkResult_return; 258 } 259 static VkResult entry_vkAllocateMemory( 260 VkDevice device, 261 const VkMemoryAllocateInfo* pAllocateInfo, 262 const VkAllocationCallbacks* pAllocator, 263 VkDeviceMemory* pMemory) 264 { 265 AEMU_SCOPED_TRACE("vkAllocateMemory"); 266 auto vkEnc = HostConnection::get()->vkEncoder(); 267 VkResult vkAllocateMemory_VkResult_return = (VkResult)0; 268 auto resources = ResourceTracker::get(); 269 vkAllocateMemory_VkResult_return = resources->on_vkAllocateMemory(vkEnc, VK_SUCCESS, device, pAllocateInfo, pAllocator, pMemory); 270 return vkAllocateMemory_VkResult_return; 271 } 272 static void entry_vkFreeMemory( 273 VkDevice device, 274 VkDeviceMemory memory, 275 const VkAllocationCallbacks* pAllocator) 276 { 277 AEMU_SCOPED_TRACE("vkFreeMemory"); 278 auto vkEnc = HostConnection::get()->vkEncoder(); 279 auto resources = ResourceTracker::get(); 280 resources->on_vkFreeMemory(vkEnc, device, memory, pAllocator); 281 } 282 static VkResult entry_vkMapMemory( 283 VkDevice device, 284 VkDeviceMemory memory, 285 VkDeviceSize offset, 286 VkDeviceSize size, 287 VkMemoryMapFlags flags, 288 void** ppData) 289 { 290 AEMU_SCOPED_TRACE("vkMapMemory"); 291 auto vkEnc = HostConnection::get()->vkEncoder(); 292 VkResult vkMapMemory_VkResult_return = (VkResult)0; 293 vkMapMemory_VkResult_return = vkEnc->vkMapMemory(device, memory, offset, size, flags, ppData); 294 return vkMapMemory_VkResult_return; 295 } 296 static void entry_vkUnmapMemory( 297 VkDevice device, 298 VkDeviceMemory memory) 299 { 300 AEMU_SCOPED_TRACE("vkUnmapMemory"); 301 auto vkEnc = HostConnection::get()->vkEncoder(); 302 vkEnc->vkUnmapMemory(device, memory); 303 } 304 static VkResult entry_vkFlushMappedMemoryRanges( 305 VkDevice device, 306 uint32_t memoryRangeCount, 307 const VkMappedMemoryRange* pMemoryRanges) 308 { 309 AEMU_SCOPED_TRACE("vkFlushMappedMemoryRanges"); 310 auto vkEnc = HostConnection::get()->vkEncoder(); 311 VkResult vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0; 312 vkFlushMappedMemoryRanges_VkResult_return = vkEnc->vkFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); 313 return vkFlushMappedMemoryRanges_VkResult_return; 314 } 315 static VkResult entry_vkInvalidateMappedMemoryRanges( 316 VkDevice device, 317 uint32_t memoryRangeCount, 318 const VkMappedMemoryRange* pMemoryRanges) 319 { 320 AEMU_SCOPED_TRACE("vkInvalidateMappedMemoryRanges"); 321 auto vkEnc = HostConnection::get()->vkEncoder(); 322 VkResult vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0; 323 vkInvalidateMappedMemoryRanges_VkResult_return = vkEnc->vkInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); 324 return vkInvalidateMappedMemoryRanges_VkResult_return; 325 } 326 static void entry_vkGetDeviceMemoryCommitment( 327 VkDevice device, 328 VkDeviceMemory memory, 329 VkDeviceSize* pCommittedMemoryInBytes) 330 { 331 AEMU_SCOPED_TRACE("vkGetDeviceMemoryCommitment"); 332 auto vkEnc = HostConnection::get()->vkEncoder(); 333 vkEnc->vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); 334 } 335 static VkResult entry_vkBindBufferMemory( 336 VkDevice device, 337 VkBuffer buffer, 338 VkDeviceMemory memory, 339 VkDeviceSize memoryOffset) 340 { 341 AEMU_SCOPED_TRACE("vkBindBufferMemory"); 342 auto vkEnc = HostConnection::get()->vkEncoder(); 343 VkResult vkBindBufferMemory_VkResult_return = (VkResult)0; 344 auto resources = ResourceTracker::get(); 345 vkBindBufferMemory_VkResult_return = resources->on_vkBindBufferMemory(vkEnc, VK_SUCCESS, device, buffer, memory, memoryOffset); 346 return vkBindBufferMemory_VkResult_return; 347 } 348 static VkResult entry_vkBindImageMemory( 349 VkDevice device, 350 VkImage image, 351 VkDeviceMemory memory, 352 VkDeviceSize memoryOffset) 353 { 354 AEMU_SCOPED_TRACE("vkBindImageMemory"); 355 auto vkEnc = HostConnection::get()->vkEncoder(); 356 VkResult vkBindImageMemory_VkResult_return = (VkResult)0; 357 auto resources = ResourceTracker::get(); 358 vkBindImageMemory_VkResult_return = resources->on_vkBindImageMemory(vkEnc, VK_SUCCESS, device, image, memory, memoryOffset); 359 return vkBindImageMemory_VkResult_return; 360 } 361 static void entry_vkGetBufferMemoryRequirements( 362 VkDevice device, 363 VkBuffer buffer, 364 VkMemoryRequirements* pMemoryRequirements) 365 { 366 AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements"); 367 auto vkEnc = HostConnection::get()->vkEncoder(); 368 auto resources = ResourceTracker::get(); 369 resources->on_vkGetBufferMemoryRequirements(vkEnc, device, buffer, pMemoryRequirements); 370 } 371 static void entry_vkGetImageMemoryRequirements( 372 VkDevice device, 373 VkImage image, 374 VkMemoryRequirements* pMemoryRequirements) 375 { 376 AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements"); 377 auto vkEnc = HostConnection::get()->vkEncoder(); 378 auto resources = ResourceTracker::get(); 379 resources->on_vkGetImageMemoryRequirements(vkEnc, device, image, pMemoryRequirements); 380 } 381 static void entry_vkGetImageSparseMemoryRequirements( 382 VkDevice device, 383 VkImage image, 384 uint32_t* pSparseMemoryRequirementCount, 385 VkSparseImageMemoryRequirements* pSparseMemoryRequirements) 386 { 387 AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements"); 388 auto vkEnc = HostConnection::get()->vkEncoder(); 389 vkEnc->vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); 390 } 391 static void entry_vkGetPhysicalDeviceSparseImageFormatProperties( 392 VkPhysicalDevice physicalDevice, 393 VkFormat format, 394 VkImageType type, 395 VkSampleCountFlagBits samples, 396 VkImageUsageFlags usage, 397 VkImageTiling tiling, 398 uint32_t* pPropertyCount, 399 VkSparseImageFormatProperties* pProperties) 400 { 401 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties"); 402 auto vkEnc = HostConnection::get()->vkEncoder(); 403 vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); 404 } 405 static VkResult entry_vkQueueBindSparse( 406 VkQueue queue, 407 uint32_t bindInfoCount, 408 const VkBindSparseInfo* pBindInfo, 409 VkFence fence) 410 { 411 AEMU_SCOPED_TRACE("vkQueueBindSparse"); 412 auto vkEnc = HostConnection::get()->vkEncoder(); 413 VkResult vkQueueBindSparse_VkResult_return = (VkResult)0; 414 vkQueueBindSparse_VkResult_return = vkEnc->vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence); 415 return vkQueueBindSparse_VkResult_return; 416 } 417 static VkResult entry_vkCreateFence( 418 VkDevice device, 419 const VkFenceCreateInfo* pCreateInfo, 420 const VkAllocationCallbacks* pAllocator, 421 VkFence* pFence) 422 { 423 AEMU_SCOPED_TRACE("vkCreateFence"); 424 auto vkEnc = HostConnection::get()->vkEncoder(); 425 VkResult vkCreateFence_VkResult_return = (VkResult)0; 426 vkCreateFence_VkResult_return = vkEnc->vkCreateFence(device, pCreateInfo, pAllocator, pFence); 427 return vkCreateFence_VkResult_return; 428 } 429 static void entry_vkDestroyFence( 430 VkDevice device, 431 VkFence fence, 432 const VkAllocationCallbacks* pAllocator) 433 { 434 AEMU_SCOPED_TRACE("vkDestroyFence"); 435 auto vkEnc = HostConnection::get()->vkEncoder(); 436 vkEnc->vkDestroyFence(device, fence, pAllocator); 437 } 438 static VkResult entry_vkResetFences( 439 VkDevice device, 440 uint32_t fenceCount, 441 const VkFence* pFences) 442 { 443 AEMU_SCOPED_TRACE("vkResetFences"); 444 auto vkEnc = HostConnection::get()->vkEncoder(); 445 VkResult vkResetFences_VkResult_return = (VkResult)0; 446 vkResetFences_VkResult_return = vkEnc->vkResetFences(device, fenceCount, pFences); 447 return vkResetFences_VkResult_return; 448 } 449 static VkResult entry_vkGetFenceStatus( 450 VkDevice device, 451 VkFence fence) 452 { 453 AEMU_SCOPED_TRACE("vkGetFenceStatus"); 454 auto vkEnc = HostConnection::get()->vkEncoder(); 455 VkResult vkGetFenceStatus_VkResult_return = (VkResult)0; 456 vkGetFenceStatus_VkResult_return = vkEnc->vkGetFenceStatus(device, fence); 457 return vkGetFenceStatus_VkResult_return; 458 } 459 static VkResult entry_vkWaitForFences( 460 VkDevice device, 461 uint32_t fenceCount, 462 const VkFence* pFences, 463 VkBool32 waitAll, 464 uint64_t timeout) 465 { 466 AEMU_SCOPED_TRACE("vkWaitForFences"); 467 auto vkEnc = HostConnection::get()->vkEncoder(); 468 VkResult vkWaitForFences_VkResult_return = (VkResult)0; 469 vkWaitForFences_VkResult_return = vkEnc->vkWaitForFences(device, fenceCount, pFences, waitAll, timeout); 470 return vkWaitForFences_VkResult_return; 471 } 472 static VkResult entry_vkCreateSemaphore( 473 VkDevice device, 474 const VkSemaphoreCreateInfo* pCreateInfo, 475 const VkAllocationCallbacks* pAllocator, 476 VkSemaphore* pSemaphore) 477 { 478 AEMU_SCOPED_TRACE("vkCreateSemaphore"); 479 auto vkEnc = HostConnection::get()->vkEncoder(); 480 VkResult vkCreateSemaphore_VkResult_return = (VkResult)0; 481 auto resources = ResourceTracker::get(); 482 vkCreateSemaphore_VkResult_return = resources->on_vkCreateSemaphore(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSemaphore); 483 return vkCreateSemaphore_VkResult_return; 484 } 485 static void entry_vkDestroySemaphore( 486 VkDevice device, 487 VkSemaphore semaphore, 488 const VkAllocationCallbacks* pAllocator) 489 { 490 AEMU_SCOPED_TRACE("vkDestroySemaphore"); 491 auto vkEnc = HostConnection::get()->vkEncoder(); 492 auto resources = ResourceTracker::get(); 493 resources->on_vkDestroySemaphore(vkEnc, device, semaphore, pAllocator); 494 } 495 static VkResult entry_vkCreateEvent( 496 VkDevice device, 497 const VkEventCreateInfo* pCreateInfo, 498 const VkAllocationCallbacks* pAllocator, 499 VkEvent* pEvent) 500 { 501 AEMU_SCOPED_TRACE("vkCreateEvent"); 502 auto vkEnc = HostConnection::get()->vkEncoder(); 503 VkResult vkCreateEvent_VkResult_return = (VkResult)0; 504 vkCreateEvent_VkResult_return = vkEnc->vkCreateEvent(device, pCreateInfo, pAllocator, pEvent); 505 return vkCreateEvent_VkResult_return; 506 } 507 static void entry_vkDestroyEvent( 508 VkDevice device, 509 VkEvent event, 510 const VkAllocationCallbacks* pAllocator) 511 { 512 AEMU_SCOPED_TRACE("vkDestroyEvent"); 513 auto vkEnc = HostConnection::get()->vkEncoder(); 514 vkEnc->vkDestroyEvent(device, event, pAllocator); 515 } 516 static VkResult entry_vkGetEventStatus( 517 VkDevice device, 518 VkEvent event) 519 { 520 AEMU_SCOPED_TRACE("vkGetEventStatus"); 521 auto vkEnc = HostConnection::get()->vkEncoder(); 522 VkResult vkGetEventStatus_VkResult_return = (VkResult)0; 523 vkGetEventStatus_VkResult_return = vkEnc->vkGetEventStatus(device, event); 524 return vkGetEventStatus_VkResult_return; 525 } 526 static VkResult entry_vkSetEvent( 527 VkDevice device, 528 VkEvent event) 529 { 530 AEMU_SCOPED_TRACE("vkSetEvent"); 531 auto vkEnc = HostConnection::get()->vkEncoder(); 532 VkResult vkSetEvent_VkResult_return = (VkResult)0; 533 vkSetEvent_VkResult_return = vkEnc->vkSetEvent(device, event); 534 return vkSetEvent_VkResult_return; 535 } 536 static VkResult entry_vkResetEvent( 537 VkDevice device, 538 VkEvent event) 539 { 540 AEMU_SCOPED_TRACE("vkResetEvent"); 541 auto vkEnc = HostConnection::get()->vkEncoder(); 542 VkResult vkResetEvent_VkResult_return = (VkResult)0; 543 vkResetEvent_VkResult_return = vkEnc->vkResetEvent(device, event); 544 return vkResetEvent_VkResult_return; 545 } 546 static VkResult entry_vkCreateQueryPool( 547 VkDevice device, 548 const VkQueryPoolCreateInfo* pCreateInfo, 549 const VkAllocationCallbacks* pAllocator, 550 VkQueryPool* pQueryPool) 551 { 552 AEMU_SCOPED_TRACE("vkCreateQueryPool"); 553 auto vkEnc = HostConnection::get()->vkEncoder(); 554 VkResult vkCreateQueryPool_VkResult_return = (VkResult)0; 555 vkCreateQueryPool_VkResult_return = vkEnc->vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); 556 return vkCreateQueryPool_VkResult_return; 557 } 558 static void entry_vkDestroyQueryPool( 559 VkDevice device, 560 VkQueryPool queryPool, 561 const VkAllocationCallbacks* pAllocator) 562 { 563 AEMU_SCOPED_TRACE("vkDestroyQueryPool"); 564 auto vkEnc = HostConnection::get()->vkEncoder(); 565 vkEnc->vkDestroyQueryPool(device, queryPool, pAllocator); 566 } 567 static VkResult entry_vkGetQueryPoolResults( 568 VkDevice device, 569 VkQueryPool queryPool, 570 uint32_t firstQuery, 571 uint32_t queryCount, 572 size_t dataSize, 573 void* pData, 574 VkDeviceSize stride, 575 VkQueryResultFlags flags) 576 { 577 AEMU_SCOPED_TRACE("vkGetQueryPoolResults"); 578 auto vkEnc = HostConnection::get()->vkEncoder(); 579 VkResult vkGetQueryPoolResults_VkResult_return = (VkResult)0; 580 vkGetQueryPoolResults_VkResult_return = vkEnc->vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); 581 return vkGetQueryPoolResults_VkResult_return; 582 } 583 static VkResult entry_vkCreateBuffer( 584 VkDevice device, 585 const VkBufferCreateInfo* pCreateInfo, 586 const VkAllocationCallbacks* pAllocator, 587 VkBuffer* pBuffer) 588 { 589 AEMU_SCOPED_TRACE("vkCreateBuffer"); 590 auto vkEnc = HostConnection::get()->vkEncoder(); 591 VkResult vkCreateBuffer_VkResult_return = (VkResult)0; 592 auto resources = ResourceTracker::get(); 593 vkCreateBuffer_VkResult_return = resources->on_vkCreateBuffer(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pBuffer); 594 return vkCreateBuffer_VkResult_return; 595 } 596 static void entry_vkDestroyBuffer( 597 VkDevice device, 598 VkBuffer buffer, 599 const VkAllocationCallbacks* pAllocator) 600 { 601 AEMU_SCOPED_TRACE("vkDestroyBuffer"); 602 auto vkEnc = HostConnection::get()->vkEncoder(); 603 auto resources = ResourceTracker::get(); 604 resources->on_vkDestroyBuffer(vkEnc, device, buffer, pAllocator); 605 } 606 static VkResult entry_vkCreateBufferView( 607 VkDevice device, 608 const VkBufferViewCreateInfo* pCreateInfo, 609 const VkAllocationCallbacks* pAllocator, 610 VkBufferView* pView) 611 { 612 AEMU_SCOPED_TRACE("vkCreateBufferView"); 613 auto vkEnc = HostConnection::get()->vkEncoder(); 614 VkResult vkCreateBufferView_VkResult_return = (VkResult)0; 615 vkCreateBufferView_VkResult_return = vkEnc->vkCreateBufferView(device, pCreateInfo, pAllocator, pView); 616 return vkCreateBufferView_VkResult_return; 617 } 618 static void entry_vkDestroyBufferView( 619 VkDevice device, 620 VkBufferView bufferView, 621 const VkAllocationCallbacks* pAllocator) 622 { 623 AEMU_SCOPED_TRACE("vkDestroyBufferView"); 624 auto vkEnc = HostConnection::get()->vkEncoder(); 625 vkEnc->vkDestroyBufferView(device, bufferView, pAllocator); 626 } 627 static VkResult entry_vkCreateImage( 628 VkDevice device, 629 const VkImageCreateInfo* pCreateInfo, 630 const VkAllocationCallbacks* pAllocator, 631 VkImage* pImage) 632 { 633 AEMU_SCOPED_TRACE("vkCreateImage"); 634 auto vkEnc = HostConnection::get()->vkEncoder(); 635 VkResult vkCreateImage_VkResult_return = (VkResult)0; 636 auto resources = ResourceTracker::get(); 637 vkCreateImage_VkResult_return = resources->on_vkCreateImage(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pImage); 638 return vkCreateImage_VkResult_return; 639 } 640 static void entry_vkDestroyImage( 641 VkDevice device, 642 VkImage image, 643 const VkAllocationCallbacks* pAllocator) 644 { 645 AEMU_SCOPED_TRACE("vkDestroyImage"); 646 auto vkEnc = HostConnection::get()->vkEncoder(); 647 auto resources = ResourceTracker::get(); 648 resources->on_vkDestroyImage(vkEnc, device, image, pAllocator); 649 } 650 static void entry_vkGetImageSubresourceLayout( 651 VkDevice device, 652 VkImage image, 653 const VkImageSubresource* pSubresource, 654 VkSubresourceLayout* pLayout) 655 { 656 AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout"); 657 auto vkEnc = HostConnection::get()->vkEncoder(); 658 vkEnc->vkGetImageSubresourceLayout(device, image, pSubresource, pLayout); 659 } 660 static VkResult entry_vkCreateImageView( 661 VkDevice device, 662 const VkImageViewCreateInfo* pCreateInfo, 663 const VkAllocationCallbacks* pAllocator, 664 VkImageView* pView) 665 { 666 AEMU_SCOPED_TRACE("vkCreateImageView"); 667 auto vkEnc = HostConnection::get()->vkEncoder(); 668 VkResult vkCreateImageView_VkResult_return = (VkResult)0; 669 auto resources = ResourceTracker::get(); 670 vkCreateImageView_VkResult_return = resources->on_vkCreateImageView(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pView); 671 return vkCreateImageView_VkResult_return; 672 } 673 static void entry_vkDestroyImageView( 674 VkDevice device, 675 VkImageView imageView, 676 const VkAllocationCallbacks* pAllocator) 677 { 678 AEMU_SCOPED_TRACE("vkDestroyImageView"); 679 auto vkEnc = HostConnection::get()->vkEncoder(); 680 vkEnc->vkDestroyImageView(device, imageView, pAllocator); 681 } 682 static VkResult entry_vkCreateShaderModule( 683 VkDevice device, 684 const VkShaderModuleCreateInfo* pCreateInfo, 685 const VkAllocationCallbacks* pAllocator, 686 VkShaderModule* pShaderModule) 687 { 688 AEMU_SCOPED_TRACE("vkCreateShaderModule"); 689 auto vkEnc = HostConnection::get()->vkEncoder(); 690 VkResult vkCreateShaderModule_VkResult_return = (VkResult)0; 691 vkCreateShaderModule_VkResult_return = vkEnc->vkCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule); 692 return vkCreateShaderModule_VkResult_return; 693 } 694 static void entry_vkDestroyShaderModule( 695 VkDevice device, 696 VkShaderModule shaderModule, 697 const VkAllocationCallbacks* pAllocator) 698 { 699 AEMU_SCOPED_TRACE("vkDestroyShaderModule"); 700 auto vkEnc = HostConnection::get()->vkEncoder(); 701 vkEnc->vkDestroyShaderModule(device, shaderModule, pAllocator); 702 } 703 static VkResult entry_vkCreatePipelineCache( 704 VkDevice device, 705 const VkPipelineCacheCreateInfo* pCreateInfo, 706 const VkAllocationCallbacks* pAllocator, 707 VkPipelineCache* pPipelineCache) 708 { 709 AEMU_SCOPED_TRACE("vkCreatePipelineCache"); 710 auto vkEnc = HostConnection::get()->vkEncoder(); 711 VkResult vkCreatePipelineCache_VkResult_return = (VkResult)0; 712 vkCreatePipelineCache_VkResult_return = vkEnc->vkCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); 713 return vkCreatePipelineCache_VkResult_return; 714 } 715 static void entry_vkDestroyPipelineCache( 716 VkDevice device, 717 VkPipelineCache pipelineCache, 718 const VkAllocationCallbacks* pAllocator) 719 { 720 AEMU_SCOPED_TRACE("vkDestroyPipelineCache"); 721 auto vkEnc = HostConnection::get()->vkEncoder(); 722 vkEnc->vkDestroyPipelineCache(device, pipelineCache, pAllocator); 723 } 724 static VkResult entry_vkGetPipelineCacheData( 725 VkDevice device, 726 VkPipelineCache pipelineCache, 727 size_t* pDataSize, 728 void* pData) 729 { 730 AEMU_SCOPED_TRACE("vkGetPipelineCacheData"); 731 auto vkEnc = HostConnection::get()->vkEncoder(); 732 VkResult vkGetPipelineCacheData_VkResult_return = (VkResult)0; 733 vkGetPipelineCacheData_VkResult_return = vkEnc->vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData); 734 return vkGetPipelineCacheData_VkResult_return; 735 } 736 static VkResult entry_vkMergePipelineCaches( 737 VkDevice device, 738 VkPipelineCache dstCache, 739 uint32_t srcCacheCount, 740 const VkPipelineCache* pSrcCaches) 741 { 742 AEMU_SCOPED_TRACE("vkMergePipelineCaches"); 743 auto vkEnc = HostConnection::get()->vkEncoder(); 744 VkResult vkMergePipelineCaches_VkResult_return = (VkResult)0; 745 vkMergePipelineCaches_VkResult_return = vkEnc->vkMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); 746 return vkMergePipelineCaches_VkResult_return; 747 } 748 static VkResult entry_vkCreateGraphicsPipelines( 749 VkDevice device, 750 VkPipelineCache pipelineCache, 751 uint32_t createInfoCount, 752 const VkGraphicsPipelineCreateInfo* pCreateInfos, 753 const VkAllocationCallbacks* pAllocator, 754 VkPipeline* pPipelines) 755 { 756 AEMU_SCOPED_TRACE("vkCreateGraphicsPipelines"); 757 auto vkEnc = HostConnection::get()->vkEncoder(); 758 VkResult vkCreateGraphicsPipelines_VkResult_return = (VkResult)0; 759 vkCreateGraphicsPipelines_VkResult_return = vkEnc->vkCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); 760 return vkCreateGraphicsPipelines_VkResult_return; 761 } 762 static VkResult entry_vkCreateComputePipelines( 763 VkDevice device, 764 VkPipelineCache pipelineCache, 765 uint32_t createInfoCount, 766 const VkComputePipelineCreateInfo* pCreateInfos, 767 const VkAllocationCallbacks* pAllocator, 768 VkPipeline* pPipelines) 769 { 770 AEMU_SCOPED_TRACE("vkCreateComputePipelines"); 771 auto vkEnc = HostConnection::get()->vkEncoder(); 772 VkResult vkCreateComputePipelines_VkResult_return = (VkResult)0; 773 vkCreateComputePipelines_VkResult_return = vkEnc->vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); 774 return vkCreateComputePipelines_VkResult_return; 775 } 776 static void entry_vkDestroyPipeline( 777 VkDevice device, 778 VkPipeline pipeline, 779 const VkAllocationCallbacks* pAllocator) 780 { 781 AEMU_SCOPED_TRACE("vkDestroyPipeline"); 782 auto vkEnc = HostConnection::get()->vkEncoder(); 783 vkEnc->vkDestroyPipeline(device, pipeline, pAllocator); 784 } 785 static VkResult entry_vkCreatePipelineLayout( 786 VkDevice device, 787 const VkPipelineLayoutCreateInfo* pCreateInfo, 788 const VkAllocationCallbacks* pAllocator, 789 VkPipelineLayout* pPipelineLayout) 790 { 791 AEMU_SCOPED_TRACE("vkCreatePipelineLayout"); 792 auto vkEnc = HostConnection::get()->vkEncoder(); 793 VkResult vkCreatePipelineLayout_VkResult_return = (VkResult)0; 794 vkCreatePipelineLayout_VkResult_return = vkEnc->vkCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); 795 return vkCreatePipelineLayout_VkResult_return; 796 } 797 static void entry_vkDestroyPipelineLayout( 798 VkDevice device, 799 VkPipelineLayout pipelineLayout, 800 const VkAllocationCallbacks* pAllocator) 801 { 802 AEMU_SCOPED_TRACE("vkDestroyPipelineLayout"); 803 auto vkEnc = HostConnection::get()->vkEncoder(); 804 vkEnc->vkDestroyPipelineLayout(device, pipelineLayout, pAllocator); 805 } 806 static VkResult entry_vkCreateSampler( 807 VkDevice device, 808 const VkSamplerCreateInfo* pCreateInfo, 809 const VkAllocationCallbacks* pAllocator, 810 VkSampler* pSampler) 811 { 812 AEMU_SCOPED_TRACE("vkCreateSampler"); 813 auto vkEnc = HostConnection::get()->vkEncoder(); 814 VkResult vkCreateSampler_VkResult_return = (VkResult)0; 815 vkCreateSampler_VkResult_return = vkEnc->vkCreateSampler(device, pCreateInfo, pAllocator, pSampler); 816 return vkCreateSampler_VkResult_return; 817 } 818 static void entry_vkDestroySampler( 819 VkDevice device, 820 VkSampler sampler, 821 const VkAllocationCallbacks* pAllocator) 822 { 823 AEMU_SCOPED_TRACE("vkDestroySampler"); 824 auto vkEnc = HostConnection::get()->vkEncoder(); 825 vkEnc->vkDestroySampler(device, sampler, pAllocator); 826 } 827 static VkResult entry_vkCreateDescriptorSetLayout( 828 VkDevice device, 829 const VkDescriptorSetLayoutCreateInfo* pCreateInfo, 830 const VkAllocationCallbacks* pAllocator, 831 VkDescriptorSetLayout* pSetLayout) 832 { 833 AEMU_SCOPED_TRACE("vkCreateDescriptorSetLayout"); 834 auto vkEnc = HostConnection::get()->vkEncoder(); 835 VkResult vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0; 836 vkCreateDescriptorSetLayout_VkResult_return = vkEnc->vkCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout); 837 return vkCreateDescriptorSetLayout_VkResult_return; 838 } 839 static void entry_vkDestroyDescriptorSetLayout( 840 VkDevice device, 841 VkDescriptorSetLayout descriptorSetLayout, 842 const VkAllocationCallbacks* pAllocator) 843 { 844 AEMU_SCOPED_TRACE("vkDestroyDescriptorSetLayout"); 845 auto vkEnc = HostConnection::get()->vkEncoder(); 846 vkEnc->vkDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); 847 } 848 static VkResult entry_vkCreateDescriptorPool( 849 VkDevice device, 850 const VkDescriptorPoolCreateInfo* pCreateInfo, 851 const VkAllocationCallbacks* pAllocator, 852 VkDescriptorPool* pDescriptorPool) 853 { 854 AEMU_SCOPED_TRACE("vkCreateDescriptorPool"); 855 auto vkEnc = HostConnection::get()->vkEncoder(); 856 VkResult vkCreateDescriptorPool_VkResult_return = (VkResult)0; 857 vkCreateDescriptorPool_VkResult_return = vkEnc->vkCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); 858 return vkCreateDescriptorPool_VkResult_return; 859 } 860 static void entry_vkDestroyDescriptorPool( 861 VkDevice device, 862 VkDescriptorPool descriptorPool, 863 const VkAllocationCallbacks* pAllocator) 864 { 865 AEMU_SCOPED_TRACE("vkDestroyDescriptorPool"); 866 auto vkEnc = HostConnection::get()->vkEncoder(); 867 vkEnc->vkDestroyDescriptorPool(device, descriptorPool, pAllocator); 868 } 869 static VkResult entry_vkResetDescriptorPool( 870 VkDevice device, 871 VkDescriptorPool descriptorPool, 872 VkDescriptorPoolResetFlags flags) 873 { 874 AEMU_SCOPED_TRACE("vkResetDescriptorPool"); 875 auto vkEnc = HostConnection::get()->vkEncoder(); 876 VkResult vkResetDescriptorPool_VkResult_return = (VkResult)0; 877 vkResetDescriptorPool_VkResult_return = vkEnc->vkResetDescriptorPool(device, descriptorPool, flags); 878 return vkResetDescriptorPool_VkResult_return; 879 } 880 static VkResult entry_vkAllocateDescriptorSets( 881 VkDevice device, 882 const VkDescriptorSetAllocateInfo* pAllocateInfo, 883 VkDescriptorSet* pDescriptorSets) 884 { 885 AEMU_SCOPED_TRACE("vkAllocateDescriptorSets"); 886 auto vkEnc = HostConnection::get()->vkEncoder(); 887 VkResult vkAllocateDescriptorSets_VkResult_return = (VkResult)0; 888 vkAllocateDescriptorSets_VkResult_return = vkEnc->vkAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); 889 return vkAllocateDescriptorSets_VkResult_return; 890 } 891 static VkResult entry_vkFreeDescriptorSets( 892 VkDevice device, 893 VkDescriptorPool descriptorPool, 894 uint32_t descriptorSetCount, 895 const VkDescriptorSet* pDescriptorSets) 896 { 897 AEMU_SCOPED_TRACE("vkFreeDescriptorSets"); 898 auto vkEnc = HostConnection::get()->vkEncoder(); 899 VkResult vkFreeDescriptorSets_VkResult_return = (VkResult)0; 900 vkFreeDescriptorSets_VkResult_return = vkEnc->vkFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); 901 return vkFreeDescriptorSets_VkResult_return; 902 } 903 static void entry_vkUpdateDescriptorSets( 904 VkDevice device, 905 uint32_t descriptorWriteCount, 906 const VkWriteDescriptorSet* pDescriptorWrites, 907 uint32_t descriptorCopyCount, 908 const VkCopyDescriptorSet* pDescriptorCopies) 909 { 910 AEMU_SCOPED_TRACE("vkUpdateDescriptorSets"); 911 auto vkEnc = HostConnection::get()->vkEncoder(); 912 vkEnc->vkUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); 913 } 914 static VkResult entry_vkCreateFramebuffer( 915 VkDevice device, 916 const VkFramebufferCreateInfo* pCreateInfo, 917 const VkAllocationCallbacks* pAllocator, 918 VkFramebuffer* pFramebuffer) 919 { 920 AEMU_SCOPED_TRACE("vkCreateFramebuffer"); 921 auto vkEnc = HostConnection::get()->vkEncoder(); 922 VkResult vkCreateFramebuffer_VkResult_return = (VkResult)0; 923 vkCreateFramebuffer_VkResult_return = vkEnc->vkCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); 924 return vkCreateFramebuffer_VkResult_return; 925 } 926 static void entry_vkDestroyFramebuffer( 927 VkDevice device, 928 VkFramebuffer framebuffer, 929 const VkAllocationCallbacks* pAllocator) 930 { 931 AEMU_SCOPED_TRACE("vkDestroyFramebuffer"); 932 auto vkEnc = HostConnection::get()->vkEncoder(); 933 vkEnc->vkDestroyFramebuffer(device, framebuffer, pAllocator); 934 } 935 static VkResult entry_vkCreateRenderPass( 936 VkDevice device, 937 const VkRenderPassCreateInfo* pCreateInfo, 938 const VkAllocationCallbacks* pAllocator, 939 VkRenderPass* pRenderPass) 940 { 941 AEMU_SCOPED_TRACE("vkCreateRenderPass"); 942 auto vkEnc = HostConnection::get()->vkEncoder(); 943 VkResult vkCreateRenderPass_VkResult_return = (VkResult)0; 944 vkCreateRenderPass_VkResult_return = vkEnc->vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); 945 return vkCreateRenderPass_VkResult_return; 946 } 947 static void entry_vkDestroyRenderPass( 948 VkDevice device, 949 VkRenderPass renderPass, 950 const VkAllocationCallbacks* pAllocator) 951 { 952 AEMU_SCOPED_TRACE("vkDestroyRenderPass"); 953 auto vkEnc = HostConnection::get()->vkEncoder(); 954 vkEnc->vkDestroyRenderPass(device, renderPass, pAllocator); 955 } 956 static void entry_vkGetRenderAreaGranularity( 957 VkDevice device, 958 VkRenderPass renderPass, 959 VkExtent2D* pGranularity) 960 { 961 AEMU_SCOPED_TRACE("vkGetRenderAreaGranularity"); 962 auto vkEnc = HostConnection::get()->vkEncoder(); 963 vkEnc->vkGetRenderAreaGranularity(device, renderPass, pGranularity); 964 } 965 static VkResult entry_vkCreateCommandPool( 966 VkDevice device, 967 const VkCommandPoolCreateInfo* pCreateInfo, 968 const VkAllocationCallbacks* pAllocator, 969 VkCommandPool* pCommandPool) 970 { 971 AEMU_SCOPED_TRACE("vkCreateCommandPool"); 972 auto vkEnc = HostConnection::get()->vkEncoder(); 973 VkResult vkCreateCommandPool_VkResult_return = (VkResult)0; 974 vkCreateCommandPool_VkResult_return = vkEnc->vkCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); 975 return vkCreateCommandPool_VkResult_return; 976 } 977 static void entry_vkDestroyCommandPool( 978 VkDevice device, 979 VkCommandPool commandPool, 980 const VkAllocationCallbacks* pAllocator) 981 { 982 AEMU_SCOPED_TRACE("vkDestroyCommandPool"); 983 auto vkEnc = HostConnection::get()->vkEncoder(); 984 vkEnc->vkDestroyCommandPool(device, commandPool, pAllocator); 985 } 986 static VkResult entry_vkResetCommandPool( 987 VkDevice device, 988 VkCommandPool commandPool, 989 VkCommandPoolResetFlags flags) 990 { 991 AEMU_SCOPED_TRACE("vkResetCommandPool"); 992 auto vkEnc = HostConnection::get()->vkEncoder(); 993 VkResult vkResetCommandPool_VkResult_return = (VkResult)0; 994 vkResetCommandPool_VkResult_return = vkEnc->vkResetCommandPool(device, commandPool, flags); 995 return vkResetCommandPool_VkResult_return; 996 } 997 static VkResult entry_vkAllocateCommandBuffers( 998 VkDevice device, 999 const VkCommandBufferAllocateInfo* pAllocateInfo, 1000 VkCommandBuffer* pCommandBuffers) 1001 { 1002 AEMU_SCOPED_TRACE("vkAllocateCommandBuffers"); 1003 auto vkEnc = HostConnection::get()->vkEncoder(); 1004 VkResult vkAllocateCommandBuffers_VkResult_return = (VkResult)0; 1005 vkAllocateCommandBuffers_VkResult_return = vkEnc->vkAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); 1006 return vkAllocateCommandBuffers_VkResult_return; 1007 } 1008 static void entry_vkFreeCommandBuffers( 1009 VkDevice device, 1010 VkCommandPool commandPool, 1011 uint32_t commandBufferCount, 1012 const VkCommandBuffer* pCommandBuffers) 1013 { 1014 AEMU_SCOPED_TRACE("vkFreeCommandBuffers"); 1015 auto vkEnc = HostConnection::get()->vkEncoder(); 1016 vkEnc->vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); 1017 } 1018 static VkResult entry_vkBeginCommandBuffer( 1019 VkCommandBuffer commandBuffer, 1020 const VkCommandBufferBeginInfo* pBeginInfo) 1021 { 1022 AEMU_SCOPED_TRACE("vkBeginCommandBuffer"); 1023 auto vkEnc = HostConnection::get()->vkEncoder(); 1024 VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0; 1025 auto resources = ResourceTracker::get(); 1026 vkBeginCommandBuffer_VkResult_return = resources->on_vkBeginCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer, pBeginInfo); 1027 return vkBeginCommandBuffer_VkResult_return; 1028 } 1029 static VkResult entry_vkEndCommandBuffer( 1030 VkCommandBuffer commandBuffer) 1031 { 1032 AEMU_SCOPED_TRACE("vkEndCommandBuffer"); 1033 auto vkEnc = HostConnection::get()->vkEncoder(); 1034 VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0; 1035 auto resources = ResourceTracker::get(); 1036 vkEndCommandBuffer_VkResult_return = resources->on_vkEndCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer); 1037 return vkEndCommandBuffer_VkResult_return; 1038 } 1039 static VkResult entry_vkResetCommandBuffer( 1040 VkCommandBuffer commandBuffer, 1041 VkCommandBufferResetFlags flags) 1042 { 1043 AEMU_SCOPED_TRACE("vkResetCommandBuffer"); 1044 auto vkEnc = HostConnection::get()->vkEncoder(); 1045 VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0; 1046 auto resources = ResourceTracker::get(); 1047 vkResetCommandBuffer_VkResult_return = resources->on_vkResetCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer, flags); 1048 return vkResetCommandBuffer_VkResult_return; 1049 } 1050 static void entry_vkCmdBindPipeline( 1051 VkCommandBuffer commandBuffer, 1052 VkPipelineBindPoint pipelineBindPoint, 1053 VkPipeline pipeline) 1054 { 1055 AEMU_SCOPED_TRACE("vkCmdBindPipeline"); 1056 auto vkEnc = HostConnection::get()->vkEncoder(); 1057 vkEnc->vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); 1058 } 1059 static void entry_vkCmdSetViewport( 1060 VkCommandBuffer commandBuffer, 1061 uint32_t firstViewport, 1062 uint32_t viewportCount, 1063 const VkViewport* pViewports) 1064 { 1065 AEMU_SCOPED_TRACE("vkCmdSetViewport"); 1066 auto vkEnc = HostConnection::get()->vkEncoder(); 1067 vkEnc->vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); 1068 } 1069 static void entry_vkCmdSetScissor( 1070 VkCommandBuffer commandBuffer, 1071 uint32_t firstScissor, 1072 uint32_t scissorCount, 1073 const VkRect2D* pScissors) 1074 { 1075 AEMU_SCOPED_TRACE("vkCmdSetScissor"); 1076 auto vkEnc = HostConnection::get()->vkEncoder(); 1077 vkEnc->vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); 1078 } 1079 static void entry_vkCmdSetLineWidth( 1080 VkCommandBuffer commandBuffer, 1081 float lineWidth) 1082 { 1083 AEMU_SCOPED_TRACE("vkCmdSetLineWidth"); 1084 auto vkEnc = HostConnection::get()->vkEncoder(); 1085 vkEnc->vkCmdSetLineWidth(commandBuffer, lineWidth); 1086 } 1087 static void entry_vkCmdSetDepthBias( 1088 VkCommandBuffer commandBuffer, 1089 float depthBiasConstantFactor, 1090 float depthBiasClamp, 1091 float depthBiasSlopeFactor) 1092 { 1093 AEMU_SCOPED_TRACE("vkCmdSetDepthBias"); 1094 auto vkEnc = HostConnection::get()->vkEncoder(); 1095 vkEnc->vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); 1096 } 1097 static void entry_vkCmdSetBlendConstants( 1098 VkCommandBuffer commandBuffer, 1099 const float blendConstants[4]) 1100 { 1101 AEMU_SCOPED_TRACE("vkCmdSetBlendConstants"); 1102 auto vkEnc = HostConnection::get()->vkEncoder(); 1103 vkEnc->vkCmdSetBlendConstants(commandBuffer, blendConstants); 1104 } 1105 static void entry_vkCmdSetDepthBounds( 1106 VkCommandBuffer commandBuffer, 1107 float minDepthBounds, 1108 float maxDepthBounds) 1109 { 1110 AEMU_SCOPED_TRACE("vkCmdSetDepthBounds"); 1111 auto vkEnc = HostConnection::get()->vkEncoder(); 1112 vkEnc->vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); 1113 } 1114 static void entry_vkCmdSetStencilCompareMask( 1115 VkCommandBuffer commandBuffer, 1116 VkStencilFaceFlags faceMask, 1117 uint32_t compareMask) 1118 { 1119 AEMU_SCOPED_TRACE("vkCmdSetStencilCompareMask"); 1120 auto vkEnc = HostConnection::get()->vkEncoder(); 1121 vkEnc->vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); 1122 } 1123 static void entry_vkCmdSetStencilWriteMask( 1124 VkCommandBuffer commandBuffer, 1125 VkStencilFaceFlags faceMask, 1126 uint32_t writeMask) 1127 { 1128 AEMU_SCOPED_TRACE("vkCmdSetStencilWriteMask"); 1129 auto vkEnc = HostConnection::get()->vkEncoder(); 1130 vkEnc->vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); 1131 } 1132 static void entry_vkCmdSetStencilReference( 1133 VkCommandBuffer commandBuffer, 1134 VkStencilFaceFlags faceMask, 1135 uint32_t reference) 1136 { 1137 AEMU_SCOPED_TRACE("vkCmdSetStencilReference"); 1138 auto vkEnc = HostConnection::get()->vkEncoder(); 1139 vkEnc->vkCmdSetStencilReference(commandBuffer, faceMask, reference); 1140 } 1141 static void entry_vkCmdBindDescriptorSets( 1142 VkCommandBuffer commandBuffer, 1143 VkPipelineBindPoint pipelineBindPoint, 1144 VkPipelineLayout layout, 1145 uint32_t firstSet, 1146 uint32_t descriptorSetCount, 1147 const VkDescriptorSet* pDescriptorSets, 1148 uint32_t dynamicOffsetCount, 1149 const uint32_t* pDynamicOffsets) 1150 { 1151 AEMU_SCOPED_TRACE("vkCmdBindDescriptorSets"); 1152 auto vkEnc = HostConnection::get()->vkEncoder(); 1153 vkEnc->vkCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); 1154 } 1155 static void entry_vkCmdBindIndexBuffer( 1156 VkCommandBuffer commandBuffer, 1157 VkBuffer buffer, 1158 VkDeviceSize offset, 1159 VkIndexType indexType) 1160 { 1161 AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer"); 1162 auto vkEnc = HostConnection::get()->vkEncoder(); 1163 vkEnc->vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); 1164 } 1165 static void entry_vkCmdBindVertexBuffers( 1166 VkCommandBuffer commandBuffer, 1167 uint32_t firstBinding, 1168 uint32_t bindingCount, 1169 const VkBuffer* pBuffers, 1170 const VkDeviceSize* pOffsets) 1171 { 1172 AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers"); 1173 auto vkEnc = HostConnection::get()->vkEncoder(); 1174 vkEnc->vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); 1175 } 1176 static void entry_vkCmdDraw( 1177 VkCommandBuffer commandBuffer, 1178 uint32_t vertexCount, 1179 uint32_t instanceCount, 1180 uint32_t firstVertex, 1181 uint32_t firstInstance) 1182 { 1183 AEMU_SCOPED_TRACE("vkCmdDraw"); 1184 auto vkEnc = HostConnection::get()->vkEncoder(); 1185 vkEnc->vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); 1186 } 1187 static void entry_vkCmdDrawIndexed( 1188 VkCommandBuffer commandBuffer, 1189 uint32_t indexCount, 1190 uint32_t instanceCount, 1191 uint32_t firstIndex, 1192 int32_t vertexOffset, 1193 uint32_t firstInstance) 1194 { 1195 AEMU_SCOPED_TRACE("vkCmdDrawIndexed"); 1196 auto vkEnc = HostConnection::get()->vkEncoder(); 1197 vkEnc->vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); 1198 } 1199 static void entry_vkCmdDrawIndirect( 1200 VkCommandBuffer commandBuffer, 1201 VkBuffer buffer, 1202 VkDeviceSize offset, 1203 uint32_t drawCount, 1204 uint32_t stride) 1205 { 1206 AEMU_SCOPED_TRACE("vkCmdDrawIndirect"); 1207 auto vkEnc = HostConnection::get()->vkEncoder(); 1208 vkEnc->vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); 1209 } 1210 static void entry_vkCmdDrawIndexedIndirect( 1211 VkCommandBuffer commandBuffer, 1212 VkBuffer buffer, 1213 VkDeviceSize offset, 1214 uint32_t drawCount, 1215 uint32_t stride) 1216 { 1217 AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect"); 1218 auto vkEnc = HostConnection::get()->vkEncoder(); 1219 vkEnc->vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); 1220 } 1221 static void entry_vkCmdDispatch( 1222 VkCommandBuffer commandBuffer, 1223 uint32_t groupCountX, 1224 uint32_t groupCountY, 1225 uint32_t groupCountZ) 1226 { 1227 AEMU_SCOPED_TRACE("vkCmdDispatch"); 1228 auto vkEnc = HostConnection::get()->vkEncoder(); 1229 vkEnc->vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ); 1230 } 1231 static void entry_vkCmdDispatchIndirect( 1232 VkCommandBuffer commandBuffer, 1233 VkBuffer buffer, 1234 VkDeviceSize offset) 1235 { 1236 AEMU_SCOPED_TRACE("vkCmdDispatchIndirect"); 1237 auto vkEnc = HostConnection::get()->vkEncoder(); 1238 vkEnc->vkCmdDispatchIndirect(commandBuffer, buffer, offset); 1239 } 1240 static void entry_vkCmdCopyBuffer( 1241 VkCommandBuffer commandBuffer, 1242 VkBuffer srcBuffer, 1243 VkBuffer dstBuffer, 1244 uint32_t regionCount, 1245 const VkBufferCopy* pRegions) 1246 { 1247 AEMU_SCOPED_TRACE("vkCmdCopyBuffer"); 1248 auto vkEnc = HostConnection::get()->vkEncoder(); 1249 vkEnc->vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); 1250 } 1251 static void entry_vkCmdCopyImage( 1252 VkCommandBuffer commandBuffer, 1253 VkImage srcImage, 1254 VkImageLayout srcImageLayout, 1255 VkImage dstImage, 1256 VkImageLayout dstImageLayout, 1257 uint32_t regionCount, 1258 const VkImageCopy* pRegions) 1259 { 1260 AEMU_SCOPED_TRACE("vkCmdCopyImage"); 1261 auto vkEnc = HostConnection::get()->vkEncoder(); 1262 vkEnc->vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); 1263 } 1264 static void entry_vkCmdBlitImage( 1265 VkCommandBuffer commandBuffer, 1266 VkImage srcImage, 1267 VkImageLayout srcImageLayout, 1268 VkImage dstImage, 1269 VkImageLayout dstImageLayout, 1270 uint32_t regionCount, 1271 const VkImageBlit* pRegions, 1272 VkFilter filter) 1273 { 1274 AEMU_SCOPED_TRACE("vkCmdBlitImage"); 1275 auto vkEnc = HostConnection::get()->vkEncoder(); 1276 vkEnc->vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); 1277 } 1278 static void entry_vkCmdCopyBufferToImage( 1279 VkCommandBuffer commandBuffer, 1280 VkBuffer srcBuffer, 1281 VkImage dstImage, 1282 VkImageLayout dstImageLayout, 1283 uint32_t regionCount, 1284 const VkBufferImageCopy* pRegions) 1285 { 1286 AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage"); 1287 auto vkEnc = HostConnection::get()->vkEncoder(); 1288 vkEnc->vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); 1289 } 1290 static void entry_vkCmdCopyImageToBuffer( 1291 VkCommandBuffer commandBuffer, 1292 VkImage srcImage, 1293 VkImageLayout srcImageLayout, 1294 VkBuffer dstBuffer, 1295 uint32_t regionCount, 1296 const VkBufferImageCopy* pRegions) 1297 { 1298 AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer"); 1299 auto vkEnc = HostConnection::get()->vkEncoder(); 1300 vkEnc->vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); 1301 } 1302 static void entry_vkCmdUpdateBuffer( 1303 VkCommandBuffer commandBuffer, 1304 VkBuffer dstBuffer, 1305 VkDeviceSize dstOffset, 1306 VkDeviceSize dataSize, 1307 const void* pData) 1308 { 1309 AEMU_SCOPED_TRACE("vkCmdUpdateBuffer"); 1310 auto vkEnc = HostConnection::get()->vkEncoder(); 1311 vkEnc->vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); 1312 } 1313 static void entry_vkCmdFillBuffer( 1314 VkCommandBuffer commandBuffer, 1315 VkBuffer dstBuffer, 1316 VkDeviceSize dstOffset, 1317 VkDeviceSize size, 1318 uint32_t data) 1319 { 1320 AEMU_SCOPED_TRACE("vkCmdFillBuffer"); 1321 auto vkEnc = HostConnection::get()->vkEncoder(); 1322 vkEnc->vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); 1323 } 1324 static void entry_vkCmdClearColorImage( 1325 VkCommandBuffer commandBuffer, 1326 VkImage image, 1327 VkImageLayout imageLayout, 1328 const VkClearColorValue* pColor, 1329 uint32_t rangeCount, 1330 const VkImageSubresourceRange* pRanges) 1331 { 1332 AEMU_SCOPED_TRACE("vkCmdClearColorImage"); 1333 auto vkEnc = HostConnection::get()->vkEncoder(); 1334 vkEnc->vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); 1335 } 1336 static void entry_vkCmdClearDepthStencilImage( 1337 VkCommandBuffer commandBuffer, 1338 VkImage image, 1339 VkImageLayout imageLayout, 1340 const VkClearDepthStencilValue* pDepthStencil, 1341 uint32_t rangeCount, 1342 const VkImageSubresourceRange* pRanges) 1343 { 1344 AEMU_SCOPED_TRACE("vkCmdClearDepthStencilImage"); 1345 auto vkEnc = HostConnection::get()->vkEncoder(); 1346 vkEnc->vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); 1347 } 1348 static void entry_vkCmdClearAttachments( 1349 VkCommandBuffer commandBuffer, 1350 uint32_t attachmentCount, 1351 const VkClearAttachment* pAttachments, 1352 uint32_t rectCount, 1353 const VkClearRect* pRects) 1354 { 1355 AEMU_SCOPED_TRACE("vkCmdClearAttachments"); 1356 auto vkEnc = HostConnection::get()->vkEncoder(); 1357 vkEnc->vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); 1358 } 1359 static void entry_vkCmdResolveImage( 1360 VkCommandBuffer commandBuffer, 1361 VkImage srcImage, 1362 VkImageLayout srcImageLayout, 1363 VkImage dstImage, 1364 VkImageLayout dstImageLayout, 1365 uint32_t regionCount, 1366 const VkImageResolve* pRegions) 1367 { 1368 AEMU_SCOPED_TRACE("vkCmdResolveImage"); 1369 auto vkEnc = HostConnection::get()->vkEncoder(); 1370 vkEnc->vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); 1371 } 1372 static void entry_vkCmdSetEvent( 1373 VkCommandBuffer commandBuffer, 1374 VkEvent event, 1375 VkPipelineStageFlags stageMask) 1376 { 1377 AEMU_SCOPED_TRACE("vkCmdSetEvent"); 1378 auto vkEnc = HostConnection::get()->vkEncoder(); 1379 vkEnc->vkCmdSetEvent(commandBuffer, event, stageMask); 1380 } 1381 static void entry_vkCmdResetEvent( 1382 VkCommandBuffer commandBuffer, 1383 VkEvent event, 1384 VkPipelineStageFlags stageMask) 1385 { 1386 AEMU_SCOPED_TRACE("vkCmdResetEvent"); 1387 auto vkEnc = HostConnection::get()->vkEncoder(); 1388 vkEnc->vkCmdResetEvent(commandBuffer, event, stageMask); 1389 } 1390 static void entry_vkCmdWaitEvents( 1391 VkCommandBuffer commandBuffer, 1392 uint32_t eventCount, 1393 const VkEvent* pEvents, 1394 VkPipelineStageFlags srcStageMask, 1395 VkPipelineStageFlags dstStageMask, 1396 uint32_t memoryBarrierCount, 1397 const VkMemoryBarrier* pMemoryBarriers, 1398 uint32_t bufferMemoryBarrierCount, 1399 const VkBufferMemoryBarrier* pBufferMemoryBarriers, 1400 uint32_t imageMemoryBarrierCount, 1401 const VkImageMemoryBarrier* pImageMemoryBarriers) 1402 { 1403 AEMU_SCOPED_TRACE("vkCmdWaitEvents"); 1404 auto vkEnc = HostConnection::get()->vkEncoder(); 1405 vkEnc->vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); 1406 } 1407 static void entry_vkCmdPipelineBarrier( 1408 VkCommandBuffer commandBuffer, 1409 VkPipelineStageFlags srcStageMask, 1410 VkPipelineStageFlags dstStageMask, 1411 VkDependencyFlags dependencyFlags, 1412 uint32_t memoryBarrierCount, 1413 const VkMemoryBarrier* pMemoryBarriers, 1414 uint32_t bufferMemoryBarrierCount, 1415 const VkBufferMemoryBarrier* pBufferMemoryBarriers, 1416 uint32_t imageMemoryBarrierCount, 1417 const VkImageMemoryBarrier* pImageMemoryBarriers) 1418 { 1419 AEMU_SCOPED_TRACE("vkCmdPipelineBarrier"); 1420 auto vkEnc = HostConnection::get()->vkEncoder(); 1421 vkEnc->vkCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); 1422 } 1423 static void entry_vkCmdBeginQuery( 1424 VkCommandBuffer commandBuffer, 1425 VkQueryPool queryPool, 1426 uint32_t query, 1427 VkQueryControlFlags flags) 1428 { 1429 AEMU_SCOPED_TRACE("vkCmdBeginQuery"); 1430 auto vkEnc = HostConnection::get()->vkEncoder(); 1431 vkEnc->vkCmdBeginQuery(commandBuffer, queryPool, query, flags); 1432 } 1433 static void entry_vkCmdEndQuery( 1434 VkCommandBuffer commandBuffer, 1435 VkQueryPool queryPool, 1436 uint32_t query) 1437 { 1438 AEMU_SCOPED_TRACE("vkCmdEndQuery"); 1439 auto vkEnc = HostConnection::get()->vkEncoder(); 1440 vkEnc->vkCmdEndQuery(commandBuffer, queryPool, query); 1441 } 1442 static void entry_vkCmdResetQueryPool( 1443 VkCommandBuffer commandBuffer, 1444 VkQueryPool queryPool, 1445 uint32_t firstQuery, 1446 uint32_t queryCount) 1447 { 1448 AEMU_SCOPED_TRACE("vkCmdResetQueryPool"); 1449 auto vkEnc = HostConnection::get()->vkEncoder(); 1450 vkEnc->vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); 1451 } 1452 static void entry_vkCmdWriteTimestamp( 1453 VkCommandBuffer commandBuffer, 1454 VkPipelineStageFlagBits pipelineStage, 1455 VkQueryPool queryPool, 1456 uint32_t query) 1457 { 1458 AEMU_SCOPED_TRACE("vkCmdWriteTimestamp"); 1459 auto vkEnc = HostConnection::get()->vkEncoder(); 1460 vkEnc->vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); 1461 } 1462 static void entry_vkCmdCopyQueryPoolResults( 1463 VkCommandBuffer commandBuffer, 1464 VkQueryPool queryPool, 1465 uint32_t firstQuery, 1466 uint32_t queryCount, 1467 VkBuffer dstBuffer, 1468 VkDeviceSize dstOffset, 1469 VkDeviceSize stride, 1470 VkQueryResultFlags flags) 1471 { 1472 AEMU_SCOPED_TRACE("vkCmdCopyQueryPoolResults"); 1473 auto vkEnc = HostConnection::get()->vkEncoder(); 1474 vkEnc->vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); 1475 } 1476 static void entry_vkCmdPushConstants( 1477 VkCommandBuffer commandBuffer, 1478 VkPipelineLayout layout, 1479 VkShaderStageFlags stageFlags, 1480 uint32_t offset, 1481 uint32_t size, 1482 const void* pValues) 1483 { 1484 AEMU_SCOPED_TRACE("vkCmdPushConstants"); 1485 auto vkEnc = HostConnection::get()->vkEncoder(); 1486 vkEnc->vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); 1487 } 1488 static void entry_vkCmdBeginRenderPass( 1489 VkCommandBuffer commandBuffer, 1490 const VkRenderPassBeginInfo* pRenderPassBegin, 1491 VkSubpassContents contents) 1492 { 1493 AEMU_SCOPED_TRACE("vkCmdBeginRenderPass"); 1494 auto vkEnc = HostConnection::get()->vkEncoder(); 1495 vkEnc->vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); 1496 } 1497 static void entry_vkCmdNextSubpass( 1498 VkCommandBuffer commandBuffer, 1499 VkSubpassContents contents) 1500 { 1501 AEMU_SCOPED_TRACE("vkCmdNextSubpass"); 1502 auto vkEnc = HostConnection::get()->vkEncoder(); 1503 vkEnc->vkCmdNextSubpass(commandBuffer, contents); 1504 } 1505 static void entry_vkCmdEndRenderPass( 1506 VkCommandBuffer commandBuffer) 1507 { 1508 AEMU_SCOPED_TRACE("vkCmdEndRenderPass"); 1509 auto vkEnc = HostConnection::get()->vkEncoder(); 1510 vkEnc->vkCmdEndRenderPass(commandBuffer); 1511 } 1512 static void entry_vkCmdExecuteCommands( 1513 VkCommandBuffer commandBuffer, 1514 uint32_t commandBufferCount, 1515 const VkCommandBuffer* pCommandBuffers) 1516 { 1517 AEMU_SCOPED_TRACE("vkCmdExecuteCommands"); 1518 auto vkEnc = HostConnection::get()->vkEncoder(); 1519 vkEnc->vkCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); 1520 } 1521 #endif 1522 #ifdef VK_VERSION_1_1 1523 static VkResult entry_vkEnumerateInstanceVersion( 1524 uint32_t* pApiVersion) 1525 { 1526 AEMU_SCOPED_TRACE("vkEnumerateInstanceVersion"); 1527 auto vkEnc = HostConnection::get()->vkEncoder(); 1528 VkResult vkEnumerateInstanceVersion_VkResult_return = (VkResult)0; 1529 vkEnumerateInstanceVersion_VkResult_return = vkEnc->vkEnumerateInstanceVersion(pApiVersion); 1530 return vkEnumerateInstanceVersion_VkResult_return; 1531 } 1532 static VkResult entry_vkBindBufferMemory2( 1533 VkDevice device, 1534 uint32_t bindInfoCount, 1535 const VkBindBufferMemoryInfo* pBindInfos) 1536 { 1537 AEMU_SCOPED_TRACE("vkBindBufferMemory2"); 1538 auto vkEnc = HostConnection::get()->vkEncoder(); 1539 VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0; 1540 auto resources = ResourceTracker::get(); 1541 vkBindBufferMemory2_VkResult_return = resources->on_vkBindBufferMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos); 1542 return vkBindBufferMemory2_VkResult_return; 1543 } 1544 static VkResult entry_vkBindImageMemory2( 1545 VkDevice device, 1546 uint32_t bindInfoCount, 1547 const VkBindImageMemoryInfo* pBindInfos) 1548 { 1549 AEMU_SCOPED_TRACE("vkBindImageMemory2"); 1550 auto vkEnc = HostConnection::get()->vkEncoder(); 1551 VkResult vkBindImageMemory2_VkResult_return = (VkResult)0; 1552 auto resources = ResourceTracker::get(); 1553 vkBindImageMemory2_VkResult_return = resources->on_vkBindImageMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos); 1554 return vkBindImageMemory2_VkResult_return; 1555 } 1556 static void entry_vkGetDeviceGroupPeerMemoryFeatures( 1557 VkDevice device, 1558 uint32_t heapIndex, 1559 uint32_t localDeviceIndex, 1560 uint32_t remoteDeviceIndex, 1561 VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) 1562 { 1563 AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures"); 1564 auto vkEnc = HostConnection::get()->vkEncoder(); 1565 vkEnc->vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); 1566 } 1567 static void entry_vkCmdSetDeviceMask( 1568 VkCommandBuffer commandBuffer, 1569 uint32_t deviceMask) 1570 { 1571 AEMU_SCOPED_TRACE("vkCmdSetDeviceMask"); 1572 auto vkEnc = HostConnection::get()->vkEncoder(); 1573 vkEnc->vkCmdSetDeviceMask(commandBuffer, deviceMask); 1574 } 1575 static void entry_vkCmdDispatchBase( 1576 VkCommandBuffer commandBuffer, 1577 uint32_t baseGroupX, 1578 uint32_t baseGroupY, 1579 uint32_t baseGroupZ, 1580 uint32_t groupCountX, 1581 uint32_t groupCountY, 1582 uint32_t groupCountZ) 1583 { 1584 AEMU_SCOPED_TRACE("vkCmdDispatchBase"); 1585 auto vkEnc = HostConnection::get()->vkEncoder(); 1586 vkEnc->vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); 1587 } 1588 static VkResult entry_vkEnumeratePhysicalDeviceGroups( 1589 VkInstance instance, 1590 uint32_t* pPhysicalDeviceGroupCount, 1591 VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) 1592 { 1593 AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroups"); 1594 auto vkEnc = HostConnection::get()->vkEncoder(); 1595 VkResult vkEnumeratePhysicalDeviceGroups_VkResult_return = (VkResult)0; 1596 vkEnumeratePhysicalDeviceGroups_VkResult_return = vkEnc->vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); 1597 return vkEnumeratePhysicalDeviceGroups_VkResult_return; 1598 } 1599 static void entry_vkGetImageMemoryRequirements2( 1600 VkDevice device, 1601 const VkImageMemoryRequirementsInfo2* pInfo, 1602 VkMemoryRequirements2* pMemoryRequirements) 1603 { 1604 AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2"); 1605 auto vkEnc = HostConnection::get()->vkEncoder(); 1606 auto resources = ResourceTracker::get(); 1607 resources->on_vkGetImageMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements); 1608 } 1609 static void entry_vkGetBufferMemoryRequirements2( 1610 VkDevice device, 1611 const VkBufferMemoryRequirementsInfo2* pInfo, 1612 VkMemoryRequirements2* pMemoryRequirements) 1613 { 1614 AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2"); 1615 auto vkEnc = HostConnection::get()->vkEncoder(); 1616 auto resources = ResourceTracker::get(); 1617 resources->on_vkGetBufferMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements); 1618 } 1619 static void entry_vkGetImageSparseMemoryRequirements2( 1620 VkDevice device, 1621 const VkImageSparseMemoryRequirementsInfo2* pInfo, 1622 uint32_t* pSparseMemoryRequirementCount, 1623 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) 1624 { 1625 AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2"); 1626 auto vkEnc = HostConnection::get()->vkEncoder(); 1627 vkEnc->vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); 1628 } 1629 static void entry_vkGetPhysicalDeviceFeatures2( 1630 VkPhysicalDevice physicalDevice, 1631 VkPhysicalDeviceFeatures2* pFeatures) 1632 { 1633 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2"); 1634 auto vkEnc = HostConnection::get()->vkEncoder(); 1635 vkEnc->vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures); 1636 } 1637 static void entry_vkGetPhysicalDeviceProperties2( 1638 VkPhysicalDevice physicalDevice, 1639 VkPhysicalDeviceProperties2* pProperties) 1640 { 1641 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2"); 1642 auto vkEnc = HostConnection::get()->vkEncoder(); 1643 vkEnc->vkGetPhysicalDeviceProperties2(physicalDevice, pProperties); 1644 } 1645 static void entry_vkGetPhysicalDeviceFormatProperties2( 1646 VkPhysicalDevice physicalDevice, 1647 VkFormat format, 1648 VkFormatProperties2* pFormatProperties) 1649 { 1650 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2"); 1651 auto vkEnc = HostConnection::get()->vkEncoder(); 1652 vkEnc->vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties); 1653 } 1654 static VkResult entry_vkGetPhysicalDeviceImageFormatProperties2( 1655 VkPhysicalDevice physicalDevice, 1656 const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, 1657 VkImageFormatProperties2* pImageFormatProperties) 1658 { 1659 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2"); 1660 auto vkEnc = HostConnection::get()->vkEncoder(); 1661 VkResult vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = (VkResult)0; 1662 auto resources = ResourceTracker::get(); 1663 vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = resources->on_vkGetPhysicalDeviceImageFormatProperties2(vkEnc, VK_SUCCESS, physicalDevice, pImageFormatInfo, pImageFormatProperties); 1664 return vkGetPhysicalDeviceImageFormatProperties2_VkResult_return; 1665 } 1666 static void entry_vkGetPhysicalDeviceQueueFamilyProperties2( 1667 VkPhysicalDevice physicalDevice, 1668 uint32_t* pQueueFamilyPropertyCount, 1669 VkQueueFamilyProperties2* pQueueFamilyProperties) 1670 { 1671 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2"); 1672 auto vkEnc = HostConnection::get()->vkEncoder(); 1673 vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); 1674 } 1675 static void entry_vkGetPhysicalDeviceMemoryProperties2( 1676 VkPhysicalDevice physicalDevice, 1677 VkPhysicalDeviceMemoryProperties2* pMemoryProperties) 1678 { 1679 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2"); 1680 auto vkEnc = HostConnection::get()->vkEncoder(); 1681 vkEnc->vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties); 1682 } 1683 static void entry_vkGetPhysicalDeviceSparseImageFormatProperties2( 1684 VkPhysicalDevice physicalDevice, 1685 const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, 1686 uint32_t* pPropertyCount, 1687 VkSparseImageFormatProperties2* pProperties) 1688 { 1689 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2"); 1690 auto vkEnc = HostConnection::get()->vkEncoder(); 1691 vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties); 1692 } 1693 static void entry_vkTrimCommandPool( 1694 VkDevice device, 1695 VkCommandPool commandPool, 1696 VkCommandPoolTrimFlags flags) 1697 { 1698 AEMU_SCOPED_TRACE("vkTrimCommandPool"); 1699 auto vkEnc = HostConnection::get()->vkEncoder(); 1700 vkEnc->vkTrimCommandPool(device, commandPool, flags); 1701 } 1702 static void entry_vkGetDeviceQueue2( 1703 VkDevice device, 1704 const VkDeviceQueueInfo2* pQueueInfo, 1705 VkQueue* pQueue) 1706 { 1707 AEMU_SCOPED_TRACE("vkGetDeviceQueue2"); 1708 auto vkEnc = HostConnection::get()->vkEncoder(); 1709 vkEnc->vkGetDeviceQueue2(device, pQueueInfo, pQueue); 1710 } 1711 static VkResult entry_vkCreateSamplerYcbcrConversion( 1712 VkDevice device, 1713 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, 1714 const VkAllocationCallbacks* pAllocator, 1715 VkSamplerYcbcrConversion* pYcbcrConversion) 1716 { 1717 AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion"); 1718 auto vkEnc = HostConnection::get()->vkEncoder(); 1719 VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0; 1720 auto resources = ResourceTracker::get(); 1721 vkCreateSamplerYcbcrConversion_VkResult_return = resources->on_vkCreateSamplerYcbcrConversion(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pYcbcrConversion); 1722 return vkCreateSamplerYcbcrConversion_VkResult_return; 1723 } 1724 static void entry_vkDestroySamplerYcbcrConversion( 1725 VkDevice device, 1726 VkSamplerYcbcrConversion ycbcrConversion, 1727 const VkAllocationCallbacks* pAllocator) 1728 { 1729 AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion"); 1730 auto vkEnc = HostConnection::get()->vkEncoder(); 1731 vkEnc->vkDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator); 1732 } 1733 static VkResult entry_vkCreateDescriptorUpdateTemplate( 1734 VkDevice device, 1735 const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, 1736 const VkAllocationCallbacks* pAllocator, 1737 VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) 1738 { 1739 AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate"); 1740 auto vkEnc = HostConnection::get()->vkEncoder(); 1741 VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0; 1742 vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); 1743 return vkCreateDescriptorUpdateTemplate_VkResult_return; 1744 } 1745 static void entry_vkDestroyDescriptorUpdateTemplate( 1746 VkDevice device, 1747 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 1748 const VkAllocationCallbacks* pAllocator) 1749 { 1750 AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate"); 1751 auto vkEnc = HostConnection::get()->vkEncoder(); 1752 vkEnc->vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator); 1753 } 1754 static void entry_vkUpdateDescriptorSetWithTemplate( 1755 VkDevice device, 1756 VkDescriptorSet descriptorSet, 1757 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 1758 const void* pData) 1759 { 1760 AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate"); 1761 auto vkEnc = HostConnection::get()->vkEncoder(); 1762 auto resources = ResourceTracker::get(); 1763 resources->on_vkUpdateDescriptorSetWithTemplate(vkEnc, device, descriptorSet, descriptorUpdateTemplate, pData); 1764 } 1765 static void entry_vkGetPhysicalDeviceExternalBufferProperties( 1766 VkPhysicalDevice physicalDevice, 1767 const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, 1768 VkExternalBufferProperties* pExternalBufferProperties) 1769 { 1770 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferProperties"); 1771 auto vkEnc = HostConnection::get()->vkEncoder(); 1772 vkEnc->vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); 1773 } 1774 static void entry_vkGetPhysicalDeviceExternalFenceProperties( 1775 VkPhysicalDevice physicalDevice, 1776 const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, 1777 VkExternalFenceProperties* pExternalFenceProperties) 1778 { 1779 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFenceProperties"); 1780 auto vkEnc = HostConnection::get()->vkEncoder(); 1781 vkEnc->vkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); 1782 } 1783 static void entry_vkGetPhysicalDeviceExternalSemaphoreProperties( 1784 VkPhysicalDevice physicalDevice, 1785 const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, 1786 VkExternalSemaphoreProperties* pExternalSemaphoreProperties) 1787 { 1788 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphoreProperties"); 1789 auto vkEnc = HostConnection::get()->vkEncoder(); 1790 vkEnc->vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); 1791 } 1792 static void entry_vkGetDescriptorSetLayoutSupport( 1793 VkDevice device, 1794 const VkDescriptorSetLayoutCreateInfo* pCreateInfo, 1795 VkDescriptorSetLayoutSupport* pSupport) 1796 { 1797 AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport"); 1798 auto vkEnc = HostConnection::get()->vkEncoder(); 1799 vkEnc->vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); 1800 } 1801 #endif 1802 #ifdef VK_KHR_surface 1803 static void entry_vkDestroySurfaceKHR( 1804 VkInstance instance, 1805 VkSurfaceKHR surface, 1806 const VkAllocationCallbacks* pAllocator) 1807 { 1808 AEMU_SCOPED_TRACE("vkDestroySurfaceKHR"); 1809 auto vkEnc = HostConnection::get()->vkEncoder(); 1810 vkEnc->vkDestroySurfaceKHR(instance, surface, pAllocator); 1811 } 1812 static VkResult entry_vkGetPhysicalDeviceSurfaceSupportKHR( 1813 VkPhysicalDevice physicalDevice, 1814 uint32_t queueFamilyIndex, 1815 VkSurfaceKHR surface, 1816 VkBool32* pSupported) 1817 { 1818 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceSupportKHR"); 1819 auto vkEnc = HostConnection::get()->vkEncoder(); 1820 VkResult vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = (VkResult)0; 1821 vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); 1822 return vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return; 1823 } 1824 static VkResult entry_vkGetPhysicalDeviceSurfaceCapabilitiesKHR( 1825 VkPhysicalDevice physicalDevice, 1826 VkSurfaceKHR surface, 1827 VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) 1828 { 1829 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilitiesKHR"); 1830 auto vkEnc = HostConnection::get()->vkEncoder(); 1831 VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = (VkResult)0; 1832 vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); 1833 return vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return; 1834 } 1835 static VkResult entry_vkGetPhysicalDeviceSurfaceFormatsKHR( 1836 VkPhysicalDevice physicalDevice, 1837 VkSurfaceKHR surface, 1838 uint32_t* pSurfaceFormatCount, 1839 VkSurfaceFormatKHR* pSurfaceFormats) 1840 { 1841 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormatsKHR"); 1842 auto vkEnc = HostConnection::get()->vkEncoder(); 1843 VkResult vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = (VkResult)0; 1844 vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); 1845 return vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return; 1846 } 1847 static VkResult entry_vkGetPhysicalDeviceSurfacePresentModesKHR( 1848 VkPhysicalDevice physicalDevice, 1849 VkSurfaceKHR surface, 1850 uint32_t* pPresentModeCount, 1851 VkPresentModeKHR* pPresentModes) 1852 { 1853 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfacePresentModesKHR"); 1854 auto vkEnc = HostConnection::get()->vkEncoder(); 1855 VkResult vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = (VkResult)0; 1856 vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes); 1857 return vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return; 1858 } 1859 #endif 1860 #ifdef VK_KHR_swapchain 1861 static VkResult entry_vkCreateSwapchainKHR( 1862 VkDevice device, 1863 const VkSwapchainCreateInfoKHR* pCreateInfo, 1864 const VkAllocationCallbacks* pAllocator, 1865 VkSwapchainKHR* pSwapchain) 1866 { 1867 AEMU_SCOPED_TRACE("vkCreateSwapchainKHR"); 1868 auto vkEnc = HostConnection::get()->vkEncoder(); 1869 VkResult vkCreateSwapchainKHR_VkResult_return = (VkResult)0; 1870 vkCreateSwapchainKHR_VkResult_return = vkEnc->vkCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); 1871 return vkCreateSwapchainKHR_VkResult_return; 1872 } 1873 static void entry_vkDestroySwapchainKHR( 1874 VkDevice device, 1875 VkSwapchainKHR swapchain, 1876 const VkAllocationCallbacks* pAllocator) 1877 { 1878 AEMU_SCOPED_TRACE("vkDestroySwapchainKHR"); 1879 auto vkEnc = HostConnection::get()->vkEncoder(); 1880 vkEnc->vkDestroySwapchainKHR(device, swapchain, pAllocator); 1881 } 1882 static VkResult entry_vkGetSwapchainImagesKHR( 1883 VkDevice device, 1884 VkSwapchainKHR swapchain, 1885 uint32_t* pSwapchainImageCount, 1886 VkImage* pSwapchainImages) 1887 { 1888 AEMU_SCOPED_TRACE("vkGetSwapchainImagesKHR"); 1889 auto vkEnc = HostConnection::get()->vkEncoder(); 1890 VkResult vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0; 1891 vkGetSwapchainImagesKHR_VkResult_return = vkEnc->vkGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); 1892 return vkGetSwapchainImagesKHR_VkResult_return; 1893 } 1894 static VkResult entry_vkAcquireNextImageKHR( 1895 VkDevice device, 1896 VkSwapchainKHR swapchain, 1897 uint64_t timeout, 1898 VkSemaphore semaphore, 1899 VkFence fence, 1900 uint32_t* pImageIndex) 1901 { 1902 AEMU_SCOPED_TRACE("vkAcquireNextImageKHR"); 1903 auto vkEnc = HostConnection::get()->vkEncoder(); 1904 VkResult vkAcquireNextImageKHR_VkResult_return = (VkResult)0; 1905 vkAcquireNextImageKHR_VkResult_return = vkEnc->vkAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); 1906 return vkAcquireNextImageKHR_VkResult_return; 1907 } 1908 static VkResult entry_vkQueuePresentKHR( 1909 VkQueue queue, 1910 const VkPresentInfoKHR* pPresentInfo) 1911 { 1912 AEMU_SCOPED_TRACE("vkQueuePresentKHR"); 1913 auto vkEnc = HostConnection::get()->vkEncoder(); 1914 VkResult vkQueuePresentKHR_VkResult_return = (VkResult)0; 1915 vkQueuePresentKHR_VkResult_return = vkEnc->vkQueuePresentKHR(queue, pPresentInfo); 1916 return vkQueuePresentKHR_VkResult_return; 1917 } 1918 static VkResult entry_vkGetDeviceGroupPresentCapabilitiesKHR( 1919 VkDevice device, 1920 VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) 1921 { 1922 AEMU_SCOPED_TRACE("vkGetDeviceGroupPresentCapabilitiesKHR"); 1923 auto vkEnc = HostConnection::get()->vkEncoder(); 1924 VkResult vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = (VkResult)0; 1925 vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = vkEnc->vkGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities); 1926 return vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return; 1927 } 1928 static VkResult entry_vkGetDeviceGroupSurfacePresentModesKHR( 1929 VkDevice device, 1930 VkSurfaceKHR surface, 1931 VkDeviceGroupPresentModeFlagsKHR* pModes) 1932 { 1933 AEMU_SCOPED_TRACE("vkGetDeviceGroupSurfacePresentModesKHR"); 1934 auto vkEnc = HostConnection::get()->vkEncoder(); 1935 VkResult vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = (VkResult)0; 1936 vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = vkEnc->vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes); 1937 return vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return; 1938 } 1939 static VkResult entry_vkGetPhysicalDevicePresentRectanglesKHR( 1940 VkPhysicalDevice physicalDevice, 1941 VkSurfaceKHR surface, 1942 uint32_t* pRectCount, 1943 VkRect2D* pRects) 1944 { 1945 AEMU_SCOPED_TRACE("vkGetPhysicalDevicePresentRectanglesKHR"); 1946 auto vkEnc = HostConnection::get()->vkEncoder(); 1947 VkResult vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = (VkResult)0; 1948 vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = vkEnc->vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects); 1949 return vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return; 1950 } 1951 static VkResult entry_vkAcquireNextImage2KHR( 1952 VkDevice device, 1953 const VkAcquireNextImageInfoKHR* pAcquireInfo, 1954 uint32_t* pImageIndex) 1955 { 1956 AEMU_SCOPED_TRACE("vkAcquireNextImage2KHR"); 1957 auto vkEnc = HostConnection::get()->vkEncoder(); 1958 VkResult vkAcquireNextImage2KHR_VkResult_return = (VkResult)0; 1959 vkAcquireNextImage2KHR_VkResult_return = vkEnc->vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex); 1960 return vkAcquireNextImage2KHR_VkResult_return; 1961 } 1962 #endif 1963 #ifdef VK_KHR_display 1964 static VkResult entry_vkGetPhysicalDeviceDisplayPropertiesKHR( 1965 VkPhysicalDevice physicalDevice, 1966 uint32_t* pPropertyCount, 1967 VkDisplayPropertiesKHR* pProperties) 1968 { 1969 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPropertiesKHR"); 1970 auto vkEnc = HostConnection::get()->vkEncoder(); 1971 VkResult vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = (VkResult)0; 1972 vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties); 1973 return vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return; 1974 } 1975 static VkResult entry_vkGetPhysicalDeviceDisplayPlanePropertiesKHR( 1976 VkPhysicalDevice physicalDevice, 1977 uint32_t* pPropertyCount, 1978 VkDisplayPlanePropertiesKHR* pProperties) 1979 { 1980 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlanePropertiesKHR"); 1981 auto vkEnc = HostConnection::get()->vkEncoder(); 1982 VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = (VkResult)0; 1983 vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties); 1984 return vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return; 1985 } 1986 static VkResult entry_vkGetDisplayPlaneSupportedDisplaysKHR( 1987 VkPhysicalDevice physicalDevice, 1988 uint32_t planeIndex, 1989 uint32_t* pDisplayCount, 1990 VkDisplayKHR* pDisplays) 1991 { 1992 AEMU_SCOPED_TRACE("vkGetDisplayPlaneSupportedDisplaysKHR"); 1993 auto vkEnc = HostConnection::get()->vkEncoder(); 1994 VkResult vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = (VkResult)0; 1995 vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = vkEnc->vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays); 1996 return vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return; 1997 } 1998 static VkResult entry_vkGetDisplayModePropertiesKHR( 1999 VkPhysicalDevice physicalDevice, 2000 VkDisplayKHR display, 2001 uint32_t* pPropertyCount, 2002 VkDisplayModePropertiesKHR* pProperties) 2003 { 2004 AEMU_SCOPED_TRACE("vkGetDisplayModePropertiesKHR"); 2005 auto vkEnc = HostConnection::get()->vkEncoder(); 2006 VkResult vkGetDisplayModePropertiesKHR_VkResult_return = (VkResult)0; 2007 vkGetDisplayModePropertiesKHR_VkResult_return = vkEnc->vkGetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties); 2008 return vkGetDisplayModePropertiesKHR_VkResult_return; 2009 } 2010 static VkResult entry_vkCreateDisplayModeKHR( 2011 VkPhysicalDevice physicalDevice, 2012 VkDisplayKHR display, 2013 const VkDisplayModeCreateInfoKHR* pCreateInfo, 2014 const VkAllocationCallbacks* pAllocator, 2015 VkDisplayModeKHR* pMode) 2016 { 2017 AEMU_SCOPED_TRACE("vkCreateDisplayModeKHR"); 2018 auto vkEnc = HostConnection::get()->vkEncoder(); 2019 VkResult vkCreateDisplayModeKHR_VkResult_return = (VkResult)0; 2020 vkCreateDisplayModeKHR_VkResult_return = vkEnc->vkCreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode); 2021 return vkCreateDisplayModeKHR_VkResult_return; 2022 } 2023 static VkResult entry_vkGetDisplayPlaneCapabilitiesKHR( 2024 VkPhysicalDevice physicalDevice, 2025 VkDisplayModeKHR mode, 2026 uint32_t planeIndex, 2027 VkDisplayPlaneCapabilitiesKHR* pCapabilities) 2028 { 2029 AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilitiesKHR"); 2030 auto vkEnc = HostConnection::get()->vkEncoder(); 2031 VkResult vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = (VkResult)0; 2032 vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = vkEnc->vkGetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities); 2033 return vkGetDisplayPlaneCapabilitiesKHR_VkResult_return; 2034 } 2035 static VkResult entry_vkCreateDisplayPlaneSurfaceKHR( 2036 VkInstance instance, 2037 const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, 2038 const VkAllocationCallbacks* pAllocator, 2039 VkSurfaceKHR* pSurface) 2040 { 2041 AEMU_SCOPED_TRACE("vkCreateDisplayPlaneSurfaceKHR"); 2042 auto vkEnc = HostConnection::get()->vkEncoder(); 2043 VkResult vkCreateDisplayPlaneSurfaceKHR_VkResult_return = (VkResult)0; 2044 vkCreateDisplayPlaneSurfaceKHR_VkResult_return = vkEnc->vkCreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); 2045 return vkCreateDisplayPlaneSurfaceKHR_VkResult_return; 2046 } 2047 #endif 2048 #ifdef VK_KHR_display_swapchain 2049 static VkResult entry_vkCreateSharedSwapchainsKHR( 2050 VkDevice device, 2051 uint32_t swapchainCount, 2052 const VkSwapchainCreateInfoKHR* pCreateInfos, 2053 const VkAllocationCallbacks* pAllocator, 2054 VkSwapchainKHR* pSwapchains) 2055 { 2056 AEMU_SCOPED_TRACE("vkCreateSharedSwapchainsKHR"); 2057 auto vkEnc = HostConnection::get()->vkEncoder(); 2058 VkResult vkCreateSharedSwapchainsKHR_VkResult_return = (VkResult)0; 2059 vkCreateSharedSwapchainsKHR_VkResult_return = vkEnc->vkCreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); 2060 return vkCreateSharedSwapchainsKHR_VkResult_return; 2061 } 2062 #endif 2063 #ifdef VK_KHR_xlib_surface 2064 static VkResult entry_vkCreateXlibSurfaceKHR( 2065 VkInstance instance, 2066 const VkXlibSurfaceCreateInfoKHR* pCreateInfo, 2067 const VkAllocationCallbacks* pAllocator, 2068 VkSurfaceKHR* pSurface) 2069 { 2070 AEMU_SCOPED_TRACE("vkCreateXlibSurfaceKHR"); 2071 auto vkEnc = HostConnection::get()->vkEncoder(); 2072 VkResult vkCreateXlibSurfaceKHR_VkResult_return = (VkResult)0; 2073 vkCreateXlibSurfaceKHR_VkResult_return = vkEnc->vkCreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); 2074 return vkCreateXlibSurfaceKHR_VkResult_return; 2075 } 2076 static VkBool32 entry_vkGetPhysicalDeviceXlibPresentationSupportKHR( 2077 VkPhysicalDevice physicalDevice, 2078 uint32_t queueFamilyIndex, 2079 Display* dpy, 2080 VisualID visualID) 2081 { 2082 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXlibPresentationSupportKHR"); 2083 auto vkEnc = HostConnection::get()->vkEncoder(); 2084 VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = (VkBool32)0; 2085 vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID); 2086 return vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return; 2087 } 2088 #endif 2089 #ifdef VK_KHR_xcb_surface 2090 static VkResult entry_vkCreateXcbSurfaceKHR( 2091 VkInstance instance, 2092 const VkXcbSurfaceCreateInfoKHR* pCreateInfo, 2093 const VkAllocationCallbacks* pAllocator, 2094 VkSurfaceKHR* pSurface) 2095 { 2096 AEMU_SCOPED_TRACE("vkCreateXcbSurfaceKHR"); 2097 auto vkEnc = HostConnection::get()->vkEncoder(); 2098 VkResult vkCreateXcbSurfaceKHR_VkResult_return = (VkResult)0; 2099 vkCreateXcbSurfaceKHR_VkResult_return = vkEnc->vkCreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); 2100 return vkCreateXcbSurfaceKHR_VkResult_return; 2101 } 2102 static VkBool32 entry_vkGetPhysicalDeviceXcbPresentationSupportKHR( 2103 VkPhysicalDevice physicalDevice, 2104 uint32_t queueFamilyIndex, 2105 xcb_connection_t* connection, 2106 xcb_visualid_t visual_id) 2107 { 2108 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXcbPresentationSupportKHR"); 2109 auto vkEnc = HostConnection::get()->vkEncoder(); 2110 VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = (VkBool32)0; 2111 vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id); 2112 return vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return; 2113 } 2114 #endif 2115 #ifdef VK_KHR_wayland_surface 2116 static VkResult entry_vkCreateWaylandSurfaceKHR( 2117 VkInstance instance, 2118 const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, 2119 const VkAllocationCallbacks* pAllocator, 2120 VkSurfaceKHR* pSurface) 2121 { 2122 AEMU_SCOPED_TRACE("vkCreateWaylandSurfaceKHR"); 2123 auto vkEnc = HostConnection::get()->vkEncoder(); 2124 VkResult vkCreateWaylandSurfaceKHR_VkResult_return = (VkResult)0; 2125 vkCreateWaylandSurfaceKHR_VkResult_return = vkEnc->vkCreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); 2126 return vkCreateWaylandSurfaceKHR_VkResult_return; 2127 } 2128 static VkBool32 entry_vkGetPhysicalDeviceWaylandPresentationSupportKHR( 2129 VkPhysicalDevice physicalDevice, 2130 uint32_t queueFamilyIndex, 2131 wl_display* display) 2132 { 2133 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWaylandPresentationSupportKHR"); 2134 auto vkEnc = HostConnection::get()->vkEncoder(); 2135 VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return = (VkBool32)0; 2136 vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display); 2137 return vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return; 2138 } 2139 #endif 2140 #ifdef VK_KHR_mir_surface 2141 static VkResult entry_vkCreateMirSurfaceKHR( 2142 VkInstance instance, 2143 const VkMirSurfaceCreateInfoKHR* pCreateInfo, 2144 const VkAllocationCallbacks* pAllocator, 2145 VkSurfaceKHR* pSurface) 2146 { 2147 AEMU_SCOPED_TRACE("vkCreateMirSurfaceKHR"); 2148 auto vkEnc = HostConnection::get()->vkEncoder(); 2149 VkResult vkCreateMirSurfaceKHR_VkResult_return = (VkResult)0; 2150 vkCreateMirSurfaceKHR_VkResult_return = vkEnc->vkCreateMirSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); 2151 return vkCreateMirSurfaceKHR_VkResult_return; 2152 } 2153 static VkBool32 entry_vkGetPhysicalDeviceMirPresentationSupportKHR( 2154 VkPhysicalDevice physicalDevice, 2155 uint32_t queueFamilyIndex, 2156 MirConnection* connection) 2157 { 2158 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMirPresentationSupportKHR"); 2159 auto vkEnc = HostConnection::get()->vkEncoder(); 2160 VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return = (VkBool32)0; 2161 vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceMirPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection); 2162 return vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return; 2163 } 2164 #endif 2165 #ifdef VK_KHR_android_surface 2166 static VkResult entry_vkCreateAndroidSurfaceKHR( 2167 VkInstance instance, 2168 const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, 2169 const VkAllocationCallbacks* pAllocator, 2170 VkSurfaceKHR* pSurface) 2171 { 2172 AEMU_SCOPED_TRACE("vkCreateAndroidSurfaceKHR"); 2173 auto vkEnc = HostConnection::get()->vkEncoder(); 2174 VkResult vkCreateAndroidSurfaceKHR_VkResult_return = (VkResult)0; 2175 vkCreateAndroidSurfaceKHR_VkResult_return = vkEnc->vkCreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); 2176 return vkCreateAndroidSurfaceKHR_VkResult_return; 2177 } 2178 #endif 2179 #ifdef VK_KHR_win32_surface 2180 static VkResult entry_vkCreateWin32SurfaceKHR( 2181 VkInstance instance, 2182 const VkWin32SurfaceCreateInfoKHR* pCreateInfo, 2183 const VkAllocationCallbacks* pAllocator, 2184 VkSurfaceKHR* pSurface) 2185 { 2186 AEMU_SCOPED_TRACE("vkCreateWin32SurfaceKHR"); 2187 auto vkEnc = HostConnection::get()->vkEncoder(); 2188 VkResult vkCreateWin32SurfaceKHR_VkResult_return = (VkResult)0; 2189 vkCreateWin32SurfaceKHR_VkResult_return = vkEnc->vkCreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); 2190 return vkCreateWin32SurfaceKHR_VkResult_return; 2191 } 2192 static VkBool32 entry_vkGetPhysicalDeviceWin32PresentationSupportKHR( 2193 VkPhysicalDevice physicalDevice, 2194 uint32_t queueFamilyIndex) 2195 { 2196 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWin32PresentationSupportKHR"); 2197 auto vkEnc = HostConnection::get()->vkEncoder(); 2198 VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return = (VkBool32)0; 2199 vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex); 2200 return vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return; 2201 } 2202 #endif 2203 #ifdef VK_KHR_sampler_mirror_clamp_to_edge 2204 #endif 2205 #ifdef VK_KHR_multiview 2206 #endif 2207 #ifdef VK_KHR_get_physical_device_properties2 2208 static void entry_vkGetPhysicalDeviceFeatures2KHR( 2209 VkPhysicalDevice physicalDevice, 2210 VkPhysicalDeviceFeatures2* pFeatures) 2211 { 2212 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2KHR"); 2213 auto vkEnc = HostConnection::get()->vkEncoder(); 2214 vkEnc->vkGetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures); 2215 } 2216 static void entry_vkGetPhysicalDeviceProperties2KHR( 2217 VkPhysicalDevice physicalDevice, 2218 VkPhysicalDeviceProperties2* pProperties) 2219 { 2220 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2KHR"); 2221 auto vkEnc = HostConnection::get()->vkEncoder(); 2222 vkEnc->vkGetPhysicalDeviceProperties2KHR(physicalDevice, pProperties); 2223 } 2224 static void entry_vkGetPhysicalDeviceFormatProperties2KHR( 2225 VkPhysicalDevice physicalDevice, 2226 VkFormat format, 2227 VkFormatProperties2* pFormatProperties) 2228 { 2229 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2KHR"); 2230 auto vkEnc = HostConnection::get()->vkEncoder(); 2231 vkEnc->vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties); 2232 } 2233 static VkResult entry_vkGetPhysicalDeviceImageFormatProperties2KHR( 2234 VkPhysicalDevice physicalDevice, 2235 const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, 2236 VkImageFormatProperties2* pImageFormatProperties) 2237 { 2238 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2KHR"); 2239 auto vkEnc = HostConnection::get()->vkEncoder(); 2240 VkResult vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = (VkResult)0; 2241 auto resources = ResourceTracker::get(); 2242 vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = resources->on_vkGetPhysicalDeviceImageFormatProperties2KHR(vkEnc, VK_SUCCESS, physicalDevice, pImageFormatInfo, pImageFormatProperties); 2243 return vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return; 2244 } 2245 static void entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR( 2246 VkPhysicalDevice physicalDevice, 2247 uint32_t* pQueueFamilyPropertyCount, 2248 VkQueueFamilyProperties2* pQueueFamilyProperties) 2249 { 2250 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2KHR"); 2251 auto vkEnc = HostConnection::get()->vkEncoder(); 2252 vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); 2253 } 2254 static void entry_vkGetPhysicalDeviceMemoryProperties2KHR( 2255 VkPhysicalDevice physicalDevice, 2256 VkPhysicalDeviceMemoryProperties2* pMemoryProperties) 2257 { 2258 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2KHR"); 2259 auto vkEnc = HostConnection::get()->vkEncoder(); 2260 vkEnc->vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties); 2261 } 2262 static void entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR( 2263 VkPhysicalDevice physicalDevice, 2264 const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, 2265 uint32_t* pPropertyCount, 2266 VkSparseImageFormatProperties2* pProperties) 2267 { 2268 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2KHR"); 2269 auto vkEnc = HostConnection::get()->vkEncoder(); 2270 vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties); 2271 } 2272 #endif 2273 #ifdef VK_KHR_device_group 2274 static void entry_vkGetDeviceGroupPeerMemoryFeaturesKHR( 2275 VkDevice device, 2276 uint32_t heapIndex, 2277 uint32_t localDeviceIndex, 2278 uint32_t remoteDeviceIndex, 2279 VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) 2280 { 2281 AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeaturesKHR"); 2282 auto vkEnc = HostConnection::get()->vkEncoder(); 2283 vkEnc->vkGetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); 2284 } 2285 static void entry_vkCmdSetDeviceMaskKHR( 2286 VkCommandBuffer commandBuffer, 2287 uint32_t deviceMask) 2288 { 2289 AEMU_SCOPED_TRACE("vkCmdSetDeviceMaskKHR"); 2290 auto vkEnc = HostConnection::get()->vkEncoder(); 2291 vkEnc->vkCmdSetDeviceMaskKHR(commandBuffer, deviceMask); 2292 } 2293 static void entry_vkCmdDispatchBaseKHR( 2294 VkCommandBuffer commandBuffer, 2295 uint32_t baseGroupX, 2296 uint32_t baseGroupY, 2297 uint32_t baseGroupZ, 2298 uint32_t groupCountX, 2299 uint32_t groupCountY, 2300 uint32_t groupCountZ) 2301 { 2302 AEMU_SCOPED_TRACE("vkCmdDispatchBaseKHR"); 2303 auto vkEnc = HostConnection::get()->vkEncoder(); 2304 vkEnc->vkCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); 2305 } 2306 #endif 2307 #ifdef VK_KHR_shader_draw_parameters 2308 #endif 2309 #ifdef VK_KHR_maintenance1 2310 static void entry_vkTrimCommandPoolKHR( 2311 VkDevice device, 2312 VkCommandPool commandPool, 2313 VkCommandPoolTrimFlags flags) 2314 { 2315 AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR"); 2316 auto vkEnc = HostConnection::get()->vkEncoder(); 2317 vkEnc->vkTrimCommandPoolKHR(device, commandPool, flags); 2318 } 2319 #endif 2320 #ifdef VK_KHR_device_group_creation 2321 static VkResult entry_vkEnumeratePhysicalDeviceGroupsKHR( 2322 VkInstance instance, 2323 uint32_t* pPhysicalDeviceGroupCount, 2324 VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) 2325 { 2326 AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroupsKHR"); 2327 auto vkEnc = HostConnection::get()->vkEncoder(); 2328 VkResult vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return = (VkResult)0; 2329 vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return = vkEnc->vkEnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); 2330 return vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return; 2331 } 2332 #endif 2333 #ifdef VK_KHR_external_memory_capabilities 2334 static void entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR( 2335 VkPhysicalDevice physicalDevice, 2336 const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, 2337 VkExternalBufferProperties* pExternalBufferProperties) 2338 { 2339 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferPropertiesKHR"); 2340 auto vkEnc = HostConnection::get()->vkEncoder(); 2341 vkEnc->vkGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); 2342 } 2343 #endif 2344 #ifdef VK_KHR_external_memory 2345 #endif 2346 #ifdef VK_KHR_external_memory_win32 2347 static VkResult entry_vkGetMemoryWin32HandleKHR( 2348 VkDevice device, 2349 const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, 2350 HANDLE* pHandle) 2351 { 2352 AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleKHR"); 2353 auto vkEnc = HostConnection::get()->vkEncoder(); 2354 VkResult vkGetMemoryWin32HandleKHR_VkResult_return = (VkResult)0; 2355 vkGetMemoryWin32HandleKHR_VkResult_return = vkEnc->vkGetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); 2356 return vkGetMemoryWin32HandleKHR_VkResult_return; 2357 } 2358 static VkResult entry_vkGetMemoryWin32HandlePropertiesKHR( 2359 VkDevice device, 2360 VkExternalMemoryHandleTypeFlagBits handleType, 2361 HANDLE handle, 2362 VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) 2363 { 2364 AEMU_SCOPED_TRACE("vkGetMemoryWin32HandlePropertiesKHR"); 2365 auto vkEnc = HostConnection::get()->vkEncoder(); 2366 VkResult vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = (VkResult)0; 2367 vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = vkEnc->vkGetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties); 2368 return vkGetMemoryWin32HandlePropertiesKHR_VkResult_return; 2369 } 2370 #endif 2371 #ifdef VK_KHR_external_memory_fd 2372 static VkResult entry_vkGetMemoryFdKHR( 2373 VkDevice device, 2374 const VkMemoryGetFdInfoKHR* pGetFdInfo, 2375 int* pFd) 2376 { 2377 AEMU_SCOPED_TRACE("vkGetMemoryFdKHR"); 2378 auto vkEnc = HostConnection::get()->vkEncoder(); 2379 VkResult vkGetMemoryFdKHR_VkResult_return = (VkResult)0; 2380 vkGetMemoryFdKHR_VkResult_return = vkEnc->vkGetMemoryFdKHR(device, pGetFdInfo, pFd); 2381 return vkGetMemoryFdKHR_VkResult_return; 2382 } 2383 static VkResult entry_vkGetMemoryFdPropertiesKHR( 2384 VkDevice device, 2385 VkExternalMemoryHandleTypeFlagBits handleType, 2386 int fd, 2387 VkMemoryFdPropertiesKHR* pMemoryFdProperties) 2388 { 2389 AEMU_SCOPED_TRACE("vkGetMemoryFdPropertiesKHR"); 2390 auto vkEnc = HostConnection::get()->vkEncoder(); 2391 VkResult vkGetMemoryFdPropertiesKHR_VkResult_return = (VkResult)0; 2392 vkGetMemoryFdPropertiesKHR_VkResult_return = vkEnc->vkGetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties); 2393 return vkGetMemoryFdPropertiesKHR_VkResult_return; 2394 } 2395 #endif 2396 #ifdef VK_KHR_win32_keyed_mutex 2397 #endif 2398 #ifdef VK_KHR_external_semaphore_capabilities 2399 static void entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( 2400 VkPhysicalDevice physicalDevice, 2401 const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, 2402 VkExternalSemaphoreProperties* pExternalSemaphoreProperties) 2403 { 2404 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"); 2405 auto vkEnc = HostConnection::get()->vkEncoder(); 2406 vkEnc->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); 2407 } 2408 #endif 2409 #ifdef VK_KHR_external_semaphore 2410 #endif 2411 #ifdef VK_KHR_external_semaphore_win32 2412 static VkResult entry_vkImportSemaphoreWin32HandleKHR( 2413 VkDevice device, 2414 const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) 2415 { 2416 AEMU_SCOPED_TRACE("vkImportSemaphoreWin32HandleKHR"); 2417 auto vkEnc = HostConnection::get()->vkEncoder(); 2418 VkResult vkImportSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0; 2419 vkImportSemaphoreWin32HandleKHR_VkResult_return = vkEnc->vkImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo); 2420 return vkImportSemaphoreWin32HandleKHR_VkResult_return; 2421 } 2422 static VkResult entry_vkGetSemaphoreWin32HandleKHR( 2423 VkDevice device, 2424 const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, 2425 HANDLE* pHandle) 2426 { 2427 AEMU_SCOPED_TRACE("vkGetSemaphoreWin32HandleKHR"); 2428 auto vkEnc = HostConnection::get()->vkEncoder(); 2429 VkResult vkGetSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0; 2430 vkGetSemaphoreWin32HandleKHR_VkResult_return = vkEnc->vkGetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); 2431 return vkGetSemaphoreWin32HandleKHR_VkResult_return; 2432 } 2433 #endif 2434 #ifdef VK_KHR_external_semaphore_fd 2435 static VkResult entry_vkImportSemaphoreFdKHR( 2436 VkDevice device, 2437 const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) 2438 { 2439 AEMU_SCOPED_TRACE("vkImportSemaphoreFdKHR"); 2440 auto vkEnc = HostConnection::get()->vkEncoder(); 2441 VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0; 2442 auto resources = ResourceTracker::get(); 2443 vkImportSemaphoreFdKHR_VkResult_return = resources->on_vkImportSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pImportSemaphoreFdInfo); 2444 return vkImportSemaphoreFdKHR_VkResult_return; 2445 } 2446 static VkResult entry_vkGetSemaphoreFdKHR( 2447 VkDevice device, 2448 const VkSemaphoreGetFdInfoKHR* pGetFdInfo, 2449 int* pFd) 2450 { 2451 AEMU_SCOPED_TRACE("vkGetSemaphoreFdKHR"); 2452 auto vkEnc = HostConnection::get()->vkEncoder(); 2453 VkResult vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0; 2454 auto resources = ResourceTracker::get(); 2455 vkGetSemaphoreFdKHR_VkResult_return = resources->on_vkGetSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd); 2456 return vkGetSemaphoreFdKHR_VkResult_return; 2457 } 2458 #endif 2459 #ifdef VK_KHR_push_descriptor 2460 static void entry_vkCmdPushDescriptorSetKHR( 2461 VkCommandBuffer commandBuffer, 2462 VkPipelineBindPoint pipelineBindPoint, 2463 VkPipelineLayout layout, 2464 uint32_t set, 2465 uint32_t descriptorWriteCount, 2466 const VkWriteDescriptorSet* pDescriptorWrites) 2467 { 2468 AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetKHR"); 2469 auto vkEnc = HostConnection::get()->vkEncoder(); 2470 vkEnc->vkCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); 2471 } 2472 static void entry_vkCmdPushDescriptorSetWithTemplateKHR( 2473 VkCommandBuffer commandBuffer, 2474 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 2475 VkPipelineLayout layout, 2476 uint32_t set, 2477 const void* pData) 2478 { 2479 AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetWithTemplateKHR"); 2480 auto vkEnc = HostConnection::get()->vkEncoder(); 2481 vkEnc->vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData); 2482 } 2483 #endif 2484 #ifdef VK_KHR_16bit_storage 2485 #endif 2486 #ifdef VK_KHR_incremental_present 2487 #endif 2488 #ifdef VK_KHR_descriptor_update_template 2489 static VkResult entry_vkCreateDescriptorUpdateTemplateKHR( 2490 VkDevice device, 2491 const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, 2492 const VkAllocationCallbacks* pAllocator, 2493 VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) 2494 { 2495 AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplateKHR"); 2496 auto vkEnc = HostConnection::get()->vkEncoder(); 2497 VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0; 2498 vkCreateDescriptorUpdateTemplateKHR_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); 2499 return vkCreateDescriptorUpdateTemplateKHR_VkResult_return; 2500 } 2501 static void entry_vkDestroyDescriptorUpdateTemplateKHR( 2502 VkDevice device, 2503 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 2504 const VkAllocationCallbacks* pAllocator) 2505 { 2506 AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplateKHR"); 2507 auto vkEnc = HostConnection::get()->vkEncoder(); 2508 vkEnc->vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator); 2509 } 2510 static void entry_vkUpdateDescriptorSetWithTemplateKHR( 2511 VkDevice device, 2512 VkDescriptorSet descriptorSet, 2513 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 2514 const void* pData) 2515 { 2516 AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateKHR"); 2517 auto vkEnc = HostConnection::get()->vkEncoder(); 2518 vkEnc->vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData); 2519 } 2520 #endif 2521 #ifdef VK_KHR_create_renderpass2 2522 static VkResult entry_vkCreateRenderPass2KHR( 2523 VkDevice device, 2524 const VkRenderPassCreateInfo2KHR* pCreateInfo, 2525 const VkAllocationCallbacks* pAllocator, 2526 VkRenderPass* pRenderPass) 2527 { 2528 AEMU_SCOPED_TRACE("vkCreateRenderPass2KHR"); 2529 auto vkEnc = HostConnection::get()->vkEncoder(); 2530 VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0; 2531 vkCreateRenderPass2KHR_VkResult_return = vkEnc->vkCreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass); 2532 return vkCreateRenderPass2KHR_VkResult_return; 2533 } 2534 static void entry_vkCmdBeginRenderPass2KHR( 2535 VkCommandBuffer commandBuffer, 2536 const VkRenderPassBeginInfo* pRenderPassBegin, 2537 const VkSubpassBeginInfoKHR* pSubpassBeginInfo) 2538 { 2539 AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR"); 2540 auto vkEnc = HostConnection::get()->vkEncoder(); 2541 vkEnc->vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); 2542 } 2543 static void entry_vkCmdNextSubpass2KHR( 2544 VkCommandBuffer commandBuffer, 2545 const VkSubpassBeginInfoKHR* pSubpassBeginInfo, 2546 const VkSubpassEndInfoKHR* pSubpassEndInfo) 2547 { 2548 AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR"); 2549 auto vkEnc = HostConnection::get()->vkEncoder(); 2550 vkEnc->vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); 2551 } 2552 static void entry_vkCmdEndRenderPass2KHR( 2553 VkCommandBuffer commandBuffer, 2554 const VkSubpassEndInfoKHR* pSubpassEndInfo) 2555 { 2556 AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR"); 2557 auto vkEnc = HostConnection::get()->vkEncoder(); 2558 vkEnc->vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo); 2559 } 2560 #endif 2561 #ifdef VK_KHR_shared_presentable_image 2562 static VkResult entry_vkGetSwapchainStatusKHR( 2563 VkDevice device, 2564 VkSwapchainKHR swapchain) 2565 { 2566 AEMU_SCOPED_TRACE("vkGetSwapchainStatusKHR"); 2567 auto vkEnc = HostConnection::get()->vkEncoder(); 2568 VkResult vkGetSwapchainStatusKHR_VkResult_return = (VkResult)0; 2569 vkGetSwapchainStatusKHR_VkResult_return = vkEnc->vkGetSwapchainStatusKHR(device, swapchain); 2570 return vkGetSwapchainStatusKHR_VkResult_return; 2571 } 2572 #endif 2573 #ifdef VK_KHR_external_fence_capabilities 2574 static void entry_vkGetPhysicalDeviceExternalFencePropertiesKHR( 2575 VkPhysicalDevice physicalDevice, 2576 const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, 2577 VkExternalFenceProperties* pExternalFenceProperties) 2578 { 2579 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFencePropertiesKHR"); 2580 auto vkEnc = HostConnection::get()->vkEncoder(); 2581 vkEnc->vkGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); 2582 } 2583 #endif 2584 #ifdef VK_KHR_external_fence 2585 #endif 2586 #ifdef VK_KHR_external_fence_win32 2587 static VkResult entry_vkImportFenceWin32HandleKHR( 2588 VkDevice device, 2589 const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) 2590 { 2591 AEMU_SCOPED_TRACE("vkImportFenceWin32HandleKHR"); 2592 auto vkEnc = HostConnection::get()->vkEncoder(); 2593 VkResult vkImportFenceWin32HandleKHR_VkResult_return = (VkResult)0; 2594 vkImportFenceWin32HandleKHR_VkResult_return = vkEnc->vkImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo); 2595 return vkImportFenceWin32HandleKHR_VkResult_return; 2596 } 2597 static VkResult entry_vkGetFenceWin32HandleKHR( 2598 VkDevice device, 2599 const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, 2600 HANDLE* pHandle) 2601 { 2602 AEMU_SCOPED_TRACE("vkGetFenceWin32HandleKHR"); 2603 auto vkEnc = HostConnection::get()->vkEncoder(); 2604 VkResult vkGetFenceWin32HandleKHR_VkResult_return = (VkResult)0; 2605 vkGetFenceWin32HandleKHR_VkResult_return = vkEnc->vkGetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); 2606 return vkGetFenceWin32HandleKHR_VkResult_return; 2607 } 2608 #endif 2609 #ifdef VK_KHR_external_fence_fd 2610 static VkResult entry_vkImportFenceFdKHR( 2611 VkDevice device, 2612 const VkImportFenceFdInfoKHR* pImportFenceFdInfo) 2613 { 2614 AEMU_SCOPED_TRACE("vkImportFenceFdKHR"); 2615 auto vkEnc = HostConnection::get()->vkEncoder(); 2616 VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0; 2617 vkImportFenceFdKHR_VkResult_return = vkEnc->vkImportFenceFdKHR(device, pImportFenceFdInfo); 2618 return vkImportFenceFdKHR_VkResult_return; 2619 } 2620 static VkResult entry_vkGetFenceFdKHR( 2621 VkDevice device, 2622 const VkFenceGetFdInfoKHR* pGetFdInfo, 2623 int* pFd) 2624 { 2625 AEMU_SCOPED_TRACE("vkGetFenceFdKHR"); 2626 auto vkEnc = HostConnection::get()->vkEncoder(); 2627 VkResult vkGetFenceFdKHR_VkResult_return = (VkResult)0; 2628 vkGetFenceFdKHR_VkResult_return = vkEnc->vkGetFenceFdKHR(device, pGetFdInfo, pFd); 2629 return vkGetFenceFdKHR_VkResult_return; 2630 } 2631 #endif 2632 #ifdef VK_KHR_maintenance2 2633 #endif 2634 #ifdef VK_KHR_get_surface_capabilities2 2635 static VkResult entry_vkGetPhysicalDeviceSurfaceCapabilities2KHR( 2636 VkPhysicalDevice physicalDevice, 2637 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, 2638 VkSurfaceCapabilities2KHR* pSurfaceCapabilities) 2639 { 2640 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2KHR"); 2641 auto vkEnc = HostConnection::get()->vkEncoder(); 2642 VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return = (VkResult)0; 2643 vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities); 2644 return vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return; 2645 } 2646 static VkResult entry_vkGetPhysicalDeviceSurfaceFormats2KHR( 2647 VkPhysicalDevice physicalDevice, 2648 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, 2649 uint32_t* pSurfaceFormatCount, 2650 VkSurfaceFormat2KHR* pSurfaceFormats) 2651 { 2652 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormats2KHR"); 2653 auto vkEnc = HostConnection::get()->vkEncoder(); 2654 VkResult vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return = (VkResult)0; 2655 vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats); 2656 return vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return; 2657 } 2658 #endif 2659 #ifdef VK_KHR_variable_pointers 2660 #endif 2661 #ifdef VK_KHR_get_display_properties2 2662 static VkResult entry_vkGetPhysicalDeviceDisplayProperties2KHR( 2663 VkPhysicalDevice physicalDevice, 2664 uint32_t* pPropertyCount, 2665 VkDisplayProperties2KHR* pProperties) 2666 { 2667 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayProperties2KHR"); 2668 auto vkEnc = HostConnection::get()->vkEncoder(); 2669 VkResult vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return = (VkResult)0; 2670 vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties); 2671 return vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return; 2672 } 2673 static VkResult entry_vkGetPhysicalDeviceDisplayPlaneProperties2KHR( 2674 VkPhysicalDevice physicalDevice, 2675 uint32_t* pPropertyCount, 2676 VkDisplayPlaneProperties2KHR* pProperties) 2677 { 2678 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlaneProperties2KHR"); 2679 auto vkEnc = HostConnection::get()->vkEncoder(); 2680 VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return = (VkResult)0; 2681 vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, pPropertyCount, pProperties); 2682 return vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return; 2683 } 2684 static VkResult entry_vkGetDisplayModeProperties2KHR( 2685 VkPhysicalDevice physicalDevice, 2686 VkDisplayKHR display, 2687 uint32_t* pPropertyCount, 2688 VkDisplayModeProperties2KHR* pProperties) 2689 { 2690 AEMU_SCOPED_TRACE("vkGetDisplayModeProperties2KHR"); 2691 auto vkEnc = HostConnection::get()->vkEncoder(); 2692 VkResult vkGetDisplayModeProperties2KHR_VkResult_return = (VkResult)0; 2693 vkGetDisplayModeProperties2KHR_VkResult_return = vkEnc->vkGetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties); 2694 return vkGetDisplayModeProperties2KHR_VkResult_return; 2695 } 2696 static VkResult entry_vkGetDisplayPlaneCapabilities2KHR( 2697 VkPhysicalDevice physicalDevice, 2698 const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, 2699 VkDisplayPlaneCapabilities2KHR* pCapabilities) 2700 { 2701 AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilities2KHR"); 2702 auto vkEnc = HostConnection::get()->vkEncoder(); 2703 VkResult vkGetDisplayPlaneCapabilities2KHR_VkResult_return = (VkResult)0; 2704 vkGetDisplayPlaneCapabilities2KHR_VkResult_return = vkEnc->vkGetDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities); 2705 return vkGetDisplayPlaneCapabilities2KHR_VkResult_return; 2706 } 2707 #endif 2708 #ifdef VK_KHR_dedicated_allocation 2709 #endif 2710 #ifdef VK_KHR_storage_buffer_storage_class 2711 #endif 2712 #ifdef VK_KHR_relaxed_block_layout 2713 #endif 2714 #ifdef VK_KHR_get_memory_requirements2 2715 static void entry_vkGetImageMemoryRequirements2KHR( 2716 VkDevice device, 2717 const VkImageMemoryRequirementsInfo2* pInfo, 2718 VkMemoryRequirements2* pMemoryRequirements) 2719 { 2720 AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2KHR"); 2721 auto vkEnc = HostConnection::get()->vkEncoder(); 2722 auto resources = ResourceTracker::get(); 2723 resources->on_vkGetImageMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements); 2724 } 2725 static void entry_vkGetBufferMemoryRequirements2KHR( 2726 VkDevice device, 2727 const VkBufferMemoryRequirementsInfo2* pInfo, 2728 VkMemoryRequirements2* pMemoryRequirements) 2729 { 2730 AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2KHR"); 2731 auto vkEnc = HostConnection::get()->vkEncoder(); 2732 auto resources = ResourceTracker::get(); 2733 resources->on_vkGetBufferMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements); 2734 } 2735 static void entry_vkGetImageSparseMemoryRequirements2KHR( 2736 VkDevice device, 2737 const VkImageSparseMemoryRequirementsInfo2* pInfo, 2738 uint32_t* pSparseMemoryRequirementCount, 2739 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) 2740 { 2741 AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2KHR"); 2742 auto vkEnc = HostConnection::get()->vkEncoder(); 2743 vkEnc->vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); 2744 } 2745 #endif 2746 #ifdef VK_KHR_image_format_list 2747 #endif 2748 #ifdef VK_KHR_sampler_ycbcr_conversion 2749 static VkResult entry_vkCreateSamplerYcbcrConversionKHR( 2750 VkDevice device, 2751 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, 2752 const VkAllocationCallbacks* pAllocator, 2753 VkSamplerYcbcrConversion* pYcbcrConversion) 2754 { 2755 AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversionKHR"); 2756 auto vkEnc = HostConnection::get()->vkEncoder(); 2757 VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0; 2758 auto resources = ResourceTracker::get(); 2759 vkCreateSamplerYcbcrConversionKHR_VkResult_return = resources->on_vkCreateSamplerYcbcrConversionKHR(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pYcbcrConversion); 2760 return vkCreateSamplerYcbcrConversionKHR_VkResult_return; 2761 } 2762 static void entry_vkDestroySamplerYcbcrConversionKHR( 2763 VkDevice device, 2764 VkSamplerYcbcrConversion ycbcrConversion, 2765 const VkAllocationCallbacks* pAllocator) 2766 { 2767 AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversionKHR"); 2768 auto vkEnc = HostConnection::get()->vkEncoder(); 2769 vkEnc->vkDestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator); 2770 } 2771 #endif 2772 #ifdef VK_KHR_bind_memory2 2773 static VkResult entry_vkBindBufferMemory2KHR( 2774 VkDevice device, 2775 uint32_t bindInfoCount, 2776 const VkBindBufferMemoryInfo* pBindInfos) 2777 { 2778 AEMU_SCOPED_TRACE("vkBindBufferMemory2KHR"); 2779 auto vkEnc = HostConnection::get()->vkEncoder(); 2780 VkResult vkBindBufferMemory2KHR_VkResult_return = (VkResult)0; 2781 auto resources = ResourceTracker::get(); 2782 vkBindBufferMemory2KHR_VkResult_return = resources->on_vkBindBufferMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos); 2783 return vkBindBufferMemory2KHR_VkResult_return; 2784 } 2785 static VkResult entry_vkBindImageMemory2KHR( 2786 VkDevice device, 2787 uint32_t bindInfoCount, 2788 const VkBindImageMemoryInfo* pBindInfos) 2789 { 2790 AEMU_SCOPED_TRACE("vkBindImageMemory2KHR"); 2791 auto vkEnc = HostConnection::get()->vkEncoder(); 2792 VkResult vkBindImageMemory2KHR_VkResult_return = (VkResult)0; 2793 auto resources = ResourceTracker::get(); 2794 vkBindImageMemory2KHR_VkResult_return = resources->on_vkBindImageMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos); 2795 return vkBindImageMemory2KHR_VkResult_return; 2796 } 2797 #endif 2798 #ifdef VK_KHR_maintenance3 2799 static void entry_vkGetDescriptorSetLayoutSupportKHR( 2800 VkDevice device, 2801 const VkDescriptorSetLayoutCreateInfo* pCreateInfo, 2802 VkDescriptorSetLayoutSupport* pSupport) 2803 { 2804 AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupportKHR"); 2805 auto vkEnc = HostConnection::get()->vkEncoder(); 2806 vkEnc->vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport); 2807 } 2808 #endif 2809 #ifdef VK_KHR_draw_indirect_count 2810 static void entry_vkCmdDrawIndirectCountKHR( 2811 VkCommandBuffer commandBuffer, 2812 VkBuffer buffer, 2813 VkDeviceSize offset, 2814 VkBuffer countBuffer, 2815 VkDeviceSize countBufferOffset, 2816 uint32_t maxDrawCount, 2817 uint32_t stride) 2818 { 2819 AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountKHR"); 2820 auto vkEnc = HostConnection::get()->vkEncoder(); 2821 vkEnc->vkCmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); 2822 } 2823 static void entry_vkCmdDrawIndexedIndirectCountKHR( 2824 VkCommandBuffer commandBuffer, 2825 VkBuffer buffer, 2826 VkDeviceSize offset, 2827 VkBuffer countBuffer, 2828 VkDeviceSize countBufferOffset, 2829 uint32_t maxDrawCount, 2830 uint32_t stride) 2831 { 2832 AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountKHR"); 2833 auto vkEnc = HostConnection::get()->vkEncoder(); 2834 vkEnc->vkCmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); 2835 } 2836 #endif 2837 #ifdef VK_KHR_8bit_storage 2838 #endif 2839 #ifdef VK_ANDROID_native_buffer 2840 static VkResult entry_vkGetSwapchainGrallocUsageANDROID( 2841 VkDevice device, 2842 VkFormat format, 2843 VkImageUsageFlags imageUsage, 2844 int* grallocUsage) 2845 { 2846 AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsageANDROID"); 2847 auto vkEnc = HostConnection::get()->vkEncoder(); 2848 VkResult vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0; 2849 vkGetSwapchainGrallocUsageANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsageANDROID(device, format, imageUsage, grallocUsage); 2850 return vkGetSwapchainGrallocUsageANDROID_VkResult_return; 2851 } 2852 static VkResult entry_vkAcquireImageANDROID( 2853 VkDevice device, 2854 VkImage image, 2855 int nativeFenceFd, 2856 VkSemaphore semaphore, 2857 VkFence fence) 2858 { 2859 AEMU_SCOPED_TRACE("vkAcquireImageANDROID"); 2860 auto vkEnc = HostConnection::get()->vkEncoder(); 2861 VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0; 2862 vkAcquireImageANDROID_VkResult_return = vkEnc->vkAcquireImageANDROID(device, image, nativeFenceFd, semaphore, fence); 2863 return vkAcquireImageANDROID_VkResult_return; 2864 } 2865 static VkResult entry_vkQueueSignalReleaseImageANDROID( 2866 VkQueue queue, 2867 uint32_t waitSemaphoreCount, 2868 const VkSemaphore* pWaitSemaphores, 2869 VkImage image, 2870 int* pNativeFenceFd) 2871 { 2872 AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROID"); 2873 auto vkEnc = HostConnection::get()->vkEncoder(); 2874 VkResult vkQueueSignalReleaseImageANDROID_VkResult_return = (VkResult)0; 2875 vkQueueSignalReleaseImageANDROID_VkResult_return = vkEnc->vkQueueSignalReleaseImageANDROID(queue, waitSemaphoreCount, pWaitSemaphores, image, pNativeFenceFd); 2876 return vkQueueSignalReleaseImageANDROID_VkResult_return; 2877 } 2878 #endif 2879 #ifdef VK_EXT_debug_report 2880 static VkResult entry_vkCreateDebugReportCallbackEXT( 2881 VkInstance instance, 2882 const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, 2883 const VkAllocationCallbacks* pAllocator, 2884 VkDebugReportCallbackEXT* pCallback) 2885 { 2886 AEMU_SCOPED_TRACE("vkCreateDebugReportCallbackEXT"); 2887 auto vkEnc = HostConnection::get()->vkEncoder(); 2888 VkResult vkCreateDebugReportCallbackEXT_VkResult_return = (VkResult)0; 2889 vkCreateDebugReportCallbackEXT_VkResult_return = vkEnc->vkCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback); 2890 return vkCreateDebugReportCallbackEXT_VkResult_return; 2891 } 2892 static void entry_vkDestroyDebugReportCallbackEXT( 2893 VkInstance instance, 2894 VkDebugReportCallbackEXT callback, 2895 const VkAllocationCallbacks* pAllocator) 2896 { 2897 AEMU_SCOPED_TRACE("vkDestroyDebugReportCallbackEXT"); 2898 auto vkEnc = HostConnection::get()->vkEncoder(); 2899 vkEnc->vkDestroyDebugReportCallbackEXT(instance, callback, pAllocator); 2900 } 2901 static void entry_vkDebugReportMessageEXT( 2902 VkInstance instance, 2903 VkDebugReportFlagsEXT flags, 2904 VkDebugReportObjectTypeEXT objectType, 2905 uint64_t object, 2906 size_t location, 2907 int32_t messageCode, 2908 const char* pLayerPrefix, 2909 const char* pMessage) 2910 { 2911 AEMU_SCOPED_TRACE("vkDebugReportMessageEXT"); 2912 auto vkEnc = HostConnection::get()->vkEncoder(); 2913 vkEnc->vkDebugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage); 2914 } 2915 #endif 2916 #ifdef VK_NV_glsl_shader 2917 #endif 2918 #ifdef VK_EXT_depth_range_unrestricted 2919 #endif 2920 #ifdef VK_IMG_filter_cubic 2921 #endif 2922 #ifdef VK_AMD_rasterization_order 2923 #endif 2924 #ifdef VK_AMD_shader_trinary_minmax 2925 #endif 2926 #ifdef VK_AMD_shader_explicit_vertex_parameter 2927 #endif 2928 #ifdef VK_EXT_debug_marker 2929 static VkResult entry_vkDebugMarkerSetObjectTagEXT( 2930 VkDevice device, 2931 const VkDebugMarkerObjectTagInfoEXT* pTagInfo) 2932 { 2933 AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectTagEXT"); 2934 auto vkEnc = HostConnection::get()->vkEncoder(); 2935 VkResult vkDebugMarkerSetObjectTagEXT_VkResult_return = (VkResult)0; 2936 vkDebugMarkerSetObjectTagEXT_VkResult_return = vkEnc->vkDebugMarkerSetObjectTagEXT(device, pTagInfo); 2937 return vkDebugMarkerSetObjectTagEXT_VkResult_return; 2938 } 2939 static VkResult entry_vkDebugMarkerSetObjectNameEXT( 2940 VkDevice device, 2941 const VkDebugMarkerObjectNameInfoEXT* pNameInfo) 2942 { 2943 AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectNameEXT"); 2944 auto vkEnc = HostConnection::get()->vkEncoder(); 2945 VkResult vkDebugMarkerSetObjectNameEXT_VkResult_return = (VkResult)0; 2946 vkDebugMarkerSetObjectNameEXT_VkResult_return = vkEnc->vkDebugMarkerSetObjectNameEXT(device, pNameInfo); 2947 return vkDebugMarkerSetObjectNameEXT_VkResult_return; 2948 } 2949 static void entry_vkCmdDebugMarkerBeginEXT( 2950 VkCommandBuffer commandBuffer, 2951 const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) 2952 { 2953 AEMU_SCOPED_TRACE("vkCmdDebugMarkerBeginEXT"); 2954 auto vkEnc = HostConnection::get()->vkEncoder(); 2955 vkEnc->vkCmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo); 2956 } 2957 static void entry_vkCmdDebugMarkerEndEXT( 2958 VkCommandBuffer commandBuffer) 2959 { 2960 AEMU_SCOPED_TRACE("vkCmdDebugMarkerEndEXT"); 2961 auto vkEnc = HostConnection::get()->vkEncoder(); 2962 vkEnc->vkCmdDebugMarkerEndEXT(commandBuffer); 2963 } 2964 static void entry_vkCmdDebugMarkerInsertEXT( 2965 VkCommandBuffer commandBuffer, 2966 const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) 2967 { 2968 AEMU_SCOPED_TRACE("vkCmdDebugMarkerInsertEXT"); 2969 auto vkEnc = HostConnection::get()->vkEncoder(); 2970 vkEnc->vkCmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo); 2971 } 2972 #endif 2973 #ifdef VK_AMD_gcn_shader 2974 #endif 2975 #ifdef VK_NV_dedicated_allocation 2976 #endif 2977 #ifdef VK_AMD_draw_indirect_count 2978 static void entry_vkCmdDrawIndirectCountAMD( 2979 VkCommandBuffer commandBuffer, 2980 VkBuffer buffer, 2981 VkDeviceSize offset, 2982 VkBuffer countBuffer, 2983 VkDeviceSize countBufferOffset, 2984 uint32_t maxDrawCount, 2985 uint32_t stride) 2986 { 2987 AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountAMD"); 2988 auto vkEnc = HostConnection::get()->vkEncoder(); 2989 vkEnc->vkCmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); 2990 } 2991 static void entry_vkCmdDrawIndexedIndirectCountAMD( 2992 VkCommandBuffer commandBuffer, 2993 VkBuffer buffer, 2994 VkDeviceSize offset, 2995 VkBuffer countBuffer, 2996 VkDeviceSize countBufferOffset, 2997 uint32_t maxDrawCount, 2998 uint32_t stride) 2999 { 3000 AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountAMD"); 3001 auto vkEnc = HostConnection::get()->vkEncoder(); 3002 vkEnc->vkCmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); 3003 } 3004 #endif 3005 #ifdef VK_AMD_negative_viewport_height 3006 #endif 3007 #ifdef VK_AMD_gpu_shader_half_float 3008 #endif 3009 #ifdef VK_AMD_shader_ballot 3010 #endif 3011 #ifdef VK_AMD_texture_gather_bias_lod 3012 #endif 3013 #ifdef VK_AMD_shader_info 3014 static VkResult entry_vkGetShaderInfoAMD( 3015 VkDevice device, 3016 VkPipeline pipeline, 3017 VkShaderStageFlagBits shaderStage, 3018 VkShaderInfoTypeAMD infoType, 3019 size_t* pInfoSize, 3020 void* pInfo) 3021 { 3022 AEMU_SCOPED_TRACE("vkGetShaderInfoAMD"); 3023 auto vkEnc = HostConnection::get()->vkEncoder(); 3024 VkResult vkGetShaderInfoAMD_VkResult_return = (VkResult)0; 3025 vkGetShaderInfoAMD_VkResult_return = vkEnc->vkGetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo); 3026 return vkGetShaderInfoAMD_VkResult_return; 3027 } 3028 #endif 3029 #ifdef VK_AMD_shader_image_load_store_lod 3030 #endif 3031 #ifdef VK_IMG_format_pvrtc 3032 #endif 3033 #ifdef VK_NV_external_memory_capabilities 3034 static VkResult entry_vkGetPhysicalDeviceExternalImageFormatPropertiesNV( 3035 VkPhysicalDevice physicalDevice, 3036 VkFormat format, 3037 VkImageType type, 3038 VkImageTiling tiling, 3039 VkImageUsageFlags usage, 3040 VkImageCreateFlags flags, 3041 VkExternalMemoryHandleTypeFlagsNV externalHandleType, 3042 VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) 3043 { 3044 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalImageFormatPropertiesNV"); 3045 auto vkEnc = HostConnection::get()->vkEncoder(); 3046 VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return = (VkResult)0; 3047 vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return = vkEnc->vkGetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties); 3048 return vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return; 3049 } 3050 #endif 3051 #ifdef VK_NV_external_memory 3052 #endif 3053 #ifdef VK_NV_external_memory_win32 3054 static VkResult entry_vkGetMemoryWin32HandleNV( 3055 VkDevice device, 3056 VkDeviceMemory memory, 3057 VkExternalMemoryHandleTypeFlagsNV handleType, 3058 HANDLE* pHandle) 3059 { 3060 AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleNV"); 3061 auto vkEnc = HostConnection::get()->vkEncoder(); 3062 VkResult vkGetMemoryWin32HandleNV_VkResult_return = (VkResult)0; 3063 vkGetMemoryWin32HandleNV_VkResult_return = vkEnc->vkGetMemoryWin32HandleNV(device, memory, handleType, pHandle); 3064 return vkGetMemoryWin32HandleNV_VkResult_return; 3065 } 3066 #endif 3067 #ifdef VK_NV_win32_keyed_mutex 3068 #endif 3069 #ifdef VK_EXT_validation_flags 3070 #endif 3071 #ifdef VK_NN_vi_surface 3072 static VkResult entry_vkCreateViSurfaceNN( 3073 VkInstance instance, 3074 const VkViSurfaceCreateInfoNN* pCreateInfo, 3075 const VkAllocationCallbacks* pAllocator, 3076 VkSurfaceKHR* pSurface) 3077 { 3078 AEMU_SCOPED_TRACE("vkCreateViSurfaceNN"); 3079 auto vkEnc = HostConnection::get()->vkEncoder(); 3080 VkResult vkCreateViSurfaceNN_VkResult_return = (VkResult)0; 3081 vkCreateViSurfaceNN_VkResult_return = vkEnc->vkCreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface); 3082 return vkCreateViSurfaceNN_VkResult_return; 3083 } 3084 #endif 3085 #ifdef VK_EXT_shader_subgroup_ballot 3086 #endif 3087 #ifdef VK_EXT_shader_subgroup_vote 3088 #endif 3089 #ifdef VK_EXT_conditional_rendering 3090 static void entry_vkCmdBeginConditionalRenderingEXT( 3091 VkCommandBuffer commandBuffer, 3092 const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) 3093 { 3094 AEMU_SCOPED_TRACE("vkCmdBeginConditionalRenderingEXT"); 3095 auto vkEnc = HostConnection::get()->vkEncoder(); 3096 vkEnc->vkCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin); 3097 } 3098 static void entry_vkCmdEndConditionalRenderingEXT( 3099 VkCommandBuffer commandBuffer) 3100 { 3101 AEMU_SCOPED_TRACE("vkCmdEndConditionalRenderingEXT"); 3102 auto vkEnc = HostConnection::get()->vkEncoder(); 3103 vkEnc->vkCmdEndConditionalRenderingEXT(commandBuffer); 3104 } 3105 #endif 3106 #ifdef VK_NVX_device_generated_commands 3107 static void entry_vkCmdProcessCommandsNVX( 3108 VkCommandBuffer commandBuffer, 3109 const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo) 3110 { 3111 AEMU_SCOPED_TRACE("vkCmdProcessCommandsNVX"); 3112 auto vkEnc = HostConnection::get()->vkEncoder(); 3113 vkEnc->vkCmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo); 3114 } 3115 static void entry_vkCmdReserveSpaceForCommandsNVX( 3116 VkCommandBuffer commandBuffer, 3117 const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo) 3118 { 3119 AEMU_SCOPED_TRACE("vkCmdReserveSpaceForCommandsNVX"); 3120 auto vkEnc = HostConnection::get()->vkEncoder(); 3121 vkEnc->vkCmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo); 3122 } 3123 static VkResult entry_vkCreateIndirectCommandsLayoutNVX( 3124 VkDevice device, 3125 const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, 3126 const VkAllocationCallbacks* pAllocator, 3127 VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout) 3128 { 3129 AEMU_SCOPED_TRACE("vkCreateIndirectCommandsLayoutNVX"); 3130 auto vkEnc = HostConnection::get()->vkEncoder(); 3131 VkResult vkCreateIndirectCommandsLayoutNVX_VkResult_return = (VkResult)0; 3132 vkCreateIndirectCommandsLayoutNVX_VkResult_return = vkEnc->vkCreateIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout); 3133 return vkCreateIndirectCommandsLayoutNVX_VkResult_return; 3134 } 3135 static void entry_vkDestroyIndirectCommandsLayoutNVX( 3136 VkDevice device, 3137 VkIndirectCommandsLayoutNVX indirectCommandsLayout, 3138 const VkAllocationCallbacks* pAllocator) 3139 { 3140 AEMU_SCOPED_TRACE("vkDestroyIndirectCommandsLayoutNVX"); 3141 auto vkEnc = HostConnection::get()->vkEncoder(); 3142 vkEnc->vkDestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator); 3143 } 3144 static VkResult entry_vkCreateObjectTableNVX( 3145 VkDevice device, 3146 const VkObjectTableCreateInfoNVX* pCreateInfo, 3147 const VkAllocationCallbacks* pAllocator, 3148 VkObjectTableNVX* pObjectTable) 3149 { 3150 AEMU_SCOPED_TRACE("vkCreateObjectTableNVX"); 3151 auto vkEnc = HostConnection::get()->vkEncoder(); 3152 VkResult vkCreateObjectTableNVX_VkResult_return = (VkResult)0; 3153 vkCreateObjectTableNVX_VkResult_return = vkEnc->vkCreateObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable); 3154 return vkCreateObjectTableNVX_VkResult_return; 3155 } 3156 static void entry_vkDestroyObjectTableNVX( 3157 VkDevice device, 3158 VkObjectTableNVX objectTable, 3159 const VkAllocationCallbacks* pAllocator) 3160 { 3161 AEMU_SCOPED_TRACE("vkDestroyObjectTableNVX"); 3162 auto vkEnc = HostConnection::get()->vkEncoder(); 3163 vkEnc->vkDestroyObjectTableNVX(device, objectTable, pAllocator); 3164 } 3165 static VkResult entry_vkRegisterObjectsNVX( 3166 VkDevice device, 3167 VkObjectTableNVX objectTable, 3168 uint32_t objectCount, 3169 const VkObjectTableEntryNVX* const* ppObjectTableEntries, 3170 const uint32_t* pObjectIndices) 3171 { 3172 AEMU_SCOPED_TRACE("vkRegisterObjectsNVX"); 3173 auto vkEnc = HostConnection::get()->vkEncoder(); 3174 VkResult vkRegisterObjectsNVX_VkResult_return = (VkResult)0; 3175 vkRegisterObjectsNVX_VkResult_return = vkEnc->vkRegisterObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices); 3176 return vkRegisterObjectsNVX_VkResult_return; 3177 } 3178 static VkResult entry_vkUnregisterObjectsNVX( 3179 VkDevice device, 3180 VkObjectTableNVX objectTable, 3181 uint32_t objectCount, 3182 const VkObjectEntryTypeNVX* pObjectEntryTypes, 3183 const uint32_t* pObjectIndices) 3184 { 3185 AEMU_SCOPED_TRACE("vkUnregisterObjectsNVX"); 3186 auto vkEnc = HostConnection::get()->vkEncoder(); 3187 VkResult vkUnregisterObjectsNVX_VkResult_return = (VkResult)0; 3188 vkUnregisterObjectsNVX_VkResult_return = vkEnc->vkUnregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices); 3189 return vkUnregisterObjectsNVX_VkResult_return; 3190 } 3191 static void entry_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( 3192 VkPhysicalDevice physicalDevice, 3193 VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, 3194 VkDeviceGeneratedCommandsLimitsNVX* pLimits) 3195 { 3196 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX"); 3197 auto vkEnc = HostConnection::get()->vkEncoder(); 3198 vkEnc->vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(physicalDevice, pFeatures, pLimits); 3199 } 3200 #endif 3201 #ifdef VK_NV_clip_space_w_scaling 3202 static void entry_vkCmdSetViewportWScalingNV( 3203 VkCommandBuffer commandBuffer, 3204 uint32_t firstViewport, 3205 uint32_t viewportCount, 3206 const VkViewportWScalingNV* pViewportWScalings) 3207 { 3208 AEMU_SCOPED_TRACE("vkCmdSetViewportWScalingNV"); 3209 auto vkEnc = HostConnection::get()->vkEncoder(); 3210 vkEnc->vkCmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings); 3211 } 3212 #endif 3213 #ifdef VK_EXT_direct_mode_display 3214 static VkResult entry_vkReleaseDisplayEXT( 3215 VkPhysicalDevice physicalDevice, 3216 VkDisplayKHR display) 3217 { 3218 AEMU_SCOPED_TRACE("vkReleaseDisplayEXT"); 3219 auto vkEnc = HostConnection::get()->vkEncoder(); 3220 VkResult vkReleaseDisplayEXT_VkResult_return = (VkResult)0; 3221 vkReleaseDisplayEXT_VkResult_return = vkEnc->vkReleaseDisplayEXT(physicalDevice, display); 3222 return vkReleaseDisplayEXT_VkResult_return; 3223 } 3224 #endif 3225 #ifdef VK_EXT_acquire_xlib_display 3226 static VkResult entry_vkAcquireXlibDisplayEXT( 3227 VkPhysicalDevice physicalDevice, 3228 Display* dpy, 3229 VkDisplayKHR display) 3230 { 3231 AEMU_SCOPED_TRACE("vkAcquireXlibDisplayEXT"); 3232 auto vkEnc = HostConnection::get()->vkEncoder(); 3233 VkResult vkAcquireXlibDisplayEXT_VkResult_return = (VkResult)0; 3234 vkAcquireXlibDisplayEXT_VkResult_return = vkEnc->vkAcquireXlibDisplayEXT(physicalDevice, dpy, display); 3235 return vkAcquireXlibDisplayEXT_VkResult_return; 3236 } 3237 static VkResult entry_vkGetRandROutputDisplayEXT( 3238 VkPhysicalDevice physicalDevice, 3239 Display* dpy, 3240 RROutput rrOutput, 3241 VkDisplayKHR* pDisplay) 3242 { 3243 AEMU_SCOPED_TRACE("vkGetRandROutputDisplayEXT"); 3244 auto vkEnc = HostConnection::get()->vkEncoder(); 3245 VkResult vkGetRandROutputDisplayEXT_VkResult_return = (VkResult)0; 3246 vkGetRandROutputDisplayEXT_VkResult_return = vkEnc->vkGetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay); 3247 return vkGetRandROutputDisplayEXT_VkResult_return; 3248 } 3249 #endif 3250 #ifdef VK_EXT_display_surface_counter 3251 static VkResult entry_vkGetPhysicalDeviceSurfaceCapabilities2EXT( 3252 VkPhysicalDevice physicalDevice, 3253 VkSurfaceKHR surface, 3254 VkSurfaceCapabilities2EXT* pSurfaceCapabilities) 3255 { 3256 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2EXT"); 3257 auto vkEnc = HostConnection::get()->vkEncoder(); 3258 VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return = (VkResult)0; 3259 vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities); 3260 return vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return; 3261 } 3262 #endif 3263 #ifdef VK_EXT_display_control 3264 static VkResult entry_vkDisplayPowerControlEXT( 3265 VkDevice device, 3266 VkDisplayKHR display, 3267 const VkDisplayPowerInfoEXT* pDisplayPowerInfo) 3268 { 3269 AEMU_SCOPED_TRACE("vkDisplayPowerControlEXT"); 3270 auto vkEnc = HostConnection::get()->vkEncoder(); 3271 VkResult vkDisplayPowerControlEXT_VkResult_return = (VkResult)0; 3272 vkDisplayPowerControlEXT_VkResult_return = vkEnc->vkDisplayPowerControlEXT(device, display, pDisplayPowerInfo); 3273 return vkDisplayPowerControlEXT_VkResult_return; 3274 } 3275 static VkResult entry_vkRegisterDeviceEventEXT( 3276 VkDevice device, 3277 const VkDeviceEventInfoEXT* pDeviceEventInfo, 3278 const VkAllocationCallbacks* pAllocator, 3279 VkFence* pFence) 3280 { 3281 AEMU_SCOPED_TRACE("vkRegisterDeviceEventEXT"); 3282 auto vkEnc = HostConnection::get()->vkEncoder(); 3283 VkResult vkRegisterDeviceEventEXT_VkResult_return = (VkResult)0; 3284 vkRegisterDeviceEventEXT_VkResult_return = vkEnc->vkRegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence); 3285 return vkRegisterDeviceEventEXT_VkResult_return; 3286 } 3287 static VkResult entry_vkRegisterDisplayEventEXT( 3288 VkDevice device, 3289 VkDisplayKHR display, 3290 const VkDisplayEventInfoEXT* pDisplayEventInfo, 3291 const VkAllocationCallbacks* pAllocator, 3292 VkFence* pFence) 3293 { 3294 AEMU_SCOPED_TRACE("vkRegisterDisplayEventEXT"); 3295 auto vkEnc = HostConnection::get()->vkEncoder(); 3296 VkResult vkRegisterDisplayEventEXT_VkResult_return = (VkResult)0; 3297 vkRegisterDisplayEventEXT_VkResult_return = vkEnc->vkRegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence); 3298 return vkRegisterDisplayEventEXT_VkResult_return; 3299 } 3300 static VkResult entry_vkGetSwapchainCounterEXT( 3301 VkDevice device, 3302 VkSwapchainKHR swapchain, 3303 VkSurfaceCounterFlagBitsEXT counter, 3304 uint64_t* pCounterValue) 3305 { 3306 AEMU_SCOPED_TRACE("vkGetSwapchainCounterEXT"); 3307 auto vkEnc = HostConnection::get()->vkEncoder(); 3308 VkResult vkGetSwapchainCounterEXT_VkResult_return = (VkResult)0; 3309 vkGetSwapchainCounterEXT_VkResult_return = vkEnc->vkGetSwapchainCounterEXT(device, swapchain, counter, pCounterValue); 3310 return vkGetSwapchainCounterEXT_VkResult_return; 3311 } 3312 #endif 3313 #ifdef VK_GOOGLE_display_timing 3314 static VkResult entry_vkGetRefreshCycleDurationGOOGLE( 3315 VkDevice device, 3316 VkSwapchainKHR swapchain, 3317 VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) 3318 { 3319 AEMU_SCOPED_TRACE("vkGetRefreshCycleDurationGOOGLE"); 3320 auto vkEnc = HostConnection::get()->vkEncoder(); 3321 VkResult vkGetRefreshCycleDurationGOOGLE_VkResult_return = (VkResult)0; 3322 vkGetRefreshCycleDurationGOOGLE_VkResult_return = vkEnc->vkGetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties); 3323 return vkGetRefreshCycleDurationGOOGLE_VkResult_return; 3324 } 3325 static VkResult entry_vkGetPastPresentationTimingGOOGLE( 3326 VkDevice device, 3327 VkSwapchainKHR swapchain, 3328 uint32_t* pPresentationTimingCount, 3329 VkPastPresentationTimingGOOGLE* pPresentationTimings) 3330 { 3331 AEMU_SCOPED_TRACE("vkGetPastPresentationTimingGOOGLE"); 3332 auto vkEnc = HostConnection::get()->vkEncoder(); 3333 VkResult vkGetPastPresentationTimingGOOGLE_VkResult_return = (VkResult)0; 3334 vkGetPastPresentationTimingGOOGLE_VkResult_return = vkEnc->vkGetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings); 3335 return vkGetPastPresentationTimingGOOGLE_VkResult_return; 3336 } 3337 #endif 3338 #ifdef VK_NV_sample_mask_override_coverage 3339 #endif 3340 #ifdef VK_NV_geometry_shader_passthrough 3341 #endif 3342 #ifdef VK_NV_viewport_array2 3343 #endif 3344 #ifdef VK_NVX_multiview_per_view_attributes 3345 #endif 3346 #ifdef VK_NV_viewport_swizzle 3347 #endif 3348 #ifdef VK_EXT_discard_rectangles 3349 static void entry_vkCmdSetDiscardRectangleEXT( 3350 VkCommandBuffer commandBuffer, 3351 uint32_t firstDiscardRectangle, 3352 uint32_t discardRectangleCount, 3353 const VkRect2D* pDiscardRectangles) 3354 { 3355 AEMU_SCOPED_TRACE("vkCmdSetDiscardRectangleEXT"); 3356 auto vkEnc = HostConnection::get()->vkEncoder(); 3357 vkEnc->vkCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); 3358 } 3359 #endif 3360 #ifdef VK_EXT_conservative_rasterization 3361 #endif 3362 #ifdef VK_EXT_swapchain_colorspace 3363 #endif 3364 #ifdef VK_EXT_hdr_metadata 3365 static void entry_vkSetHdrMetadataEXT( 3366 VkDevice device, 3367 uint32_t swapchainCount, 3368 const VkSwapchainKHR* pSwapchains, 3369 const VkHdrMetadataEXT* pMetadata) 3370 { 3371 AEMU_SCOPED_TRACE("vkSetHdrMetadataEXT"); 3372 auto vkEnc = HostConnection::get()->vkEncoder(); 3373 vkEnc->vkSetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata); 3374 } 3375 #endif 3376 #ifdef VK_MVK_ios_surface 3377 static VkResult entry_vkCreateIOSSurfaceMVK( 3378 VkInstance instance, 3379 const VkIOSSurfaceCreateInfoMVK* pCreateInfo, 3380 const VkAllocationCallbacks* pAllocator, 3381 VkSurfaceKHR* pSurface) 3382 { 3383 AEMU_SCOPED_TRACE("vkCreateIOSSurfaceMVK"); 3384 auto vkEnc = HostConnection::get()->vkEncoder(); 3385 VkResult vkCreateIOSSurfaceMVK_VkResult_return = (VkResult)0; 3386 vkCreateIOSSurfaceMVK_VkResult_return = vkEnc->vkCreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); 3387 return vkCreateIOSSurfaceMVK_VkResult_return; 3388 } 3389 #endif 3390 #ifdef VK_MVK_macos_surface 3391 static VkResult entry_vkCreateMacOSSurfaceMVK( 3392 VkInstance instance, 3393 const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, 3394 const VkAllocationCallbacks* pAllocator, 3395 VkSurfaceKHR* pSurface) 3396 { 3397 AEMU_SCOPED_TRACE("vkCreateMacOSSurfaceMVK"); 3398 auto vkEnc = HostConnection::get()->vkEncoder(); 3399 VkResult vkCreateMacOSSurfaceMVK_VkResult_return = (VkResult)0; 3400 vkCreateMacOSSurfaceMVK_VkResult_return = vkEnc->vkCreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); 3401 return vkCreateMacOSSurfaceMVK_VkResult_return; 3402 } 3403 #endif 3404 #ifdef VK_EXT_external_memory_dma_buf 3405 #endif 3406 #ifdef VK_EXT_queue_family_foreign 3407 #endif 3408 #ifdef VK_EXT_debug_utils 3409 static VkResult entry_vkSetDebugUtilsObjectNameEXT( 3410 VkDevice device, 3411 const VkDebugUtilsObjectNameInfoEXT* pNameInfo) 3412 { 3413 AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectNameEXT"); 3414 auto vkEnc = HostConnection::get()->vkEncoder(); 3415 VkResult vkSetDebugUtilsObjectNameEXT_VkResult_return = (VkResult)0; 3416 vkSetDebugUtilsObjectNameEXT_VkResult_return = vkEnc->vkSetDebugUtilsObjectNameEXT(device, pNameInfo); 3417 return vkSetDebugUtilsObjectNameEXT_VkResult_return; 3418 } 3419 static VkResult entry_vkSetDebugUtilsObjectTagEXT( 3420 VkDevice device, 3421 const VkDebugUtilsObjectTagInfoEXT* pTagInfo) 3422 { 3423 AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectTagEXT"); 3424 auto vkEnc = HostConnection::get()->vkEncoder(); 3425 VkResult vkSetDebugUtilsObjectTagEXT_VkResult_return = (VkResult)0; 3426 vkSetDebugUtilsObjectTagEXT_VkResult_return = vkEnc->vkSetDebugUtilsObjectTagEXT(device, pTagInfo); 3427 return vkSetDebugUtilsObjectTagEXT_VkResult_return; 3428 } 3429 static void entry_vkQueueBeginDebugUtilsLabelEXT( 3430 VkQueue queue, 3431 const VkDebugUtilsLabelEXT* pLabelInfo) 3432 { 3433 AEMU_SCOPED_TRACE("vkQueueBeginDebugUtilsLabelEXT"); 3434 auto vkEnc = HostConnection::get()->vkEncoder(); 3435 vkEnc->vkQueueBeginDebugUtilsLabelEXT(queue, pLabelInfo); 3436 } 3437 static void entry_vkQueueEndDebugUtilsLabelEXT( 3438 VkQueue queue) 3439 { 3440 AEMU_SCOPED_TRACE("vkQueueEndDebugUtilsLabelEXT"); 3441 auto vkEnc = HostConnection::get()->vkEncoder(); 3442 vkEnc->vkQueueEndDebugUtilsLabelEXT(queue); 3443 } 3444 static void entry_vkQueueInsertDebugUtilsLabelEXT( 3445 VkQueue queue, 3446 const VkDebugUtilsLabelEXT* pLabelInfo) 3447 { 3448 AEMU_SCOPED_TRACE("vkQueueInsertDebugUtilsLabelEXT"); 3449 auto vkEnc = HostConnection::get()->vkEncoder(); 3450 vkEnc->vkQueueInsertDebugUtilsLabelEXT(queue, pLabelInfo); 3451 } 3452 static void entry_vkCmdBeginDebugUtilsLabelEXT( 3453 VkCommandBuffer commandBuffer, 3454 const VkDebugUtilsLabelEXT* pLabelInfo) 3455 { 3456 AEMU_SCOPED_TRACE("vkCmdBeginDebugUtilsLabelEXT"); 3457 auto vkEnc = HostConnection::get()->vkEncoder(); 3458 vkEnc->vkCmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo); 3459 } 3460 static void entry_vkCmdEndDebugUtilsLabelEXT( 3461 VkCommandBuffer commandBuffer) 3462 { 3463 AEMU_SCOPED_TRACE("vkCmdEndDebugUtilsLabelEXT"); 3464 auto vkEnc = HostConnection::get()->vkEncoder(); 3465 vkEnc->vkCmdEndDebugUtilsLabelEXT(commandBuffer); 3466 } 3467 static void entry_vkCmdInsertDebugUtilsLabelEXT( 3468 VkCommandBuffer commandBuffer, 3469 const VkDebugUtilsLabelEXT* pLabelInfo) 3470 { 3471 AEMU_SCOPED_TRACE("vkCmdInsertDebugUtilsLabelEXT"); 3472 auto vkEnc = HostConnection::get()->vkEncoder(); 3473 vkEnc->vkCmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo); 3474 } 3475 static VkResult entry_vkCreateDebugUtilsMessengerEXT( 3476 VkInstance instance, 3477 const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, 3478 const VkAllocationCallbacks* pAllocator, 3479 VkDebugUtilsMessengerEXT* pMessenger) 3480 { 3481 AEMU_SCOPED_TRACE("vkCreateDebugUtilsMessengerEXT"); 3482 auto vkEnc = HostConnection::get()->vkEncoder(); 3483 VkResult vkCreateDebugUtilsMessengerEXT_VkResult_return = (VkResult)0; 3484 vkCreateDebugUtilsMessengerEXT_VkResult_return = vkEnc->vkCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger); 3485 return vkCreateDebugUtilsMessengerEXT_VkResult_return; 3486 } 3487 static void entry_vkDestroyDebugUtilsMessengerEXT( 3488 VkInstance instance, 3489 VkDebugUtilsMessengerEXT messenger, 3490 const VkAllocationCallbacks* pAllocator) 3491 { 3492 AEMU_SCOPED_TRACE("vkDestroyDebugUtilsMessengerEXT"); 3493 auto vkEnc = HostConnection::get()->vkEncoder(); 3494 vkEnc->vkDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator); 3495 } 3496 static void entry_vkSubmitDebugUtilsMessageEXT( 3497 VkInstance instance, 3498 VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, 3499 VkDebugUtilsMessageTypeFlagsEXT messageTypes, 3500 const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) 3501 { 3502 AEMU_SCOPED_TRACE("vkSubmitDebugUtilsMessageEXT"); 3503 auto vkEnc = HostConnection::get()->vkEncoder(); 3504 vkEnc->vkSubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData); 3505 } 3506 #endif 3507 #ifdef VK_ANDROID_external_memory_android_hardware_buffer 3508 static VkResult entry_vkGetAndroidHardwareBufferPropertiesANDROID( 3509 VkDevice device, 3510 const AHardwareBuffer* buffer, 3511 VkAndroidHardwareBufferPropertiesANDROID* pProperties) 3512 { 3513 AEMU_SCOPED_TRACE("vkGetAndroidHardwareBufferPropertiesANDROID"); 3514 auto vkEnc = HostConnection::get()->vkEncoder(); 3515 VkResult vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = (VkResult)0; 3516 auto resources = ResourceTracker::get(); 3517 vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = resources->on_vkGetAndroidHardwareBufferPropertiesANDROID(vkEnc, VK_SUCCESS, device, buffer, pProperties); 3518 return vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return; 3519 } 3520 static VkResult entry_vkGetMemoryAndroidHardwareBufferANDROID( 3521 VkDevice device, 3522 const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, 3523 AHardwareBuffer** pBuffer) 3524 { 3525 AEMU_SCOPED_TRACE("vkGetMemoryAndroidHardwareBufferANDROID"); 3526 auto vkEnc = HostConnection::get()->vkEncoder(); 3527 VkResult vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = (VkResult)0; 3528 auto resources = ResourceTracker::get(); 3529 vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = resources->on_vkGetMemoryAndroidHardwareBufferANDROID(vkEnc, VK_SUCCESS, device, pInfo, pBuffer); 3530 return vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return; 3531 } 3532 #endif 3533 #ifdef VK_EXT_sampler_filter_minmax 3534 #endif 3535 #ifdef VK_AMD_gpu_shader_int16 3536 #endif 3537 #ifdef VK_AMD_mixed_attachment_samples 3538 #endif 3539 #ifdef VK_AMD_shader_fragment_mask 3540 #endif 3541 #ifdef VK_EXT_shader_stencil_export 3542 #endif 3543 #ifdef VK_EXT_sample_locations 3544 static void entry_vkCmdSetSampleLocationsEXT( 3545 VkCommandBuffer commandBuffer, 3546 const VkSampleLocationsInfoEXT* pSampleLocationsInfo) 3547 { 3548 AEMU_SCOPED_TRACE("vkCmdSetSampleLocationsEXT"); 3549 auto vkEnc = HostConnection::get()->vkEncoder(); 3550 vkEnc->vkCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo); 3551 } 3552 static void entry_vkGetPhysicalDeviceMultisamplePropertiesEXT( 3553 VkPhysicalDevice physicalDevice, 3554 VkSampleCountFlagBits samples, 3555 VkMultisamplePropertiesEXT* pMultisampleProperties) 3556 { 3557 AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMultisamplePropertiesEXT"); 3558 auto vkEnc = HostConnection::get()->vkEncoder(); 3559 vkEnc->vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties); 3560 } 3561 #endif 3562 #ifdef VK_EXT_blend_operation_advanced 3563 #endif 3564 #ifdef VK_NV_fragment_coverage_to_color 3565 #endif 3566 #ifdef VK_NV_framebuffer_mixed_samples 3567 #endif 3568 #ifdef VK_NV_fill_rectangle 3569 #endif 3570 #ifdef VK_EXT_post_depth_coverage 3571 #endif 3572 #ifdef VK_EXT_validation_cache 3573 static VkResult entry_vkCreateValidationCacheEXT( 3574 VkDevice device, 3575 const VkValidationCacheCreateInfoEXT* pCreateInfo, 3576 const VkAllocationCallbacks* pAllocator, 3577 VkValidationCacheEXT* pValidationCache) 3578 { 3579 AEMU_SCOPED_TRACE("vkCreateValidationCacheEXT"); 3580 auto vkEnc = HostConnection::get()->vkEncoder(); 3581 VkResult vkCreateValidationCacheEXT_VkResult_return = (VkResult)0; 3582 vkCreateValidationCacheEXT_VkResult_return = vkEnc->vkCreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache); 3583 return vkCreateValidationCacheEXT_VkResult_return; 3584 } 3585 static void entry_vkDestroyValidationCacheEXT( 3586 VkDevice device, 3587 VkValidationCacheEXT validationCache, 3588 const VkAllocationCallbacks* pAllocator) 3589 { 3590 AEMU_SCOPED_TRACE("vkDestroyValidationCacheEXT"); 3591 auto vkEnc = HostConnection::get()->vkEncoder(); 3592 vkEnc->vkDestroyValidationCacheEXT(device, validationCache, pAllocator); 3593 } 3594 static VkResult entry_vkMergeValidationCachesEXT( 3595 VkDevice device, 3596 VkValidationCacheEXT dstCache, 3597 uint32_t srcCacheCount, 3598 const VkValidationCacheEXT* pSrcCaches) 3599 { 3600 AEMU_SCOPED_TRACE("vkMergeValidationCachesEXT"); 3601 auto vkEnc = HostConnection::get()->vkEncoder(); 3602 VkResult vkMergeValidationCachesEXT_VkResult_return = (VkResult)0; 3603 vkMergeValidationCachesEXT_VkResult_return = vkEnc->vkMergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches); 3604 return vkMergeValidationCachesEXT_VkResult_return; 3605 } 3606 static VkResult entry_vkGetValidationCacheDataEXT( 3607 VkDevice device, 3608 VkValidationCacheEXT validationCache, 3609 size_t* pDataSize, 3610 void* pData) 3611 { 3612 AEMU_SCOPED_TRACE("vkGetValidationCacheDataEXT"); 3613 auto vkEnc = HostConnection::get()->vkEncoder(); 3614 VkResult vkGetValidationCacheDataEXT_VkResult_return = (VkResult)0; 3615 vkGetValidationCacheDataEXT_VkResult_return = vkEnc->vkGetValidationCacheDataEXT(device, validationCache, pDataSize, pData); 3616 return vkGetValidationCacheDataEXT_VkResult_return; 3617 } 3618 #endif 3619 #ifdef VK_EXT_descriptor_indexing 3620 #endif 3621 #ifdef VK_EXT_shader_viewport_index_layer 3622 #endif 3623 #ifdef VK_EXT_global_priority 3624 #endif 3625 #ifdef VK_EXT_external_memory_host 3626 static VkResult entry_vkGetMemoryHostPointerPropertiesEXT( 3627 VkDevice device, 3628 VkExternalMemoryHandleTypeFlagBits handleType, 3629 const void* pHostPointer, 3630 VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) 3631 { 3632 AEMU_SCOPED_TRACE("vkGetMemoryHostPointerPropertiesEXT"); 3633 auto vkEnc = HostConnection::get()->vkEncoder(); 3634 VkResult vkGetMemoryHostPointerPropertiesEXT_VkResult_return = (VkResult)0; 3635 vkGetMemoryHostPointerPropertiesEXT_VkResult_return = vkEnc->vkGetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties); 3636 return vkGetMemoryHostPointerPropertiesEXT_VkResult_return; 3637 } 3638 #endif 3639 #ifdef VK_AMD_buffer_marker 3640 static void entry_vkCmdWriteBufferMarkerAMD( 3641 VkCommandBuffer commandBuffer, 3642 VkPipelineStageFlagBits pipelineStage, 3643 VkBuffer dstBuffer, 3644 VkDeviceSize dstOffset, 3645 uint32_t marker) 3646 { 3647 AEMU_SCOPED_TRACE("vkCmdWriteBufferMarkerAMD"); 3648 auto vkEnc = HostConnection::get()->vkEncoder(); 3649 vkEnc->vkCmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker); 3650 } 3651 #endif 3652 #ifdef VK_AMD_shader_core_properties 3653 #endif 3654 #ifdef VK_EXT_vertex_attribute_divisor 3655 #endif 3656 #ifdef VK_NV_shader_subgroup_partitioned 3657 #endif 3658 #ifdef VK_NV_device_diagnostic_checkpoints 3659 static void entry_vkCmdSetCheckpointNV( 3660 VkCommandBuffer commandBuffer, 3661 const void* pCheckpointMarker) 3662 { 3663 AEMU_SCOPED_TRACE("vkCmdSetCheckpointNV"); 3664 auto vkEnc = HostConnection::get()->vkEncoder(); 3665 vkEnc->vkCmdSetCheckpointNV(commandBuffer, pCheckpointMarker); 3666 } 3667 static void entry_vkGetQueueCheckpointDataNV( 3668 VkQueue queue, 3669 uint32_t* pCheckpointDataCount, 3670 VkCheckpointDataNV* pCheckpointData) 3671 { 3672 AEMU_SCOPED_TRACE("vkGetQueueCheckpointDataNV"); 3673 auto vkEnc = HostConnection::get()->vkEncoder(); 3674 vkEnc->vkGetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData); 3675 } 3676 #endif 3677 #ifdef VK_GOOGLE_address_space 3678 static VkResult entry_vkMapMemoryIntoAddressSpaceGOOGLE( 3679 VkDevice device, 3680 VkDeviceMemory memory, 3681 uint64_t* pAddress) 3682 { 3683 AEMU_SCOPED_TRACE("vkMapMemoryIntoAddressSpaceGOOGLE"); 3684 auto vkEnc = HostConnection::get()->vkEncoder(); 3685 VkResult vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return = (VkResult)0; 3686 vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return = vkEnc->vkMapMemoryIntoAddressSpaceGOOGLE(device, memory, pAddress); 3687 return vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return; 3688 } 3689 #endif 3690 #ifdef VK_GOOGLE_color_buffer 3691 static VkResult entry_vkRegisterImageColorBufferGOOGLE( 3692 VkDevice device, 3693 VkImage image, 3694 uint32_t colorBuffer) 3695 { 3696 AEMU_SCOPED_TRACE("vkRegisterImageColorBufferGOOGLE"); 3697 auto vkEnc = HostConnection::get()->vkEncoder(); 3698 VkResult vkRegisterImageColorBufferGOOGLE_VkResult_return = (VkResult)0; 3699 vkRegisterImageColorBufferGOOGLE_VkResult_return = vkEnc->vkRegisterImageColorBufferGOOGLE(device, image, colorBuffer); 3700 return vkRegisterImageColorBufferGOOGLE_VkResult_return; 3701 } 3702 static VkResult entry_vkRegisterBufferColorBufferGOOGLE( 3703 VkDevice device, 3704 VkBuffer buffer, 3705 uint32_t colorBuffer) 3706 { 3707 AEMU_SCOPED_TRACE("vkRegisterBufferColorBufferGOOGLE"); 3708 auto vkEnc = HostConnection::get()->vkEncoder(); 3709 VkResult vkRegisterBufferColorBufferGOOGLE_VkResult_return = (VkResult)0; 3710 vkRegisterBufferColorBufferGOOGLE_VkResult_return = vkEnc->vkRegisterBufferColorBufferGOOGLE(device, buffer, colorBuffer); 3711 return vkRegisterBufferColorBufferGOOGLE_VkResult_return; 3712 } 3713 #endif 3714 #ifdef VK_GOOGLE_sized_descriptor_update_template 3715 static void entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE( 3716 VkDevice device, 3717 VkDescriptorSet descriptorSet, 3718 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 3719 uint32_t imageInfoCount, 3720 uint32_t bufferInfoCount, 3721 uint32_t bufferViewCount, 3722 const uint32_t* pImageInfoEntryIndices, 3723 const uint32_t* pBufferInfoEntryIndices, 3724 const uint32_t* pBufferViewEntryIndices, 3725 const VkDescriptorImageInfo* pImageInfos, 3726 const VkDescriptorBufferInfo* pBufferInfos, 3727 const VkBufferView* pBufferViews) 3728 { 3729 AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE"); 3730 auto vkEnc = HostConnection::get()->vkEncoder(); 3731 vkEnc->vkUpdateDescriptorSetWithTemplateSizedGOOGLE(device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount, bufferViewCount, pImageInfoEntryIndices, pBufferInfoEntryIndices, pBufferViewEntryIndices, pImageInfos, pBufferInfos, pBufferViews); 3732 } 3733 #endif 3734 #ifdef VK_GOOGLE_async_command_buffers 3735 static void entry_vkBeginCommandBufferAsyncGOOGLE( 3736 VkCommandBuffer commandBuffer, 3737 const VkCommandBufferBeginInfo* pBeginInfo) 3738 { 3739 AEMU_SCOPED_TRACE("vkBeginCommandBufferAsyncGOOGLE"); 3740 auto vkEnc = HostConnection::get()->vkEncoder(); 3741 vkEnc->vkBeginCommandBufferAsyncGOOGLE(commandBuffer, pBeginInfo); 3742 } 3743 static void entry_vkEndCommandBufferAsyncGOOGLE( 3744 VkCommandBuffer commandBuffer) 3745 { 3746 AEMU_SCOPED_TRACE("vkEndCommandBufferAsyncGOOGLE"); 3747 auto vkEnc = HostConnection::get()->vkEncoder(); 3748 vkEnc->vkEndCommandBufferAsyncGOOGLE(commandBuffer); 3749 } 3750 static void entry_vkResetCommandBufferAsyncGOOGLE( 3751 VkCommandBuffer commandBuffer, 3752 VkCommandBufferResetFlags flags) 3753 { 3754 AEMU_SCOPED_TRACE("vkResetCommandBufferAsyncGOOGLE"); 3755 auto vkEnc = HostConnection::get()->vkEncoder(); 3756 vkEnc->vkResetCommandBufferAsyncGOOGLE(commandBuffer, flags); 3757 } 3758 #endif 3759 void* goldfish_vulkan_get_proc_address(const char* name){ 3760 #ifdef VK_VERSION_1_0 3761 if (!strcmp(name, "vkCreateInstance")) 3762 { 3763 return (void*)entry_vkCreateInstance; 3764 } 3765 if (!strcmp(name, "vkDestroyInstance")) 3766 { 3767 return (void*)entry_vkDestroyInstance; 3768 } 3769 if (!strcmp(name, "vkEnumeratePhysicalDevices")) 3770 { 3771 return (void*)entry_vkEnumeratePhysicalDevices; 3772 } 3773 if (!strcmp(name, "vkGetPhysicalDeviceFeatures")) 3774 { 3775 return (void*)entry_vkGetPhysicalDeviceFeatures; 3776 } 3777 if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties")) 3778 { 3779 return (void*)entry_vkGetPhysicalDeviceFormatProperties; 3780 } 3781 if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties")) 3782 { 3783 return (void*)entry_vkGetPhysicalDeviceImageFormatProperties; 3784 } 3785 if (!strcmp(name, "vkGetPhysicalDeviceProperties")) 3786 { 3787 return (void*)entry_vkGetPhysicalDeviceProperties; 3788 } 3789 if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties")) 3790 { 3791 return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties; 3792 } 3793 if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties")) 3794 { 3795 return (void*)entry_vkGetPhysicalDeviceMemoryProperties; 3796 } 3797 if (!strcmp(name, "vkGetInstanceProcAddr")) 3798 { 3799 return (void*)entry_vkGetInstanceProcAddr; 3800 } 3801 if (!strcmp(name, "vkGetDeviceProcAddr")) 3802 { 3803 return (void*)entry_vkGetDeviceProcAddr; 3804 } 3805 if (!strcmp(name, "vkCreateDevice")) 3806 { 3807 return (void*)entry_vkCreateDevice; 3808 } 3809 if (!strcmp(name, "vkDestroyDevice")) 3810 { 3811 return (void*)entry_vkDestroyDevice; 3812 } 3813 if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) 3814 { 3815 return (void*)entry_vkEnumerateInstanceExtensionProperties; 3816 } 3817 if (!strcmp(name, "vkEnumerateDeviceExtensionProperties")) 3818 { 3819 return (void*)entry_vkEnumerateDeviceExtensionProperties; 3820 } 3821 if (!strcmp(name, "vkEnumerateInstanceLayerProperties")) 3822 { 3823 return (void*)entry_vkEnumerateInstanceLayerProperties; 3824 } 3825 if (!strcmp(name, "vkEnumerateDeviceLayerProperties")) 3826 { 3827 return (void*)entry_vkEnumerateDeviceLayerProperties; 3828 } 3829 if (!strcmp(name, "vkGetDeviceQueue")) 3830 { 3831 return (void*)entry_vkGetDeviceQueue; 3832 } 3833 if (!strcmp(name, "vkQueueSubmit")) 3834 { 3835 return (void*)entry_vkQueueSubmit; 3836 } 3837 if (!strcmp(name, "vkQueueWaitIdle")) 3838 { 3839 return (void*)entry_vkQueueWaitIdle; 3840 } 3841 if (!strcmp(name, "vkDeviceWaitIdle")) 3842 { 3843 return (void*)entry_vkDeviceWaitIdle; 3844 } 3845 if (!strcmp(name, "vkAllocateMemory")) 3846 { 3847 return (void*)entry_vkAllocateMemory; 3848 } 3849 if (!strcmp(name, "vkFreeMemory")) 3850 { 3851 return (void*)entry_vkFreeMemory; 3852 } 3853 if (!strcmp(name, "vkMapMemory")) 3854 { 3855 return (void*)entry_vkMapMemory; 3856 } 3857 if (!strcmp(name, "vkUnmapMemory")) 3858 { 3859 return (void*)entry_vkUnmapMemory; 3860 } 3861 if (!strcmp(name, "vkFlushMappedMemoryRanges")) 3862 { 3863 return (void*)entry_vkFlushMappedMemoryRanges; 3864 } 3865 if (!strcmp(name, "vkInvalidateMappedMemoryRanges")) 3866 { 3867 return (void*)entry_vkInvalidateMappedMemoryRanges; 3868 } 3869 if (!strcmp(name, "vkGetDeviceMemoryCommitment")) 3870 { 3871 return (void*)entry_vkGetDeviceMemoryCommitment; 3872 } 3873 if (!strcmp(name, "vkBindBufferMemory")) 3874 { 3875 return (void*)entry_vkBindBufferMemory; 3876 } 3877 if (!strcmp(name, "vkBindImageMemory")) 3878 { 3879 return (void*)entry_vkBindImageMemory; 3880 } 3881 if (!strcmp(name, "vkGetBufferMemoryRequirements")) 3882 { 3883 return (void*)entry_vkGetBufferMemoryRequirements; 3884 } 3885 if (!strcmp(name, "vkGetImageMemoryRequirements")) 3886 { 3887 return (void*)entry_vkGetImageMemoryRequirements; 3888 } 3889 if (!strcmp(name, "vkGetImageSparseMemoryRequirements")) 3890 { 3891 return (void*)entry_vkGetImageSparseMemoryRequirements; 3892 } 3893 if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties")) 3894 { 3895 return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties; 3896 } 3897 if (!strcmp(name, "vkQueueBindSparse")) 3898 { 3899 return (void*)entry_vkQueueBindSparse; 3900 } 3901 if (!strcmp(name, "vkCreateFence")) 3902 { 3903 return (void*)entry_vkCreateFence; 3904 } 3905 if (!strcmp(name, "vkDestroyFence")) 3906 { 3907 return (void*)entry_vkDestroyFence; 3908 } 3909 if (!strcmp(name, "vkResetFences")) 3910 { 3911 return (void*)entry_vkResetFences; 3912 } 3913 if (!strcmp(name, "vkGetFenceStatus")) 3914 { 3915 return (void*)entry_vkGetFenceStatus; 3916 } 3917 if (!strcmp(name, "vkWaitForFences")) 3918 { 3919 return (void*)entry_vkWaitForFences; 3920 } 3921 if (!strcmp(name, "vkCreateSemaphore")) 3922 { 3923 return (void*)entry_vkCreateSemaphore; 3924 } 3925 if (!strcmp(name, "vkDestroySemaphore")) 3926 { 3927 return (void*)entry_vkDestroySemaphore; 3928 } 3929 if (!strcmp(name, "vkCreateEvent")) 3930 { 3931 return (void*)entry_vkCreateEvent; 3932 } 3933 if (!strcmp(name, "vkDestroyEvent")) 3934 { 3935 return (void*)entry_vkDestroyEvent; 3936 } 3937 if (!strcmp(name, "vkGetEventStatus")) 3938 { 3939 return (void*)entry_vkGetEventStatus; 3940 } 3941 if (!strcmp(name, "vkSetEvent")) 3942 { 3943 return (void*)entry_vkSetEvent; 3944 } 3945 if (!strcmp(name, "vkResetEvent")) 3946 { 3947 return (void*)entry_vkResetEvent; 3948 } 3949 if (!strcmp(name, "vkCreateQueryPool")) 3950 { 3951 return (void*)entry_vkCreateQueryPool; 3952 } 3953 if (!strcmp(name, "vkDestroyQueryPool")) 3954 { 3955 return (void*)entry_vkDestroyQueryPool; 3956 } 3957 if (!strcmp(name, "vkGetQueryPoolResults")) 3958 { 3959 return (void*)entry_vkGetQueryPoolResults; 3960 } 3961 if (!strcmp(name, "vkCreateBuffer")) 3962 { 3963 return (void*)entry_vkCreateBuffer; 3964 } 3965 if (!strcmp(name, "vkDestroyBuffer")) 3966 { 3967 return (void*)entry_vkDestroyBuffer; 3968 } 3969 if (!strcmp(name, "vkCreateBufferView")) 3970 { 3971 return (void*)entry_vkCreateBufferView; 3972 } 3973 if (!strcmp(name, "vkDestroyBufferView")) 3974 { 3975 return (void*)entry_vkDestroyBufferView; 3976 } 3977 if (!strcmp(name, "vkCreateImage")) 3978 { 3979 return (void*)entry_vkCreateImage; 3980 } 3981 if (!strcmp(name, "vkDestroyImage")) 3982 { 3983 return (void*)entry_vkDestroyImage; 3984 } 3985 if (!strcmp(name, "vkGetImageSubresourceLayout")) 3986 { 3987 return (void*)entry_vkGetImageSubresourceLayout; 3988 } 3989 if (!strcmp(name, "vkCreateImageView")) 3990 { 3991 return (void*)entry_vkCreateImageView; 3992 } 3993 if (!strcmp(name, "vkDestroyImageView")) 3994 { 3995 return (void*)entry_vkDestroyImageView; 3996 } 3997 if (!strcmp(name, "vkCreateShaderModule")) 3998 { 3999 return (void*)entry_vkCreateShaderModule; 4000 } 4001 if (!strcmp(name, "vkDestroyShaderModule")) 4002 { 4003 return (void*)entry_vkDestroyShaderModule; 4004 } 4005 if (!strcmp(name, "vkCreatePipelineCache")) 4006 { 4007 return (void*)entry_vkCreatePipelineCache; 4008 } 4009 if (!strcmp(name, "vkDestroyPipelineCache")) 4010 { 4011 return (void*)entry_vkDestroyPipelineCache; 4012 } 4013 if (!strcmp(name, "vkGetPipelineCacheData")) 4014 { 4015 return (void*)entry_vkGetPipelineCacheData; 4016 } 4017 if (!strcmp(name, "vkMergePipelineCaches")) 4018 { 4019 return (void*)entry_vkMergePipelineCaches; 4020 } 4021 if (!strcmp(name, "vkCreateGraphicsPipelines")) 4022 { 4023 return (void*)entry_vkCreateGraphicsPipelines; 4024 } 4025 if (!strcmp(name, "vkCreateComputePipelines")) 4026 { 4027 return (void*)entry_vkCreateComputePipelines; 4028 } 4029 if (!strcmp(name, "vkDestroyPipeline")) 4030 { 4031 return (void*)entry_vkDestroyPipeline; 4032 } 4033 if (!strcmp(name, "vkCreatePipelineLayout")) 4034 { 4035 return (void*)entry_vkCreatePipelineLayout; 4036 } 4037 if (!strcmp(name, "vkDestroyPipelineLayout")) 4038 { 4039 return (void*)entry_vkDestroyPipelineLayout; 4040 } 4041 if (!strcmp(name, "vkCreateSampler")) 4042 { 4043 return (void*)entry_vkCreateSampler; 4044 } 4045 if (!strcmp(name, "vkDestroySampler")) 4046 { 4047 return (void*)entry_vkDestroySampler; 4048 } 4049 if (!strcmp(name, "vkCreateDescriptorSetLayout")) 4050 { 4051 return (void*)entry_vkCreateDescriptorSetLayout; 4052 } 4053 if (!strcmp(name, "vkDestroyDescriptorSetLayout")) 4054 { 4055 return (void*)entry_vkDestroyDescriptorSetLayout; 4056 } 4057 if (!strcmp(name, "vkCreateDescriptorPool")) 4058 { 4059 return (void*)entry_vkCreateDescriptorPool; 4060 } 4061 if (!strcmp(name, "vkDestroyDescriptorPool")) 4062 { 4063 return (void*)entry_vkDestroyDescriptorPool; 4064 } 4065 if (!strcmp(name, "vkResetDescriptorPool")) 4066 { 4067 return (void*)entry_vkResetDescriptorPool; 4068 } 4069 if (!strcmp(name, "vkAllocateDescriptorSets")) 4070 { 4071 return (void*)entry_vkAllocateDescriptorSets; 4072 } 4073 if (!strcmp(name, "vkFreeDescriptorSets")) 4074 { 4075 return (void*)entry_vkFreeDescriptorSets; 4076 } 4077 if (!strcmp(name, "vkUpdateDescriptorSets")) 4078 { 4079 return (void*)entry_vkUpdateDescriptorSets; 4080 } 4081 if (!strcmp(name, "vkCreateFramebuffer")) 4082 { 4083 return (void*)entry_vkCreateFramebuffer; 4084 } 4085 if (!strcmp(name, "vkDestroyFramebuffer")) 4086 { 4087 return (void*)entry_vkDestroyFramebuffer; 4088 } 4089 if (!strcmp(name, "vkCreateRenderPass")) 4090 { 4091 return (void*)entry_vkCreateRenderPass; 4092 } 4093 if (!strcmp(name, "vkDestroyRenderPass")) 4094 { 4095 return (void*)entry_vkDestroyRenderPass; 4096 } 4097 if (!strcmp(name, "vkGetRenderAreaGranularity")) 4098 { 4099 return (void*)entry_vkGetRenderAreaGranularity; 4100 } 4101 if (!strcmp(name, "vkCreateCommandPool")) 4102 { 4103 return (void*)entry_vkCreateCommandPool; 4104 } 4105 if (!strcmp(name, "vkDestroyCommandPool")) 4106 { 4107 return (void*)entry_vkDestroyCommandPool; 4108 } 4109 if (!strcmp(name, "vkResetCommandPool")) 4110 { 4111 return (void*)entry_vkResetCommandPool; 4112 } 4113 if (!strcmp(name, "vkAllocateCommandBuffers")) 4114 { 4115 return (void*)entry_vkAllocateCommandBuffers; 4116 } 4117 if (!strcmp(name, "vkFreeCommandBuffers")) 4118 { 4119 return (void*)entry_vkFreeCommandBuffers; 4120 } 4121 if (!strcmp(name, "vkBeginCommandBuffer")) 4122 { 4123 return (void*)entry_vkBeginCommandBuffer; 4124 } 4125 if (!strcmp(name, "vkEndCommandBuffer")) 4126 { 4127 return (void*)entry_vkEndCommandBuffer; 4128 } 4129 if (!strcmp(name, "vkResetCommandBuffer")) 4130 { 4131 return (void*)entry_vkResetCommandBuffer; 4132 } 4133 if (!strcmp(name, "vkCmdBindPipeline")) 4134 { 4135 return (void*)entry_vkCmdBindPipeline; 4136 } 4137 if (!strcmp(name, "vkCmdSetViewport")) 4138 { 4139 return (void*)entry_vkCmdSetViewport; 4140 } 4141 if (!strcmp(name, "vkCmdSetScissor")) 4142 { 4143 return (void*)entry_vkCmdSetScissor; 4144 } 4145 if (!strcmp(name, "vkCmdSetLineWidth")) 4146 { 4147 return (void*)entry_vkCmdSetLineWidth; 4148 } 4149 if (!strcmp(name, "vkCmdSetDepthBias")) 4150 { 4151 return (void*)entry_vkCmdSetDepthBias; 4152 } 4153 if (!strcmp(name, "vkCmdSetBlendConstants")) 4154 { 4155 return (void*)entry_vkCmdSetBlendConstants; 4156 } 4157 if (!strcmp(name, "vkCmdSetDepthBounds")) 4158 { 4159 return (void*)entry_vkCmdSetDepthBounds; 4160 } 4161 if (!strcmp(name, "vkCmdSetStencilCompareMask")) 4162 { 4163 return (void*)entry_vkCmdSetStencilCompareMask; 4164 } 4165 if (!strcmp(name, "vkCmdSetStencilWriteMask")) 4166 { 4167 return (void*)entry_vkCmdSetStencilWriteMask; 4168 } 4169 if (!strcmp(name, "vkCmdSetStencilReference")) 4170 { 4171 return (void*)entry_vkCmdSetStencilReference; 4172 } 4173 if (!strcmp(name, "vkCmdBindDescriptorSets")) 4174 { 4175 return (void*)entry_vkCmdBindDescriptorSets; 4176 } 4177 if (!strcmp(name, "vkCmdBindIndexBuffer")) 4178 { 4179 return (void*)entry_vkCmdBindIndexBuffer; 4180 } 4181 if (!strcmp(name, "vkCmdBindVertexBuffers")) 4182 { 4183 return (void*)entry_vkCmdBindVertexBuffers; 4184 } 4185 if (!strcmp(name, "vkCmdDraw")) 4186 { 4187 return (void*)entry_vkCmdDraw; 4188 } 4189 if (!strcmp(name, "vkCmdDrawIndexed")) 4190 { 4191 return (void*)entry_vkCmdDrawIndexed; 4192 } 4193 if (!strcmp(name, "vkCmdDrawIndirect")) 4194 { 4195 return (void*)entry_vkCmdDrawIndirect; 4196 } 4197 if (!strcmp(name, "vkCmdDrawIndexedIndirect")) 4198 { 4199 return (void*)entry_vkCmdDrawIndexedIndirect; 4200 } 4201 if (!strcmp(name, "vkCmdDispatch")) 4202 { 4203 return (void*)entry_vkCmdDispatch; 4204 } 4205 if (!strcmp(name, "vkCmdDispatchIndirect")) 4206 { 4207 return (void*)entry_vkCmdDispatchIndirect; 4208 } 4209 if (!strcmp(name, "vkCmdCopyBuffer")) 4210 { 4211 return (void*)entry_vkCmdCopyBuffer; 4212 } 4213 if (!strcmp(name, "vkCmdCopyImage")) 4214 { 4215 return (void*)entry_vkCmdCopyImage; 4216 } 4217 if (!strcmp(name, "vkCmdBlitImage")) 4218 { 4219 return (void*)entry_vkCmdBlitImage; 4220 } 4221 if (!strcmp(name, "vkCmdCopyBufferToImage")) 4222 { 4223 return (void*)entry_vkCmdCopyBufferToImage; 4224 } 4225 if (!strcmp(name, "vkCmdCopyImageToBuffer")) 4226 { 4227 return (void*)entry_vkCmdCopyImageToBuffer; 4228 } 4229 if (!strcmp(name, "vkCmdUpdateBuffer")) 4230 { 4231 return (void*)entry_vkCmdUpdateBuffer; 4232 } 4233 if (!strcmp(name, "vkCmdFillBuffer")) 4234 { 4235 return (void*)entry_vkCmdFillBuffer; 4236 } 4237 if (!strcmp(name, "vkCmdClearColorImage")) 4238 { 4239 return (void*)entry_vkCmdClearColorImage; 4240 } 4241 if (!strcmp(name, "vkCmdClearDepthStencilImage")) 4242 { 4243 return (void*)entry_vkCmdClearDepthStencilImage; 4244 } 4245 if (!strcmp(name, "vkCmdClearAttachments")) 4246 { 4247 return (void*)entry_vkCmdClearAttachments; 4248 } 4249 if (!strcmp(name, "vkCmdResolveImage")) 4250 { 4251 return (void*)entry_vkCmdResolveImage; 4252 } 4253 if (!strcmp(name, "vkCmdSetEvent")) 4254 { 4255 return (void*)entry_vkCmdSetEvent; 4256 } 4257 if (!strcmp(name, "vkCmdResetEvent")) 4258 { 4259 return (void*)entry_vkCmdResetEvent; 4260 } 4261 if (!strcmp(name, "vkCmdWaitEvents")) 4262 { 4263 return (void*)entry_vkCmdWaitEvents; 4264 } 4265 if (!strcmp(name, "vkCmdPipelineBarrier")) 4266 { 4267 return (void*)entry_vkCmdPipelineBarrier; 4268 } 4269 if (!strcmp(name, "vkCmdBeginQuery")) 4270 { 4271 return (void*)entry_vkCmdBeginQuery; 4272 } 4273 if (!strcmp(name, "vkCmdEndQuery")) 4274 { 4275 return (void*)entry_vkCmdEndQuery; 4276 } 4277 if (!strcmp(name, "vkCmdResetQueryPool")) 4278 { 4279 return (void*)entry_vkCmdResetQueryPool; 4280 } 4281 if (!strcmp(name, "vkCmdWriteTimestamp")) 4282 { 4283 return (void*)entry_vkCmdWriteTimestamp; 4284 } 4285 if (!strcmp(name, "vkCmdCopyQueryPoolResults")) 4286 { 4287 return (void*)entry_vkCmdCopyQueryPoolResults; 4288 } 4289 if (!strcmp(name, "vkCmdPushConstants")) 4290 { 4291 return (void*)entry_vkCmdPushConstants; 4292 } 4293 if (!strcmp(name, "vkCmdBeginRenderPass")) 4294 { 4295 return (void*)entry_vkCmdBeginRenderPass; 4296 } 4297 if (!strcmp(name, "vkCmdNextSubpass")) 4298 { 4299 return (void*)entry_vkCmdNextSubpass; 4300 } 4301 if (!strcmp(name, "vkCmdEndRenderPass")) 4302 { 4303 return (void*)entry_vkCmdEndRenderPass; 4304 } 4305 if (!strcmp(name, "vkCmdExecuteCommands")) 4306 { 4307 return (void*)entry_vkCmdExecuteCommands; 4308 } 4309 #endif 4310 #ifdef VK_VERSION_1_1 4311 if (!strcmp(name, "vkEnumerateInstanceVersion")) 4312 { 4313 return nullptr; 4314 } 4315 if (!strcmp(name, "vkBindBufferMemory2")) 4316 { 4317 return nullptr; 4318 } 4319 if (!strcmp(name, "vkBindImageMemory2")) 4320 { 4321 return nullptr; 4322 } 4323 if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures")) 4324 { 4325 return nullptr; 4326 } 4327 if (!strcmp(name, "vkCmdSetDeviceMask")) 4328 { 4329 return nullptr; 4330 } 4331 if (!strcmp(name, "vkCmdDispatchBase")) 4332 { 4333 return nullptr; 4334 } 4335 if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups")) 4336 { 4337 return nullptr; 4338 } 4339 if (!strcmp(name, "vkGetImageMemoryRequirements2")) 4340 { 4341 return nullptr; 4342 } 4343 if (!strcmp(name, "vkGetBufferMemoryRequirements2")) 4344 { 4345 return nullptr; 4346 } 4347 if (!strcmp(name, "vkGetImageSparseMemoryRequirements2")) 4348 { 4349 return nullptr; 4350 } 4351 if (!strcmp(name, "vkGetPhysicalDeviceFeatures2")) 4352 { 4353 return nullptr; 4354 } 4355 if (!strcmp(name, "vkGetPhysicalDeviceProperties2")) 4356 { 4357 return nullptr; 4358 } 4359 if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2")) 4360 { 4361 return nullptr; 4362 } 4363 if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2")) 4364 { 4365 return nullptr; 4366 } 4367 if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2")) 4368 { 4369 return nullptr; 4370 } 4371 if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2")) 4372 { 4373 return nullptr; 4374 } 4375 if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2")) 4376 { 4377 return nullptr; 4378 } 4379 if (!strcmp(name, "vkTrimCommandPool")) 4380 { 4381 return nullptr; 4382 } 4383 if (!strcmp(name, "vkGetDeviceQueue2")) 4384 { 4385 return nullptr; 4386 } 4387 if (!strcmp(name, "vkCreateSamplerYcbcrConversion")) 4388 { 4389 return nullptr; 4390 } 4391 if (!strcmp(name, "vkDestroySamplerYcbcrConversion")) 4392 { 4393 return nullptr; 4394 } 4395 if (!strcmp(name, "vkCreateDescriptorUpdateTemplate")) 4396 { 4397 return nullptr; 4398 } 4399 if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate")) 4400 { 4401 return nullptr; 4402 } 4403 if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate")) 4404 { 4405 return nullptr; 4406 } 4407 if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties")) 4408 { 4409 return nullptr; 4410 } 4411 if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties")) 4412 { 4413 return nullptr; 4414 } 4415 if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties")) 4416 { 4417 return nullptr; 4418 } 4419 if (!strcmp(name, "vkGetDescriptorSetLayoutSupport")) 4420 { 4421 return nullptr; 4422 } 4423 #endif 4424 #ifdef VK_KHR_surface 4425 if (!strcmp(name, "vkDestroySurfaceKHR")) 4426 { 4427 return nullptr; 4428 } 4429 if (!strcmp(name, "vkGetPhysicalDeviceSurfaceSupportKHR")) 4430 { 4431 return nullptr; 4432 } 4433 if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR")) 4434 { 4435 return nullptr; 4436 } 4437 if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormatsKHR")) 4438 { 4439 return nullptr; 4440 } 4441 if (!strcmp(name, "vkGetPhysicalDeviceSurfacePresentModesKHR")) 4442 { 4443 return nullptr; 4444 } 4445 #endif 4446 #ifdef VK_KHR_swapchain 4447 if (!strcmp(name, "vkCreateSwapchainKHR")) 4448 { 4449 return nullptr; 4450 } 4451 if (!strcmp(name, "vkDestroySwapchainKHR")) 4452 { 4453 return nullptr; 4454 } 4455 if (!strcmp(name, "vkGetSwapchainImagesKHR")) 4456 { 4457 return nullptr; 4458 } 4459 if (!strcmp(name, "vkAcquireNextImageKHR")) 4460 { 4461 return nullptr; 4462 } 4463 if (!strcmp(name, "vkQueuePresentKHR")) 4464 { 4465 return nullptr; 4466 } 4467 if (!strcmp(name, "vkGetDeviceGroupPresentCapabilitiesKHR")) 4468 { 4469 return nullptr; 4470 } 4471 if (!strcmp(name, "vkGetDeviceGroupSurfacePresentModesKHR")) 4472 { 4473 return nullptr; 4474 } 4475 if (!strcmp(name, "vkGetPhysicalDevicePresentRectanglesKHR")) 4476 { 4477 return nullptr; 4478 } 4479 if (!strcmp(name, "vkAcquireNextImage2KHR")) 4480 { 4481 return nullptr; 4482 } 4483 #endif 4484 #ifdef VK_KHR_display 4485 if (!strcmp(name, "vkGetPhysicalDeviceDisplayPropertiesKHR")) 4486 { 4487 return nullptr; 4488 } 4489 if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR")) 4490 { 4491 return nullptr; 4492 } 4493 if (!strcmp(name, "vkGetDisplayPlaneSupportedDisplaysKHR")) 4494 { 4495 return nullptr; 4496 } 4497 if (!strcmp(name, "vkGetDisplayModePropertiesKHR")) 4498 { 4499 return nullptr; 4500 } 4501 if (!strcmp(name, "vkCreateDisplayModeKHR")) 4502 { 4503 return nullptr; 4504 } 4505 if (!strcmp(name, "vkGetDisplayPlaneCapabilitiesKHR")) 4506 { 4507 return nullptr; 4508 } 4509 if (!strcmp(name, "vkCreateDisplayPlaneSurfaceKHR")) 4510 { 4511 return nullptr; 4512 } 4513 #endif 4514 #ifdef VK_KHR_display_swapchain 4515 if (!strcmp(name, "vkCreateSharedSwapchainsKHR")) 4516 { 4517 return nullptr; 4518 } 4519 #endif 4520 #ifdef VK_KHR_xlib_surface 4521 if (!strcmp(name, "vkCreateXlibSurfaceKHR")) 4522 { 4523 return nullptr; 4524 } 4525 if (!strcmp(name, "vkGetPhysicalDeviceXlibPresentationSupportKHR")) 4526 { 4527 return nullptr; 4528 } 4529 #endif 4530 #ifdef VK_KHR_xcb_surface 4531 if (!strcmp(name, "vkCreateXcbSurfaceKHR")) 4532 { 4533 return nullptr; 4534 } 4535 if (!strcmp(name, "vkGetPhysicalDeviceXcbPresentationSupportKHR")) 4536 { 4537 return nullptr; 4538 } 4539 #endif 4540 #ifdef VK_KHR_wayland_surface 4541 if (!strcmp(name, "vkCreateWaylandSurfaceKHR")) 4542 { 4543 return nullptr; 4544 } 4545 if (!strcmp(name, "vkGetPhysicalDeviceWaylandPresentationSupportKHR")) 4546 { 4547 return nullptr; 4548 } 4549 #endif 4550 #ifdef VK_KHR_mir_surface 4551 if (!strcmp(name, "vkCreateMirSurfaceKHR")) 4552 { 4553 return nullptr; 4554 } 4555 if (!strcmp(name, "vkGetPhysicalDeviceMirPresentationSupportKHR")) 4556 { 4557 return nullptr; 4558 } 4559 #endif 4560 #ifdef VK_KHR_android_surface 4561 if (!strcmp(name, "vkCreateAndroidSurfaceKHR")) 4562 { 4563 return nullptr; 4564 } 4565 #endif 4566 #ifdef VK_KHR_win32_surface 4567 if (!strcmp(name, "vkCreateWin32SurfaceKHR")) 4568 { 4569 return nullptr; 4570 } 4571 if (!strcmp(name, "vkGetPhysicalDeviceWin32PresentationSupportKHR")) 4572 { 4573 return nullptr; 4574 } 4575 #endif 4576 #ifdef VK_KHR_get_physical_device_properties2 4577 if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR")) 4578 { 4579 return nullptr; 4580 } 4581 if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR")) 4582 { 4583 return nullptr; 4584 } 4585 if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR")) 4586 { 4587 return nullptr; 4588 } 4589 if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR")) 4590 { 4591 return nullptr; 4592 } 4593 if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR")) 4594 { 4595 return nullptr; 4596 } 4597 if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR")) 4598 { 4599 return nullptr; 4600 } 4601 if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")) 4602 { 4603 return nullptr; 4604 } 4605 #endif 4606 #ifdef VK_KHR_device_group 4607 if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeaturesKHR")) 4608 { 4609 return nullptr; 4610 } 4611 if (!strcmp(name, "vkCmdSetDeviceMaskKHR")) 4612 { 4613 return nullptr; 4614 } 4615 if (!strcmp(name, "vkCmdDispatchBaseKHR")) 4616 { 4617 return nullptr; 4618 } 4619 #endif 4620 #ifdef VK_KHR_maintenance1 4621 if (!strcmp(name, "vkTrimCommandPoolKHR")) 4622 { 4623 return nullptr; 4624 } 4625 #endif 4626 #ifdef VK_KHR_device_group_creation 4627 if (!strcmp(name, "vkEnumeratePhysicalDeviceGroupsKHR")) 4628 { 4629 return nullptr; 4630 } 4631 #endif 4632 #ifdef VK_KHR_external_memory_capabilities 4633 if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR")) 4634 { 4635 return nullptr; 4636 } 4637 #endif 4638 #ifdef VK_KHR_external_memory_win32 4639 if (!strcmp(name, "vkGetMemoryWin32HandleKHR")) 4640 { 4641 return nullptr; 4642 } 4643 if (!strcmp(name, "vkGetMemoryWin32HandlePropertiesKHR")) 4644 { 4645 return nullptr; 4646 } 4647 #endif 4648 #ifdef VK_KHR_external_memory_fd 4649 if (!strcmp(name, "vkGetMemoryFdKHR")) 4650 { 4651 return nullptr; 4652 } 4653 if (!strcmp(name, "vkGetMemoryFdPropertiesKHR")) 4654 { 4655 return nullptr; 4656 } 4657 #endif 4658 #ifdef VK_KHR_external_semaphore_capabilities 4659 if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")) 4660 { 4661 return nullptr; 4662 } 4663 #endif 4664 #ifdef VK_KHR_external_semaphore_win32 4665 if (!strcmp(name, "vkImportSemaphoreWin32HandleKHR")) 4666 { 4667 return nullptr; 4668 } 4669 if (!strcmp(name, "vkGetSemaphoreWin32HandleKHR")) 4670 { 4671 return nullptr; 4672 } 4673 #endif 4674 #ifdef VK_KHR_external_semaphore_fd 4675 if (!strcmp(name, "vkImportSemaphoreFdKHR")) 4676 { 4677 return nullptr; 4678 } 4679 if (!strcmp(name, "vkGetSemaphoreFdKHR")) 4680 { 4681 return nullptr; 4682 } 4683 #endif 4684 #ifdef VK_KHR_push_descriptor 4685 if (!strcmp(name, "vkCmdPushDescriptorSetKHR")) 4686 { 4687 return nullptr; 4688 } 4689 if (!strcmp(name, "vkCmdPushDescriptorSetWithTemplateKHR")) 4690 { 4691 return nullptr; 4692 } 4693 #endif 4694 #ifdef VK_KHR_descriptor_update_template 4695 if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR")) 4696 { 4697 return nullptr; 4698 } 4699 if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR")) 4700 { 4701 return nullptr; 4702 } 4703 if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR")) 4704 { 4705 return nullptr; 4706 } 4707 #endif 4708 #ifdef VK_KHR_create_renderpass2 4709 if (!strcmp(name, "vkCreateRenderPass2KHR")) 4710 { 4711 return nullptr; 4712 } 4713 if (!strcmp(name, "vkCmdBeginRenderPass2KHR")) 4714 { 4715 return nullptr; 4716 } 4717 if (!strcmp(name, "vkCmdNextSubpass2KHR")) 4718 { 4719 return nullptr; 4720 } 4721 if (!strcmp(name, "vkCmdEndRenderPass2KHR")) 4722 { 4723 return nullptr; 4724 } 4725 #endif 4726 #ifdef VK_KHR_shared_presentable_image 4727 if (!strcmp(name, "vkGetSwapchainStatusKHR")) 4728 { 4729 return nullptr; 4730 } 4731 #endif 4732 #ifdef VK_KHR_external_fence_capabilities 4733 if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR")) 4734 { 4735 return nullptr; 4736 } 4737 #endif 4738 #ifdef VK_KHR_external_fence_win32 4739 if (!strcmp(name, "vkImportFenceWin32HandleKHR")) 4740 { 4741 return nullptr; 4742 } 4743 if (!strcmp(name, "vkGetFenceWin32HandleKHR")) 4744 { 4745 return nullptr; 4746 } 4747 #endif 4748 #ifdef VK_KHR_external_fence_fd 4749 if (!strcmp(name, "vkImportFenceFdKHR")) 4750 { 4751 return nullptr; 4752 } 4753 if (!strcmp(name, "vkGetFenceFdKHR")) 4754 { 4755 return nullptr; 4756 } 4757 #endif 4758 #ifdef VK_KHR_get_surface_capabilities2 4759 if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2KHR")) 4760 { 4761 return nullptr; 4762 } 4763 if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormats2KHR")) 4764 { 4765 return nullptr; 4766 } 4767 #endif 4768 #ifdef VK_KHR_get_display_properties2 4769 if (!strcmp(name, "vkGetPhysicalDeviceDisplayProperties2KHR")) 4770 { 4771 return nullptr; 4772 } 4773 if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR")) 4774 { 4775 return nullptr; 4776 } 4777 if (!strcmp(name, "vkGetDisplayModeProperties2KHR")) 4778 { 4779 return nullptr; 4780 } 4781 if (!strcmp(name, "vkGetDisplayPlaneCapabilities2KHR")) 4782 { 4783 return nullptr; 4784 } 4785 #endif 4786 #ifdef VK_KHR_get_memory_requirements2 4787 if (!strcmp(name, "vkGetImageMemoryRequirements2KHR")) 4788 { 4789 return nullptr; 4790 } 4791 if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR")) 4792 { 4793 return nullptr; 4794 } 4795 if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR")) 4796 { 4797 return nullptr; 4798 } 4799 #endif 4800 #ifdef VK_KHR_sampler_ycbcr_conversion 4801 if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR")) 4802 { 4803 return nullptr; 4804 } 4805 if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR")) 4806 { 4807 return nullptr; 4808 } 4809 #endif 4810 #ifdef VK_KHR_bind_memory2 4811 if (!strcmp(name, "vkBindBufferMemory2KHR")) 4812 { 4813 return nullptr; 4814 } 4815 if (!strcmp(name, "vkBindImageMemory2KHR")) 4816 { 4817 return nullptr; 4818 } 4819 #endif 4820 #ifdef VK_KHR_maintenance3 4821 if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR")) 4822 { 4823 return nullptr; 4824 } 4825 #endif 4826 #ifdef VK_KHR_draw_indirect_count 4827 if (!strcmp(name, "vkCmdDrawIndirectCountKHR")) 4828 { 4829 return nullptr; 4830 } 4831 if (!strcmp(name, "vkCmdDrawIndexedIndirectCountKHR")) 4832 { 4833 return nullptr; 4834 } 4835 #endif 4836 #ifdef VK_ANDROID_native_buffer 4837 if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID")) 4838 { 4839 return nullptr; 4840 } 4841 if (!strcmp(name, "vkAcquireImageANDROID")) 4842 { 4843 return nullptr; 4844 } 4845 if (!strcmp(name, "vkQueueSignalReleaseImageANDROID")) 4846 { 4847 return nullptr; 4848 } 4849 #endif 4850 #ifdef VK_EXT_debug_report 4851 if (!strcmp(name, "vkCreateDebugReportCallbackEXT")) 4852 { 4853 return nullptr; 4854 } 4855 if (!strcmp(name, "vkDestroyDebugReportCallbackEXT")) 4856 { 4857 return nullptr; 4858 } 4859 if (!strcmp(name, "vkDebugReportMessageEXT")) 4860 { 4861 return nullptr; 4862 } 4863 #endif 4864 #ifdef VK_EXT_debug_marker 4865 if (!strcmp(name, "vkDebugMarkerSetObjectTagEXT")) 4866 { 4867 return nullptr; 4868 } 4869 if (!strcmp(name, "vkDebugMarkerSetObjectNameEXT")) 4870 { 4871 return nullptr; 4872 } 4873 if (!strcmp(name, "vkCmdDebugMarkerBeginEXT")) 4874 { 4875 return nullptr; 4876 } 4877 if (!strcmp(name, "vkCmdDebugMarkerEndEXT")) 4878 { 4879 return nullptr; 4880 } 4881 if (!strcmp(name, "vkCmdDebugMarkerInsertEXT")) 4882 { 4883 return nullptr; 4884 } 4885 #endif 4886 #ifdef VK_AMD_draw_indirect_count 4887 if (!strcmp(name, "vkCmdDrawIndirectCountAMD")) 4888 { 4889 return nullptr; 4890 } 4891 if (!strcmp(name, "vkCmdDrawIndexedIndirectCountAMD")) 4892 { 4893 return nullptr; 4894 } 4895 #endif 4896 #ifdef VK_AMD_shader_info 4897 if (!strcmp(name, "vkGetShaderInfoAMD")) 4898 { 4899 return nullptr; 4900 } 4901 #endif 4902 #ifdef VK_NV_external_memory_capabilities 4903 if (!strcmp(name, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV")) 4904 { 4905 return nullptr; 4906 } 4907 #endif 4908 #ifdef VK_NV_external_memory_win32 4909 if (!strcmp(name, "vkGetMemoryWin32HandleNV")) 4910 { 4911 return nullptr; 4912 } 4913 #endif 4914 #ifdef VK_NN_vi_surface 4915 if (!strcmp(name, "vkCreateViSurfaceNN")) 4916 { 4917 return nullptr; 4918 } 4919 #endif 4920 #ifdef VK_EXT_conditional_rendering 4921 if (!strcmp(name, "vkCmdBeginConditionalRenderingEXT")) 4922 { 4923 return nullptr; 4924 } 4925 if (!strcmp(name, "vkCmdEndConditionalRenderingEXT")) 4926 { 4927 return nullptr; 4928 } 4929 #endif 4930 #ifdef VK_NVX_device_generated_commands 4931 if (!strcmp(name, "vkCmdProcessCommandsNVX")) 4932 { 4933 return nullptr; 4934 } 4935 if (!strcmp(name, "vkCmdReserveSpaceForCommandsNVX")) 4936 { 4937 return nullptr; 4938 } 4939 if (!strcmp(name, "vkCreateIndirectCommandsLayoutNVX")) 4940 { 4941 return nullptr; 4942 } 4943 if (!strcmp(name, "vkDestroyIndirectCommandsLayoutNVX")) 4944 { 4945 return nullptr; 4946 } 4947 if (!strcmp(name, "vkCreateObjectTableNVX")) 4948 { 4949 return nullptr; 4950 } 4951 if (!strcmp(name, "vkDestroyObjectTableNVX")) 4952 { 4953 return nullptr; 4954 } 4955 if (!strcmp(name, "vkRegisterObjectsNVX")) 4956 { 4957 return nullptr; 4958 } 4959 if (!strcmp(name, "vkUnregisterObjectsNVX")) 4960 { 4961 return nullptr; 4962 } 4963 if (!strcmp(name, "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX")) 4964 { 4965 return nullptr; 4966 } 4967 #endif 4968 #ifdef VK_NV_clip_space_w_scaling 4969 if (!strcmp(name, "vkCmdSetViewportWScalingNV")) 4970 { 4971 return nullptr; 4972 } 4973 #endif 4974 #ifdef VK_EXT_direct_mode_display 4975 if (!strcmp(name, "vkReleaseDisplayEXT")) 4976 { 4977 return nullptr; 4978 } 4979 #endif 4980 #ifdef VK_EXT_acquire_xlib_display 4981 if (!strcmp(name, "vkAcquireXlibDisplayEXT")) 4982 { 4983 return nullptr; 4984 } 4985 if (!strcmp(name, "vkGetRandROutputDisplayEXT")) 4986 { 4987 return nullptr; 4988 } 4989 #endif 4990 #ifdef VK_EXT_display_surface_counter 4991 if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2EXT")) 4992 { 4993 return nullptr; 4994 } 4995 #endif 4996 #ifdef VK_EXT_display_control 4997 if (!strcmp(name, "vkDisplayPowerControlEXT")) 4998 { 4999 return nullptr; 5000 } 5001 if (!strcmp(name, "vkRegisterDeviceEventEXT")) 5002 { 5003 return nullptr; 5004 } 5005 if (!strcmp(name, "vkRegisterDisplayEventEXT")) 5006 { 5007 return nullptr; 5008 } 5009 if (!strcmp(name, "vkGetSwapchainCounterEXT")) 5010 { 5011 return nullptr; 5012 } 5013 #endif 5014 #ifdef VK_GOOGLE_display_timing 5015 if (!strcmp(name, "vkGetRefreshCycleDurationGOOGLE")) 5016 { 5017 return nullptr; 5018 } 5019 if (!strcmp(name, "vkGetPastPresentationTimingGOOGLE")) 5020 { 5021 return nullptr; 5022 } 5023 #endif 5024 #ifdef VK_EXT_discard_rectangles 5025 if (!strcmp(name, "vkCmdSetDiscardRectangleEXT")) 5026 { 5027 return nullptr; 5028 } 5029 #endif 5030 #ifdef VK_EXT_hdr_metadata 5031 if (!strcmp(name, "vkSetHdrMetadataEXT")) 5032 { 5033 return nullptr; 5034 } 5035 #endif 5036 #ifdef VK_MVK_ios_surface 5037 if (!strcmp(name, "vkCreateIOSSurfaceMVK")) 5038 { 5039 return nullptr; 5040 } 5041 #endif 5042 #ifdef VK_MVK_macos_surface 5043 if (!strcmp(name, "vkCreateMacOSSurfaceMVK")) 5044 { 5045 return nullptr; 5046 } 5047 #endif 5048 #ifdef VK_EXT_debug_utils 5049 if (!strcmp(name, "vkSetDebugUtilsObjectNameEXT")) 5050 { 5051 return nullptr; 5052 } 5053 if (!strcmp(name, "vkSetDebugUtilsObjectTagEXT")) 5054 { 5055 return nullptr; 5056 } 5057 if (!strcmp(name, "vkQueueBeginDebugUtilsLabelEXT")) 5058 { 5059 return nullptr; 5060 } 5061 if (!strcmp(name, "vkQueueEndDebugUtilsLabelEXT")) 5062 { 5063 return nullptr; 5064 } 5065 if (!strcmp(name, "vkQueueInsertDebugUtilsLabelEXT")) 5066 { 5067 return nullptr; 5068 } 5069 if (!strcmp(name, "vkCmdBeginDebugUtilsLabelEXT")) 5070 { 5071 return nullptr; 5072 } 5073 if (!strcmp(name, "vkCmdEndDebugUtilsLabelEXT")) 5074 { 5075 return nullptr; 5076 } 5077 if (!strcmp(name, "vkCmdInsertDebugUtilsLabelEXT")) 5078 { 5079 return nullptr; 5080 } 5081 if (!strcmp(name, "vkCreateDebugUtilsMessengerEXT")) 5082 { 5083 return nullptr; 5084 } 5085 if (!strcmp(name, "vkDestroyDebugUtilsMessengerEXT")) 5086 { 5087 return nullptr; 5088 } 5089 if (!strcmp(name, "vkSubmitDebugUtilsMessageEXT")) 5090 { 5091 return nullptr; 5092 } 5093 #endif 5094 #ifdef VK_ANDROID_external_memory_android_hardware_buffer 5095 if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID")) 5096 { 5097 return nullptr; 5098 } 5099 if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID")) 5100 { 5101 return nullptr; 5102 } 5103 #endif 5104 #ifdef VK_EXT_sample_locations 5105 if (!strcmp(name, "vkCmdSetSampleLocationsEXT")) 5106 { 5107 return nullptr; 5108 } 5109 if (!strcmp(name, "vkGetPhysicalDeviceMultisamplePropertiesEXT")) 5110 { 5111 return nullptr; 5112 } 5113 #endif 5114 #ifdef VK_EXT_validation_cache 5115 if (!strcmp(name, "vkCreateValidationCacheEXT")) 5116 { 5117 return nullptr; 5118 } 5119 if (!strcmp(name, "vkDestroyValidationCacheEXT")) 5120 { 5121 return nullptr; 5122 } 5123 if (!strcmp(name, "vkMergeValidationCachesEXT")) 5124 { 5125 return nullptr; 5126 } 5127 if (!strcmp(name, "vkGetValidationCacheDataEXT")) 5128 { 5129 return nullptr; 5130 } 5131 #endif 5132 #ifdef VK_EXT_external_memory_host 5133 if (!strcmp(name, "vkGetMemoryHostPointerPropertiesEXT")) 5134 { 5135 return nullptr; 5136 } 5137 #endif 5138 #ifdef VK_AMD_buffer_marker 5139 if (!strcmp(name, "vkCmdWriteBufferMarkerAMD")) 5140 { 5141 return nullptr; 5142 } 5143 #endif 5144 #ifdef VK_NV_device_diagnostic_checkpoints 5145 if (!strcmp(name, "vkCmdSetCheckpointNV")) 5146 { 5147 return nullptr; 5148 } 5149 if (!strcmp(name, "vkGetQueueCheckpointDataNV")) 5150 { 5151 return nullptr; 5152 } 5153 #endif 5154 #ifdef VK_GOOGLE_address_space 5155 if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE")) 5156 { 5157 return nullptr; 5158 } 5159 #endif 5160 #ifdef VK_GOOGLE_color_buffer 5161 if (!strcmp(name, "vkRegisterImageColorBufferGOOGLE")) 5162 { 5163 return nullptr; 5164 } 5165 if (!strcmp(name, "vkRegisterBufferColorBufferGOOGLE")) 5166 { 5167 return nullptr; 5168 } 5169 #endif 5170 #ifdef VK_GOOGLE_sized_descriptor_update_template 5171 if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSizedGOOGLE")) 5172 { 5173 return nullptr; 5174 } 5175 #endif 5176 #ifdef VK_GOOGLE_async_command_buffers 5177 if (!strcmp(name, "vkBeginCommandBufferAsyncGOOGLE")) 5178 { 5179 return nullptr; 5180 } 5181 if (!strcmp(name, "vkEndCommandBufferAsyncGOOGLE")) 5182 { 5183 return nullptr; 5184 } 5185 if (!strcmp(name, "vkResetCommandBufferAsyncGOOGLE")) 5186 { 5187 return nullptr; 5188 } 5189 #endif 5190 return nullptr; 5191 } 5192 void* goldfish_vulkan_get_instance_proc_address(VkInstance instance, const char* name){ 5193 auto resources = ResourceTracker::get(); 5194 bool has1_1OrHigher = resources->getApiVersionFromInstance(instance) >= VK_API_VERSION_1_1; 5195 #ifdef VK_VERSION_1_0 5196 if (!strcmp(name, "vkCreateInstance")) 5197 { 5198 return (void*)entry_vkCreateInstance; 5199 } 5200 if (!strcmp(name, "vkDestroyInstance")) 5201 { 5202 return (void*)entry_vkDestroyInstance; 5203 } 5204 if (!strcmp(name, "vkEnumeratePhysicalDevices")) 5205 { 5206 return (void*)entry_vkEnumeratePhysicalDevices; 5207 } 5208 if (!strcmp(name, "vkGetPhysicalDeviceFeatures")) 5209 { 5210 return (void*)entry_vkGetPhysicalDeviceFeatures; 5211 } 5212 if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties")) 5213 { 5214 return (void*)entry_vkGetPhysicalDeviceFormatProperties; 5215 } 5216 if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties")) 5217 { 5218 return (void*)entry_vkGetPhysicalDeviceImageFormatProperties; 5219 } 5220 if (!strcmp(name, "vkGetPhysicalDeviceProperties")) 5221 { 5222 return (void*)entry_vkGetPhysicalDeviceProperties; 5223 } 5224 if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties")) 5225 { 5226 return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties; 5227 } 5228 if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties")) 5229 { 5230 return (void*)entry_vkGetPhysicalDeviceMemoryProperties; 5231 } 5232 if (!strcmp(name, "vkGetInstanceProcAddr")) 5233 { 5234 return (void*)entry_vkGetInstanceProcAddr; 5235 } 5236 if (!strcmp(name, "vkGetDeviceProcAddr")) 5237 { 5238 return (void*)entry_vkGetDeviceProcAddr; 5239 } 5240 if (!strcmp(name, "vkCreateDevice")) 5241 { 5242 return (void*)entry_vkCreateDevice; 5243 } 5244 if (!strcmp(name, "vkDestroyDevice")) 5245 { 5246 return (void*)entry_vkDestroyDevice; 5247 } 5248 if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) 5249 { 5250 return (void*)entry_vkEnumerateInstanceExtensionProperties; 5251 } 5252 if (!strcmp(name, "vkEnumerateDeviceExtensionProperties")) 5253 { 5254 return (void*)entry_vkEnumerateDeviceExtensionProperties; 5255 } 5256 if (!strcmp(name, "vkEnumerateInstanceLayerProperties")) 5257 { 5258 return (void*)entry_vkEnumerateInstanceLayerProperties; 5259 } 5260 if (!strcmp(name, "vkEnumerateDeviceLayerProperties")) 5261 { 5262 return (void*)entry_vkEnumerateDeviceLayerProperties; 5263 } 5264 if (!strcmp(name, "vkGetDeviceQueue")) 5265 { 5266 return (void*)entry_vkGetDeviceQueue; 5267 } 5268 if (!strcmp(name, "vkQueueSubmit")) 5269 { 5270 return (void*)entry_vkQueueSubmit; 5271 } 5272 if (!strcmp(name, "vkQueueWaitIdle")) 5273 { 5274 return (void*)entry_vkQueueWaitIdle; 5275 } 5276 if (!strcmp(name, "vkDeviceWaitIdle")) 5277 { 5278 return (void*)entry_vkDeviceWaitIdle; 5279 } 5280 if (!strcmp(name, "vkAllocateMemory")) 5281 { 5282 return (void*)entry_vkAllocateMemory; 5283 } 5284 if (!strcmp(name, "vkFreeMemory")) 5285 { 5286 return (void*)entry_vkFreeMemory; 5287 } 5288 if (!strcmp(name, "vkMapMemory")) 5289 { 5290 return (void*)entry_vkMapMemory; 5291 } 5292 if (!strcmp(name, "vkUnmapMemory")) 5293 { 5294 return (void*)entry_vkUnmapMemory; 5295 } 5296 if (!strcmp(name, "vkFlushMappedMemoryRanges")) 5297 { 5298 return (void*)entry_vkFlushMappedMemoryRanges; 5299 } 5300 if (!strcmp(name, "vkInvalidateMappedMemoryRanges")) 5301 { 5302 return (void*)entry_vkInvalidateMappedMemoryRanges; 5303 } 5304 if (!strcmp(name, "vkGetDeviceMemoryCommitment")) 5305 { 5306 return (void*)entry_vkGetDeviceMemoryCommitment; 5307 } 5308 if (!strcmp(name, "vkBindBufferMemory")) 5309 { 5310 return (void*)entry_vkBindBufferMemory; 5311 } 5312 if (!strcmp(name, "vkBindImageMemory")) 5313 { 5314 return (void*)entry_vkBindImageMemory; 5315 } 5316 if (!strcmp(name, "vkGetBufferMemoryRequirements")) 5317 { 5318 return (void*)entry_vkGetBufferMemoryRequirements; 5319 } 5320 if (!strcmp(name, "vkGetImageMemoryRequirements")) 5321 { 5322 return (void*)entry_vkGetImageMemoryRequirements; 5323 } 5324 if (!strcmp(name, "vkGetImageSparseMemoryRequirements")) 5325 { 5326 return (void*)entry_vkGetImageSparseMemoryRequirements; 5327 } 5328 if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties")) 5329 { 5330 return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties; 5331 } 5332 if (!strcmp(name, "vkQueueBindSparse")) 5333 { 5334 return (void*)entry_vkQueueBindSparse; 5335 } 5336 if (!strcmp(name, "vkCreateFence")) 5337 { 5338 return (void*)entry_vkCreateFence; 5339 } 5340 if (!strcmp(name, "vkDestroyFence")) 5341 { 5342 return (void*)entry_vkDestroyFence; 5343 } 5344 if (!strcmp(name, "vkResetFences")) 5345 { 5346 return (void*)entry_vkResetFences; 5347 } 5348 if (!strcmp(name, "vkGetFenceStatus")) 5349 { 5350 return (void*)entry_vkGetFenceStatus; 5351 } 5352 if (!strcmp(name, "vkWaitForFences")) 5353 { 5354 return (void*)entry_vkWaitForFences; 5355 } 5356 if (!strcmp(name, "vkCreateSemaphore")) 5357 { 5358 return (void*)entry_vkCreateSemaphore; 5359 } 5360 if (!strcmp(name, "vkDestroySemaphore")) 5361 { 5362 return (void*)entry_vkDestroySemaphore; 5363 } 5364 if (!strcmp(name, "vkCreateEvent")) 5365 { 5366 return (void*)entry_vkCreateEvent; 5367 } 5368 if (!strcmp(name, "vkDestroyEvent")) 5369 { 5370 return (void*)entry_vkDestroyEvent; 5371 } 5372 if (!strcmp(name, "vkGetEventStatus")) 5373 { 5374 return (void*)entry_vkGetEventStatus; 5375 } 5376 if (!strcmp(name, "vkSetEvent")) 5377 { 5378 return (void*)entry_vkSetEvent; 5379 } 5380 if (!strcmp(name, "vkResetEvent")) 5381 { 5382 return (void*)entry_vkResetEvent; 5383 } 5384 if (!strcmp(name, "vkCreateQueryPool")) 5385 { 5386 return (void*)entry_vkCreateQueryPool; 5387 } 5388 if (!strcmp(name, "vkDestroyQueryPool")) 5389 { 5390 return (void*)entry_vkDestroyQueryPool; 5391 } 5392 if (!strcmp(name, "vkGetQueryPoolResults")) 5393 { 5394 return (void*)entry_vkGetQueryPoolResults; 5395 } 5396 if (!strcmp(name, "vkCreateBuffer")) 5397 { 5398 return (void*)entry_vkCreateBuffer; 5399 } 5400 if (!strcmp(name, "vkDestroyBuffer")) 5401 { 5402 return (void*)entry_vkDestroyBuffer; 5403 } 5404 if (!strcmp(name, "vkCreateBufferView")) 5405 { 5406 return (void*)entry_vkCreateBufferView; 5407 } 5408 if (!strcmp(name, "vkDestroyBufferView")) 5409 { 5410 return (void*)entry_vkDestroyBufferView; 5411 } 5412 if (!strcmp(name, "vkCreateImage")) 5413 { 5414 return (void*)entry_vkCreateImage; 5415 } 5416 if (!strcmp(name, "vkDestroyImage")) 5417 { 5418 return (void*)entry_vkDestroyImage; 5419 } 5420 if (!strcmp(name, "vkGetImageSubresourceLayout")) 5421 { 5422 return (void*)entry_vkGetImageSubresourceLayout; 5423 } 5424 if (!strcmp(name, "vkCreateImageView")) 5425 { 5426 return (void*)entry_vkCreateImageView; 5427 } 5428 if (!strcmp(name, "vkDestroyImageView")) 5429 { 5430 return (void*)entry_vkDestroyImageView; 5431 } 5432 if (!strcmp(name, "vkCreateShaderModule")) 5433 { 5434 return (void*)entry_vkCreateShaderModule; 5435 } 5436 if (!strcmp(name, "vkDestroyShaderModule")) 5437 { 5438 return (void*)entry_vkDestroyShaderModule; 5439 } 5440 if (!strcmp(name, "vkCreatePipelineCache")) 5441 { 5442 return (void*)entry_vkCreatePipelineCache; 5443 } 5444 if (!strcmp(name, "vkDestroyPipelineCache")) 5445 { 5446 return (void*)entry_vkDestroyPipelineCache; 5447 } 5448 if (!strcmp(name, "vkGetPipelineCacheData")) 5449 { 5450 return (void*)entry_vkGetPipelineCacheData; 5451 } 5452 if (!strcmp(name, "vkMergePipelineCaches")) 5453 { 5454 return (void*)entry_vkMergePipelineCaches; 5455 } 5456 if (!strcmp(name, "vkCreateGraphicsPipelines")) 5457 { 5458 return (void*)entry_vkCreateGraphicsPipelines; 5459 } 5460 if (!strcmp(name, "vkCreateComputePipelines")) 5461 { 5462 return (void*)entry_vkCreateComputePipelines; 5463 } 5464 if (!strcmp(name, "vkDestroyPipeline")) 5465 { 5466 return (void*)entry_vkDestroyPipeline; 5467 } 5468 if (!strcmp(name, "vkCreatePipelineLayout")) 5469 { 5470 return (void*)entry_vkCreatePipelineLayout; 5471 } 5472 if (!strcmp(name, "vkDestroyPipelineLayout")) 5473 { 5474 return (void*)entry_vkDestroyPipelineLayout; 5475 } 5476 if (!strcmp(name, "vkCreateSampler")) 5477 { 5478 return (void*)entry_vkCreateSampler; 5479 } 5480 if (!strcmp(name, "vkDestroySampler")) 5481 { 5482 return (void*)entry_vkDestroySampler; 5483 } 5484 if (!strcmp(name, "vkCreateDescriptorSetLayout")) 5485 { 5486 return (void*)entry_vkCreateDescriptorSetLayout; 5487 } 5488 if (!strcmp(name, "vkDestroyDescriptorSetLayout")) 5489 { 5490 return (void*)entry_vkDestroyDescriptorSetLayout; 5491 } 5492 if (!strcmp(name, "vkCreateDescriptorPool")) 5493 { 5494 return (void*)entry_vkCreateDescriptorPool; 5495 } 5496 if (!strcmp(name, "vkDestroyDescriptorPool")) 5497 { 5498 return (void*)entry_vkDestroyDescriptorPool; 5499 } 5500 if (!strcmp(name, "vkResetDescriptorPool")) 5501 { 5502 return (void*)entry_vkResetDescriptorPool; 5503 } 5504 if (!strcmp(name, "vkAllocateDescriptorSets")) 5505 { 5506 return (void*)entry_vkAllocateDescriptorSets; 5507 } 5508 if (!strcmp(name, "vkFreeDescriptorSets")) 5509 { 5510 return (void*)entry_vkFreeDescriptorSets; 5511 } 5512 if (!strcmp(name, "vkUpdateDescriptorSets")) 5513 { 5514 return (void*)entry_vkUpdateDescriptorSets; 5515 } 5516 if (!strcmp(name, "vkCreateFramebuffer")) 5517 { 5518 return (void*)entry_vkCreateFramebuffer; 5519 } 5520 if (!strcmp(name, "vkDestroyFramebuffer")) 5521 { 5522 return (void*)entry_vkDestroyFramebuffer; 5523 } 5524 if (!strcmp(name, "vkCreateRenderPass")) 5525 { 5526 return (void*)entry_vkCreateRenderPass; 5527 } 5528 if (!strcmp(name, "vkDestroyRenderPass")) 5529 { 5530 return (void*)entry_vkDestroyRenderPass; 5531 } 5532 if (!strcmp(name, "vkGetRenderAreaGranularity")) 5533 { 5534 return (void*)entry_vkGetRenderAreaGranularity; 5535 } 5536 if (!strcmp(name, "vkCreateCommandPool")) 5537 { 5538 return (void*)entry_vkCreateCommandPool; 5539 } 5540 if (!strcmp(name, "vkDestroyCommandPool")) 5541 { 5542 return (void*)entry_vkDestroyCommandPool; 5543 } 5544 if (!strcmp(name, "vkResetCommandPool")) 5545 { 5546 return (void*)entry_vkResetCommandPool; 5547 } 5548 if (!strcmp(name, "vkAllocateCommandBuffers")) 5549 { 5550 return (void*)entry_vkAllocateCommandBuffers; 5551 } 5552 if (!strcmp(name, "vkFreeCommandBuffers")) 5553 { 5554 return (void*)entry_vkFreeCommandBuffers; 5555 } 5556 if (!strcmp(name, "vkBeginCommandBuffer")) 5557 { 5558 return (void*)entry_vkBeginCommandBuffer; 5559 } 5560 if (!strcmp(name, "vkEndCommandBuffer")) 5561 { 5562 return (void*)entry_vkEndCommandBuffer; 5563 } 5564 if (!strcmp(name, "vkResetCommandBuffer")) 5565 { 5566 return (void*)entry_vkResetCommandBuffer; 5567 } 5568 if (!strcmp(name, "vkCmdBindPipeline")) 5569 { 5570 return (void*)entry_vkCmdBindPipeline; 5571 } 5572 if (!strcmp(name, "vkCmdSetViewport")) 5573 { 5574 return (void*)entry_vkCmdSetViewport; 5575 } 5576 if (!strcmp(name, "vkCmdSetScissor")) 5577 { 5578 return (void*)entry_vkCmdSetScissor; 5579 } 5580 if (!strcmp(name, "vkCmdSetLineWidth")) 5581 { 5582 return (void*)entry_vkCmdSetLineWidth; 5583 } 5584 if (!strcmp(name, "vkCmdSetDepthBias")) 5585 { 5586 return (void*)entry_vkCmdSetDepthBias; 5587 } 5588 if (!strcmp(name, "vkCmdSetBlendConstants")) 5589 { 5590 return (void*)entry_vkCmdSetBlendConstants; 5591 } 5592 if (!strcmp(name, "vkCmdSetDepthBounds")) 5593 { 5594 return (void*)entry_vkCmdSetDepthBounds; 5595 } 5596 if (!strcmp(name, "vkCmdSetStencilCompareMask")) 5597 { 5598 return (void*)entry_vkCmdSetStencilCompareMask; 5599 } 5600 if (!strcmp(name, "vkCmdSetStencilWriteMask")) 5601 { 5602 return (void*)entry_vkCmdSetStencilWriteMask; 5603 } 5604 if (!strcmp(name, "vkCmdSetStencilReference")) 5605 { 5606 return (void*)entry_vkCmdSetStencilReference; 5607 } 5608 if (!strcmp(name, "vkCmdBindDescriptorSets")) 5609 { 5610 return (void*)entry_vkCmdBindDescriptorSets; 5611 } 5612 if (!strcmp(name, "vkCmdBindIndexBuffer")) 5613 { 5614 return (void*)entry_vkCmdBindIndexBuffer; 5615 } 5616 if (!strcmp(name, "vkCmdBindVertexBuffers")) 5617 { 5618 return (void*)entry_vkCmdBindVertexBuffers; 5619 } 5620 if (!strcmp(name, "vkCmdDraw")) 5621 { 5622 return (void*)entry_vkCmdDraw; 5623 } 5624 if (!strcmp(name, "vkCmdDrawIndexed")) 5625 { 5626 return (void*)entry_vkCmdDrawIndexed; 5627 } 5628 if (!strcmp(name, "vkCmdDrawIndirect")) 5629 { 5630 return (void*)entry_vkCmdDrawIndirect; 5631 } 5632 if (!strcmp(name, "vkCmdDrawIndexedIndirect")) 5633 { 5634 return (void*)entry_vkCmdDrawIndexedIndirect; 5635 } 5636 if (!strcmp(name, "vkCmdDispatch")) 5637 { 5638 return (void*)entry_vkCmdDispatch; 5639 } 5640 if (!strcmp(name, "vkCmdDispatchIndirect")) 5641 { 5642 return (void*)entry_vkCmdDispatchIndirect; 5643 } 5644 if (!strcmp(name, "vkCmdCopyBuffer")) 5645 { 5646 return (void*)entry_vkCmdCopyBuffer; 5647 } 5648 if (!strcmp(name, "vkCmdCopyImage")) 5649 { 5650 return (void*)entry_vkCmdCopyImage; 5651 } 5652 if (!strcmp(name, "vkCmdBlitImage")) 5653 { 5654 return (void*)entry_vkCmdBlitImage; 5655 } 5656 if (!strcmp(name, "vkCmdCopyBufferToImage")) 5657 { 5658 return (void*)entry_vkCmdCopyBufferToImage; 5659 } 5660 if (!strcmp(name, "vkCmdCopyImageToBuffer")) 5661 { 5662 return (void*)entry_vkCmdCopyImageToBuffer; 5663 } 5664 if (!strcmp(name, "vkCmdUpdateBuffer")) 5665 { 5666 return (void*)entry_vkCmdUpdateBuffer; 5667 } 5668 if (!strcmp(name, "vkCmdFillBuffer")) 5669 { 5670 return (void*)entry_vkCmdFillBuffer; 5671 } 5672 if (!strcmp(name, "vkCmdClearColorImage")) 5673 { 5674 return (void*)entry_vkCmdClearColorImage; 5675 } 5676 if (!strcmp(name, "vkCmdClearDepthStencilImage")) 5677 { 5678 return (void*)entry_vkCmdClearDepthStencilImage; 5679 } 5680 if (!strcmp(name, "vkCmdClearAttachments")) 5681 { 5682 return (void*)entry_vkCmdClearAttachments; 5683 } 5684 if (!strcmp(name, "vkCmdResolveImage")) 5685 { 5686 return (void*)entry_vkCmdResolveImage; 5687 } 5688 if (!strcmp(name, "vkCmdSetEvent")) 5689 { 5690 return (void*)entry_vkCmdSetEvent; 5691 } 5692 if (!strcmp(name, "vkCmdResetEvent")) 5693 { 5694 return (void*)entry_vkCmdResetEvent; 5695 } 5696 if (!strcmp(name, "vkCmdWaitEvents")) 5697 { 5698 return (void*)entry_vkCmdWaitEvents; 5699 } 5700 if (!strcmp(name, "vkCmdPipelineBarrier")) 5701 { 5702 return (void*)entry_vkCmdPipelineBarrier; 5703 } 5704 if (!strcmp(name, "vkCmdBeginQuery")) 5705 { 5706 return (void*)entry_vkCmdBeginQuery; 5707 } 5708 if (!strcmp(name, "vkCmdEndQuery")) 5709 { 5710 return (void*)entry_vkCmdEndQuery; 5711 } 5712 if (!strcmp(name, "vkCmdResetQueryPool")) 5713 { 5714 return (void*)entry_vkCmdResetQueryPool; 5715 } 5716 if (!strcmp(name, "vkCmdWriteTimestamp")) 5717 { 5718 return (void*)entry_vkCmdWriteTimestamp; 5719 } 5720 if (!strcmp(name, "vkCmdCopyQueryPoolResults")) 5721 { 5722 return (void*)entry_vkCmdCopyQueryPoolResults; 5723 } 5724 if (!strcmp(name, "vkCmdPushConstants")) 5725 { 5726 return (void*)entry_vkCmdPushConstants; 5727 } 5728 if (!strcmp(name, "vkCmdBeginRenderPass")) 5729 { 5730 return (void*)entry_vkCmdBeginRenderPass; 5731 } 5732 if (!strcmp(name, "vkCmdNextSubpass")) 5733 { 5734 return (void*)entry_vkCmdNextSubpass; 5735 } 5736 if (!strcmp(name, "vkCmdEndRenderPass")) 5737 { 5738 return (void*)entry_vkCmdEndRenderPass; 5739 } 5740 if (!strcmp(name, "vkCmdExecuteCommands")) 5741 { 5742 return (void*)entry_vkCmdExecuteCommands; 5743 } 5744 #endif 5745 #ifdef VK_VERSION_1_1 5746 if (!strcmp(name, "vkEnumerateInstanceVersion")) 5747 { 5748 return has1_1OrHigher ? (void*)entry_vkEnumerateInstanceVersion : nullptr; 5749 } 5750 if (!strcmp(name, "vkBindBufferMemory2")) 5751 { 5752 return has1_1OrHigher ? (void*)entry_vkBindBufferMemory2 : nullptr; 5753 } 5754 if (!strcmp(name, "vkBindImageMemory2")) 5755 { 5756 return has1_1OrHigher ? (void*)entry_vkBindImageMemory2 : nullptr; 5757 } 5758 if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures")) 5759 { 5760 return has1_1OrHigher ? (void*)entry_vkGetDeviceGroupPeerMemoryFeatures : nullptr; 5761 } 5762 if (!strcmp(name, "vkCmdSetDeviceMask")) 5763 { 5764 return has1_1OrHigher ? (void*)entry_vkCmdSetDeviceMask : nullptr; 5765 } 5766 if (!strcmp(name, "vkCmdDispatchBase")) 5767 { 5768 return has1_1OrHigher ? (void*)entry_vkCmdDispatchBase : nullptr; 5769 } 5770 if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups")) 5771 { 5772 return nullptr; 5773 } 5774 if (!strcmp(name, "vkGetImageMemoryRequirements2")) 5775 { 5776 return has1_1OrHigher ? (void*)entry_vkGetImageMemoryRequirements2 : nullptr; 5777 } 5778 if (!strcmp(name, "vkGetBufferMemoryRequirements2")) 5779 { 5780 return has1_1OrHigher ? (void*)entry_vkGetBufferMemoryRequirements2 : nullptr; 5781 } 5782 if (!strcmp(name, "vkGetImageSparseMemoryRequirements2")) 5783 { 5784 return has1_1OrHigher ? (void*)entry_vkGetImageSparseMemoryRequirements2 : nullptr; 5785 } 5786 if (!strcmp(name, "vkGetPhysicalDeviceFeatures2")) 5787 { 5788 return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFeatures2 : nullptr; 5789 } 5790 if (!strcmp(name, "vkGetPhysicalDeviceProperties2")) 5791 { 5792 return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceProperties2 : nullptr; 5793 } 5794 if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2")) 5795 { 5796 return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFormatProperties2 : nullptr; 5797 } 5798 if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2")) 5799 { 5800 return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2 : nullptr; 5801 } 5802 if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2")) 5803 { 5804 return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2 : nullptr; 5805 } 5806 if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2")) 5807 { 5808 return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2 : nullptr; 5809 } 5810 if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2")) 5811 { 5812 return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2 : nullptr; 5813 } 5814 if (!strcmp(name, "vkTrimCommandPool")) 5815 { 5816 return has1_1OrHigher ? (void*)entry_vkTrimCommandPool : nullptr; 5817 } 5818 if (!strcmp(name, "vkGetDeviceQueue2")) 5819 { 5820 return has1_1OrHigher ? (void*)entry_vkGetDeviceQueue2 : nullptr; 5821 } 5822 if (!strcmp(name, "vkCreateSamplerYcbcrConversion")) 5823 { 5824 return has1_1OrHigher ? (void*)entry_vkCreateSamplerYcbcrConversion : nullptr; 5825 } 5826 if (!strcmp(name, "vkDestroySamplerYcbcrConversion")) 5827 { 5828 return has1_1OrHigher ? (void*)entry_vkDestroySamplerYcbcrConversion : nullptr; 5829 } 5830 if (!strcmp(name, "vkCreateDescriptorUpdateTemplate")) 5831 { 5832 return has1_1OrHigher ? (void*)entry_vkCreateDescriptorUpdateTemplate : nullptr; 5833 } 5834 if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate")) 5835 { 5836 return has1_1OrHigher ? (void*)entry_vkDestroyDescriptorUpdateTemplate : nullptr; 5837 } 5838 if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate")) 5839 { 5840 return has1_1OrHigher ? (void*)entry_vkUpdateDescriptorSetWithTemplate : nullptr; 5841 } 5842 if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties")) 5843 { 5844 return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalBufferProperties : nullptr; 5845 } 5846 if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties")) 5847 { 5848 return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalFenceProperties : nullptr; 5849 } 5850 if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties")) 5851 { 5852 return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalSemaphoreProperties : nullptr; 5853 } 5854 if (!strcmp(name, "vkGetDescriptorSetLayoutSupport")) 5855 { 5856 return has1_1OrHigher ? (void*)entry_vkGetDescriptorSetLayoutSupport : nullptr; 5857 } 5858 #endif 5859 #ifdef VK_KHR_surface 5860 if (!strcmp(name, "vkDestroySurfaceKHR")) 5861 { 5862 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_surface"); 5863 return hasExt ? (void*)entry_vkDestroySurfaceKHR : nullptr; 5864 } 5865 if (!strcmp(name, "vkGetPhysicalDeviceSurfaceSupportKHR")) 5866 { 5867 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_surface"); 5868 return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceSupportKHR : nullptr; 5869 } 5870 if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR")) 5871 { 5872 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_surface"); 5873 return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceCapabilitiesKHR : nullptr; 5874 } 5875 if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormatsKHR")) 5876 { 5877 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_surface"); 5878 return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceFormatsKHR : nullptr; 5879 } 5880 if (!strcmp(name, "vkGetPhysicalDeviceSurfacePresentModesKHR")) 5881 { 5882 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_surface"); 5883 return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfacePresentModesKHR : nullptr; 5884 } 5885 #endif 5886 #ifdef VK_KHR_swapchain 5887 if (!strcmp(name, "vkCreateSwapchainKHR")) 5888 { 5889 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_swapchain"); 5890 return hasExt ? (void*)entry_vkCreateSwapchainKHR : nullptr; 5891 } 5892 if (!strcmp(name, "vkDestroySwapchainKHR")) 5893 { 5894 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_swapchain"); 5895 return hasExt ? (void*)entry_vkDestroySwapchainKHR : nullptr; 5896 } 5897 if (!strcmp(name, "vkGetSwapchainImagesKHR")) 5898 { 5899 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_swapchain"); 5900 return hasExt ? (void*)entry_vkGetSwapchainImagesKHR : nullptr; 5901 } 5902 if (!strcmp(name, "vkAcquireNextImageKHR")) 5903 { 5904 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_swapchain"); 5905 return hasExt ? (void*)entry_vkAcquireNextImageKHR : nullptr; 5906 } 5907 if (!strcmp(name, "vkQueuePresentKHR")) 5908 { 5909 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_swapchain"); 5910 return hasExt ? (void*)entry_vkQueuePresentKHR : nullptr; 5911 } 5912 if (!strcmp(name, "vkGetDeviceGroupPresentCapabilitiesKHR")) 5913 { 5914 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_swapchain"); 5915 return hasExt ? (void*)entry_vkGetDeviceGroupPresentCapabilitiesKHR : nullptr; 5916 } 5917 if (!strcmp(name, "vkGetDeviceGroupSurfacePresentModesKHR")) 5918 { 5919 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_swapchain"); 5920 return hasExt ? (void*)entry_vkGetDeviceGroupSurfacePresentModesKHR : nullptr; 5921 } 5922 if (!strcmp(name, "vkGetPhysicalDevicePresentRectanglesKHR")) 5923 { 5924 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_swapchain"); 5925 return hasExt ? (void*)entry_vkGetPhysicalDevicePresentRectanglesKHR : nullptr; 5926 } 5927 if (!strcmp(name, "vkAcquireNextImage2KHR")) 5928 { 5929 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_swapchain"); 5930 return hasExt ? (void*)entry_vkAcquireNextImage2KHR : nullptr; 5931 } 5932 #endif 5933 #ifdef VK_KHR_display 5934 if (!strcmp(name, "vkGetPhysicalDeviceDisplayPropertiesKHR")) 5935 { 5936 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_display"); 5937 return hasExt ? (void*)entry_vkGetPhysicalDeviceDisplayPropertiesKHR : nullptr; 5938 } 5939 if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR")) 5940 { 5941 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_display"); 5942 return hasExt ? (void*)entry_vkGetPhysicalDeviceDisplayPlanePropertiesKHR : nullptr; 5943 } 5944 if (!strcmp(name, "vkGetDisplayPlaneSupportedDisplaysKHR")) 5945 { 5946 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_display"); 5947 return hasExt ? (void*)entry_vkGetDisplayPlaneSupportedDisplaysKHR : nullptr; 5948 } 5949 if (!strcmp(name, "vkGetDisplayModePropertiesKHR")) 5950 { 5951 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_display"); 5952 return hasExt ? (void*)entry_vkGetDisplayModePropertiesKHR : nullptr; 5953 } 5954 if (!strcmp(name, "vkCreateDisplayModeKHR")) 5955 { 5956 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_display"); 5957 return hasExt ? (void*)entry_vkCreateDisplayModeKHR : nullptr; 5958 } 5959 if (!strcmp(name, "vkGetDisplayPlaneCapabilitiesKHR")) 5960 { 5961 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_display"); 5962 return hasExt ? (void*)entry_vkGetDisplayPlaneCapabilitiesKHR : nullptr; 5963 } 5964 if (!strcmp(name, "vkCreateDisplayPlaneSurfaceKHR")) 5965 { 5966 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_display"); 5967 return hasExt ? (void*)entry_vkCreateDisplayPlaneSurfaceKHR : nullptr; 5968 } 5969 #endif 5970 #ifdef VK_KHR_display_swapchain 5971 if (!strcmp(name, "vkCreateSharedSwapchainsKHR")) 5972 { 5973 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_display_swapchain"); 5974 return hasExt ? (void*)entry_vkCreateSharedSwapchainsKHR : nullptr; 5975 } 5976 #endif 5977 #ifdef VK_KHR_xlib_surface 5978 if (!strcmp(name, "vkCreateXlibSurfaceKHR")) 5979 { 5980 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_xlib_surface"); 5981 return hasExt ? (void*)entry_vkCreateXlibSurfaceKHR : nullptr; 5982 } 5983 if (!strcmp(name, "vkGetPhysicalDeviceXlibPresentationSupportKHR")) 5984 { 5985 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_xlib_surface"); 5986 return hasExt ? (void*)entry_vkGetPhysicalDeviceXlibPresentationSupportKHR : nullptr; 5987 } 5988 #endif 5989 #ifdef VK_KHR_xcb_surface 5990 if (!strcmp(name, "vkCreateXcbSurfaceKHR")) 5991 { 5992 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_xcb_surface"); 5993 return hasExt ? (void*)entry_vkCreateXcbSurfaceKHR : nullptr; 5994 } 5995 if (!strcmp(name, "vkGetPhysicalDeviceXcbPresentationSupportKHR")) 5996 { 5997 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_xcb_surface"); 5998 return hasExt ? (void*)entry_vkGetPhysicalDeviceXcbPresentationSupportKHR : nullptr; 5999 } 6000 #endif 6001 #ifdef VK_KHR_wayland_surface 6002 if (!strcmp(name, "vkCreateWaylandSurfaceKHR")) 6003 { 6004 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_wayland_surface"); 6005 return hasExt ? (void*)entry_vkCreateWaylandSurfaceKHR : nullptr; 6006 } 6007 if (!strcmp(name, "vkGetPhysicalDeviceWaylandPresentationSupportKHR")) 6008 { 6009 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_wayland_surface"); 6010 return hasExt ? (void*)entry_vkGetPhysicalDeviceWaylandPresentationSupportKHR : nullptr; 6011 } 6012 #endif 6013 #ifdef VK_KHR_mir_surface 6014 if (!strcmp(name, "vkCreateMirSurfaceKHR")) 6015 { 6016 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_mir_surface"); 6017 return hasExt ? (void*)entry_vkCreateMirSurfaceKHR : nullptr; 6018 } 6019 if (!strcmp(name, "vkGetPhysicalDeviceMirPresentationSupportKHR")) 6020 { 6021 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_mir_surface"); 6022 return hasExt ? (void*)entry_vkGetPhysicalDeviceMirPresentationSupportKHR : nullptr; 6023 } 6024 #endif 6025 #ifdef VK_KHR_android_surface 6026 if (!strcmp(name, "vkCreateAndroidSurfaceKHR")) 6027 { 6028 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_android_surface"); 6029 return hasExt ? (void*)entry_vkCreateAndroidSurfaceKHR : nullptr; 6030 } 6031 #endif 6032 #ifdef VK_KHR_win32_surface 6033 if (!strcmp(name, "vkCreateWin32SurfaceKHR")) 6034 { 6035 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_win32_surface"); 6036 return hasExt ? (void*)entry_vkCreateWin32SurfaceKHR : nullptr; 6037 } 6038 if (!strcmp(name, "vkGetPhysicalDeviceWin32PresentationSupportKHR")) 6039 { 6040 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_win32_surface"); 6041 return hasExt ? (void*)entry_vkGetPhysicalDeviceWin32PresentationSupportKHR : nullptr; 6042 } 6043 #endif 6044 #ifdef VK_KHR_get_physical_device_properties2 6045 if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR")) 6046 { 6047 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2"); 6048 return hasExt ? (void*)entry_vkGetPhysicalDeviceFeatures2KHR : nullptr; 6049 } 6050 if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR")) 6051 { 6052 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2"); 6053 return hasExt ? (void*)entry_vkGetPhysicalDeviceProperties2KHR : nullptr; 6054 } 6055 if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR")) 6056 { 6057 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2"); 6058 return hasExt ? (void*)entry_vkGetPhysicalDeviceFormatProperties2KHR : nullptr; 6059 } 6060 if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR")) 6061 { 6062 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2"); 6063 return hasExt ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2KHR : nullptr; 6064 } 6065 if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR")) 6066 { 6067 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2"); 6068 return hasExt ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR : nullptr; 6069 } 6070 if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR")) 6071 { 6072 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2"); 6073 return hasExt ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2KHR : nullptr; 6074 } 6075 if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")) 6076 { 6077 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2"); 6078 return hasExt ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR : nullptr; 6079 } 6080 #endif 6081 #ifdef VK_KHR_device_group 6082 if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeaturesKHR")) 6083 { 6084 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_device_group"); 6085 return hasExt ? (void*)entry_vkGetDeviceGroupPeerMemoryFeaturesKHR : nullptr; 6086 } 6087 if (!strcmp(name, "vkCmdSetDeviceMaskKHR")) 6088 { 6089 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_device_group"); 6090 return hasExt ? (void*)entry_vkCmdSetDeviceMaskKHR : nullptr; 6091 } 6092 if (!strcmp(name, "vkCmdDispatchBaseKHR")) 6093 { 6094 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_device_group"); 6095 return hasExt ? (void*)entry_vkCmdDispatchBaseKHR : nullptr; 6096 } 6097 #endif 6098 #ifdef VK_KHR_maintenance1 6099 if (!strcmp(name, "vkTrimCommandPoolKHR")) 6100 { 6101 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_maintenance1"); 6102 return hasExt ? (void*)entry_vkTrimCommandPoolKHR : nullptr; 6103 } 6104 #endif 6105 #ifdef VK_KHR_device_group_creation 6106 if (!strcmp(name, "vkEnumeratePhysicalDeviceGroupsKHR")) 6107 { 6108 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_device_group_creation"); 6109 return hasExt ? (void*)entry_vkEnumeratePhysicalDeviceGroupsKHR : nullptr; 6110 } 6111 #endif 6112 #ifdef VK_KHR_external_memory_capabilities 6113 if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR")) 6114 { 6115 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_memory_capabilities"); 6116 return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR : nullptr; 6117 } 6118 #endif 6119 #ifdef VK_KHR_external_memory_win32 6120 if (!strcmp(name, "vkGetMemoryWin32HandleKHR")) 6121 { 6122 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_memory_win32"); 6123 return hasExt ? (void*)entry_vkGetMemoryWin32HandleKHR : nullptr; 6124 } 6125 if (!strcmp(name, "vkGetMemoryWin32HandlePropertiesKHR")) 6126 { 6127 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_memory_win32"); 6128 return hasExt ? (void*)entry_vkGetMemoryWin32HandlePropertiesKHR : nullptr; 6129 } 6130 #endif 6131 #ifdef VK_KHR_external_memory_fd 6132 if (!strcmp(name, "vkGetMemoryFdKHR")) 6133 { 6134 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_memory_fd"); 6135 return hasExt ? (void*)entry_vkGetMemoryFdKHR : nullptr; 6136 } 6137 if (!strcmp(name, "vkGetMemoryFdPropertiesKHR")) 6138 { 6139 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_memory_fd"); 6140 return hasExt ? (void*)entry_vkGetMemoryFdPropertiesKHR : nullptr; 6141 } 6142 #endif 6143 #ifdef VK_KHR_external_semaphore_capabilities 6144 if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")) 6145 { 6146 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_semaphore_capabilities"); 6147 return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR : nullptr; 6148 } 6149 #endif 6150 #ifdef VK_KHR_external_semaphore_win32 6151 if (!strcmp(name, "vkImportSemaphoreWin32HandleKHR")) 6152 { 6153 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_semaphore_win32"); 6154 return hasExt ? (void*)entry_vkImportSemaphoreWin32HandleKHR : nullptr; 6155 } 6156 if (!strcmp(name, "vkGetSemaphoreWin32HandleKHR")) 6157 { 6158 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_semaphore_win32"); 6159 return hasExt ? (void*)entry_vkGetSemaphoreWin32HandleKHR : nullptr; 6160 } 6161 #endif 6162 #ifdef VK_KHR_external_semaphore_fd 6163 if (!strcmp(name, "vkImportSemaphoreFdKHR")) 6164 { 6165 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_semaphore_fd"); 6166 return hasExt ? (void*)entry_vkImportSemaphoreFdKHR : nullptr; 6167 } 6168 if (!strcmp(name, "vkGetSemaphoreFdKHR")) 6169 { 6170 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_semaphore_fd"); 6171 return hasExt ? (void*)entry_vkGetSemaphoreFdKHR : nullptr; 6172 } 6173 #endif 6174 #ifdef VK_KHR_push_descriptor 6175 if (!strcmp(name, "vkCmdPushDescriptorSetKHR")) 6176 { 6177 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_push_descriptor"); 6178 return hasExt ? (void*)entry_vkCmdPushDescriptorSetKHR : nullptr; 6179 } 6180 if (!strcmp(name, "vkCmdPushDescriptorSetWithTemplateKHR")) 6181 { 6182 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_push_descriptor"); 6183 return hasExt ? (void*)entry_vkCmdPushDescriptorSetWithTemplateKHR : nullptr; 6184 } 6185 #endif 6186 #ifdef VK_KHR_descriptor_update_template 6187 if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR")) 6188 { 6189 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_descriptor_update_template"); 6190 return hasExt ? (void*)entry_vkCreateDescriptorUpdateTemplateKHR : nullptr; 6191 } 6192 if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR")) 6193 { 6194 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_descriptor_update_template"); 6195 return hasExt ? (void*)entry_vkDestroyDescriptorUpdateTemplateKHR : nullptr; 6196 } 6197 if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR")) 6198 { 6199 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_descriptor_update_template"); 6200 return hasExt ? (void*)entry_vkUpdateDescriptorSetWithTemplateKHR : nullptr; 6201 } 6202 #endif 6203 #ifdef VK_KHR_create_renderpass2 6204 if (!strcmp(name, "vkCreateRenderPass2KHR")) 6205 { 6206 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_create_renderpass2"); 6207 return hasExt ? (void*)entry_vkCreateRenderPass2KHR : nullptr; 6208 } 6209 if (!strcmp(name, "vkCmdBeginRenderPass2KHR")) 6210 { 6211 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_create_renderpass2"); 6212 return hasExt ? (void*)entry_vkCmdBeginRenderPass2KHR : nullptr; 6213 } 6214 if (!strcmp(name, "vkCmdNextSubpass2KHR")) 6215 { 6216 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_create_renderpass2"); 6217 return hasExt ? (void*)entry_vkCmdNextSubpass2KHR : nullptr; 6218 } 6219 if (!strcmp(name, "vkCmdEndRenderPass2KHR")) 6220 { 6221 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_create_renderpass2"); 6222 return hasExt ? (void*)entry_vkCmdEndRenderPass2KHR : nullptr; 6223 } 6224 #endif 6225 #ifdef VK_KHR_shared_presentable_image 6226 if (!strcmp(name, "vkGetSwapchainStatusKHR")) 6227 { 6228 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_shared_presentable_image"); 6229 return hasExt ? (void*)entry_vkGetSwapchainStatusKHR : nullptr; 6230 } 6231 #endif 6232 #ifdef VK_KHR_external_fence_capabilities 6233 if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR")) 6234 { 6235 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_fence_capabilities"); 6236 return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalFencePropertiesKHR : nullptr; 6237 } 6238 #endif 6239 #ifdef VK_KHR_external_fence_win32 6240 if (!strcmp(name, "vkImportFenceWin32HandleKHR")) 6241 { 6242 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_fence_win32"); 6243 return hasExt ? (void*)entry_vkImportFenceWin32HandleKHR : nullptr; 6244 } 6245 if (!strcmp(name, "vkGetFenceWin32HandleKHR")) 6246 { 6247 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_fence_win32"); 6248 return hasExt ? (void*)entry_vkGetFenceWin32HandleKHR : nullptr; 6249 } 6250 #endif 6251 #ifdef VK_KHR_external_fence_fd 6252 if (!strcmp(name, "vkImportFenceFdKHR")) 6253 { 6254 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_fence_fd"); 6255 return hasExt ? (void*)entry_vkImportFenceFdKHR : nullptr; 6256 } 6257 if (!strcmp(name, "vkGetFenceFdKHR")) 6258 { 6259 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_fence_fd"); 6260 return hasExt ? (void*)entry_vkGetFenceFdKHR : nullptr; 6261 } 6262 #endif 6263 #ifdef VK_KHR_get_surface_capabilities2 6264 if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2KHR")) 6265 { 6266 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_surface_capabilities2"); 6267 return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceCapabilities2KHR : nullptr; 6268 } 6269 if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormats2KHR")) 6270 { 6271 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_surface_capabilities2"); 6272 return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceFormats2KHR : nullptr; 6273 } 6274 #endif 6275 #ifdef VK_KHR_get_display_properties2 6276 if (!strcmp(name, "vkGetPhysicalDeviceDisplayProperties2KHR")) 6277 { 6278 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_display_properties2"); 6279 return hasExt ? (void*)entry_vkGetPhysicalDeviceDisplayProperties2KHR : nullptr; 6280 } 6281 if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR")) 6282 { 6283 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_display_properties2"); 6284 return hasExt ? (void*)entry_vkGetPhysicalDeviceDisplayPlaneProperties2KHR : nullptr; 6285 } 6286 if (!strcmp(name, "vkGetDisplayModeProperties2KHR")) 6287 { 6288 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_display_properties2"); 6289 return hasExt ? (void*)entry_vkGetDisplayModeProperties2KHR : nullptr; 6290 } 6291 if (!strcmp(name, "vkGetDisplayPlaneCapabilities2KHR")) 6292 { 6293 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_display_properties2"); 6294 return hasExt ? (void*)entry_vkGetDisplayPlaneCapabilities2KHR : nullptr; 6295 } 6296 #endif 6297 #ifdef VK_KHR_get_memory_requirements2 6298 if (!strcmp(name, "vkGetImageMemoryRequirements2KHR")) 6299 { 6300 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_memory_requirements2"); 6301 return hasExt ? (void*)entry_vkGetImageMemoryRequirements2KHR : nullptr; 6302 } 6303 if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR")) 6304 { 6305 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_memory_requirements2"); 6306 return hasExt ? (void*)entry_vkGetBufferMemoryRequirements2KHR : nullptr; 6307 } 6308 if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR")) 6309 { 6310 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_memory_requirements2"); 6311 return hasExt ? (void*)entry_vkGetImageSparseMemoryRequirements2KHR : nullptr; 6312 } 6313 #endif 6314 #ifdef VK_KHR_sampler_ycbcr_conversion 6315 if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR")) 6316 { 6317 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_sampler_ycbcr_conversion"); 6318 return hasExt ? (void*)entry_vkCreateSamplerYcbcrConversionKHR : nullptr; 6319 } 6320 if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR")) 6321 { 6322 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_sampler_ycbcr_conversion"); 6323 return hasExt ? (void*)entry_vkDestroySamplerYcbcrConversionKHR : nullptr; 6324 } 6325 #endif 6326 #ifdef VK_KHR_bind_memory2 6327 if (!strcmp(name, "vkBindBufferMemory2KHR")) 6328 { 6329 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_bind_memory2"); 6330 return hasExt ? (void*)entry_vkBindBufferMemory2KHR : nullptr; 6331 } 6332 if (!strcmp(name, "vkBindImageMemory2KHR")) 6333 { 6334 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_bind_memory2"); 6335 return hasExt ? (void*)entry_vkBindImageMemory2KHR : nullptr; 6336 } 6337 #endif 6338 #ifdef VK_KHR_maintenance3 6339 if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR")) 6340 { 6341 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_maintenance3"); 6342 return hasExt ? (void*)entry_vkGetDescriptorSetLayoutSupportKHR : nullptr; 6343 } 6344 #endif 6345 #ifdef VK_KHR_draw_indirect_count 6346 if (!strcmp(name, "vkCmdDrawIndirectCountKHR")) 6347 { 6348 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_draw_indirect_count"); 6349 return hasExt ? (void*)entry_vkCmdDrawIndirectCountKHR : nullptr; 6350 } 6351 if (!strcmp(name, "vkCmdDrawIndexedIndirectCountKHR")) 6352 { 6353 bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_draw_indirect_count"); 6354 return hasExt ? (void*)entry_vkCmdDrawIndexedIndirectCountKHR : nullptr; 6355 } 6356 #endif 6357 #ifdef VK_ANDROID_native_buffer 6358 if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID")) 6359 { 6360 bool hasExt = resources->hasInstanceExtension(instance, "VK_ANDROID_native_buffer"); 6361 return hasExt ? (void*)entry_vkGetSwapchainGrallocUsageANDROID : nullptr; 6362 } 6363 if (!strcmp(name, "vkAcquireImageANDROID")) 6364 { 6365 bool hasExt = resources->hasInstanceExtension(instance, "VK_ANDROID_native_buffer"); 6366 return hasExt ? (void*)entry_vkAcquireImageANDROID : nullptr; 6367 } 6368 if (!strcmp(name, "vkQueueSignalReleaseImageANDROID")) 6369 { 6370 bool hasExt = resources->hasInstanceExtension(instance, "VK_ANDROID_native_buffer"); 6371 return hasExt ? (void*)entry_vkQueueSignalReleaseImageANDROID : nullptr; 6372 } 6373 #endif 6374 #ifdef VK_EXT_debug_report 6375 if (!strcmp(name, "vkCreateDebugReportCallbackEXT")) 6376 { 6377 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_report"); 6378 return hasExt ? (void*)entry_vkCreateDebugReportCallbackEXT : nullptr; 6379 } 6380 if (!strcmp(name, "vkDestroyDebugReportCallbackEXT")) 6381 { 6382 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_report"); 6383 return hasExt ? (void*)entry_vkDestroyDebugReportCallbackEXT : nullptr; 6384 } 6385 if (!strcmp(name, "vkDebugReportMessageEXT")) 6386 { 6387 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_report"); 6388 return hasExt ? (void*)entry_vkDebugReportMessageEXT : nullptr; 6389 } 6390 #endif 6391 #ifdef VK_EXT_debug_marker 6392 if (!strcmp(name, "vkDebugMarkerSetObjectTagEXT")) 6393 { 6394 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_marker"); 6395 return hasExt ? (void*)entry_vkDebugMarkerSetObjectTagEXT : nullptr; 6396 } 6397 if (!strcmp(name, "vkDebugMarkerSetObjectNameEXT")) 6398 { 6399 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_marker"); 6400 return hasExt ? (void*)entry_vkDebugMarkerSetObjectNameEXT : nullptr; 6401 } 6402 if (!strcmp(name, "vkCmdDebugMarkerBeginEXT")) 6403 { 6404 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_marker"); 6405 return hasExt ? (void*)entry_vkCmdDebugMarkerBeginEXT : nullptr; 6406 } 6407 if (!strcmp(name, "vkCmdDebugMarkerEndEXT")) 6408 { 6409 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_marker"); 6410 return hasExt ? (void*)entry_vkCmdDebugMarkerEndEXT : nullptr; 6411 } 6412 if (!strcmp(name, "vkCmdDebugMarkerInsertEXT")) 6413 { 6414 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_marker"); 6415 return hasExt ? (void*)entry_vkCmdDebugMarkerInsertEXT : nullptr; 6416 } 6417 #endif 6418 #ifdef VK_AMD_draw_indirect_count 6419 if (!strcmp(name, "vkCmdDrawIndirectCountAMD")) 6420 { 6421 bool hasExt = resources->hasInstanceExtension(instance, "VK_AMD_draw_indirect_count"); 6422 return hasExt ? (void*)entry_vkCmdDrawIndirectCountAMD : nullptr; 6423 } 6424 if (!strcmp(name, "vkCmdDrawIndexedIndirectCountAMD")) 6425 { 6426 bool hasExt = resources->hasInstanceExtension(instance, "VK_AMD_draw_indirect_count"); 6427 return hasExt ? (void*)entry_vkCmdDrawIndexedIndirectCountAMD : nullptr; 6428 } 6429 #endif 6430 #ifdef VK_AMD_shader_info 6431 if (!strcmp(name, "vkGetShaderInfoAMD")) 6432 { 6433 bool hasExt = resources->hasInstanceExtension(instance, "VK_AMD_shader_info"); 6434 return hasExt ? (void*)entry_vkGetShaderInfoAMD : nullptr; 6435 } 6436 #endif 6437 #ifdef VK_NV_external_memory_capabilities 6438 if (!strcmp(name, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV")) 6439 { 6440 bool hasExt = resources->hasInstanceExtension(instance, "VK_NV_external_memory_capabilities"); 6441 return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalImageFormatPropertiesNV : nullptr; 6442 } 6443 #endif 6444 #ifdef VK_NV_external_memory_win32 6445 if (!strcmp(name, "vkGetMemoryWin32HandleNV")) 6446 { 6447 bool hasExt = resources->hasInstanceExtension(instance, "VK_NV_external_memory_win32"); 6448 return hasExt ? (void*)entry_vkGetMemoryWin32HandleNV : nullptr; 6449 } 6450 #endif 6451 #ifdef VK_NN_vi_surface 6452 if (!strcmp(name, "vkCreateViSurfaceNN")) 6453 { 6454 bool hasExt = resources->hasInstanceExtension(instance, "VK_NN_vi_surface"); 6455 return hasExt ? (void*)entry_vkCreateViSurfaceNN : nullptr; 6456 } 6457 #endif 6458 #ifdef VK_EXT_conditional_rendering 6459 if (!strcmp(name, "vkCmdBeginConditionalRenderingEXT")) 6460 { 6461 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_conditional_rendering"); 6462 return hasExt ? (void*)entry_vkCmdBeginConditionalRenderingEXT : nullptr; 6463 } 6464 if (!strcmp(name, "vkCmdEndConditionalRenderingEXT")) 6465 { 6466 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_conditional_rendering"); 6467 return hasExt ? (void*)entry_vkCmdEndConditionalRenderingEXT : nullptr; 6468 } 6469 #endif 6470 #ifdef VK_NVX_device_generated_commands 6471 if (!strcmp(name, "vkCmdProcessCommandsNVX")) 6472 { 6473 bool hasExt = resources->hasInstanceExtension(instance, "VK_NVX_device_generated_commands"); 6474 return hasExt ? (void*)entry_vkCmdProcessCommandsNVX : nullptr; 6475 } 6476 if (!strcmp(name, "vkCmdReserveSpaceForCommandsNVX")) 6477 { 6478 bool hasExt = resources->hasInstanceExtension(instance, "VK_NVX_device_generated_commands"); 6479 return hasExt ? (void*)entry_vkCmdReserveSpaceForCommandsNVX : nullptr; 6480 } 6481 if (!strcmp(name, "vkCreateIndirectCommandsLayoutNVX")) 6482 { 6483 bool hasExt = resources->hasInstanceExtension(instance, "VK_NVX_device_generated_commands"); 6484 return hasExt ? (void*)entry_vkCreateIndirectCommandsLayoutNVX : nullptr; 6485 } 6486 if (!strcmp(name, "vkDestroyIndirectCommandsLayoutNVX")) 6487 { 6488 bool hasExt = resources->hasInstanceExtension(instance, "VK_NVX_device_generated_commands"); 6489 return hasExt ? (void*)entry_vkDestroyIndirectCommandsLayoutNVX : nullptr; 6490 } 6491 if (!strcmp(name, "vkCreateObjectTableNVX")) 6492 { 6493 bool hasExt = resources->hasInstanceExtension(instance, "VK_NVX_device_generated_commands"); 6494 return hasExt ? (void*)entry_vkCreateObjectTableNVX : nullptr; 6495 } 6496 if (!strcmp(name, "vkDestroyObjectTableNVX")) 6497 { 6498 bool hasExt = resources->hasInstanceExtension(instance, "VK_NVX_device_generated_commands"); 6499 return hasExt ? (void*)entry_vkDestroyObjectTableNVX : nullptr; 6500 } 6501 if (!strcmp(name, "vkRegisterObjectsNVX")) 6502 { 6503 bool hasExt = resources->hasInstanceExtension(instance, "VK_NVX_device_generated_commands"); 6504 return hasExt ? (void*)entry_vkRegisterObjectsNVX : nullptr; 6505 } 6506 if (!strcmp(name, "vkUnregisterObjectsNVX")) 6507 { 6508 bool hasExt = resources->hasInstanceExtension(instance, "VK_NVX_device_generated_commands"); 6509 return hasExt ? (void*)entry_vkUnregisterObjectsNVX : nullptr; 6510 } 6511 if (!strcmp(name, "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX")) 6512 { 6513 bool hasExt = resources->hasInstanceExtension(instance, "VK_NVX_device_generated_commands"); 6514 return hasExt ? (void*)entry_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX : nullptr; 6515 } 6516 #endif 6517 #ifdef VK_NV_clip_space_w_scaling 6518 if (!strcmp(name, "vkCmdSetViewportWScalingNV")) 6519 { 6520 bool hasExt = resources->hasInstanceExtension(instance, "VK_NV_clip_space_w_scaling"); 6521 return hasExt ? (void*)entry_vkCmdSetViewportWScalingNV : nullptr; 6522 } 6523 #endif 6524 #ifdef VK_EXT_direct_mode_display 6525 if (!strcmp(name, "vkReleaseDisplayEXT")) 6526 { 6527 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_direct_mode_display"); 6528 return hasExt ? (void*)entry_vkReleaseDisplayEXT : nullptr; 6529 } 6530 #endif 6531 #ifdef VK_EXT_acquire_xlib_display 6532 if (!strcmp(name, "vkAcquireXlibDisplayEXT")) 6533 { 6534 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_acquire_xlib_display"); 6535 return hasExt ? (void*)entry_vkAcquireXlibDisplayEXT : nullptr; 6536 } 6537 if (!strcmp(name, "vkGetRandROutputDisplayEXT")) 6538 { 6539 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_acquire_xlib_display"); 6540 return hasExt ? (void*)entry_vkGetRandROutputDisplayEXT : nullptr; 6541 } 6542 #endif 6543 #ifdef VK_EXT_display_surface_counter 6544 if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2EXT")) 6545 { 6546 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_display_surface_counter"); 6547 return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceCapabilities2EXT : nullptr; 6548 } 6549 #endif 6550 #ifdef VK_EXT_display_control 6551 if (!strcmp(name, "vkDisplayPowerControlEXT")) 6552 { 6553 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_display_control"); 6554 return hasExt ? (void*)entry_vkDisplayPowerControlEXT : nullptr; 6555 } 6556 if (!strcmp(name, "vkRegisterDeviceEventEXT")) 6557 { 6558 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_display_control"); 6559 return hasExt ? (void*)entry_vkRegisterDeviceEventEXT : nullptr; 6560 } 6561 if (!strcmp(name, "vkRegisterDisplayEventEXT")) 6562 { 6563 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_display_control"); 6564 return hasExt ? (void*)entry_vkRegisterDisplayEventEXT : nullptr; 6565 } 6566 if (!strcmp(name, "vkGetSwapchainCounterEXT")) 6567 { 6568 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_display_control"); 6569 return hasExt ? (void*)entry_vkGetSwapchainCounterEXT : nullptr; 6570 } 6571 #endif 6572 #ifdef VK_GOOGLE_display_timing 6573 if (!strcmp(name, "vkGetRefreshCycleDurationGOOGLE")) 6574 { 6575 bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_display_timing"); 6576 return hasExt ? (void*)entry_vkGetRefreshCycleDurationGOOGLE : nullptr; 6577 } 6578 if (!strcmp(name, "vkGetPastPresentationTimingGOOGLE")) 6579 { 6580 bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_display_timing"); 6581 return hasExt ? (void*)entry_vkGetPastPresentationTimingGOOGLE : nullptr; 6582 } 6583 #endif 6584 #ifdef VK_EXT_discard_rectangles 6585 if (!strcmp(name, "vkCmdSetDiscardRectangleEXT")) 6586 { 6587 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_discard_rectangles"); 6588 return hasExt ? (void*)entry_vkCmdSetDiscardRectangleEXT : nullptr; 6589 } 6590 #endif 6591 #ifdef VK_EXT_hdr_metadata 6592 if (!strcmp(name, "vkSetHdrMetadataEXT")) 6593 { 6594 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_hdr_metadata"); 6595 return hasExt ? (void*)entry_vkSetHdrMetadataEXT : nullptr; 6596 } 6597 #endif 6598 #ifdef VK_MVK_ios_surface 6599 if (!strcmp(name, "vkCreateIOSSurfaceMVK")) 6600 { 6601 bool hasExt = resources->hasInstanceExtension(instance, "VK_MVK_ios_surface"); 6602 return hasExt ? (void*)entry_vkCreateIOSSurfaceMVK : nullptr; 6603 } 6604 #endif 6605 #ifdef VK_MVK_macos_surface 6606 if (!strcmp(name, "vkCreateMacOSSurfaceMVK")) 6607 { 6608 bool hasExt = resources->hasInstanceExtension(instance, "VK_MVK_macos_surface"); 6609 return hasExt ? (void*)entry_vkCreateMacOSSurfaceMVK : nullptr; 6610 } 6611 #endif 6612 #ifdef VK_EXT_debug_utils 6613 if (!strcmp(name, "vkSetDebugUtilsObjectNameEXT")) 6614 { 6615 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils"); 6616 return hasExt ? (void*)entry_vkSetDebugUtilsObjectNameEXT : nullptr; 6617 } 6618 if (!strcmp(name, "vkSetDebugUtilsObjectTagEXT")) 6619 { 6620 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils"); 6621 return hasExt ? (void*)entry_vkSetDebugUtilsObjectTagEXT : nullptr; 6622 } 6623 if (!strcmp(name, "vkQueueBeginDebugUtilsLabelEXT")) 6624 { 6625 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils"); 6626 return hasExt ? (void*)entry_vkQueueBeginDebugUtilsLabelEXT : nullptr; 6627 } 6628 if (!strcmp(name, "vkQueueEndDebugUtilsLabelEXT")) 6629 { 6630 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils"); 6631 return hasExt ? (void*)entry_vkQueueEndDebugUtilsLabelEXT : nullptr; 6632 } 6633 if (!strcmp(name, "vkQueueInsertDebugUtilsLabelEXT")) 6634 { 6635 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils"); 6636 return hasExt ? (void*)entry_vkQueueInsertDebugUtilsLabelEXT : nullptr; 6637 } 6638 if (!strcmp(name, "vkCmdBeginDebugUtilsLabelEXT")) 6639 { 6640 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils"); 6641 return hasExt ? (void*)entry_vkCmdBeginDebugUtilsLabelEXT : nullptr; 6642 } 6643 if (!strcmp(name, "vkCmdEndDebugUtilsLabelEXT")) 6644 { 6645 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils"); 6646 return hasExt ? (void*)entry_vkCmdEndDebugUtilsLabelEXT : nullptr; 6647 } 6648 if (!strcmp(name, "vkCmdInsertDebugUtilsLabelEXT")) 6649 { 6650 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils"); 6651 return hasExt ? (void*)entry_vkCmdInsertDebugUtilsLabelEXT : nullptr; 6652 } 6653 if (!strcmp(name, "vkCreateDebugUtilsMessengerEXT")) 6654 { 6655 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils"); 6656 return hasExt ? (void*)entry_vkCreateDebugUtilsMessengerEXT : nullptr; 6657 } 6658 if (!strcmp(name, "vkDestroyDebugUtilsMessengerEXT")) 6659 { 6660 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils"); 6661 return hasExt ? (void*)entry_vkDestroyDebugUtilsMessengerEXT : nullptr; 6662 } 6663 if (!strcmp(name, "vkSubmitDebugUtilsMessageEXT")) 6664 { 6665 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils"); 6666 return hasExt ? (void*)entry_vkSubmitDebugUtilsMessageEXT : nullptr; 6667 } 6668 #endif 6669 #ifdef VK_ANDROID_external_memory_android_hardware_buffer 6670 if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID")) 6671 { 6672 bool hasExt = resources->hasInstanceExtension(instance, "VK_ANDROID_external_memory_android_hardware_buffer"); 6673 return hasExt ? (void*)entry_vkGetAndroidHardwareBufferPropertiesANDROID : nullptr; 6674 } 6675 if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID")) 6676 { 6677 bool hasExt = resources->hasInstanceExtension(instance, "VK_ANDROID_external_memory_android_hardware_buffer"); 6678 return hasExt ? (void*)entry_vkGetMemoryAndroidHardwareBufferANDROID : nullptr; 6679 } 6680 #endif 6681 #ifdef VK_EXT_sample_locations 6682 if (!strcmp(name, "vkCmdSetSampleLocationsEXT")) 6683 { 6684 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_sample_locations"); 6685 return hasExt ? (void*)entry_vkCmdSetSampleLocationsEXT : nullptr; 6686 } 6687 if (!strcmp(name, "vkGetPhysicalDeviceMultisamplePropertiesEXT")) 6688 { 6689 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_sample_locations"); 6690 return hasExt ? (void*)entry_vkGetPhysicalDeviceMultisamplePropertiesEXT : nullptr; 6691 } 6692 #endif 6693 #ifdef VK_EXT_validation_cache 6694 if (!strcmp(name, "vkCreateValidationCacheEXT")) 6695 { 6696 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_validation_cache"); 6697 return hasExt ? (void*)entry_vkCreateValidationCacheEXT : nullptr; 6698 } 6699 if (!strcmp(name, "vkDestroyValidationCacheEXT")) 6700 { 6701 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_validation_cache"); 6702 return hasExt ? (void*)entry_vkDestroyValidationCacheEXT : nullptr; 6703 } 6704 if (!strcmp(name, "vkMergeValidationCachesEXT")) 6705 { 6706 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_validation_cache"); 6707 return hasExt ? (void*)entry_vkMergeValidationCachesEXT : nullptr; 6708 } 6709 if (!strcmp(name, "vkGetValidationCacheDataEXT")) 6710 { 6711 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_validation_cache"); 6712 return hasExt ? (void*)entry_vkGetValidationCacheDataEXT : nullptr; 6713 } 6714 #endif 6715 #ifdef VK_EXT_external_memory_host 6716 if (!strcmp(name, "vkGetMemoryHostPointerPropertiesEXT")) 6717 { 6718 bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_external_memory_host"); 6719 return hasExt ? (void*)entry_vkGetMemoryHostPointerPropertiesEXT : nullptr; 6720 } 6721 #endif 6722 #ifdef VK_AMD_buffer_marker 6723 if (!strcmp(name, "vkCmdWriteBufferMarkerAMD")) 6724 { 6725 bool hasExt = resources->hasInstanceExtension(instance, "VK_AMD_buffer_marker"); 6726 return hasExt ? (void*)entry_vkCmdWriteBufferMarkerAMD : nullptr; 6727 } 6728 #endif 6729 #ifdef VK_NV_device_diagnostic_checkpoints 6730 if (!strcmp(name, "vkCmdSetCheckpointNV")) 6731 { 6732 bool hasExt = resources->hasInstanceExtension(instance, "VK_NV_device_diagnostic_checkpoints"); 6733 return hasExt ? (void*)entry_vkCmdSetCheckpointNV : nullptr; 6734 } 6735 if (!strcmp(name, "vkGetQueueCheckpointDataNV")) 6736 { 6737 bool hasExt = resources->hasInstanceExtension(instance, "VK_NV_device_diagnostic_checkpoints"); 6738 return hasExt ? (void*)entry_vkGetQueueCheckpointDataNV : nullptr; 6739 } 6740 #endif 6741 #ifdef VK_GOOGLE_address_space 6742 if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE")) 6743 { 6744 bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_address_space"); 6745 return hasExt ? (void*)entry_vkMapMemoryIntoAddressSpaceGOOGLE : nullptr; 6746 } 6747 #endif 6748 #ifdef VK_GOOGLE_color_buffer 6749 if (!strcmp(name, "vkRegisterImageColorBufferGOOGLE")) 6750 { 6751 bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_color_buffer"); 6752 return hasExt ? (void*)entry_vkRegisterImageColorBufferGOOGLE : nullptr; 6753 } 6754 if (!strcmp(name, "vkRegisterBufferColorBufferGOOGLE")) 6755 { 6756 bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_color_buffer"); 6757 return hasExt ? (void*)entry_vkRegisterBufferColorBufferGOOGLE : nullptr; 6758 } 6759 #endif 6760 #ifdef VK_GOOGLE_sized_descriptor_update_template 6761 if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSizedGOOGLE")) 6762 { 6763 bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_sized_descriptor_update_template"); 6764 return hasExt ? (void*)entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE : nullptr; 6765 } 6766 #endif 6767 #ifdef VK_GOOGLE_async_command_buffers 6768 if (!strcmp(name, "vkBeginCommandBufferAsyncGOOGLE")) 6769 { 6770 bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_async_command_buffers"); 6771 return hasExt ? (void*)entry_vkBeginCommandBufferAsyncGOOGLE : nullptr; 6772 } 6773 if (!strcmp(name, "vkEndCommandBufferAsyncGOOGLE")) 6774 { 6775 bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_async_command_buffers"); 6776 return hasExt ? (void*)entry_vkEndCommandBufferAsyncGOOGLE : nullptr; 6777 } 6778 if (!strcmp(name, "vkResetCommandBufferAsyncGOOGLE")) 6779 { 6780 bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_async_command_buffers"); 6781 return hasExt ? (void*)entry_vkResetCommandBufferAsyncGOOGLE : nullptr; 6782 } 6783 #endif 6784 return nullptr; 6785 } 6786 void* goldfish_vulkan_get_device_proc_address(VkDevice device, const char* name){ 6787 auto resources = ResourceTracker::get(); 6788 bool has1_1OrHigher = resources->getApiVersionFromDevice(device) >= VK_API_VERSION_1_1; 6789 #ifdef VK_VERSION_1_0 6790 if (!strcmp(name, "vkCreateInstance")) 6791 { 6792 return (void*)entry_vkCreateInstance; 6793 } 6794 if (!strcmp(name, "vkDestroyInstance")) 6795 { 6796 return (void*)entry_vkDestroyInstance; 6797 } 6798 if (!strcmp(name, "vkEnumeratePhysicalDevices")) 6799 { 6800 return (void*)entry_vkEnumeratePhysicalDevices; 6801 } 6802 if (!strcmp(name, "vkGetPhysicalDeviceFeatures")) 6803 { 6804 return (void*)entry_vkGetPhysicalDeviceFeatures; 6805 } 6806 if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties")) 6807 { 6808 return (void*)entry_vkGetPhysicalDeviceFormatProperties; 6809 } 6810 if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties")) 6811 { 6812 return (void*)entry_vkGetPhysicalDeviceImageFormatProperties; 6813 } 6814 if (!strcmp(name, "vkGetPhysicalDeviceProperties")) 6815 { 6816 return (void*)entry_vkGetPhysicalDeviceProperties; 6817 } 6818 if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties")) 6819 { 6820 return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties; 6821 } 6822 if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties")) 6823 { 6824 return (void*)entry_vkGetPhysicalDeviceMemoryProperties; 6825 } 6826 if (!strcmp(name, "vkGetInstanceProcAddr")) 6827 { 6828 return (void*)entry_vkGetInstanceProcAddr; 6829 } 6830 if (!strcmp(name, "vkGetDeviceProcAddr")) 6831 { 6832 return (void*)entry_vkGetDeviceProcAddr; 6833 } 6834 if (!strcmp(name, "vkCreateDevice")) 6835 { 6836 return (void*)entry_vkCreateDevice; 6837 } 6838 if (!strcmp(name, "vkDestroyDevice")) 6839 { 6840 return (void*)entry_vkDestroyDevice; 6841 } 6842 if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) 6843 { 6844 return (void*)entry_vkEnumerateInstanceExtensionProperties; 6845 } 6846 if (!strcmp(name, "vkEnumerateDeviceExtensionProperties")) 6847 { 6848 return (void*)entry_vkEnumerateDeviceExtensionProperties; 6849 } 6850 if (!strcmp(name, "vkEnumerateInstanceLayerProperties")) 6851 { 6852 return (void*)entry_vkEnumerateInstanceLayerProperties; 6853 } 6854 if (!strcmp(name, "vkEnumerateDeviceLayerProperties")) 6855 { 6856 return (void*)entry_vkEnumerateDeviceLayerProperties; 6857 } 6858 if (!strcmp(name, "vkGetDeviceQueue")) 6859 { 6860 return (void*)entry_vkGetDeviceQueue; 6861 } 6862 if (!strcmp(name, "vkQueueSubmit")) 6863 { 6864 return (void*)entry_vkQueueSubmit; 6865 } 6866 if (!strcmp(name, "vkQueueWaitIdle")) 6867 { 6868 return (void*)entry_vkQueueWaitIdle; 6869 } 6870 if (!strcmp(name, "vkDeviceWaitIdle")) 6871 { 6872 return (void*)entry_vkDeviceWaitIdle; 6873 } 6874 if (!strcmp(name, "vkAllocateMemory")) 6875 { 6876 return (void*)entry_vkAllocateMemory; 6877 } 6878 if (!strcmp(name, "vkFreeMemory")) 6879 { 6880 return (void*)entry_vkFreeMemory; 6881 } 6882 if (!strcmp(name, "vkMapMemory")) 6883 { 6884 return (void*)entry_vkMapMemory; 6885 } 6886 if (!strcmp(name, "vkUnmapMemory")) 6887 { 6888 return (void*)entry_vkUnmapMemory; 6889 } 6890 if (!strcmp(name, "vkFlushMappedMemoryRanges")) 6891 { 6892 return (void*)entry_vkFlushMappedMemoryRanges; 6893 } 6894 if (!strcmp(name, "vkInvalidateMappedMemoryRanges")) 6895 { 6896 return (void*)entry_vkInvalidateMappedMemoryRanges; 6897 } 6898 if (!strcmp(name, "vkGetDeviceMemoryCommitment")) 6899 { 6900 return (void*)entry_vkGetDeviceMemoryCommitment; 6901 } 6902 if (!strcmp(name, "vkBindBufferMemory")) 6903 { 6904 return (void*)entry_vkBindBufferMemory; 6905 } 6906 if (!strcmp(name, "vkBindImageMemory")) 6907 { 6908 return (void*)entry_vkBindImageMemory; 6909 } 6910 if (!strcmp(name, "vkGetBufferMemoryRequirements")) 6911 { 6912 return (void*)entry_vkGetBufferMemoryRequirements; 6913 } 6914 if (!strcmp(name, "vkGetImageMemoryRequirements")) 6915 { 6916 return (void*)entry_vkGetImageMemoryRequirements; 6917 } 6918 if (!strcmp(name, "vkGetImageSparseMemoryRequirements")) 6919 { 6920 return (void*)entry_vkGetImageSparseMemoryRequirements; 6921 } 6922 if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties")) 6923 { 6924 return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties; 6925 } 6926 if (!strcmp(name, "vkQueueBindSparse")) 6927 { 6928 return (void*)entry_vkQueueBindSparse; 6929 } 6930 if (!strcmp(name, "vkCreateFence")) 6931 { 6932 return (void*)entry_vkCreateFence; 6933 } 6934 if (!strcmp(name, "vkDestroyFence")) 6935 { 6936 return (void*)entry_vkDestroyFence; 6937 } 6938 if (!strcmp(name, "vkResetFences")) 6939 { 6940 return (void*)entry_vkResetFences; 6941 } 6942 if (!strcmp(name, "vkGetFenceStatus")) 6943 { 6944 return (void*)entry_vkGetFenceStatus; 6945 } 6946 if (!strcmp(name, "vkWaitForFences")) 6947 { 6948 return (void*)entry_vkWaitForFences; 6949 } 6950 if (!strcmp(name, "vkCreateSemaphore")) 6951 { 6952 return (void*)entry_vkCreateSemaphore; 6953 } 6954 if (!strcmp(name, "vkDestroySemaphore")) 6955 { 6956 return (void*)entry_vkDestroySemaphore; 6957 } 6958 if (!strcmp(name, "vkCreateEvent")) 6959 { 6960 return (void*)entry_vkCreateEvent; 6961 } 6962 if (!strcmp(name, "vkDestroyEvent")) 6963 { 6964 return (void*)entry_vkDestroyEvent; 6965 } 6966 if (!strcmp(name, "vkGetEventStatus")) 6967 { 6968 return (void*)entry_vkGetEventStatus; 6969 } 6970 if (!strcmp(name, "vkSetEvent")) 6971 { 6972 return (void*)entry_vkSetEvent; 6973 } 6974 if (!strcmp(name, "vkResetEvent")) 6975 { 6976 return (void*)entry_vkResetEvent; 6977 } 6978 if (!strcmp(name, "vkCreateQueryPool")) 6979 { 6980 return (void*)entry_vkCreateQueryPool; 6981 } 6982 if (!strcmp(name, "vkDestroyQueryPool")) 6983 { 6984 return (void*)entry_vkDestroyQueryPool; 6985 } 6986 if (!strcmp(name, "vkGetQueryPoolResults")) 6987 { 6988 return (void*)entry_vkGetQueryPoolResults; 6989 } 6990 if (!strcmp(name, "vkCreateBuffer")) 6991 { 6992 return (void*)entry_vkCreateBuffer; 6993 } 6994 if (!strcmp(name, "vkDestroyBuffer")) 6995 { 6996 return (void*)entry_vkDestroyBuffer; 6997 } 6998 if (!strcmp(name, "vkCreateBufferView")) 6999 { 7000 return (void*)entry_vkCreateBufferView; 7001 } 7002 if (!strcmp(name, "vkDestroyBufferView")) 7003 { 7004 return (void*)entry_vkDestroyBufferView; 7005 } 7006 if (!strcmp(name, "vkCreateImage")) 7007 { 7008 return (void*)entry_vkCreateImage; 7009 } 7010 if (!strcmp(name, "vkDestroyImage")) 7011 { 7012 return (void*)entry_vkDestroyImage; 7013 } 7014 if (!strcmp(name, "vkGetImageSubresourceLayout")) 7015 { 7016 return (void*)entry_vkGetImageSubresourceLayout; 7017 } 7018 if (!strcmp(name, "vkCreateImageView")) 7019 { 7020 return (void*)entry_vkCreateImageView; 7021 } 7022 if (!strcmp(name, "vkDestroyImageView")) 7023 { 7024 return (void*)entry_vkDestroyImageView; 7025 } 7026 if (!strcmp(name, "vkCreateShaderModule")) 7027 { 7028 return (void*)entry_vkCreateShaderModule; 7029 } 7030 if (!strcmp(name, "vkDestroyShaderModule")) 7031 { 7032 return (void*)entry_vkDestroyShaderModule; 7033 } 7034 if (!strcmp(name, "vkCreatePipelineCache")) 7035 { 7036 return (void*)entry_vkCreatePipelineCache; 7037 } 7038 if (!strcmp(name, "vkDestroyPipelineCache")) 7039 { 7040 return (void*)entry_vkDestroyPipelineCache; 7041 } 7042 if (!strcmp(name, "vkGetPipelineCacheData")) 7043 { 7044 return (void*)entry_vkGetPipelineCacheData; 7045 } 7046 if (!strcmp(name, "vkMergePipelineCaches")) 7047 { 7048 return (void*)entry_vkMergePipelineCaches; 7049 } 7050 if (!strcmp(name, "vkCreateGraphicsPipelines")) 7051 { 7052 return (void*)entry_vkCreateGraphicsPipelines; 7053 } 7054 if (!strcmp(name, "vkCreateComputePipelines")) 7055 { 7056 return (void*)entry_vkCreateComputePipelines; 7057 } 7058 if (!strcmp(name, "vkDestroyPipeline")) 7059 { 7060 return (void*)entry_vkDestroyPipeline; 7061 } 7062 if (!strcmp(name, "vkCreatePipelineLayout")) 7063 { 7064 return (void*)entry_vkCreatePipelineLayout; 7065 } 7066 if (!strcmp(name, "vkDestroyPipelineLayout")) 7067 { 7068 return (void*)entry_vkDestroyPipelineLayout; 7069 } 7070 if (!strcmp(name, "vkCreateSampler")) 7071 { 7072 return (void*)entry_vkCreateSampler; 7073 } 7074 if (!strcmp(name, "vkDestroySampler")) 7075 { 7076 return (void*)entry_vkDestroySampler; 7077 } 7078 if (!strcmp(name, "vkCreateDescriptorSetLayout")) 7079 { 7080 return (void*)entry_vkCreateDescriptorSetLayout; 7081 } 7082 if (!strcmp(name, "vkDestroyDescriptorSetLayout")) 7083 { 7084 return (void*)entry_vkDestroyDescriptorSetLayout; 7085 } 7086 if (!strcmp(name, "vkCreateDescriptorPool")) 7087 { 7088 return (void*)entry_vkCreateDescriptorPool; 7089 } 7090 if (!strcmp(name, "vkDestroyDescriptorPool")) 7091 { 7092 return (void*)entry_vkDestroyDescriptorPool; 7093 } 7094 if (!strcmp(name, "vkResetDescriptorPool")) 7095 { 7096 return (void*)entry_vkResetDescriptorPool; 7097 } 7098 if (!strcmp(name, "vkAllocateDescriptorSets")) 7099 { 7100 return (void*)entry_vkAllocateDescriptorSets; 7101 } 7102 if (!strcmp(name, "vkFreeDescriptorSets")) 7103 { 7104 return (void*)entry_vkFreeDescriptorSets; 7105 } 7106 if (!strcmp(name, "vkUpdateDescriptorSets")) 7107 { 7108 return (void*)entry_vkUpdateDescriptorSets; 7109 } 7110 if (!strcmp(name, "vkCreateFramebuffer")) 7111 { 7112 return (void*)entry_vkCreateFramebuffer; 7113 } 7114 if (!strcmp(name, "vkDestroyFramebuffer")) 7115 { 7116 return (void*)entry_vkDestroyFramebuffer; 7117 } 7118 if (!strcmp(name, "vkCreateRenderPass")) 7119 { 7120 return (void*)entry_vkCreateRenderPass; 7121 } 7122 if (!strcmp(name, "vkDestroyRenderPass")) 7123 { 7124 return (void*)entry_vkDestroyRenderPass; 7125 } 7126 if (!strcmp(name, "vkGetRenderAreaGranularity")) 7127 { 7128 return (void*)entry_vkGetRenderAreaGranularity; 7129 } 7130 if (!strcmp(name, "vkCreateCommandPool")) 7131 { 7132 return (void*)entry_vkCreateCommandPool; 7133 } 7134 if (!strcmp(name, "vkDestroyCommandPool")) 7135 { 7136 return (void*)entry_vkDestroyCommandPool; 7137 } 7138 if (!strcmp(name, "vkResetCommandPool")) 7139 { 7140 return (void*)entry_vkResetCommandPool; 7141 } 7142 if (!strcmp(name, "vkAllocateCommandBuffers")) 7143 { 7144 return (void*)entry_vkAllocateCommandBuffers; 7145 } 7146 if (!strcmp(name, "vkFreeCommandBuffers")) 7147 { 7148 return (void*)entry_vkFreeCommandBuffers; 7149 } 7150 if (!strcmp(name, "vkBeginCommandBuffer")) 7151 { 7152 return (void*)entry_vkBeginCommandBuffer; 7153 } 7154 if (!strcmp(name, "vkEndCommandBuffer")) 7155 { 7156 return (void*)entry_vkEndCommandBuffer; 7157 } 7158 if (!strcmp(name, "vkResetCommandBuffer")) 7159 { 7160 return (void*)entry_vkResetCommandBuffer; 7161 } 7162 if (!strcmp(name, "vkCmdBindPipeline")) 7163 { 7164 return (void*)entry_vkCmdBindPipeline; 7165 } 7166 if (!strcmp(name, "vkCmdSetViewport")) 7167 { 7168 return (void*)entry_vkCmdSetViewport; 7169 } 7170 if (!strcmp(name, "vkCmdSetScissor")) 7171 { 7172 return (void*)entry_vkCmdSetScissor; 7173 } 7174 if (!strcmp(name, "vkCmdSetLineWidth")) 7175 { 7176 return (void*)entry_vkCmdSetLineWidth; 7177 } 7178 if (!strcmp(name, "vkCmdSetDepthBias")) 7179 { 7180 return (void*)entry_vkCmdSetDepthBias; 7181 } 7182 if (!strcmp(name, "vkCmdSetBlendConstants")) 7183 { 7184 return (void*)entry_vkCmdSetBlendConstants; 7185 } 7186 if (!strcmp(name, "vkCmdSetDepthBounds")) 7187 { 7188 return (void*)entry_vkCmdSetDepthBounds; 7189 } 7190 if (!strcmp(name, "vkCmdSetStencilCompareMask")) 7191 { 7192 return (void*)entry_vkCmdSetStencilCompareMask; 7193 } 7194 if (!strcmp(name, "vkCmdSetStencilWriteMask")) 7195 { 7196 return (void*)entry_vkCmdSetStencilWriteMask; 7197 } 7198 if (!strcmp(name, "vkCmdSetStencilReference")) 7199 { 7200 return (void*)entry_vkCmdSetStencilReference; 7201 } 7202 if (!strcmp(name, "vkCmdBindDescriptorSets")) 7203 { 7204 return (void*)entry_vkCmdBindDescriptorSets; 7205 } 7206 if (!strcmp(name, "vkCmdBindIndexBuffer")) 7207 { 7208 return (void*)entry_vkCmdBindIndexBuffer; 7209 } 7210 if (!strcmp(name, "vkCmdBindVertexBuffers")) 7211 { 7212 return (void*)entry_vkCmdBindVertexBuffers; 7213 } 7214 if (!strcmp(name, "vkCmdDraw")) 7215 { 7216 return (void*)entry_vkCmdDraw; 7217 } 7218 if (!strcmp(name, "vkCmdDrawIndexed")) 7219 { 7220 return (void*)entry_vkCmdDrawIndexed; 7221 } 7222 if (!strcmp(name, "vkCmdDrawIndirect")) 7223 { 7224 return (void*)entry_vkCmdDrawIndirect; 7225 } 7226 if (!strcmp(name, "vkCmdDrawIndexedIndirect")) 7227 { 7228 return (void*)entry_vkCmdDrawIndexedIndirect; 7229 } 7230 if (!strcmp(name, "vkCmdDispatch")) 7231 { 7232 return (void*)entry_vkCmdDispatch; 7233 } 7234 if (!strcmp(name, "vkCmdDispatchIndirect")) 7235 { 7236 return (void*)entry_vkCmdDispatchIndirect; 7237 } 7238 if (!strcmp(name, "vkCmdCopyBuffer")) 7239 { 7240 return (void*)entry_vkCmdCopyBuffer; 7241 } 7242 if (!strcmp(name, "vkCmdCopyImage")) 7243 { 7244 return (void*)entry_vkCmdCopyImage; 7245 } 7246 if (!strcmp(name, "vkCmdBlitImage")) 7247 { 7248 return (void*)entry_vkCmdBlitImage; 7249 } 7250 if (!strcmp(name, "vkCmdCopyBufferToImage")) 7251 { 7252 return (void*)entry_vkCmdCopyBufferToImage; 7253 } 7254 if (!strcmp(name, "vkCmdCopyImageToBuffer")) 7255 { 7256 return (void*)entry_vkCmdCopyImageToBuffer; 7257 } 7258 if (!strcmp(name, "vkCmdUpdateBuffer")) 7259 { 7260 return (void*)entry_vkCmdUpdateBuffer; 7261 } 7262 if (!strcmp(name, "vkCmdFillBuffer")) 7263 { 7264 return (void*)entry_vkCmdFillBuffer; 7265 } 7266 if (!strcmp(name, "vkCmdClearColorImage")) 7267 { 7268 return (void*)entry_vkCmdClearColorImage; 7269 } 7270 if (!strcmp(name, "vkCmdClearDepthStencilImage")) 7271 { 7272 return (void*)entry_vkCmdClearDepthStencilImage; 7273 } 7274 if (!strcmp(name, "vkCmdClearAttachments")) 7275 { 7276 return (void*)entry_vkCmdClearAttachments; 7277 } 7278 if (!strcmp(name, "vkCmdResolveImage")) 7279 { 7280 return (void*)entry_vkCmdResolveImage; 7281 } 7282 if (!strcmp(name, "vkCmdSetEvent")) 7283 { 7284 return (void*)entry_vkCmdSetEvent; 7285 } 7286 if (!strcmp(name, "vkCmdResetEvent")) 7287 { 7288 return (void*)entry_vkCmdResetEvent; 7289 } 7290 if (!strcmp(name, "vkCmdWaitEvents")) 7291 { 7292 return (void*)entry_vkCmdWaitEvents; 7293 } 7294 if (!strcmp(name, "vkCmdPipelineBarrier")) 7295 { 7296 return (void*)entry_vkCmdPipelineBarrier; 7297 } 7298 if (!strcmp(name, "vkCmdBeginQuery")) 7299 { 7300 return (void*)entry_vkCmdBeginQuery; 7301 } 7302 if (!strcmp(name, "vkCmdEndQuery")) 7303 { 7304 return (void*)entry_vkCmdEndQuery; 7305 } 7306 if (!strcmp(name, "vkCmdResetQueryPool")) 7307 { 7308 return (void*)entry_vkCmdResetQueryPool; 7309 } 7310 if (!strcmp(name, "vkCmdWriteTimestamp")) 7311 { 7312 return (void*)entry_vkCmdWriteTimestamp; 7313 } 7314 if (!strcmp(name, "vkCmdCopyQueryPoolResults")) 7315 { 7316 return (void*)entry_vkCmdCopyQueryPoolResults; 7317 } 7318 if (!strcmp(name, "vkCmdPushConstants")) 7319 { 7320 return (void*)entry_vkCmdPushConstants; 7321 } 7322 if (!strcmp(name, "vkCmdBeginRenderPass")) 7323 { 7324 return (void*)entry_vkCmdBeginRenderPass; 7325 } 7326 if (!strcmp(name, "vkCmdNextSubpass")) 7327 { 7328 return (void*)entry_vkCmdNextSubpass; 7329 } 7330 if (!strcmp(name, "vkCmdEndRenderPass")) 7331 { 7332 return (void*)entry_vkCmdEndRenderPass; 7333 } 7334 if (!strcmp(name, "vkCmdExecuteCommands")) 7335 { 7336 return (void*)entry_vkCmdExecuteCommands; 7337 } 7338 #endif 7339 #ifdef VK_VERSION_1_1 7340 if (!strcmp(name, "vkEnumerateInstanceVersion")) 7341 { 7342 return has1_1OrHigher ? (void*)entry_vkEnumerateInstanceVersion : nullptr; 7343 } 7344 if (!strcmp(name, "vkBindBufferMemory2")) 7345 { 7346 return has1_1OrHigher ? (void*)entry_vkBindBufferMemory2 : nullptr; 7347 } 7348 if (!strcmp(name, "vkBindImageMemory2")) 7349 { 7350 return has1_1OrHigher ? (void*)entry_vkBindImageMemory2 : nullptr; 7351 } 7352 if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures")) 7353 { 7354 return has1_1OrHigher ? (void*)entry_vkGetDeviceGroupPeerMemoryFeatures : nullptr; 7355 } 7356 if (!strcmp(name, "vkCmdSetDeviceMask")) 7357 { 7358 return has1_1OrHigher ? (void*)entry_vkCmdSetDeviceMask : nullptr; 7359 } 7360 if (!strcmp(name, "vkCmdDispatchBase")) 7361 { 7362 return has1_1OrHigher ? (void*)entry_vkCmdDispatchBase : nullptr; 7363 } 7364 if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups")) 7365 { 7366 return nullptr; 7367 } 7368 if (!strcmp(name, "vkGetImageMemoryRequirements2")) 7369 { 7370 return has1_1OrHigher ? (void*)entry_vkGetImageMemoryRequirements2 : nullptr; 7371 } 7372 if (!strcmp(name, "vkGetBufferMemoryRequirements2")) 7373 { 7374 return has1_1OrHigher ? (void*)entry_vkGetBufferMemoryRequirements2 : nullptr; 7375 } 7376 if (!strcmp(name, "vkGetImageSparseMemoryRequirements2")) 7377 { 7378 return has1_1OrHigher ? (void*)entry_vkGetImageSparseMemoryRequirements2 : nullptr; 7379 } 7380 if (!strcmp(name, "vkGetPhysicalDeviceFeatures2")) 7381 { 7382 return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFeatures2 : nullptr; 7383 } 7384 if (!strcmp(name, "vkGetPhysicalDeviceProperties2")) 7385 { 7386 return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceProperties2 : nullptr; 7387 } 7388 if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2")) 7389 { 7390 return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFormatProperties2 : nullptr; 7391 } 7392 if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2")) 7393 { 7394 return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2 : nullptr; 7395 } 7396 if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2")) 7397 { 7398 return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2 : nullptr; 7399 } 7400 if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2")) 7401 { 7402 return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2 : nullptr; 7403 } 7404 if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2")) 7405 { 7406 return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2 : nullptr; 7407 } 7408 if (!strcmp(name, "vkTrimCommandPool")) 7409 { 7410 return has1_1OrHigher ? (void*)entry_vkTrimCommandPool : nullptr; 7411 } 7412 if (!strcmp(name, "vkGetDeviceQueue2")) 7413 { 7414 return has1_1OrHigher ? (void*)entry_vkGetDeviceQueue2 : nullptr; 7415 } 7416 if (!strcmp(name, "vkCreateSamplerYcbcrConversion")) 7417 { 7418 return has1_1OrHigher ? (void*)entry_vkCreateSamplerYcbcrConversion : nullptr; 7419 } 7420 if (!strcmp(name, "vkDestroySamplerYcbcrConversion")) 7421 { 7422 return has1_1OrHigher ? (void*)entry_vkDestroySamplerYcbcrConversion : nullptr; 7423 } 7424 if (!strcmp(name, "vkCreateDescriptorUpdateTemplate")) 7425 { 7426 return has1_1OrHigher ? (void*)entry_vkCreateDescriptorUpdateTemplate : nullptr; 7427 } 7428 if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate")) 7429 { 7430 return has1_1OrHigher ? (void*)entry_vkDestroyDescriptorUpdateTemplate : nullptr; 7431 } 7432 if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate")) 7433 { 7434 return has1_1OrHigher ? (void*)entry_vkUpdateDescriptorSetWithTemplate : nullptr; 7435 } 7436 if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties")) 7437 { 7438 return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalBufferProperties : nullptr; 7439 } 7440 if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties")) 7441 { 7442 return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalFenceProperties : nullptr; 7443 } 7444 if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties")) 7445 { 7446 return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalSemaphoreProperties : nullptr; 7447 } 7448 if (!strcmp(name, "vkGetDescriptorSetLayoutSupport")) 7449 { 7450 return has1_1OrHigher ? (void*)entry_vkGetDescriptorSetLayoutSupport : nullptr; 7451 } 7452 #endif 7453 #ifdef VK_KHR_surface 7454 if (!strcmp(name, "vkDestroySurfaceKHR")) 7455 { 7456 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_surface"); 7457 return hasExt ? (void*)entry_vkDestroySurfaceKHR : nullptr; 7458 } 7459 if (!strcmp(name, "vkGetPhysicalDeviceSurfaceSupportKHR")) 7460 { 7461 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_surface"); 7462 return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceSupportKHR : nullptr; 7463 } 7464 if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR")) 7465 { 7466 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_surface"); 7467 return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceCapabilitiesKHR : nullptr; 7468 } 7469 if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormatsKHR")) 7470 { 7471 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_surface"); 7472 return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceFormatsKHR : nullptr; 7473 } 7474 if (!strcmp(name, "vkGetPhysicalDeviceSurfacePresentModesKHR")) 7475 { 7476 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_surface"); 7477 return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfacePresentModesKHR : nullptr; 7478 } 7479 #endif 7480 #ifdef VK_KHR_swapchain 7481 if (!strcmp(name, "vkCreateSwapchainKHR")) 7482 { 7483 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain"); 7484 return hasExt ? (void*)entry_vkCreateSwapchainKHR : nullptr; 7485 } 7486 if (!strcmp(name, "vkDestroySwapchainKHR")) 7487 { 7488 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain"); 7489 return hasExt ? (void*)entry_vkDestroySwapchainKHR : nullptr; 7490 } 7491 if (!strcmp(name, "vkGetSwapchainImagesKHR")) 7492 { 7493 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain"); 7494 return hasExt ? (void*)entry_vkGetSwapchainImagesKHR : nullptr; 7495 } 7496 if (!strcmp(name, "vkAcquireNextImageKHR")) 7497 { 7498 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain"); 7499 return hasExt ? (void*)entry_vkAcquireNextImageKHR : nullptr; 7500 } 7501 if (!strcmp(name, "vkQueuePresentKHR")) 7502 { 7503 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain"); 7504 return hasExt ? (void*)entry_vkQueuePresentKHR : nullptr; 7505 } 7506 if (!strcmp(name, "vkGetDeviceGroupPresentCapabilitiesKHR")) 7507 { 7508 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain"); 7509 return hasExt ? (void*)entry_vkGetDeviceGroupPresentCapabilitiesKHR : nullptr; 7510 } 7511 if (!strcmp(name, "vkGetDeviceGroupSurfacePresentModesKHR")) 7512 { 7513 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain"); 7514 return hasExt ? (void*)entry_vkGetDeviceGroupSurfacePresentModesKHR : nullptr; 7515 } 7516 if (!strcmp(name, "vkGetPhysicalDevicePresentRectanglesKHR")) 7517 { 7518 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain"); 7519 return hasExt ? (void*)entry_vkGetPhysicalDevicePresentRectanglesKHR : nullptr; 7520 } 7521 if (!strcmp(name, "vkAcquireNextImage2KHR")) 7522 { 7523 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain"); 7524 return hasExt ? (void*)entry_vkAcquireNextImage2KHR : nullptr; 7525 } 7526 #endif 7527 #ifdef VK_KHR_display 7528 if (!strcmp(name, "vkGetPhysicalDeviceDisplayPropertiesKHR")) 7529 { 7530 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_display"); 7531 return hasExt ? (void*)entry_vkGetPhysicalDeviceDisplayPropertiesKHR : nullptr; 7532 } 7533 if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR")) 7534 { 7535 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_display"); 7536 return hasExt ? (void*)entry_vkGetPhysicalDeviceDisplayPlanePropertiesKHR : nullptr; 7537 } 7538 if (!strcmp(name, "vkGetDisplayPlaneSupportedDisplaysKHR")) 7539 { 7540 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_display"); 7541 return hasExt ? (void*)entry_vkGetDisplayPlaneSupportedDisplaysKHR : nullptr; 7542 } 7543 if (!strcmp(name, "vkGetDisplayModePropertiesKHR")) 7544 { 7545 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_display"); 7546 return hasExt ? (void*)entry_vkGetDisplayModePropertiesKHR : nullptr; 7547 } 7548 if (!strcmp(name, "vkCreateDisplayModeKHR")) 7549 { 7550 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_display"); 7551 return hasExt ? (void*)entry_vkCreateDisplayModeKHR : nullptr; 7552 } 7553 if (!strcmp(name, "vkGetDisplayPlaneCapabilitiesKHR")) 7554 { 7555 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_display"); 7556 return hasExt ? (void*)entry_vkGetDisplayPlaneCapabilitiesKHR : nullptr; 7557 } 7558 if (!strcmp(name, "vkCreateDisplayPlaneSurfaceKHR")) 7559 { 7560 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_display"); 7561 return hasExt ? (void*)entry_vkCreateDisplayPlaneSurfaceKHR : nullptr; 7562 } 7563 #endif 7564 #ifdef VK_KHR_display_swapchain 7565 if (!strcmp(name, "vkCreateSharedSwapchainsKHR")) 7566 { 7567 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_display_swapchain"); 7568 return hasExt ? (void*)entry_vkCreateSharedSwapchainsKHR : nullptr; 7569 } 7570 #endif 7571 #ifdef VK_KHR_xlib_surface 7572 if (!strcmp(name, "vkCreateXlibSurfaceKHR")) 7573 { 7574 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_xlib_surface"); 7575 return hasExt ? (void*)entry_vkCreateXlibSurfaceKHR : nullptr; 7576 } 7577 if (!strcmp(name, "vkGetPhysicalDeviceXlibPresentationSupportKHR")) 7578 { 7579 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_xlib_surface"); 7580 return hasExt ? (void*)entry_vkGetPhysicalDeviceXlibPresentationSupportKHR : nullptr; 7581 } 7582 #endif 7583 #ifdef VK_KHR_xcb_surface 7584 if (!strcmp(name, "vkCreateXcbSurfaceKHR")) 7585 { 7586 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_xcb_surface"); 7587 return hasExt ? (void*)entry_vkCreateXcbSurfaceKHR : nullptr; 7588 } 7589 if (!strcmp(name, "vkGetPhysicalDeviceXcbPresentationSupportKHR")) 7590 { 7591 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_xcb_surface"); 7592 return hasExt ? (void*)entry_vkGetPhysicalDeviceXcbPresentationSupportKHR : nullptr; 7593 } 7594 #endif 7595 #ifdef VK_KHR_wayland_surface 7596 if (!strcmp(name, "vkCreateWaylandSurfaceKHR")) 7597 { 7598 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_wayland_surface"); 7599 return hasExt ? (void*)entry_vkCreateWaylandSurfaceKHR : nullptr; 7600 } 7601 if (!strcmp(name, "vkGetPhysicalDeviceWaylandPresentationSupportKHR")) 7602 { 7603 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_wayland_surface"); 7604 return hasExt ? (void*)entry_vkGetPhysicalDeviceWaylandPresentationSupportKHR : nullptr; 7605 } 7606 #endif 7607 #ifdef VK_KHR_mir_surface 7608 if (!strcmp(name, "vkCreateMirSurfaceKHR")) 7609 { 7610 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_mir_surface"); 7611 return hasExt ? (void*)entry_vkCreateMirSurfaceKHR : nullptr; 7612 } 7613 if (!strcmp(name, "vkGetPhysicalDeviceMirPresentationSupportKHR")) 7614 { 7615 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_mir_surface"); 7616 return hasExt ? (void*)entry_vkGetPhysicalDeviceMirPresentationSupportKHR : nullptr; 7617 } 7618 #endif 7619 #ifdef VK_KHR_android_surface 7620 if (!strcmp(name, "vkCreateAndroidSurfaceKHR")) 7621 { 7622 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_android_surface"); 7623 return hasExt ? (void*)entry_vkCreateAndroidSurfaceKHR : nullptr; 7624 } 7625 #endif 7626 #ifdef VK_KHR_win32_surface 7627 if (!strcmp(name, "vkCreateWin32SurfaceKHR")) 7628 { 7629 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_win32_surface"); 7630 return hasExt ? (void*)entry_vkCreateWin32SurfaceKHR : nullptr; 7631 } 7632 if (!strcmp(name, "vkGetPhysicalDeviceWin32PresentationSupportKHR")) 7633 { 7634 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_win32_surface"); 7635 return hasExt ? (void*)entry_vkGetPhysicalDeviceWin32PresentationSupportKHR : nullptr; 7636 } 7637 #endif 7638 #ifdef VK_KHR_get_physical_device_properties2 7639 if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR")) 7640 { 7641 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2"); 7642 return hasExt ? (void*)entry_vkGetPhysicalDeviceFeatures2KHR : nullptr; 7643 } 7644 if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR")) 7645 { 7646 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2"); 7647 return hasExt ? (void*)entry_vkGetPhysicalDeviceProperties2KHR : nullptr; 7648 } 7649 if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR")) 7650 { 7651 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2"); 7652 return hasExt ? (void*)entry_vkGetPhysicalDeviceFormatProperties2KHR : nullptr; 7653 } 7654 if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR")) 7655 { 7656 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2"); 7657 return hasExt ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2KHR : nullptr; 7658 } 7659 if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR")) 7660 { 7661 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2"); 7662 return hasExt ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR : nullptr; 7663 } 7664 if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR")) 7665 { 7666 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2"); 7667 return hasExt ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2KHR : nullptr; 7668 } 7669 if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")) 7670 { 7671 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2"); 7672 return hasExt ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR : nullptr; 7673 } 7674 #endif 7675 #ifdef VK_KHR_device_group 7676 if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeaturesKHR")) 7677 { 7678 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_device_group"); 7679 return hasExt ? (void*)entry_vkGetDeviceGroupPeerMemoryFeaturesKHR : nullptr; 7680 } 7681 if (!strcmp(name, "vkCmdSetDeviceMaskKHR")) 7682 { 7683 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_device_group"); 7684 return hasExt ? (void*)entry_vkCmdSetDeviceMaskKHR : nullptr; 7685 } 7686 if (!strcmp(name, "vkCmdDispatchBaseKHR")) 7687 { 7688 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_device_group"); 7689 return hasExt ? (void*)entry_vkCmdDispatchBaseKHR : nullptr; 7690 } 7691 #endif 7692 #ifdef VK_KHR_maintenance1 7693 if (!strcmp(name, "vkTrimCommandPoolKHR")) 7694 { 7695 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance1"); 7696 return hasExt ? (void*)entry_vkTrimCommandPoolKHR : nullptr; 7697 } 7698 #endif 7699 #ifdef VK_KHR_device_group_creation 7700 if (!strcmp(name, "vkEnumeratePhysicalDeviceGroupsKHR")) 7701 { 7702 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_device_group_creation"); 7703 return hasExt ? (void*)entry_vkEnumeratePhysicalDeviceGroupsKHR : nullptr; 7704 } 7705 #endif 7706 #ifdef VK_KHR_external_memory_capabilities 7707 if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR")) 7708 { 7709 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_memory_capabilities"); 7710 return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR : nullptr; 7711 } 7712 #endif 7713 #ifdef VK_KHR_external_memory_win32 7714 if (!strcmp(name, "vkGetMemoryWin32HandleKHR")) 7715 { 7716 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_memory_win32"); 7717 return hasExt ? (void*)entry_vkGetMemoryWin32HandleKHR : nullptr; 7718 } 7719 if (!strcmp(name, "vkGetMemoryWin32HandlePropertiesKHR")) 7720 { 7721 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_memory_win32"); 7722 return hasExt ? (void*)entry_vkGetMemoryWin32HandlePropertiesKHR : nullptr; 7723 } 7724 #endif 7725 #ifdef VK_KHR_external_memory_fd 7726 if (!strcmp(name, "vkGetMemoryFdKHR")) 7727 { 7728 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_memory_fd"); 7729 return hasExt ? (void*)entry_vkGetMemoryFdKHR : nullptr; 7730 } 7731 if (!strcmp(name, "vkGetMemoryFdPropertiesKHR")) 7732 { 7733 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_memory_fd"); 7734 return hasExt ? (void*)entry_vkGetMemoryFdPropertiesKHR : nullptr; 7735 } 7736 #endif 7737 #ifdef VK_KHR_external_semaphore_capabilities 7738 if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")) 7739 { 7740 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_capabilities"); 7741 return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR : nullptr; 7742 } 7743 #endif 7744 #ifdef VK_KHR_external_semaphore_win32 7745 if (!strcmp(name, "vkImportSemaphoreWin32HandleKHR")) 7746 { 7747 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_win32"); 7748 return hasExt ? (void*)entry_vkImportSemaphoreWin32HandleKHR : nullptr; 7749 } 7750 if (!strcmp(name, "vkGetSemaphoreWin32HandleKHR")) 7751 { 7752 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_win32"); 7753 return hasExt ? (void*)entry_vkGetSemaphoreWin32HandleKHR : nullptr; 7754 } 7755 #endif 7756 #ifdef VK_KHR_external_semaphore_fd 7757 if (!strcmp(name, "vkImportSemaphoreFdKHR")) 7758 { 7759 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd"); 7760 return hasExt ? (void*)entry_vkImportSemaphoreFdKHR : nullptr; 7761 } 7762 if (!strcmp(name, "vkGetSemaphoreFdKHR")) 7763 { 7764 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd"); 7765 return hasExt ? (void*)entry_vkGetSemaphoreFdKHR : nullptr; 7766 } 7767 #endif 7768 #ifdef VK_KHR_push_descriptor 7769 if (!strcmp(name, "vkCmdPushDescriptorSetKHR")) 7770 { 7771 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_push_descriptor"); 7772 return hasExt ? (void*)entry_vkCmdPushDescriptorSetKHR : nullptr; 7773 } 7774 if (!strcmp(name, "vkCmdPushDescriptorSetWithTemplateKHR")) 7775 { 7776 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_push_descriptor"); 7777 return hasExt ? (void*)entry_vkCmdPushDescriptorSetWithTemplateKHR : nullptr; 7778 } 7779 #endif 7780 #ifdef VK_KHR_descriptor_update_template 7781 if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR")) 7782 { 7783 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template"); 7784 return hasExt ? (void*)entry_vkCreateDescriptorUpdateTemplateKHR : nullptr; 7785 } 7786 if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR")) 7787 { 7788 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template"); 7789 return hasExt ? (void*)entry_vkDestroyDescriptorUpdateTemplateKHR : nullptr; 7790 } 7791 if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR")) 7792 { 7793 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template"); 7794 return hasExt ? (void*)entry_vkUpdateDescriptorSetWithTemplateKHR : nullptr; 7795 } 7796 #endif 7797 #ifdef VK_KHR_create_renderpass2 7798 if (!strcmp(name, "vkCreateRenderPass2KHR")) 7799 { 7800 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2"); 7801 return hasExt ? (void*)entry_vkCreateRenderPass2KHR : nullptr; 7802 } 7803 if (!strcmp(name, "vkCmdBeginRenderPass2KHR")) 7804 { 7805 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2"); 7806 return hasExt ? (void*)entry_vkCmdBeginRenderPass2KHR : nullptr; 7807 } 7808 if (!strcmp(name, "vkCmdNextSubpass2KHR")) 7809 { 7810 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2"); 7811 return hasExt ? (void*)entry_vkCmdNextSubpass2KHR : nullptr; 7812 } 7813 if (!strcmp(name, "vkCmdEndRenderPass2KHR")) 7814 { 7815 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2"); 7816 return hasExt ? (void*)entry_vkCmdEndRenderPass2KHR : nullptr; 7817 } 7818 #endif 7819 #ifdef VK_KHR_shared_presentable_image 7820 if (!strcmp(name, "vkGetSwapchainStatusKHR")) 7821 { 7822 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_shared_presentable_image"); 7823 return hasExt ? (void*)entry_vkGetSwapchainStatusKHR : nullptr; 7824 } 7825 #endif 7826 #ifdef VK_KHR_external_fence_capabilities 7827 if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR")) 7828 { 7829 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_fence_capabilities"); 7830 return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalFencePropertiesKHR : nullptr; 7831 } 7832 #endif 7833 #ifdef VK_KHR_external_fence_win32 7834 if (!strcmp(name, "vkImportFenceWin32HandleKHR")) 7835 { 7836 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_fence_win32"); 7837 return hasExt ? (void*)entry_vkImportFenceWin32HandleKHR : nullptr; 7838 } 7839 if (!strcmp(name, "vkGetFenceWin32HandleKHR")) 7840 { 7841 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_fence_win32"); 7842 return hasExt ? (void*)entry_vkGetFenceWin32HandleKHR : nullptr; 7843 } 7844 #endif 7845 #ifdef VK_KHR_external_fence_fd 7846 if (!strcmp(name, "vkImportFenceFdKHR")) 7847 { 7848 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd"); 7849 return hasExt ? (void*)entry_vkImportFenceFdKHR : nullptr; 7850 } 7851 if (!strcmp(name, "vkGetFenceFdKHR")) 7852 { 7853 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd"); 7854 return hasExt ? (void*)entry_vkGetFenceFdKHR : nullptr; 7855 } 7856 #endif 7857 #ifdef VK_KHR_get_surface_capabilities2 7858 if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2KHR")) 7859 { 7860 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_surface_capabilities2"); 7861 return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceCapabilities2KHR : nullptr; 7862 } 7863 if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormats2KHR")) 7864 { 7865 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_surface_capabilities2"); 7866 return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceFormats2KHR : nullptr; 7867 } 7868 #endif 7869 #ifdef VK_KHR_get_display_properties2 7870 if (!strcmp(name, "vkGetPhysicalDeviceDisplayProperties2KHR")) 7871 { 7872 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_display_properties2"); 7873 return hasExt ? (void*)entry_vkGetPhysicalDeviceDisplayProperties2KHR : nullptr; 7874 } 7875 if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR")) 7876 { 7877 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_display_properties2"); 7878 return hasExt ? (void*)entry_vkGetPhysicalDeviceDisplayPlaneProperties2KHR : nullptr; 7879 } 7880 if (!strcmp(name, "vkGetDisplayModeProperties2KHR")) 7881 { 7882 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_display_properties2"); 7883 return hasExt ? (void*)entry_vkGetDisplayModeProperties2KHR : nullptr; 7884 } 7885 if (!strcmp(name, "vkGetDisplayPlaneCapabilities2KHR")) 7886 { 7887 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_display_properties2"); 7888 return hasExt ? (void*)entry_vkGetDisplayPlaneCapabilities2KHR : nullptr; 7889 } 7890 #endif 7891 #ifdef VK_KHR_get_memory_requirements2 7892 if (!strcmp(name, "vkGetImageMemoryRequirements2KHR")) 7893 { 7894 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2"); 7895 return hasExt ? (void*)entry_vkGetImageMemoryRequirements2KHR : nullptr; 7896 } 7897 if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR")) 7898 { 7899 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2"); 7900 return hasExt ? (void*)entry_vkGetBufferMemoryRequirements2KHR : nullptr; 7901 } 7902 if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR")) 7903 { 7904 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2"); 7905 return hasExt ? (void*)entry_vkGetImageSparseMemoryRequirements2KHR : nullptr; 7906 } 7907 #endif 7908 #ifdef VK_KHR_sampler_ycbcr_conversion 7909 if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR")) 7910 { 7911 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion"); 7912 return hasExt ? (void*)entry_vkCreateSamplerYcbcrConversionKHR : nullptr; 7913 } 7914 if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR")) 7915 { 7916 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion"); 7917 return hasExt ? (void*)entry_vkDestroySamplerYcbcrConversionKHR : nullptr; 7918 } 7919 #endif 7920 #ifdef VK_KHR_bind_memory2 7921 if (!strcmp(name, "vkBindBufferMemory2KHR")) 7922 { 7923 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_bind_memory2"); 7924 return hasExt ? (void*)entry_vkBindBufferMemory2KHR : nullptr; 7925 } 7926 if (!strcmp(name, "vkBindImageMemory2KHR")) 7927 { 7928 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_bind_memory2"); 7929 return hasExt ? (void*)entry_vkBindImageMemory2KHR : nullptr; 7930 } 7931 #endif 7932 #ifdef VK_KHR_maintenance3 7933 if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR")) 7934 { 7935 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance3"); 7936 return hasExt ? (void*)entry_vkGetDescriptorSetLayoutSupportKHR : nullptr; 7937 } 7938 #endif 7939 #ifdef VK_KHR_draw_indirect_count 7940 if (!strcmp(name, "vkCmdDrawIndirectCountKHR")) 7941 { 7942 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_draw_indirect_count"); 7943 return hasExt ? (void*)entry_vkCmdDrawIndirectCountKHR : nullptr; 7944 } 7945 if (!strcmp(name, "vkCmdDrawIndexedIndirectCountKHR")) 7946 { 7947 bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_draw_indirect_count"); 7948 return hasExt ? (void*)entry_vkCmdDrawIndexedIndirectCountKHR : nullptr; 7949 } 7950 #endif 7951 #ifdef VK_ANDROID_native_buffer 7952 if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID")) 7953 { 7954 bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer"); 7955 return hasExt ? (void*)entry_vkGetSwapchainGrallocUsageANDROID : nullptr; 7956 } 7957 if (!strcmp(name, "vkAcquireImageANDROID")) 7958 { 7959 bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer"); 7960 return hasExt ? (void*)entry_vkAcquireImageANDROID : nullptr; 7961 } 7962 if (!strcmp(name, "vkQueueSignalReleaseImageANDROID")) 7963 { 7964 bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer"); 7965 return hasExt ? (void*)entry_vkQueueSignalReleaseImageANDROID : nullptr; 7966 } 7967 #endif 7968 #ifdef VK_EXT_debug_report 7969 if (!strcmp(name, "vkCreateDebugReportCallbackEXT")) 7970 { 7971 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_report"); 7972 return hasExt ? (void*)entry_vkCreateDebugReportCallbackEXT : nullptr; 7973 } 7974 if (!strcmp(name, "vkDestroyDebugReportCallbackEXT")) 7975 { 7976 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_report"); 7977 return hasExt ? (void*)entry_vkDestroyDebugReportCallbackEXT : nullptr; 7978 } 7979 if (!strcmp(name, "vkDebugReportMessageEXT")) 7980 { 7981 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_report"); 7982 return hasExt ? (void*)entry_vkDebugReportMessageEXT : nullptr; 7983 } 7984 #endif 7985 #ifdef VK_EXT_debug_marker 7986 if (!strcmp(name, "vkDebugMarkerSetObjectTagEXT")) 7987 { 7988 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_marker"); 7989 return hasExt ? (void*)entry_vkDebugMarkerSetObjectTagEXT : nullptr; 7990 } 7991 if (!strcmp(name, "vkDebugMarkerSetObjectNameEXT")) 7992 { 7993 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_marker"); 7994 return hasExt ? (void*)entry_vkDebugMarkerSetObjectNameEXT : nullptr; 7995 } 7996 if (!strcmp(name, "vkCmdDebugMarkerBeginEXT")) 7997 { 7998 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_marker"); 7999 return hasExt ? (void*)entry_vkCmdDebugMarkerBeginEXT : nullptr; 8000 } 8001 if (!strcmp(name, "vkCmdDebugMarkerEndEXT")) 8002 { 8003 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_marker"); 8004 return hasExt ? (void*)entry_vkCmdDebugMarkerEndEXT : nullptr; 8005 } 8006 if (!strcmp(name, "vkCmdDebugMarkerInsertEXT")) 8007 { 8008 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_marker"); 8009 return hasExt ? (void*)entry_vkCmdDebugMarkerInsertEXT : nullptr; 8010 } 8011 #endif 8012 #ifdef VK_AMD_draw_indirect_count 8013 if (!strcmp(name, "vkCmdDrawIndirectCountAMD")) 8014 { 8015 bool hasExt = resources->hasDeviceExtension(device, "VK_AMD_draw_indirect_count"); 8016 return hasExt ? (void*)entry_vkCmdDrawIndirectCountAMD : nullptr; 8017 } 8018 if (!strcmp(name, "vkCmdDrawIndexedIndirectCountAMD")) 8019 { 8020 bool hasExt = resources->hasDeviceExtension(device, "VK_AMD_draw_indirect_count"); 8021 return hasExt ? (void*)entry_vkCmdDrawIndexedIndirectCountAMD : nullptr; 8022 } 8023 #endif 8024 #ifdef VK_AMD_shader_info 8025 if (!strcmp(name, "vkGetShaderInfoAMD")) 8026 { 8027 bool hasExt = resources->hasDeviceExtension(device, "VK_AMD_shader_info"); 8028 return hasExt ? (void*)entry_vkGetShaderInfoAMD : nullptr; 8029 } 8030 #endif 8031 #ifdef VK_NV_external_memory_capabilities 8032 if (!strcmp(name, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV")) 8033 { 8034 bool hasExt = resources->hasDeviceExtension(device, "VK_NV_external_memory_capabilities"); 8035 return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalImageFormatPropertiesNV : nullptr; 8036 } 8037 #endif 8038 #ifdef VK_NV_external_memory_win32 8039 if (!strcmp(name, "vkGetMemoryWin32HandleNV")) 8040 { 8041 bool hasExt = resources->hasDeviceExtension(device, "VK_NV_external_memory_win32"); 8042 return hasExt ? (void*)entry_vkGetMemoryWin32HandleNV : nullptr; 8043 } 8044 #endif 8045 #ifdef VK_NN_vi_surface 8046 if (!strcmp(name, "vkCreateViSurfaceNN")) 8047 { 8048 bool hasExt = resources->hasDeviceExtension(device, "VK_NN_vi_surface"); 8049 return hasExt ? (void*)entry_vkCreateViSurfaceNN : nullptr; 8050 } 8051 #endif 8052 #ifdef VK_EXT_conditional_rendering 8053 if (!strcmp(name, "vkCmdBeginConditionalRenderingEXT")) 8054 { 8055 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_conditional_rendering"); 8056 return hasExt ? (void*)entry_vkCmdBeginConditionalRenderingEXT : nullptr; 8057 } 8058 if (!strcmp(name, "vkCmdEndConditionalRenderingEXT")) 8059 { 8060 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_conditional_rendering"); 8061 return hasExt ? (void*)entry_vkCmdEndConditionalRenderingEXT : nullptr; 8062 } 8063 #endif 8064 #ifdef VK_NVX_device_generated_commands 8065 if (!strcmp(name, "vkCmdProcessCommandsNVX")) 8066 { 8067 bool hasExt = resources->hasDeviceExtension(device, "VK_NVX_device_generated_commands"); 8068 return hasExt ? (void*)entry_vkCmdProcessCommandsNVX : nullptr; 8069 } 8070 if (!strcmp(name, "vkCmdReserveSpaceForCommandsNVX")) 8071 { 8072 bool hasExt = resources->hasDeviceExtension(device, "VK_NVX_device_generated_commands"); 8073 return hasExt ? (void*)entry_vkCmdReserveSpaceForCommandsNVX : nullptr; 8074 } 8075 if (!strcmp(name, "vkCreateIndirectCommandsLayoutNVX")) 8076 { 8077 bool hasExt = resources->hasDeviceExtension(device, "VK_NVX_device_generated_commands"); 8078 return hasExt ? (void*)entry_vkCreateIndirectCommandsLayoutNVX : nullptr; 8079 } 8080 if (!strcmp(name, "vkDestroyIndirectCommandsLayoutNVX")) 8081 { 8082 bool hasExt = resources->hasDeviceExtension(device, "VK_NVX_device_generated_commands"); 8083 return hasExt ? (void*)entry_vkDestroyIndirectCommandsLayoutNVX : nullptr; 8084 } 8085 if (!strcmp(name, "vkCreateObjectTableNVX")) 8086 { 8087 bool hasExt = resources->hasDeviceExtension(device, "VK_NVX_device_generated_commands"); 8088 return hasExt ? (void*)entry_vkCreateObjectTableNVX : nullptr; 8089 } 8090 if (!strcmp(name, "vkDestroyObjectTableNVX")) 8091 { 8092 bool hasExt = resources->hasDeviceExtension(device, "VK_NVX_device_generated_commands"); 8093 return hasExt ? (void*)entry_vkDestroyObjectTableNVX : nullptr; 8094 } 8095 if (!strcmp(name, "vkRegisterObjectsNVX")) 8096 { 8097 bool hasExt = resources->hasDeviceExtension(device, "VK_NVX_device_generated_commands"); 8098 return hasExt ? (void*)entry_vkRegisterObjectsNVX : nullptr; 8099 } 8100 if (!strcmp(name, "vkUnregisterObjectsNVX")) 8101 { 8102 bool hasExt = resources->hasDeviceExtension(device, "VK_NVX_device_generated_commands"); 8103 return hasExt ? (void*)entry_vkUnregisterObjectsNVX : nullptr; 8104 } 8105 if (!strcmp(name, "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX")) 8106 { 8107 bool hasExt = resources->hasDeviceExtension(device, "VK_NVX_device_generated_commands"); 8108 return hasExt ? (void*)entry_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX : nullptr; 8109 } 8110 #endif 8111 #ifdef VK_NV_clip_space_w_scaling 8112 if (!strcmp(name, "vkCmdSetViewportWScalingNV")) 8113 { 8114 bool hasExt = resources->hasDeviceExtension(device, "VK_NV_clip_space_w_scaling"); 8115 return hasExt ? (void*)entry_vkCmdSetViewportWScalingNV : nullptr; 8116 } 8117 #endif 8118 #ifdef VK_EXT_direct_mode_display 8119 if (!strcmp(name, "vkReleaseDisplayEXT")) 8120 { 8121 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_direct_mode_display"); 8122 return hasExt ? (void*)entry_vkReleaseDisplayEXT : nullptr; 8123 } 8124 #endif 8125 #ifdef VK_EXT_acquire_xlib_display 8126 if (!strcmp(name, "vkAcquireXlibDisplayEXT")) 8127 { 8128 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_acquire_xlib_display"); 8129 return hasExt ? (void*)entry_vkAcquireXlibDisplayEXT : nullptr; 8130 } 8131 if (!strcmp(name, "vkGetRandROutputDisplayEXT")) 8132 { 8133 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_acquire_xlib_display"); 8134 return hasExt ? (void*)entry_vkGetRandROutputDisplayEXT : nullptr; 8135 } 8136 #endif 8137 #ifdef VK_EXT_display_surface_counter 8138 if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2EXT")) 8139 { 8140 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_display_surface_counter"); 8141 return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceCapabilities2EXT : nullptr; 8142 } 8143 #endif 8144 #ifdef VK_EXT_display_control 8145 if (!strcmp(name, "vkDisplayPowerControlEXT")) 8146 { 8147 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_display_control"); 8148 return hasExt ? (void*)entry_vkDisplayPowerControlEXT : nullptr; 8149 } 8150 if (!strcmp(name, "vkRegisterDeviceEventEXT")) 8151 { 8152 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_display_control"); 8153 return hasExt ? (void*)entry_vkRegisterDeviceEventEXT : nullptr; 8154 } 8155 if (!strcmp(name, "vkRegisterDisplayEventEXT")) 8156 { 8157 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_display_control"); 8158 return hasExt ? (void*)entry_vkRegisterDisplayEventEXT : nullptr; 8159 } 8160 if (!strcmp(name, "vkGetSwapchainCounterEXT")) 8161 { 8162 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_display_control"); 8163 return hasExt ? (void*)entry_vkGetSwapchainCounterEXT : nullptr; 8164 } 8165 #endif 8166 #ifdef VK_GOOGLE_display_timing 8167 if (!strcmp(name, "vkGetRefreshCycleDurationGOOGLE")) 8168 { 8169 bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_display_timing"); 8170 return hasExt ? (void*)entry_vkGetRefreshCycleDurationGOOGLE : nullptr; 8171 } 8172 if (!strcmp(name, "vkGetPastPresentationTimingGOOGLE")) 8173 { 8174 bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_display_timing"); 8175 return hasExt ? (void*)entry_vkGetPastPresentationTimingGOOGLE : nullptr; 8176 } 8177 #endif 8178 #ifdef VK_EXT_discard_rectangles 8179 if (!strcmp(name, "vkCmdSetDiscardRectangleEXT")) 8180 { 8181 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_discard_rectangles"); 8182 return hasExt ? (void*)entry_vkCmdSetDiscardRectangleEXT : nullptr; 8183 } 8184 #endif 8185 #ifdef VK_EXT_hdr_metadata 8186 if (!strcmp(name, "vkSetHdrMetadataEXT")) 8187 { 8188 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_hdr_metadata"); 8189 return hasExt ? (void*)entry_vkSetHdrMetadataEXT : nullptr; 8190 } 8191 #endif 8192 #ifdef VK_MVK_ios_surface 8193 if (!strcmp(name, "vkCreateIOSSurfaceMVK")) 8194 { 8195 bool hasExt = resources->hasDeviceExtension(device, "VK_MVK_ios_surface"); 8196 return hasExt ? (void*)entry_vkCreateIOSSurfaceMVK : nullptr; 8197 } 8198 #endif 8199 #ifdef VK_MVK_macos_surface 8200 if (!strcmp(name, "vkCreateMacOSSurfaceMVK")) 8201 { 8202 bool hasExt = resources->hasDeviceExtension(device, "VK_MVK_macos_surface"); 8203 return hasExt ? (void*)entry_vkCreateMacOSSurfaceMVK : nullptr; 8204 } 8205 #endif 8206 #ifdef VK_EXT_debug_utils 8207 if (!strcmp(name, "vkSetDebugUtilsObjectNameEXT")) 8208 { 8209 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_utils"); 8210 return hasExt ? (void*)entry_vkSetDebugUtilsObjectNameEXT : nullptr; 8211 } 8212 if (!strcmp(name, "vkSetDebugUtilsObjectTagEXT")) 8213 { 8214 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_utils"); 8215 return hasExt ? (void*)entry_vkSetDebugUtilsObjectTagEXT : nullptr; 8216 } 8217 if (!strcmp(name, "vkQueueBeginDebugUtilsLabelEXT")) 8218 { 8219 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_utils"); 8220 return hasExt ? (void*)entry_vkQueueBeginDebugUtilsLabelEXT : nullptr; 8221 } 8222 if (!strcmp(name, "vkQueueEndDebugUtilsLabelEXT")) 8223 { 8224 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_utils"); 8225 return hasExt ? (void*)entry_vkQueueEndDebugUtilsLabelEXT : nullptr; 8226 } 8227 if (!strcmp(name, "vkQueueInsertDebugUtilsLabelEXT")) 8228 { 8229 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_utils"); 8230 return hasExt ? (void*)entry_vkQueueInsertDebugUtilsLabelEXT : nullptr; 8231 } 8232 if (!strcmp(name, "vkCmdBeginDebugUtilsLabelEXT")) 8233 { 8234 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_utils"); 8235 return hasExt ? (void*)entry_vkCmdBeginDebugUtilsLabelEXT : nullptr; 8236 } 8237 if (!strcmp(name, "vkCmdEndDebugUtilsLabelEXT")) 8238 { 8239 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_utils"); 8240 return hasExt ? (void*)entry_vkCmdEndDebugUtilsLabelEXT : nullptr; 8241 } 8242 if (!strcmp(name, "vkCmdInsertDebugUtilsLabelEXT")) 8243 { 8244 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_utils"); 8245 return hasExt ? (void*)entry_vkCmdInsertDebugUtilsLabelEXT : nullptr; 8246 } 8247 if (!strcmp(name, "vkCreateDebugUtilsMessengerEXT")) 8248 { 8249 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_utils"); 8250 return hasExt ? (void*)entry_vkCreateDebugUtilsMessengerEXT : nullptr; 8251 } 8252 if (!strcmp(name, "vkDestroyDebugUtilsMessengerEXT")) 8253 { 8254 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_utils"); 8255 return hasExt ? (void*)entry_vkDestroyDebugUtilsMessengerEXT : nullptr; 8256 } 8257 if (!strcmp(name, "vkSubmitDebugUtilsMessageEXT")) 8258 { 8259 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_utils"); 8260 return hasExt ? (void*)entry_vkSubmitDebugUtilsMessageEXT : nullptr; 8261 } 8262 #endif 8263 #ifdef VK_ANDROID_external_memory_android_hardware_buffer 8264 if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID")) 8265 { 8266 bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_external_memory_android_hardware_buffer"); 8267 return hasExt ? (void*)entry_vkGetAndroidHardwareBufferPropertiesANDROID : nullptr; 8268 } 8269 if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID")) 8270 { 8271 bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_external_memory_android_hardware_buffer"); 8272 return hasExt ? (void*)entry_vkGetMemoryAndroidHardwareBufferANDROID : nullptr; 8273 } 8274 #endif 8275 #ifdef VK_EXT_sample_locations 8276 if (!strcmp(name, "vkCmdSetSampleLocationsEXT")) 8277 { 8278 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_sample_locations"); 8279 return hasExt ? (void*)entry_vkCmdSetSampleLocationsEXT : nullptr; 8280 } 8281 if (!strcmp(name, "vkGetPhysicalDeviceMultisamplePropertiesEXT")) 8282 { 8283 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_sample_locations"); 8284 return hasExt ? (void*)entry_vkGetPhysicalDeviceMultisamplePropertiesEXT : nullptr; 8285 } 8286 #endif 8287 #ifdef VK_EXT_validation_cache 8288 if (!strcmp(name, "vkCreateValidationCacheEXT")) 8289 { 8290 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_validation_cache"); 8291 return hasExt ? (void*)entry_vkCreateValidationCacheEXT : nullptr; 8292 } 8293 if (!strcmp(name, "vkDestroyValidationCacheEXT")) 8294 { 8295 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_validation_cache"); 8296 return hasExt ? (void*)entry_vkDestroyValidationCacheEXT : nullptr; 8297 } 8298 if (!strcmp(name, "vkMergeValidationCachesEXT")) 8299 { 8300 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_validation_cache"); 8301 return hasExt ? (void*)entry_vkMergeValidationCachesEXT : nullptr; 8302 } 8303 if (!strcmp(name, "vkGetValidationCacheDataEXT")) 8304 { 8305 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_validation_cache"); 8306 return hasExt ? (void*)entry_vkGetValidationCacheDataEXT : nullptr; 8307 } 8308 #endif 8309 #ifdef VK_EXT_external_memory_host 8310 if (!strcmp(name, "vkGetMemoryHostPointerPropertiesEXT")) 8311 { 8312 bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_external_memory_host"); 8313 return hasExt ? (void*)entry_vkGetMemoryHostPointerPropertiesEXT : nullptr; 8314 } 8315 #endif 8316 #ifdef VK_AMD_buffer_marker 8317 if (!strcmp(name, "vkCmdWriteBufferMarkerAMD")) 8318 { 8319 bool hasExt = resources->hasDeviceExtension(device, "VK_AMD_buffer_marker"); 8320 return hasExt ? (void*)entry_vkCmdWriteBufferMarkerAMD : nullptr; 8321 } 8322 #endif 8323 #ifdef VK_NV_device_diagnostic_checkpoints 8324 if (!strcmp(name, "vkCmdSetCheckpointNV")) 8325 { 8326 bool hasExt = resources->hasDeviceExtension(device, "VK_NV_device_diagnostic_checkpoints"); 8327 return hasExt ? (void*)entry_vkCmdSetCheckpointNV : nullptr; 8328 } 8329 if (!strcmp(name, "vkGetQueueCheckpointDataNV")) 8330 { 8331 bool hasExt = resources->hasDeviceExtension(device, "VK_NV_device_diagnostic_checkpoints"); 8332 return hasExt ? (void*)entry_vkGetQueueCheckpointDataNV : nullptr; 8333 } 8334 #endif 8335 #ifdef VK_GOOGLE_address_space 8336 if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE")) 8337 { 8338 bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_address_space"); 8339 return hasExt ? (void*)entry_vkMapMemoryIntoAddressSpaceGOOGLE : nullptr; 8340 } 8341 #endif 8342 #ifdef VK_GOOGLE_color_buffer 8343 if (!strcmp(name, "vkRegisterImageColorBufferGOOGLE")) 8344 { 8345 bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_color_buffer"); 8346 return hasExt ? (void*)entry_vkRegisterImageColorBufferGOOGLE : nullptr; 8347 } 8348 if (!strcmp(name, "vkRegisterBufferColorBufferGOOGLE")) 8349 { 8350 bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_color_buffer"); 8351 return hasExt ? (void*)entry_vkRegisterBufferColorBufferGOOGLE : nullptr; 8352 } 8353 #endif 8354 #ifdef VK_GOOGLE_sized_descriptor_update_template 8355 if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSizedGOOGLE")) 8356 { 8357 bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_sized_descriptor_update_template"); 8358 return hasExt ? (void*)entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE : nullptr; 8359 } 8360 #endif 8361 #ifdef VK_GOOGLE_async_command_buffers 8362 if (!strcmp(name, "vkBeginCommandBufferAsyncGOOGLE")) 8363 { 8364 bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_async_command_buffers"); 8365 return hasExt ? (void*)entry_vkBeginCommandBufferAsyncGOOGLE : nullptr; 8366 } 8367 if (!strcmp(name, "vkEndCommandBufferAsyncGOOGLE")) 8368 { 8369 bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_async_command_buffers"); 8370 return hasExt ? (void*)entry_vkEndCommandBufferAsyncGOOGLE : nullptr; 8371 } 8372 if (!strcmp(name, "vkResetCommandBufferAsyncGOOGLE")) 8373 { 8374 bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_async_command_buffers"); 8375 return hasExt ? (void*)entry_vkResetCommandBufferAsyncGOOGLE : nullptr; 8376 } 8377 #endif 8378 return nullptr; 8379 } 8380 8381 } // namespace goldfish_vk 8382
