Home | History | Annotate | Download | only in vulkan
      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