[vulkan] Add function lookup table
bug: 111137294
bug: 119104088
Change-Id: Id27b02e239be3ab4b07dce4c5f0abb4ac749dc74
diff --git a/system/vulkan/Android.mk b/system/vulkan/Android.mk
index 931993c..c30d8da 100644
--- a/system/vulkan/Android.mk
+++ b/system/vulkan/Android.mk
@@ -32,6 +32,7 @@
-DVK_NO_PROTOTYPES \
LOCAL_SRC_FILES := \
+ func_table.cpp \
goldfish_vulkan.cpp \
$(call emugl-end-module)
diff --git a/system/vulkan/CMakeLists.txt b/system/vulkan/CMakeLists.txt
index d1b92e8..cdd1520 100644
--- a/system/vulkan/CMakeLists.txt
+++ b/system/vulkan/CMakeLists.txt
@@ -1,7 +1,7 @@
# This is an autogenerated file! Do not edit!
# instead run make from .../device/generic/goldfish-opengl
# which will re-generate this file.
-set(vulkan.ranchu_src goldfish_vulkan.cpp)
+set(vulkan.ranchu_src func_table.cpp goldfish_vulkan.cpp)
android_add_shared_library(vulkan.ranchu)
target_include_directories(vulkan.ranchu PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/system/vulkan ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/host/include)
target_compile_definitions(vulkan.ranchu PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"goldfish_vulkan\"" "-DVK_USE_PLATFORM_ANDROID_KHR" "-DVK_NO_PROTOTYPES")
diff --git a/system/vulkan/func_table.cpp b/system/vulkan/func_table.cpp
new file mode 100644
index 0000000..809e4f0
--- /dev/null
+++ b/system/vulkan/func_table.cpp
@@ -0,0 +1,4668 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module func_table
+// (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
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#include "func_table.h"
+
+
+#include "VkEncoder.h"
+#include "HostConnection.h"
+
+// Stuff we are not going to use but if included,
+// will cause compile errors. These are Android Vulkan
+// required extensions, but the approach will be to
+// implement them completely on the guest side.
+#undef VK_KHR_android_surface
+#undef VK_ANDROID_external_memory_android_hardware_buffer
+
+
+namespace goldfish_vk {
+
+#ifdef VK_VERSION_1_0
+static VkResult entry_vkCreateInstance(
+ const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkInstance* pInstance)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateInstance_VkResult_return = (VkResult)0;
+ vkCreateInstance_VkResult_return = vkEnc->vkCreateInstance(pCreateInfo, pAllocator, pInstance);
+ return vkCreateInstance_VkResult_return;
+}
+static void entry_vkDestroyInstance(
+ VkInstance instance,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyInstance(instance, pAllocator);
+}
+static VkResult entry_vkEnumeratePhysicalDevices(
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceCount,
+ VkPhysicalDevice* pPhysicalDevices)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkEnumeratePhysicalDevices_VkResult_return = (VkResult)0;
+ vkEnumeratePhysicalDevices_VkResult_return = vkEnc->vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
+ return vkEnumeratePhysicalDevices_VkResult_return;
+}
+static void entry_vkGetPhysicalDeviceFeatures(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures* pFeatures)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures);
+}
+static void entry_vkGetPhysicalDeviceFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties* pFormatProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
+}
+static VkResult entry_vkGetPhysicalDeviceImageFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkImageTiling tiling,
+ VkImageUsageFlags usage,
+ VkImageCreateFlags flags,
+ VkImageFormatProperties* pImageFormatProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceImageFormatProperties_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceImageFormatProperties_VkResult_return = vkEnc->vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
+ return vkGetPhysicalDeviceImageFormatProperties_VkResult_return;
+}
+static void entry_vkGetPhysicalDeviceProperties(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceProperties(physicalDevice, pProperties);
+}
+static void entry_vkGetPhysicalDeviceQueueFamilyProperties(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties* pQueueFamilyProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+}
+static void entry_vkGetPhysicalDeviceMemoryProperties(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties* pMemoryProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
+}
+static PFN_vkVoidFunction entry_vkGetInstanceProcAddr(
+ VkInstance instance,
+ const char* pName)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ PFN_vkVoidFunction vkGetInstanceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
+ vkGetInstanceProcAddr_PFN_vkVoidFunction_return = vkEnc->vkGetInstanceProcAddr(instance, pName);
+ return vkGetInstanceProcAddr_PFN_vkVoidFunction_return;
+}
+static PFN_vkVoidFunction entry_vkGetDeviceProcAddr(
+ VkDevice device,
+ const char* pName)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ PFN_vkVoidFunction vkGetDeviceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
+ vkGetDeviceProcAddr_PFN_vkVoidFunction_return = vkEnc->vkGetDeviceProcAddr(device, pName);
+ return vkGetDeviceProcAddr_PFN_vkVoidFunction_return;
+}
+static VkResult entry_vkCreateDevice(
+ VkPhysicalDevice physicalDevice,
+ const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDevice* pDevice)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateDevice_VkResult_return = (VkResult)0;
+ vkCreateDevice_VkResult_return = vkEnc->vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
+ return vkCreateDevice_VkResult_return;
+}
+static void entry_vkDestroyDevice(
+ VkDevice device,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyDevice(device, pAllocator);
+}
+static VkResult entry_vkEnumerateInstanceExtensionProperties(
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkEnumerateInstanceExtensionProperties_VkResult_return = (VkResult)0;
+ vkEnumerateInstanceExtensionProperties_VkResult_return = vkEnc->vkEnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, pProperties);
+ return vkEnumerateInstanceExtensionProperties_VkResult_return;
+}
+static VkResult entry_vkEnumerateDeviceExtensionProperties(
+ VkPhysicalDevice physicalDevice,
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkEnumerateDeviceExtensionProperties_VkResult_return = (VkResult)0;
+ vkEnumerateDeviceExtensionProperties_VkResult_return = vkEnc->vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
+ return vkEnumerateDeviceExtensionProperties_VkResult_return;
+}
+static VkResult entry_vkEnumerateInstanceLayerProperties(
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkEnumerateInstanceLayerProperties_VkResult_return = (VkResult)0;
+ vkEnumerateInstanceLayerProperties_VkResult_return = vkEnc->vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties);
+ return vkEnumerateInstanceLayerProperties_VkResult_return;
+}
+static VkResult entry_vkEnumerateDeviceLayerProperties(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkEnumerateDeviceLayerProperties_VkResult_return = (VkResult)0;
+ vkEnumerateDeviceLayerProperties_VkResult_return = vkEnc->vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
+ return vkEnumerateDeviceLayerProperties_VkResult_return;
+}
+static void entry_vkGetDeviceQueue(
+ VkDevice device,
+ uint32_t queueFamilyIndex,
+ uint32_t queueIndex,
+ VkQueue* pQueue)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
+}
+static VkResult entry_vkQueueSubmit(
+ VkQueue queue,
+ uint32_t submitCount,
+ const VkSubmitInfo* pSubmits,
+ VkFence fence)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkQueueSubmit_VkResult_return = (VkResult)0;
+ vkQueueSubmit_VkResult_return = vkEnc->vkQueueSubmit(queue, submitCount, pSubmits, fence);
+ return vkQueueSubmit_VkResult_return;
+}
+static VkResult entry_vkQueueWaitIdle(
+ VkQueue queue)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkQueueWaitIdle_VkResult_return = (VkResult)0;
+ vkQueueWaitIdle_VkResult_return = vkEnc->vkQueueWaitIdle(queue);
+ return vkQueueWaitIdle_VkResult_return;
+}
+static VkResult entry_vkDeviceWaitIdle(
+ VkDevice device)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkDeviceWaitIdle_VkResult_return = (VkResult)0;
+ vkDeviceWaitIdle_VkResult_return = vkEnc->vkDeviceWaitIdle(device);
+ return vkDeviceWaitIdle_VkResult_return;
+}
+static VkResult entry_vkAllocateMemory(
+ VkDevice device,
+ const VkMemoryAllocateInfo* pAllocateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkAllocateMemory_VkResult_return = (VkResult)0;
+ vkAllocateMemory_VkResult_return = vkEnc->vkAllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
+ return vkAllocateMemory_VkResult_return;
+}
+static void entry_vkFreeMemory(
+ VkDevice device,
+ VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkFreeMemory(device, memory, pAllocator);
+}
+static VkResult entry_vkMapMemory(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkDeviceSize offset,
+ VkDeviceSize size,
+ VkMemoryMapFlags flags,
+ void** ppData)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkMapMemory_VkResult_return = (VkResult)0;
+ vkMapMemory_VkResult_return = vkEnc->vkMapMemory(device, memory, offset, size, flags, ppData);
+ return vkMapMemory_VkResult_return;
+}
+static void entry_vkUnmapMemory(
+ VkDevice device,
+ VkDeviceMemory memory)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkUnmapMemory(device, memory);
+}
+static VkResult entry_vkFlushMappedMemoryRanges(
+ VkDevice device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0;
+ vkFlushMappedMemoryRanges_VkResult_return = vkEnc->vkFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
+ return vkFlushMappedMemoryRanges_VkResult_return;
+}
+static VkResult entry_vkInvalidateMappedMemoryRanges(
+ VkDevice device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0;
+ vkInvalidateMappedMemoryRanges_VkResult_return = vkEnc->vkInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
+ return vkInvalidateMappedMemoryRanges_VkResult_return;
+}
+static void entry_vkGetDeviceMemoryCommitment(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkDeviceSize* pCommittedMemoryInBytes)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
+}
+static VkResult entry_vkBindBufferMemory(
+ VkDevice device,
+ VkBuffer buffer,
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkBindBufferMemory_VkResult_return = (VkResult)0;
+ vkBindBufferMemory_VkResult_return = vkEnc->vkBindBufferMemory(device, buffer, memory, memoryOffset);
+ return vkBindBufferMemory_VkResult_return;
+}
+static VkResult entry_vkBindImageMemory(
+ VkDevice device,
+ VkImage image,
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkBindImageMemory_VkResult_return = (VkResult)0;
+ vkBindImageMemory_VkResult_return = vkEnc->vkBindImageMemory(device, image, memory, memoryOffset);
+ return vkBindImageMemory_VkResult_return;
+}
+static void entry_vkGetBufferMemoryRequirements(
+ VkDevice device,
+ VkBuffer buffer,
+ VkMemoryRequirements* pMemoryRequirements)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
+}
+static void entry_vkGetImageMemoryRequirements(
+ VkDevice device,
+ VkImage image,
+ VkMemoryRequirements* pMemoryRequirements)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetImageMemoryRequirements(device, image, pMemoryRequirements);
+}
+static void entry_vkGetImageSparseMemoryRequirements(
+ VkDevice device,
+ VkImage image,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+}
+static void entry_vkGetPhysicalDeviceSparseImageFormatProperties(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkSampleCountFlagBits samples,
+ VkImageUsageFlags usage,
+ VkImageTiling tiling,
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
+}
+static VkResult entry_vkQueueBindSparse(
+ VkQueue queue,
+ uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo,
+ VkFence fence)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkQueueBindSparse_VkResult_return = (VkResult)0;
+ vkQueueBindSparse_VkResult_return = vkEnc->vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
+ return vkQueueBindSparse_VkResult_return;
+}
+static VkResult entry_vkCreateFence(
+ VkDevice device,
+ const VkFenceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateFence_VkResult_return = (VkResult)0;
+ vkCreateFence_VkResult_return = vkEnc->vkCreateFence(device, pCreateInfo, pAllocator, pFence);
+ return vkCreateFence_VkResult_return;
+}
+static void entry_vkDestroyFence(
+ VkDevice device,
+ VkFence fence,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyFence(device, fence, pAllocator);
+}
+static VkResult entry_vkResetFences(
+ VkDevice device,
+ uint32_t fenceCount,
+ const VkFence* pFences)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkResetFences_VkResult_return = (VkResult)0;
+ vkResetFences_VkResult_return = vkEnc->vkResetFences(device, fenceCount, pFences);
+ return vkResetFences_VkResult_return;
+}
+static VkResult entry_vkGetFenceStatus(
+ VkDevice device,
+ VkFence fence)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetFenceStatus_VkResult_return = (VkResult)0;
+ vkGetFenceStatus_VkResult_return = vkEnc->vkGetFenceStatus(device, fence);
+ return vkGetFenceStatus_VkResult_return;
+}
+static VkResult entry_vkWaitForFences(
+ VkDevice device,
+ uint32_t fenceCount,
+ const VkFence* pFences,
+ VkBool32 waitAll,
+ uint64_t timeout)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkWaitForFences_VkResult_return = (VkResult)0;
+ vkWaitForFences_VkResult_return = vkEnc->vkWaitForFences(device, fenceCount, pFences, waitAll, timeout);
+ return vkWaitForFences_VkResult_return;
+}
+static VkResult entry_vkCreateSemaphore(
+ VkDevice device,
+ const VkSemaphoreCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSemaphore* pSemaphore)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateSemaphore_VkResult_return = (VkResult)0;
+ vkCreateSemaphore_VkResult_return = vkEnc->vkCreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
+ return vkCreateSemaphore_VkResult_return;
+}
+static void entry_vkDestroySemaphore(
+ VkDevice device,
+ VkSemaphore semaphore,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroySemaphore(device, semaphore, pAllocator);
+}
+static VkResult entry_vkCreateEvent(
+ VkDevice device,
+ const VkEventCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkEvent* pEvent)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateEvent_VkResult_return = (VkResult)0;
+ vkCreateEvent_VkResult_return = vkEnc->vkCreateEvent(device, pCreateInfo, pAllocator, pEvent);
+ return vkCreateEvent_VkResult_return;
+}
+static void entry_vkDestroyEvent(
+ VkDevice device,
+ VkEvent event,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyEvent(device, event, pAllocator);
+}
+static VkResult entry_vkGetEventStatus(
+ VkDevice device,
+ VkEvent event)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetEventStatus_VkResult_return = (VkResult)0;
+ vkGetEventStatus_VkResult_return = vkEnc->vkGetEventStatus(device, event);
+ return vkGetEventStatus_VkResult_return;
+}
+static VkResult entry_vkSetEvent(
+ VkDevice device,
+ VkEvent event)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkSetEvent_VkResult_return = (VkResult)0;
+ vkSetEvent_VkResult_return = vkEnc->vkSetEvent(device, event);
+ return vkSetEvent_VkResult_return;
+}
+static VkResult entry_vkResetEvent(
+ VkDevice device,
+ VkEvent event)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkResetEvent_VkResult_return = (VkResult)0;
+ vkResetEvent_VkResult_return = vkEnc->vkResetEvent(device, event);
+ return vkResetEvent_VkResult_return;
+}
+static VkResult entry_vkCreateQueryPool(
+ VkDevice device,
+ const VkQueryPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkQueryPool* pQueryPool)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateQueryPool_VkResult_return = (VkResult)0;
+ vkCreateQueryPool_VkResult_return = vkEnc->vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
+ return vkCreateQueryPool_VkResult_return;
+}
+static void entry_vkDestroyQueryPool(
+ VkDevice device,
+ VkQueryPool queryPool,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyQueryPool(device, queryPool, pAllocator);
+}
+static VkResult entry_vkGetQueryPoolResults(
+ VkDevice device,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount,
+ size_t dataSize,
+ void* pData,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetQueryPoolResults_VkResult_return = (VkResult)0;
+ vkGetQueryPoolResults_VkResult_return = vkEnc->vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
+ return vkGetQueryPoolResults_VkResult_return;
+}
+static VkResult entry_vkCreateBuffer(
+ VkDevice device,
+ const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBuffer* pBuffer)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateBuffer_VkResult_return = (VkResult)0;
+ vkCreateBuffer_VkResult_return = vkEnc->vkCreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
+ return vkCreateBuffer_VkResult_return;
+}
+static void entry_vkDestroyBuffer(
+ VkDevice device,
+ VkBuffer buffer,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyBuffer(device, buffer, pAllocator);
+}
+static VkResult entry_vkCreateBufferView(
+ VkDevice device,
+ const VkBufferViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferView* pView)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateBufferView_VkResult_return = (VkResult)0;
+ vkCreateBufferView_VkResult_return = vkEnc->vkCreateBufferView(device, pCreateInfo, pAllocator, pView);
+ return vkCreateBufferView_VkResult_return;
+}
+static void entry_vkDestroyBufferView(
+ VkDevice device,
+ VkBufferView bufferView,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyBufferView(device, bufferView, pAllocator);
+}
+static VkResult entry_vkCreateImage(
+ VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateImage_VkResult_return = (VkResult)0;
+ vkCreateImage_VkResult_return = vkEnc->vkCreateImage(device, pCreateInfo, pAllocator, pImage);
+ return vkCreateImage_VkResult_return;
+}
+static void entry_vkDestroyImage(
+ VkDevice device,
+ VkImage image,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyImage(device, image, pAllocator);
+}
+static void entry_vkGetImageSubresourceLayout(
+ VkDevice device,
+ VkImage image,
+ const VkImageSubresource* pSubresource,
+ VkSubresourceLayout* pLayout)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetImageSubresourceLayout(device, image, pSubresource, pLayout);
+}
+static VkResult entry_vkCreateImageView(
+ VkDevice device,
+ const VkImageViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImageView* pView)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateImageView_VkResult_return = (VkResult)0;
+ vkCreateImageView_VkResult_return = vkEnc->vkCreateImageView(device, pCreateInfo, pAllocator, pView);
+ return vkCreateImageView_VkResult_return;
+}
+static void entry_vkDestroyImageView(
+ VkDevice device,
+ VkImageView imageView,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyImageView(device, imageView, pAllocator);
+}
+static VkResult entry_vkCreateShaderModule(
+ VkDevice device,
+ const VkShaderModuleCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkShaderModule* pShaderModule)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateShaderModule_VkResult_return = (VkResult)0;
+ vkCreateShaderModule_VkResult_return = vkEnc->vkCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
+ return vkCreateShaderModule_VkResult_return;
+}
+static void entry_vkDestroyShaderModule(
+ VkDevice device,
+ VkShaderModule shaderModule,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyShaderModule(device, shaderModule, pAllocator);
+}
+static VkResult entry_vkCreatePipelineCache(
+ VkDevice device,
+ const VkPipelineCacheCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineCache* pPipelineCache)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreatePipelineCache_VkResult_return = (VkResult)0;
+ vkCreatePipelineCache_VkResult_return = vkEnc->vkCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
+ return vkCreatePipelineCache_VkResult_return;
+}
+static void entry_vkDestroyPipelineCache(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyPipelineCache(device, pipelineCache, pAllocator);
+}
+static VkResult entry_vkGetPipelineCacheData(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ size_t* pDataSize,
+ void* pData)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPipelineCacheData_VkResult_return = (VkResult)0;
+ vkGetPipelineCacheData_VkResult_return = vkEnc->vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData);
+ return vkGetPipelineCacheData_VkResult_return;
+}
+static VkResult entry_vkMergePipelineCaches(
+ VkDevice device,
+ VkPipelineCache dstCache,
+ uint32_t srcCacheCount,
+ const VkPipelineCache* pSrcCaches)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkMergePipelineCaches_VkResult_return = (VkResult)0;
+ vkMergePipelineCaches_VkResult_return = vkEnc->vkMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
+ return vkMergePipelineCaches_VkResult_return;
+}
+static VkResult entry_vkCreateGraphicsPipelines(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkGraphicsPipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateGraphicsPipelines_VkResult_return = (VkResult)0;
+ vkCreateGraphicsPipelines_VkResult_return = vkEnc->vkCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+ return vkCreateGraphicsPipelines_VkResult_return;
+}
+static VkResult entry_vkCreateComputePipelines(
+ VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkComputePipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateComputePipelines_VkResult_return = (VkResult)0;
+ vkCreateComputePipelines_VkResult_return = vkEnc->vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+ return vkCreateComputePipelines_VkResult_return;
+}
+static void entry_vkDestroyPipeline(
+ VkDevice device,
+ VkPipeline pipeline,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyPipeline(device, pipeline, pAllocator);
+}
+static VkResult entry_vkCreatePipelineLayout(
+ VkDevice device,
+ const VkPipelineLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineLayout* pPipelineLayout)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreatePipelineLayout_VkResult_return = (VkResult)0;
+ vkCreatePipelineLayout_VkResult_return = vkEnc->vkCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
+ return vkCreatePipelineLayout_VkResult_return;
+}
+static void entry_vkDestroyPipelineLayout(
+ VkDevice device,
+ VkPipelineLayout pipelineLayout,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyPipelineLayout(device, pipelineLayout, pAllocator);
+}
+static VkResult entry_vkCreateSampler(
+ VkDevice device,
+ const VkSamplerCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSampler* pSampler)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateSampler_VkResult_return = (VkResult)0;
+ vkCreateSampler_VkResult_return = vkEnc->vkCreateSampler(device, pCreateInfo, pAllocator, pSampler);
+ return vkCreateSampler_VkResult_return;
+}
+static void entry_vkDestroySampler(
+ VkDevice device,
+ VkSampler sampler,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroySampler(device, sampler, pAllocator);
+}
+static VkResult entry_vkCreateDescriptorSetLayout(
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorSetLayout* pSetLayout)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0;
+ vkCreateDescriptorSetLayout_VkResult_return = vkEnc->vkCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
+ return vkCreateDescriptorSetLayout_VkResult_return;
+}
+static void entry_vkDestroyDescriptorSetLayout(
+ VkDevice device,
+ VkDescriptorSetLayout descriptorSetLayout,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
+}
+static VkResult entry_vkCreateDescriptorPool(
+ VkDevice device,
+ const VkDescriptorPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorPool* pDescriptorPool)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateDescriptorPool_VkResult_return = (VkResult)0;
+ vkCreateDescriptorPool_VkResult_return = vkEnc->vkCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
+ return vkCreateDescriptorPool_VkResult_return;
+}
+static void entry_vkDestroyDescriptorPool(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyDescriptorPool(device, descriptorPool, pAllocator);
+}
+static VkResult entry_vkResetDescriptorPool(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ VkDescriptorPoolResetFlags flags)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkResetDescriptorPool_VkResult_return = (VkResult)0;
+ vkResetDescriptorPool_VkResult_return = vkEnc->vkResetDescriptorPool(device, descriptorPool, flags);
+ return vkResetDescriptorPool_VkResult_return;
+}
+static VkResult entry_vkAllocateDescriptorSets(
+ VkDevice device,
+ const VkDescriptorSetAllocateInfo* pAllocateInfo,
+ VkDescriptorSet* pDescriptorSets)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkAllocateDescriptorSets_VkResult_return = (VkResult)0;
+ vkAllocateDescriptorSets_VkResult_return = vkEnc->vkAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
+ return vkAllocateDescriptorSets_VkResult_return;
+}
+static VkResult entry_vkFreeDescriptorSets(
+ VkDevice device,
+ VkDescriptorPool descriptorPool,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkFreeDescriptorSets_VkResult_return = (VkResult)0;
+ vkFreeDescriptorSets_VkResult_return = vkEnc->vkFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
+ return vkFreeDescriptorSets_VkResult_return;
+}
+static void entry_vkUpdateDescriptorSets(
+ VkDevice device,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites,
+ uint32_t descriptorCopyCount,
+ const VkCopyDescriptorSet* pDescriptorCopies)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+}
+static VkResult entry_vkCreateFramebuffer(
+ VkDevice device,
+ const VkFramebufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFramebuffer* pFramebuffer)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateFramebuffer_VkResult_return = (VkResult)0;
+ vkCreateFramebuffer_VkResult_return = vkEnc->vkCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
+ return vkCreateFramebuffer_VkResult_return;
+}
+static void entry_vkDestroyFramebuffer(
+ VkDevice device,
+ VkFramebuffer framebuffer,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyFramebuffer(device, framebuffer, pAllocator);
+}
+static VkResult entry_vkCreateRenderPass(
+ VkDevice device,
+ const VkRenderPassCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateRenderPass_VkResult_return = (VkResult)0;
+ vkCreateRenderPass_VkResult_return = vkEnc->vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
+ return vkCreateRenderPass_VkResult_return;
+}
+static void entry_vkDestroyRenderPass(
+ VkDevice device,
+ VkRenderPass renderPass,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyRenderPass(device, renderPass, pAllocator);
+}
+static void entry_vkGetRenderAreaGranularity(
+ VkDevice device,
+ VkRenderPass renderPass,
+ VkExtent2D* pGranularity)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetRenderAreaGranularity(device, renderPass, pGranularity);
+}
+static VkResult entry_vkCreateCommandPool(
+ VkDevice device,
+ const VkCommandPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCommandPool* pCommandPool)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateCommandPool_VkResult_return = (VkResult)0;
+ vkCreateCommandPool_VkResult_return = vkEnc->vkCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
+ return vkCreateCommandPool_VkResult_return;
+}
+static void entry_vkDestroyCommandPool(
+ VkDevice device,
+ VkCommandPool commandPool,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyCommandPool(device, commandPool, pAllocator);
+}
+static VkResult entry_vkResetCommandPool(
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolResetFlags flags)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkResetCommandPool_VkResult_return = (VkResult)0;
+ vkResetCommandPool_VkResult_return = vkEnc->vkResetCommandPool(device, commandPool, flags);
+ return vkResetCommandPool_VkResult_return;
+}
+static VkResult entry_vkAllocateCommandBuffers(
+ VkDevice device,
+ const VkCommandBufferAllocateInfo* pAllocateInfo,
+ VkCommandBuffer* pCommandBuffers)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkAllocateCommandBuffers_VkResult_return = (VkResult)0;
+ vkAllocateCommandBuffers_VkResult_return = vkEnc->vkAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
+ return vkAllocateCommandBuffers_VkResult_return;
+}
+static void entry_vkFreeCommandBuffers(
+ VkDevice device,
+ VkCommandPool commandPool,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
+}
+static VkResult entry_vkBeginCommandBuffer(
+ VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0;
+ vkBeginCommandBuffer_VkResult_return = vkEnc->vkBeginCommandBuffer(commandBuffer, pBeginInfo);
+ return vkBeginCommandBuffer_VkResult_return;
+}
+static VkResult entry_vkEndCommandBuffer(
+ VkCommandBuffer commandBuffer)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
+ vkEndCommandBuffer_VkResult_return = vkEnc->vkEndCommandBuffer(commandBuffer);
+ return vkEndCommandBuffer_VkResult_return;
+}
+static VkResult entry_vkResetCommandBuffer(
+ VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0;
+ vkResetCommandBuffer_VkResult_return = vkEnc->vkResetCommandBuffer(commandBuffer, flags);
+ return vkResetCommandBuffer_VkResult_return;
+}
+static void entry_vkCmdBindPipeline(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipeline pipeline)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
+}
+static void entry_vkCmdSetViewport(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkViewport* pViewports)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
+}
+static void entry_vkCmdSetScissor(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstScissor,
+ uint32_t scissorCount,
+ const VkRect2D* pScissors)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
+}
+static void entry_vkCmdSetLineWidth(
+ VkCommandBuffer commandBuffer,
+ float lineWidth)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetLineWidth(commandBuffer, lineWidth);
+}
+static void entry_vkCmdSetDepthBias(
+ VkCommandBuffer commandBuffer,
+ float depthBiasConstantFactor,
+ float depthBiasClamp,
+ float depthBiasSlopeFactor)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+}
+static void entry_vkCmdSetBlendConstants(
+ VkCommandBuffer commandBuffer,
+ const float blendConstants)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetBlendConstants(commandBuffer, blendConstants);
+}
+static void entry_vkCmdSetDepthBounds(
+ VkCommandBuffer commandBuffer,
+ float minDepthBounds,
+ float maxDepthBounds)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
+}
+static void entry_vkCmdSetStencilCompareMask(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t compareMask)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
+}
+static void entry_vkCmdSetStencilWriteMask(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t writeMask)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
+}
+static void entry_vkCmdSetStencilReference(
+ VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ uint32_t reference)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetStencilReference(commandBuffer, faceMask, reference);
+}
+static void entry_vkCmdBindDescriptorSets(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t firstSet,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets,
+ uint32_t dynamicOffsetCount,
+ const uint32_t* pDynamicOffsets)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+}
+static void entry_vkCmdBindIndexBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkIndexType indexType)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
+}
+static void entry_vkCmdBindVertexBuffers(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstBinding,
+ uint32_t bindingCount,
+ const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
+}
+static void entry_vkCmdDraw(
+ VkCommandBuffer commandBuffer,
+ uint32_t vertexCount,
+ uint32_t instanceCount,
+ uint32_t firstVertex,
+ uint32_t firstInstance)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+}
+static void entry_vkCmdDrawIndexed(
+ VkCommandBuffer commandBuffer,
+ uint32_t indexCount,
+ uint32_t instanceCount,
+ uint32_t firstIndex,
+ int32_t vertexOffset,
+ uint32_t firstInstance)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
+}
+static void entry_vkCmdDrawIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
+}
+static void entry_vkCmdDrawIndexedIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
+}
+static void entry_vkCmdDispatch(
+ VkCommandBuffer commandBuffer,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ);
+}
+static void entry_vkCmdDispatchIndirect(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDispatchIndirect(commandBuffer, buffer, offset);
+}
+static void entry_vkCmdCopyBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferCopy* pRegions)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
+}
+static void entry_vkCmdCopyImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageCopy* pRegions)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+}
+static void entry_vkCmdBlitImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageBlit* pRegions,
+ VkFilter filter)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
+}
+static void entry_vkCmdCopyBufferToImage(
+ VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
+}
+static void entry_vkCmdCopyImageToBuffer(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferImageCopy* pRegions)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
+}
+static void entry_vkCmdUpdateBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize dataSize,
+ const void* pData)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
+}
+static void entry_vkCmdFillBuffer(
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize size,
+ uint32_t data)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
+}
+static void entry_vkCmdClearColorImage(
+ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearColorValue* pColor,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+}
+static void entry_vkCmdClearDepthStencilImage(
+ VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearDepthStencilValue* pDepthStencil,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+}
+static void entry_vkCmdClearAttachments(
+ VkCommandBuffer commandBuffer,
+ uint32_t attachmentCount,
+ const VkClearAttachment* pAttachments,
+ uint32_t rectCount,
+ const VkClearRect* pRects)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
+}
+static void entry_vkCmdResolveImage(
+ VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageResolve* pRegions)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+}
+static void entry_vkCmdSetEvent(
+ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetEvent(commandBuffer, event, stageMask);
+}
+static void entry_vkCmdResetEvent(
+ VkCommandBuffer commandBuffer,
+ VkEvent event,
+ VkPipelineStageFlags stageMask)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdResetEvent(commandBuffer, event, stageMask);
+}
+static void entry_vkCmdWaitEvents(
+ VkCommandBuffer commandBuffer,
+ uint32_t eventCount,
+ const VkEvent* pEvents,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags dstStageMask,
+ uint32_t memoryBarrierCount,
+ const VkMemoryBarrier* pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+}
+static void entry_vkCmdPipelineBarrier(
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags dstStageMask,
+ VkDependencyFlags dependencyFlags,
+ uint32_t memoryBarrierCount,
+ const VkMemoryBarrier* pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier* pImageMemoryBarriers)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+}
+static void entry_vkCmdBeginQuery(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t query,
+ VkQueryControlFlags flags)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdBeginQuery(commandBuffer, queryPool, query, flags);
+}
+static void entry_vkCmdEndQuery(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t query)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdEndQuery(commandBuffer, queryPool, query);
+}
+static void entry_vkCmdResetQueryPool(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
+}
+static void entry_vkCmdWriteTimestamp(
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkQueryPool queryPool,
+ uint32_t query)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
+}
+static void entry_vkCmdCopyQueryPoolResults(
+ VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
+}
+static void entry_vkCmdPushConstants(
+ VkCommandBuffer commandBuffer,
+ VkPipelineLayout layout,
+ VkShaderStageFlags stageFlags,
+ uint32_t offset,
+ uint32_t size,
+ const void* pValues)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
+}
+static void entry_vkCmdBeginRenderPass(
+ VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ VkSubpassContents contents)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
+}
+static void entry_vkCmdNextSubpass(
+ VkCommandBuffer commandBuffer,
+ VkSubpassContents contents)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdNextSubpass(commandBuffer, contents);
+}
+static void entry_vkCmdEndRenderPass(
+ VkCommandBuffer commandBuffer)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdEndRenderPass(commandBuffer);
+}
+static void entry_vkCmdExecuteCommands(
+ VkCommandBuffer commandBuffer,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
+}
+#endif
+#ifdef VK_VERSION_1_1
+static VkResult entry_vkEnumerateInstanceVersion(
+ uint32_t* pApiVersion)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkEnumerateInstanceVersion_VkResult_return = (VkResult)0;
+ vkEnumerateInstanceVersion_VkResult_return = vkEnc->vkEnumerateInstanceVersion(pApiVersion);
+ return vkEnumerateInstanceVersion_VkResult_return;
+}
+static VkResult entry_vkBindBufferMemory2(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
+ vkBindBufferMemory2_VkResult_return = vkEnc->vkBindBufferMemory2(device, bindInfoCount, pBindInfos);
+ return vkBindBufferMemory2_VkResult_return;
+}
+static VkResult entry_vkBindImageMemory2(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
+ vkBindImageMemory2_VkResult_return = vkEnc->vkBindImageMemory2(device, bindInfoCount, pBindInfos);
+ return vkBindImageMemory2_VkResult_return;
+}
+static void entry_vkGetDeviceGroupPeerMemoryFeatures(
+ VkDevice device,
+ uint32_t heapIndex,
+ uint32_t localDeviceIndex,
+ uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
+}
+static void entry_vkCmdSetDeviceMask(
+ VkCommandBuffer commandBuffer,
+ uint32_t deviceMask)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetDeviceMask(commandBuffer, deviceMask);
+}
+static void entry_vkCmdDispatchBase(
+ VkCommandBuffer commandBuffer,
+ uint32_t baseGroupX,
+ uint32_t baseGroupY,
+ uint32_t baseGroupZ,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
+}
+static VkResult entry_vkEnumeratePhysicalDeviceGroups(
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkEnumeratePhysicalDeviceGroups_VkResult_return = (VkResult)0;
+ vkEnumeratePhysicalDeviceGroups_VkResult_return = vkEnc->vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
+ return vkEnumeratePhysicalDeviceGroups_VkResult_return;
+}
+static void entry_vkGetImageMemoryRequirements2(
+ VkDevice device,
+ const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements);
+}
+static void entry_vkGetBufferMemoryRequirements2(
+ VkDevice device,
+ const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements);
+}
+static void entry_vkGetImageSparseMemoryRequirements2(
+ VkDevice device,
+ const VkImageSparseMemoryRequirementsInfo2* pInfo,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+}
+static void entry_vkGetPhysicalDeviceFeatures2(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures2* pFeatures)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures);
+}
+static void entry_vkGetPhysicalDeviceProperties2(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceProperties2(physicalDevice, pProperties);
+}
+static void entry_vkGetPhysicalDeviceFormatProperties2(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties2* pFormatProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties);
+}
+static VkResult entry_vkGetPhysicalDeviceImageFormatProperties2(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+ VkImageFormatProperties2* pImageFormatProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = vkEnc->vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties);
+ return vkGetPhysicalDeviceImageFormatProperties2_VkResult_return;
+}
+static void entry_vkGetPhysicalDeviceQueueFamilyProperties2(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties2* pQueueFamilyProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+}
+static void entry_vkGetPhysicalDeviceMemoryProperties2(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties);
+}
+static void entry_vkGetPhysicalDeviceSparseImageFormatProperties2(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties2* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
+}
+static void entry_vkTrimCommandPool(
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolTrimFlags flags)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkTrimCommandPool(device, commandPool, flags);
+}
+static void entry_vkGetDeviceQueue2(
+ VkDevice device,
+ const VkDeviceQueueInfo2* pQueueInfo,
+ VkQueue* pQueue)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetDeviceQueue2(device, pQueueInfo, pQueue);
+}
+static VkResult entry_vkCreateSamplerYcbcrConversion(
+ VkDevice device,
+ const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
+ vkCreateSamplerYcbcrConversion_VkResult_return = vkEnc->vkCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion);
+ return vkCreateSamplerYcbcrConversion_VkResult_return;
+}
+static void entry_vkDestroySamplerYcbcrConversion(
+ VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator);
+}
+static VkResult entry_vkCreateDescriptorUpdateTemplate(
+ VkDevice device,
+ const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
+ vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+ return vkCreateDescriptorUpdateTemplate_VkResult_return;
+}
+static void entry_vkDestroyDescriptorUpdateTemplate(
+ VkDevice device,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
+}
+static void entry_vkUpdateDescriptorSetWithTemplate(
+ VkDevice device,
+ VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const void* pData)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkUpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData);
+}
+static void entry_vkGetPhysicalDeviceExternalBufferProperties(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+ VkExternalBufferProperties* pExternalBufferProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+}
+static void entry_vkGetPhysicalDeviceExternalFenceProperties(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+ VkExternalFenceProperties* pExternalFenceProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+}
+static void entry_vkGetPhysicalDeviceExternalSemaphoreProperties(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+ VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
+}
+static void entry_vkGetDescriptorSetLayoutSupport(
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ VkDescriptorSetLayoutSupport* pSupport)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
+}
+#endif
+#ifdef VK_KHR_surface
+static void entry_vkDestroySurfaceKHR(
+ VkInstance instance,
+ VkSurfaceKHR surface,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroySurfaceKHR(instance, surface, pAllocator);
+}
+static VkResult entry_vkGetPhysicalDeviceSurfaceSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ VkSurfaceKHR surface,
+ VkBool32* pSupported)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
+ return vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return;
+}
+static VkResult entry_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
+ return vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return;
+}
+static VkResult entry_vkGetPhysicalDeviceSurfaceFormatsKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormatKHR* pSurfaceFormats)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
+ return vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return;
+}
+static VkResult entry_vkGetPhysicalDeviceSurfacePresentModesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pPresentModeCount,
+ VkPresentModeKHR* pPresentModes)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
+ return vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_swapchain
+static VkResult entry_vkCreateSwapchainKHR(
+ VkDevice device,
+ const VkSwapchainCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchain)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
+ vkCreateSwapchainKHR_VkResult_return = vkEnc->vkCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
+ return vkCreateSwapchainKHR_VkResult_return;
+}
+static void entry_vkDestroySwapchainKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroySwapchainKHR(device, swapchain, pAllocator);
+}
+static VkResult entry_vkGetSwapchainImagesKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t* pSwapchainImageCount,
+ VkImage* pSwapchainImages)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0;
+ vkGetSwapchainImagesKHR_VkResult_return = vkEnc->vkGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
+ return vkGetSwapchainImagesKHR_VkResult_return;
+}
+static VkResult entry_vkAcquireNextImageKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint64_t timeout,
+ VkSemaphore semaphore,
+ VkFence fence,
+ uint32_t* pImageIndex)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkAcquireNextImageKHR_VkResult_return = (VkResult)0;
+ vkAcquireNextImageKHR_VkResult_return = vkEnc->vkAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
+ return vkAcquireNextImageKHR_VkResult_return;
+}
+static VkResult entry_vkQueuePresentKHR(
+ VkQueue queue,
+ const VkPresentInfoKHR* pPresentInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkQueuePresentKHR_VkResult_return = (VkResult)0;
+ vkQueuePresentKHR_VkResult_return = vkEnc->vkQueuePresentKHR(queue, pPresentInfo);
+ return vkQueuePresentKHR_VkResult_return;
+}
+static VkResult entry_vkGetDeviceGroupPresentCapabilitiesKHR(
+ VkDevice device,
+ VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = (VkResult)0;
+ vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = vkEnc->vkGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities);
+ return vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return;
+}
+static VkResult entry_vkGetDeviceGroupSurfacePresentModesKHR(
+ VkDevice device,
+ VkSurfaceKHR surface,
+ VkDeviceGroupPresentModeFlagsKHR* pModes)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = (VkResult)0;
+ vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = vkEnc->vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
+ return vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return;
+}
+static VkResult entry_vkGetPhysicalDevicePresentRectanglesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pRectCount,
+ VkRect2D* pRects)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = vkEnc->vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects);
+ return vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return;
+}
+static VkResult entry_vkAcquireNextImage2KHR(
+ VkDevice device,
+ const VkAcquireNextImageInfoKHR* pAcquireInfo,
+ uint32_t* pImageIndex)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkAcquireNextImage2KHR_VkResult_return = (VkResult)0;
+ vkAcquireNextImage2KHR_VkResult_return = vkEnc->vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex);
+ return vkAcquireNextImage2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_display
+static VkResult entry_vkGetPhysicalDeviceDisplayPropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPropertiesKHR* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties);
+ return vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return;
+}
+static VkResult entry_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPlanePropertiesKHR* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties);
+ return vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return;
+}
+static VkResult entry_vkGetDisplayPlaneSupportedDisplaysKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t planeIndex,
+ uint32_t* pDisplayCount,
+ VkDisplayKHR* pDisplays)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = (VkResult)0;
+ vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = vkEnc->vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays);
+ return vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return;
+}
+static VkResult entry_vkGetDisplayModePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ uint32_t* pPropertyCount,
+ VkDisplayModePropertiesKHR* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetDisplayModePropertiesKHR_VkResult_return = (VkResult)0;
+ vkGetDisplayModePropertiesKHR_VkResult_return = vkEnc->vkGetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties);
+ return vkGetDisplayModePropertiesKHR_VkResult_return;
+}
+static VkResult entry_vkCreateDisplayModeKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ const VkDisplayModeCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDisplayModeKHR* pMode)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateDisplayModeKHR_VkResult_return = (VkResult)0;
+ vkCreateDisplayModeKHR_VkResult_return = vkEnc->vkCreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode);
+ return vkCreateDisplayModeKHR_VkResult_return;
+}
+static VkResult entry_vkGetDisplayPlaneCapabilitiesKHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayModeKHR mode,
+ uint32_t planeIndex,
+ VkDisplayPlaneCapabilitiesKHR* pCapabilities)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = (VkResult)0;
+ vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = vkEnc->vkGetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities);
+ return vkGetDisplayPlaneCapabilitiesKHR_VkResult_return;
+}
+static VkResult entry_vkCreateDisplayPlaneSurfaceKHR(
+ VkInstance instance,
+ const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateDisplayPlaneSurfaceKHR_VkResult_return = (VkResult)0;
+ vkCreateDisplayPlaneSurfaceKHR_VkResult_return = vkEnc->vkCreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+ return vkCreateDisplayPlaneSurfaceKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_display_swapchain
+static VkResult entry_vkCreateSharedSwapchainsKHR(
+ VkDevice device,
+ uint32_t swapchainCount,
+ const VkSwapchainCreateInfoKHR* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchains)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateSharedSwapchainsKHR_VkResult_return = (VkResult)0;
+ vkCreateSharedSwapchainsKHR_VkResult_return = vkEnc->vkCreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
+ return vkCreateSharedSwapchainsKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_xlib_surface
+static VkResult entry_vkCreateXlibSurfaceKHR(
+ VkInstance instance,
+ const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateXlibSurfaceKHR_VkResult_return = (VkResult)0;
+ vkCreateXlibSurfaceKHR_VkResult_return = vkEnc->vkCreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+ return vkCreateXlibSurfaceKHR_VkResult_return;
+}
+static VkBool32 entry_vkGetPhysicalDeviceXlibPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ Display* dpy,
+ VisualID visualID)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID);
+ return vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_xcb_surface
+static VkResult entry_vkCreateXcbSurfaceKHR(
+ VkInstance instance,
+ const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateXcbSurfaceKHR_VkResult_return = (VkResult)0;
+ vkCreateXcbSurfaceKHR_VkResult_return = vkEnc->vkCreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+ return vkCreateXcbSurfaceKHR_VkResult_return;
+}
+static VkBool32 entry_vkGetPhysicalDeviceXcbPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ xcb_connection_t* connection,
+ xcb_visualid_t visual_id)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id);
+ return vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_wayland_surface
+static VkResult entry_vkCreateWaylandSurfaceKHR(
+ VkInstance instance,
+ const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateWaylandSurfaceKHR_VkResult_return = (VkResult)0;
+ vkCreateWaylandSurfaceKHR_VkResult_return = vkEnc->vkCreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+ return vkCreateWaylandSurfaceKHR_VkResult_return;
+}
+static VkBool32 entry_vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ wl_display* display)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display);
+ return vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_mir_surface
+static VkResult entry_vkCreateMirSurfaceKHR(
+ VkInstance instance,
+ const VkMirSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateMirSurfaceKHR_VkResult_return = (VkResult)0;
+ vkCreateMirSurfaceKHR_VkResult_return = vkEnc->vkCreateMirSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+ return vkCreateMirSurfaceKHR_VkResult_return;
+}
+static VkBool32 entry_vkGetPhysicalDeviceMirPresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ MirConnection* connection)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceMirPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection);
+ return vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_android_surface
+static VkResult entry_vkCreateAndroidSurfaceKHR(
+ VkInstance instance,
+ const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateAndroidSurfaceKHR_VkResult_return = (VkResult)0;
+ vkCreateAndroidSurfaceKHR_VkResult_return = vkEnc->vkCreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+ return vkCreateAndroidSurfaceKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_win32_surface
+static VkResult entry_vkCreateWin32SurfaceKHR(
+ VkInstance instance,
+ const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateWin32SurfaceKHR_VkResult_return = (VkResult)0;
+ vkCreateWin32SurfaceKHR_VkResult_return = vkEnc->vkCreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+ return vkCreateWin32SurfaceKHR_VkResult_return;
+}
+static VkBool32 entry_vkGetPhysicalDeviceWin32PresentationSupportKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return = (VkBool32)0;
+ vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex);
+ return vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return;
+}
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+static void entry_vkGetPhysicalDeviceFeatures2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures2* pFeatures)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures);
+}
+static void entry_vkGetPhysicalDeviceProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceProperties2KHR(physicalDevice, pProperties);
+}
+static void entry_vkGetPhysicalDeviceFormatProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties2* pFormatProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties);
+}
+static VkResult entry_vkGetPhysicalDeviceImageFormatProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+ VkImageFormatProperties2* pImageFormatProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = vkEnc->vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties);
+ return vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return;
+}
+static void entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties2* pQueueFamilyProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+}
+static void entry_vkGetPhysicalDeviceMemoryProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties);
+}
+static void entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+ uint32_t* pPropertyCount,
+ VkSparseImageFormatProperties2* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
+}
+#endif
+#ifdef VK_KHR_device_group
+static void entry_vkGetDeviceGroupPeerMemoryFeaturesKHR(
+ VkDevice device,
+ uint32_t heapIndex,
+ uint32_t localDeviceIndex,
+ uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
+}
+static void entry_vkCmdSetDeviceMaskKHR(
+ VkCommandBuffer commandBuffer,
+ uint32_t deviceMask)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetDeviceMaskKHR(commandBuffer, deviceMask);
+}
+static void entry_vkCmdDispatchBaseKHR(
+ VkCommandBuffer commandBuffer,
+ uint32_t baseGroupX,
+ uint32_t baseGroupY,
+ uint32_t baseGroupZ,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
+}
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+static void entry_vkTrimCommandPoolKHR(
+ VkDevice device,
+ VkCommandPool commandPool,
+ VkCommandPoolTrimFlags flags)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkTrimCommandPoolKHR(device, commandPool, flags);
+}
+#endif
+#ifdef VK_KHR_device_group_creation
+static VkResult entry_vkEnumeratePhysicalDeviceGroupsKHR(
+ VkInstance instance,
+ uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return = (VkResult)0;
+ vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return = vkEnc->vkEnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
+ return vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+static void entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+ VkExternalBufferProperties* pExternalBufferProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+}
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+static VkResult entry_vkGetMemoryWin32HandleKHR(
+ VkDevice device,
+ const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetMemoryWin32HandleKHR_VkResult_return = (VkResult)0;
+ vkGetMemoryWin32HandleKHR_VkResult_return = vkEnc->vkGetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
+ return vkGetMemoryWin32HandleKHR_VkResult_return;
+}
+static VkResult entry_vkGetMemoryWin32HandlePropertiesKHR(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ HANDLE handle,
+ VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = (VkResult)0;
+ vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = vkEnc->vkGetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties);
+ return vkGetMemoryWin32HandlePropertiesKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_memory_fd
+static VkResult entry_vkGetMemoryFdKHR(
+ VkDevice device,
+ const VkMemoryGetFdInfoKHR* pGetFdInfo,
+ int* pFd)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetMemoryFdKHR_VkResult_return = (VkResult)0;
+ vkGetMemoryFdKHR_VkResult_return = vkEnc->vkGetMemoryFdKHR(device, pGetFdInfo, pFd);
+ return vkGetMemoryFdKHR_VkResult_return;
+}
+static VkResult entry_vkGetMemoryFdPropertiesKHR(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ int fd,
+ VkMemoryFdPropertiesKHR* pMemoryFdProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetMemoryFdPropertiesKHR_VkResult_return = (VkResult)0;
+ vkGetMemoryFdPropertiesKHR_VkResult_return = vkEnc->vkGetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties);
+ return vkGetMemoryFdPropertiesKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+static void entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+ VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
+}
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+static VkResult entry_vkImportSemaphoreWin32HandleKHR(
+ VkDevice device,
+ const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkImportSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
+ vkImportSemaphoreWin32HandleKHR_VkResult_return = vkEnc->vkImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo);
+ return vkImportSemaphoreWin32HandleKHR_VkResult_return;
+}
+static VkResult entry_vkGetSemaphoreWin32HandleKHR(
+ VkDevice device,
+ const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
+ vkGetSemaphoreWin32HandleKHR_VkResult_return = vkEnc->vkGetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
+ return vkGetSemaphoreWin32HandleKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+static VkResult entry_vkImportSemaphoreFdKHR(
+ VkDevice device,
+ const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
+ vkImportSemaphoreFdKHR_VkResult_return = vkEnc->vkImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo);
+ return vkImportSemaphoreFdKHR_VkResult_return;
+}
+static VkResult entry_vkGetSemaphoreFdKHR(
+ VkDevice device,
+ const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
+ int* pFd)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
+ vkGetSemaphoreFdKHR_VkResult_return = vkEnc->vkGetSemaphoreFdKHR(device, pGetFdInfo, pFd);
+ return vkGetSemaphoreFdKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_push_descriptor
+static void entry_vkCmdPushDescriptorSetKHR(
+ VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t set,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
+}
+static void entry_vkCmdPushDescriptorSetWithTemplateKHR(
+ VkCommandBuffer commandBuffer,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ VkPipelineLayout layout,
+ uint32_t set,
+ const void* pData)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData);
+}
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+#endif
+#ifdef VK_KHR_descriptor_update_template
+static VkResult entry_vkCreateDescriptorUpdateTemplateKHR(
+ VkDevice device,
+ const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
+ vkCreateDescriptorUpdateTemplateKHR_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+ return vkCreateDescriptorUpdateTemplateKHR_VkResult_return;
+}
+static void entry_vkDestroyDescriptorUpdateTemplateKHR(
+ VkDevice device,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator);
+}
+static void entry_vkUpdateDescriptorSetWithTemplateKHR(
+ VkDevice device,
+ VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const void* pData)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData);
+}
+#endif
+#ifdef VK_KHR_create_renderpass2
+static VkResult entry_vkCreateRenderPass2KHR(
+ VkDevice device,
+ const VkRenderPassCreateInfo2KHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
+ vkCreateRenderPass2KHR_VkResult_return = vkEnc->vkCreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass);
+ return vkCreateRenderPass2KHR_VkResult_return;
+}
+static void entry_vkCmdBeginRenderPass2KHR(
+ VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ const VkSubpassBeginInfoKHR* pSubpassBeginInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
+}
+static void entry_vkCmdNextSubpass2KHR(
+ VkCommandBuffer commandBuffer,
+ const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
+ const VkSubpassEndInfoKHR* pSubpassEndInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
+}
+static void entry_vkCmdEndRenderPass2KHR(
+ VkCommandBuffer commandBuffer,
+ const VkSubpassEndInfoKHR* pSubpassEndInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo);
+}
+#endif
+#ifdef VK_KHR_shared_presentable_image
+static VkResult entry_vkGetSwapchainStatusKHR(
+ VkDevice device,
+ VkSwapchainKHR swapchain)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetSwapchainStatusKHR_VkResult_return = (VkResult)0;
+ vkGetSwapchainStatusKHR_VkResult_return = vkEnc->vkGetSwapchainStatusKHR(device, swapchain);
+ return vkGetSwapchainStatusKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+static void entry_vkGetPhysicalDeviceExternalFencePropertiesKHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+ VkExternalFenceProperties* pExternalFenceProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+}
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+static VkResult entry_vkImportFenceWin32HandleKHR(
+ VkDevice device,
+ const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkImportFenceWin32HandleKHR_VkResult_return = (VkResult)0;
+ vkImportFenceWin32HandleKHR_VkResult_return = vkEnc->vkImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo);
+ return vkImportFenceWin32HandleKHR_VkResult_return;
+}
+static VkResult entry_vkGetFenceWin32HandleKHR(
+ VkDevice device,
+ const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetFenceWin32HandleKHR_VkResult_return = (VkResult)0;
+ vkGetFenceWin32HandleKHR_VkResult_return = vkEnc->vkGetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
+ return vkGetFenceWin32HandleKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_external_fence_fd
+static VkResult entry_vkImportFenceFdKHR(
+ VkDevice device,
+ const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0;
+ vkImportFenceFdKHR_VkResult_return = vkEnc->vkImportFenceFdKHR(device, pImportFenceFdInfo);
+ return vkImportFenceFdKHR_VkResult_return;
+}
+static VkResult entry_vkGetFenceFdKHR(
+ VkDevice device,
+ const VkFenceGetFdInfoKHR* pGetFdInfo,
+ int* pFd)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetFenceFdKHR_VkResult_return = (VkResult)0;
+ vkGetFenceFdKHR_VkResult_return = vkEnc->vkGetFenceFdKHR(device, pGetFdInfo, pFd);
+ return vkGetFenceFdKHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+static VkResult entry_vkGetPhysicalDeviceSurfaceCapabilities2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ VkSurfaceCapabilities2KHR* pSurfaceCapabilities)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
+ return vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return;
+}
+static VkResult entry_vkGetPhysicalDeviceSurfaceFormats2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormat2KHR* pSurfaceFormats)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
+ return vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+static VkResult entry_vkGetPhysicalDeviceDisplayProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayProperties2KHR* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties);
+ return vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return;
+}
+static VkResult entry_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPlaneProperties2KHR* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, pPropertyCount, pProperties);
+ return vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return;
+}
+static VkResult entry_vkGetDisplayModeProperties2KHR(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ uint32_t* pPropertyCount,
+ VkDisplayModeProperties2KHR* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetDisplayModeProperties2KHR_VkResult_return = (VkResult)0;
+ vkGetDisplayModeProperties2KHR_VkResult_return = vkEnc->vkGetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties);
+ return vkGetDisplayModeProperties2KHR_VkResult_return;
+}
+static VkResult entry_vkGetDisplayPlaneCapabilities2KHR(
+ VkPhysicalDevice physicalDevice,
+ const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
+ VkDisplayPlaneCapabilities2KHR* pCapabilities)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetDisplayPlaneCapabilities2KHR_VkResult_return = (VkResult)0;
+ vkGetDisplayPlaneCapabilities2KHR_VkResult_return = vkEnc->vkGetDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities);
+ return vkGetDisplayPlaneCapabilities2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+static void entry_vkGetImageMemoryRequirements2KHR(
+ VkDevice device,
+ const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
+}
+static void entry_vkGetBufferMemoryRequirements2KHR(
+ VkDevice device,
+ const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
+}
+static void entry_vkGetImageSparseMemoryRequirements2KHR(
+ VkDevice device,
+ const VkImageSparseMemoryRequirementsInfo2* pInfo,
+ uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+}
+#endif
+#ifdef VK_KHR_image_format_list
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+static VkResult entry_vkCreateSamplerYcbcrConversionKHR(
+ VkDevice device,
+ const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
+ vkCreateSamplerYcbcrConversionKHR_VkResult_return = vkEnc->vkCreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, pYcbcrConversion);
+ return vkCreateSamplerYcbcrConversionKHR_VkResult_return;
+}
+static void entry_vkDestroySamplerYcbcrConversionKHR(
+ VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator);
+}
+#endif
+#ifdef VK_KHR_bind_memory2
+static VkResult entry_vkBindBufferMemory2KHR(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
+ vkBindBufferMemory2KHR_VkResult_return = vkEnc->vkBindBufferMemory2KHR(device, bindInfoCount, pBindInfos);
+ return vkBindBufferMemory2KHR_VkResult_return;
+}
+static VkResult entry_vkBindImageMemory2KHR(
+ VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
+ vkBindImageMemory2KHR_VkResult_return = vkEnc->vkBindImageMemory2KHR(device, bindInfoCount, pBindInfos);
+ return vkBindImageMemory2KHR_VkResult_return;
+}
+#endif
+#ifdef VK_KHR_maintenance3
+static void entry_vkGetDescriptorSetLayoutSupportKHR(
+ VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ VkDescriptorSetLayoutSupport* pSupport)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport);
+}
+#endif
+#ifdef VK_KHR_draw_indirect_count
+static void entry_vkCmdDrawIndirectCountKHR(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+}
+static void entry_vkCmdDrawIndexedIndirectCountKHR(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+}
+#endif
+#ifdef VK_KHR_8bit_storage
+#endif
+#ifdef VK_EXT_debug_report
+static VkResult entry_vkCreateDebugReportCallbackEXT(
+ VkInstance instance,
+ const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDebugReportCallbackEXT* pCallback)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateDebugReportCallbackEXT_VkResult_return = (VkResult)0;
+ vkCreateDebugReportCallbackEXT_VkResult_return = vkEnc->vkCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);
+ return vkCreateDebugReportCallbackEXT_VkResult_return;
+}
+static void entry_vkDestroyDebugReportCallbackEXT(
+ VkInstance instance,
+ VkDebugReportCallbackEXT callback,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyDebugReportCallbackEXT(instance, callback, pAllocator);
+}
+static void entry_vkDebugReportMessageEXT(
+ VkInstance instance,
+ VkDebugReportFlagsEXT flags,
+ VkDebugReportObjectTypeEXT objectType,
+ uint64_t object,
+ size_t location,
+ int32_t messageCode,
+ const char* pLayerPrefix,
+ const char* pMessage)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDebugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
+}
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+static VkResult entry_vkDebugMarkerSetObjectTagEXT(
+ VkDevice device,
+ const VkDebugMarkerObjectTagInfoEXT* pTagInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkDebugMarkerSetObjectTagEXT_VkResult_return = (VkResult)0;
+ vkDebugMarkerSetObjectTagEXT_VkResult_return = vkEnc->vkDebugMarkerSetObjectTagEXT(device, pTagInfo);
+ return vkDebugMarkerSetObjectTagEXT_VkResult_return;
+}
+static VkResult entry_vkDebugMarkerSetObjectNameEXT(
+ VkDevice device,
+ const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkDebugMarkerSetObjectNameEXT_VkResult_return = (VkResult)0;
+ vkDebugMarkerSetObjectNameEXT_VkResult_return = vkEnc->vkDebugMarkerSetObjectNameEXT(device, pNameInfo);
+ return vkDebugMarkerSetObjectNameEXT_VkResult_return;
+}
+static void entry_vkCmdDebugMarkerBeginEXT(
+ VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo);
+}
+static void entry_vkCmdDebugMarkerEndEXT(
+ VkCommandBuffer commandBuffer)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDebugMarkerEndEXT(commandBuffer);
+}
+static void entry_vkCmdDebugMarkerInsertEXT(
+ VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo);
+}
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+#endif
+#ifdef VK_AMD_draw_indirect_count
+static void entry_vkCmdDrawIndirectCountAMD(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+}
+static void entry_vkCmdDrawIndexedIndirectCountAMD(
+ VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+}
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+#endif
+#ifdef VK_AMD_shader_info
+static VkResult entry_vkGetShaderInfoAMD(
+ VkDevice device,
+ VkPipeline pipeline,
+ VkShaderStageFlagBits shaderStage,
+ VkShaderInfoTypeAMD infoType,
+ size_t* pInfoSize,
+ void* pInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetShaderInfoAMD_VkResult_return = (VkResult)0;
+ vkGetShaderInfoAMD_VkResult_return = vkEnc->vkGetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
+ return vkGetShaderInfoAMD_VkResult_return;
+}
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+static VkResult entry_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+ VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkImageTiling tiling,
+ VkImageUsageFlags usage,
+ VkImageCreateFlags flags,
+ VkExternalMemoryHandleTypeFlagsNV externalHandleType,
+ VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return = vkEnc->vkGetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties);
+ return vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return;
+}
+#endif
+#ifdef VK_NV_external_memory
+#endif
+#ifdef VK_NV_external_memory_win32
+static VkResult entry_vkGetMemoryWin32HandleNV(
+ VkDevice device,
+ VkDeviceMemory memory,
+ VkExternalMemoryHandleTypeFlagsNV handleType,
+ HANDLE* pHandle)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetMemoryWin32HandleNV_VkResult_return = (VkResult)0;
+ vkGetMemoryWin32HandleNV_VkResult_return = vkEnc->vkGetMemoryWin32HandleNV(device, memory, handleType, pHandle);
+ return vkGetMemoryWin32HandleNV_VkResult_return;
+}
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+#endif
+#ifdef VK_EXT_validation_flags
+#endif
+#ifdef VK_NN_vi_surface
+static VkResult entry_vkCreateViSurfaceNN(
+ VkInstance instance,
+ const VkViSurfaceCreateInfoNN* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateViSurfaceNN_VkResult_return = (VkResult)0;
+ vkCreateViSurfaceNN_VkResult_return = vkEnc->vkCreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface);
+ return vkCreateViSurfaceNN_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+static void entry_vkCmdBeginConditionalRenderingEXT(
+ VkCommandBuffer commandBuffer,
+ const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin);
+}
+static void entry_vkCmdEndConditionalRenderingEXT(
+ VkCommandBuffer commandBuffer)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdEndConditionalRenderingEXT(commandBuffer);
+}
+#endif
+#ifdef VK_NVX_device_generated_commands
+static void entry_vkCmdProcessCommandsNVX(
+ VkCommandBuffer commandBuffer,
+ const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo);
+}
+static void entry_vkCmdReserveSpaceForCommandsNVX(
+ VkCommandBuffer commandBuffer,
+ const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo);
+}
+static VkResult entry_vkCreateIndirectCommandsLayoutNVX(
+ VkDevice device,
+ const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateIndirectCommandsLayoutNVX_VkResult_return = (VkResult)0;
+ vkCreateIndirectCommandsLayoutNVX_VkResult_return = vkEnc->vkCreateIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
+ return vkCreateIndirectCommandsLayoutNVX_VkResult_return;
+}
+static void entry_vkDestroyIndirectCommandsLayoutNVX(
+ VkDevice device,
+ VkIndirectCommandsLayoutNVX indirectCommandsLayout,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator);
+}
+static VkResult entry_vkCreateObjectTableNVX(
+ VkDevice device,
+ const VkObjectTableCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkObjectTableNVX* pObjectTable)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateObjectTableNVX_VkResult_return = (VkResult)0;
+ vkCreateObjectTableNVX_VkResult_return = vkEnc->vkCreateObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable);
+ return vkCreateObjectTableNVX_VkResult_return;
+}
+static void entry_vkDestroyObjectTableNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyObjectTableNVX(device, objectTable, pAllocator);
+}
+static VkResult entry_vkRegisterObjectsNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ uint32_t objectCount,
+ const VkObjectTableEntryNVX* const* ppObjectTableEntries,
+ const uint32_t* pObjectIndices)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkRegisterObjectsNVX_VkResult_return = (VkResult)0;
+ vkRegisterObjectsNVX_VkResult_return = vkEnc->vkRegisterObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices);
+ return vkRegisterObjectsNVX_VkResult_return;
+}
+static VkResult entry_vkUnregisterObjectsNVX(
+ VkDevice device,
+ VkObjectTableNVX objectTable,
+ uint32_t objectCount,
+ const VkObjectEntryTypeNVX* pObjectEntryTypes,
+ const uint32_t* pObjectIndices)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkUnregisterObjectsNVX_VkResult_return = (VkResult)0;
+ vkUnregisterObjectsNVX_VkResult_return = vkEnc->vkUnregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices);
+ return vkUnregisterObjectsNVX_VkResult_return;
+}
+static void entry_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+ VkPhysicalDevice physicalDevice,
+ VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
+ VkDeviceGeneratedCommandsLimitsNVX* pLimits)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(physicalDevice, pFeatures, pLimits);
+}
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+static void entry_vkCmdSetViewportWScalingNV(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkViewportWScalingNV* pViewportWScalings)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings);
+}
+#endif
+#ifdef VK_EXT_direct_mode_display
+static VkResult entry_vkReleaseDisplayEXT(
+ VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkReleaseDisplayEXT_VkResult_return = (VkResult)0;
+ vkReleaseDisplayEXT_VkResult_return = vkEnc->vkReleaseDisplayEXT(physicalDevice, display);
+ return vkReleaseDisplayEXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+static VkResult entry_vkAcquireXlibDisplayEXT(
+ VkPhysicalDevice physicalDevice,
+ Display* dpy,
+ VkDisplayKHR display)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkAcquireXlibDisplayEXT_VkResult_return = (VkResult)0;
+ vkAcquireXlibDisplayEXT_VkResult_return = vkEnc->vkAcquireXlibDisplayEXT(physicalDevice, dpy, display);
+ return vkAcquireXlibDisplayEXT_VkResult_return;
+}
+static VkResult entry_vkGetRandROutputDisplayEXT(
+ VkPhysicalDevice physicalDevice,
+ Display* dpy,
+ RROutput rrOutput,
+ VkDisplayKHR* pDisplay)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetRandROutputDisplayEXT_VkResult_return = (VkResult)0;
+ vkGetRandROutputDisplayEXT_VkResult_return = vkEnc->vkGetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay);
+ return vkGetRandROutputDisplayEXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_display_surface_counter
+static VkResult entry_vkGetPhysicalDeviceSurfaceCapabilities2EXT(
+ VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilities2EXT* pSurfaceCapabilities)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return = (VkResult)0;
+ vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities);
+ return vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_display_control
+static VkResult entry_vkDisplayPowerControlEXT(
+ VkDevice device,
+ VkDisplayKHR display,
+ const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkDisplayPowerControlEXT_VkResult_return = (VkResult)0;
+ vkDisplayPowerControlEXT_VkResult_return = vkEnc->vkDisplayPowerControlEXT(device, display, pDisplayPowerInfo);
+ return vkDisplayPowerControlEXT_VkResult_return;
+}
+static VkResult entry_vkRegisterDeviceEventEXT(
+ VkDevice device,
+ const VkDeviceEventInfoEXT* pDeviceEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkRegisterDeviceEventEXT_VkResult_return = (VkResult)0;
+ vkRegisterDeviceEventEXT_VkResult_return = vkEnc->vkRegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence);
+ return vkRegisterDeviceEventEXT_VkResult_return;
+}
+static VkResult entry_vkRegisterDisplayEventEXT(
+ VkDevice device,
+ VkDisplayKHR display,
+ const VkDisplayEventInfoEXT* pDisplayEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkRegisterDisplayEventEXT_VkResult_return = (VkResult)0;
+ vkRegisterDisplayEventEXT_VkResult_return = vkEnc->vkRegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence);
+ return vkRegisterDisplayEventEXT_VkResult_return;
+}
+static VkResult entry_vkGetSwapchainCounterEXT(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkSurfaceCounterFlagBitsEXT counter,
+ uint64_t* pCounterValue)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetSwapchainCounterEXT_VkResult_return = (VkResult)0;
+ vkGetSwapchainCounterEXT_VkResult_return = vkEnc->vkGetSwapchainCounterEXT(device, swapchain, counter, pCounterValue);
+ return vkGetSwapchainCounterEXT_VkResult_return;
+}
+#endif
+#ifdef VK_GOOGLE_display_timing
+static VkResult entry_vkGetRefreshCycleDurationGOOGLE(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetRefreshCycleDurationGOOGLE_VkResult_return = (VkResult)0;
+ vkGetRefreshCycleDurationGOOGLE_VkResult_return = vkEnc->vkGetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties);
+ return vkGetRefreshCycleDurationGOOGLE_VkResult_return;
+}
+static VkResult entry_vkGetPastPresentationTimingGOOGLE(
+ VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t* pPresentationTimingCount,
+ VkPastPresentationTimingGOOGLE* pPresentationTimings)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetPastPresentationTimingGOOGLE_VkResult_return = (VkResult)0;
+ vkGetPastPresentationTimingGOOGLE_VkResult_return = vkEnc->vkGetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings);
+ return vkGetPastPresentationTimingGOOGLE_VkResult_return;
+}
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+#endif
+#ifdef VK_NV_viewport_swizzle
+#endif
+#ifdef VK_EXT_discard_rectangles
+static void entry_vkCmdSetDiscardRectangleEXT(
+ VkCommandBuffer commandBuffer,
+ uint32_t firstDiscardRectangle,
+ uint32_t discardRectangleCount,
+ const VkRect2D* pDiscardRectangles)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
+}
+#endif
+#ifdef VK_EXT_conservative_rasterization
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+static void entry_vkSetHdrMetadataEXT(
+ VkDevice device,
+ uint32_t swapchainCount,
+ const VkSwapchainKHR* pSwapchains,
+ const VkHdrMetadataEXT* pMetadata)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkSetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata);
+}
+#endif
+#ifdef VK_MVK_ios_surface
+static VkResult entry_vkCreateIOSSurfaceMVK(
+ VkInstance instance,
+ const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateIOSSurfaceMVK_VkResult_return = (VkResult)0;
+ vkCreateIOSSurfaceMVK_VkResult_return = vkEnc->vkCreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
+ return vkCreateIOSSurfaceMVK_VkResult_return;
+}
+#endif
+#ifdef VK_MVK_macos_surface
+static VkResult entry_vkCreateMacOSSurfaceMVK(
+ VkInstance instance,
+ const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateMacOSSurfaceMVK_VkResult_return = (VkResult)0;
+ vkCreateMacOSSurfaceMVK_VkResult_return = vkEnc->vkCreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
+ return vkCreateMacOSSurfaceMVK_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+static VkResult entry_vkSetDebugUtilsObjectNameEXT(
+ VkDevice device,
+ const VkDebugUtilsObjectNameInfoEXT* pNameInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkSetDebugUtilsObjectNameEXT_VkResult_return = (VkResult)0;
+ vkSetDebugUtilsObjectNameEXT_VkResult_return = vkEnc->vkSetDebugUtilsObjectNameEXT(device, pNameInfo);
+ return vkSetDebugUtilsObjectNameEXT_VkResult_return;
+}
+static VkResult entry_vkSetDebugUtilsObjectTagEXT(
+ VkDevice device,
+ const VkDebugUtilsObjectTagInfoEXT* pTagInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkSetDebugUtilsObjectTagEXT_VkResult_return = (VkResult)0;
+ vkSetDebugUtilsObjectTagEXT_VkResult_return = vkEnc->vkSetDebugUtilsObjectTagEXT(device, pTagInfo);
+ return vkSetDebugUtilsObjectTagEXT_VkResult_return;
+}
+static void entry_vkQueueBeginDebugUtilsLabelEXT(
+ VkQueue queue,
+ const VkDebugUtilsLabelEXT* pLabelInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkQueueBeginDebugUtilsLabelEXT(queue, pLabelInfo);
+}
+static void entry_vkQueueEndDebugUtilsLabelEXT(
+ VkQueue queue)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkQueueEndDebugUtilsLabelEXT(queue);
+}
+static void entry_vkQueueInsertDebugUtilsLabelEXT(
+ VkQueue queue,
+ const VkDebugUtilsLabelEXT* pLabelInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkQueueInsertDebugUtilsLabelEXT(queue, pLabelInfo);
+}
+static void entry_vkCmdBeginDebugUtilsLabelEXT(
+ VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
+}
+static void entry_vkCmdEndDebugUtilsLabelEXT(
+ VkCommandBuffer commandBuffer)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdEndDebugUtilsLabelEXT(commandBuffer);
+}
+static void entry_vkCmdInsertDebugUtilsLabelEXT(
+ VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
+}
+static VkResult entry_vkCreateDebugUtilsMessengerEXT(
+ VkInstance instance,
+ const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDebugUtilsMessengerEXT* pMessenger)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateDebugUtilsMessengerEXT_VkResult_return = (VkResult)0;
+ vkCreateDebugUtilsMessengerEXT_VkResult_return = vkEnc->vkCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger);
+ return vkCreateDebugUtilsMessengerEXT_VkResult_return;
+}
+static void entry_vkDestroyDebugUtilsMessengerEXT(
+ VkInstance instance,
+ VkDebugUtilsMessengerEXT messenger,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator);
+}
+static void entry_vkSubmitDebugUtilsMessageEXT(
+ VkInstance instance,
+ VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+ VkDebugUtilsMessageTypeFlagsEXT messageTypes,
+ const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkSubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData);
+}
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+static VkResult entry_vkGetAndroidHardwareBufferPropertiesANDROID(
+ VkDevice device,
+ const AHardwareBuffer* buffer,
+ VkAndroidHardwareBufferPropertiesANDROID* pProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = (VkResult)0;
+ vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = vkEnc->vkGetAndroidHardwareBufferPropertiesANDROID(device, buffer, pProperties);
+ return vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return;
+}
+static VkResult entry_vkGetMemoryAndroidHardwareBufferANDROID(
+ VkDevice device,
+ const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
+ AHardwareBuffer** pBuffer)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = (VkResult)0;
+ vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = vkEnc->vkGetMemoryAndroidHardwareBufferANDROID(device, pInfo, pBuffer);
+ return vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+static void entry_vkCmdSetSampleLocationsEXT(
+ VkCommandBuffer commandBuffer,
+ const VkSampleLocationsInfoEXT* pSampleLocationsInfo)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo);
+}
+static void entry_vkGetPhysicalDeviceMultisamplePropertiesEXT(
+ VkPhysicalDevice physicalDevice,
+ VkSampleCountFlagBits samples,
+ VkMultisamplePropertiesEXT* pMultisampleProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties);
+}
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+static VkResult entry_vkCreateValidationCacheEXT(
+ VkDevice device,
+ const VkValidationCacheCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkValidationCacheEXT* pValidationCache)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkCreateValidationCacheEXT_VkResult_return = (VkResult)0;
+ vkCreateValidationCacheEXT_VkResult_return = vkEnc->vkCreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache);
+ return vkCreateValidationCacheEXT_VkResult_return;
+}
+static void entry_vkDestroyValidationCacheEXT(
+ VkDevice device,
+ VkValidationCacheEXT validationCache,
+ const VkAllocationCallbacks* pAllocator)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkDestroyValidationCacheEXT(device, validationCache, pAllocator);
+}
+static VkResult entry_vkMergeValidationCachesEXT(
+ VkDevice device,
+ VkValidationCacheEXT dstCache,
+ uint32_t srcCacheCount,
+ const VkValidationCacheEXT* pSrcCaches)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkMergeValidationCachesEXT_VkResult_return = (VkResult)0;
+ vkMergeValidationCachesEXT_VkResult_return = vkEnc->vkMergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches);
+ return vkMergeValidationCachesEXT_VkResult_return;
+}
+static VkResult entry_vkGetValidationCacheDataEXT(
+ VkDevice device,
+ VkValidationCacheEXT validationCache,
+ size_t* pDataSize,
+ void* pData)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetValidationCacheDataEXT_VkResult_return = (VkResult)0;
+ vkGetValidationCacheDataEXT_VkResult_return = vkEnc->vkGetValidationCacheDataEXT(device, validationCache, pDataSize, pData);
+ return vkGetValidationCacheDataEXT_VkResult_return;
+}
+#endif
+#ifdef VK_EXT_descriptor_indexing
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+#endif
+#ifdef VK_EXT_external_memory_host
+static VkResult entry_vkGetMemoryHostPointerPropertiesEXT(
+ VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ const void* pHostPointer,
+ VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ VkResult vkGetMemoryHostPointerPropertiesEXT_VkResult_return = (VkResult)0;
+ vkGetMemoryHostPointerPropertiesEXT_VkResult_return = vkEnc->vkGetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties);
+ return vkGetMemoryHostPointerPropertiesEXT_VkResult_return;
+}
+#endif
+#ifdef VK_AMD_buffer_marker
+static void entry_vkCmdWriteBufferMarkerAMD(
+ VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ uint32_t marker)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
+}
+#endif
+#ifdef VK_AMD_shader_core_properties
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+static void entry_vkCmdSetCheckpointNV(
+ VkCommandBuffer commandBuffer,
+ const void* pCheckpointMarker)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkCmdSetCheckpointNV(commandBuffer, pCheckpointMarker);
+}
+static void entry_vkGetQueueCheckpointDataNV(
+ VkQueue queue,
+ uint32_t* pCheckpointDataCount,
+ VkCheckpointDataNV* pCheckpointData)
+{
+ auto vkEnc = HostConnection::get()->vkEncoder();
+ vkEnc->vkGetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData);
+}
+#endif
+void* goldfish_vulkan_get_proc_address(const char* name){
+#ifdef VK_VERSION_1_0
+ if (!strcmp(name, "vkCreateInstance"))
+ {
+ return (void*)entry_vkCreateInstance;
+ }
+ if (!strcmp(name, "vkDestroyInstance"))
+ {
+ return (void*)entry_vkDestroyInstance;
+ }
+ if (!strcmp(name, "vkEnumeratePhysicalDevices"))
+ {
+ return (void*)entry_vkEnumeratePhysicalDevices;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceFeatures"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceFeatures;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceFormatProperties;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceImageFormatProperties;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceProperties"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceProperties;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceMemoryProperties;
+ }
+ if (!strcmp(name, "vkGetInstanceProcAddr"))
+ {
+ return (void*)entry_vkGetInstanceProcAddr;
+ }
+ if (!strcmp(name, "vkGetDeviceProcAddr"))
+ {
+ return (void*)entry_vkGetDeviceProcAddr;
+ }
+ if (!strcmp(name, "vkCreateDevice"))
+ {
+ return (void*)entry_vkCreateDevice;
+ }
+ if (!strcmp(name, "vkDestroyDevice"))
+ {
+ return (void*)entry_vkDestroyDevice;
+ }
+ if (!strcmp(name, "vkEnumerateInstanceExtensionProperties"))
+ {
+ return (void*)entry_vkEnumerateInstanceExtensionProperties;
+ }
+ if (!strcmp(name, "vkEnumerateDeviceExtensionProperties"))
+ {
+ return (void*)entry_vkEnumerateDeviceExtensionProperties;
+ }
+ if (!strcmp(name, "vkEnumerateInstanceLayerProperties"))
+ {
+ return (void*)entry_vkEnumerateInstanceLayerProperties;
+ }
+ if (!strcmp(name, "vkEnumerateDeviceLayerProperties"))
+ {
+ return (void*)entry_vkEnumerateDeviceLayerProperties;
+ }
+ if (!strcmp(name, "vkGetDeviceQueue"))
+ {
+ return (void*)entry_vkGetDeviceQueue;
+ }
+ if (!strcmp(name, "vkQueueSubmit"))
+ {
+ return (void*)entry_vkQueueSubmit;
+ }
+ if (!strcmp(name, "vkQueueWaitIdle"))
+ {
+ return (void*)entry_vkQueueWaitIdle;
+ }
+ if (!strcmp(name, "vkDeviceWaitIdle"))
+ {
+ return (void*)entry_vkDeviceWaitIdle;
+ }
+ if (!strcmp(name, "vkAllocateMemory"))
+ {
+ return (void*)entry_vkAllocateMemory;
+ }
+ if (!strcmp(name, "vkFreeMemory"))
+ {
+ return (void*)entry_vkFreeMemory;
+ }
+ if (!strcmp(name, "vkMapMemory"))
+ {
+ return (void*)entry_vkMapMemory;
+ }
+ if (!strcmp(name, "vkUnmapMemory"))
+ {
+ return (void*)entry_vkUnmapMemory;
+ }
+ if (!strcmp(name, "vkFlushMappedMemoryRanges"))
+ {
+ return (void*)entry_vkFlushMappedMemoryRanges;
+ }
+ if (!strcmp(name, "vkInvalidateMappedMemoryRanges"))
+ {
+ return (void*)entry_vkInvalidateMappedMemoryRanges;
+ }
+ if (!strcmp(name, "vkGetDeviceMemoryCommitment"))
+ {
+ return (void*)entry_vkGetDeviceMemoryCommitment;
+ }
+ if (!strcmp(name, "vkBindBufferMemory"))
+ {
+ return (void*)entry_vkBindBufferMemory;
+ }
+ if (!strcmp(name, "vkBindImageMemory"))
+ {
+ return (void*)entry_vkBindImageMemory;
+ }
+ if (!strcmp(name, "vkGetBufferMemoryRequirements"))
+ {
+ return (void*)entry_vkGetBufferMemoryRequirements;
+ }
+ if (!strcmp(name, "vkGetImageMemoryRequirements"))
+ {
+ return (void*)entry_vkGetImageMemoryRequirements;
+ }
+ if (!strcmp(name, "vkGetImageSparseMemoryRequirements"))
+ {
+ return (void*)entry_vkGetImageSparseMemoryRequirements;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties;
+ }
+ if (!strcmp(name, "vkQueueBindSparse"))
+ {
+ return (void*)entry_vkQueueBindSparse;
+ }
+ if (!strcmp(name, "vkCreateFence"))
+ {
+ return (void*)entry_vkCreateFence;
+ }
+ if (!strcmp(name, "vkDestroyFence"))
+ {
+ return (void*)entry_vkDestroyFence;
+ }
+ if (!strcmp(name, "vkResetFences"))
+ {
+ return (void*)entry_vkResetFences;
+ }
+ if (!strcmp(name, "vkGetFenceStatus"))
+ {
+ return (void*)entry_vkGetFenceStatus;
+ }
+ if (!strcmp(name, "vkWaitForFences"))
+ {
+ return (void*)entry_vkWaitForFences;
+ }
+ if (!strcmp(name, "vkCreateSemaphore"))
+ {
+ return (void*)entry_vkCreateSemaphore;
+ }
+ if (!strcmp(name, "vkDestroySemaphore"))
+ {
+ return (void*)entry_vkDestroySemaphore;
+ }
+ if (!strcmp(name, "vkCreateEvent"))
+ {
+ return (void*)entry_vkCreateEvent;
+ }
+ if (!strcmp(name, "vkDestroyEvent"))
+ {
+ return (void*)entry_vkDestroyEvent;
+ }
+ if (!strcmp(name, "vkGetEventStatus"))
+ {
+ return (void*)entry_vkGetEventStatus;
+ }
+ if (!strcmp(name, "vkSetEvent"))
+ {
+ return (void*)entry_vkSetEvent;
+ }
+ if (!strcmp(name, "vkResetEvent"))
+ {
+ return (void*)entry_vkResetEvent;
+ }
+ if (!strcmp(name, "vkCreateQueryPool"))
+ {
+ return (void*)entry_vkCreateQueryPool;
+ }
+ if (!strcmp(name, "vkDestroyQueryPool"))
+ {
+ return (void*)entry_vkDestroyQueryPool;
+ }
+ if (!strcmp(name, "vkGetQueryPoolResults"))
+ {
+ return (void*)entry_vkGetQueryPoolResults;
+ }
+ if (!strcmp(name, "vkCreateBuffer"))
+ {
+ return (void*)entry_vkCreateBuffer;
+ }
+ if (!strcmp(name, "vkDestroyBuffer"))
+ {
+ return (void*)entry_vkDestroyBuffer;
+ }
+ if (!strcmp(name, "vkCreateBufferView"))
+ {
+ return (void*)entry_vkCreateBufferView;
+ }
+ if (!strcmp(name, "vkDestroyBufferView"))
+ {
+ return (void*)entry_vkDestroyBufferView;
+ }
+ if (!strcmp(name, "vkCreateImage"))
+ {
+ return (void*)entry_vkCreateImage;
+ }
+ if (!strcmp(name, "vkDestroyImage"))
+ {
+ return (void*)entry_vkDestroyImage;
+ }
+ if (!strcmp(name, "vkGetImageSubresourceLayout"))
+ {
+ return (void*)entry_vkGetImageSubresourceLayout;
+ }
+ if (!strcmp(name, "vkCreateImageView"))
+ {
+ return (void*)entry_vkCreateImageView;
+ }
+ if (!strcmp(name, "vkDestroyImageView"))
+ {
+ return (void*)entry_vkDestroyImageView;
+ }
+ if (!strcmp(name, "vkCreateShaderModule"))
+ {
+ return (void*)entry_vkCreateShaderModule;
+ }
+ if (!strcmp(name, "vkDestroyShaderModule"))
+ {
+ return (void*)entry_vkDestroyShaderModule;
+ }
+ if (!strcmp(name, "vkCreatePipelineCache"))
+ {
+ return (void*)entry_vkCreatePipelineCache;
+ }
+ if (!strcmp(name, "vkDestroyPipelineCache"))
+ {
+ return (void*)entry_vkDestroyPipelineCache;
+ }
+ if (!strcmp(name, "vkGetPipelineCacheData"))
+ {
+ return (void*)entry_vkGetPipelineCacheData;
+ }
+ if (!strcmp(name, "vkMergePipelineCaches"))
+ {
+ return (void*)entry_vkMergePipelineCaches;
+ }
+ if (!strcmp(name, "vkCreateGraphicsPipelines"))
+ {
+ return (void*)entry_vkCreateGraphicsPipelines;
+ }
+ if (!strcmp(name, "vkCreateComputePipelines"))
+ {
+ return (void*)entry_vkCreateComputePipelines;
+ }
+ if (!strcmp(name, "vkDestroyPipeline"))
+ {
+ return (void*)entry_vkDestroyPipeline;
+ }
+ if (!strcmp(name, "vkCreatePipelineLayout"))
+ {
+ return (void*)entry_vkCreatePipelineLayout;
+ }
+ if (!strcmp(name, "vkDestroyPipelineLayout"))
+ {
+ return (void*)entry_vkDestroyPipelineLayout;
+ }
+ if (!strcmp(name, "vkCreateSampler"))
+ {
+ return (void*)entry_vkCreateSampler;
+ }
+ if (!strcmp(name, "vkDestroySampler"))
+ {
+ return (void*)entry_vkDestroySampler;
+ }
+ if (!strcmp(name, "vkCreateDescriptorSetLayout"))
+ {
+ return (void*)entry_vkCreateDescriptorSetLayout;
+ }
+ if (!strcmp(name, "vkDestroyDescriptorSetLayout"))
+ {
+ return (void*)entry_vkDestroyDescriptorSetLayout;
+ }
+ if (!strcmp(name, "vkCreateDescriptorPool"))
+ {
+ return (void*)entry_vkCreateDescriptorPool;
+ }
+ if (!strcmp(name, "vkDestroyDescriptorPool"))
+ {
+ return (void*)entry_vkDestroyDescriptorPool;
+ }
+ if (!strcmp(name, "vkResetDescriptorPool"))
+ {
+ return (void*)entry_vkResetDescriptorPool;
+ }
+ if (!strcmp(name, "vkAllocateDescriptorSets"))
+ {
+ return (void*)entry_vkAllocateDescriptorSets;
+ }
+ if (!strcmp(name, "vkFreeDescriptorSets"))
+ {
+ return (void*)entry_vkFreeDescriptorSets;
+ }
+ if (!strcmp(name, "vkUpdateDescriptorSets"))
+ {
+ return (void*)entry_vkUpdateDescriptorSets;
+ }
+ if (!strcmp(name, "vkCreateFramebuffer"))
+ {
+ return (void*)entry_vkCreateFramebuffer;
+ }
+ if (!strcmp(name, "vkDestroyFramebuffer"))
+ {
+ return (void*)entry_vkDestroyFramebuffer;
+ }
+ if (!strcmp(name, "vkCreateRenderPass"))
+ {
+ return (void*)entry_vkCreateRenderPass;
+ }
+ if (!strcmp(name, "vkDestroyRenderPass"))
+ {
+ return (void*)entry_vkDestroyRenderPass;
+ }
+ if (!strcmp(name, "vkGetRenderAreaGranularity"))
+ {
+ return (void*)entry_vkGetRenderAreaGranularity;
+ }
+ if (!strcmp(name, "vkCreateCommandPool"))
+ {
+ return (void*)entry_vkCreateCommandPool;
+ }
+ if (!strcmp(name, "vkDestroyCommandPool"))
+ {
+ return (void*)entry_vkDestroyCommandPool;
+ }
+ if (!strcmp(name, "vkResetCommandPool"))
+ {
+ return (void*)entry_vkResetCommandPool;
+ }
+ if (!strcmp(name, "vkAllocateCommandBuffers"))
+ {
+ return (void*)entry_vkAllocateCommandBuffers;
+ }
+ if (!strcmp(name, "vkFreeCommandBuffers"))
+ {
+ return (void*)entry_vkFreeCommandBuffers;
+ }
+ if (!strcmp(name, "vkBeginCommandBuffer"))
+ {
+ return (void*)entry_vkBeginCommandBuffer;
+ }
+ if (!strcmp(name, "vkEndCommandBuffer"))
+ {
+ return (void*)entry_vkEndCommandBuffer;
+ }
+ if (!strcmp(name, "vkResetCommandBuffer"))
+ {
+ return (void*)entry_vkResetCommandBuffer;
+ }
+ if (!strcmp(name, "vkCmdBindPipeline"))
+ {
+ return (void*)entry_vkCmdBindPipeline;
+ }
+ if (!strcmp(name, "vkCmdSetViewport"))
+ {
+ return (void*)entry_vkCmdSetViewport;
+ }
+ if (!strcmp(name, "vkCmdSetScissor"))
+ {
+ return (void*)entry_vkCmdSetScissor;
+ }
+ if (!strcmp(name, "vkCmdSetLineWidth"))
+ {
+ return (void*)entry_vkCmdSetLineWidth;
+ }
+ if (!strcmp(name, "vkCmdSetDepthBias"))
+ {
+ return (void*)entry_vkCmdSetDepthBias;
+ }
+ if (!strcmp(name, "vkCmdSetBlendConstants"))
+ {
+ return (void*)entry_vkCmdSetBlendConstants;
+ }
+ if (!strcmp(name, "vkCmdSetDepthBounds"))
+ {
+ return (void*)entry_vkCmdSetDepthBounds;
+ }
+ if (!strcmp(name, "vkCmdSetStencilCompareMask"))
+ {
+ return (void*)entry_vkCmdSetStencilCompareMask;
+ }
+ if (!strcmp(name, "vkCmdSetStencilWriteMask"))
+ {
+ return (void*)entry_vkCmdSetStencilWriteMask;
+ }
+ if (!strcmp(name, "vkCmdSetStencilReference"))
+ {
+ return (void*)entry_vkCmdSetStencilReference;
+ }
+ if (!strcmp(name, "vkCmdBindDescriptorSets"))
+ {
+ return (void*)entry_vkCmdBindDescriptorSets;
+ }
+ if (!strcmp(name, "vkCmdBindIndexBuffer"))
+ {
+ return (void*)entry_vkCmdBindIndexBuffer;
+ }
+ if (!strcmp(name, "vkCmdBindVertexBuffers"))
+ {
+ return (void*)entry_vkCmdBindVertexBuffers;
+ }
+ if (!strcmp(name, "vkCmdDraw"))
+ {
+ return (void*)entry_vkCmdDraw;
+ }
+ if (!strcmp(name, "vkCmdDrawIndexed"))
+ {
+ return (void*)entry_vkCmdDrawIndexed;
+ }
+ if (!strcmp(name, "vkCmdDrawIndirect"))
+ {
+ return (void*)entry_vkCmdDrawIndirect;
+ }
+ if (!strcmp(name, "vkCmdDrawIndexedIndirect"))
+ {
+ return (void*)entry_vkCmdDrawIndexedIndirect;
+ }
+ if (!strcmp(name, "vkCmdDispatch"))
+ {
+ return (void*)entry_vkCmdDispatch;
+ }
+ if (!strcmp(name, "vkCmdDispatchIndirect"))
+ {
+ return (void*)entry_vkCmdDispatchIndirect;
+ }
+ if (!strcmp(name, "vkCmdCopyBuffer"))
+ {
+ return (void*)entry_vkCmdCopyBuffer;
+ }
+ if (!strcmp(name, "vkCmdCopyImage"))
+ {
+ return (void*)entry_vkCmdCopyImage;
+ }
+ if (!strcmp(name, "vkCmdBlitImage"))
+ {
+ return (void*)entry_vkCmdBlitImage;
+ }
+ if (!strcmp(name, "vkCmdCopyBufferToImage"))
+ {
+ return (void*)entry_vkCmdCopyBufferToImage;
+ }
+ if (!strcmp(name, "vkCmdCopyImageToBuffer"))
+ {
+ return (void*)entry_vkCmdCopyImageToBuffer;
+ }
+ if (!strcmp(name, "vkCmdUpdateBuffer"))
+ {
+ return (void*)entry_vkCmdUpdateBuffer;
+ }
+ if (!strcmp(name, "vkCmdFillBuffer"))
+ {
+ return (void*)entry_vkCmdFillBuffer;
+ }
+ if (!strcmp(name, "vkCmdClearColorImage"))
+ {
+ return (void*)entry_vkCmdClearColorImage;
+ }
+ if (!strcmp(name, "vkCmdClearDepthStencilImage"))
+ {
+ return (void*)entry_vkCmdClearDepthStencilImage;
+ }
+ if (!strcmp(name, "vkCmdClearAttachments"))
+ {
+ return (void*)entry_vkCmdClearAttachments;
+ }
+ if (!strcmp(name, "vkCmdResolveImage"))
+ {
+ return (void*)entry_vkCmdResolveImage;
+ }
+ if (!strcmp(name, "vkCmdSetEvent"))
+ {
+ return (void*)entry_vkCmdSetEvent;
+ }
+ if (!strcmp(name, "vkCmdResetEvent"))
+ {
+ return (void*)entry_vkCmdResetEvent;
+ }
+ if (!strcmp(name, "vkCmdWaitEvents"))
+ {
+ return (void*)entry_vkCmdWaitEvents;
+ }
+ if (!strcmp(name, "vkCmdPipelineBarrier"))
+ {
+ return (void*)entry_vkCmdPipelineBarrier;
+ }
+ if (!strcmp(name, "vkCmdBeginQuery"))
+ {
+ return (void*)entry_vkCmdBeginQuery;
+ }
+ if (!strcmp(name, "vkCmdEndQuery"))
+ {
+ return (void*)entry_vkCmdEndQuery;
+ }
+ if (!strcmp(name, "vkCmdResetQueryPool"))
+ {
+ return (void*)entry_vkCmdResetQueryPool;
+ }
+ if (!strcmp(name, "vkCmdWriteTimestamp"))
+ {
+ return (void*)entry_vkCmdWriteTimestamp;
+ }
+ if (!strcmp(name, "vkCmdCopyQueryPoolResults"))
+ {
+ return (void*)entry_vkCmdCopyQueryPoolResults;
+ }
+ if (!strcmp(name, "vkCmdPushConstants"))
+ {
+ return (void*)entry_vkCmdPushConstants;
+ }
+ if (!strcmp(name, "vkCmdBeginRenderPass"))
+ {
+ return (void*)entry_vkCmdBeginRenderPass;
+ }
+ if (!strcmp(name, "vkCmdNextSubpass"))
+ {
+ return (void*)entry_vkCmdNextSubpass;
+ }
+ if (!strcmp(name, "vkCmdEndRenderPass"))
+ {
+ return (void*)entry_vkCmdEndRenderPass;
+ }
+ if (!strcmp(name, "vkCmdExecuteCommands"))
+ {
+ return (void*)entry_vkCmdExecuteCommands;
+ }
+#endif
+#ifdef VK_VERSION_1_1
+ if (!strcmp(name, "vkEnumerateInstanceVersion"))
+ {
+ return (void*)entry_vkEnumerateInstanceVersion;
+ }
+ if (!strcmp(name, "vkBindBufferMemory2"))
+ {
+ return (void*)entry_vkBindBufferMemory2;
+ }
+ if (!strcmp(name, "vkBindImageMemory2"))
+ {
+ return (void*)entry_vkBindImageMemory2;
+ }
+ if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures"))
+ {
+ return (void*)entry_vkGetDeviceGroupPeerMemoryFeatures;
+ }
+ if (!strcmp(name, "vkCmdSetDeviceMask"))
+ {
+ return (void*)entry_vkCmdSetDeviceMask;
+ }
+ if (!strcmp(name, "vkCmdDispatchBase"))
+ {
+ return (void*)entry_vkCmdDispatchBase;
+ }
+ if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups"))
+ {
+ return (void*)entry_vkEnumeratePhysicalDeviceGroups;
+ }
+ if (!strcmp(name, "vkGetImageMemoryRequirements2"))
+ {
+ return (void*)entry_vkGetImageMemoryRequirements2;
+ }
+ if (!strcmp(name, "vkGetBufferMemoryRequirements2"))
+ {
+ return (void*)entry_vkGetBufferMemoryRequirements2;
+ }
+ if (!strcmp(name, "vkGetImageSparseMemoryRequirements2"))
+ {
+ return (void*)entry_vkGetImageSparseMemoryRequirements2;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceFeatures2"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceFeatures2;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceProperties2"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceProperties2;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceFormatProperties2;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceImageFormatProperties2;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceMemoryProperties2;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2;
+ }
+ if (!strcmp(name, "vkTrimCommandPool"))
+ {
+ return (void*)entry_vkTrimCommandPool;
+ }
+ if (!strcmp(name, "vkGetDeviceQueue2"))
+ {
+ return (void*)entry_vkGetDeviceQueue2;
+ }
+ if (!strcmp(name, "vkCreateSamplerYcbcrConversion"))
+ {
+ return (void*)entry_vkCreateSamplerYcbcrConversion;
+ }
+ if (!strcmp(name, "vkDestroySamplerYcbcrConversion"))
+ {
+ return (void*)entry_vkDestroySamplerYcbcrConversion;
+ }
+ if (!strcmp(name, "vkCreateDescriptorUpdateTemplate"))
+ {
+ return (void*)entry_vkCreateDescriptorUpdateTemplate;
+ }
+ if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate"))
+ {
+ return (void*)entry_vkDestroyDescriptorUpdateTemplate;
+ }
+ if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate"))
+ {
+ return (void*)entry_vkUpdateDescriptorSetWithTemplate;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceExternalBufferProperties;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceExternalFenceProperties;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceExternalSemaphoreProperties;
+ }
+ if (!strcmp(name, "vkGetDescriptorSetLayoutSupport"))
+ {
+ return (void*)entry_vkGetDescriptorSetLayoutSupport;
+ }
+#endif
+#ifdef VK_KHR_surface
+ if (!strcmp(name, "vkDestroySurfaceKHR"))
+ {
+ return (void*)entry_vkDestroySurfaceKHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceSupportKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceSurfaceSupportKHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormatsKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceSurfaceFormatsKHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfacePresentModesKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceSurfacePresentModesKHR;
+ }
+#endif
+#ifdef VK_KHR_swapchain
+ if (!strcmp(name, "vkCreateSwapchainKHR"))
+ {
+ return (void*)entry_vkCreateSwapchainKHR;
+ }
+ if (!strcmp(name, "vkDestroySwapchainKHR"))
+ {
+ return (void*)entry_vkDestroySwapchainKHR;
+ }
+ if (!strcmp(name, "vkGetSwapchainImagesKHR"))
+ {
+ return (void*)entry_vkGetSwapchainImagesKHR;
+ }
+ if (!strcmp(name, "vkAcquireNextImageKHR"))
+ {
+ return (void*)entry_vkAcquireNextImageKHR;
+ }
+ if (!strcmp(name, "vkQueuePresentKHR"))
+ {
+ return (void*)entry_vkQueuePresentKHR;
+ }
+ if (!strcmp(name, "vkGetDeviceGroupPresentCapabilitiesKHR"))
+ {
+ return (void*)entry_vkGetDeviceGroupPresentCapabilitiesKHR;
+ }
+ if (!strcmp(name, "vkGetDeviceGroupSurfacePresentModesKHR"))
+ {
+ return (void*)entry_vkGetDeviceGroupSurfacePresentModesKHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDevicePresentRectanglesKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDevicePresentRectanglesKHR;
+ }
+ if (!strcmp(name, "vkAcquireNextImage2KHR"))
+ {
+ return (void*)entry_vkAcquireNextImage2KHR;
+ }
+#endif
+#ifdef VK_KHR_display
+ if (!strcmp(name, "vkGetPhysicalDeviceDisplayPropertiesKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceDisplayPropertiesKHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceDisplayPlanePropertiesKHR;
+ }
+ if (!strcmp(name, "vkGetDisplayPlaneSupportedDisplaysKHR"))
+ {
+ return (void*)entry_vkGetDisplayPlaneSupportedDisplaysKHR;
+ }
+ if (!strcmp(name, "vkGetDisplayModePropertiesKHR"))
+ {
+ return (void*)entry_vkGetDisplayModePropertiesKHR;
+ }
+ if (!strcmp(name, "vkCreateDisplayModeKHR"))
+ {
+ return (void*)entry_vkCreateDisplayModeKHR;
+ }
+ if (!strcmp(name, "vkGetDisplayPlaneCapabilitiesKHR"))
+ {
+ return (void*)entry_vkGetDisplayPlaneCapabilitiesKHR;
+ }
+ if (!strcmp(name, "vkCreateDisplayPlaneSurfaceKHR"))
+ {
+ return (void*)entry_vkCreateDisplayPlaneSurfaceKHR;
+ }
+#endif
+#ifdef VK_KHR_display_swapchain
+ if (!strcmp(name, "vkCreateSharedSwapchainsKHR"))
+ {
+ return (void*)entry_vkCreateSharedSwapchainsKHR;
+ }
+#endif
+#ifdef VK_KHR_xlib_surface
+ if (!strcmp(name, "vkCreateXlibSurfaceKHR"))
+ {
+ return (void*)entry_vkCreateXlibSurfaceKHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceXlibPresentationSupportKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceXlibPresentationSupportKHR;
+ }
+#endif
+#ifdef VK_KHR_xcb_surface
+ if (!strcmp(name, "vkCreateXcbSurfaceKHR"))
+ {
+ return (void*)entry_vkCreateXcbSurfaceKHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceXcbPresentationSupportKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceXcbPresentationSupportKHR;
+ }
+#endif
+#ifdef VK_KHR_wayland_surface
+ if (!strcmp(name, "vkCreateWaylandSurfaceKHR"))
+ {
+ return (void*)entry_vkCreateWaylandSurfaceKHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceWaylandPresentationSupportKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceWaylandPresentationSupportKHR;
+ }
+#endif
+#ifdef VK_KHR_mir_surface
+ if (!strcmp(name, "vkCreateMirSurfaceKHR"))
+ {
+ return (void*)entry_vkCreateMirSurfaceKHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceMirPresentationSupportKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceMirPresentationSupportKHR;
+ }
+#endif
+#ifdef VK_KHR_android_surface
+ if (!strcmp(name, "vkCreateAndroidSurfaceKHR"))
+ {
+ return (void*)entry_vkCreateAndroidSurfaceKHR;
+ }
+#endif
+#ifdef VK_KHR_win32_surface
+ if (!strcmp(name, "vkCreateWin32SurfaceKHR"))
+ {
+ return (void*)entry_vkCreateWin32SurfaceKHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceWin32PresentationSupportKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceWin32PresentationSupportKHR;
+ }
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+ if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceFeatures2KHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceProperties2KHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceFormatProperties2KHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceImageFormatProperties2KHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceMemoryProperties2KHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR;
+ }
+#endif
+#ifdef VK_KHR_device_group
+ if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeaturesKHR"))
+ {
+ return (void*)entry_vkGetDeviceGroupPeerMemoryFeaturesKHR;
+ }
+ if (!strcmp(name, "vkCmdSetDeviceMaskKHR"))
+ {
+ return (void*)entry_vkCmdSetDeviceMaskKHR;
+ }
+ if (!strcmp(name, "vkCmdDispatchBaseKHR"))
+ {
+ return (void*)entry_vkCmdDispatchBaseKHR;
+ }
+#endif
+#ifdef VK_KHR_maintenance1
+ if (!strcmp(name, "vkTrimCommandPoolKHR"))
+ {
+ return (void*)entry_vkTrimCommandPoolKHR;
+ }
+#endif
+#ifdef VK_KHR_device_group_creation
+ if (!strcmp(name, "vkEnumeratePhysicalDeviceGroupsKHR"))
+ {
+ return (void*)entry_vkEnumeratePhysicalDeviceGroupsKHR;
+ }
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR;
+ }
+#endif
+#ifdef VK_KHR_external_memory_win32
+ if (!strcmp(name, "vkGetMemoryWin32HandleKHR"))
+ {
+ return (void*)entry_vkGetMemoryWin32HandleKHR;
+ }
+ if (!strcmp(name, "vkGetMemoryWin32HandlePropertiesKHR"))
+ {
+ return (void*)entry_vkGetMemoryWin32HandlePropertiesKHR;
+ }
+#endif
+#ifdef VK_KHR_external_memory_fd
+ if (!strcmp(name, "vkGetMemoryFdKHR"))
+ {
+ return (void*)entry_vkGetMemoryFdKHR;
+ }
+ if (!strcmp(name, "vkGetMemoryFdPropertiesKHR"))
+ {
+ return (void*)entry_vkGetMemoryFdPropertiesKHR;
+ }
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR;
+ }
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+ if (!strcmp(name, "vkImportSemaphoreWin32HandleKHR"))
+ {
+ return (void*)entry_vkImportSemaphoreWin32HandleKHR;
+ }
+ if (!strcmp(name, "vkGetSemaphoreWin32HandleKHR"))
+ {
+ return (void*)entry_vkGetSemaphoreWin32HandleKHR;
+ }
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+ if (!strcmp(name, "vkImportSemaphoreFdKHR"))
+ {
+ return (void*)entry_vkImportSemaphoreFdKHR;
+ }
+ if (!strcmp(name, "vkGetSemaphoreFdKHR"))
+ {
+ return (void*)entry_vkGetSemaphoreFdKHR;
+ }
+#endif
+#ifdef VK_KHR_push_descriptor
+ if (!strcmp(name, "vkCmdPushDescriptorSetKHR"))
+ {
+ return (void*)entry_vkCmdPushDescriptorSetKHR;
+ }
+ if (!strcmp(name, "vkCmdPushDescriptorSetWithTemplateKHR"))
+ {
+ return (void*)entry_vkCmdPushDescriptorSetWithTemplateKHR;
+ }
+#endif
+#ifdef VK_KHR_descriptor_update_template
+ if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR"))
+ {
+ return (void*)entry_vkCreateDescriptorUpdateTemplateKHR;
+ }
+ if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR"))
+ {
+ return (void*)entry_vkDestroyDescriptorUpdateTemplateKHR;
+ }
+ if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR"))
+ {
+ return (void*)entry_vkUpdateDescriptorSetWithTemplateKHR;
+ }
+#endif
+#ifdef VK_KHR_create_renderpass2
+ if (!strcmp(name, "vkCreateRenderPass2KHR"))
+ {
+ return (void*)entry_vkCreateRenderPass2KHR;
+ }
+ if (!strcmp(name, "vkCmdBeginRenderPass2KHR"))
+ {
+ return (void*)entry_vkCmdBeginRenderPass2KHR;
+ }
+ if (!strcmp(name, "vkCmdNextSubpass2KHR"))
+ {
+ return (void*)entry_vkCmdNextSubpass2KHR;
+ }
+ if (!strcmp(name, "vkCmdEndRenderPass2KHR"))
+ {
+ return (void*)entry_vkCmdEndRenderPass2KHR;
+ }
+#endif
+#ifdef VK_KHR_shared_presentable_image
+ if (!strcmp(name, "vkGetSwapchainStatusKHR"))
+ {
+ return (void*)entry_vkGetSwapchainStatusKHR;
+ }
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceExternalFencePropertiesKHR;
+ }
+#endif
+#ifdef VK_KHR_external_fence_win32
+ if (!strcmp(name, "vkImportFenceWin32HandleKHR"))
+ {
+ return (void*)entry_vkImportFenceWin32HandleKHR;
+ }
+ if (!strcmp(name, "vkGetFenceWin32HandleKHR"))
+ {
+ return (void*)entry_vkGetFenceWin32HandleKHR;
+ }
+#endif
+#ifdef VK_KHR_external_fence_fd
+ if (!strcmp(name, "vkImportFenceFdKHR"))
+ {
+ return (void*)entry_vkImportFenceFdKHR;
+ }
+ if (!strcmp(name, "vkGetFenceFdKHR"))
+ {
+ return (void*)entry_vkGetFenceFdKHR;
+ }
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2KHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceSurfaceCapabilities2KHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormats2KHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceSurfaceFormats2KHR;
+ }
+#endif
+#ifdef VK_KHR_get_display_properties2
+ if (!strcmp(name, "vkGetPhysicalDeviceDisplayProperties2KHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceDisplayProperties2KHR;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceDisplayPlaneProperties2KHR;
+ }
+ if (!strcmp(name, "vkGetDisplayModeProperties2KHR"))
+ {
+ return (void*)entry_vkGetDisplayModeProperties2KHR;
+ }
+ if (!strcmp(name, "vkGetDisplayPlaneCapabilities2KHR"))
+ {
+ return (void*)entry_vkGetDisplayPlaneCapabilities2KHR;
+ }
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+ if (!strcmp(name, "vkGetImageMemoryRequirements2KHR"))
+ {
+ return (void*)entry_vkGetImageMemoryRequirements2KHR;
+ }
+ if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR"))
+ {
+ return (void*)entry_vkGetBufferMemoryRequirements2KHR;
+ }
+ if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR"))
+ {
+ return (void*)entry_vkGetImageSparseMemoryRequirements2KHR;
+ }
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+ if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR"))
+ {
+ return (void*)entry_vkCreateSamplerYcbcrConversionKHR;
+ }
+ if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR"))
+ {
+ return (void*)entry_vkDestroySamplerYcbcrConversionKHR;
+ }
+#endif
+#ifdef VK_KHR_bind_memory2
+ if (!strcmp(name, "vkBindBufferMemory2KHR"))
+ {
+ return (void*)entry_vkBindBufferMemory2KHR;
+ }
+ if (!strcmp(name, "vkBindImageMemory2KHR"))
+ {
+ return (void*)entry_vkBindImageMemory2KHR;
+ }
+#endif
+#ifdef VK_KHR_maintenance3
+ if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR"))
+ {
+ return (void*)entry_vkGetDescriptorSetLayoutSupportKHR;
+ }
+#endif
+#ifdef VK_KHR_draw_indirect_count
+ if (!strcmp(name, "vkCmdDrawIndirectCountKHR"))
+ {
+ return (void*)entry_vkCmdDrawIndirectCountKHR;
+ }
+ if (!strcmp(name, "vkCmdDrawIndexedIndirectCountKHR"))
+ {
+ return (void*)entry_vkCmdDrawIndexedIndirectCountKHR;
+ }
+#endif
+#ifdef VK_EXT_debug_report
+ if (!strcmp(name, "vkCreateDebugReportCallbackEXT"))
+ {
+ return (void*)entry_vkCreateDebugReportCallbackEXT;
+ }
+ if (!strcmp(name, "vkDestroyDebugReportCallbackEXT"))
+ {
+ return (void*)entry_vkDestroyDebugReportCallbackEXT;
+ }
+ if (!strcmp(name, "vkDebugReportMessageEXT"))
+ {
+ return (void*)entry_vkDebugReportMessageEXT;
+ }
+#endif
+#ifdef VK_EXT_debug_marker
+ if (!strcmp(name, "vkDebugMarkerSetObjectTagEXT"))
+ {
+ return (void*)entry_vkDebugMarkerSetObjectTagEXT;
+ }
+ if (!strcmp(name, "vkDebugMarkerSetObjectNameEXT"))
+ {
+ return (void*)entry_vkDebugMarkerSetObjectNameEXT;
+ }
+ if (!strcmp(name, "vkCmdDebugMarkerBeginEXT"))
+ {
+ return (void*)entry_vkCmdDebugMarkerBeginEXT;
+ }
+ if (!strcmp(name, "vkCmdDebugMarkerEndEXT"))
+ {
+ return (void*)entry_vkCmdDebugMarkerEndEXT;
+ }
+ if (!strcmp(name, "vkCmdDebugMarkerInsertEXT"))
+ {
+ return (void*)entry_vkCmdDebugMarkerInsertEXT;
+ }
+#endif
+#ifdef VK_AMD_draw_indirect_count
+ if (!strcmp(name, "vkCmdDrawIndirectCountAMD"))
+ {
+ return (void*)entry_vkCmdDrawIndirectCountAMD;
+ }
+ if (!strcmp(name, "vkCmdDrawIndexedIndirectCountAMD"))
+ {
+ return (void*)entry_vkCmdDrawIndexedIndirectCountAMD;
+ }
+#endif
+#ifdef VK_AMD_shader_info
+ if (!strcmp(name, "vkGetShaderInfoAMD"))
+ {
+ return (void*)entry_vkGetShaderInfoAMD;
+ }
+#endif
+#ifdef VK_NV_external_memory_capabilities
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceExternalImageFormatPropertiesNV;
+ }
+#endif
+#ifdef VK_NV_external_memory_win32
+ if (!strcmp(name, "vkGetMemoryWin32HandleNV"))
+ {
+ return (void*)entry_vkGetMemoryWin32HandleNV;
+ }
+#endif
+#ifdef VK_NN_vi_surface
+ if (!strcmp(name, "vkCreateViSurfaceNN"))
+ {
+ return (void*)entry_vkCreateViSurfaceNN;
+ }
+#endif
+#ifdef VK_EXT_conditional_rendering
+ if (!strcmp(name, "vkCmdBeginConditionalRenderingEXT"))
+ {
+ return (void*)entry_vkCmdBeginConditionalRenderingEXT;
+ }
+ if (!strcmp(name, "vkCmdEndConditionalRenderingEXT"))
+ {
+ return (void*)entry_vkCmdEndConditionalRenderingEXT;
+ }
+#endif
+#ifdef VK_NVX_device_generated_commands
+ if (!strcmp(name, "vkCmdProcessCommandsNVX"))
+ {
+ return (void*)entry_vkCmdProcessCommandsNVX;
+ }
+ if (!strcmp(name, "vkCmdReserveSpaceForCommandsNVX"))
+ {
+ return (void*)entry_vkCmdReserveSpaceForCommandsNVX;
+ }
+ if (!strcmp(name, "vkCreateIndirectCommandsLayoutNVX"))
+ {
+ return (void*)entry_vkCreateIndirectCommandsLayoutNVX;
+ }
+ if (!strcmp(name, "vkDestroyIndirectCommandsLayoutNVX"))
+ {
+ return (void*)entry_vkDestroyIndirectCommandsLayoutNVX;
+ }
+ if (!strcmp(name, "vkCreateObjectTableNVX"))
+ {
+ return (void*)entry_vkCreateObjectTableNVX;
+ }
+ if (!strcmp(name, "vkDestroyObjectTableNVX"))
+ {
+ return (void*)entry_vkDestroyObjectTableNVX;
+ }
+ if (!strcmp(name, "vkRegisterObjectsNVX"))
+ {
+ return (void*)entry_vkRegisterObjectsNVX;
+ }
+ if (!strcmp(name, "vkUnregisterObjectsNVX"))
+ {
+ return (void*)entry_vkUnregisterObjectsNVX;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX;
+ }
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+ if (!strcmp(name, "vkCmdSetViewportWScalingNV"))
+ {
+ return (void*)entry_vkCmdSetViewportWScalingNV;
+ }
+#endif
+#ifdef VK_EXT_direct_mode_display
+ if (!strcmp(name, "vkReleaseDisplayEXT"))
+ {
+ return (void*)entry_vkReleaseDisplayEXT;
+ }
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+ if (!strcmp(name, "vkAcquireXlibDisplayEXT"))
+ {
+ return (void*)entry_vkAcquireXlibDisplayEXT;
+ }
+ if (!strcmp(name, "vkGetRandROutputDisplayEXT"))
+ {
+ return (void*)entry_vkGetRandROutputDisplayEXT;
+ }
+#endif
+#ifdef VK_EXT_display_surface_counter
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceSurfaceCapabilities2EXT;
+ }
+#endif
+#ifdef VK_EXT_display_control
+ if (!strcmp(name, "vkDisplayPowerControlEXT"))
+ {
+ return (void*)entry_vkDisplayPowerControlEXT;
+ }
+ if (!strcmp(name, "vkRegisterDeviceEventEXT"))
+ {
+ return (void*)entry_vkRegisterDeviceEventEXT;
+ }
+ if (!strcmp(name, "vkRegisterDisplayEventEXT"))
+ {
+ return (void*)entry_vkRegisterDisplayEventEXT;
+ }
+ if (!strcmp(name, "vkGetSwapchainCounterEXT"))
+ {
+ return (void*)entry_vkGetSwapchainCounterEXT;
+ }
+#endif
+#ifdef VK_GOOGLE_display_timing
+ if (!strcmp(name, "vkGetRefreshCycleDurationGOOGLE"))
+ {
+ return (void*)entry_vkGetRefreshCycleDurationGOOGLE;
+ }
+ if (!strcmp(name, "vkGetPastPresentationTimingGOOGLE"))
+ {
+ return (void*)entry_vkGetPastPresentationTimingGOOGLE;
+ }
+#endif
+#ifdef VK_EXT_discard_rectangles
+ if (!strcmp(name, "vkCmdSetDiscardRectangleEXT"))
+ {
+ return (void*)entry_vkCmdSetDiscardRectangleEXT;
+ }
+#endif
+#ifdef VK_EXT_hdr_metadata
+ if (!strcmp(name, "vkSetHdrMetadataEXT"))
+ {
+ return (void*)entry_vkSetHdrMetadataEXT;
+ }
+#endif
+#ifdef VK_MVK_ios_surface
+ if (!strcmp(name, "vkCreateIOSSurfaceMVK"))
+ {
+ return (void*)entry_vkCreateIOSSurfaceMVK;
+ }
+#endif
+#ifdef VK_MVK_macos_surface
+ if (!strcmp(name, "vkCreateMacOSSurfaceMVK"))
+ {
+ return (void*)entry_vkCreateMacOSSurfaceMVK;
+ }
+#endif
+#ifdef VK_EXT_debug_utils
+ if (!strcmp(name, "vkSetDebugUtilsObjectNameEXT"))
+ {
+ return (void*)entry_vkSetDebugUtilsObjectNameEXT;
+ }
+ if (!strcmp(name, "vkSetDebugUtilsObjectTagEXT"))
+ {
+ return (void*)entry_vkSetDebugUtilsObjectTagEXT;
+ }
+ if (!strcmp(name, "vkQueueBeginDebugUtilsLabelEXT"))
+ {
+ return (void*)entry_vkQueueBeginDebugUtilsLabelEXT;
+ }
+ if (!strcmp(name, "vkQueueEndDebugUtilsLabelEXT"))
+ {
+ return (void*)entry_vkQueueEndDebugUtilsLabelEXT;
+ }
+ if (!strcmp(name, "vkQueueInsertDebugUtilsLabelEXT"))
+ {
+ return (void*)entry_vkQueueInsertDebugUtilsLabelEXT;
+ }
+ if (!strcmp(name, "vkCmdBeginDebugUtilsLabelEXT"))
+ {
+ return (void*)entry_vkCmdBeginDebugUtilsLabelEXT;
+ }
+ if (!strcmp(name, "vkCmdEndDebugUtilsLabelEXT"))
+ {
+ return (void*)entry_vkCmdEndDebugUtilsLabelEXT;
+ }
+ if (!strcmp(name, "vkCmdInsertDebugUtilsLabelEXT"))
+ {
+ return (void*)entry_vkCmdInsertDebugUtilsLabelEXT;
+ }
+ if (!strcmp(name, "vkCreateDebugUtilsMessengerEXT"))
+ {
+ return (void*)entry_vkCreateDebugUtilsMessengerEXT;
+ }
+ if (!strcmp(name, "vkDestroyDebugUtilsMessengerEXT"))
+ {
+ return (void*)entry_vkDestroyDebugUtilsMessengerEXT;
+ }
+ if (!strcmp(name, "vkSubmitDebugUtilsMessageEXT"))
+ {
+ return (void*)entry_vkSubmitDebugUtilsMessageEXT;
+ }
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+ if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID"))
+ {
+ return (void*)entry_vkGetAndroidHardwareBufferPropertiesANDROID;
+ }
+ if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID"))
+ {
+ return (void*)entry_vkGetMemoryAndroidHardwareBufferANDROID;
+ }
+#endif
+#ifdef VK_EXT_sample_locations
+ if (!strcmp(name, "vkCmdSetSampleLocationsEXT"))
+ {
+ return (void*)entry_vkCmdSetSampleLocationsEXT;
+ }
+ if (!strcmp(name, "vkGetPhysicalDeviceMultisamplePropertiesEXT"))
+ {
+ return (void*)entry_vkGetPhysicalDeviceMultisamplePropertiesEXT;
+ }
+#endif
+#ifdef VK_EXT_validation_cache
+ if (!strcmp(name, "vkCreateValidationCacheEXT"))
+ {
+ return (void*)entry_vkCreateValidationCacheEXT;
+ }
+ if (!strcmp(name, "vkDestroyValidationCacheEXT"))
+ {
+ return (void*)entry_vkDestroyValidationCacheEXT;
+ }
+ if (!strcmp(name, "vkMergeValidationCachesEXT"))
+ {
+ return (void*)entry_vkMergeValidationCachesEXT;
+ }
+ if (!strcmp(name, "vkGetValidationCacheDataEXT"))
+ {
+ return (void*)entry_vkGetValidationCacheDataEXT;
+ }
+#endif
+#ifdef VK_EXT_external_memory_host
+ if (!strcmp(name, "vkGetMemoryHostPointerPropertiesEXT"))
+ {
+ return (void*)entry_vkGetMemoryHostPointerPropertiesEXT;
+ }
+#endif
+#ifdef VK_AMD_buffer_marker
+ if (!strcmp(name, "vkCmdWriteBufferMarkerAMD"))
+ {
+ return (void*)entry_vkCmdWriteBufferMarkerAMD;
+ }
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+ if (!strcmp(name, "vkCmdSetCheckpointNV"))
+ {
+ return (void*)entry_vkCmdSetCheckpointNV;
+ }
+ if (!strcmp(name, "vkGetQueueCheckpointDataNV"))
+ {
+ return (void*)entry_vkGetQueueCheckpointDataNV;
+ }
+#endif
+ return nullptr;
+}
+
+} // namespace goldfish_vk
diff --git a/system/vulkan/func_table.h b/system/vulkan/func_table.h
new file mode 100644
index 0000000..3db8b8d
--- /dev/null
+++ b/system/vulkan/func_table.h
@@ -0,0 +1,279 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Autogenerated module func_table
+// (header) 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
+// Please do not modify directly;
+// re-run android/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+
+#pragma once
+
+#include <vulkan/vulkan.h>
+
+
+
+namespace goldfish_vk {
+
+#ifdef VK_VERSION_1_0
+#endif
+#ifdef VK_VERSION_1_1
+#endif
+#ifdef VK_KHR_surface
+#endif
+#ifdef VK_KHR_swapchain
+#endif
+#ifdef VK_KHR_display
+#endif
+#ifdef VK_KHR_display_swapchain
+#endif
+#ifdef VK_KHR_xlib_surface
+#endif
+#ifdef VK_KHR_xcb_surface
+#endif
+#ifdef VK_KHR_wayland_surface
+#endif
+#ifdef VK_KHR_mir_surface
+#endif
+#ifdef VK_KHR_android_surface
+#endif
+#ifdef VK_KHR_win32_surface
+#endif
+#ifdef VK_KHR_sampler_mirror_clamp_to_edge
+#endif
+#ifdef VK_KHR_multiview
+#endif
+#ifdef VK_KHR_get_physical_device_properties2
+#endif
+#ifdef VK_KHR_device_group
+#endif
+#ifdef VK_KHR_shader_draw_parameters
+#endif
+#ifdef VK_KHR_maintenance1
+#endif
+#ifdef VK_KHR_device_group_creation
+#endif
+#ifdef VK_KHR_external_memory_capabilities
+#endif
+#ifdef VK_KHR_external_memory
+#endif
+#ifdef VK_KHR_external_memory_win32
+#endif
+#ifdef VK_KHR_external_memory_fd
+#endif
+#ifdef VK_KHR_win32_keyed_mutex
+#endif
+#ifdef VK_KHR_external_semaphore_capabilities
+#endif
+#ifdef VK_KHR_external_semaphore
+#endif
+#ifdef VK_KHR_external_semaphore_win32
+#endif
+#ifdef VK_KHR_external_semaphore_fd
+#endif
+#ifdef VK_KHR_push_descriptor
+#endif
+#ifdef VK_KHR_16bit_storage
+#endif
+#ifdef VK_KHR_incremental_present
+#endif
+#ifdef VK_KHR_descriptor_update_template
+#endif
+#ifdef VK_KHR_create_renderpass2
+#endif
+#ifdef VK_KHR_shared_presentable_image
+#endif
+#ifdef VK_KHR_external_fence_capabilities
+#endif
+#ifdef VK_KHR_external_fence
+#endif
+#ifdef VK_KHR_external_fence_win32
+#endif
+#ifdef VK_KHR_external_fence_fd
+#endif
+#ifdef VK_KHR_maintenance2
+#endif
+#ifdef VK_KHR_get_surface_capabilities2
+#endif
+#ifdef VK_KHR_variable_pointers
+#endif
+#ifdef VK_KHR_get_display_properties2
+#endif
+#ifdef VK_KHR_dedicated_allocation
+#endif
+#ifdef VK_KHR_storage_buffer_storage_class
+#endif
+#ifdef VK_KHR_relaxed_block_layout
+#endif
+#ifdef VK_KHR_get_memory_requirements2
+#endif
+#ifdef VK_KHR_image_format_list
+#endif
+#ifdef VK_KHR_sampler_ycbcr_conversion
+#endif
+#ifdef VK_KHR_bind_memory2
+#endif
+#ifdef VK_KHR_maintenance3
+#endif
+#ifdef VK_KHR_draw_indirect_count
+#endif
+#ifdef VK_KHR_8bit_storage
+#endif
+#ifdef VK_EXT_debug_report
+#endif
+#ifdef VK_NV_glsl_shader
+#endif
+#ifdef VK_EXT_depth_range_unrestricted
+#endif
+#ifdef VK_IMG_filter_cubic
+#endif
+#ifdef VK_AMD_rasterization_order
+#endif
+#ifdef VK_AMD_shader_trinary_minmax
+#endif
+#ifdef VK_AMD_shader_explicit_vertex_parameter
+#endif
+#ifdef VK_EXT_debug_marker
+#endif
+#ifdef VK_AMD_gcn_shader
+#endif
+#ifdef VK_NV_dedicated_allocation
+#endif
+#ifdef VK_AMD_draw_indirect_count
+#endif
+#ifdef VK_AMD_negative_viewport_height
+#endif
+#ifdef VK_AMD_gpu_shader_half_float
+#endif
+#ifdef VK_AMD_shader_ballot
+#endif
+#ifdef VK_AMD_texture_gather_bias_lod
+#endif
+#ifdef VK_AMD_shader_info
+#endif
+#ifdef VK_AMD_shader_image_load_store_lod
+#endif
+#ifdef VK_IMG_format_pvrtc
+#endif
+#ifdef VK_NV_external_memory_capabilities
+#endif
+#ifdef VK_NV_external_memory
+#endif
+#ifdef VK_NV_external_memory_win32
+#endif
+#ifdef VK_NV_win32_keyed_mutex
+#endif
+#ifdef VK_EXT_validation_flags
+#endif
+#ifdef VK_NN_vi_surface
+#endif
+#ifdef VK_EXT_shader_subgroup_ballot
+#endif
+#ifdef VK_EXT_shader_subgroup_vote
+#endif
+#ifdef VK_EXT_conditional_rendering
+#endif
+#ifdef VK_NVX_device_generated_commands
+#endif
+#ifdef VK_NV_clip_space_w_scaling
+#endif
+#ifdef VK_EXT_direct_mode_display
+#endif
+#ifdef VK_EXT_acquire_xlib_display
+#endif
+#ifdef VK_EXT_display_surface_counter
+#endif
+#ifdef VK_EXT_display_control
+#endif
+#ifdef VK_GOOGLE_display_timing
+#endif
+#ifdef VK_NV_sample_mask_override_coverage
+#endif
+#ifdef VK_NV_geometry_shader_passthrough
+#endif
+#ifdef VK_NV_viewport_array2
+#endif
+#ifdef VK_NVX_multiview_per_view_attributes
+#endif
+#ifdef VK_NV_viewport_swizzle
+#endif
+#ifdef VK_EXT_discard_rectangles
+#endif
+#ifdef VK_EXT_conservative_rasterization
+#endif
+#ifdef VK_EXT_swapchain_colorspace
+#endif
+#ifdef VK_EXT_hdr_metadata
+#endif
+#ifdef VK_MVK_ios_surface
+#endif
+#ifdef VK_MVK_macos_surface
+#endif
+#ifdef VK_EXT_external_memory_dma_buf
+#endif
+#ifdef VK_EXT_queue_family_foreign
+#endif
+#ifdef VK_EXT_debug_utils
+#endif
+#ifdef VK_ANDROID_external_memory_android_hardware_buffer
+#endif
+#ifdef VK_EXT_sampler_filter_minmax
+#endif
+#ifdef VK_AMD_gpu_shader_int16
+#endif
+#ifdef VK_AMD_mixed_attachment_samples
+#endif
+#ifdef VK_AMD_shader_fragment_mask
+#endif
+#ifdef VK_EXT_shader_stencil_export
+#endif
+#ifdef VK_EXT_sample_locations
+#endif
+#ifdef VK_EXT_blend_operation_advanced
+#endif
+#ifdef VK_NV_fragment_coverage_to_color
+#endif
+#ifdef VK_NV_framebuffer_mixed_samples
+#endif
+#ifdef VK_NV_fill_rectangle
+#endif
+#ifdef VK_EXT_post_depth_coverage
+#endif
+#ifdef VK_EXT_validation_cache
+#endif
+#ifdef VK_EXT_descriptor_indexing
+#endif
+#ifdef VK_EXT_shader_viewport_index_layer
+#endif
+#ifdef VK_EXT_global_priority
+#endif
+#ifdef VK_EXT_external_memory_host
+#endif
+#ifdef VK_AMD_buffer_marker
+#endif
+#ifdef VK_AMD_shader_core_properties
+#endif
+#ifdef VK_EXT_vertex_attribute_divisor
+#endif
+#ifdef VK_NV_shader_subgroup_partitioned
+#endif
+#ifdef VK_NV_device_diagnostic_checkpoints
+#endif
+void* goldfish_vulkan_get_proc_address(const char* name);
+
+} // namespace goldfish_vk
diff --git a/system/vulkan/goldfish_vulkan.cpp b/system/vulkan/goldfish_vulkan.cpp
index 96466df..1c0471f 100644
--- a/system/vulkan/goldfish_vulkan.cpp
+++ b/system/vulkan/goldfish_vulkan.cpp
@@ -21,6 +21,8 @@
#include "HostConnection.h"
#include "VkEncoder.h"
+#include "func_table.h"
+
namespace {
int OpenDevice(const hw_module_t* module, const char* id, hw_device_t** device);
@@ -95,12 +97,22 @@
ALOGD("%s: goldfish vkCreateInstance\n", __func__);
VK_HOST_CONNECTION;
- return VK_ERROR_OUT_OF_HOST_MEMORY;
+ VkResult res = vkEnc->vkCreateInstance(create_info, nullptr, out_instance);
+
+ return res;
}
VKAPI_ATTR
PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* name) {
- return nullptr;
+ (void)instance;
+
+ if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) {
+ return (PFN_vkVoidFunction)EnumerateInstanceExtensionProperties;
+ }
+ if (!strcmp(name, "vkCreateInstance")) {
+ return (PFN_vkVoidFunction)CreateInstance;
+ }
+ return (PFN_vkVoidFunction)(goldfish_vk::goldfish_vulkan_get_proc_address(name));
}
hwvulkan_device_t goldfish_vulkan_device = {
