diff --git a/patches/patchinstall.sh b/patches/patchinstall.sh index fb2fbe21..e952219d 100755 --- a/patches/patchinstall.sh +++ b/patches/patchinstall.sh @@ -338,6 +338,7 @@ patch_enable_all () enable_version_GetFileVersionInfoSizeExW="$1" enable_version_VerFindFileA="$1" enable_version_VerQueryValue="$1" + enable_vulkan_Vulkan_Implementation="$1" enable_wbemdisp_ISWbemSecurity="$1" enable_widl_SLTG_Typelib_Support="$1" enable_windowscodecs_32bppGrayFloat="$1" @@ -1182,6 +1183,9 @@ patch_enable () version-VerQueryValue) enable_version_VerQueryValue="$2" ;; + vulkan-Vulkan_Implementation) + enable_vulkan_Vulkan_Implementation="$2" + ;; wbemdisp-ISWbemSecurity) enable_wbemdisp_ISWbemSecurity="$2" ;; @@ -6833,6 +6837,22 @@ if test "$enable_version_VerQueryValue" -eq 1; then ) >> "$patchlist" fi +# Patchset vulkan-Vulkan_Implementation +# | +# | This patchset fixes the following Wine bugs: +# | * [#40164] Implement support for Vulkan +# | +# | Modified files: +# | * configure.ac, dlls/vulkan-1/Makefile.in, dlls/vulkan-1/vulkan-1.spec, dlls/vulkan/Makefile.in, dlls/vulkan/vulkan.spec, +# | dlls/vulkan/vulkan_main.c, dlls/vulkan/vulkan_private.h, dlls/vulkan/vulkan_thunks.c +# | +if test "$enable_vulkan_Vulkan_Implementation" -eq 1; then + patch_apply vulkan-Vulkan_Implementation/0001-vulkan-Initial-implementation.patch + ( + echo '+ { "Sebastian Lackner", "vulkan: Initial implementation.", 1 },'; + ) >> "$patchlist" +fi + # Patchset wbemdisp-ISWbemSecurity # | # | Modified files: diff --git a/patches/vulkan-Vulkan_Implementation/0001-vulkan-Initial-implementation.patch b/patches/vulkan-Vulkan_Implementation/0001-vulkan-Initial-implementation.patch new file mode 100644 index 00000000..6f882473 --- /dev/null +++ b/patches/vulkan-Vulkan_Implementation/0001-vulkan-Initial-implementation.patch @@ -0,0 +1,10659 @@ +From cf24f42b278183e732542925177a0b3cf405dfc7 Mon Sep 17 00:00:00 2001 +From: Sebastian Lackner +Date: Sat, 19 Mar 2016 00:42:10 +0100 +Subject: vulkan: Initial implementation. + +--- + configure.ac | 14 + + dlls/vulkan-1/Makefile.in | 1 + + dlls/vulkan-1/vulkan-1.spec | 160 + + dlls/vulkan/Makefile.in | 8 + + dlls/vulkan/vulkan.spec | 160 + + dlls/vulkan/vulkan_main.c | 327 +++ + dlls/vulkan/vulkan_private.h | 3296 +++++++++++++++++++++ + dlls/vulkan/vulkan_thunks.c | 6593 ++++++++++++++++++++++++++++++++++++++++++ + 8 files changed, 10559 insertions(+) + create mode 100644 dlls/vulkan-1/Makefile.in + create mode 100644 dlls/vulkan-1/vulkan-1.spec + create mode 100644 dlls/vulkan/Makefile.in + create mode 100644 dlls/vulkan/vulkan.spec + create mode 100644 dlls/vulkan/vulkan_main.c + create mode 100644 dlls/vulkan/vulkan_private.h + create mode 100644 dlls/vulkan/vulkan_thunks.c + +diff --git a/configure.ac b/configure.ac +index 77c54c8..149ec4c 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -985,6 +985,7 @@ then + + dnl *** All of the following tests require X11/Xlib.h + AC_CHECK_HEADERS([X11/Xlib.h \ ++ X11/Xlib-xcb.h \ + X11/XKBlib.h \ + X11/Xutil.h \ + X11/Xcursor/Xcursor.h \ +@@ -1108,6 +1109,14 @@ then + WINE_NOTICE_WITH(xcomposite,[test "x$ac_cv_lib_soname_Xcomposite" = "x"], + [libxcomposite ${notice_platform}development files not found, Xcomposite won't be supported.]) + ++ dnl *** Check for XCB extension ++ if test "$ac_cv_header_X11_Xlib_xcb_h" = "yes" ++ then ++ WINE_CHECK_SONAME(X11-xcb,XGetXCBConnection,,,[$X_LIBS $X_EXTRA_LIBS]) ++ fi ++ WINE_NOTICE_WITH(X11-xcb,[test "x$ac_cv_lib_soname_X11_xcb" = "x"], ++ [X11-xcb ${notice_platform}development files not found, the XCB extension won't be supported.]) ++ + dnl *** Check for XICCallback struct + AC_CHECK_MEMBERS([XICCallback.callback, XEvent.xcookie],,, + [#ifdef HAVE_X11_XLIB_H +@@ -1160,6 +1169,9 @@ without X support, which probably isn't what you want. You will need + to install ${notice_platform}development packages of Xlib/Xfree86 at the very least.], + [enable_winex11_drv]) + ++test "x$X_LIBS" = "x" && enable_vulkan=${enable_vulkan:-no} ++test "x$X_LIBS" = "x" && enable_vulkan_1=${enable_vulkan_1:-no} ++ + test "x$ac_cv_lib_GLU_gluLookAt" != xyes && enable_glu32=${enable_glu32:-no} + + dnl **** Check for OpenCL **** +@@ -3310,6 +3322,8 @@ WINE_CONFIG_DLL(vnbt.vxd,enable_win16) + WINE_CONFIG_DLL(vnetbios.vxd,enable_win16) + WINE_CONFIG_DLL(vssapi) + WINE_CONFIG_DLL(vtdapi.vxd,enable_win16) ++WINE_CONFIG_DLL(vulkan-1) ++WINE_CONFIG_DLL(vulkan) + WINE_CONFIG_DLL(vwin32.vxd,enable_win16) + WINE_CONFIG_DLL(w32skrnl,enable_win16) + WINE_CONFIG_DLL(w32sys.dll16,enable_win16) +diff --git a/dlls/vulkan-1/Makefile.in b/dlls/vulkan-1/Makefile.in +new file mode 100644 +index 0000000..4960141 +--- /dev/null ++++ b/dlls/vulkan-1/Makefile.in +@@ -0,0 +1 @@ ++MODULE = vulkan-1.dll +diff --git a/dlls/vulkan-1/vulkan-1.spec b/dlls/vulkan-1/vulkan-1.spec +new file mode 100644 +index 0000000..51bcfff +--- /dev/null ++++ b/dlls/vulkan-1/vulkan-1.spec +@@ -0,0 +1,160 @@ ++@ stdcall vkAcquireNextImageKHR(ptr int64 int64 int64 int64 ptr) vulkan.vkAcquireNextImageKHR ++@ stdcall vkAllocateCommandBuffers(ptr ptr ptr) vulkan.vkAllocateCommandBuffers ++@ stdcall vkAllocateDescriptorSets(ptr ptr ptr) vulkan.vkAllocateDescriptorSets ++@ stdcall vkAllocateMemory(ptr ptr ptr ptr) vulkan.vkAllocateMemory ++@ stdcall vkBeginCommandBuffer(ptr ptr) vulkan.vkBeginCommandBuffer ++@ stdcall vkBindBufferMemory(ptr int64 int64 int64) vulkan.vkBindBufferMemory ++@ stdcall vkBindImageMemory(ptr int64 int64 int64) vulkan.vkBindImageMemory ++@ stdcall vkCmdBeginQuery(ptr int64 long long) vulkan.vkCmdBeginQuery ++@ stdcall vkCmdBeginRenderPass(ptr ptr long) vulkan.vkCmdBeginRenderPass ++@ stdcall vkCmdBindDescriptorSets(ptr long int64 long long ptr long ptr) vulkan.vkCmdBindDescriptorSets ++@ stdcall vkCmdBindIndexBuffer(ptr int64 int64 long) vulkan.vkCmdBindIndexBuffer ++@ stdcall vkCmdBindPipeline(ptr long int64) vulkan.vkCmdBindPipeline ++@ stdcall vkCmdBindVertexBuffers(ptr long long ptr ptr) vulkan.vkCmdBindVertexBuffers ++@ stdcall vkCmdBlitImage(ptr int64 long int64 long long ptr long) vulkan.vkCmdBlitImage ++@ stdcall vkCmdClearAttachments(ptr long ptr long ptr) vulkan.vkCmdClearAttachments ++@ stdcall vkCmdClearColorImage(ptr int64 long ptr long ptr) vulkan.vkCmdClearColorImage ++@ stdcall vkCmdClearDepthStencilImage(ptr int64 long ptr long ptr) vulkan.vkCmdClearDepthStencilImage ++@ stdcall vkCmdCopyBuffer(ptr int64 int64 long ptr) vulkan.vkCmdCopyBuffer ++@ stdcall vkCmdCopyBufferToImage(ptr int64 int64 long long ptr) vulkan.vkCmdCopyBufferToImage ++@ stdcall vkCmdCopyImage(ptr int64 long int64 long long ptr) vulkan.vkCmdCopyImage ++@ stdcall vkCmdCopyImageToBuffer(ptr int64 long int64 long ptr) vulkan.vkCmdCopyImageToBuffer ++@ stdcall vkCmdCopyQueryPoolResults(ptr int64 long long int64 int64 int64 long) vulkan.vkCmdCopyQueryPoolResults ++@ stdcall vkCmdDispatch(ptr long long long) vulkan.vkCmdDispatch ++@ stdcall vkCmdDispatchIndirect(ptr int64 int64) vulkan.vkCmdDispatchIndirect ++@ stdcall vkCmdDraw(ptr long long long long) vulkan.vkCmdDraw ++@ stdcall vkCmdDrawIndexed(ptr long long long long long) vulkan.vkCmdDrawIndexed ++@ stdcall vkCmdDrawIndexedIndirect(ptr int64 int64 long long) vulkan.vkCmdDrawIndexedIndirect ++@ stdcall vkCmdDrawIndirect(ptr int64 int64 long long) vulkan.vkCmdDrawIndirect ++@ stdcall vkCmdEndQuery(ptr int64 long) vulkan.vkCmdEndQuery ++@ stdcall vkCmdEndRenderPass(ptr) vulkan.vkCmdEndRenderPass ++@ stdcall vkCmdExecuteCommands(ptr long ptr) vulkan.vkCmdExecuteCommands ++@ stdcall vkCmdFillBuffer(ptr int64 int64 int64 long) vulkan.vkCmdFillBuffer ++@ stdcall vkCmdNextSubpass(ptr long) vulkan.vkCmdNextSubpass ++@ stdcall vkCmdPipelineBarrier(ptr long long long long ptr long ptr long ptr) vulkan.vkCmdPipelineBarrier ++@ stdcall vkCmdPushConstants(ptr int64 long long long ptr) vulkan.vkCmdPushConstants ++@ stdcall vkCmdResetEvent(ptr int64 long) vulkan.vkCmdResetEvent ++@ stdcall vkCmdResetQueryPool(ptr int64 long long) vulkan.vkCmdResetQueryPool ++@ stdcall vkCmdResolveImage(ptr int64 long int64 long long ptr) vulkan.vkCmdResolveImage ++@ stdcall vkCmdSetBlendConstants(ptr ptr) vulkan.vkCmdSetBlendConstants ++@ stdcall vkCmdSetDepthBias(ptr float float float) vulkan.vkCmdSetDepthBias ++@ stdcall vkCmdSetDepthBounds(ptr float float) vulkan.vkCmdSetDepthBounds ++@ stdcall vkCmdSetEvent(ptr int64 long) vulkan.vkCmdSetEvent ++@ stdcall vkCmdSetLineWidth(ptr float) vulkan.vkCmdSetLineWidth ++@ stdcall vkCmdSetScissor(ptr long long ptr) vulkan.vkCmdSetScissor ++@ stdcall vkCmdSetStencilCompareMask(ptr long long) vulkan.vkCmdSetStencilCompareMask ++@ stdcall vkCmdSetStencilReference(ptr long long) vulkan.vkCmdSetStencilReference ++@ stdcall vkCmdSetStencilWriteMask(ptr long long) vulkan.vkCmdSetStencilWriteMask ++@ stdcall vkCmdSetViewport(ptr long long ptr) vulkan.vkCmdSetViewport ++@ stdcall vkCmdUpdateBuffer(ptr int64 int64 int64 ptr) vulkan.vkCmdUpdateBuffer ++@ stdcall vkCmdWaitEvents(ptr long ptr long long long ptr long ptr long ptr) vulkan.vkCmdWaitEvents ++@ stdcall vkCmdWriteTimestamp(ptr long int64 long) vulkan.vkCmdWriteTimestamp ++@ stdcall vkCreateBuffer(ptr ptr ptr ptr) vulkan.vkCreateBuffer ++@ stdcall vkCreateBufferView(ptr ptr ptr ptr) vulkan.vkCreateBufferView ++@ stdcall vkCreateCommandPool(ptr ptr ptr ptr) vulkan.vkCreateCommandPool ++@ stdcall vkCreateComputePipelines(ptr int64 long ptr ptr ptr) vulkan.vkCreateComputePipelines ++@ stdcall vkCreateDebugReportCallbackEXT(ptr ptr ptr ptr) vulkan.vkCreateDebugReportCallbackEXT ++@ stdcall vkCreateDescriptorPool(ptr ptr ptr ptr) vulkan.vkCreateDescriptorPool ++@ stdcall vkCreateDescriptorSetLayout(ptr ptr ptr ptr) vulkan.vkCreateDescriptorSetLayout ++@ stdcall vkCreateDevice(ptr ptr ptr ptr) vulkan.vkCreateDevice ++@ stdcall vkCreateDisplayModeKHR(ptr int64 ptr ptr ptr) vulkan.vkCreateDisplayModeKHR ++@ stdcall vkCreateDisplayPlaneSurfaceKHR(ptr ptr ptr ptr) vulkan.vkCreateDisplayPlaneSurfaceKHR ++@ stdcall vkCreateEvent(ptr ptr ptr ptr) vulkan.vkCreateEvent ++@ stdcall vkCreateFence(ptr ptr ptr ptr) vulkan.vkCreateFence ++@ stdcall vkCreateFramebuffer(ptr ptr ptr ptr) vulkan.vkCreateFramebuffer ++@ stdcall vkCreateGraphicsPipelines(ptr int64 long ptr ptr ptr) vulkan.vkCreateGraphicsPipelines ++@ stdcall vkCreateImage(ptr ptr ptr ptr) vulkan.vkCreateImage ++@ stdcall vkCreateImageView(ptr ptr ptr ptr) vulkan.vkCreateImageView ++@ stdcall vkCreateInstance(ptr ptr ptr) vulkan.vkCreateInstance ++@ stdcall vkCreatePipelineCache(ptr ptr ptr ptr) vulkan.vkCreatePipelineCache ++@ stdcall vkCreatePipelineLayout(ptr ptr ptr ptr) vulkan.vkCreatePipelineLayout ++@ stdcall vkCreateQueryPool(ptr ptr ptr ptr) vulkan.vkCreateQueryPool ++@ stdcall vkCreateRenderPass(ptr ptr ptr ptr) vulkan.vkCreateRenderPass ++@ stdcall vkCreateSampler(ptr ptr ptr ptr) vulkan.vkCreateSampler ++@ stdcall vkCreateSemaphore(ptr ptr ptr ptr) vulkan.vkCreateSemaphore ++@ stdcall vkCreateShaderModule(ptr ptr ptr ptr) vulkan.vkCreateShaderModule ++@ stdcall vkCreateSharedSwapchainsKHR(ptr long ptr ptr ptr) vulkan.vkCreateSharedSwapchainsKHR ++@ stdcall vkCreateSwapchainKHR(ptr ptr ptr ptr) vulkan.vkCreateSwapchainKHR ++@ stdcall vkCreateWin32SurfaceKHR(ptr ptr ptr ptr) vulkan.vkCreateWin32SurfaceKHR ++@ stdcall vkDebugReportMessageEXT(ptr long long int64 long long str str) vulkan.vkDebugReportMessageEXT ++@ stdcall vkDestroyBuffer(ptr int64 ptr) vulkan.vkDestroyBuffer ++@ stdcall vkDestroyBufferView(ptr int64 ptr) vulkan.vkDestroyBufferView ++@ stdcall vkDestroyCommandPool(ptr int64 ptr) vulkan.vkDestroyCommandPool ++@ stdcall vkDestroyDebugReportCallbackEXT(ptr int64 ptr) vulkan.vkDestroyDebugReportCallbackEXT ++@ stdcall vkDestroyDescriptorPool(ptr int64 ptr) vulkan.vkDestroyDescriptorPool ++@ stdcall vkDestroyDescriptorSetLayout(ptr int64 ptr) vulkan.vkDestroyDescriptorSetLayout ++@ stdcall vkDestroyDevice(ptr ptr) vulkan.vkDestroyDevice ++@ stdcall vkDestroyEvent(ptr int64 ptr) vulkan.vkDestroyEvent ++@ stdcall vkDestroyFence(ptr int64 ptr) vulkan.vkDestroyFence ++@ stdcall vkDestroyFramebuffer(ptr int64 ptr) vulkan.vkDestroyFramebuffer ++@ stdcall vkDestroyImage(ptr int64 ptr) vulkan.vkDestroyImage ++@ stdcall vkDestroyImageView(ptr int64 ptr) vulkan.vkDestroyImageView ++@ stdcall vkDestroyInstance(ptr ptr) vulkan.vkDestroyInstance ++@ stdcall vkDestroyPipeline(ptr int64 ptr) vulkan.vkDestroyPipeline ++@ stdcall vkDestroyPipelineCache(ptr int64 ptr) vulkan.vkDestroyPipelineCache ++@ stdcall vkDestroyPipelineLayout(ptr int64 ptr) vulkan.vkDestroyPipelineLayout ++@ stdcall vkDestroyQueryPool(ptr int64 ptr) vulkan.vkDestroyQueryPool ++@ stdcall vkDestroyRenderPass(ptr int64 ptr) vulkan.vkDestroyRenderPass ++@ stdcall vkDestroySampler(ptr int64 ptr) vulkan.vkDestroySampler ++@ stdcall vkDestroySemaphore(ptr int64 ptr) vulkan.vkDestroySemaphore ++@ stdcall vkDestroyShaderModule(ptr int64 ptr) vulkan.vkDestroyShaderModule ++@ stdcall vkDestroySurfaceKHR(ptr int64 ptr) vulkan.vkDestroySurfaceKHR ++@ stdcall vkDestroySwapchainKHR(ptr int64 ptr) vulkan.vkDestroySwapchainKHR ++@ stdcall vkDeviceWaitIdle(ptr) vulkan.vkDeviceWaitIdle ++@ stdcall vkEndCommandBuffer(ptr) vulkan.vkEndCommandBuffer ++@ stdcall vkEnumerateDeviceExtensionProperties(ptr str ptr ptr) vulkan.vkEnumerateDeviceExtensionProperties ++@ stdcall vkEnumerateDeviceLayerProperties(ptr ptr ptr) vulkan.vkEnumerateDeviceLayerProperties ++@ stdcall vkEnumerateInstanceExtensionProperties(str ptr ptr) vulkan.vkEnumerateInstanceExtensionProperties ++@ stdcall vkEnumerateInstanceLayerProperties(ptr ptr) vulkan.vkEnumerateInstanceLayerProperties ++@ stdcall vkEnumeratePhysicalDevices(ptr ptr ptr) vulkan.vkEnumeratePhysicalDevices ++@ stdcall vkFlushMappedMemoryRanges(ptr long ptr) vulkan.vkFlushMappedMemoryRanges ++@ stdcall vkFreeCommandBuffers(ptr int64 long ptr) vulkan.vkFreeCommandBuffers ++@ stdcall vkFreeDescriptorSets(ptr int64 long ptr) vulkan.vkFreeDescriptorSets ++@ stdcall vkFreeMemory(ptr int64 ptr) vulkan.vkFreeMemory ++@ stdcall vkGetBufferMemoryRequirements(ptr int64 ptr) vulkan.vkGetBufferMemoryRequirements ++@ stdcall vkGetDeviceMemoryCommitment(ptr int64 ptr) vulkan.vkGetDeviceMemoryCommitment ++@ stdcall vkGetDeviceProcAddr(ptr str) vulkan.vkGetDeviceProcAddr ++@ stdcall vkGetDeviceQueue(ptr long long ptr) vulkan.vkGetDeviceQueue ++@ stdcall vkGetDisplayModePropertiesKHR(ptr int64 ptr ptr) vulkan.vkGetDisplayModePropertiesKHR ++@ stdcall vkGetDisplayPlaneCapabilitiesKHR(ptr int64 long ptr) vulkan.vkGetDisplayPlaneCapabilitiesKHR ++@ stdcall vkGetDisplayPlaneSupportedDisplaysKHR(ptr long ptr ptr) vulkan.vkGetDisplayPlaneSupportedDisplaysKHR ++@ stdcall vkGetEventStatus(ptr int64) vulkan.vkGetEventStatus ++@ stdcall vkGetFenceStatus(ptr int64) vulkan.vkGetFenceStatus ++@ stdcall vkGetImageMemoryRequirements(ptr int64 ptr) vulkan.vkGetImageMemoryRequirements ++@ stdcall vkGetImageSparseMemoryRequirements(ptr int64 ptr ptr) vulkan.vkGetImageSparseMemoryRequirements ++@ stdcall vkGetImageSubresourceLayout(ptr int64 ptr ptr) vulkan.vkGetImageSubresourceLayout ++@ stdcall vkGetInstanceProcAddr(ptr str) vulkan.vkGetInstanceProcAddr ++@ stdcall vkGetPhysicalDeviceDisplayPlanePropertiesKHR(ptr ptr ptr) vulkan.vkGetPhysicalDeviceDisplayPlanePropertiesKHR ++@ stdcall vkGetPhysicalDeviceDisplayPropertiesKHR(ptr ptr ptr) vulkan.vkGetPhysicalDeviceDisplayPropertiesKHR ++@ stdcall vkGetPhysicalDeviceFeatures(ptr ptr) vulkan.vkGetPhysicalDeviceFeatures ++@ stdcall vkGetPhysicalDeviceFormatProperties(ptr long ptr) vulkan.vkGetPhysicalDeviceFormatProperties ++@ stdcall vkGetPhysicalDeviceImageFormatProperties(ptr long long long long long ptr) vulkan.vkGetPhysicalDeviceImageFormatProperties ++@ stdcall vkGetPhysicalDeviceMemoryProperties(ptr ptr) vulkan.vkGetPhysicalDeviceMemoryProperties ++@ stdcall vkGetPhysicalDeviceProperties(ptr ptr) vulkan.vkGetPhysicalDeviceProperties ++@ stdcall vkGetPhysicalDeviceQueueFamilyProperties(ptr ptr ptr) vulkan.vkGetPhysicalDeviceQueueFamilyProperties ++@ stdcall vkGetPhysicalDeviceSparseImageFormatProperties(ptr long long long long long ptr ptr) vulkan.vkGetPhysicalDeviceSparseImageFormatProperties ++@ stdcall vkGetPhysicalDeviceSurfaceCapabilitiesKHR(ptr int64 ptr) vulkan.vkGetPhysicalDeviceSurfaceCapabilitiesKHR ++@ stdcall vkGetPhysicalDeviceSurfaceFormatsKHR(ptr int64 ptr ptr) vulkan.vkGetPhysicalDeviceSurfaceFormatsKHR ++@ stdcall vkGetPhysicalDeviceSurfacePresentModesKHR(ptr int64 ptr ptr) vulkan.vkGetPhysicalDeviceSurfacePresentModesKHR ++@ stdcall vkGetPhysicalDeviceSurfaceSupportKHR(ptr long int64 ptr) vulkan.vkGetPhysicalDeviceSurfaceSupportKHR ++@ stdcall vkGetPhysicalDeviceWin32PresentationSupportKHR(ptr long) vulkan.vkGetPhysicalDeviceWin32PresentationSupportKHR ++@ stdcall vkGetPipelineCacheData(ptr int64 ptr ptr) vulkan.vkGetPipelineCacheData ++@ stdcall vkGetQueryPoolResults(ptr int64 long long long ptr int64 long) vulkan.vkGetQueryPoolResults ++@ stdcall vkGetRenderAreaGranularity(ptr int64 ptr) vulkan.vkGetRenderAreaGranularity ++@ stdcall vkGetSwapchainImagesKHR(ptr int64 ptr ptr) vulkan.vkGetSwapchainImagesKHR ++@ stdcall vkInvalidateMappedMemoryRanges(ptr long ptr) vulkan.vkInvalidateMappedMemoryRanges ++@ stdcall vkMapMemory(ptr int64 int64 int64 long ptr) vulkan.vkMapMemory ++@ stdcall vkMergePipelineCaches(ptr int64 long ptr) vulkan.vkMergePipelineCaches ++@ stdcall vkQueueBindSparse(ptr long ptr int64) vulkan.vkQueueBindSparse ++@ stdcall vkQueuePresentKHR(ptr ptr) vulkan.vkQueuePresentKHR ++@ stdcall vkQueueSubmit(ptr long ptr int64) vulkan.vkQueueSubmit ++@ stdcall vkQueueWaitIdle(ptr) vulkan.vkQueueWaitIdle ++@ stdcall vkResetCommandBuffer(ptr long) vulkan.vkResetCommandBuffer ++@ stdcall vkResetCommandPool(ptr int64 long) vulkan.vkResetCommandPool ++@ stdcall vkResetDescriptorPool(ptr int64 long) vulkan.vkResetDescriptorPool ++@ stdcall vkResetEvent(ptr int64) vulkan.vkResetEvent ++@ stdcall vkResetFences(ptr long ptr) vulkan.vkResetFences ++@ stdcall vkSetEvent(ptr int64) vulkan.vkSetEvent ++@ stdcall vkUnmapMemory(ptr int64) vulkan.vkUnmapMemory ++@ stdcall vkUpdateDescriptorSets(ptr long ptr long ptr) vulkan.vkUpdateDescriptorSets ++@ stdcall vkWaitForFences(ptr long ptr long int64) vulkan.vkWaitForFences +diff --git a/dlls/vulkan/Makefile.in b/dlls/vulkan/Makefile.in +new file mode 100644 +index 0000000..7ee6d18 +--- /dev/null ++++ b/dlls/vulkan/Makefile.in +@@ -0,0 +1,8 @@ ++MODULE = vulkan.dll ++IMPORTS = user32 ++EXTRAINCL = $(X_CFLAGS) ++EXTRALIBS = $(X_LIBS) $(X_EXTRA_LIBS) ++ ++C_SRCS = \ ++ vulkan_main.c \ ++ vulkan_thunks.c +diff --git a/dlls/vulkan/vulkan.spec b/dlls/vulkan/vulkan.spec +new file mode 100644 +index 0000000..9b689ad +--- /dev/null ++++ b/dlls/vulkan/vulkan.spec +@@ -0,0 +1,160 @@ ++@ stdcall vkAcquireNextImageKHR(ptr int64 int64 int64 int64 ptr) ++@ stdcall vkAllocateCommandBuffers(ptr ptr ptr) ++@ stdcall vkAllocateDescriptorSets(ptr ptr ptr) ++@ stdcall vkAllocateMemory(ptr ptr ptr ptr) ++@ stdcall vkBeginCommandBuffer(ptr ptr) ++@ stdcall vkBindBufferMemory(ptr int64 int64 int64) ++@ stdcall vkBindImageMemory(ptr int64 int64 int64) ++@ stdcall vkCmdBeginQuery(ptr int64 long long) ++@ stdcall vkCmdBeginRenderPass(ptr ptr long) ++@ stdcall vkCmdBindDescriptorSets(ptr long int64 long long ptr long ptr) ++@ stdcall vkCmdBindIndexBuffer(ptr int64 int64 long) ++@ stdcall vkCmdBindPipeline(ptr long int64) ++@ stdcall vkCmdBindVertexBuffers(ptr long long ptr ptr) ++@ stdcall vkCmdBlitImage(ptr int64 long int64 long long ptr long) ++@ stdcall vkCmdClearAttachments(ptr long ptr long ptr) ++@ stdcall vkCmdClearColorImage(ptr int64 long ptr long ptr) ++@ stdcall vkCmdClearDepthStencilImage(ptr int64 long ptr long ptr) ++@ stdcall vkCmdCopyBuffer(ptr int64 int64 long ptr) ++@ stdcall vkCmdCopyBufferToImage(ptr int64 int64 long long ptr) ++@ stdcall vkCmdCopyImage(ptr int64 long int64 long long ptr) ++@ stdcall vkCmdCopyImageToBuffer(ptr int64 long int64 long ptr) ++@ stdcall vkCmdCopyQueryPoolResults(ptr int64 long long int64 int64 int64 long) ++@ stdcall vkCmdDispatch(ptr long long long) ++@ stdcall vkCmdDispatchIndirect(ptr int64 int64) ++@ stdcall vkCmdDraw(ptr long long long long) ++@ stdcall vkCmdDrawIndexed(ptr long long long long long) ++@ stdcall vkCmdDrawIndexedIndirect(ptr int64 int64 long long) ++@ stdcall vkCmdDrawIndirect(ptr int64 int64 long long) ++@ stdcall vkCmdEndQuery(ptr int64 long) ++@ stdcall vkCmdEndRenderPass(ptr) ++@ stdcall vkCmdExecuteCommands(ptr long ptr) ++@ stdcall vkCmdFillBuffer(ptr int64 int64 int64 long) ++@ stdcall vkCmdNextSubpass(ptr long) ++@ stdcall vkCmdPipelineBarrier(ptr long long long long ptr long ptr long ptr) ++@ stdcall vkCmdPushConstants(ptr int64 long long long ptr) ++@ stdcall vkCmdResetEvent(ptr int64 long) ++@ stdcall vkCmdResetQueryPool(ptr int64 long long) ++@ stdcall vkCmdResolveImage(ptr int64 long int64 long long ptr) ++@ stdcall vkCmdSetBlendConstants(ptr ptr) ++@ stdcall vkCmdSetDepthBias(ptr float float float) ++@ stdcall vkCmdSetDepthBounds(ptr float float) ++@ stdcall vkCmdSetEvent(ptr int64 long) ++@ stdcall vkCmdSetLineWidth(ptr float) ++@ stdcall vkCmdSetScissor(ptr long long ptr) ++@ stdcall vkCmdSetStencilCompareMask(ptr long long) ++@ stdcall vkCmdSetStencilReference(ptr long long) ++@ stdcall vkCmdSetStencilWriteMask(ptr long long) ++@ stdcall vkCmdSetViewport(ptr long long ptr) ++@ stdcall vkCmdUpdateBuffer(ptr int64 int64 int64 ptr) ++@ stdcall vkCmdWaitEvents(ptr long ptr long long long ptr long ptr long ptr) ++@ stdcall vkCmdWriteTimestamp(ptr long int64 long) ++@ stdcall vkCreateBuffer(ptr ptr ptr ptr) ++@ stdcall vkCreateBufferView(ptr ptr ptr ptr) ++@ stdcall vkCreateCommandPool(ptr ptr ptr ptr) ++@ stdcall vkCreateComputePipelines(ptr int64 long ptr ptr ptr) ++@ stdcall vkCreateDebugReportCallbackEXT(ptr ptr ptr ptr) ++@ stdcall vkCreateDescriptorPool(ptr ptr ptr ptr) ++@ stdcall vkCreateDescriptorSetLayout(ptr ptr ptr ptr) ++@ stdcall vkCreateDevice(ptr ptr ptr ptr) ++@ stdcall vkCreateDisplayModeKHR(ptr int64 ptr ptr ptr) ++@ stdcall vkCreateDisplayPlaneSurfaceKHR(ptr ptr ptr ptr) ++@ stdcall vkCreateEvent(ptr ptr ptr ptr) ++@ stdcall vkCreateFence(ptr ptr ptr ptr) ++@ stdcall vkCreateFramebuffer(ptr ptr ptr ptr) ++@ stdcall vkCreateGraphicsPipelines(ptr int64 long ptr ptr ptr) ++@ stdcall vkCreateImage(ptr ptr ptr ptr) ++@ stdcall vkCreateImageView(ptr ptr ptr ptr) ++@ stdcall vkCreateInstance(ptr ptr ptr) ++@ stdcall vkCreatePipelineCache(ptr ptr ptr ptr) ++@ stdcall vkCreatePipelineLayout(ptr ptr ptr ptr) ++@ stdcall vkCreateQueryPool(ptr ptr ptr ptr) ++@ stdcall vkCreateRenderPass(ptr ptr ptr ptr) ++@ stdcall vkCreateSampler(ptr ptr ptr ptr) ++@ stdcall vkCreateSemaphore(ptr ptr ptr ptr) ++@ stdcall vkCreateShaderModule(ptr ptr ptr ptr) ++@ stdcall vkCreateSharedSwapchainsKHR(ptr long ptr ptr ptr) ++@ stdcall vkCreateSwapchainKHR(ptr ptr ptr ptr) ++@ stdcall vkCreateWin32SurfaceKHR(ptr ptr ptr ptr) ++@ stdcall vkDebugReportMessageEXT(ptr long long int64 long long str str) ++@ stdcall vkDestroyBuffer(ptr int64 ptr) ++@ stdcall vkDestroyBufferView(ptr int64 ptr) ++@ stdcall vkDestroyCommandPool(ptr int64 ptr) ++@ stdcall vkDestroyDebugReportCallbackEXT(ptr int64 ptr) ++@ stdcall vkDestroyDescriptorPool(ptr int64 ptr) ++@ stdcall vkDestroyDescriptorSetLayout(ptr int64 ptr) ++@ stdcall vkDestroyDevice(ptr ptr) ++@ stdcall vkDestroyEvent(ptr int64 ptr) ++@ stdcall vkDestroyFence(ptr int64 ptr) ++@ stdcall vkDestroyFramebuffer(ptr int64 ptr) ++@ stdcall vkDestroyImage(ptr int64 ptr) ++@ stdcall vkDestroyImageView(ptr int64 ptr) ++@ stdcall vkDestroyInstance(ptr ptr) ++@ stdcall vkDestroyPipeline(ptr int64 ptr) ++@ stdcall vkDestroyPipelineCache(ptr int64 ptr) ++@ stdcall vkDestroyPipelineLayout(ptr int64 ptr) ++@ stdcall vkDestroyQueryPool(ptr int64 ptr) ++@ stdcall vkDestroyRenderPass(ptr int64 ptr) ++@ stdcall vkDestroySampler(ptr int64 ptr) ++@ stdcall vkDestroySemaphore(ptr int64 ptr) ++@ stdcall vkDestroyShaderModule(ptr int64 ptr) ++@ stdcall vkDestroySurfaceKHR(ptr int64 ptr) ++@ stdcall vkDestroySwapchainKHR(ptr int64 ptr) ++@ stdcall vkDeviceWaitIdle(ptr) ++@ stdcall vkEndCommandBuffer(ptr) ++@ stdcall vkEnumerateDeviceExtensionProperties(ptr str ptr ptr) ++@ stdcall vkEnumerateDeviceLayerProperties(ptr ptr ptr) ++@ stdcall vkEnumerateInstanceExtensionProperties(str ptr ptr) ++@ stdcall vkEnumerateInstanceLayerProperties(ptr ptr) ++@ stdcall vkEnumeratePhysicalDevices(ptr ptr ptr) ++@ stdcall vkFlushMappedMemoryRanges(ptr long ptr) ++@ stdcall vkFreeCommandBuffers(ptr int64 long ptr) ++@ stdcall vkFreeDescriptorSets(ptr int64 long ptr) ++@ stdcall vkFreeMemory(ptr int64 ptr) ++@ stdcall vkGetBufferMemoryRequirements(ptr int64 ptr) ++@ stdcall vkGetDeviceMemoryCommitment(ptr int64 ptr) ++@ stdcall vkGetDeviceProcAddr(ptr str) ++@ stdcall vkGetDeviceQueue(ptr long long ptr) ++@ stdcall vkGetDisplayModePropertiesKHR(ptr int64 ptr ptr) ++@ stdcall vkGetDisplayPlaneCapabilitiesKHR(ptr int64 long ptr) ++@ stdcall vkGetDisplayPlaneSupportedDisplaysKHR(ptr long ptr ptr) ++@ stdcall vkGetEventStatus(ptr int64) ++@ stdcall vkGetFenceStatus(ptr int64) ++@ stdcall vkGetImageMemoryRequirements(ptr int64 ptr) ++@ stdcall vkGetImageSparseMemoryRequirements(ptr int64 ptr ptr) ++@ stdcall vkGetImageSubresourceLayout(ptr int64 ptr ptr) ++@ stdcall vkGetInstanceProcAddr(ptr str) ++@ stdcall vkGetPhysicalDeviceDisplayPlanePropertiesKHR(ptr ptr ptr) ++@ stdcall vkGetPhysicalDeviceDisplayPropertiesKHR(ptr ptr ptr) ++@ stdcall vkGetPhysicalDeviceFeatures(ptr ptr) ++@ stdcall vkGetPhysicalDeviceFormatProperties(ptr long ptr) ++@ stdcall vkGetPhysicalDeviceImageFormatProperties(ptr long long long long long ptr) ++@ stdcall vkGetPhysicalDeviceMemoryProperties(ptr ptr) ++@ stdcall vkGetPhysicalDeviceProperties(ptr ptr) ++@ stdcall vkGetPhysicalDeviceQueueFamilyProperties(ptr ptr ptr) ++@ stdcall vkGetPhysicalDeviceSparseImageFormatProperties(ptr long long long long long ptr ptr) ++@ stdcall vkGetPhysicalDeviceSurfaceCapabilitiesKHR(ptr int64 ptr) ++@ stdcall vkGetPhysicalDeviceSurfaceFormatsKHR(ptr int64 ptr ptr) ++@ stdcall vkGetPhysicalDeviceSurfacePresentModesKHR(ptr int64 ptr ptr) ++@ stdcall vkGetPhysicalDeviceSurfaceSupportKHR(ptr long int64 ptr) ++@ stdcall vkGetPhysicalDeviceWin32PresentationSupportKHR(ptr long) ++@ stdcall vkGetPipelineCacheData(ptr int64 ptr ptr) ++@ stdcall vkGetQueryPoolResults(ptr int64 long long long ptr int64 long) ++@ stdcall vkGetRenderAreaGranularity(ptr int64 ptr) ++@ stdcall vkGetSwapchainImagesKHR(ptr int64 ptr ptr) ++@ stdcall vkInvalidateMappedMemoryRanges(ptr long ptr) ++@ stdcall vkMapMemory(ptr int64 int64 int64 long ptr) ++@ stdcall vkMergePipelineCaches(ptr int64 long ptr) ++@ stdcall vkQueueBindSparse(ptr long ptr int64) ++@ stdcall vkQueuePresentKHR(ptr ptr) ++@ stdcall vkQueueSubmit(ptr long ptr int64) ++@ stdcall vkQueueWaitIdle(ptr) ++@ stdcall vkResetCommandBuffer(ptr long) ++@ stdcall vkResetCommandPool(ptr int64 long) ++@ stdcall vkResetDescriptorPool(ptr int64 long) ++@ stdcall vkResetEvent(ptr int64) ++@ stdcall vkResetFences(ptr long ptr) ++@ stdcall vkSetEvent(ptr int64) ++@ stdcall vkUnmapMemory(ptr int64) ++@ stdcall vkUpdateDescriptorSets(ptr long ptr long ptr) ++@ stdcall vkWaitForFences(ptr long ptr long int64) +diff --git a/dlls/vulkan/vulkan_main.c b/dlls/vulkan/vulkan_main.c +new file mode 100644 +index 0000000..1cc30d1 +--- /dev/null ++++ b/dlls/vulkan/vulkan_main.c +@@ -0,0 +1,327 @@ ++/* ++ * Vulkan API implementation ++ * ++ * Copyright 2016 Sebastian Lackner ++ * Copyright 2016 Michael Müller ++ * Copyright 2016 Erich E. Hoover ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA ++ */ ++ ++#include "config.h" ++#include "wine/port.h" ++#include ++ ++#include "windef.h" ++#include "winbase.h" ++#include "winuser.h" ++#include "wine/debug.h" ++#include "wine/library.h" ++ ++#include "vulkan_private.h" ++ ++WINE_DEFAULT_DEBUG_CHANNEL(vulkan); ++WINE_DECLARE_DEBUG_CHANNEL(winediag); ++ ++static HINSTANCE vulkan_module; ++ ++#if defined(HAVE_X11_XLIB_H) ++static Display *display; ++#endif ++ ++#if defined(HAVE_X11_XLIB_H) && defined(SONAME_LIBX11_XCB) ++static void *libx11_xcb_handle; ++static typeof(XGetXCBConnection) *pXGetXCBConnection; ++ ++static BOOL init_x11_xcb( void ) ++{ ++ if (!(libx11_xcb_handle = wine_dlopen( SONAME_LIBX11_XCB, RTLD_NOW, NULL, 0 ))) ++ { ++ ERR_(winediag)( "failed to load %s, vulkan support might not work properly\n", SONAME_LIBX11_XCB ); ++ return FALSE; ++ } ++ ++ pXGetXCBConnection = wine_dlsym( libx11_xcb_handle, "XGetXCBConnection", NULL, 0 ); ++ return TRUE; ++} ++ ++static void free_x11_xcb( void ) ++{ ++ if (!libx11_xcb_handle) return; ++ wine_dlclose( libx11_xcb_handle, NULL, 0 ); ++ libx11_xcb_handle = NULL; ++} ++#else ++static BOOL init_x11_xcb( void ) ++{ ++ return FALSE; ++} ++ ++static void free_x11_xcb( void ) ++{ ++} ++#endif ++ ++static VkInstanceCreateInfo *convert_VkInstanceCreateInfo( VkInstanceCreateInfo *out, ++ const VkInstanceCreateInfo *in, const char *extension_name ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->flags = in->flags; ++ out->pApplicationInfo = in->pApplicationInfo; ++ out->enabledLayerCount = in->enabledLayerCount; ++ out->ppEnabledLayerNames = in->ppEnabledLayerNames; ++ out->enabledExtensionCount = in->enabledExtensionCount; ++ out->ppEnabledExtensionNames = NULL; ++ ++ if (in->ppEnabledExtensionNames) ++ { ++ out->ppEnabledExtensionNames = HeapAlloc( GetProcessHeap(), 0, ++ in->enabledExtensionCount * sizeof(*out->ppEnabledExtensionNames) ); ++ for (i = 0; i < in->enabledExtensionCount; i++) ++ { ++ if (!strcmp(in->ppEnabledExtensionNames[i], "VK_KHR_win32_surface")) ++ out->ppEnabledExtensionNames[i] = (char *)extension_name; ++ else ++ out->ppEnabledExtensionNames[i] = in->ppEnabledExtensionNames[i]; ++ } ++ } ++ ++ return out; ++} ++static void release_VkInstanceCreateInfo( VkInstanceCreateInfo *out, ++ VkInstanceCreateInfo *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return; ++ ++ HeapFree( GetProcessHeap(), 0, in->ppEnabledExtensionNames ); ++} ++ ++BOOL WINAPI DllMain( HINSTANCE instance, DWORD reason, LPVOID reserved ) ++{ ++ TRACE( "(%p, %u, %p)\n", instance, reason, reserved ); ++ ++ switch (reason) ++ { ++ case DLL_PROCESS_ATTACH: ++ vulkan_module = instance; ++ DisableThreadLibraryCalls( instance ); ++ if (!init_vulkan()) return FALSE; ++#if defined(HAVE_X11_XLIB_H) ++ if (!(display = XOpenDisplay( NULL))) ++ { ++ free_vulkan(); ++ return FALSE; ++ } ++#endif ++ init_x11_xcb(); ++ break; ++ ++ case DLL_PROCESS_DETACH: ++ if (reserved) break; ++ free_x11_xcb(); ++ free_vulkan(); ++ if (display) XCloseDisplay( display ); ++ break; ++ } ++ ++ return TRUE; ++} ++ ++/*********************************************************************** ++ * vkGetDeviceProcAddr (VULKAN.@) ++ */ ++PFN_vkVoidFunction WINAPI vkGetDeviceProcAddr( VkDevice device, const char *pName ) ++{ ++ void *function; ++ ++ TRACE( "(%p, %s)\n", device, debugstr_a(pName) ); ++ ++ if (is_null_func( pName )) ++ { ++ FIXME( "%s not supported\n", debugstr_a(pName) ); ++ return NULL; ++ } ++ ++ function = GetProcAddress( vulkan_module, pName ); ++ if (!function) FIXME( "missing function %s\n", debugstr_a(pName) ); ++ return function; ++} ++ ++/*********************************************************************** ++ * vkGetInstanceProcAddr (VULKAN.@) ++ */ ++PFN_vkVoidFunction WINAPI vkGetInstanceProcAddr( VkInstance instance, const char *pName ) ++{ ++ void *function; ++ ++ TRACE( "(%p, %s)\n", instance, debugstr_a(pName) ); ++ ++ if (is_null_func( pName )) ++ { ++ FIXME( "%s not supported\n", debugstr_a(pName) ); ++ return NULL; ++ } ++ ++ function = GetProcAddress( vulkan_module, pName ); ++ if (!function) FIXME( "missing function %s\n", debugstr_a(pName) ); ++ return function; ++} ++ ++/*********************************************************************** ++ * vkCreateWin32SurfaceKHR (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateWin32SurfaceKHR( VkInstance instance, ++ const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, ++ VkSurfaceKHR *pSurface ) ++{ ++ VkResult res = VK_ERROR_INCOMPATIBLE_DRIVER; ++ ++ TRACE( "(%p, %p, %p, %p)\n", instance, pCreateInfo, pAllocator, pSurface ); ++ ++#if defined(HAVE_X11_XLIB_H) && defined(SONAME_LIBX11_XCB) ++ if (pXGetXCBConnection && res == VK_ERROR_INCOMPATIBLE_DRIVER) ++ { ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkXcbSurfaceCreateInfoKHR_host tmp_pCreateInfo; ++ ++ tmp_pCreateInfo.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR; ++ tmp_pCreateInfo.pNext = NULL; ++ tmp_pCreateInfo.flags = pCreateInfo->flags; ++ tmp_pCreateInfo.connection = pXGetXCBConnection( display ); ++ tmp_pCreateInfo.window = (xcb_window_t)(DWORD_PTR)GetPropA( pCreateInfo->hwnd, "__wine_x11_whole_window" ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateXcbSurfaceKHR( instance, &tmp_pCreateInfo, ptr_pAllocator, pSurface ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ } ++#endif ++ ++#if defined(HAVE_X11_XLIB_H) ++ if (res == VK_ERROR_INCOMPATIBLE_DRIVER) ++ { ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkXlibSurfaceCreateInfoKHR_host tmp_pCreateInfo; ++ ++ tmp_pCreateInfo.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR; ++ tmp_pCreateInfo.pNext = NULL; ++ tmp_pCreateInfo.flags = pCreateInfo->flags; ++ tmp_pCreateInfo.dpy = display; ++ tmp_pCreateInfo.window = (Window)(DWORD_PTR)GetPropA( pCreateInfo->hwnd, "__wine_x11_whole_window" ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateXlibSurfaceKHR( instance, &tmp_pCreateInfo, ptr_pAllocator, pSurface ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ } ++#endif ++ ++ if (res != VK_SUCCESS) ++ ERR( "failed to create Win32Surface: %08x\n", res ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkGetPhysicalDeviceWin32PresentationSupportKHR (VULKAN.@) ++ */ ++VkBool32 WINAPI vkGetPhysicalDeviceWin32PresentationSupportKHR( VkPhysicalDevice physicalDevice, ++ uint32_t queueFamilyIndex ) ++{ ++ FIXME( "(%p, %u): stub\n", physicalDevice, queueFamilyIndex ); ++ return VK_FALSE; ++} ++ ++/*********************************************************************** ++ * vkCreateInstance (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateInstance( const VkInstanceCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks *pAllocator, VkInstance *pInstance ) ++{ ++ VkResult res = VK_ERROR_INCOMPATIBLE_DRIVER; ++ ++ TRACE( "(%p, %p, %p)\n", pCreateInfo, pAllocator, pInstance ); ++ ++#if defined(HAVE_X11_XLIB_H) && defined(SONAME_LIBX11_XCB) ++ if (pXGetXCBConnection && (res == VK_ERROR_INCOMPATIBLE_DRIVER || ++ res == VK_ERROR_EXTENSION_NOT_PRESENT)) ++ { ++ VkInstanceCreateInfo tmp_pCreateInfo, *ptr_pCreateInfo; ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ ptr_pCreateInfo = convert_VkInstanceCreateInfo( &tmp_pCreateInfo, pCreateInfo, "VK_KHR_xcb_surface" ); ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateInstance( &tmp_pCreateInfo, ptr_pAllocator, pInstance ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ release_VkInstanceCreateInfo( NULL, ptr_pCreateInfo ); ++ } ++#endif ++ ++#if defined(HAVE_X11_XLIB_H) ++ if (res == VK_ERROR_INCOMPATIBLE_DRIVER || ++ res == VK_ERROR_EXTENSION_NOT_PRESENT) ++ { ++ VkInstanceCreateInfo tmp_pCreateInfo, *ptr_pCreateInfo; ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ ptr_pCreateInfo = convert_VkInstanceCreateInfo( &tmp_pCreateInfo, pCreateInfo, "VK_KHR_xlib_surface" ); ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateInstance( &tmp_pCreateInfo, ptr_pAllocator, pInstance ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ release_VkInstanceCreateInfo( NULL, ptr_pCreateInfo ); ++ } ++#endif ++ ++ if (res != VK_SUCCESS) ++ ERR( "failed to create instance: %08x\n", res ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkEnumerateInstanceExtensionProperties (VULKAN.@) ++ */ ++VkResult WINAPI vkEnumerateInstanceExtensionProperties( const char *pLayerName, ++ uint32_t *pPropertyCount, VkExtensionProperties *pProperties ) ++{ ++ VkResult res; ++ int i; ++ ++ TRACE( "(%p, %p, %p)\n", pLayerName, pPropertyCount, pProperties ); ++ ++ res = p_vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, pProperties ); ++ if ((res == VK_SUCCESS || res == VK_INCOMPLETE) && pProperties) ++ { ++ for (i = 0; i < *pPropertyCount; i++) ++ { ++ if (!strcmp( pProperties[i].extensionName, "VK_KHR_xcb_surface" ) || ++ !strcmp( pProperties[i].extensionName, "VK_KHR_xlib_surface" )) ++ { ++ TRACE( "replacing %s -> VK_KHR_win32_surface\n", debugstr_a(pProperties[i].extensionName) ); ++ strcpy( pProperties[i].extensionName, "VK_KHR_win32_surface" ); ++ pProperties[i].specVersion = 6; ++ } ++ } ++ } ++ ++ return res; ++} +diff --git a/dlls/vulkan/vulkan_private.h b/dlls/vulkan/vulkan_private.h +new file mode 100644 +index 0000000..0f85854 +--- /dev/null ++++ b/dlls/vulkan/vulkan_private.h +@@ -0,0 +1,3296 @@ ++/* ++ * Vulkan API implementation ++ * ++ * Copyright 2016 Sebastian Lackner ++ * Copyright 2016 Michael Müller ++ * Copyright 2016 Erich E. Hoover ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA ++ */ ++ ++#ifndef __VULKAN_PRIVATE_H ++#define __VULKAN_PRIVATE_H ++ ++#include ++ ++#if defined(HAVE_X11_XLIB_H) ++# include ++#endif ++#if defined(HAVE_X11_XLIB_XCB_H) ++# include ++#endif ++ ++#if defined(__i386__) ++# define USE_STRUCT_CONVERSION ++#endif ++ ++#define VK_SUCCESS 0 ++#define VK_INCOMPLETE 5 ++#define VK_ERROR_EXTENSION_NOT_PRESENT (-7) ++#define VK_ERROR_INCOMPATIBLE_DRIVER (-9) ++#define VK_FALSE 0 ++#define VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR 1000004000 ++#define VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR 1000005000 ++ ++#if !defined(HAVE_X11_XLIB_H) ++typedef struct _XDisplay Display; ++#endif ++typedef void *PFN_vkAllocationFunction; ++typedef void *PFN_vkAllocationFunction_host; ++typedef void *PFN_vkDebugReportCallbackEXT; ++typedef void *PFN_vkDebugReportCallbackEXT_host; ++typedef void *PFN_vkFreeFunction; ++typedef void *PFN_vkFreeFunction_host; ++typedef void *PFN_vkInternalAllocationNotification; ++typedef void *PFN_vkInternalAllocationNotification_host; ++typedef void *PFN_vkInternalFreeNotification; ++typedef void *PFN_vkInternalFreeNotification_host; ++typedef void *PFN_vkReallocationFunction; ++typedef void *PFN_vkReallocationFunction_host; ++typedef void *PFN_vkVoidFunction; ++typedef void *PFN_vkVoidFunction_host; ++typedef void *VK_DEFINE_HANDLE; ++typedef uint64_t VK_DEFINE_NON_DISPATCHABLE_HANDLE; ++typedef uint32_t VkAccessFlags; ++typedef uint32_t VkAttachmentDescriptionFlags; ++typedef int VkAttachmentLoadOp; ++typedef int VkAttachmentStoreOp; ++typedef int VkBlendFactor; ++typedef int VkBlendOp; ++typedef uint32_t VkBool32; ++typedef int VkBorderColor; ++typedef uint64_t VkBuffer; ++typedef uint32_t VkBufferCreateFlags; ++typedef uint32_t VkBufferUsageFlags; ++typedef uint64_t VkBufferView; ++typedef uint32_t VkBufferViewCreateFlags; ++typedef uint32_t VkColorComponentFlags; ++typedef int VkColorSpaceKHR; ++typedef void *VkCommandBuffer; ++typedef int VkCommandBufferLevel; ++typedef uint32_t VkCommandBufferResetFlags; ++typedef uint32_t VkCommandBufferUsageFlags; ++typedef uint64_t VkCommandPool; ++typedef uint32_t VkCommandPoolCreateFlags; ++typedef uint32_t VkCommandPoolResetFlags; ++typedef int VkCompareOp; ++typedef int VkComponentSwizzle; ++typedef int VkCompositeAlphaFlagBitsKHR; ++typedef uint32_t VkCompositeAlphaFlagsKHR; ++typedef uint32_t VkCullModeFlags; ++typedef uint64_t VkDebugReportCallbackEXT; ++typedef uint32_t VkDebugReportFlagsEXT; ++typedef int VkDebugReportObjectTypeEXT; ++typedef uint32_t VkDependencyFlags; ++typedef uint64_t VkDescriptorPool; ++typedef uint32_t VkDescriptorPoolCreateFlags; ++typedef uint32_t VkDescriptorPoolResetFlags; ++typedef uint64_t VkDescriptorSet; ++typedef uint64_t VkDescriptorSetLayout; ++typedef uint32_t VkDescriptorSetLayoutCreateFlags; ++typedef int VkDescriptorType; ++typedef void *VkDevice; ++typedef uint32_t VkDeviceCreateFlags; ++typedef uint64_t VkDeviceMemory; ++typedef uint32_t VkDeviceQueueCreateFlags; ++typedef uint64_t VkDeviceSize; ++typedef uint64_t VkDisplayKHR; ++typedef uint32_t VkDisplayModeCreateFlagsKHR; ++typedef uint64_t VkDisplayModeKHR; ++typedef int VkDisplayPlaneAlphaFlagBitsKHR; ++typedef uint32_t VkDisplayPlaneAlphaFlagsKHR; ++typedef uint32_t VkDisplaySurfaceCreateFlagsKHR; ++typedef int VkDynamicState; ++typedef uint64_t VkEvent; ++typedef uint32_t VkEventCreateFlags; ++typedef uint64_t VkFence; ++typedef uint32_t VkFenceCreateFlags; ++typedef int VkFilter; ++typedef uint32_t VkFlags; ++typedef int VkFormat; ++typedef uint32_t VkFormatFeatureFlags; ++typedef uint64_t VkFramebuffer; ++typedef uint32_t VkFramebufferCreateFlags; ++typedef int VkFrontFace; ++typedef uint64_t VkImage; ++typedef uint32_t VkImageAspectFlags; ++typedef uint32_t VkImageCreateFlags; ++typedef int VkImageLayout; ++typedef int VkImageTiling; ++typedef int VkImageType; ++typedef uint32_t VkImageUsageFlags; ++typedef uint64_t VkImageView; ++typedef uint32_t VkImageViewCreateFlags; ++typedef int VkImageViewType; ++typedef int VkIndexType; ++typedef void *VkInstance; ++typedef uint32_t VkInstanceCreateFlags; ++typedef int VkLogicOp; ++typedef uint32_t VkMemoryHeapFlags; ++typedef uint32_t VkMemoryMapFlags; ++typedef uint32_t VkMemoryPropertyFlags; ++typedef void *VkPhysicalDevice; ++typedef int VkPhysicalDeviceType; ++typedef uint64_t VkPipeline; ++typedef int VkPipelineBindPoint; ++typedef uint64_t VkPipelineCache; ++typedef uint32_t VkPipelineCacheCreateFlags; ++typedef uint32_t VkPipelineColorBlendStateCreateFlags; ++typedef uint32_t VkPipelineCreateFlags; ++typedef uint32_t VkPipelineDepthStencilStateCreateFlags; ++typedef uint32_t VkPipelineDynamicStateCreateFlags; ++typedef uint32_t VkPipelineInputAssemblyStateCreateFlags; ++typedef uint64_t VkPipelineLayout; ++typedef uint32_t VkPipelineLayoutCreateFlags; ++typedef uint32_t VkPipelineMultisampleStateCreateFlags; ++typedef uint32_t VkPipelineRasterizationStateCreateFlags; ++typedef uint32_t VkPipelineShaderStageCreateFlags; ++typedef int VkPipelineStageFlagBits; ++typedef uint32_t VkPipelineStageFlags; ++typedef uint32_t VkPipelineTessellationStateCreateFlags; ++typedef uint32_t VkPipelineVertexInputStateCreateFlags; ++typedef uint32_t VkPipelineViewportStateCreateFlags; ++typedef int VkPolygonMode; ++typedef int VkPresentModeKHR; ++typedef int VkPrimitiveTopology; ++typedef uint32_t VkQueryControlFlags; ++typedef uint32_t VkQueryPipelineStatisticFlags; ++typedef uint64_t VkQueryPool; ++typedef uint32_t VkQueryPoolCreateFlags; ++typedef uint32_t VkQueryResultFlags; ++typedef int VkQueryType; ++typedef void *VkQueue; ++typedef uint32_t VkQueueFlags; ++typedef uint64_t VkRenderPass; ++typedef uint32_t VkRenderPassCreateFlags; ++typedef int VkResult; ++typedef int VkSampleCountFlagBits; ++typedef uint32_t VkSampleCountFlags; ++typedef uint32_t VkSampleMask; ++typedef uint64_t VkSampler; ++typedef int VkSamplerAddressMode; ++typedef uint32_t VkSamplerCreateFlags; ++typedef int VkSamplerMipmapMode; ++typedef uint64_t VkSemaphore; ++typedef uint32_t VkSemaphoreCreateFlags; ++typedef uint64_t VkShaderModule; ++typedef uint32_t VkShaderModuleCreateFlags; ++typedef int VkShaderStageFlagBits; ++typedef uint32_t VkShaderStageFlags; ++typedef int VkSharingMode; ++typedef uint32_t VkSparseImageFormatFlags; ++typedef uint32_t VkSparseMemoryBindFlags; ++typedef uint32_t VkStencilFaceFlags; ++typedef int VkStencilOp; ++typedef int VkStructureType; ++typedef int VkSubpassContents; ++typedef uint32_t VkSubpassDescriptionFlags; ++typedef uint64_t VkSurfaceKHR; ++typedef int VkSurfaceTransformFlagBitsKHR; ++typedef uint32_t VkSurfaceTransformFlagsKHR; ++typedef uint32_t VkSwapchainCreateFlagsKHR; ++typedef uint64_t VkSwapchainKHR; ++typedef int VkVertexInputRate; ++typedef uint32_t VkWin32SurfaceCreateFlagsKHR; ++typedef uint32_t VkXcbSurfaceCreateFlagsKHR_host; ++typedef uint32_t VkXlibSurfaceCreateFlagsKHR_host; ++typedef unsigned long int Window; ++#if !defined(HAVE_X11_XLIB_XCB_H) ++typedef struct xcb_connection_t xcb_connection_t; ++#endif ++#if !defined(HAVE_X11_XLIB_XCB_H) ++typedef uint32_t xcb_window_t; ++#endif ++ ++typedef struct VkCommandBufferAllocateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkCommandPool DECLSPEC_ALIGN(8) commandPool; ++ VkCommandBufferLevel level; ++ uint32_t commandBufferCount; ++} VkCommandBufferAllocateInfo; ++ ++typedef struct VkCommandBufferAllocateInfo_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkCommandPool commandPool; ++ VkCommandBufferLevel level; ++ uint32_t commandBufferCount; ++} VkCommandBufferAllocateInfo_host; ++ ++typedef struct VkDescriptorSetAllocateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool; ++ uint32_t descriptorSetCount; ++ VkDescriptorSetLayout *pSetLayouts; ++} VkDescriptorSetAllocateInfo; ++ ++typedef struct VkDescriptorSetAllocateInfo_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkDescriptorPool descriptorPool; ++ uint32_t descriptorSetCount; ++ VkDescriptorSetLayout *pSetLayouts; ++} VkDescriptorSetAllocateInfo_host; ++ ++typedef struct VkMemoryAllocateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkDeviceSize DECLSPEC_ALIGN(8) allocationSize; ++ uint32_t memoryTypeIndex; ++} VkMemoryAllocateInfo; ++ ++typedef struct VkMemoryAllocateInfo_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkDeviceSize allocationSize; ++ uint32_t memoryTypeIndex; ++} VkMemoryAllocateInfo_host; ++ ++typedef struct VkAllocationCallbacks ++{ ++ void *pUserData; ++ PFN_vkAllocationFunction pfnAllocation; ++ PFN_vkReallocationFunction pfnReallocation; ++ PFN_vkFreeFunction pfnFree; ++ PFN_vkInternalAllocationNotification pfnInternalAllocation; ++ PFN_vkInternalFreeNotification pfnInternalFree; ++} VkAllocationCallbacks; ++ ++typedef struct VkAllocationCallbacks_host ++{ ++ void *pUserData; ++ PFN_vkAllocationFunction_host pfnAllocation; ++ PFN_vkReallocationFunction_host pfnReallocation; ++ PFN_vkFreeFunction_host pfnFree; ++ PFN_vkInternalAllocationNotification_host pfnInternalAllocation; ++ PFN_vkInternalFreeNotification_host pfnInternalFree; ++} VkAllocationCallbacks_host; ++ ++typedef struct VkCommandBufferInheritanceInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkRenderPass DECLSPEC_ALIGN(8) renderPass; ++ uint32_t subpass; ++ VkFramebuffer DECLSPEC_ALIGN(8) framebuffer; ++ VkBool32 occlusionQueryEnable; ++ VkQueryControlFlags queryFlags; ++ VkQueryPipelineStatisticFlags pipelineStatistics; ++} VkCommandBufferInheritanceInfo; ++ ++typedef struct VkCommandBufferInheritanceInfo_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkRenderPass renderPass; ++ uint32_t subpass; ++ VkFramebuffer framebuffer; ++ VkBool32 occlusionQueryEnable; ++ VkQueryControlFlags queryFlags; ++ VkQueryPipelineStatisticFlags pipelineStatistics; ++} VkCommandBufferInheritanceInfo_host; ++ ++typedef struct VkCommandBufferBeginInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkCommandBufferUsageFlags flags; ++ VkCommandBufferInheritanceInfo *pInheritanceInfo; ++} VkCommandBufferBeginInfo; ++ ++typedef struct VkCommandBufferBeginInfo_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkCommandBufferUsageFlags flags; ++ VkCommandBufferInheritanceInfo_host *pInheritanceInfo; ++} VkCommandBufferBeginInfo_host; ++ ++typedef struct VkOffset2D ++{ ++ int32_t x; ++ int32_t y; ++} VkOffset2D; ++ ++typedef struct VkExtent2D ++{ ++ uint32_t width; ++ uint32_t height; ++} VkExtent2D; ++ ++typedef struct VkRect2D ++{ ++ VkOffset2D offset; ++ VkExtent2D extent; ++} VkRect2D; ++ ++typedef union VkClearColorValue ++{ ++ float float32[4]; ++ int32_t int32[4]; ++ uint32_t uint32[4]; ++} VkClearColorValue; ++ ++typedef struct VkClearDepthStencilValue ++{ ++ float depth; ++ uint32_t stencil; ++} VkClearDepthStencilValue; ++ ++typedef union VkClearValue ++{ ++ VkClearColorValue color; ++ VkClearDepthStencilValue depthStencil; ++} VkClearValue; ++ ++typedef struct VkRenderPassBeginInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkRenderPass DECLSPEC_ALIGN(8) renderPass; ++ VkFramebuffer DECLSPEC_ALIGN(8) framebuffer; ++ VkRect2D renderArea; ++ uint32_t clearValueCount; ++ VkClearValue *pClearValues; ++} VkRenderPassBeginInfo; ++ ++typedef struct VkRenderPassBeginInfo_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkRenderPass renderPass; ++ VkFramebuffer framebuffer; ++ VkRect2D renderArea; ++ uint32_t clearValueCount; ++ VkClearValue *pClearValues; ++} VkRenderPassBeginInfo_host; ++ ++typedef struct VkImageSubresourceLayers ++{ ++ VkImageAspectFlags aspectMask; ++ uint32_t mipLevel; ++ uint32_t baseArrayLayer; ++ uint32_t layerCount; ++} VkImageSubresourceLayers; ++ ++typedef struct VkOffset3D ++{ ++ int32_t x; ++ int32_t y; ++ int32_t z; ++} VkOffset3D; ++ ++typedef struct VkImageBlit ++{ ++ VkImageSubresourceLayers srcSubresource; ++ VkOffset3D srcOffsets[2]; ++ VkImageSubresourceLayers dstSubresource; ++ VkOffset3D dstOffsets[2]; ++} VkImageBlit; ++ ++typedef struct VkClearAttachment ++{ ++ VkImageAspectFlags aspectMask; ++ uint32_t colorAttachment; ++ VkClearValue clearValue; ++} VkClearAttachment; ++ ++typedef struct VkClearRect ++{ ++ VkRect2D rect; ++ uint32_t baseArrayLayer; ++ uint32_t layerCount; ++} VkClearRect; ++ ++typedef struct VkImageSubresourceRange ++{ ++ VkImageAspectFlags aspectMask; ++ uint32_t baseMipLevel; ++ uint32_t levelCount; ++ uint32_t baseArrayLayer; ++ uint32_t layerCount; ++} VkImageSubresourceRange; ++ ++typedef struct VkBufferCopy ++{ ++ VkDeviceSize DECLSPEC_ALIGN(8) srcOffset; ++ VkDeviceSize DECLSPEC_ALIGN(8) dstOffset; ++ VkDeviceSize DECLSPEC_ALIGN(8) size; ++} VkBufferCopy; ++ ++typedef struct VkBufferCopy_host ++{ ++ VkDeviceSize srcOffset; ++ VkDeviceSize dstOffset; ++ VkDeviceSize size; ++} VkBufferCopy_host; ++ ++typedef struct VkExtent3D ++{ ++ uint32_t width; ++ uint32_t height; ++ uint32_t depth; ++} VkExtent3D; ++ ++typedef struct VkBufferImageCopy ++{ ++ VkDeviceSize DECLSPEC_ALIGN(8) bufferOffset; ++ uint32_t bufferRowLength; ++ uint32_t bufferImageHeight; ++ VkImageSubresourceLayers imageSubresource; ++ VkOffset3D imageOffset; ++ VkExtent3D imageExtent; ++} VkBufferImageCopy; ++ ++typedef struct VkBufferImageCopy_host ++{ ++ VkDeviceSize bufferOffset; ++ uint32_t bufferRowLength; ++ uint32_t bufferImageHeight; ++ VkImageSubresourceLayers imageSubresource; ++ VkOffset3D imageOffset; ++ VkExtent3D imageExtent; ++} VkBufferImageCopy_host; ++ ++typedef struct VkImageCopy ++{ ++ VkImageSubresourceLayers srcSubresource; ++ VkOffset3D srcOffset; ++ VkImageSubresourceLayers dstSubresource; ++ VkOffset3D dstOffset; ++ VkExtent3D extent; ++} VkImageCopy; ++ ++typedef struct VkMemoryBarrier ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkAccessFlags srcAccessMask; ++ VkAccessFlags dstAccessMask; ++} VkMemoryBarrier; ++ ++typedef struct VkBufferMemoryBarrier ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkAccessFlags srcAccessMask; ++ VkAccessFlags dstAccessMask; ++ uint32_t srcQueueFamilyIndex; ++ uint32_t dstQueueFamilyIndex; ++ VkBuffer DECLSPEC_ALIGN(8) buffer; ++ VkDeviceSize DECLSPEC_ALIGN(8) offset; ++ VkDeviceSize DECLSPEC_ALIGN(8) size; ++} VkBufferMemoryBarrier; ++ ++typedef struct VkBufferMemoryBarrier_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkAccessFlags srcAccessMask; ++ VkAccessFlags dstAccessMask; ++ uint32_t srcQueueFamilyIndex; ++ uint32_t dstQueueFamilyIndex; ++ VkBuffer buffer; ++ VkDeviceSize offset; ++ VkDeviceSize size; ++} VkBufferMemoryBarrier_host; ++ ++typedef struct VkImageMemoryBarrier ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkAccessFlags srcAccessMask; ++ VkAccessFlags dstAccessMask; ++ VkImageLayout oldLayout; ++ VkImageLayout newLayout; ++ uint32_t srcQueueFamilyIndex; ++ uint32_t dstQueueFamilyIndex; ++ VkImage DECLSPEC_ALIGN(8) image; ++ VkImageSubresourceRange subresourceRange; ++} VkImageMemoryBarrier; ++ ++typedef struct VkImageMemoryBarrier_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkAccessFlags srcAccessMask; ++ VkAccessFlags dstAccessMask; ++ VkImageLayout oldLayout; ++ VkImageLayout newLayout; ++ uint32_t srcQueueFamilyIndex; ++ uint32_t dstQueueFamilyIndex; ++ VkImage image; ++ VkImageSubresourceRange subresourceRange; ++} VkImageMemoryBarrier_host; ++ ++typedef struct VkImageResolve ++{ ++ VkImageSubresourceLayers srcSubresource; ++ VkOffset3D srcOffset; ++ VkImageSubresourceLayers dstSubresource; ++ VkOffset3D dstOffset; ++ VkExtent3D extent; ++} VkImageResolve; ++ ++typedef struct VkViewport ++{ ++ float x; ++ float y; ++ float width; ++ float height; ++ float minDepth; ++ float maxDepth; ++} VkViewport; ++ ++typedef struct VkBufferCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkBufferCreateFlags flags; ++ VkDeviceSize DECLSPEC_ALIGN(8) size; ++ VkBufferUsageFlags usage; ++ VkSharingMode sharingMode; ++ uint32_t queueFamilyIndexCount; ++ uint32_t *pQueueFamilyIndices; ++} VkBufferCreateInfo; ++ ++typedef struct VkBufferCreateInfo_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkBufferCreateFlags flags; ++ VkDeviceSize size; ++ VkBufferUsageFlags usage; ++ VkSharingMode sharingMode; ++ uint32_t queueFamilyIndexCount; ++ uint32_t *pQueueFamilyIndices; ++} VkBufferCreateInfo_host; ++ ++typedef struct VkBufferViewCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkBufferViewCreateFlags flags; ++ VkBuffer DECLSPEC_ALIGN(8) buffer; ++ VkFormat format; ++ VkDeviceSize DECLSPEC_ALIGN(8) offset; ++ VkDeviceSize DECLSPEC_ALIGN(8) range; ++} VkBufferViewCreateInfo; ++ ++typedef struct VkBufferViewCreateInfo_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkBufferViewCreateFlags flags; ++ VkBuffer buffer; ++ VkFormat format; ++ VkDeviceSize offset; ++ VkDeviceSize range; ++} VkBufferViewCreateInfo_host; ++ ++typedef struct VkCommandPoolCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkCommandPoolCreateFlags flags; ++ uint32_t queueFamilyIndex; ++} VkCommandPoolCreateInfo; ++ ++typedef struct VkSpecializationMapEntry ++{ ++ uint32_t constantID; ++ uint32_t offset; ++ size_t size; ++} VkSpecializationMapEntry; ++ ++typedef struct VkSpecializationInfo ++{ ++ uint32_t mapEntryCount; ++ VkSpecializationMapEntry *pMapEntries; ++ size_t dataSize; ++ void *pData; ++} VkSpecializationInfo; ++ ++typedef struct VkPipelineShaderStageCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkPipelineShaderStageCreateFlags flags; ++ VkShaderStageFlagBits stage; ++ VkShaderModule DECLSPEC_ALIGN(8) module; ++ char *pName; ++ VkSpecializationInfo *pSpecializationInfo; ++} VkPipelineShaderStageCreateInfo; ++ ++typedef struct VkPipelineShaderStageCreateInfo_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkPipelineShaderStageCreateFlags flags; ++ VkShaderStageFlagBits stage; ++ VkShaderModule module; ++ char *pName; ++ VkSpecializationInfo *pSpecializationInfo; ++} VkPipelineShaderStageCreateInfo_host; ++ ++typedef struct VkComputePipelineCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkPipelineCreateFlags flags; ++ VkPipelineShaderStageCreateInfo DECLSPEC_ALIGN(8) stage; ++ VkPipelineLayout DECLSPEC_ALIGN(8) layout; ++ VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle; ++ int32_t basePipelineIndex; ++} VkComputePipelineCreateInfo; ++ ++typedef struct VkComputePipelineCreateInfo_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkPipelineCreateFlags flags; ++ VkPipelineShaderStageCreateInfo_host stage; ++ VkPipelineLayout layout; ++ VkPipeline basePipelineHandle; ++ int32_t basePipelineIndex; ++} VkComputePipelineCreateInfo_host; ++ ++typedef struct VkDebugReportCallbackCreateInfoEXT ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkDebugReportFlagsEXT flags; ++ PFN_vkDebugReportCallbackEXT pfnCallback; ++ void *pUserData; ++} VkDebugReportCallbackCreateInfoEXT; ++ ++typedef struct VkDebugReportCallbackCreateInfoEXT_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkDebugReportFlagsEXT flags; ++ PFN_vkDebugReportCallbackEXT_host pfnCallback; ++ void *pUserData; ++} VkDebugReportCallbackCreateInfoEXT_host; ++ ++typedef struct VkDescriptorPoolSize ++{ ++ VkDescriptorType type; ++ uint32_t descriptorCount; ++} VkDescriptorPoolSize; ++ ++typedef struct VkDescriptorPoolCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkDescriptorPoolCreateFlags flags; ++ uint32_t maxSets; ++ uint32_t poolSizeCount; ++ VkDescriptorPoolSize *pPoolSizes; ++} VkDescriptorPoolCreateInfo; ++ ++typedef struct VkDescriptorSetLayoutBinding ++{ ++ uint32_t binding; ++ VkDescriptorType descriptorType; ++ uint32_t descriptorCount; ++ VkShaderStageFlags stageFlags; ++ VkSampler *pImmutableSamplers; ++} VkDescriptorSetLayoutBinding; ++ ++typedef struct VkDescriptorSetLayoutCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkDescriptorSetLayoutCreateFlags flags; ++ uint32_t bindingCount; ++ VkDescriptorSetLayoutBinding *pBindings; ++} VkDescriptorSetLayoutCreateInfo; ++ ++typedef struct VkDeviceQueueCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkDeviceQueueCreateFlags flags; ++ uint32_t queueFamilyIndex; ++ uint32_t queueCount; ++ float *pQueuePriorities; ++} VkDeviceQueueCreateInfo; ++ ++typedef struct VkPhysicalDeviceFeatures ++{ ++ VkBool32 robustBufferAccess; ++ VkBool32 fullDrawIndexUint32; ++ VkBool32 imageCubeArray; ++ VkBool32 independentBlend; ++ VkBool32 geometryShader; ++ VkBool32 tessellationShader; ++ VkBool32 sampleRateShading; ++ VkBool32 dualSrcBlend; ++ VkBool32 logicOp; ++ VkBool32 multiDrawIndirect; ++ VkBool32 drawIndirectFirstInstance; ++ VkBool32 depthClamp; ++ VkBool32 depthBiasClamp; ++ VkBool32 fillModeNonSolid; ++ VkBool32 depthBounds; ++ VkBool32 wideLines; ++ VkBool32 largePoints; ++ VkBool32 alphaToOne; ++ VkBool32 multiViewport; ++ VkBool32 samplerAnisotropy; ++ VkBool32 textureCompressionETC2; ++ VkBool32 textureCompressionASTC_LDR; ++ VkBool32 textureCompressionBC; ++ VkBool32 occlusionQueryPrecise; ++ VkBool32 pipelineStatisticsQuery; ++ VkBool32 vertexPipelineStoresAndAtomics; ++ VkBool32 fragmentStoresAndAtomics; ++ VkBool32 shaderTessellationAndGeometryPointSize; ++ VkBool32 shaderImageGatherExtended; ++ VkBool32 shaderStorageImageExtendedFormats; ++ VkBool32 shaderStorageImageMultisample; ++ VkBool32 shaderStorageImageReadWithoutFormat; ++ VkBool32 shaderStorageImageWriteWithoutFormat; ++ VkBool32 shaderUniformBufferArrayDynamicIndexing; ++ VkBool32 shaderSampledImageArrayDynamicIndexing; ++ VkBool32 shaderStorageBufferArrayDynamicIndexing; ++ VkBool32 shaderStorageImageArrayDynamicIndexing; ++ VkBool32 shaderClipDistance; ++ VkBool32 shaderCullDistance; ++ VkBool32 shaderFloat64; ++ VkBool32 shaderInt64; ++ VkBool32 shaderInt16; ++ VkBool32 shaderResourceResidency; ++ VkBool32 shaderResourceMinLod; ++ VkBool32 sparseBinding; ++ VkBool32 sparseResidencyBuffer; ++ VkBool32 sparseResidencyImage2D; ++ VkBool32 sparseResidencyImage3D; ++ VkBool32 sparseResidency2Samples; ++ VkBool32 sparseResidency4Samples; ++ VkBool32 sparseResidency8Samples; ++ VkBool32 sparseResidency16Samples; ++ VkBool32 sparseResidencyAliased; ++ VkBool32 variableMultisampleRate; ++ VkBool32 inheritedQueries; ++} VkPhysicalDeviceFeatures; ++ ++typedef struct VkDeviceCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkDeviceCreateFlags flags; ++ uint32_t queueCreateInfoCount; ++ VkDeviceQueueCreateInfo *pQueueCreateInfos; ++ uint32_t enabledLayerCount; ++ char **ppEnabledLayerNames; ++ uint32_t enabledExtensionCount; ++ char **ppEnabledExtensionNames; ++ VkPhysicalDeviceFeatures *pEnabledFeatures; ++} VkDeviceCreateInfo; ++ ++typedef struct VkDisplayModeParametersKHR ++{ ++ VkExtent2D visibleRegion; ++ uint32_t refreshRate; ++} VkDisplayModeParametersKHR; ++ ++typedef struct VkDisplayModeCreateInfoKHR ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkDisplayModeCreateFlagsKHR flags; ++ VkDisplayModeParametersKHR parameters; ++} VkDisplayModeCreateInfoKHR; ++ ++typedef struct VkDisplaySurfaceCreateInfoKHR ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkDisplaySurfaceCreateFlagsKHR flags; ++ VkDisplayModeKHR DECLSPEC_ALIGN(8) displayMode; ++ uint32_t planeIndex; ++ uint32_t planeStackIndex; ++ VkSurfaceTransformFlagBitsKHR transform; ++ float globalAlpha; ++ VkDisplayPlaneAlphaFlagBitsKHR alphaMode; ++ VkExtent2D imageExtent; ++} VkDisplaySurfaceCreateInfoKHR; ++ ++typedef struct VkDisplaySurfaceCreateInfoKHR_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkDisplaySurfaceCreateFlagsKHR flags; ++ VkDisplayModeKHR displayMode; ++ uint32_t planeIndex; ++ uint32_t planeStackIndex; ++ VkSurfaceTransformFlagBitsKHR transform; ++ float globalAlpha; ++ VkDisplayPlaneAlphaFlagBitsKHR alphaMode; ++ VkExtent2D imageExtent; ++} VkDisplaySurfaceCreateInfoKHR_host; ++ ++typedef struct VkEventCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkEventCreateFlags flags; ++} VkEventCreateInfo; ++ ++typedef struct VkFenceCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkFenceCreateFlags flags; ++} VkFenceCreateInfo; ++ ++typedef struct VkFramebufferCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkFramebufferCreateFlags flags; ++ VkRenderPass DECLSPEC_ALIGN(8) renderPass; ++ uint32_t attachmentCount; ++ VkImageView *pAttachments; ++ uint32_t width; ++ uint32_t height; ++ uint32_t layers; ++} VkFramebufferCreateInfo; ++ ++typedef struct VkFramebufferCreateInfo_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkFramebufferCreateFlags flags; ++ VkRenderPass renderPass; ++ uint32_t attachmentCount; ++ VkImageView *pAttachments; ++ uint32_t width; ++ uint32_t height; ++ uint32_t layers; ++} VkFramebufferCreateInfo_host; ++ ++typedef struct VkVertexInputBindingDescription ++{ ++ uint32_t binding; ++ uint32_t stride; ++ VkVertexInputRate inputRate; ++} VkVertexInputBindingDescription; ++ ++typedef struct VkVertexInputAttributeDescription ++{ ++ uint32_t location; ++ uint32_t binding; ++ VkFormat format; ++ uint32_t offset; ++} VkVertexInputAttributeDescription; ++ ++typedef struct VkPipelineVertexInputStateCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkPipelineVertexInputStateCreateFlags flags; ++ uint32_t vertexBindingDescriptionCount; ++ VkVertexInputBindingDescription *pVertexBindingDescriptions; ++ uint32_t vertexAttributeDescriptionCount; ++ VkVertexInputAttributeDescription *pVertexAttributeDescriptions; ++} VkPipelineVertexInputStateCreateInfo; ++ ++typedef struct VkPipelineInputAssemblyStateCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkPipelineInputAssemblyStateCreateFlags flags; ++ VkPrimitiveTopology topology; ++ VkBool32 primitiveRestartEnable; ++} VkPipelineInputAssemblyStateCreateInfo; ++ ++typedef struct VkPipelineTessellationStateCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkPipelineTessellationStateCreateFlags flags; ++ uint32_t patchControlPoints; ++} VkPipelineTessellationStateCreateInfo; ++ ++typedef struct VkPipelineViewportStateCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkPipelineViewportStateCreateFlags flags; ++ uint32_t viewportCount; ++ VkViewport *pViewports; ++ uint32_t scissorCount; ++ VkRect2D *pScissors; ++} VkPipelineViewportStateCreateInfo; ++ ++typedef struct VkPipelineRasterizationStateCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkPipelineRasterizationStateCreateFlags flags; ++ VkBool32 depthClampEnable; ++ VkBool32 rasterizerDiscardEnable; ++ VkPolygonMode polygonMode; ++ VkCullModeFlags cullMode; ++ VkFrontFace frontFace; ++ VkBool32 depthBiasEnable; ++ float depthBiasConstantFactor; ++ float depthBiasClamp; ++ float depthBiasSlopeFactor; ++ float lineWidth; ++} VkPipelineRasterizationStateCreateInfo; ++ ++typedef struct VkPipelineMultisampleStateCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkPipelineMultisampleStateCreateFlags flags; ++ VkSampleCountFlagBits rasterizationSamples; ++ VkBool32 sampleShadingEnable; ++ float minSampleShading; ++ VkSampleMask *pSampleMask; ++ VkBool32 alphaToCoverageEnable; ++ VkBool32 alphaToOneEnable; ++} VkPipelineMultisampleStateCreateInfo; ++ ++typedef struct VkStencilOpState ++{ ++ VkStencilOp failOp; ++ VkStencilOp passOp; ++ VkStencilOp depthFailOp; ++ VkCompareOp compareOp; ++ uint32_t compareMask; ++ uint32_t writeMask; ++ uint32_t reference; ++} VkStencilOpState; ++ ++typedef struct VkPipelineDepthStencilStateCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkPipelineDepthStencilStateCreateFlags flags; ++ VkBool32 depthTestEnable; ++ VkBool32 depthWriteEnable; ++ VkCompareOp depthCompareOp; ++ VkBool32 depthBoundsTestEnable; ++ VkBool32 stencilTestEnable; ++ VkStencilOpState front; ++ VkStencilOpState back; ++ float minDepthBounds; ++ float maxDepthBounds; ++} VkPipelineDepthStencilStateCreateInfo; ++ ++typedef struct VkPipelineColorBlendAttachmentState ++{ ++ VkBool32 blendEnable; ++ VkBlendFactor srcColorBlendFactor; ++ VkBlendFactor dstColorBlendFactor; ++ VkBlendOp colorBlendOp; ++ VkBlendFactor srcAlphaBlendFactor; ++ VkBlendFactor dstAlphaBlendFactor; ++ VkBlendOp alphaBlendOp; ++ VkColorComponentFlags colorWriteMask; ++} VkPipelineColorBlendAttachmentState; ++ ++typedef struct VkPipelineColorBlendStateCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkPipelineColorBlendStateCreateFlags flags; ++ VkBool32 logicOpEnable; ++ VkLogicOp logicOp; ++ uint32_t attachmentCount; ++ VkPipelineColorBlendAttachmentState *pAttachments; ++ float blendConstants[4]; ++} VkPipelineColorBlendStateCreateInfo; ++ ++typedef struct VkPipelineDynamicStateCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkPipelineDynamicStateCreateFlags flags; ++ uint32_t dynamicStateCount; ++ VkDynamicState *pDynamicStates; ++} VkPipelineDynamicStateCreateInfo; ++ ++typedef struct VkGraphicsPipelineCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkPipelineCreateFlags flags; ++ uint32_t stageCount; ++ VkPipelineShaderStageCreateInfo *pStages; ++ VkPipelineVertexInputStateCreateInfo *pVertexInputState; ++ VkPipelineInputAssemblyStateCreateInfo *pInputAssemblyState; ++ VkPipelineTessellationStateCreateInfo *pTessellationState; ++ VkPipelineViewportStateCreateInfo *pViewportState; ++ VkPipelineRasterizationStateCreateInfo *pRasterizationState; ++ VkPipelineMultisampleStateCreateInfo *pMultisampleState; ++ VkPipelineDepthStencilStateCreateInfo *pDepthStencilState; ++ VkPipelineColorBlendStateCreateInfo *pColorBlendState; ++ VkPipelineDynamicStateCreateInfo *pDynamicState; ++ VkPipelineLayout DECLSPEC_ALIGN(8) layout; ++ VkRenderPass DECLSPEC_ALIGN(8) renderPass; ++ uint32_t subpass; ++ VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle; ++ int32_t basePipelineIndex; ++} VkGraphicsPipelineCreateInfo; ++ ++typedef struct VkGraphicsPipelineCreateInfo_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkPipelineCreateFlags flags; ++ uint32_t stageCount; ++ VkPipelineShaderStageCreateInfo_host *pStages; ++ VkPipelineVertexInputStateCreateInfo *pVertexInputState; ++ VkPipelineInputAssemblyStateCreateInfo *pInputAssemblyState; ++ VkPipelineTessellationStateCreateInfo *pTessellationState; ++ VkPipelineViewportStateCreateInfo *pViewportState; ++ VkPipelineRasterizationStateCreateInfo *pRasterizationState; ++ VkPipelineMultisampleStateCreateInfo *pMultisampleState; ++ VkPipelineDepthStencilStateCreateInfo *pDepthStencilState; ++ VkPipelineColorBlendStateCreateInfo *pColorBlendState; ++ VkPipelineDynamicStateCreateInfo *pDynamicState; ++ VkPipelineLayout layout; ++ VkRenderPass renderPass; ++ uint32_t subpass; ++ VkPipeline basePipelineHandle; ++ int32_t basePipelineIndex; ++} VkGraphicsPipelineCreateInfo_host; ++ ++typedef struct VkImageCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkImageCreateFlags flags; ++ VkImageType imageType; ++ VkFormat format; ++ VkExtent3D extent; ++ uint32_t mipLevels; ++ uint32_t arrayLayers; ++ VkSampleCountFlagBits samples; ++ VkImageTiling tiling; ++ VkImageUsageFlags usage; ++ VkSharingMode sharingMode; ++ uint32_t queueFamilyIndexCount; ++ uint32_t *pQueueFamilyIndices; ++ VkImageLayout initialLayout; ++} VkImageCreateInfo; ++ ++typedef struct VkComponentMapping ++{ ++ VkComponentSwizzle r; ++ VkComponentSwizzle g; ++ VkComponentSwizzle b; ++ VkComponentSwizzle a; ++} VkComponentMapping; ++ ++typedef struct VkImageViewCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkImageViewCreateFlags flags; ++ VkImage DECLSPEC_ALIGN(8) image; ++ VkImageViewType viewType; ++ VkFormat format; ++ VkComponentMapping components; ++ VkImageSubresourceRange subresourceRange; ++} VkImageViewCreateInfo; ++ ++typedef struct VkImageViewCreateInfo_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkImageViewCreateFlags flags; ++ VkImage image; ++ VkImageViewType viewType; ++ VkFormat format; ++ VkComponentMapping components; ++ VkImageSubresourceRange subresourceRange; ++} VkImageViewCreateInfo_host; ++ ++typedef struct VkApplicationInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ char *pApplicationName; ++ uint32_t applicationVersion; ++ char *pEngineName; ++ uint32_t engineVersion; ++ uint32_t apiVersion; ++} VkApplicationInfo; ++ ++typedef struct VkInstanceCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkInstanceCreateFlags flags; ++ VkApplicationInfo *pApplicationInfo; ++ uint32_t enabledLayerCount; ++ char **ppEnabledLayerNames; ++ uint32_t enabledExtensionCount; ++ char **ppEnabledExtensionNames; ++} VkInstanceCreateInfo; ++ ++typedef struct VkPipelineCacheCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkPipelineCacheCreateFlags flags; ++ size_t initialDataSize; ++ void *pInitialData; ++} VkPipelineCacheCreateInfo; ++ ++typedef struct VkPushConstantRange ++{ ++ VkShaderStageFlags stageFlags; ++ uint32_t offset; ++ uint32_t size; ++} VkPushConstantRange; ++ ++typedef struct VkPipelineLayoutCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkPipelineLayoutCreateFlags flags; ++ uint32_t setLayoutCount; ++ VkDescriptorSetLayout *pSetLayouts; ++ uint32_t pushConstantRangeCount; ++ VkPushConstantRange *pPushConstantRanges; ++} VkPipelineLayoutCreateInfo; ++ ++typedef struct VkQueryPoolCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkQueryPoolCreateFlags flags; ++ VkQueryType queryType; ++ uint32_t queryCount; ++ VkQueryPipelineStatisticFlags pipelineStatistics; ++} VkQueryPoolCreateInfo; ++ ++typedef struct VkAttachmentDescription ++{ ++ VkAttachmentDescriptionFlags flags; ++ VkFormat format; ++ VkSampleCountFlagBits samples; ++ VkAttachmentLoadOp loadOp; ++ VkAttachmentStoreOp storeOp; ++ VkAttachmentLoadOp stencilLoadOp; ++ VkAttachmentStoreOp stencilStoreOp; ++ VkImageLayout initialLayout; ++ VkImageLayout finalLayout; ++} VkAttachmentDescription; ++ ++typedef struct VkAttachmentReference ++{ ++ uint32_t attachment; ++ VkImageLayout layout; ++} VkAttachmentReference; ++ ++typedef struct VkSubpassDescription ++{ ++ VkSubpassDescriptionFlags flags; ++ VkPipelineBindPoint pipelineBindPoint; ++ uint32_t inputAttachmentCount; ++ VkAttachmentReference *pInputAttachments; ++ uint32_t colorAttachmentCount; ++ VkAttachmentReference *pColorAttachments; ++ VkAttachmentReference *pResolveAttachments; ++ VkAttachmentReference *pDepthStencilAttachment; ++ uint32_t preserveAttachmentCount; ++ uint32_t *pPreserveAttachments; ++} VkSubpassDescription; ++ ++typedef struct VkSubpassDependency ++{ ++ uint32_t srcSubpass; ++ uint32_t dstSubpass; ++ VkPipelineStageFlags srcStageMask; ++ VkPipelineStageFlags dstStageMask; ++ VkAccessFlags srcAccessMask; ++ VkAccessFlags dstAccessMask; ++ VkDependencyFlags dependencyFlags; ++} VkSubpassDependency; ++ ++typedef struct VkRenderPassCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkRenderPassCreateFlags flags; ++ uint32_t attachmentCount; ++ VkAttachmentDescription *pAttachments; ++ uint32_t subpassCount; ++ VkSubpassDescription *pSubpasses; ++ uint32_t dependencyCount; ++ VkSubpassDependency *pDependencies; ++} VkRenderPassCreateInfo; ++ ++typedef struct VkSamplerCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkSamplerCreateFlags flags; ++ VkFilter magFilter; ++ VkFilter minFilter; ++ VkSamplerMipmapMode mipmapMode; ++ VkSamplerAddressMode addressModeU; ++ VkSamplerAddressMode addressModeV; ++ VkSamplerAddressMode addressModeW; ++ float mipLodBias; ++ VkBool32 anisotropyEnable; ++ float maxAnisotropy; ++ VkBool32 compareEnable; ++ VkCompareOp compareOp; ++ float minLod; ++ float maxLod; ++ VkBorderColor borderColor; ++ VkBool32 unnormalizedCoordinates; ++} VkSamplerCreateInfo; ++ ++typedef struct VkSemaphoreCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkSemaphoreCreateFlags flags; ++} VkSemaphoreCreateInfo; ++ ++typedef struct VkShaderModuleCreateInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkShaderModuleCreateFlags flags; ++ size_t codeSize; ++ uint32_t *pCode; ++} VkShaderModuleCreateInfo; ++ ++typedef struct VkSwapchainCreateInfoKHR ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkSwapchainCreateFlagsKHR flags; ++ VkSurfaceKHR DECLSPEC_ALIGN(8) surface; ++ uint32_t minImageCount; ++ VkFormat imageFormat; ++ VkColorSpaceKHR imageColorSpace; ++ VkExtent2D imageExtent; ++ uint32_t imageArrayLayers; ++ VkImageUsageFlags imageUsage; ++ VkSharingMode imageSharingMode; ++ uint32_t queueFamilyIndexCount; ++ uint32_t *pQueueFamilyIndices; ++ VkSurfaceTransformFlagBitsKHR preTransform; ++ VkCompositeAlphaFlagBitsKHR compositeAlpha; ++ VkPresentModeKHR presentMode; ++ VkBool32 clipped; ++ VkSwapchainKHR DECLSPEC_ALIGN(8) oldSwapchain; ++} VkSwapchainCreateInfoKHR; ++ ++typedef struct VkSwapchainCreateInfoKHR_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkSwapchainCreateFlagsKHR flags; ++ VkSurfaceKHR surface; ++ uint32_t minImageCount; ++ VkFormat imageFormat; ++ VkColorSpaceKHR imageColorSpace; ++ VkExtent2D imageExtent; ++ uint32_t imageArrayLayers; ++ VkImageUsageFlags imageUsage; ++ VkSharingMode imageSharingMode; ++ uint32_t queueFamilyIndexCount; ++ uint32_t *pQueueFamilyIndices; ++ VkSurfaceTransformFlagBitsKHR preTransform; ++ VkCompositeAlphaFlagBitsKHR compositeAlpha; ++ VkPresentModeKHR presentMode; ++ VkBool32 clipped; ++ VkSwapchainKHR oldSwapchain; ++} VkSwapchainCreateInfoKHR_host; ++ ++typedef struct VkWin32SurfaceCreateInfoKHR ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkWin32SurfaceCreateFlagsKHR flags; ++ HINSTANCE hinstance; ++ HWND hwnd; ++} VkWin32SurfaceCreateInfoKHR; ++ ++typedef struct VkXcbSurfaceCreateInfoKHR_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkXcbSurfaceCreateFlagsKHR_host flags; ++ xcb_connection_t *connection; ++ xcb_window_t window; ++} VkXcbSurfaceCreateInfoKHR_host; ++ ++typedef struct VkXlibSurfaceCreateInfoKHR_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkXlibSurfaceCreateFlagsKHR_host flags; ++ Display *dpy; ++ Window window; ++} VkXlibSurfaceCreateInfoKHR_host; ++ ++typedef struct VkExtensionProperties ++{ ++ char extensionName[256]; ++ uint32_t specVersion; ++} VkExtensionProperties; ++ ++typedef struct VkLayerProperties ++{ ++ char layerName[256]; ++ uint32_t specVersion; ++ uint32_t implementationVersion; ++ char description[256]; ++} VkLayerProperties; ++ ++typedef struct VkMappedMemoryRange ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkDeviceMemory DECLSPEC_ALIGN(8) memory; ++ VkDeviceSize DECLSPEC_ALIGN(8) offset; ++ VkDeviceSize DECLSPEC_ALIGN(8) size; ++} VkMappedMemoryRange; ++ ++typedef struct VkMappedMemoryRange_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkDeviceMemory memory; ++ VkDeviceSize offset; ++ VkDeviceSize size; ++} VkMappedMemoryRange_host; ++ ++typedef struct VkMemoryRequirements ++{ ++ VkDeviceSize DECLSPEC_ALIGN(8) size; ++ VkDeviceSize DECLSPEC_ALIGN(8) alignment; ++ uint32_t memoryTypeBits; ++} VkMemoryRequirements; ++ ++typedef struct VkMemoryRequirements_host ++{ ++ VkDeviceSize size; ++ VkDeviceSize alignment; ++ uint32_t memoryTypeBits; ++} VkMemoryRequirements_host; ++ ++typedef struct VkDisplayModePropertiesKHR ++{ ++ VkDisplayModeKHR DECLSPEC_ALIGN(8) displayMode; ++ VkDisplayModeParametersKHR parameters; ++} VkDisplayModePropertiesKHR; ++ ++typedef struct VkDisplayModePropertiesKHR_host ++{ ++ VkDisplayModeKHR displayMode; ++ VkDisplayModeParametersKHR parameters; ++} VkDisplayModePropertiesKHR_host; ++ ++typedef struct VkDisplayPlaneCapabilitiesKHR ++{ ++ VkDisplayPlaneAlphaFlagsKHR supportedAlpha; ++ VkOffset2D minSrcPosition; ++ VkOffset2D maxSrcPosition; ++ VkExtent2D minSrcExtent; ++ VkExtent2D maxSrcExtent; ++ VkOffset2D minDstPosition; ++ VkOffset2D maxDstPosition; ++ VkExtent2D minDstExtent; ++ VkExtent2D maxDstExtent; ++} VkDisplayPlaneCapabilitiesKHR; ++ ++typedef struct VkSparseImageFormatProperties ++{ ++ VkImageAspectFlags aspectMask; ++ VkExtent3D imageGranularity; ++ VkSparseImageFormatFlags flags; ++} VkSparseImageFormatProperties; ++ ++typedef struct VkSparseImageMemoryRequirements ++{ ++ VkSparseImageFormatProperties formatProperties; ++ uint32_t imageMipTailFirstLod; ++ VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailSize; ++ VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailOffset; ++ VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailStride; ++} VkSparseImageMemoryRequirements; ++ ++typedef struct VkSparseImageMemoryRequirements_host ++{ ++ VkSparseImageFormatProperties formatProperties; ++ uint32_t imageMipTailFirstLod; ++ VkDeviceSize imageMipTailSize; ++ VkDeviceSize imageMipTailOffset; ++ VkDeviceSize imageMipTailStride; ++} VkSparseImageMemoryRequirements_host; ++ ++typedef struct VkImageSubresource ++{ ++ VkImageAspectFlags aspectMask; ++ uint32_t mipLevel; ++ uint32_t arrayLayer; ++} VkImageSubresource; ++ ++typedef struct VkSubresourceLayout ++{ ++ VkDeviceSize DECLSPEC_ALIGN(8) offset; ++ VkDeviceSize DECLSPEC_ALIGN(8) size; ++ VkDeviceSize DECLSPEC_ALIGN(8) rowPitch; ++ VkDeviceSize DECLSPEC_ALIGN(8) arrayPitch; ++ VkDeviceSize DECLSPEC_ALIGN(8) depthPitch; ++} VkSubresourceLayout; ++ ++typedef struct VkSubresourceLayout_host ++{ ++ VkDeviceSize offset; ++ VkDeviceSize size; ++ VkDeviceSize rowPitch; ++ VkDeviceSize arrayPitch; ++ VkDeviceSize depthPitch; ++} VkSubresourceLayout_host; ++ ++typedef struct VkDisplayPlanePropertiesKHR ++{ ++ VkDisplayKHR DECLSPEC_ALIGN(8) currentDisplay; ++ uint32_t currentStackIndex; ++} VkDisplayPlanePropertiesKHR; ++ ++typedef struct VkDisplayPlanePropertiesKHR_host ++{ ++ VkDisplayKHR currentDisplay; ++ uint32_t currentStackIndex; ++} VkDisplayPlanePropertiesKHR_host; ++ ++typedef struct VkDisplayPropertiesKHR ++{ ++ VkDisplayKHR DECLSPEC_ALIGN(8) display; ++ char *displayName; ++ VkExtent2D physicalDimensions; ++ VkExtent2D physicalResolution; ++ VkSurfaceTransformFlagsKHR supportedTransforms; ++ VkBool32 planeReorderPossible; ++ VkBool32 persistentContent; ++} VkDisplayPropertiesKHR; ++ ++typedef struct VkDisplayPropertiesKHR_host ++{ ++ VkDisplayKHR display; ++ char *displayName; ++ VkExtent2D physicalDimensions; ++ VkExtent2D physicalResolution; ++ VkSurfaceTransformFlagsKHR supportedTransforms; ++ VkBool32 planeReorderPossible; ++ VkBool32 persistentContent; ++} VkDisplayPropertiesKHR_host; ++ ++typedef struct VkFormatProperties ++{ ++ VkFormatFeatureFlags linearTilingFeatures; ++ VkFormatFeatureFlags optimalTilingFeatures; ++ VkFormatFeatureFlags bufferFeatures; ++} VkFormatProperties; ++ ++typedef struct VkImageFormatProperties ++{ ++ VkExtent3D maxExtent; ++ uint32_t maxMipLevels; ++ uint32_t maxArrayLayers; ++ VkSampleCountFlags sampleCounts; ++ VkDeviceSize DECLSPEC_ALIGN(8) maxResourceSize; ++} VkImageFormatProperties; ++ ++typedef struct VkImageFormatProperties_host ++{ ++ VkExtent3D maxExtent; ++ uint32_t maxMipLevels; ++ uint32_t maxArrayLayers; ++ VkSampleCountFlags sampleCounts; ++ VkDeviceSize maxResourceSize; ++} VkImageFormatProperties_host; ++ ++typedef struct VkMemoryType ++{ ++ VkMemoryPropertyFlags propertyFlags; ++ uint32_t heapIndex; ++} VkMemoryType; ++ ++typedef struct VkMemoryHeap ++{ ++ VkDeviceSize DECLSPEC_ALIGN(8) size; ++ VkMemoryHeapFlags flags; ++} VkMemoryHeap; ++ ++typedef struct VkMemoryHeap_host ++{ ++ VkDeviceSize size; ++ VkMemoryHeapFlags flags; ++} VkMemoryHeap_host; ++ ++typedef struct VkPhysicalDeviceMemoryProperties ++{ ++ uint32_t memoryTypeCount; ++ VkMemoryType memoryTypes[32]; ++ uint32_t memoryHeapCount; ++ VkMemoryHeap DECLSPEC_ALIGN(8) memoryHeaps[16]; ++} VkPhysicalDeviceMemoryProperties; ++ ++typedef struct VkPhysicalDeviceMemoryProperties_host ++{ ++ uint32_t memoryTypeCount; ++ VkMemoryType memoryTypes[32]; ++ uint32_t memoryHeapCount; ++ VkMemoryHeap_host memoryHeaps[16]; ++} VkPhysicalDeviceMemoryProperties_host; ++ ++typedef struct VkPhysicalDeviceLimits ++{ ++ uint32_t maxImageDimension1D; ++ uint32_t maxImageDimension2D; ++ uint32_t maxImageDimension3D; ++ uint32_t maxImageDimensionCube; ++ uint32_t maxImageArrayLayers; ++ uint32_t maxTexelBufferElements; ++ uint32_t maxUniformBufferRange; ++ uint32_t maxStorageBufferRange; ++ uint32_t maxPushConstantsSize; ++ uint32_t maxMemoryAllocationCount; ++ uint32_t maxSamplerAllocationCount; ++ VkDeviceSize DECLSPEC_ALIGN(8) bufferImageGranularity; ++ VkDeviceSize DECLSPEC_ALIGN(8) sparseAddressSpaceSize; ++ uint32_t maxBoundDescriptorSets; ++ uint32_t maxPerStageDescriptorSamplers; ++ uint32_t maxPerStageDescriptorUniformBuffers; ++ uint32_t maxPerStageDescriptorStorageBuffers; ++ uint32_t maxPerStageDescriptorSampledImages; ++ uint32_t maxPerStageDescriptorStorageImages; ++ uint32_t maxPerStageDescriptorInputAttachments; ++ uint32_t maxPerStageResources; ++ uint32_t maxDescriptorSetSamplers; ++ uint32_t maxDescriptorSetUniformBuffers; ++ uint32_t maxDescriptorSetUniformBuffersDynamic; ++ uint32_t maxDescriptorSetStorageBuffers; ++ uint32_t maxDescriptorSetStorageBuffersDynamic; ++ uint32_t maxDescriptorSetSampledImages; ++ uint32_t maxDescriptorSetStorageImages; ++ uint32_t maxDescriptorSetInputAttachments; ++ uint32_t maxVertexInputAttributes; ++ uint32_t maxVertexInputBindings; ++ uint32_t maxVertexInputAttributeOffset; ++ uint32_t maxVertexInputBindingStride; ++ uint32_t maxVertexOutputComponents; ++ uint32_t maxTessellationGenerationLevel; ++ uint32_t maxTessellationPatchSize; ++ uint32_t maxTessellationControlPerVertexInputComponents; ++ uint32_t maxTessellationControlPerVertexOutputComponents; ++ uint32_t maxTessellationControlPerPatchOutputComponents; ++ uint32_t maxTessellationControlTotalOutputComponents; ++ uint32_t maxTessellationEvaluationInputComponents; ++ uint32_t maxTessellationEvaluationOutputComponents; ++ uint32_t maxGeometryShaderInvocations; ++ uint32_t maxGeometryInputComponents; ++ uint32_t maxGeometryOutputComponents; ++ uint32_t maxGeometryOutputVertices; ++ uint32_t maxGeometryTotalOutputComponents; ++ uint32_t maxFragmentInputComponents; ++ uint32_t maxFragmentOutputAttachments; ++ uint32_t maxFragmentDualSrcAttachments; ++ uint32_t maxFragmentCombinedOutputResources; ++ uint32_t maxComputeSharedMemorySize; ++ uint32_t maxComputeWorkGroupCount[3]; ++ uint32_t maxComputeWorkGroupInvocations; ++ uint32_t maxComputeWorkGroupSize[3]; ++ uint32_t subPixelPrecisionBits; ++ uint32_t subTexelPrecisionBits; ++ uint32_t mipmapPrecisionBits; ++ uint32_t maxDrawIndexedIndexValue; ++ uint32_t maxDrawIndirectCount; ++ float maxSamplerLodBias; ++ float maxSamplerAnisotropy; ++ uint32_t maxViewports; ++ uint32_t maxViewportDimensions[2]; ++ float viewportBoundsRange[2]; ++ uint32_t viewportSubPixelBits; ++ size_t minMemoryMapAlignment; ++ VkDeviceSize DECLSPEC_ALIGN(8) minTexelBufferOffsetAlignment; ++ VkDeviceSize DECLSPEC_ALIGN(8) minUniformBufferOffsetAlignment; ++ VkDeviceSize DECLSPEC_ALIGN(8) minStorageBufferOffsetAlignment; ++ int32_t minTexelOffset; ++ uint32_t maxTexelOffset; ++ int32_t minTexelGatherOffset; ++ uint32_t maxTexelGatherOffset; ++ float minInterpolationOffset; ++ float maxInterpolationOffset; ++ uint32_t subPixelInterpolationOffsetBits; ++ uint32_t maxFramebufferWidth; ++ uint32_t maxFramebufferHeight; ++ uint32_t maxFramebufferLayers; ++ VkSampleCountFlags framebufferColorSampleCounts; ++ VkSampleCountFlags framebufferDepthSampleCounts; ++ VkSampleCountFlags framebufferStencilSampleCounts; ++ VkSampleCountFlags framebufferNoAttachmentsSampleCounts; ++ uint32_t maxColorAttachments; ++ VkSampleCountFlags sampledImageColorSampleCounts; ++ VkSampleCountFlags sampledImageIntegerSampleCounts; ++ VkSampleCountFlags sampledImageDepthSampleCounts; ++ VkSampleCountFlags sampledImageStencilSampleCounts; ++ VkSampleCountFlags storageImageSampleCounts; ++ uint32_t maxSampleMaskWords; ++ VkBool32 timestampComputeAndGraphics; ++ float timestampPeriod; ++ uint32_t maxClipDistances; ++ uint32_t maxCullDistances; ++ uint32_t maxCombinedClipAndCullDistances; ++ uint32_t discreteQueuePriorities; ++ float pointSizeRange[2]; ++ float lineWidthRange[2]; ++ float pointSizeGranularity; ++ float lineWidthGranularity; ++ VkBool32 strictLines; ++ VkBool32 standardSampleLocations; ++ VkDeviceSize DECLSPEC_ALIGN(8) optimalBufferCopyOffsetAlignment; ++ VkDeviceSize DECLSPEC_ALIGN(8) optimalBufferCopyRowPitchAlignment; ++ VkDeviceSize DECLSPEC_ALIGN(8) nonCoherentAtomSize; ++} VkPhysicalDeviceLimits; ++ ++typedef struct VkPhysicalDeviceLimits_host ++{ ++ uint32_t maxImageDimension1D; ++ uint32_t maxImageDimension2D; ++ uint32_t maxImageDimension3D; ++ uint32_t maxImageDimensionCube; ++ uint32_t maxImageArrayLayers; ++ uint32_t maxTexelBufferElements; ++ uint32_t maxUniformBufferRange; ++ uint32_t maxStorageBufferRange; ++ uint32_t maxPushConstantsSize; ++ uint32_t maxMemoryAllocationCount; ++ uint32_t maxSamplerAllocationCount; ++ VkDeviceSize bufferImageGranularity; ++ VkDeviceSize sparseAddressSpaceSize; ++ uint32_t maxBoundDescriptorSets; ++ uint32_t maxPerStageDescriptorSamplers; ++ uint32_t maxPerStageDescriptorUniformBuffers; ++ uint32_t maxPerStageDescriptorStorageBuffers; ++ uint32_t maxPerStageDescriptorSampledImages; ++ uint32_t maxPerStageDescriptorStorageImages; ++ uint32_t maxPerStageDescriptorInputAttachments; ++ uint32_t maxPerStageResources; ++ uint32_t maxDescriptorSetSamplers; ++ uint32_t maxDescriptorSetUniformBuffers; ++ uint32_t maxDescriptorSetUniformBuffersDynamic; ++ uint32_t maxDescriptorSetStorageBuffers; ++ uint32_t maxDescriptorSetStorageBuffersDynamic; ++ uint32_t maxDescriptorSetSampledImages; ++ uint32_t maxDescriptorSetStorageImages; ++ uint32_t maxDescriptorSetInputAttachments; ++ uint32_t maxVertexInputAttributes; ++ uint32_t maxVertexInputBindings; ++ uint32_t maxVertexInputAttributeOffset; ++ uint32_t maxVertexInputBindingStride; ++ uint32_t maxVertexOutputComponents; ++ uint32_t maxTessellationGenerationLevel; ++ uint32_t maxTessellationPatchSize; ++ uint32_t maxTessellationControlPerVertexInputComponents; ++ uint32_t maxTessellationControlPerVertexOutputComponents; ++ uint32_t maxTessellationControlPerPatchOutputComponents; ++ uint32_t maxTessellationControlTotalOutputComponents; ++ uint32_t maxTessellationEvaluationInputComponents; ++ uint32_t maxTessellationEvaluationOutputComponents; ++ uint32_t maxGeometryShaderInvocations; ++ uint32_t maxGeometryInputComponents; ++ uint32_t maxGeometryOutputComponents; ++ uint32_t maxGeometryOutputVertices; ++ uint32_t maxGeometryTotalOutputComponents; ++ uint32_t maxFragmentInputComponents; ++ uint32_t maxFragmentOutputAttachments; ++ uint32_t maxFragmentDualSrcAttachments; ++ uint32_t maxFragmentCombinedOutputResources; ++ uint32_t maxComputeSharedMemorySize; ++ uint32_t maxComputeWorkGroupCount[3]; ++ uint32_t maxComputeWorkGroupInvocations; ++ uint32_t maxComputeWorkGroupSize[3]; ++ uint32_t subPixelPrecisionBits; ++ uint32_t subTexelPrecisionBits; ++ uint32_t mipmapPrecisionBits; ++ uint32_t maxDrawIndexedIndexValue; ++ uint32_t maxDrawIndirectCount; ++ float maxSamplerLodBias; ++ float maxSamplerAnisotropy; ++ uint32_t maxViewports; ++ uint32_t maxViewportDimensions[2]; ++ float viewportBoundsRange[2]; ++ uint32_t viewportSubPixelBits; ++ size_t minMemoryMapAlignment; ++ VkDeviceSize minTexelBufferOffsetAlignment; ++ VkDeviceSize minUniformBufferOffsetAlignment; ++ VkDeviceSize minStorageBufferOffsetAlignment; ++ int32_t minTexelOffset; ++ uint32_t maxTexelOffset; ++ int32_t minTexelGatherOffset; ++ uint32_t maxTexelGatherOffset; ++ float minInterpolationOffset; ++ float maxInterpolationOffset; ++ uint32_t subPixelInterpolationOffsetBits; ++ uint32_t maxFramebufferWidth; ++ uint32_t maxFramebufferHeight; ++ uint32_t maxFramebufferLayers; ++ VkSampleCountFlags framebufferColorSampleCounts; ++ VkSampleCountFlags framebufferDepthSampleCounts; ++ VkSampleCountFlags framebufferStencilSampleCounts; ++ VkSampleCountFlags framebufferNoAttachmentsSampleCounts; ++ uint32_t maxColorAttachments; ++ VkSampleCountFlags sampledImageColorSampleCounts; ++ VkSampleCountFlags sampledImageIntegerSampleCounts; ++ VkSampleCountFlags sampledImageDepthSampleCounts; ++ VkSampleCountFlags sampledImageStencilSampleCounts; ++ VkSampleCountFlags storageImageSampleCounts; ++ uint32_t maxSampleMaskWords; ++ VkBool32 timestampComputeAndGraphics; ++ float timestampPeriod; ++ uint32_t maxClipDistances; ++ uint32_t maxCullDistances; ++ uint32_t maxCombinedClipAndCullDistances; ++ uint32_t discreteQueuePriorities; ++ float pointSizeRange[2]; ++ float lineWidthRange[2]; ++ float pointSizeGranularity; ++ float lineWidthGranularity; ++ VkBool32 strictLines; ++ VkBool32 standardSampleLocations; ++ VkDeviceSize optimalBufferCopyOffsetAlignment; ++ VkDeviceSize optimalBufferCopyRowPitchAlignment; ++ VkDeviceSize nonCoherentAtomSize; ++} VkPhysicalDeviceLimits_host; ++ ++typedef struct VkPhysicalDeviceSparseProperties ++{ ++ VkBool32 residencyStandard2DBlockShape; ++ VkBool32 residencyStandard2DMultisampleBlockShape; ++ VkBool32 residencyStandard3DBlockShape; ++ VkBool32 residencyAlignedMipSize; ++ VkBool32 residencyNonResidentStrict; ++} VkPhysicalDeviceSparseProperties; ++ ++typedef struct VkPhysicalDeviceProperties ++{ ++ uint32_t apiVersion; ++ uint32_t driverVersion; ++ uint32_t vendorID; ++ uint32_t deviceID; ++ VkPhysicalDeviceType deviceType; ++ char deviceName[256]; ++ uint8_t pipelineCacheUUID[16]; ++ VkPhysicalDeviceLimits DECLSPEC_ALIGN(8) limits; ++ VkPhysicalDeviceSparseProperties sparseProperties; ++} VkPhysicalDeviceProperties; ++ ++typedef struct VkPhysicalDeviceProperties_host ++{ ++ uint32_t apiVersion; ++ uint32_t driverVersion; ++ uint32_t vendorID; ++ uint32_t deviceID; ++ VkPhysicalDeviceType deviceType; ++ char deviceName[256]; ++ uint8_t pipelineCacheUUID[16]; ++ VkPhysicalDeviceLimits_host limits; ++ VkPhysicalDeviceSparseProperties sparseProperties; ++} VkPhysicalDeviceProperties_host; ++ ++typedef struct VkQueueFamilyProperties ++{ ++ VkQueueFlags queueFlags; ++ uint32_t queueCount; ++ uint32_t timestampValidBits; ++ VkExtent3D minImageTransferGranularity; ++} VkQueueFamilyProperties; ++ ++typedef struct VkSurfaceCapabilitiesKHR ++{ ++ uint32_t minImageCount; ++ uint32_t maxImageCount; ++ VkExtent2D currentExtent; ++ VkExtent2D minImageExtent; ++ VkExtent2D maxImageExtent; ++ uint32_t maxImageArrayLayers; ++ VkSurfaceTransformFlagsKHR supportedTransforms; ++ VkSurfaceTransformFlagBitsKHR currentTransform; ++ VkCompositeAlphaFlagsKHR supportedCompositeAlpha; ++ VkImageUsageFlags supportedUsageFlags; ++} VkSurfaceCapabilitiesKHR; ++ ++typedef struct VkSurfaceFormatKHR ++{ ++ VkFormat format; ++ VkColorSpaceKHR colorSpace; ++} VkSurfaceFormatKHR; ++ ++typedef struct VkSparseMemoryBind ++{ ++ VkDeviceSize DECLSPEC_ALIGN(8) resourceOffset; ++ VkDeviceSize DECLSPEC_ALIGN(8) size; ++ VkDeviceMemory DECLSPEC_ALIGN(8) memory; ++ VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset; ++ VkSparseMemoryBindFlags flags; ++} VkSparseMemoryBind; ++ ++typedef struct VkSparseMemoryBind_host ++{ ++ VkDeviceSize resourceOffset; ++ VkDeviceSize size; ++ VkDeviceMemory memory; ++ VkDeviceSize memoryOffset; ++ VkSparseMemoryBindFlags flags; ++} VkSparseMemoryBind_host; ++ ++typedef struct VkSparseBufferMemoryBindInfo ++{ ++ VkBuffer DECLSPEC_ALIGN(8) buffer; ++ uint32_t bindCount; ++ VkSparseMemoryBind *pBinds; ++} VkSparseBufferMemoryBindInfo; ++ ++typedef struct VkSparseBufferMemoryBindInfo_host ++{ ++ VkBuffer buffer; ++ uint32_t bindCount; ++ VkSparseMemoryBind_host *pBinds; ++} VkSparseBufferMemoryBindInfo_host; ++ ++typedef struct VkSparseImageOpaqueMemoryBindInfo ++{ ++ VkImage DECLSPEC_ALIGN(8) image; ++ uint32_t bindCount; ++ VkSparseMemoryBind *pBinds; ++} VkSparseImageOpaqueMemoryBindInfo; ++ ++typedef struct VkSparseImageOpaqueMemoryBindInfo_host ++{ ++ VkImage image; ++ uint32_t bindCount; ++ VkSparseMemoryBind_host *pBinds; ++} VkSparseImageOpaqueMemoryBindInfo_host; ++ ++typedef struct VkSparseImageMemoryBind ++{ ++ VkImageSubresource subresource; ++ VkOffset3D offset; ++ VkExtent3D extent; ++ VkDeviceMemory DECLSPEC_ALIGN(8) memory; ++ VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset; ++ VkSparseMemoryBindFlags flags; ++} VkSparseImageMemoryBind; ++ ++typedef struct VkSparseImageMemoryBind_host ++{ ++ VkImageSubresource subresource; ++ VkOffset3D offset; ++ VkExtent3D extent; ++ VkDeviceMemory memory; ++ VkDeviceSize memoryOffset; ++ VkSparseMemoryBindFlags flags; ++} VkSparseImageMemoryBind_host; ++ ++typedef struct VkSparseImageMemoryBindInfo ++{ ++ VkImage DECLSPEC_ALIGN(8) image; ++ uint32_t bindCount; ++ VkSparseImageMemoryBind *pBinds; ++} VkSparseImageMemoryBindInfo; ++ ++typedef struct VkSparseImageMemoryBindInfo_host ++{ ++ VkImage image; ++ uint32_t bindCount; ++ VkSparseImageMemoryBind_host *pBinds; ++} VkSparseImageMemoryBindInfo_host; ++ ++typedef struct VkBindSparseInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ uint32_t waitSemaphoreCount; ++ VkSemaphore *pWaitSemaphores; ++ uint32_t bufferBindCount; ++ VkSparseBufferMemoryBindInfo *pBufferBinds; ++ uint32_t imageOpaqueBindCount; ++ VkSparseImageOpaqueMemoryBindInfo *pImageOpaqueBinds; ++ uint32_t imageBindCount; ++ VkSparseImageMemoryBindInfo *pImageBinds; ++ uint32_t signalSemaphoreCount; ++ VkSemaphore *pSignalSemaphores; ++} VkBindSparseInfo; ++ ++typedef struct VkBindSparseInfo_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ uint32_t waitSemaphoreCount; ++ VkSemaphore *pWaitSemaphores; ++ uint32_t bufferBindCount; ++ VkSparseBufferMemoryBindInfo_host *pBufferBinds; ++ uint32_t imageOpaqueBindCount; ++ VkSparseImageOpaqueMemoryBindInfo_host *pImageOpaqueBinds; ++ uint32_t imageBindCount; ++ VkSparseImageMemoryBindInfo_host *pImageBinds; ++ uint32_t signalSemaphoreCount; ++ VkSemaphore *pSignalSemaphores; ++} VkBindSparseInfo_host; ++ ++typedef struct VkPresentInfoKHR ++{ ++ VkStructureType sType; ++ void *pNext; ++ uint32_t waitSemaphoreCount; ++ VkSemaphore *pWaitSemaphores; ++ uint32_t swapchainCount; ++ VkSwapchainKHR *pSwapchains; ++ uint32_t *pImageIndices; ++ VkResult *pResults; ++} VkPresentInfoKHR; ++ ++typedef struct VkSubmitInfo ++{ ++ VkStructureType sType; ++ void *pNext; ++ uint32_t waitSemaphoreCount; ++ VkSemaphore *pWaitSemaphores; ++ VkPipelineStageFlags *pWaitDstStageMask; ++ uint32_t commandBufferCount; ++ VkCommandBuffer *pCommandBuffers; ++ uint32_t signalSemaphoreCount; ++ VkSemaphore *pSignalSemaphores; ++} VkSubmitInfo; ++ ++typedef struct VkDescriptorImageInfo ++{ ++ VkSampler DECLSPEC_ALIGN(8) sampler; ++ VkImageView DECLSPEC_ALIGN(8) imageView; ++ VkImageLayout imageLayout; ++} VkDescriptorImageInfo; ++ ++typedef struct VkDescriptorImageInfo_host ++{ ++ VkSampler sampler; ++ VkImageView imageView; ++ VkImageLayout imageLayout; ++} VkDescriptorImageInfo_host; ++ ++typedef struct VkDescriptorBufferInfo ++{ ++ VkBuffer DECLSPEC_ALIGN(8) buffer; ++ VkDeviceSize DECLSPEC_ALIGN(8) offset; ++ VkDeviceSize DECLSPEC_ALIGN(8) range; ++} VkDescriptorBufferInfo; ++ ++typedef struct VkDescriptorBufferInfo_host ++{ ++ VkBuffer buffer; ++ VkDeviceSize offset; ++ VkDeviceSize range; ++} VkDescriptorBufferInfo_host; ++ ++typedef struct VkWriteDescriptorSet ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkDescriptorSet DECLSPEC_ALIGN(8) dstSet; ++ uint32_t dstBinding; ++ uint32_t dstArrayElement; ++ uint32_t descriptorCount; ++ VkDescriptorType descriptorType; ++ VkDescriptorImageInfo *pImageInfo; ++ VkDescriptorBufferInfo *pBufferInfo; ++ VkBufferView *pTexelBufferView; ++} VkWriteDescriptorSet; ++ ++typedef struct VkWriteDescriptorSet_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkDescriptorSet dstSet; ++ uint32_t dstBinding; ++ uint32_t dstArrayElement; ++ uint32_t descriptorCount; ++ VkDescriptorType descriptorType; ++ VkDescriptorImageInfo_host *pImageInfo; ++ VkDescriptorBufferInfo_host *pBufferInfo; ++ VkBufferView *pTexelBufferView; ++} VkWriteDescriptorSet_host; ++ ++typedef struct VkCopyDescriptorSet ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkDescriptorSet DECLSPEC_ALIGN(8) srcSet; ++ uint32_t srcBinding; ++ uint32_t srcArrayElement; ++ VkDescriptorSet DECLSPEC_ALIGN(8) dstSet; ++ uint32_t dstBinding; ++ uint32_t dstArrayElement; ++ uint32_t descriptorCount; ++} VkCopyDescriptorSet; ++ ++typedef struct VkCopyDescriptorSet_host ++{ ++ VkStructureType sType; ++ void *pNext; ++ VkDescriptorSet srcSet; ++ uint32_t srcBinding; ++ uint32_t srcArrayElement; ++ VkDescriptorSet dstSet; ++ uint32_t dstBinding; ++ uint32_t dstArrayElement; ++ uint32_t descriptorCount; ++} VkCopyDescriptorSet_host; ++ ++extern VkResult (*p_vkAcquireNextImageKHR)( VkDevice, VkSwapchainKHR, uint64_t, VkSemaphore, ++ VkFence, uint32_t * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkAllocateCommandBuffers)( VkDevice, const VkCommandBufferAllocateInfo *, ++ VkCommandBuffer * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkAllocateDescriptorSets)( VkDevice, const VkDescriptorSetAllocateInfo *, ++ VkDescriptorSet * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkAllocateMemory)( VkDevice, const VkMemoryAllocateInfo *, ++ const VkAllocationCallbacks_host *, VkDeviceMemory * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkBeginCommandBuffer)( VkCommandBuffer, ++ const VkCommandBufferBeginInfo_host * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkBindBufferMemory)( VkDevice, VkBuffer, VkDeviceMemory, ++ VkDeviceSize ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkBindImageMemory)( VkDevice, VkImage, VkDeviceMemory, ++ VkDeviceSize ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdBeginQuery)( VkCommandBuffer, VkQueryPool, uint32_t, ++ VkQueryControlFlags ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdBeginRenderPass)( VkCommandBuffer, const VkRenderPassBeginInfo *, ++ VkSubpassContents ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdBindDescriptorSets)( VkCommandBuffer, VkPipelineBindPoint, VkPipelineLayout, ++ uint32_t, uint32_t, const VkDescriptorSet *, uint32_t, const uint32_t * ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdBindIndexBuffer)( VkCommandBuffer, VkBuffer, VkDeviceSize, ++ VkIndexType ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdBindPipeline)( VkCommandBuffer, VkPipelineBindPoint, ++ VkPipeline ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdBindVertexBuffers)( VkCommandBuffer, uint32_t, uint32_t, const VkBuffer *, ++ const VkDeviceSize * ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdBlitImage)( VkCommandBuffer, VkImage, VkImageLayout, VkImage, VkImageLayout, ++ uint32_t, const VkImageBlit *, VkFilter ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdClearAttachments)( VkCommandBuffer, uint32_t, const VkClearAttachment *, ++ uint32_t, const VkClearRect * ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdClearColorImage)( VkCommandBuffer, VkImage, VkImageLayout, ++ const VkClearColorValue *, uint32_t, const VkImageSubresourceRange * ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdClearDepthStencilImage)( VkCommandBuffer, VkImage, VkImageLayout, ++ const VkClearDepthStencilValue *, uint32_t, ++ const VkImageSubresourceRange * ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdCopyBuffer)( VkCommandBuffer, VkBuffer, VkBuffer, uint32_t, ++ const VkBufferCopy * ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdCopyBufferToImage)( VkCommandBuffer, VkBuffer, VkImage, VkImageLayout, ++ uint32_t, const VkBufferImageCopy * ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdCopyImage)( VkCommandBuffer, VkImage, VkImageLayout, VkImage, VkImageLayout, ++ uint32_t, const VkImageCopy * ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdCopyImageToBuffer)( VkCommandBuffer, VkImage, VkImageLayout, VkBuffer, ++ uint32_t, const VkBufferImageCopy * ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdCopyQueryPoolResults)( VkCommandBuffer, VkQueryPool, uint32_t, uint32_t, ++ VkBuffer, VkDeviceSize, VkDeviceSize, VkQueryResultFlags ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdDispatch)( VkCommandBuffer, uint32_t, uint32_t, uint32_t ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdDispatchIndirect)( VkCommandBuffer, VkBuffer, VkDeviceSize ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdDraw)( VkCommandBuffer, uint32_t, uint32_t, uint32_t, ++ uint32_t ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdDrawIndexed)( VkCommandBuffer, uint32_t, uint32_t, uint32_t, int32_t, ++ uint32_t ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdDrawIndexedIndirect)( VkCommandBuffer, VkBuffer, VkDeviceSize, uint32_t, ++ uint32_t ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdDrawIndirect)( VkCommandBuffer, VkBuffer, VkDeviceSize, uint32_t, ++ uint32_t ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdEndQuery)( VkCommandBuffer, VkQueryPool, uint32_t ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdEndRenderPass)( VkCommandBuffer ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdExecuteCommands)( VkCommandBuffer, uint32_t, ++ const VkCommandBuffer * ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdFillBuffer)( VkCommandBuffer, VkBuffer, VkDeviceSize, VkDeviceSize, ++ uint32_t ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdNextSubpass)( VkCommandBuffer, VkSubpassContents ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdPipelineBarrier)( VkCommandBuffer, VkPipelineStageFlags, VkPipelineStageFlags, ++ VkDependencyFlags, uint32_t, const VkMemoryBarrier *, uint32_t, ++ const VkBufferMemoryBarrier *, uint32_t, ++ const VkImageMemoryBarrier_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdPushConstants)( VkCommandBuffer, VkPipelineLayout, VkShaderStageFlags, ++ uint32_t, uint32_t, const void * ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdResetEvent)( VkCommandBuffer, VkEvent, VkPipelineStageFlags ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdResetQueryPool)( VkCommandBuffer, VkQueryPool, uint32_t, ++ uint32_t ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdResolveImage)( VkCommandBuffer, VkImage, VkImageLayout, VkImage, ++ VkImageLayout, uint32_t, const VkImageResolve * ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdSetBlendConstants)( VkCommandBuffer, const float[4] ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdSetDepthBias)( VkCommandBuffer, float, float, float ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdSetDepthBounds)( VkCommandBuffer, float, float ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdSetEvent)( VkCommandBuffer, VkEvent, VkPipelineStageFlags ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdSetLineWidth)( VkCommandBuffer, float ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdSetScissor)( VkCommandBuffer, uint32_t, uint32_t, ++ const VkRect2D * ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdSetStencilCompareMask)( VkCommandBuffer, VkStencilFaceFlags, ++ uint32_t ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdSetStencilReference)( VkCommandBuffer, VkStencilFaceFlags, ++ uint32_t ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdSetStencilWriteMask)( VkCommandBuffer, VkStencilFaceFlags, ++ uint32_t ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdSetViewport)( VkCommandBuffer, uint32_t, uint32_t, ++ const VkViewport * ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdUpdateBuffer)( VkCommandBuffer, VkBuffer, VkDeviceSize, VkDeviceSize, ++ const uint32_t * ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdWaitEvents)( VkCommandBuffer, uint32_t, const VkEvent *, VkPipelineStageFlags, ++ VkPipelineStageFlags, uint32_t, const VkMemoryBarrier *, uint32_t, ++ const VkBufferMemoryBarrier *, uint32_t, ++ const VkImageMemoryBarrier_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkCmdWriteTimestamp)( VkCommandBuffer, VkPipelineStageFlagBits, VkQueryPool, ++ uint32_t ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateBuffer)( VkDevice, const VkBufferCreateInfo_host *, ++ const VkAllocationCallbacks_host *, VkBuffer * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateBufferView)( VkDevice, const VkBufferViewCreateInfo_host *, ++ const VkAllocationCallbacks_host *, VkBufferView * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateCommandPool)( VkDevice, const VkCommandPoolCreateInfo *, ++ const VkAllocationCallbacks_host *, VkCommandPool * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateComputePipelines)( VkDevice, VkPipelineCache, uint32_t, ++ const VkComputePipelineCreateInfo_host *, const VkAllocationCallbacks_host *, ++ VkPipeline * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateDebugReportCallbackEXT)( VkInstance, ++ const VkDebugReportCallbackCreateInfoEXT_host *, const VkAllocationCallbacks_host *, ++ VkDebugReportCallbackEXT * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateDescriptorPool)( VkDevice, const VkDescriptorPoolCreateInfo *, ++ const VkAllocationCallbacks_host *, VkDescriptorPool * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateDescriptorSetLayout)( VkDevice, ++ const VkDescriptorSetLayoutCreateInfo *, const VkAllocationCallbacks_host *, ++ VkDescriptorSetLayout * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateDevice)( VkPhysicalDevice, const VkDeviceCreateInfo *, ++ const VkAllocationCallbacks_host *, VkDevice * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateDisplayModeKHR)( VkPhysicalDevice, VkDisplayKHR, ++ const VkDisplayModeCreateInfoKHR *, const VkAllocationCallbacks_host *, ++ VkDisplayModeKHR * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateDisplayPlaneSurfaceKHR)( VkInstance, ++ const VkDisplaySurfaceCreateInfoKHR_host *, const VkAllocationCallbacks_host *, ++ VkSurfaceKHR * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateEvent)( VkDevice, const VkEventCreateInfo *, ++ const VkAllocationCallbacks_host *, VkEvent * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateFence)( VkDevice, const VkFenceCreateInfo *, ++ const VkAllocationCallbacks_host *, VkFence * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateFramebuffer)( VkDevice, const VkFramebufferCreateInfo_host *, ++ const VkAllocationCallbacks_host *, VkFramebuffer * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateGraphicsPipelines)( VkDevice, VkPipelineCache, uint32_t, ++ const VkGraphicsPipelineCreateInfo_host *, const VkAllocationCallbacks_host *, ++ VkPipeline * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateImage)( VkDevice, const VkImageCreateInfo *, ++ const VkAllocationCallbacks_host *, VkImage * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateImageView)( VkDevice, const VkImageViewCreateInfo_host *, ++ const VkAllocationCallbacks_host *, VkImageView * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateInstance)( const VkInstanceCreateInfo *, ++ const VkAllocationCallbacks_host *, VkInstance * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreatePipelineCache)( VkDevice, const VkPipelineCacheCreateInfo *, ++ const VkAllocationCallbacks_host *, VkPipelineCache * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreatePipelineLayout)( VkDevice, const VkPipelineLayoutCreateInfo *, ++ const VkAllocationCallbacks_host *, VkPipelineLayout * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateQueryPool)( VkDevice, const VkQueryPoolCreateInfo *, ++ const VkAllocationCallbacks_host *, VkQueryPool * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateRenderPass)( VkDevice, const VkRenderPassCreateInfo *, ++ const VkAllocationCallbacks_host *, VkRenderPass * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateSampler)( VkDevice, const VkSamplerCreateInfo *, ++ const VkAllocationCallbacks_host *, VkSampler * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateSemaphore)( VkDevice, const VkSemaphoreCreateInfo *, ++ const VkAllocationCallbacks_host *, VkSemaphore * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateShaderModule)( VkDevice, const VkShaderModuleCreateInfo *, ++ const VkAllocationCallbacks_host *, VkShaderModule * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateSharedSwapchainsKHR)( VkDevice, uint32_t, ++ const VkSwapchainCreateInfoKHR_host *, const VkAllocationCallbacks_host *, ++ VkSwapchainKHR * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateSwapchainKHR)( VkDevice, const VkSwapchainCreateInfoKHR_host *, ++ const VkAllocationCallbacks_host *, VkSwapchainKHR * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateXcbSurfaceKHR)( VkInstance, const VkXcbSurfaceCreateInfoKHR_host *, ++ const VkAllocationCallbacks_host *, VkSurfaceKHR * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkCreateXlibSurfaceKHR)( VkInstance, const VkXlibSurfaceCreateInfoKHR_host *, ++ const VkAllocationCallbacks_host *, VkSurfaceKHR * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDebugReportMessageEXT)( VkInstance, VkDebugReportFlagsEXT, ++ VkDebugReportObjectTypeEXT, uint64_t, size_t, int32_t, const char *, ++ const char * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDestroyBuffer)( VkDevice, VkBuffer, ++ const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDestroyBufferView)( VkDevice, VkBufferView, ++ const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDestroyCommandPool)( VkDevice, VkCommandPool, ++ const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDestroyDebugReportCallbackEXT)( VkInstance, VkDebugReportCallbackEXT, ++ const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDestroyDescriptorPool)( VkDevice, VkDescriptorPool, ++ const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDestroyDescriptorSetLayout)( VkDevice, VkDescriptorSetLayout, ++ const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDestroyDevice)( VkDevice, const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDestroyEvent)( VkDevice, VkEvent, ++ const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDestroyFence)( VkDevice, VkFence, ++ const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDestroyFramebuffer)( VkDevice, VkFramebuffer, ++ const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDestroyImage)( VkDevice, VkImage, ++ const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDestroyImageView)( VkDevice, VkImageView, ++ const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDestroyInstance)( VkInstance, ++ const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDestroyPipeline)( VkDevice, VkPipeline, ++ const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDestroyPipelineCache)( VkDevice, VkPipelineCache, ++ const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDestroyPipelineLayout)( VkDevice, VkPipelineLayout, ++ const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDestroyQueryPool)( VkDevice, VkQueryPool, ++ const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDestroyRenderPass)( VkDevice, VkRenderPass, ++ const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDestroySampler)( VkDevice, VkSampler, ++ const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDestroySemaphore)( VkDevice, VkSemaphore, ++ const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDestroyShaderModule)( VkDevice, VkShaderModule, ++ const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDestroySurfaceKHR)( VkInstance, VkSurfaceKHR, ++ const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkDestroySwapchainKHR)( VkDevice, VkSwapchainKHR, ++ const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkDeviceWaitIdle)( VkDevice ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkEndCommandBuffer)( VkCommandBuffer ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkEnumerateDeviceExtensionProperties)( VkPhysicalDevice, const char *, ++ uint32_t *, VkExtensionProperties * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkEnumerateDeviceLayerProperties)( VkPhysicalDevice, uint32_t *, ++ VkLayerProperties * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkEnumerateInstanceExtensionProperties)( const char *, uint32_t *, ++ VkExtensionProperties * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkEnumerateInstanceLayerProperties)( uint32_t *, ++ VkLayerProperties * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkEnumeratePhysicalDevices)( VkInstance, uint32_t *, ++ VkPhysicalDevice * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkFlushMappedMemoryRanges)( VkDevice, uint32_t, ++ const VkMappedMemoryRange * ) DECLSPEC_HIDDEN; ++extern void (*p_vkFreeCommandBuffers)( VkDevice, VkCommandPool, uint32_t, ++ const VkCommandBuffer * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkFreeDescriptorSets)( VkDevice, VkDescriptorPool, uint32_t, ++ const VkDescriptorSet * ) DECLSPEC_HIDDEN; ++extern void (*p_vkFreeMemory)( VkDevice, VkDeviceMemory, ++ const VkAllocationCallbacks_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkGetBufferMemoryRequirements)( VkDevice, VkBuffer, ++ VkMemoryRequirements * ) DECLSPEC_HIDDEN; ++extern void (*p_vkGetDeviceMemoryCommitment)( VkDevice, VkDeviceMemory, ++ VkDeviceSize * ) DECLSPEC_HIDDEN; ++extern PFN_vkVoidFunction_host (*p_vkGetDeviceProcAddr)( VkDevice, const char * ) DECLSPEC_HIDDEN; ++extern void (*p_vkGetDeviceQueue)( VkDevice, uint32_t, uint32_t, VkQueue * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkGetDisplayModePropertiesKHR)( VkPhysicalDevice, VkDisplayKHR, uint32_t *, ++ VkDisplayModePropertiesKHR_host * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkGetDisplayPlaneCapabilitiesKHR)( VkPhysicalDevice, VkDisplayModeKHR, ++ uint32_t, VkDisplayPlaneCapabilitiesKHR * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkGetDisplayPlaneSupportedDisplaysKHR)( VkPhysicalDevice, uint32_t, uint32_t *, ++ VkDisplayKHR * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkGetEventStatus)( VkDevice, VkEvent ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkGetFenceStatus)( VkDevice, VkFence ) DECLSPEC_HIDDEN; ++extern void (*p_vkGetImageMemoryRequirements)( VkDevice, VkImage, ++ VkMemoryRequirements * ) DECLSPEC_HIDDEN; ++extern void (*p_vkGetImageSparseMemoryRequirements)( VkDevice, VkImage, uint32_t *, ++ VkSparseImageMemoryRequirements * ) DECLSPEC_HIDDEN; ++extern void (*p_vkGetImageSubresourceLayout)( VkDevice, VkImage, const VkImageSubresource *, ++ VkSubresourceLayout * ) DECLSPEC_HIDDEN; ++extern PFN_vkVoidFunction_host (*p_vkGetInstanceProcAddr)( VkInstance, ++ const char * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)( VkPhysicalDevice, uint32_t *, ++ VkDisplayPlanePropertiesKHR_host * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkGetPhysicalDeviceDisplayPropertiesKHR)( VkPhysicalDevice, uint32_t *, ++ VkDisplayPropertiesKHR * ) DECLSPEC_HIDDEN; ++extern void (*p_vkGetPhysicalDeviceFeatures)( VkPhysicalDevice, ++ VkPhysicalDeviceFeatures * ) DECLSPEC_HIDDEN; ++extern void (*p_vkGetPhysicalDeviceFormatProperties)( VkPhysicalDevice, VkFormat, ++ VkFormatProperties * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkGetPhysicalDeviceImageFormatProperties)( VkPhysicalDevice, VkFormat, ++ VkImageType, VkImageTiling, VkImageUsageFlags, VkImageCreateFlags, ++ VkImageFormatProperties * ) DECLSPEC_HIDDEN; ++extern void (*p_vkGetPhysicalDeviceMemoryProperties)( VkPhysicalDevice, ++ VkPhysicalDeviceMemoryProperties_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkGetPhysicalDeviceProperties)( VkPhysicalDevice, ++ VkPhysicalDeviceProperties_host * ) DECLSPEC_HIDDEN; ++extern void (*p_vkGetPhysicalDeviceQueueFamilyProperties)( VkPhysicalDevice, uint32_t *, ++ VkQueueFamilyProperties * ) DECLSPEC_HIDDEN; ++extern void (*p_vkGetPhysicalDeviceSparseImageFormatProperties)( VkPhysicalDevice, VkFormat, ++ VkImageType, VkSampleCountFlagBits, VkImageUsageFlags, VkImageTiling, uint32_t *, ++ VkSparseImageFormatProperties * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)( VkPhysicalDevice, VkSurfaceKHR, ++ VkSurfaceCapabilitiesKHR * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkGetPhysicalDeviceSurfaceFormatsKHR)( VkPhysicalDevice, VkSurfaceKHR, ++ uint32_t *, VkSurfaceFormatKHR * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkGetPhysicalDeviceSurfacePresentModesKHR)( VkPhysicalDevice, VkSurfaceKHR, ++ uint32_t *, VkPresentModeKHR * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkGetPhysicalDeviceSurfaceSupportKHR)( VkPhysicalDevice, uint32_t, ++ VkSurfaceKHR, VkBool32 * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkGetPipelineCacheData)( VkDevice, VkPipelineCache, size_t *, ++ void * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkGetQueryPoolResults)( VkDevice, VkQueryPool, uint32_t, uint32_t, size_t, ++ void *, VkDeviceSize, VkQueryResultFlags ) DECLSPEC_HIDDEN; ++extern void (*p_vkGetRenderAreaGranularity)( VkDevice, VkRenderPass, VkExtent2D * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkGetSwapchainImagesKHR)( VkDevice, VkSwapchainKHR, uint32_t *, ++ VkImage * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkInvalidateMappedMemoryRanges)( VkDevice, uint32_t, ++ const VkMappedMemoryRange * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkMapMemory)( VkDevice, VkDeviceMemory, VkDeviceSize, VkDeviceSize, ++ VkMemoryMapFlags, void ** ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkMergePipelineCaches)( VkDevice, VkPipelineCache, uint32_t, ++ const VkPipelineCache * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkQueueBindSparse)( VkQueue, uint32_t, const VkBindSparseInfo_host *, ++ VkFence ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkQueuePresentKHR)( VkQueue, const VkPresentInfoKHR * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkQueueSubmit)( VkQueue, uint32_t, const VkSubmitInfo *, ++ VkFence ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkQueueWaitIdle)( VkQueue ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkResetCommandBuffer)( VkCommandBuffer, ++ VkCommandBufferResetFlags ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkResetCommandPool)( VkDevice, VkCommandPool, ++ VkCommandPoolResetFlags ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkResetDescriptorPool)( VkDevice, VkDescriptorPool, ++ VkDescriptorPoolResetFlags ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkResetEvent)( VkDevice, VkEvent ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkResetFences)( VkDevice, uint32_t, const VkFence * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkSetEvent)( VkDevice, VkEvent ) DECLSPEC_HIDDEN; ++extern void (*p_vkUnmapMemory)( VkDevice, VkDeviceMemory ) DECLSPEC_HIDDEN; ++extern void (*p_vkUpdateDescriptorSets)( VkDevice, uint32_t, const VkWriteDescriptorSet_host *, ++ uint32_t, const VkCopyDescriptorSet_host * ) DECLSPEC_HIDDEN; ++extern VkResult (*p_vkWaitForFences)( VkDevice, uint32_t, const VkFence *, VkBool32, ++ uint64_t ) DECLSPEC_HIDDEN; ++ ++extern void convert_PFN_vkAllocationFunction( PFN_vkAllocationFunction_host *out, ++ const PFN_vkAllocationFunction *in ) DECLSPEC_HIDDEN; ++extern void release_PFN_vkAllocationFunction( PFN_vkAllocationFunction *out, ++ PFN_vkAllocationFunction_host *in ) DECLSPEC_HIDDEN; ++ ++extern void convert_PFN_vkReallocationFunction( PFN_vkReallocationFunction_host *out, ++ const PFN_vkReallocationFunction *in ) DECLSPEC_HIDDEN; ++extern void release_PFN_vkReallocationFunction( PFN_vkReallocationFunction *out, ++ PFN_vkReallocationFunction_host *in ) DECLSPEC_HIDDEN; ++ ++extern void convert_PFN_vkFreeFunction( PFN_vkFreeFunction_host *out, ++ const PFN_vkFreeFunction *in ) DECLSPEC_HIDDEN; ++extern void release_PFN_vkFreeFunction( PFN_vkFreeFunction *out, ++ PFN_vkFreeFunction_host *in ) DECLSPEC_HIDDEN; ++ ++extern void convert_PFN_vkInternalAllocationNotification( ++ PFN_vkInternalAllocationNotification_host *out, ++ const PFN_vkInternalAllocationNotification *in ) DECLSPEC_HIDDEN; ++extern void release_PFN_vkInternalAllocationNotification( ++ PFN_vkInternalAllocationNotification *out, ++ PFN_vkInternalAllocationNotification_host *in ) DECLSPEC_HIDDEN; ++ ++extern void convert_PFN_vkInternalFreeNotification( PFN_vkInternalFreeNotification_host *out, ++ const PFN_vkInternalFreeNotification *in ) DECLSPEC_HIDDEN; ++extern void release_PFN_vkInternalFreeNotification( PFN_vkInternalFreeNotification *out, ++ PFN_vkInternalFreeNotification_host *in ) DECLSPEC_HIDDEN; ++ ++extern VkAllocationCallbacks_host *convert_VkAllocationCallbacks( VkAllocationCallbacks_host *out, ++ const VkAllocationCallbacks *in ) DECLSPEC_HIDDEN; ++extern void release_VkAllocationCallbacks( VkAllocationCallbacks *out, ++ VkAllocationCallbacks_host *in ) DECLSPEC_HIDDEN; ++extern VkAllocationCallbacks_host *convert_VkAllocationCallbacks_array( ++ const VkAllocationCallbacks *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkAllocationCallbacks_array( VkAllocationCallbacks *out, ++ VkAllocationCallbacks_host *in, int count ) DECLSPEC_HIDDEN; ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkCommandBufferInheritanceInfo_host *convert_VkCommandBufferInheritanceInfo( ++ VkCommandBufferInheritanceInfo_host *out, ++ const VkCommandBufferInheritanceInfo *in ) DECLSPEC_HIDDEN; ++extern void release_VkCommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo *out, ++ VkCommandBufferInheritanceInfo_host *in ) DECLSPEC_HIDDEN; ++extern VkCommandBufferInheritanceInfo_host *convert_VkCommandBufferInheritanceInfo_array( ++ const VkCommandBufferInheritanceInfo *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkCommandBufferInheritanceInfo_array( VkCommandBufferInheritanceInfo *out, ++ VkCommandBufferInheritanceInfo_host *in, int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkCommandBufferInheritanceInfo_host *convert_VkCommandBufferInheritanceInfo( ++ VkCommandBufferInheritanceInfo_host *out, const VkCommandBufferInheritanceInfo *in ) ++{ ++ return (VkCommandBufferInheritanceInfo_host *)in; ++} ++static inline void release_VkCommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo *out, ++ VkCommandBufferInheritanceInfo_host *in ) ++{ ++} ++static inline VkCommandBufferInheritanceInfo_host *convert_VkCommandBufferInheritanceInfo_array( ++ const VkCommandBufferInheritanceInfo *in, int count ) ++{ ++ return (VkCommandBufferInheritanceInfo_host *)in; ++} ++static inline void release_VkCommandBufferInheritanceInfo_array( ++ VkCommandBufferInheritanceInfo *out, VkCommandBufferInheritanceInfo_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkCommandBufferBeginInfo_host *convert_VkCommandBufferBeginInfo( ++ VkCommandBufferBeginInfo_host *out, const VkCommandBufferBeginInfo *in ) DECLSPEC_HIDDEN; ++extern void release_VkCommandBufferBeginInfo( VkCommandBufferBeginInfo *out, ++ VkCommandBufferBeginInfo_host *in ) DECLSPEC_HIDDEN; ++extern VkCommandBufferBeginInfo_host *convert_VkCommandBufferBeginInfo_array( ++ const VkCommandBufferBeginInfo *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkCommandBufferBeginInfo_array( VkCommandBufferBeginInfo *out, ++ VkCommandBufferBeginInfo_host *in, int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkCommandBufferBeginInfo_host *convert_VkCommandBufferBeginInfo( ++ VkCommandBufferBeginInfo_host *out, const VkCommandBufferBeginInfo *in ) ++{ ++ return (VkCommandBufferBeginInfo_host *)in; ++} ++static inline void release_VkCommandBufferBeginInfo( VkCommandBufferBeginInfo *out, ++ VkCommandBufferBeginInfo_host *in ) ++{ ++} ++static inline VkCommandBufferBeginInfo_host *convert_VkCommandBufferBeginInfo_array( ++ const VkCommandBufferBeginInfo *in, int count ) ++{ ++ return (VkCommandBufferBeginInfo_host *)in; ++} ++static inline void release_VkCommandBufferBeginInfo_array( VkCommandBufferBeginInfo *out, ++ VkCommandBufferBeginInfo_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkImageMemoryBarrier_host *convert_VkImageMemoryBarrier( VkImageMemoryBarrier_host *out, ++ const VkImageMemoryBarrier *in ) DECLSPEC_HIDDEN; ++extern void release_VkImageMemoryBarrier( VkImageMemoryBarrier *out, ++ VkImageMemoryBarrier_host *in ) DECLSPEC_HIDDEN; ++extern VkImageMemoryBarrier_host *convert_VkImageMemoryBarrier_array( ++ const VkImageMemoryBarrier *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkImageMemoryBarrier_array( VkImageMemoryBarrier *out, ++ VkImageMemoryBarrier_host *in, int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkImageMemoryBarrier_host *convert_VkImageMemoryBarrier( ++ VkImageMemoryBarrier_host *out, const VkImageMemoryBarrier *in ) ++{ ++ return (VkImageMemoryBarrier_host *)in; ++} ++static inline void release_VkImageMemoryBarrier( VkImageMemoryBarrier *out, ++ VkImageMemoryBarrier_host *in ) ++{ ++} ++static inline VkImageMemoryBarrier_host *convert_VkImageMemoryBarrier_array( ++ const VkImageMemoryBarrier *in, int count ) ++{ ++ return (VkImageMemoryBarrier_host *)in; ++} ++static inline void release_VkImageMemoryBarrier_array( VkImageMemoryBarrier *out, ++ VkImageMemoryBarrier_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkBufferCreateInfo_host *convert_VkBufferCreateInfo( VkBufferCreateInfo_host *out, ++ const VkBufferCreateInfo *in ) DECLSPEC_HIDDEN; ++extern void release_VkBufferCreateInfo( VkBufferCreateInfo *out, ++ VkBufferCreateInfo_host *in ) DECLSPEC_HIDDEN; ++extern VkBufferCreateInfo_host *convert_VkBufferCreateInfo_array( const VkBufferCreateInfo *in, ++ int count ) DECLSPEC_HIDDEN; ++extern void release_VkBufferCreateInfo_array( VkBufferCreateInfo *out, VkBufferCreateInfo_host *in, ++ int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkBufferCreateInfo_host *convert_VkBufferCreateInfo( VkBufferCreateInfo_host *out, ++ const VkBufferCreateInfo *in ) ++{ ++ return (VkBufferCreateInfo_host *)in; ++} ++static inline void release_VkBufferCreateInfo( VkBufferCreateInfo *out, ++ VkBufferCreateInfo_host *in ) ++{ ++} ++static inline VkBufferCreateInfo_host *convert_VkBufferCreateInfo_array( ++ const VkBufferCreateInfo *in, int count ) ++{ ++ return (VkBufferCreateInfo_host *)in; ++} ++static inline void release_VkBufferCreateInfo_array( VkBufferCreateInfo *out, ++ VkBufferCreateInfo_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkBufferViewCreateInfo_host *convert_VkBufferViewCreateInfo( ++ VkBufferViewCreateInfo_host *out, const VkBufferViewCreateInfo *in ) DECLSPEC_HIDDEN; ++extern void release_VkBufferViewCreateInfo( VkBufferViewCreateInfo *out, ++ VkBufferViewCreateInfo_host *in ) DECLSPEC_HIDDEN; ++extern VkBufferViewCreateInfo_host *convert_VkBufferViewCreateInfo_array( ++ const VkBufferViewCreateInfo *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkBufferViewCreateInfo_array( VkBufferViewCreateInfo *out, ++ VkBufferViewCreateInfo_host *in, int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkBufferViewCreateInfo_host *convert_VkBufferViewCreateInfo( ++ VkBufferViewCreateInfo_host *out, const VkBufferViewCreateInfo *in ) ++{ ++ return (VkBufferViewCreateInfo_host *)in; ++} ++static inline void release_VkBufferViewCreateInfo( VkBufferViewCreateInfo *out, ++ VkBufferViewCreateInfo_host *in ) ++{ ++} ++static inline VkBufferViewCreateInfo_host *convert_VkBufferViewCreateInfo_array( ++ const VkBufferViewCreateInfo *in, int count ) ++{ ++ return (VkBufferViewCreateInfo_host *)in; ++} ++static inline void release_VkBufferViewCreateInfo_array( VkBufferViewCreateInfo *out, ++ VkBufferViewCreateInfo_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkPipelineShaderStageCreateInfo_host *convert_VkPipelineShaderStageCreateInfo( ++ VkPipelineShaderStageCreateInfo_host *out, ++ const VkPipelineShaderStageCreateInfo *in ) DECLSPEC_HIDDEN; ++extern void release_VkPipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo *out, ++ VkPipelineShaderStageCreateInfo_host *in ) DECLSPEC_HIDDEN; ++extern VkPipelineShaderStageCreateInfo_host *convert_VkPipelineShaderStageCreateInfo_array( ++ const VkPipelineShaderStageCreateInfo *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkPipelineShaderStageCreateInfo_array( VkPipelineShaderStageCreateInfo *out, ++ VkPipelineShaderStageCreateInfo_host *in, int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkPipelineShaderStageCreateInfo_host *convert_VkPipelineShaderStageCreateInfo( ++ VkPipelineShaderStageCreateInfo_host *out, const VkPipelineShaderStageCreateInfo *in ) ++{ ++ return (VkPipelineShaderStageCreateInfo_host *)in; ++} ++static inline void release_VkPipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo *out, ++ VkPipelineShaderStageCreateInfo_host *in ) ++{ ++} ++static inline VkPipelineShaderStageCreateInfo_host *convert_VkPipelineShaderStageCreateInfo_array( ++ const VkPipelineShaderStageCreateInfo *in, int count ) ++{ ++ return (VkPipelineShaderStageCreateInfo_host *)in; ++} ++static inline void release_VkPipelineShaderStageCreateInfo_array( ++ VkPipelineShaderStageCreateInfo *out, VkPipelineShaderStageCreateInfo_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkComputePipelineCreateInfo_host *convert_VkComputePipelineCreateInfo( ++ VkComputePipelineCreateInfo_host *out, ++ const VkComputePipelineCreateInfo *in ) DECLSPEC_HIDDEN; ++extern void release_VkComputePipelineCreateInfo( VkComputePipelineCreateInfo *out, ++ VkComputePipelineCreateInfo_host *in ) DECLSPEC_HIDDEN; ++extern VkComputePipelineCreateInfo_host *convert_VkComputePipelineCreateInfo_array( ++ const VkComputePipelineCreateInfo *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkComputePipelineCreateInfo_array( VkComputePipelineCreateInfo *out, ++ VkComputePipelineCreateInfo_host *in, int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkComputePipelineCreateInfo_host *convert_VkComputePipelineCreateInfo( ++ VkComputePipelineCreateInfo_host *out, const VkComputePipelineCreateInfo *in ) ++{ ++ return (VkComputePipelineCreateInfo_host *)in; ++} ++static inline void release_VkComputePipelineCreateInfo( VkComputePipelineCreateInfo *out, ++ VkComputePipelineCreateInfo_host *in ) ++{ ++} ++static inline VkComputePipelineCreateInfo_host *convert_VkComputePipelineCreateInfo_array( ++ const VkComputePipelineCreateInfo *in, int count ) ++{ ++ return (VkComputePipelineCreateInfo_host *)in; ++} ++static inline void release_VkComputePipelineCreateInfo_array( VkComputePipelineCreateInfo *out, ++ VkComputePipelineCreateInfo_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++extern void convert_PFN_vkDebugReportCallbackEXT( PFN_vkDebugReportCallbackEXT_host *out, ++ const PFN_vkDebugReportCallbackEXT *in ) DECLSPEC_HIDDEN; ++extern void release_PFN_vkDebugReportCallbackEXT( PFN_vkDebugReportCallbackEXT *out, ++ PFN_vkDebugReportCallbackEXT_host *in ) DECLSPEC_HIDDEN; ++ ++extern VkDebugReportCallbackCreateInfoEXT_host *convert_VkDebugReportCallbackCreateInfoEXT( ++ VkDebugReportCallbackCreateInfoEXT_host *out, ++ const VkDebugReportCallbackCreateInfoEXT *in ) DECLSPEC_HIDDEN; ++extern void release_VkDebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT *out, ++ VkDebugReportCallbackCreateInfoEXT_host *in ) DECLSPEC_HIDDEN; ++extern VkDebugReportCallbackCreateInfoEXT_host *convert_VkDebugReportCallbackCreateInfoEXT_array( ++ const VkDebugReportCallbackCreateInfoEXT *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkDebugReportCallbackCreateInfoEXT_array( ++ VkDebugReportCallbackCreateInfoEXT *out, VkDebugReportCallbackCreateInfoEXT_host *in, ++ int count ) DECLSPEC_HIDDEN; ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkDisplaySurfaceCreateInfoKHR_host *convert_VkDisplaySurfaceCreateInfoKHR( ++ VkDisplaySurfaceCreateInfoKHR_host *out, ++ const VkDisplaySurfaceCreateInfoKHR *in ) DECLSPEC_HIDDEN; ++extern void release_VkDisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR *out, ++ VkDisplaySurfaceCreateInfoKHR_host *in ) DECLSPEC_HIDDEN; ++extern VkDisplaySurfaceCreateInfoKHR_host *convert_VkDisplaySurfaceCreateInfoKHR_array( ++ const VkDisplaySurfaceCreateInfoKHR *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkDisplaySurfaceCreateInfoKHR_array( VkDisplaySurfaceCreateInfoKHR *out, ++ VkDisplaySurfaceCreateInfoKHR_host *in, int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkDisplaySurfaceCreateInfoKHR_host *convert_VkDisplaySurfaceCreateInfoKHR( ++ VkDisplaySurfaceCreateInfoKHR_host *out, const VkDisplaySurfaceCreateInfoKHR *in ) ++{ ++ return (VkDisplaySurfaceCreateInfoKHR_host *)in; ++} ++static inline void release_VkDisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR *out, ++ VkDisplaySurfaceCreateInfoKHR_host *in ) ++{ ++} ++static inline VkDisplaySurfaceCreateInfoKHR_host *convert_VkDisplaySurfaceCreateInfoKHR_array( ++ const VkDisplaySurfaceCreateInfoKHR *in, int count ) ++{ ++ return (VkDisplaySurfaceCreateInfoKHR_host *)in; ++} ++static inline void release_VkDisplaySurfaceCreateInfoKHR_array( VkDisplaySurfaceCreateInfoKHR *out, ++ VkDisplaySurfaceCreateInfoKHR_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkFramebufferCreateInfo_host *convert_VkFramebufferCreateInfo( ++ VkFramebufferCreateInfo_host *out, const VkFramebufferCreateInfo *in ) DECLSPEC_HIDDEN; ++extern void release_VkFramebufferCreateInfo( VkFramebufferCreateInfo *out, ++ VkFramebufferCreateInfo_host *in ) DECLSPEC_HIDDEN; ++extern VkFramebufferCreateInfo_host *convert_VkFramebufferCreateInfo_array( ++ const VkFramebufferCreateInfo *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkFramebufferCreateInfo_array( VkFramebufferCreateInfo *out, ++ VkFramebufferCreateInfo_host *in, int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkFramebufferCreateInfo_host *convert_VkFramebufferCreateInfo( ++ VkFramebufferCreateInfo_host *out, const VkFramebufferCreateInfo *in ) ++{ ++ return (VkFramebufferCreateInfo_host *)in; ++} ++static inline void release_VkFramebufferCreateInfo( VkFramebufferCreateInfo *out, ++ VkFramebufferCreateInfo_host *in ) ++{ ++} ++static inline VkFramebufferCreateInfo_host *convert_VkFramebufferCreateInfo_array( ++ const VkFramebufferCreateInfo *in, int count ) ++{ ++ return (VkFramebufferCreateInfo_host *)in; ++} ++static inline void release_VkFramebufferCreateInfo_array( VkFramebufferCreateInfo *out, ++ VkFramebufferCreateInfo_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkGraphicsPipelineCreateInfo_host *convert_VkGraphicsPipelineCreateInfo( ++ VkGraphicsPipelineCreateInfo_host *out, ++ const VkGraphicsPipelineCreateInfo *in ) DECLSPEC_HIDDEN; ++extern void release_VkGraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo *out, ++ VkGraphicsPipelineCreateInfo_host *in ) DECLSPEC_HIDDEN; ++extern VkGraphicsPipelineCreateInfo_host *convert_VkGraphicsPipelineCreateInfo_array( ++ const VkGraphicsPipelineCreateInfo *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkGraphicsPipelineCreateInfo_array( VkGraphicsPipelineCreateInfo *out, ++ VkGraphicsPipelineCreateInfo_host *in, int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkGraphicsPipelineCreateInfo_host *convert_VkGraphicsPipelineCreateInfo( ++ VkGraphicsPipelineCreateInfo_host *out, const VkGraphicsPipelineCreateInfo *in ) ++{ ++ return (VkGraphicsPipelineCreateInfo_host *)in; ++} ++static inline void release_VkGraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo *out, ++ VkGraphicsPipelineCreateInfo_host *in ) ++{ ++} ++static inline VkGraphicsPipelineCreateInfo_host *convert_VkGraphicsPipelineCreateInfo_array( ++ const VkGraphicsPipelineCreateInfo *in, int count ) ++{ ++ return (VkGraphicsPipelineCreateInfo_host *)in; ++} ++static inline void release_VkGraphicsPipelineCreateInfo_array( VkGraphicsPipelineCreateInfo *out, ++ VkGraphicsPipelineCreateInfo_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkImageViewCreateInfo_host *convert_VkImageViewCreateInfo( VkImageViewCreateInfo_host *out, ++ const VkImageViewCreateInfo *in ) DECLSPEC_HIDDEN; ++extern void release_VkImageViewCreateInfo( VkImageViewCreateInfo *out, ++ VkImageViewCreateInfo_host *in ) DECLSPEC_HIDDEN; ++extern VkImageViewCreateInfo_host *convert_VkImageViewCreateInfo_array( ++ const VkImageViewCreateInfo *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkImageViewCreateInfo_array( VkImageViewCreateInfo *out, ++ VkImageViewCreateInfo_host *in, int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkImageViewCreateInfo_host *convert_VkImageViewCreateInfo( ++ VkImageViewCreateInfo_host *out, const VkImageViewCreateInfo *in ) ++{ ++ return (VkImageViewCreateInfo_host *)in; ++} ++static inline void release_VkImageViewCreateInfo( VkImageViewCreateInfo *out, ++ VkImageViewCreateInfo_host *in ) ++{ ++} ++static inline VkImageViewCreateInfo_host *convert_VkImageViewCreateInfo_array( ++ const VkImageViewCreateInfo *in, int count ) ++{ ++ return (VkImageViewCreateInfo_host *)in; ++} ++static inline void release_VkImageViewCreateInfo_array( VkImageViewCreateInfo *out, ++ VkImageViewCreateInfo_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkSwapchainCreateInfoKHR_host *convert_VkSwapchainCreateInfoKHR( ++ VkSwapchainCreateInfoKHR_host *out, const VkSwapchainCreateInfoKHR *in ) DECLSPEC_HIDDEN; ++extern void release_VkSwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR *out, ++ VkSwapchainCreateInfoKHR_host *in ) DECLSPEC_HIDDEN; ++extern VkSwapchainCreateInfoKHR_host *convert_VkSwapchainCreateInfoKHR_array( ++ const VkSwapchainCreateInfoKHR *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkSwapchainCreateInfoKHR_array( VkSwapchainCreateInfoKHR *out, ++ VkSwapchainCreateInfoKHR_host *in, int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkSwapchainCreateInfoKHR_host *convert_VkSwapchainCreateInfoKHR( ++ VkSwapchainCreateInfoKHR_host *out, const VkSwapchainCreateInfoKHR *in ) ++{ ++ return (VkSwapchainCreateInfoKHR_host *)in; ++} ++static inline void release_VkSwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR *out, ++ VkSwapchainCreateInfoKHR_host *in ) ++{ ++} ++static inline VkSwapchainCreateInfoKHR_host *convert_VkSwapchainCreateInfoKHR_array( ++ const VkSwapchainCreateInfoKHR *in, int count ) ++{ ++ return (VkSwapchainCreateInfoKHR_host *)in; ++} ++static inline void release_VkSwapchainCreateInfoKHR_array( VkSwapchainCreateInfoKHR *out, ++ VkSwapchainCreateInfoKHR_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkDisplayModePropertiesKHR_host *convert_VkDisplayModePropertiesKHR( ++ VkDisplayModePropertiesKHR_host *out, ++ const VkDisplayModePropertiesKHR *in ) DECLSPEC_HIDDEN; ++extern void release_VkDisplayModePropertiesKHR( VkDisplayModePropertiesKHR *out, ++ VkDisplayModePropertiesKHR_host *in ) DECLSPEC_HIDDEN; ++extern VkDisplayModePropertiesKHR_host *convert_VkDisplayModePropertiesKHR_array( ++ const VkDisplayModePropertiesKHR *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkDisplayModePropertiesKHR_array( VkDisplayModePropertiesKHR *out, ++ VkDisplayModePropertiesKHR_host *in, int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkDisplayModePropertiesKHR_host *convert_VkDisplayModePropertiesKHR( ++ VkDisplayModePropertiesKHR_host *out, const VkDisplayModePropertiesKHR *in ) ++{ ++ return (VkDisplayModePropertiesKHR_host *)in; ++} ++static inline void release_VkDisplayModePropertiesKHR( VkDisplayModePropertiesKHR *out, ++ VkDisplayModePropertiesKHR_host *in ) ++{ ++} ++static inline VkDisplayModePropertiesKHR_host *convert_VkDisplayModePropertiesKHR_array( ++ const VkDisplayModePropertiesKHR *in, int count ) ++{ ++ return (VkDisplayModePropertiesKHR_host *)in; ++} ++static inline void release_VkDisplayModePropertiesKHR_array( VkDisplayModePropertiesKHR *out, ++ VkDisplayModePropertiesKHR_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkDisplayPlanePropertiesKHR_host *convert_VkDisplayPlanePropertiesKHR( ++ VkDisplayPlanePropertiesKHR_host *out, ++ const VkDisplayPlanePropertiesKHR *in ) DECLSPEC_HIDDEN; ++extern void release_VkDisplayPlanePropertiesKHR( VkDisplayPlanePropertiesKHR *out, ++ VkDisplayPlanePropertiesKHR_host *in ) DECLSPEC_HIDDEN; ++extern VkDisplayPlanePropertiesKHR_host *convert_VkDisplayPlanePropertiesKHR_array( ++ const VkDisplayPlanePropertiesKHR *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkDisplayPlanePropertiesKHR_array( VkDisplayPlanePropertiesKHR *out, ++ VkDisplayPlanePropertiesKHR_host *in, int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkDisplayPlanePropertiesKHR_host *convert_VkDisplayPlanePropertiesKHR( ++ VkDisplayPlanePropertiesKHR_host *out, const VkDisplayPlanePropertiesKHR *in ) ++{ ++ return (VkDisplayPlanePropertiesKHR_host *)in; ++} ++static inline void release_VkDisplayPlanePropertiesKHR( VkDisplayPlanePropertiesKHR *out, ++ VkDisplayPlanePropertiesKHR_host *in ) ++{ ++} ++static inline VkDisplayPlanePropertiesKHR_host *convert_VkDisplayPlanePropertiesKHR_array( ++ const VkDisplayPlanePropertiesKHR *in, int count ) ++{ ++ return (VkDisplayPlanePropertiesKHR_host *)in; ++} ++static inline void release_VkDisplayPlanePropertiesKHR_array( VkDisplayPlanePropertiesKHR *out, ++ VkDisplayPlanePropertiesKHR_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkMemoryHeap_host *convert_VkMemoryHeap( VkMemoryHeap_host *out, ++ const VkMemoryHeap *in ) DECLSPEC_HIDDEN; ++extern void release_VkMemoryHeap( VkMemoryHeap *out, VkMemoryHeap_host *in ) DECLSPEC_HIDDEN; ++extern VkMemoryHeap_host *convert_VkMemoryHeap_array( const VkMemoryHeap *in, ++ int count ) DECLSPEC_HIDDEN; ++extern void release_VkMemoryHeap_array( VkMemoryHeap *out, VkMemoryHeap_host *in, ++ int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkMemoryHeap_host *convert_VkMemoryHeap( VkMemoryHeap_host *out, ++ const VkMemoryHeap *in ) ++{ ++ return (VkMemoryHeap_host *)in; ++} ++static inline void release_VkMemoryHeap( VkMemoryHeap *out, VkMemoryHeap_host *in ) ++{ ++} ++static inline VkMemoryHeap_host *convert_VkMemoryHeap_array( const VkMemoryHeap *in, int count ) ++{ ++ return (VkMemoryHeap_host *)in; ++} ++static inline void release_VkMemoryHeap_array( VkMemoryHeap *out, VkMemoryHeap_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkPhysicalDeviceMemoryProperties_host *convert_VkPhysicalDeviceMemoryProperties( ++ VkPhysicalDeviceMemoryProperties_host *out, ++ const VkPhysicalDeviceMemoryProperties *in ) DECLSPEC_HIDDEN; ++extern void release_VkPhysicalDeviceMemoryProperties( VkPhysicalDeviceMemoryProperties *out, ++ VkPhysicalDeviceMemoryProperties_host *in ) DECLSPEC_HIDDEN; ++extern VkPhysicalDeviceMemoryProperties_host *convert_VkPhysicalDeviceMemoryProperties_array( ++ const VkPhysicalDeviceMemoryProperties *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkPhysicalDeviceMemoryProperties_array( VkPhysicalDeviceMemoryProperties *out, ++ VkPhysicalDeviceMemoryProperties_host *in, int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkPhysicalDeviceMemoryProperties_host *convert_VkPhysicalDeviceMemoryProperties( ++ VkPhysicalDeviceMemoryProperties_host *out, const VkPhysicalDeviceMemoryProperties *in ) ++{ ++ return (VkPhysicalDeviceMemoryProperties_host *)in; ++} ++static inline void release_VkPhysicalDeviceMemoryProperties( VkPhysicalDeviceMemoryProperties *out, ++ VkPhysicalDeviceMemoryProperties_host *in ) ++{ ++} ++static inline VkPhysicalDeviceMemoryProperties_host *convert_VkPhysicalDeviceMemoryProperties_array( ++ const VkPhysicalDeviceMemoryProperties *in, int count ) ++{ ++ return (VkPhysicalDeviceMemoryProperties_host *)in; ++} ++static inline void release_VkPhysicalDeviceMemoryProperties_array( ++ VkPhysicalDeviceMemoryProperties *out, VkPhysicalDeviceMemoryProperties_host *in, ++ int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkPhysicalDeviceLimits_host *convert_VkPhysicalDeviceLimits( ++ VkPhysicalDeviceLimits_host *out, const VkPhysicalDeviceLimits *in ) DECLSPEC_HIDDEN; ++extern void release_VkPhysicalDeviceLimits( VkPhysicalDeviceLimits *out, ++ VkPhysicalDeviceLimits_host *in ) DECLSPEC_HIDDEN; ++extern VkPhysicalDeviceLimits_host *convert_VkPhysicalDeviceLimits_array( ++ const VkPhysicalDeviceLimits *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkPhysicalDeviceLimits_array( VkPhysicalDeviceLimits *out, ++ VkPhysicalDeviceLimits_host *in, int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkPhysicalDeviceLimits_host *convert_VkPhysicalDeviceLimits( ++ VkPhysicalDeviceLimits_host *out, const VkPhysicalDeviceLimits *in ) ++{ ++ return (VkPhysicalDeviceLimits_host *)in; ++} ++static inline void release_VkPhysicalDeviceLimits( VkPhysicalDeviceLimits *out, ++ VkPhysicalDeviceLimits_host *in ) ++{ ++} ++static inline VkPhysicalDeviceLimits_host *convert_VkPhysicalDeviceLimits_array( ++ const VkPhysicalDeviceLimits *in, int count ) ++{ ++ return (VkPhysicalDeviceLimits_host *)in; ++} ++static inline void release_VkPhysicalDeviceLimits_array( VkPhysicalDeviceLimits *out, ++ VkPhysicalDeviceLimits_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkPhysicalDeviceProperties_host *convert_VkPhysicalDeviceProperties( ++ VkPhysicalDeviceProperties_host *out, ++ const VkPhysicalDeviceProperties *in ) DECLSPEC_HIDDEN; ++extern void release_VkPhysicalDeviceProperties( VkPhysicalDeviceProperties *out, ++ VkPhysicalDeviceProperties_host *in ) DECLSPEC_HIDDEN; ++extern VkPhysicalDeviceProperties_host *convert_VkPhysicalDeviceProperties_array( ++ const VkPhysicalDeviceProperties *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkPhysicalDeviceProperties_array( VkPhysicalDeviceProperties *out, ++ VkPhysicalDeviceProperties_host *in, int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkPhysicalDeviceProperties_host *convert_VkPhysicalDeviceProperties( ++ VkPhysicalDeviceProperties_host *out, const VkPhysicalDeviceProperties *in ) ++{ ++ return (VkPhysicalDeviceProperties_host *)in; ++} ++static inline void release_VkPhysicalDeviceProperties( VkPhysicalDeviceProperties *out, ++ VkPhysicalDeviceProperties_host *in ) ++{ ++} ++static inline VkPhysicalDeviceProperties_host *convert_VkPhysicalDeviceProperties_array( ++ const VkPhysicalDeviceProperties *in, int count ) ++{ ++ return (VkPhysicalDeviceProperties_host *)in; ++} ++static inline void release_VkPhysicalDeviceProperties_array( VkPhysicalDeviceProperties *out, ++ VkPhysicalDeviceProperties_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkSparseMemoryBind_host *convert_VkSparseMemoryBind( VkSparseMemoryBind_host *out, ++ const VkSparseMemoryBind *in ) DECLSPEC_HIDDEN; ++extern void release_VkSparseMemoryBind( VkSparseMemoryBind *out, ++ VkSparseMemoryBind_host *in ) DECLSPEC_HIDDEN; ++extern VkSparseMemoryBind_host *convert_VkSparseMemoryBind_array( const VkSparseMemoryBind *in, ++ int count ) DECLSPEC_HIDDEN; ++extern void release_VkSparseMemoryBind_array( VkSparseMemoryBind *out, VkSparseMemoryBind_host *in, ++ int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkSparseMemoryBind_host *convert_VkSparseMemoryBind( VkSparseMemoryBind_host *out, ++ const VkSparseMemoryBind *in ) ++{ ++ return (VkSparseMemoryBind_host *)in; ++} ++static inline void release_VkSparseMemoryBind( VkSparseMemoryBind *out, ++ VkSparseMemoryBind_host *in ) ++{ ++} ++static inline VkSparseMemoryBind_host *convert_VkSparseMemoryBind_array( ++ const VkSparseMemoryBind *in, int count ) ++{ ++ return (VkSparseMemoryBind_host *)in; ++} ++static inline void release_VkSparseMemoryBind_array( VkSparseMemoryBind *out, ++ VkSparseMemoryBind_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkSparseBufferMemoryBindInfo_host *convert_VkSparseBufferMemoryBindInfo( ++ VkSparseBufferMemoryBindInfo_host *out, ++ const VkSparseBufferMemoryBindInfo *in ) DECLSPEC_HIDDEN; ++extern void release_VkSparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo *out, ++ VkSparseBufferMemoryBindInfo_host *in ) DECLSPEC_HIDDEN; ++extern VkSparseBufferMemoryBindInfo_host *convert_VkSparseBufferMemoryBindInfo_array( ++ const VkSparseBufferMemoryBindInfo *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkSparseBufferMemoryBindInfo_array( VkSparseBufferMemoryBindInfo *out, ++ VkSparseBufferMemoryBindInfo_host *in, int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkSparseBufferMemoryBindInfo_host *convert_VkSparseBufferMemoryBindInfo( ++ VkSparseBufferMemoryBindInfo_host *out, const VkSparseBufferMemoryBindInfo *in ) ++{ ++ return (VkSparseBufferMemoryBindInfo_host *)in; ++} ++static inline void release_VkSparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo *out, ++ VkSparseBufferMemoryBindInfo_host *in ) ++{ ++} ++static inline VkSparseBufferMemoryBindInfo_host *convert_VkSparseBufferMemoryBindInfo_array( ++ const VkSparseBufferMemoryBindInfo *in, int count ) ++{ ++ return (VkSparseBufferMemoryBindInfo_host *)in; ++} ++static inline void release_VkSparseBufferMemoryBindInfo_array( VkSparseBufferMemoryBindInfo *out, ++ VkSparseBufferMemoryBindInfo_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkSparseImageOpaqueMemoryBindInfo_host *convert_VkSparseImageOpaqueMemoryBindInfo( ++ VkSparseImageOpaqueMemoryBindInfo_host *out, ++ const VkSparseImageOpaqueMemoryBindInfo *in ) DECLSPEC_HIDDEN; ++extern void release_VkSparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo *out, ++ VkSparseImageOpaqueMemoryBindInfo_host *in ) DECLSPEC_HIDDEN; ++extern VkSparseImageOpaqueMemoryBindInfo_host *convert_VkSparseImageOpaqueMemoryBindInfo_array( ++ const VkSparseImageOpaqueMemoryBindInfo *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkSparseImageOpaqueMemoryBindInfo_array( ++ VkSparseImageOpaqueMemoryBindInfo *out, VkSparseImageOpaqueMemoryBindInfo_host *in, ++ int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkSparseImageOpaqueMemoryBindInfo_host *convert_VkSparseImageOpaqueMemoryBindInfo( ++ VkSparseImageOpaqueMemoryBindInfo_host *out, const VkSparseImageOpaqueMemoryBindInfo *in ) ++{ ++ return (VkSparseImageOpaqueMemoryBindInfo_host *)in; ++} ++static inline void release_VkSparseImageOpaqueMemoryBindInfo( ++ VkSparseImageOpaqueMemoryBindInfo *out, VkSparseImageOpaqueMemoryBindInfo_host *in ) ++{ ++} ++static inline VkSparseImageOpaqueMemoryBindInfo_host *convert_VkSparseImageOpaqueMemoryBindInfo_array( ++ const VkSparseImageOpaqueMemoryBindInfo *in, int count ) ++{ ++ return (VkSparseImageOpaqueMemoryBindInfo_host *)in; ++} ++static inline void release_VkSparseImageOpaqueMemoryBindInfo_array( ++ VkSparseImageOpaqueMemoryBindInfo *out, VkSparseImageOpaqueMemoryBindInfo_host *in, ++ int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkSparseImageMemoryBind_host *convert_VkSparseImageMemoryBind( ++ VkSparseImageMemoryBind_host *out, const VkSparseImageMemoryBind *in ) DECLSPEC_HIDDEN; ++extern void release_VkSparseImageMemoryBind( VkSparseImageMemoryBind *out, ++ VkSparseImageMemoryBind_host *in ) DECLSPEC_HIDDEN; ++extern VkSparseImageMemoryBind_host *convert_VkSparseImageMemoryBind_array( ++ const VkSparseImageMemoryBind *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkSparseImageMemoryBind_array( VkSparseImageMemoryBind *out, ++ VkSparseImageMemoryBind_host *in, int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkSparseImageMemoryBind_host *convert_VkSparseImageMemoryBind( ++ VkSparseImageMemoryBind_host *out, const VkSparseImageMemoryBind *in ) ++{ ++ return (VkSparseImageMemoryBind_host *)in; ++} ++static inline void release_VkSparseImageMemoryBind( VkSparseImageMemoryBind *out, ++ VkSparseImageMemoryBind_host *in ) ++{ ++} ++static inline VkSparseImageMemoryBind_host *convert_VkSparseImageMemoryBind_array( ++ const VkSparseImageMemoryBind *in, int count ) ++{ ++ return (VkSparseImageMemoryBind_host *)in; ++} ++static inline void release_VkSparseImageMemoryBind_array( VkSparseImageMemoryBind *out, ++ VkSparseImageMemoryBind_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkSparseImageMemoryBindInfo_host *convert_VkSparseImageMemoryBindInfo( ++ VkSparseImageMemoryBindInfo_host *out, ++ const VkSparseImageMemoryBindInfo *in ) DECLSPEC_HIDDEN; ++extern void release_VkSparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo *out, ++ VkSparseImageMemoryBindInfo_host *in ) DECLSPEC_HIDDEN; ++extern VkSparseImageMemoryBindInfo_host *convert_VkSparseImageMemoryBindInfo_array( ++ const VkSparseImageMemoryBindInfo *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkSparseImageMemoryBindInfo_array( VkSparseImageMemoryBindInfo *out, ++ VkSparseImageMemoryBindInfo_host *in, int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkSparseImageMemoryBindInfo_host *convert_VkSparseImageMemoryBindInfo( ++ VkSparseImageMemoryBindInfo_host *out, const VkSparseImageMemoryBindInfo *in ) ++{ ++ return (VkSparseImageMemoryBindInfo_host *)in; ++} ++static inline void release_VkSparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo *out, ++ VkSparseImageMemoryBindInfo_host *in ) ++{ ++} ++static inline VkSparseImageMemoryBindInfo_host *convert_VkSparseImageMemoryBindInfo_array( ++ const VkSparseImageMemoryBindInfo *in, int count ) ++{ ++ return (VkSparseImageMemoryBindInfo_host *)in; ++} ++static inline void release_VkSparseImageMemoryBindInfo_array( VkSparseImageMemoryBindInfo *out, ++ VkSparseImageMemoryBindInfo_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkBindSparseInfo_host *convert_VkBindSparseInfo( VkBindSparseInfo_host *out, ++ const VkBindSparseInfo *in ) DECLSPEC_HIDDEN; ++extern void release_VkBindSparseInfo( VkBindSparseInfo *out, ++ VkBindSparseInfo_host *in ) DECLSPEC_HIDDEN; ++extern VkBindSparseInfo_host *convert_VkBindSparseInfo_array( const VkBindSparseInfo *in, ++ int count ) DECLSPEC_HIDDEN; ++extern void release_VkBindSparseInfo_array( VkBindSparseInfo *out, VkBindSparseInfo_host *in, ++ int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkBindSparseInfo_host *convert_VkBindSparseInfo( VkBindSparseInfo_host *out, ++ const VkBindSparseInfo *in ) ++{ ++ return (VkBindSparseInfo_host *)in; ++} ++static inline void release_VkBindSparseInfo( VkBindSparseInfo *out, VkBindSparseInfo_host *in ) ++{ ++} ++static inline VkBindSparseInfo_host *convert_VkBindSparseInfo_array( const VkBindSparseInfo *in, ++ int count ) ++{ ++ return (VkBindSparseInfo_host *)in; ++} ++static inline void release_VkBindSparseInfo_array( VkBindSparseInfo *out, ++ VkBindSparseInfo_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkDescriptorImageInfo_host *convert_VkDescriptorImageInfo( VkDescriptorImageInfo_host *out, ++ const VkDescriptorImageInfo *in ) DECLSPEC_HIDDEN; ++extern void release_VkDescriptorImageInfo( VkDescriptorImageInfo *out, ++ VkDescriptorImageInfo_host *in ) DECLSPEC_HIDDEN; ++extern VkDescriptorImageInfo_host *convert_VkDescriptorImageInfo_array( ++ const VkDescriptorImageInfo *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkDescriptorImageInfo_array( VkDescriptorImageInfo *out, ++ VkDescriptorImageInfo_host *in, int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkDescriptorImageInfo_host *convert_VkDescriptorImageInfo( ++ VkDescriptorImageInfo_host *out, const VkDescriptorImageInfo *in ) ++{ ++ return (VkDescriptorImageInfo_host *)in; ++} ++static inline void release_VkDescriptorImageInfo( VkDescriptorImageInfo *out, ++ VkDescriptorImageInfo_host *in ) ++{ ++} ++static inline VkDescriptorImageInfo_host *convert_VkDescriptorImageInfo_array( ++ const VkDescriptorImageInfo *in, int count ) ++{ ++ return (VkDescriptorImageInfo_host *)in; ++} ++static inline void release_VkDescriptorImageInfo_array( VkDescriptorImageInfo *out, ++ VkDescriptorImageInfo_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkDescriptorBufferInfo_host *convert_VkDescriptorBufferInfo( ++ VkDescriptorBufferInfo_host *out, const VkDescriptorBufferInfo *in ) DECLSPEC_HIDDEN; ++extern void release_VkDescriptorBufferInfo( VkDescriptorBufferInfo *out, ++ VkDescriptorBufferInfo_host *in ) DECLSPEC_HIDDEN; ++extern VkDescriptorBufferInfo_host *convert_VkDescriptorBufferInfo_array( ++ const VkDescriptorBufferInfo *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkDescriptorBufferInfo_array( VkDescriptorBufferInfo *out, ++ VkDescriptorBufferInfo_host *in, int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkDescriptorBufferInfo_host *convert_VkDescriptorBufferInfo( ++ VkDescriptorBufferInfo_host *out, const VkDescriptorBufferInfo *in ) ++{ ++ return (VkDescriptorBufferInfo_host *)in; ++} ++static inline void release_VkDescriptorBufferInfo( VkDescriptorBufferInfo *out, ++ VkDescriptorBufferInfo_host *in ) ++{ ++} ++static inline VkDescriptorBufferInfo_host *convert_VkDescriptorBufferInfo_array( ++ const VkDescriptorBufferInfo *in, int count ) ++{ ++ return (VkDescriptorBufferInfo_host *)in; ++} ++static inline void release_VkDescriptorBufferInfo_array( VkDescriptorBufferInfo *out, ++ VkDescriptorBufferInfo_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkWriteDescriptorSet_host *convert_VkWriteDescriptorSet( VkWriteDescriptorSet_host *out, ++ const VkWriteDescriptorSet *in ) DECLSPEC_HIDDEN; ++extern void release_VkWriteDescriptorSet( VkWriteDescriptorSet *out, ++ VkWriteDescriptorSet_host *in ) DECLSPEC_HIDDEN; ++extern VkWriteDescriptorSet_host *convert_VkWriteDescriptorSet_array( ++ const VkWriteDescriptorSet *in, int count ) DECLSPEC_HIDDEN; ++extern void release_VkWriteDescriptorSet_array( VkWriteDescriptorSet *out, ++ VkWriteDescriptorSet_host *in, int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkWriteDescriptorSet_host *convert_VkWriteDescriptorSet( ++ VkWriteDescriptorSet_host *out, const VkWriteDescriptorSet *in ) ++{ ++ return (VkWriteDescriptorSet_host *)in; ++} ++static inline void release_VkWriteDescriptorSet( VkWriteDescriptorSet *out, ++ VkWriteDescriptorSet_host *in ) ++{ ++} ++static inline VkWriteDescriptorSet_host *convert_VkWriteDescriptorSet_array( ++ const VkWriteDescriptorSet *in, int count ) ++{ ++ return (VkWriteDescriptorSet_host *)in; ++} ++static inline void release_VkWriteDescriptorSet_array( VkWriteDescriptorSet *out, ++ VkWriteDescriptorSet_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++extern VkCopyDescriptorSet_host *convert_VkCopyDescriptorSet( VkCopyDescriptorSet_host *out, ++ const VkCopyDescriptorSet *in ) DECLSPEC_HIDDEN; ++extern void release_VkCopyDescriptorSet( VkCopyDescriptorSet *out, ++ VkCopyDescriptorSet_host *in ) DECLSPEC_HIDDEN; ++extern VkCopyDescriptorSet_host *convert_VkCopyDescriptorSet_array( const VkCopyDescriptorSet *in, ++ int count ) DECLSPEC_HIDDEN; ++extern void release_VkCopyDescriptorSet_array( VkCopyDescriptorSet *out, ++ VkCopyDescriptorSet_host *in, int count ) DECLSPEC_HIDDEN; ++#else /* defined(USE_STRUCT_CONVERSION) */ ++static inline VkCopyDescriptorSet_host *convert_VkCopyDescriptorSet( VkCopyDescriptorSet_host *out, ++ const VkCopyDescriptorSet *in ) ++{ ++ return (VkCopyDescriptorSet_host *)in; ++} ++static inline void release_VkCopyDescriptorSet( VkCopyDescriptorSet *out, ++ VkCopyDescriptorSet_host *in ) ++{ ++} ++static inline VkCopyDescriptorSet_host *convert_VkCopyDescriptorSet_array( ++ const VkCopyDescriptorSet *in, int count ) ++{ ++ return (VkCopyDescriptorSet_host *)in; ++} ++static inline void release_VkCopyDescriptorSet_array( VkCopyDescriptorSet *out, ++ VkCopyDescriptorSet_host *in, int count ) ++{ ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++ ++extern BOOL init_vulkan( void ) DECLSPEC_HIDDEN; ++extern BOOL is_null_func( const char *name ); DECLSPEC_HIDDEN ++extern void free_vulkan( void ) DECLSPEC_HIDDEN; ++ ++#endif /* __VULKAN_PRIVATE_H */ +diff --git a/dlls/vulkan/vulkan_thunks.c b/dlls/vulkan/vulkan_thunks.c +new file mode 100644 +index 0000000..8af28e7c +--- /dev/null ++++ b/dlls/vulkan/vulkan_thunks.c +@@ -0,0 +1,6593 @@ ++/* ++ * Vulkan API implementation ++ * ++ * Copyright 2016 Sebastian Lackner ++ * Copyright 2016 Michael Müller ++ * Copyright 2016 Erich E. Hoover ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA ++ */ ++ ++#include "config.h" ++#include "wine/port.h" ++#include ++ ++#include "windef.h" ++#include "winbase.h" ++#include "wine/list.h" ++#include "wine/debug.h" ++#include "wine/library.h" ++ ++#include "vulkan_private.h" ++ ++WINE_DEFAULT_DEBUG_CHANNEL(vulkan); ++WINE_DECLARE_DEBUG_CHANNEL(winediag); ++ ++#define ARRAY_SIZE(array) (sizeof(array)/sizeof(*array)) ++ ++static HANDLE function_heap; ++ ++static CRITICAL_SECTION function_section; ++static CRITICAL_SECTION_DEBUG critsect_debug = ++{ ++ 0, 0, &function_section, ++ { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList }, ++ 0, 0, { (DWORD_PTR)(__FILE__ ": function_section") } ++}; ++static CRITICAL_SECTION function_section = { &critsect_debug, -1, 0, 0, 0, 0 }; ++ ++#if defined(__i386__) ++#include ++struct PFN_vkAllocationFunction_opcodes ++{ ++ BYTE pushl_ebp[1]; /* pushl %ebp */ ++ BYTE movl_esp_ebp[2]; /* movl %esp,%ebp */ ++ BYTE subl_0x08_esp[3]; /* subl $8,%esp */ ++ BYTE pushl_0x14_ebp[3]; /* pushl 20(%ebp) */ ++ BYTE pushl_0x10_ebp[3]; /* pushl 16(%ebp) */ ++ BYTE pushl_0x0c_ebp[3]; /* pushl 12(%ebp) */ ++ BYTE pushl_0x08_ebp[3]; /* pushl 8(%ebp) */ ++ BYTE movl_func_eax[1]; /* movl function,%eax */ ++ void *function; ++ BYTE call_eax[2]; /* call *%eax */ ++ BYTE leave[1]; /* leave */ ++ BYTE ret[1]; /* ret */ ++}; ++#include ++ ++static const struct PFN_vkAllocationFunction_opcodes PFN_vkAllocationFunction_code = ++{ ++ { 0x55 }, /* pushl %ebp */ ++ { 0x89, 0xe5 }, /* movl %esp,%ebp */ ++ { 0x83, 0xec, 0x08 }, /* subl $8,%esp */ ++ { 0xff, 0x75, 0x14 }, /* pushl 20(%ebp) */ ++ { 0xff, 0x75, 0x10 }, /* pushl 16(%ebp) */ ++ { 0xff, 0x75, 0x0c }, /* pushl 12(%ebp) */ ++ { 0xff, 0x75, 0x08 }, /* pushl 8(%ebp) */ ++ { 0xb8 }, /* movl function,%eax */ ++ NULL, ++ { 0xff, 0xd0 }, /* call *%eax */ ++ { 0xc9 }, /* leave */ ++ { 0xc3 }, /* ret */ ++}; ++#elif defined(__x86_64__) ++#include ++struct PFN_vkAllocationFunction_opcodes ++{ ++ BYTE pushq_rbp[1]; /* pushq %rbp */ ++ BYTE movq_rsp_rbp[3]; /* movq %rsp,%rbp */ ++ BYTE subq_0x20_rsp[4]; /* subq $0x20,%rsp */ ++ BYTE movq_rcx_r9[3]; /* movq %rcx,%r9 */ ++ BYTE movq_rdx_r8[3]; /* movq %rdx,%r8 */ ++ BYTE movq_rsi_rdx[3]; /* movq %rsi,%rdx */ ++ BYTE movq_rsi_rcx[3]; /* movq %rdi,%rcx */ ++ BYTE movq_func_rax[2]; /* movq function,%rax */ ++ void *function; ++ BYTE call_rax[2]; /* call *%rax */ ++ BYTE movq_rbp_rsp[3]; /* movq %rbp,%rsp */ ++ BYTE popq_rbp[1]; /* popq %rbp */ ++ BYTE ret[1]; /* ret */ ++}; ++#include ++ ++static const struct PFN_vkAllocationFunction_opcodes PFN_vkAllocationFunction_code = ++{ ++ { 0x55 }, /* pushq %rbp */ ++ { 0x48, 0x89, 0xe5 }, /* movq %rsp,%rbp */ ++ { 0x48, 0x83, 0xec, 0x20 }, /* subq $0x20,%rsp */ ++ { 0x49, 0x89, 0xc9 }, /* movq %rcx,%r9 */ ++ { 0x49, 0x89, 0xd0 }, /* movq %rdx,%r8 */ ++ { 0x48, 0x89, 0xf2 }, /* movq %rsi,%rdx */ ++ { 0x48, 0x89, 0xf9 }, /* movq %rdi,%rcx */ ++ { 0x48, 0xb8 }, /* movq function,%rax */ ++ NULL, ++ { 0xff, 0xd0 }, /* call *%eax */ ++ { 0x48, 0x89, 0xec }, /* movq %rbp,%rsp */ ++ { 0x5d }, /* popq %rbp */ ++ { 0xc3 }, /* ret */ ++}; ++#endif ++ ++#if defined(__i386__) || defined(__x86_64__) ++struct PFN_vkAllocationFunction_function ++{ ++ struct list entry; ++ struct PFN_vkAllocationFunction_opcodes code; ++}; ++#endif ++ ++void convert_PFN_vkAllocationFunction( PFN_vkAllocationFunction_host *out, ++ const PFN_vkAllocationFunction *in ) ++{ ++#if defined(__i386__) || defined(__x86_64__) ++ static struct list function_list = LIST_INIT( function_list ); ++ struct PFN_vkAllocationFunction_function *function; ++ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!*in) ++ { ++ *out = NULL; ++ return; ++ } ++ EnterCriticalSection( &function_section ); ++ ++ LIST_FOR_EACH_ENTRY( function, &function_list, struct PFN_vkAllocationFunction_function, entry ) ++ if (function->code.function == *in) break; ++ ++ if (&function->entry == &function_list) ++ { ++ function = HeapAlloc( function_heap, 0, sizeof(*function) ); ++ list_add_tail( &function_list, &function->entry ); ++ function->code = PFN_vkAllocationFunction_code; ++ function->code.function = *in; ++ } ++ *out = (void *)&function->code; ++ ++ LeaveCriticalSection( &function_section ); ++#else ++ *out = *in; ++#endif ++} ++void release_PFN_vkAllocationFunction( PFN_vkAllocationFunction *out, ++ PFN_vkAllocationFunction_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++} ++ ++#if defined(__i386__) ++#include ++struct PFN_vkReallocationFunction_opcodes ++{ ++ BYTE pushl_ebp[1]; /* pushl %ebp */ ++ BYTE movl_esp_ebp[2]; /* movl %esp,%ebp */ ++ BYTE subl_0x04_esp[3]; /* subl $4,%esp */ ++ BYTE pushl_0x18_ebp[3]; /* pushl 24(%ebp) */ ++ BYTE pushl_0x14_ebp[3]; /* pushl 20(%ebp) */ ++ BYTE pushl_0x10_ebp[3]; /* pushl 16(%ebp) */ ++ BYTE pushl_0x0c_ebp[3]; /* pushl 12(%ebp) */ ++ BYTE pushl_0x08_ebp[3]; /* pushl 8(%ebp) */ ++ BYTE movl_func_eax[1]; /* movl function,%eax */ ++ void *function; ++ BYTE call_eax[2]; /* call *%eax */ ++ BYTE leave[1]; /* leave */ ++ BYTE ret[1]; /* ret */ ++}; ++#include ++ ++static const struct PFN_vkReallocationFunction_opcodes PFN_vkReallocationFunction_code = ++{ ++ { 0x55 }, /* pushl %ebp */ ++ { 0x89, 0xe5 }, /* movl %esp,%ebp */ ++ { 0x83, 0xec, 0x04 }, /* subl $4,%esp */ ++ { 0xff, 0x75, 0x18 }, /* pushl 24(%ebp) */ ++ { 0xff, 0x75, 0x14 }, /* pushl 20(%ebp) */ ++ { 0xff, 0x75, 0x10 }, /* pushl 16(%ebp) */ ++ { 0xff, 0x75, 0x0c }, /* pushl 12(%ebp) */ ++ { 0xff, 0x75, 0x08 }, /* pushl 8(%ebp) */ ++ { 0xb8 }, /* movl function,%eax */ ++ NULL, ++ { 0xff, 0xd0 }, /* call *%eax */ ++ { 0xc9 }, /* leave */ ++ { 0xc3 }, /* ret */ ++}; ++#elif defined(__x86_64__) ++#include ++struct PFN_vkReallocationFunction_opcodes ++{ ++ BYTE pushq_rbp[1]; /* pushq %rbp */ ++ BYTE movq_rsp_rbp[3]; /* movq %rsp,%rbp */ ++ BYTE subq_0x08_rsp[4]; /* subq $8,%rsp */ ++ BYTE pushq_r8[2]; /* pushq %r8 */ ++ BYTE subq_0x20_rsp[4]; /* subq $0x20,%rsp */ ++ BYTE movq_rcx_r9[3]; /* movq %rcx,%r9 */ ++ BYTE movq_rdx_r8[3]; /* movq %rdx,%r8 */ ++ BYTE movq_rsi_rdx[3]; /* movq %rsi,%rdx */ ++ BYTE movq_rsi_rcx[3]; /* movq %rdi,%rcx */ ++ BYTE movq_func_rax[2]; /* movq function,%rax */ ++ void *function; ++ BYTE call_rax[2]; /* call *%rax */ ++ BYTE movq_rbp_rsp[3]; /* movq %rbp,%rsp */ ++ BYTE popq_rbp[1]; /* popq %rbp */ ++ BYTE ret[1]; /* ret */ ++}; ++#include ++ ++static const struct PFN_vkReallocationFunction_opcodes PFN_vkReallocationFunction_code = ++{ ++ { 0x55 }, /* pushq %rbp */ ++ { 0x48, 0x89, 0xe5 }, /* movq %rsp,%rbp */ ++ { 0x48, 0x83, 0xec, 0x08 }, /* subq $8,%rsp */ ++ { 0x41, 0x50 }, /* pushq %r8 */ ++ { 0x48, 0x83, 0xec, 0x20 }, /* subq $0x20,%rsp */ ++ { 0x49, 0x89, 0xc9 }, /* movq %rcx,%r9 */ ++ { 0x49, 0x89, 0xd0 }, /* movq %rdx,%r8 */ ++ { 0x48, 0x89, 0xf2 }, /* movq %rsi,%rdx */ ++ { 0x48, 0x89, 0xf9 }, /* movq %rdi,%rcx */ ++ { 0x48, 0xb8 }, /* movq function,%rax */ ++ NULL, ++ { 0xff, 0xd0 }, /* call *%eax */ ++ { 0x48, 0x89, 0xec }, /* movq %rbp,%rsp */ ++ { 0x5d }, /* popq %rbp */ ++ { 0xc3 }, /* ret */ ++}; ++#endif ++ ++#if defined(__i386__) || defined(__x86_64__) ++struct PFN_vkReallocationFunction_function ++{ ++ struct list entry; ++ struct PFN_vkReallocationFunction_opcodes code; ++}; ++#endif ++ ++void convert_PFN_vkReallocationFunction( PFN_vkReallocationFunction_host *out, ++ const PFN_vkReallocationFunction *in ) ++{ ++#if defined(__i386__) || defined(__x86_64__) ++ static struct list function_list = LIST_INIT( function_list ); ++ struct PFN_vkReallocationFunction_function *function; ++ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!*in) ++ { ++ *out = NULL; ++ return; ++ } ++ EnterCriticalSection( &function_section ); ++ ++ LIST_FOR_EACH_ENTRY( function, &function_list, struct PFN_vkReallocationFunction_function, ++ entry ) ++ if (function->code.function == *in) break; ++ ++ if (&function->entry == &function_list) ++ { ++ function = HeapAlloc( function_heap, 0, sizeof(*function) ); ++ list_add_tail( &function_list, &function->entry ); ++ function->code = PFN_vkReallocationFunction_code; ++ function->code.function = *in; ++ } ++ *out = (void *)&function->code; ++ ++ LeaveCriticalSection( &function_section ); ++#else ++ *out = *in; ++#endif ++} ++void release_PFN_vkReallocationFunction( PFN_vkReallocationFunction *out, ++ PFN_vkReallocationFunction_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++} ++ ++#if defined(__i386__) ++#include ++struct PFN_vkFreeFunction_opcodes ++{ ++ BYTE pushl_ebp[1]; /* pushl %ebp */ ++ BYTE movl_esp_ebp[2]; /* movl %esp,%ebp */ ++ BYTE pushl_0x0c_ebp[3]; /* pushl 12(%ebp) */ ++ BYTE pushl_0x08_ebp[3]; /* pushl 8(%ebp) */ ++ BYTE movl_func_eax[1]; /* movl function,%eax */ ++ void *function; ++ BYTE call_eax[2]; /* call *%eax */ ++ BYTE leave[1]; /* leave */ ++ BYTE ret[1]; /* ret */ ++}; ++#include ++ ++static const struct PFN_vkFreeFunction_opcodes PFN_vkFreeFunction_code = ++{ ++ { 0x55 }, /* pushl %ebp */ ++ { 0x89, 0xe5 }, /* movl %esp,%ebp */ ++ { 0xff, 0x75, 0x0c }, /* pushl 12(%ebp) */ ++ { 0xff, 0x75, 0x08 }, /* pushl 8(%ebp) */ ++ { 0xb8 }, /* movl function,%eax */ ++ NULL, ++ { 0xff, 0xd0 }, /* call *%eax */ ++ { 0xc9 }, /* leave */ ++ { 0xc3 }, /* ret */ ++}; ++#elif defined(__x86_64__) ++#include ++struct PFN_vkFreeFunction_opcodes ++{ ++ BYTE pushq_rbp[1]; /* pushq %rbp */ ++ BYTE movq_rsp_rbp[3]; /* movq %rsp,%rbp */ ++ BYTE subq_0x20_rsp[4]; /* subq $0x20,%rsp */ ++ BYTE movq_rsi_rdx[3]; /* movq %rsi,%rdx */ ++ BYTE movq_rsi_rcx[3]; /* movq %rdi,%rcx */ ++ BYTE movq_func_rax[2]; /* movq function,%rax */ ++ void *function; ++ BYTE call_rax[2]; /* call *%rax */ ++ BYTE movq_rbp_rsp[3]; /* movq %rbp,%rsp */ ++ BYTE popq_rbp[1]; /* popq %rbp */ ++ BYTE ret[1]; /* ret */ ++}; ++#include ++ ++static const struct PFN_vkFreeFunction_opcodes PFN_vkFreeFunction_code = ++{ ++ { 0x55 }, /* pushq %rbp */ ++ { 0x48, 0x89, 0xe5 }, /* movq %rsp,%rbp */ ++ { 0x48, 0x83, 0xec, 0x20 }, /* subq $0x20,%rsp */ ++ { 0x48, 0x89, 0xf2 }, /* movq %rsi,%rdx */ ++ { 0x48, 0x89, 0xf9 }, /* movq %rdi,%rcx */ ++ { 0x48, 0xb8 }, /* movq function,%rax */ ++ NULL, ++ { 0xff, 0xd0 }, /* call *%eax */ ++ { 0x48, 0x89, 0xec }, /* movq %rbp,%rsp */ ++ { 0x5d }, /* popq %rbp */ ++ { 0xc3 }, /* ret */ ++}; ++#endif ++ ++#if defined(__i386__) || defined(__x86_64__) ++struct PFN_vkFreeFunction_function ++{ ++ struct list entry; ++ struct PFN_vkFreeFunction_opcodes code; ++}; ++#endif ++ ++void convert_PFN_vkFreeFunction( PFN_vkFreeFunction_host *out, const PFN_vkFreeFunction *in ) ++{ ++#if defined(__i386__) || defined(__x86_64__) ++ static struct list function_list = LIST_INIT( function_list ); ++ struct PFN_vkFreeFunction_function *function; ++ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!*in) ++ { ++ *out = NULL; ++ return; ++ } ++ EnterCriticalSection( &function_section ); ++ ++ LIST_FOR_EACH_ENTRY( function, &function_list, struct PFN_vkFreeFunction_function, entry ) ++ if (function->code.function == *in) break; ++ ++ if (&function->entry == &function_list) ++ { ++ function = HeapAlloc( function_heap, 0, sizeof(*function) ); ++ list_add_tail( &function_list, &function->entry ); ++ function->code = PFN_vkFreeFunction_code; ++ function->code.function = *in; ++ } ++ *out = (void *)&function->code; ++ ++ LeaveCriticalSection( &function_section ); ++#else ++ *out = *in; ++#endif ++} ++void release_PFN_vkFreeFunction( PFN_vkFreeFunction *out, PFN_vkFreeFunction_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++} ++ ++#if defined(__i386__) ++#include ++struct PFN_vkInternalAllocationNotification_opcodes ++{ ++ BYTE pushl_ebp[1]; /* pushl %ebp */ ++ BYTE movl_esp_ebp[2]; /* movl %esp,%ebp */ ++ BYTE subl_0x08_esp[3]; /* subl $8,%esp */ ++ BYTE pushl_0x14_ebp[3]; /* pushl 20(%ebp) */ ++ BYTE pushl_0x10_ebp[3]; /* pushl 16(%ebp) */ ++ BYTE pushl_0x0c_ebp[3]; /* pushl 12(%ebp) */ ++ BYTE pushl_0x08_ebp[3]; /* pushl 8(%ebp) */ ++ BYTE movl_func_eax[1]; /* movl function,%eax */ ++ void *function; ++ BYTE call_eax[2]; /* call *%eax */ ++ BYTE leave[1]; /* leave */ ++ BYTE ret[1]; /* ret */ ++}; ++#include ++ ++static const struct PFN_vkInternalAllocationNotification_opcodes PFN_vkInternalAllocationNotification_code = ++{ ++ { 0x55 }, /* pushl %ebp */ ++ { 0x89, 0xe5 }, /* movl %esp,%ebp */ ++ { 0x83, 0xec, 0x08 }, /* subl $8,%esp */ ++ { 0xff, 0x75, 0x14 }, /* pushl 20(%ebp) */ ++ { 0xff, 0x75, 0x10 }, /* pushl 16(%ebp) */ ++ { 0xff, 0x75, 0x0c }, /* pushl 12(%ebp) */ ++ { 0xff, 0x75, 0x08 }, /* pushl 8(%ebp) */ ++ { 0xb8 }, /* movl function,%eax */ ++ NULL, ++ { 0xff, 0xd0 }, /* call *%eax */ ++ { 0xc9 }, /* leave */ ++ { 0xc3 }, /* ret */ ++}; ++#elif defined(__x86_64__) ++#include ++struct PFN_vkInternalAllocationNotification_opcodes ++{ ++ BYTE pushq_rbp[1]; /* pushq %rbp */ ++ BYTE movq_rsp_rbp[3]; /* movq %rsp,%rbp */ ++ BYTE subq_0x20_rsp[4]; /* subq $0x20,%rsp */ ++ BYTE movq_rcx_r9[3]; /* movq %rcx,%r9 */ ++ BYTE movq_rdx_r8[3]; /* movq %rdx,%r8 */ ++ BYTE movq_rsi_rdx[3]; /* movq %rsi,%rdx */ ++ BYTE movq_rsi_rcx[3]; /* movq %rdi,%rcx */ ++ BYTE movq_func_rax[2]; /* movq function,%rax */ ++ void *function; ++ BYTE call_rax[2]; /* call *%rax */ ++ BYTE movq_rbp_rsp[3]; /* movq %rbp,%rsp */ ++ BYTE popq_rbp[1]; /* popq %rbp */ ++ BYTE ret[1]; /* ret */ ++}; ++#include ++ ++static const struct PFN_vkInternalAllocationNotification_opcodes PFN_vkInternalAllocationNotification_code = ++{ ++ { 0x55 }, /* pushq %rbp */ ++ { 0x48, 0x89, 0xe5 }, /* movq %rsp,%rbp */ ++ { 0x48, 0x83, 0xec, 0x20 }, /* subq $0x20,%rsp */ ++ { 0x49, 0x89, 0xc9 }, /* movq %rcx,%r9 */ ++ { 0x49, 0x89, 0xd0 }, /* movq %rdx,%r8 */ ++ { 0x48, 0x89, 0xf2 }, /* movq %rsi,%rdx */ ++ { 0x48, 0x89, 0xf9 }, /* movq %rdi,%rcx */ ++ { 0x48, 0xb8 }, /* movq function,%rax */ ++ NULL, ++ { 0xff, 0xd0 }, /* call *%eax */ ++ { 0x48, 0x89, 0xec }, /* movq %rbp,%rsp */ ++ { 0x5d }, /* popq %rbp */ ++ { 0xc3 }, /* ret */ ++}; ++#endif ++ ++#if defined(__i386__) || defined(__x86_64__) ++struct PFN_vkInternalAllocationNotification_function ++{ ++ struct list entry; ++ struct PFN_vkInternalAllocationNotification_opcodes code; ++}; ++#endif ++ ++void convert_PFN_vkInternalAllocationNotification( PFN_vkInternalAllocationNotification_host *out, ++ const PFN_vkInternalAllocationNotification *in ) ++{ ++#if defined(__i386__) || defined(__x86_64__) ++ static struct list function_list = LIST_INIT( function_list ); ++ struct PFN_vkInternalAllocationNotification_function *function; ++ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!*in) ++ { ++ *out = NULL; ++ return; ++ } ++ EnterCriticalSection( &function_section ); ++ ++ LIST_FOR_EACH_ENTRY( function, &function_list, ++ struct PFN_vkInternalAllocationNotification_function, entry ) ++ if (function->code.function == *in) break; ++ ++ if (&function->entry == &function_list) ++ { ++ function = HeapAlloc( function_heap, 0, sizeof(*function) ); ++ list_add_tail( &function_list, &function->entry ); ++ function->code = PFN_vkInternalAllocationNotification_code; ++ function->code.function = *in; ++ } ++ *out = (void *)&function->code; ++ ++ LeaveCriticalSection( &function_section ); ++#else ++ *out = *in; ++#endif ++} ++void release_PFN_vkInternalAllocationNotification( PFN_vkInternalAllocationNotification *out, ++ PFN_vkInternalAllocationNotification_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++} ++ ++#if defined(__i386__) ++#include ++struct PFN_vkInternalFreeNotification_opcodes ++{ ++ BYTE pushl_ebp[1]; /* pushl %ebp */ ++ BYTE movl_esp_ebp[2]; /* movl %esp,%ebp */ ++ BYTE subl_0x08_esp[3]; /* subl $8,%esp */ ++ BYTE pushl_0x14_ebp[3]; /* pushl 20(%ebp) */ ++ BYTE pushl_0x10_ebp[3]; /* pushl 16(%ebp) */ ++ BYTE pushl_0x0c_ebp[3]; /* pushl 12(%ebp) */ ++ BYTE pushl_0x08_ebp[3]; /* pushl 8(%ebp) */ ++ BYTE movl_func_eax[1]; /* movl function,%eax */ ++ void *function; ++ BYTE call_eax[2]; /* call *%eax */ ++ BYTE leave[1]; /* leave */ ++ BYTE ret[1]; /* ret */ ++}; ++#include ++ ++static const struct PFN_vkInternalFreeNotification_opcodes PFN_vkInternalFreeNotification_code = ++{ ++ { 0x55 }, /* pushl %ebp */ ++ { 0x89, 0xe5 }, /* movl %esp,%ebp */ ++ { 0x83, 0xec, 0x08 }, /* subl $8,%esp */ ++ { 0xff, 0x75, 0x14 }, /* pushl 20(%ebp) */ ++ { 0xff, 0x75, 0x10 }, /* pushl 16(%ebp) */ ++ { 0xff, 0x75, 0x0c }, /* pushl 12(%ebp) */ ++ { 0xff, 0x75, 0x08 }, /* pushl 8(%ebp) */ ++ { 0xb8 }, /* movl function,%eax */ ++ NULL, ++ { 0xff, 0xd0 }, /* call *%eax */ ++ { 0xc9 }, /* leave */ ++ { 0xc3 }, /* ret */ ++}; ++#elif defined(__x86_64__) ++#include ++struct PFN_vkInternalFreeNotification_opcodes ++{ ++ BYTE pushq_rbp[1]; /* pushq %rbp */ ++ BYTE movq_rsp_rbp[3]; /* movq %rsp,%rbp */ ++ BYTE subq_0x20_rsp[4]; /* subq $0x20,%rsp */ ++ BYTE movq_rcx_r9[3]; /* movq %rcx,%r9 */ ++ BYTE movq_rdx_r8[3]; /* movq %rdx,%r8 */ ++ BYTE movq_rsi_rdx[3]; /* movq %rsi,%rdx */ ++ BYTE movq_rsi_rcx[3]; /* movq %rdi,%rcx */ ++ BYTE movq_func_rax[2]; /* movq function,%rax */ ++ void *function; ++ BYTE call_rax[2]; /* call *%rax */ ++ BYTE movq_rbp_rsp[3]; /* movq %rbp,%rsp */ ++ BYTE popq_rbp[1]; /* popq %rbp */ ++ BYTE ret[1]; /* ret */ ++}; ++#include ++ ++static const struct PFN_vkInternalFreeNotification_opcodes PFN_vkInternalFreeNotification_code = ++{ ++ { 0x55 }, /* pushq %rbp */ ++ { 0x48, 0x89, 0xe5 }, /* movq %rsp,%rbp */ ++ { 0x48, 0x83, 0xec, 0x20 }, /* subq $0x20,%rsp */ ++ { 0x49, 0x89, 0xc9 }, /* movq %rcx,%r9 */ ++ { 0x49, 0x89, 0xd0 }, /* movq %rdx,%r8 */ ++ { 0x48, 0x89, 0xf2 }, /* movq %rsi,%rdx */ ++ { 0x48, 0x89, 0xf9 }, /* movq %rdi,%rcx */ ++ { 0x48, 0xb8 }, /* movq function,%rax */ ++ NULL, ++ { 0xff, 0xd0 }, /* call *%eax */ ++ { 0x48, 0x89, 0xec }, /* movq %rbp,%rsp */ ++ { 0x5d }, /* popq %rbp */ ++ { 0xc3 }, /* ret */ ++}; ++#endif ++ ++#if defined(__i386__) || defined(__x86_64__) ++struct PFN_vkInternalFreeNotification_function ++{ ++ struct list entry; ++ struct PFN_vkInternalFreeNotification_opcodes code; ++}; ++#endif ++ ++void convert_PFN_vkInternalFreeNotification( PFN_vkInternalFreeNotification_host *out, ++ const PFN_vkInternalFreeNotification *in ) ++{ ++#if defined(__i386__) || defined(__x86_64__) ++ static struct list function_list = LIST_INIT( function_list ); ++ struct PFN_vkInternalFreeNotification_function *function; ++ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!*in) ++ { ++ *out = NULL; ++ return; ++ } ++ EnterCriticalSection( &function_section ); ++ ++ LIST_FOR_EACH_ENTRY( function, &function_list, struct PFN_vkInternalFreeNotification_function, ++ entry ) ++ if (function->code.function == *in) break; ++ ++ if (&function->entry == &function_list) ++ { ++ function = HeapAlloc( function_heap, 0, sizeof(*function) ); ++ list_add_tail( &function_list, &function->entry ); ++ function->code = PFN_vkInternalFreeNotification_code; ++ function->code.function = *in; ++ } ++ *out = (void *)&function->code; ++ ++ LeaveCriticalSection( &function_section ); ++#else ++ *out = *in; ++#endif ++} ++void release_PFN_vkInternalFreeNotification( PFN_vkInternalFreeNotification *out, ++ PFN_vkInternalFreeNotification_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++} ++ ++VkAllocationCallbacks_host *convert_VkAllocationCallbacks( VkAllocationCallbacks_host *out, ++ const VkAllocationCallbacks *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->pUserData = in->pUserData; ++ convert_PFN_vkAllocationFunction( &out->pfnAllocation, &in->pfnAllocation ); ++ convert_PFN_vkReallocationFunction( &out->pfnReallocation, &in->pfnReallocation ); ++ convert_PFN_vkFreeFunction( &out->pfnFree, &in->pfnFree ); ++ convert_PFN_vkInternalAllocationNotification( &out->pfnInternalAllocation, &in->pfnInternalAllocation ); ++ convert_PFN_vkInternalFreeNotification( &out->pfnInternalFree, &in->pfnInternalFree ); ++ ++ return out; ++} ++void release_VkAllocationCallbacks( VkAllocationCallbacks *out, VkAllocationCallbacks_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return; ++ ++ release_PFN_vkAllocationFunction( out ? &out->pfnAllocation : NULL, &in->pfnAllocation ); ++ release_PFN_vkReallocationFunction( out ? &out->pfnReallocation : NULL, &in->pfnReallocation ); ++ release_PFN_vkFreeFunction( out ? &out->pfnFree : NULL, &in->pfnFree ); ++ release_PFN_vkInternalAllocationNotification( out ? &out->pfnInternalAllocation : NULL, &in->pfnInternalAllocation ); ++ release_PFN_vkInternalFreeNotification( out ? &out->pfnInternalFree : NULL, &in->pfnInternalFree ); ++ ++ if (!out) return; ++ ++ out->pUserData = in->pUserData; ++} ++ ++VkAllocationCallbacks_host *convert_VkAllocationCallbacks_array( const VkAllocationCallbacks *in, ++ int count ) ++{ ++ VkAllocationCallbacks_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkAllocationCallbacks( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkAllocationCallbacks_array( VkAllocationCallbacks *out, ++ VkAllocationCallbacks_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkAllocationCallbacks( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkCommandBufferInheritanceInfo_host *convert_VkCommandBufferInheritanceInfo( ++ VkCommandBufferInheritanceInfo_host *out, const VkCommandBufferInheritanceInfo *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->renderPass = in->renderPass; ++ out->subpass = in->subpass; ++ out->framebuffer = in->framebuffer; ++ out->occlusionQueryEnable = in->occlusionQueryEnable; ++ out->queryFlags = in->queryFlags; ++ out->pipelineStatistics = in->pipelineStatistics; ++ ++ return out; ++} ++void release_VkCommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo *out, ++ VkCommandBufferInheritanceInfo_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in || !out) return; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->renderPass = in->renderPass; ++ out->subpass = in->subpass; ++ out->framebuffer = in->framebuffer; ++ out->occlusionQueryEnable = in->occlusionQueryEnable; ++ out->queryFlags = in->queryFlags; ++ out->pipelineStatistics = in->pipelineStatistics; ++} ++ ++VkCommandBufferInheritanceInfo_host *convert_VkCommandBufferInheritanceInfo_array( ++ const VkCommandBufferInheritanceInfo *in, int count ) ++{ ++ VkCommandBufferInheritanceInfo_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkCommandBufferInheritanceInfo( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkCommandBufferInheritanceInfo_array( VkCommandBufferInheritanceInfo *out, ++ VkCommandBufferInheritanceInfo_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkCommandBufferInheritanceInfo( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkCommandBufferBeginInfo_host *convert_VkCommandBufferBeginInfo( ++ VkCommandBufferBeginInfo_host *out, const VkCommandBufferBeginInfo *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->flags = in->flags; ++ out->pInheritanceInfo = convert_VkCommandBufferInheritanceInfo_array( in->pInheritanceInfo, 1 ); ++ ++ return out; ++} ++void release_VkCommandBufferBeginInfo( VkCommandBufferBeginInfo *out, ++ VkCommandBufferBeginInfo_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return; ++ ++ release_VkCommandBufferInheritanceInfo_array( out ? out->pInheritanceInfo : NULL, in->pInheritanceInfo, 1 ); ++ ++ if (!out) return; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->flags = in->flags; ++} ++ ++VkCommandBufferBeginInfo_host *convert_VkCommandBufferBeginInfo_array( ++ const VkCommandBufferBeginInfo *in, int count ) ++{ ++ VkCommandBufferBeginInfo_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkCommandBufferBeginInfo( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkCommandBufferBeginInfo_array( VkCommandBufferBeginInfo *out, ++ VkCommandBufferBeginInfo_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkCommandBufferBeginInfo( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkImageMemoryBarrier_host *convert_VkImageMemoryBarrier( VkImageMemoryBarrier_host *out, ++ const VkImageMemoryBarrier *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->srcAccessMask = in->srcAccessMask; ++ out->dstAccessMask = in->dstAccessMask; ++ out->oldLayout = in->oldLayout; ++ out->newLayout = in->newLayout; ++ out->srcQueueFamilyIndex = in->srcQueueFamilyIndex; ++ out->dstQueueFamilyIndex = in->dstQueueFamilyIndex; ++ out->image = in->image; ++ out->subresourceRange = in->subresourceRange; ++ ++ return out; ++} ++void release_VkImageMemoryBarrier( VkImageMemoryBarrier *out, VkImageMemoryBarrier_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in || !out) return; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->srcAccessMask = in->srcAccessMask; ++ out->dstAccessMask = in->dstAccessMask; ++ out->oldLayout = in->oldLayout; ++ out->newLayout = in->newLayout; ++ out->srcQueueFamilyIndex = in->srcQueueFamilyIndex; ++ out->dstQueueFamilyIndex = in->dstQueueFamilyIndex; ++ out->image = in->image; ++ out->subresourceRange = in->subresourceRange; ++} ++ ++VkImageMemoryBarrier_host *convert_VkImageMemoryBarrier_array( const VkImageMemoryBarrier *in, ++ int count ) ++{ ++ VkImageMemoryBarrier_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkImageMemoryBarrier( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkImageMemoryBarrier_array( VkImageMemoryBarrier *out, VkImageMemoryBarrier_host *in, ++ int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkImageMemoryBarrier( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkBufferCreateInfo_host *convert_VkBufferCreateInfo( VkBufferCreateInfo_host *out, ++ const VkBufferCreateInfo *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->flags = in->flags; ++ out->size = in->size; ++ out->usage = in->usage; ++ out->sharingMode = in->sharingMode; ++ out->queueFamilyIndexCount = in->queueFamilyIndexCount; ++ out->pQueueFamilyIndices = in->pQueueFamilyIndices; /* length is queueFamilyIndexCount */ ++ ++ return out; ++} ++void release_VkBufferCreateInfo( VkBufferCreateInfo *out, VkBufferCreateInfo_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in || !out) return; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->flags = in->flags; ++ out->size = in->size; ++ out->usage = in->usage; ++ out->sharingMode = in->sharingMode; ++ out->queueFamilyIndexCount = in->queueFamilyIndexCount; ++ out->pQueueFamilyIndices = in->pQueueFamilyIndices; /* length is queueFamilyIndexCount */ ++} ++ ++VkBufferCreateInfo_host *convert_VkBufferCreateInfo_array( const VkBufferCreateInfo *in, int count ) ++{ ++ VkBufferCreateInfo_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkBufferCreateInfo( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkBufferCreateInfo_array( VkBufferCreateInfo *out, VkBufferCreateInfo_host *in, ++ int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkBufferCreateInfo( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkBufferViewCreateInfo_host *convert_VkBufferViewCreateInfo( VkBufferViewCreateInfo_host *out, ++ const VkBufferViewCreateInfo *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->flags = in->flags; ++ out->buffer = in->buffer; ++ out->format = in->format; ++ out->offset = in->offset; ++ out->range = in->range; ++ ++ return out; ++} ++void release_VkBufferViewCreateInfo( VkBufferViewCreateInfo *out, VkBufferViewCreateInfo_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in || !out) return; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->flags = in->flags; ++ out->buffer = in->buffer; ++ out->format = in->format; ++ out->offset = in->offset; ++ out->range = in->range; ++} ++ ++VkBufferViewCreateInfo_host *convert_VkBufferViewCreateInfo_array( ++ const VkBufferViewCreateInfo *in, int count ) ++{ ++ VkBufferViewCreateInfo_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkBufferViewCreateInfo( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkBufferViewCreateInfo_array( VkBufferViewCreateInfo *out, ++ VkBufferViewCreateInfo_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkBufferViewCreateInfo( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkPipelineShaderStageCreateInfo_host *convert_VkPipelineShaderStageCreateInfo( ++ VkPipelineShaderStageCreateInfo_host *out, const VkPipelineShaderStageCreateInfo *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->flags = in->flags; ++ out->stage = in->stage; ++ out->module = in->module; ++ out->pName = in->pName; ++ out->pSpecializationInfo = in->pSpecializationInfo; ++ ++ return out; ++} ++void release_VkPipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo *out, ++ VkPipelineShaderStageCreateInfo_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in || !out) return; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->flags = in->flags; ++ out->stage = in->stage; ++ out->module = in->module; ++ out->pName = in->pName; ++ out->pSpecializationInfo = in->pSpecializationInfo; ++} ++ ++VkPipelineShaderStageCreateInfo_host *convert_VkPipelineShaderStageCreateInfo_array( ++ const VkPipelineShaderStageCreateInfo *in, int count ) ++{ ++ VkPipelineShaderStageCreateInfo_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkPipelineShaderStageCreateInfo( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkPipelineShaderStageCreateInfo_array( VkPipelineShaderStageCreateInfo *out, ++ VkPipelineShaderStageCreateInfo_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkPipelineShaderStageCreateInfo( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkComputePipelineCreateInfo_host *convert_VkComputePipelineCreateInfo( ++ VkComputePipelineCreateInfo_host *out, const VkComputePipelineCreateInfo *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->flags = in->flags; ++ convert_VkPipelineShaderStageCreateInfo( &out->stage, &in->stage ); ++ out->layout = in->layout; ++ out->basePipelineHandle = in->basePipelineHandle; ++ out->basePipelineIndex = in->basePipelineIndex; ++ ++ return out; ++} ++void release_VkComputePipelineCreateInfo( VkComputePipelineCreateInfo *out, ++ VkComputePipelineCreateInfo_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return; ++ ++ release_VkPipelineShaderStageCreateInfo( out ? &out->stage : NULL, &in->stage ); ++ ++ if (!out) return; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->flags = in->flags; ++ out->layout = in->layout; ++ out->basePipelineHandle = in->basePipelineHandle; ++ out->basePipelineIndex = in->basePipelineIndex; ++} ++ ++VkComputePipelineCreateInfo_host *convert_VkComputePipelineCreateInfo_array( ++ const VkComputePipelineCreateInfo *in, int count ) ++{ ++ VkComputePipelineCreateInfo_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkComputePipelineCreateInfo( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkComputePipelineCreateInfo_array( VkComputePipelineCreateInfo *out, ++ VkComputePipelineCreateInfo_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkComputePipelineCreateInfo( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(__i386__) ++#include ++struct PFN_vkDebugReportCallbackEXT_opcodes ++{ ++ BYTE pushl_ebp[1]; /* pushl %ebp */ ++ BYTE movl_esp_ebp[2]; /* movl %esp,%ebp */ ++ BYTE subl_0x04_esp[3]; /* subl $4,%esp */ ++ BYTE pushl_0x28_ebp[3]; /* pushl 40(%ebp) */ ++ BYTE pushl_0x24_ebp[3]; /* pushl 36(%ebp) */ ++ BYTE pushl_0x20_ebp[3]; /* pushl 32(%ebp) */ ++ BYTE pushl_0x1c_ebp[3]; /* pushl 28(%ebp) */ ++ BYTE pushl_0x18_ebp[3]; /* pushl 24(%ebp) */ ++ BYTE pushl_0x14_ebp[3]; /* pushl 20(%ebp) */ ++ BYTE pushl_0x10_ebp[3]; /* pushl 16(%ebp) */ ++ BYTE pushl_0x0c_ebp[3]; /* pushl 12(%ebp) */ ++ BYTE pushl_0x08_ebp[3]; /* pushl 8(%ebp) */ ++ BYTE movl_func_eax[1]; /* movl function,%eax */ ++ void *function; ++ BYTE call_eax[2]; /* call *%eax */ ++ BYTE leave[1]; /* leave */ ++ BYTE ret[1]; /* ret */ ++}; ++#include ++ ++static const struct PFN_vkDebugReportCallbackEXT_opcodes PFN_vkDebugReportCallbackEXT_code = ++{ ++ { 0x55 }, /* pushl %ebp */ ++ { 0x89, 0xe5 }, /* movl %esp,%ebp */ ++ { 0x83, 0xec, 0x04 }, /* subl $4,%esp */ ++ { 0xff, 0x75, 0x28 }, /* pushl 40(%ebp) */ ++ { 0xff, 0x75, 0x24 }, /* pushl 36(%ebp) */ ++ { 0xff, 0x75, 0x20 }, /* pushl 32(%ebp) */ ++ { 0xff, 0x75, 0x1c }, /* pushl 28(%ebp) */ ++ { 0xff, 0x75, 0x18 }, /* pushl 24(%ebp) */ ++ { 0xff, 0x75, 0x14 }, /* pushl 20(%ebp) */ ++ { 0xff, 0x75, 0x10 }, /* pushl 16(%ebp) */ ++ { 0xff, 0x75, 0x0c }, /* pushl 12(%ebp) */ ++ { 0xff, 0x75, 0x08 }, /* pushl 8(%ebp) */ ++ { 0xb8 }, /* movl function,%eax */ ++ NULL, ++ { 0xff, 0xd0 }, /* call *%eax */ ++ { 0xc9 }, /* leave */ ++ { 0xc3 }, /* ret */ ++}; ++#elif defined(__x86_64__) ++#include ++struct PFN_vkDebugReportCallbackEXT_opcodes ++{ ++ BYTE pushq_rbp[1]; /* pushq %rbp */ ++ BYTE movq_rsp_rbp[3]; /* movq %rsp,%rbp */ ++ BYTE pushq_0x18_rbp[3]; /* pushq 24(%rbp) */ ++ BYTE pushq_0x10_rbp[3]; /* pushq 16(%rbp) */ ++ BYTE pushq_r9[2]; /* pushq %r9 */ ++ BYTE pushq_r8[2]; /* pushq %r8 */ ++ BYTE subq_0x20_rsp[4]; /* subq $0x20,%rsp */ ++ BYTE movq_rcx_r9[3]; /* movq %rcx,%r9 */ ++ BYTE movq_rdx_r8[3]; /* movq %rdx,%r8 */ ++ BYTE movq_rsi_rdx[3]; /* movq %rsi,%rdx */ ++ BYTE movq_rsi_rcx[3]; /* movq %rdi,%rcx */ ++ BYTE movq_func_rax[2]; /* movq function,%rax */ ++ void *function; ++ BYTE call_rax[2]; /* call *%rax */ ++ BYTE movq_rbp_rsp[3]; /* movq %rbp,%rsp */ ++ BYTE popq_rbp[1]; /* popq %rbp */ ++ BYTE ret[1]; /* ret */ ++}; ++#include ++ ++static const struct PFN_vkDebugReportCallbackEXT_opcodes PFN_vkDebugReportCallbackEXT_code = ++{ ++ { 0x55 }, /* pushq %rbp */ ++ { 0x48, 0x89, 0xe5 }, /* movq %rsp,%rbp */ ++ { 0xff, 0x75, 0x18 }, /* pushq 24(%rbp) */ ++ { 0xff, 0x75, 0x10 }, /* pushq 16(%rbp) */ ++ { 0x41, 0x51 }, /* pushq %r9 */ ++ { 0x41, 0x50 }, /* pushq %r8 */ ++ { 0x48, 0x83, 0xec, 0x20 }, /* subq $0x20,%rsp */ ++ { 0x49, 0x89, 0xc9 }, /* movq %rcx,%r9 */ ++ { 0x49, 0x89, 0xd0 }, /* movq %rdx,%r8 */ ++ { 0x48, 0x89, 0xf2 }, /* movq %rsi,%rdx */ ++ { 0x48, 0x89, 0xf9 }, /* movq %rdi,%rcx */ ++ { 0x48, 0xb8 }, /* movq function,%rax */ ++ NULL, ++ { 0xff, 0xd0 }, /* call *%eax */ ++ { 0x48, 0x89, 0xec }, /* movq %rbp,%rsp */ ++ { 0x5d }, /* popq %rbp */ ++ { 0xc3 }, /* ret */ ++}; ++#endif ++ ++#if defined(__i386__) || defined(__x86_64__) ++struct PFN_vkDebugReportCallbackEXT_function ++{ ++ struct list entry; ++ struct PFN_vkDebugReportCallbackEXT_opcodes code; ++}; ++#endif ++ ++void convert_PFN_vkDebugReportCallbackEXT( PFN_vkDebugReportCallbackEXT_host *out, ++ const PFN_vkDebugReportCallbackEXT *in ) ++{ ++#if defined(__i386__) || defined(__x86_64__) ++ static struct list function_list = LIST_INIT( function_list ); ++ struct PFN_vkDebugReportCallbackEXT_function *function; ++ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!*in) ++ { ++ *out = NULL; ++ return; ++ } ++ EnterCriticalSection( &function_section ); ++ ++ LIST_FOR_EACH_ENTRY( function, &function_list, struct PFN_vkDebugReportCallbackEXT_function, ++ entry ) ++ if (function->code.function == *in) break; ++ ++ if (&function->entry == &function_list) ++ { ++ function = HeapAlloc( function_heap, 0, sizeof(*function) ); ++ list_add_tail( &function_list, &function->entry ); ++ function->code = PFN_vkDebugReportCallbackEXT_code; ++ function->code.function = *in; ++ } ++ *out = (void *)&function->code; ++ ++ LeaveCriticalSection( &function_section ); ++#else ++ *out = *in; ++#endif ++} ++void release_PFN_vkDebugReportCallbackEXT( PFN_vkDebugReportCallbackEXT *out, ++ PFN_vkDebugReportCallbackEXT_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++} ++ ++VkDebugReportCallbackCreateInfoEXT_host *convert_VkDebugReportCallbackCreateInfoEXT( ++ VkDebugReportCallbackCreateInfoEXT_host *out, const VkDebugReportCallbackCreateInfoEXT *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->flags = in->flags; ++ convert_PFN_vkDebugReportCallbackEXT( &out->pfnCallback, &in->pfnCallback ); ++ out->pUserData = in->pUserData; ++ ++ return out; ++} ++void release_VkDebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT *out, ++ VkDebugReportCallbackCreateInfoEXT_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return; ++ ++ release_PFN_vkDebugReportCallbackEXT( out ? &out->pfnCallback : NULL, &in->pfnCallback ); ++ ++ if (!out) return; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->flags = in->flags; ++ out->pUserData = in->pUserData; ++} ++ ++VkDebugReportCallbackCreateInfoEXT_host *convert_VkDebugReportCallbackCreateInfoEXT_array( ++ const VkDebugReportCallbackCreateInfoEXT *in, int count ) ++{ ++ VkDebugReportCallbackCreateInfoEXT_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkDebugReportCallbackCreateInfoEXT( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkDebugReportCallbackCreateInfoEXT_array( VkDebugReportCallbackCreateInfoEXT *out, ++ VkDebugReportCallbackCreateInfoEXT_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkDebugReportCallbackCreateInfoEXT( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkDisplaySurfaceCreateInfoKHR_host *convert_VkDisplaySurfaceCreateInfoKHR( ++ VkDisplaySurfaceCreateInfoKHR_host *out, const VkDisplaySurfaceCreateInfoKHR *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->flags = in->flags; ++ out->displayMode = in->displayMode; ++ out->planeIndex = in->planeIndex; ++ out->planeStackIndex = in->planeStackIndex; ++ out->transform = in->transform; ++ out->globalAlpha = in->globalAlpha; ++ out->alphaMode = in->alphaMode; ++ out->imageExtent = in->imageExtent; ++ ++ return out; ++} ++void release_VkDisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR *out, ++ VkDisplaySurfaceCreateInfoKHR_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in || !out) return; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->flags = in->flags; ++ out->displayMode = in->displayMode; ++ out->planeIndex = in->planeIndex; ++ out->planeStackIndex = in->planeStackIndex; ++ out->transform = in->transform; ++ out->globalAlpha = in->globalAlpha; ++ out->alphaMode = in->alphaMode; ++ out->imageExtent = in->imageExtent; ++} ++ ++VkDisplaySurfaceCreateInfoKHR_host *convert_VkDisplaySurfaceCreateInfoKHR_array( ++ const VkDisplaySurfaceCreateInfoKHR *in, int count ) ++{ ++ VkDisplaySurfaceCreateInfoKHR_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkDisplaySurfaceCreateInfoKHR( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkDisplaySurfaceCreateInfoKHR_array( VkDisplaySurfaceCreateInfoKHR *out, ++ VkDisplaySurfaceCreateInfoKHR_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkDisplaySurfaceCreateInfoKHR( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkFramebufferCreateInfo_host *convert_VkFramebufferCreateInfo( VkFramebufferCreateInfo_host *out, ++ const VkFramebufferCreateInfo *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->flags = in->flags; ++ out->renderPass = in->renderPass; ++ out->attachmentCount = in->attachmentCount; ++ out->pAttachments = in->pAttachments; /* length is attachmentCount */ ++ out->width = in->width; ++ out->height = in->height; ++ out->layers = in->layers; ++ ++ return out; ++} ++void release_VkFramebufferCreateInfo( VkFramebufferCreateInfo *out, ++ VkFramebufferCreateInfo_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in || !out) return; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->flags = in->flags; ++ out->renderPass = in->renderPass; ++ out->attachmentCount = in->attachmentCount; ++ out->pAttachments = in->pAttachments; /* length is attachmentCount */ ++ out->width = in->width; ++ out->height = in->height; ++ out->layers = in->layers; ++} ++ ++VkFramebufferCreateInfo_host *convert_VkFramebufferCreateInfo_array( ++ const VkFramebufferCreateInfo *in, int count ) ++{ ++ VkFramebufferCreateInfo_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkFramebufferCreateInfo( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkFramebufferCreateInfo_array( VkFramebufferCreateInfo *out, ++ VkFramebufferCreateInfo_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkFramebufferCreateInfo( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkGraphicsPipelineCreateInfo_host *convert_VkGraphicsPipelineCreateInfo( ++ VkGraphicsPipelineCreateInfo_host *out, const VkGraphicsPipelineCreateInfo *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->flags = in->flags; ++ out->stageCount = in->stageCount; ++ out->pStages = convert_VkPipelineShaderStageCreateInfo_array( in->pStages, in->stageCount ); ++ out->pVertexInputState = in->pVertexInputState; ++ out->pInputAssemblyState = in->pInputAssemblyState; ++ out->pTessellationState = in->pTessellationState; ++ out->pViewportState = in->pViewportState; ++ out->pRasterizationState = in->pRasterizationState; ++ out->pMultisampleState = in->pMultisampleState; ++ out->pDepthStencilState = in->pDepthStencilState; ++ out->pColorBlendState = in->pColorBlendState; ++ out->pDynamicState = in->pDynamicState; ++ out->layout = in->layout; ++ out->renderPass = in->renderPass; ++ out->subpass = in->subpass; ++ out->basePipelineHandle = in->basePipelineHandle; ++ out->basePipelineIndex = in->basePipelineIndex; ++ ++ return out; ++} ++void release_VkGraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo *out, ++ VkGraphicsPipelineCreateInfo_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return; ++ ++ release_VkPipelineShaderStageCreateInfo_array( out ? out->pStages : NULL, in->pStages, in->stageCount ); ++ ++ if (!out) return; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->flags = in->flags; ++ out->stageCount = in->stageCount; ++ out->pVertexInputState = in->pVertexInputState; ++ out->pInputAssemblyState = in->pInputAssemblyState; ++ out->pTessellationState = in->pTessellationState; ++ out->pViewportState = in->pViewportState; ++ out->pRasterizationState = in->pRasterizationState; ++ out->pMultisampleState = in->pMultisampleState; ++ out->pDepthStencilState = in->pDepthStencilState; ++ out->pColorBlendState = in->pColorBlendState; ++ out->pDynamicState = in->pDynamicState; ++ out->layout = in->layout; ++ out->renderPass = in->renderPass; ++ out->subpass = in->subpass; ++ out->basePipelineHandle = in->basePipelineHandle; ++ out->basePipelineIndex = in->basePipelineIndex; ++} ++ ++VkGraphicsPipelineCreateInfo_host *convert_VkGraphicsPipelineCreateInfo_array( ++ const VkGraphicsPipelineCreateInfo *in, int count ) ++{ ++ VkGraphicsPipelineCreateInfo_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkGraphicsPipelineCreateInfo( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkGraphicsPipelineCreateInfo_array( VkGraphicsPipelineCreateInfo *out, ++ VkGraphicsPipelineCreateInfo_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkGraphicsPipelineCreateInfo( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkImageViewCreateInfo_host *convert_VkImageViewCreateInfo( VkImageViewCreateInfo_host *out, ++ const VkImageViewCreateInfo *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->flags = in->flags; ++ out->image = in->image; ++ out->viewType = in->viewType; ++ out->format = in->format; ++ out->components = in->components; ++ out->subresourceRange = in->subresourceRange; ++ ++ return out; ++} ++void release_VkImageViewCreateInfo( VkImageViewCreateInfo *out, VkImageViewCreateInfo_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in || !out) return; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->flags = in->flags; ++ out->image = in->image; ++ out->viewType = in->viewType; ++ out->format = in->format; ++ out->components = in->components; ++ out->subresourceRange = in->subresourceRange; ++} ++ ++VkImageViewCreateInfo_host *convert_VkImageViewCreateInfo_array( const VkImageViewCreateInfo *in, ++ int count ) ++{ ++ VkImageViewCreateInfo_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkImageViewCreateInfo( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkImageViewCreateInfo_array( VkImageViewCreateInfo *out, ++ VkImageViewCreateInfo_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkImageViewCreateInfo( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkSwapchainCreateInfoKHR_host *convert_VkSwapchainCreateInfoKHR( ++ VkSwapchainCreateInfoKHR_host *out, const VkSwapchainCreateInfoKHR *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->flags = in->flags; ++ out->surface = in->surface; ++ out->minImageCount = in->minImageCount; ++ out->imageFormat = in->imageFormat; ++ out->imageColorSpace = in->imageColorSpace; ++ out->imageExtent = in->imageExtent; ++ out->imageArrayLayers = in->imageArrayLayers; ++ out->imageUsage = in->imageUsage; ++ out->imageSharingMode = in->imageSharingMode; ++ out->queueFamilyIndexCount = in->queueFamilyIndexCount; ++ out->pQueueFamilyIndices = in->pQueueFamilyIndices; /* length is queueFamilyIndexCount */ ++ out->preTransform = in->preTransform; ++ out->compositeAlpha = in->compositeAlpha; ++ out->presentMode = in->presentMode; ++ out->clipped = in->clipped; ++ out->oldSwapchain = in->oldSwapchain; ++ ++ return out; ++} ++void release_VkSwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR *out, ++ VkSwapchainCreateInfoKHR_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in || !out) return; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->flags = in->flags; ++ out->surface = in->surface; ++ out->minImageCount = in->minImageCount; ++ out->imageFormat = in->imageFormat; ++ out->imageColorSpace = in->imageColorSpace; ++ out->imageExtent = in->imageExtent; ++ out->imageArrayLayers = in->imageArrayLayers; ++ out->imageUsage = in->imageUsage; ++ out->imageSharingMode = in->imageSharingMode; ++ out->queueFamilyIndexCount = in->queueFamilyIndexCount; ++ out->pQueueFamilyIndices = in->pQueueFamilyIndices; /* length is queueFamilyIndexCount */ ++ out->preTransform = in->preTransform; ++ out->compositeAlpha = in->compositeAlpha; ++ out->presentMode = in->presentMode; ++ out->clipped = in->clipped; ++ out->oldSwapchain = in->oldSwapchain; ++} ++ ++VkSwapchainCreateInfoKHR_host *convert_VkSwapchainCreateInfoKHR_array( ++ const VkSwapchainCreateInfoKHR *in, int count ) ++{ ++ VkSwapchainCreateInfoKHR_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkSwapchainCreateInfoKHR( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkSwapchainCreateInfoKHR_array( VkSwapchainCreateInfoKHR *out, ++ VkSwapchainCreateInfoKHR_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkSwapchainCreateInfoKHR( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkDisplayModePropertiesKHR_host *convert_VkDisplayModePropertiesKHR( ++ VkDisplayModePropertiesKHR_host *out, const VkDisplayModePropertiesKHR *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->displayMode = in->displayMode; ++ out->parameters = in->parameters; ++ ++ return out; ++} ++void release_VkDisplayModePropertiesKHR( VkDisplayModePropertiesKHR *out, ++ VkDisplayModePropertiesKHR_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in || !out) return; ++ ++ out->displayMode = in->displayMode; ++ out->parameters = in->parameters; ++} ++ ++VkDisplayModePropertiesKHR_host *convert_VkDisplayModePropertiesKHR_array( ++ const VkDisplayModePropertiesKHR *in, int count ) ++{ ++ VkDisplayModePropertiesKHR_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkDisplayModePropertiesKHR( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkDisplayModePropertiesKHR_array( VkDisplayModePropertiesKHR *out, ++ VkDisplayModePropertiesKHR_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkDisplayModePropertiesKHR( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkDisplayPlanePropertiesKHR_host *convert_VkDisplayPlanePropertiesKHR( ++ VkDisplayPlanePropertiesKHR_host *out, const VkDisplayPlanePropertiesKHR *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->currentDisplay = in->currentDisplay; ++ out->currentStackIndex = in->currentStackIndex; ++ ++ return out; ++} ++void release_VkDisplayPlanePropertiesKHR( VkDisplayPlanePropertiesKHR *out, ++ VkDisplayPlanePropertiesKHR_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in || !out) return; ++ ++ out->currentDisplay = in->currentDisplay; ++ out->currentStackIndex = in->currentStackIndex; ++} ++ ++VkDisplayPlanePropertiesKHR_host *convert_VkDisplayPlanePropertiesKHR_array( ++ const VkDisplayPlanePropertiesKHR *in, int count ) ++{ ++ VkDisplayPlanePropertiesKHR_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkDisplayPlanePropertiesKHR( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkDisplayPlanePropertiesKHR_array( VkDisplayPlanePropertiesKHR *out, ++ VkDisplayPlanePropertiesKHR_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkDisplayPlanePropertiesKHR( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkMemoryHeap_host *convert_VkMemoryHeap( VkMemoryHeap_host *out, const VkMemoryHeap *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ /* return-only type, skipping conversion */ ++ return in ? out : NULL; ++} ++void release_VkMemoryHeap( VkMemoryHeap *out, VkMemoryHeap_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in || !out) return; ++ ++ out->size = in->size; ++ out->flags = in->flags; ++} ++ ++VkMemoryHeap_host *convert_VkMemoryHeap_array( const VkMemoryHeap *in, int count ) ++{ ++ VkMemoryHeap_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkMemoryHeap( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkMemoryHeap_array( VkMemoryHeap *out, VkMemoryHeap_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkMemoryHeap( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkPhysicalDeviceMemoryProperties_host *convert_VkPhysicalDeviceMemoryProperties( ++ VkPhysicalDeviceMemoryProperties_host *out, const VkPhysicalDeviceMemoryProperties *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ /* return-only type, skipping conversion */ ++ return in ? out : NULL; ++} ++void release_VkPhysicalDeviceMemoryProperties( VkPhysicalDeviceMemoryProperties *out, ++ VkPhysicalDeviceMemoryProperties_host *in ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < ARRAY_SIZE(in->memoryHeaps); i++) ++ release_VkMemoryHeap( out ? &out->memoryHeaps[i] : NULL, &in->memoryHeaps[i] ); ++ ++ if (!out) return; ++ ++ out->memoryTypeCount = in->memoryTypeCount; ++ memcpy(out->memoryTypes, in->memoryTypes, sizeof(in->memoryTypes)); ++ out->memoryHeapCount = in->memoryHeapCount; ++} ++ ++VkPhysicalDeviceMemoryProperties_host *convert_VkPhysicalDeviceMemoryProperties_array( ++ const VkPhysicalDeviceMemoryProperties *in, int count ) ++{ ++ VkPhysicalDeviceMemoryProperties_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkPhysicalDeviceMemoryProperties( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkPhysicalDeviceMemoryProperties_array( VkPhysicalDeviceMemoryProperties *out, ++ VkPhysicalDeviceMemoryProperties_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkPhysicalDeviceMemoryProperties( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkPhysicalDeviceLimits_host *convert_VkPhysicalDeviceLimits( VkPhysicalDeviceLimits_host *out, ++ const VkPhysicalDeviceLimits *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ /* return-only type, skipping conversion */ ++ return in ? out : NULL; ++} ++void release_VkPhysicalDeviceLimits( VkPhysicalDeviceLimits *out, VkPhysicalDeviceLimits_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in || !out) return; ++ ++ out->maxImageDimension1D = in->maxImageDimension1D; ++ out->maxImageDimension2D = in->maxImageDimension2D; ++ out->maxImageDimension3D = in->maxImageDimension3D; ++ out->maxImageDimensionCube = in->maxImageDimensionCube; ++ out->maxImageArrayLayers = in->maxImageArrayLayers; ++ out->maxTexelBufferElements = in->maxTexelBufferElements; ++ out->maxUniformBufferRange = in->maxUniformBufferRange; ++ out->maxStorageBufferRange = in->maxStorageBufferRange; ++ out->maxPushConstantsSize = in->maxPushConstantsSize; ++ out->maxMemoryAllocationCount = in->maxMemoryAllocationCount; ++ out->maxSamplerAllocationCount = in->maxSamplerAllocationCount; ++ out->bufferImageGranularity = in->bufferImageGranularity; ++ out->sparseAddressSpaceSize = in->sparseAddressSpaceSize; ++ out->maxBoundDescriptorSets = in->maxBoundDescriptorSets; ++ out->maxPerStageDescriptorSamplers = in->maxPerStageDescriptorSamplers; ++ out->maxPerStageDescriptorUniformBuffers = in->maxPerStageDescriptorUniformBuffers; ++ out->maxPerStageDescriptorStorageBuffers = in->maxPerStageDescriptorStorageBuffers; ++ out->maxPerStageDescriptorSampledImages = in->maxPerStageDescriptorSampledImages; ++ out->maxPerStageDescriptorStorageImages = in->maxPerStageDescriptorStorageImages; ++ out->maxPerStageDescriptorInputAttachments = in->maxPerStageDescriptorInputAttachments; ++ out->maxPerStageResources = in->maxPerStageResources; ++ out->maxDescriptorSetSamplers = in->maxDescriptorSetSamplers; ++ out->maxDescriptorSetUniformBuffers = in->maxDescriptorSetUniformBuffers; ++ out->maxDescriptorSetUniformBuffersDynamic = in->maxDescriptorSetUniformBuffersDynamic; ++ out->maxDescriptorSetStorageBuffers = in->maxDescriptorSetStorageBuffers; ++ out->maxDescriptorSetStorageBuffersDynamic = in->maxDescriptorSetStorageBuffersDynamic; ++ out->maxDescriptorSetSampledImages = in->maxDescriptorSetSampledImages; ++ out->maxDescriptorSetStorageImages = in->maxDescriptorSetStorageImages; ++ out->maxDescriptorSetInputAttachments = in->maxDescriptorSetInputAttachments; ++ out->maxVertexInputAttributes = in->maxVertexInputAttributes; ++ out->maxVertexInputBindings = in->maxVertexInputBindings; ++ out->maxVertexInputAttributeOffset = in->maxVertexInputAttributeOffset; ++ out->maxVertexInputBindingStride = in->maxVertexInputBindingStride; ++ out->maxVertexOutputComponents = in->maxVertexOutputComponents; ++ out->maxTessellationGenerationLevel = in->maxTessellationGenerationLevel; ++ out->maxTessellationPatchSize = in->maxTessellationPatchSize; ++ out->maxTessellationControlPerVertexInputComponents = in->maxTessellationControlPerVertexInputComponents; ++ out->maxTessellationControlPerVertexOutputComponents = in->maxTessellationControlPerVertexOutputComponents; ++ out->maxTessellationControlPerPatchOutputComponents = in->maxTessellationControlPerPatchOutputComponents; ++ out->maxTessellationControlTotalOutputComponents = in->maxTessellationControlTotalOutputComponents; ++ out->maxTessellationEvaluationInputComponents = in->maxTessellationEvaluationInputComponents; ++ out->maxTessellationEvaluationOutputComponents = in->maxTessellationEvaluationOutputComponents; ++ out->maxGeometryShaderInvocations = in->maxGeometryShaderInvocations; ++ out->maxGeometryInputComponents = in->maxGeometryInputComponents; ++ out->maxGeometryOutputComponents = in->maxGeometryOutputComponents; ++ out->maxGeometryOutputVertices = in->maxGeometryOutputVertices; ++ out->maxGeometryTotalOutputComponents = in->maxGeometryTotalOutputComponents; ++ out->maxFragmentInputComponents = in->maxFragmentInputComponents; ++ out->maxFragmentOutputAttachments = in->maxFragmentOutputAttachments; ++ out->maxFragmentDualSrcAttachments = in->maxFragmentDualSrcAttachments; ++ out->maxFragmentCombinedOutputResources = in->maxFragmentCombinedOutputResources; ++ out->maxComputeSharedMemorySize = in->maxComputeSharedMemorySize; ++ memcpy(out->maxComputeWorkGroupCount, in->maxComputeWorkGroupCount, sizeof(in->maxComputeWorkGroupCount)); ++ out->maxComputeWorkGroupInvocations = in->maxComputeWorkGroupInvocations; ++ memcpy(out->maxComputeWorkGroupSize, in->maxComputeWorkGroupSize, sizeof(in->maxComputeWorkGroupSize)); ++ out->subPixelPrecisionBits = in->subPixelPrecisionBits; ++ out->subTexelPrecisionBits = in->subTexelPrecisionBits; ++ out->mipmapPrecisionBits = in->mipmapPrecisionBits; ++ out->maxDrawIndexedIndexValue = in->maxDrawIndexedIndexValue; ++ out->maxDrawIndirectCount = in->maxDrawIndirectCount; ++ out->maxSamplerLodBias = in->maxSamplerLodBias; ++ out->maxSamplerAnisotropy = in->maxSamplerAnisotropy; ++ out->maxViewports = in->maxViewports; ++ memcpy(out->maxViewportDimensions, in->maxViewportDimensions, sizeof(in->maxViewportDimensions)); ++ memcpy(out->viewportBoundsRange, in->viewportBoundsRange, sizeof(in->viewportBoundsRange)); ++ out->viewportSubPixelBits = in->viewportSubPixelBits; ++ out->minMemoryMapAlignment = in->minMemoryMapAlignment; ++ out->minTexelBufferOffsetAlignment = in->minTexelBufferOffsetAlignment; ++ out->minUniformBufferOffsetAlignment = in->minUniformBufferOffsetAlignment; ++ out->minStorageBufferOffsetAlignment = in->minStorageBufferOffsetAlignment; ++ out->minTexelOffset = in->minTexelOffset; ++ out->maxTexelOffset = in->maxTexelOffset; ++ out->minTexelGatherOffset = in->minTexelGatherOffset; ++ out->maxTexelGatherOffset = in->maxTexelGatherOffset; ++ out->minInterpolationOffset = in->minInterpolationOffset; ++ out->maxInterpolationOffset = in->maxInterpolationOffset; ++ out->subPixelInterpolationOffsetBits = in->subPixelInterpolationOffsetBits; ++ out->maxFramebufferWidth = in->maxFramebufferWidth; ++ out->maxFramebufferHeight = in->maxFramebufferHeight; ++ out->maxFramebufferLayers = in->maxFramebufferLayers; ++ out->framebufferColorSampleCounts = in->framebufferColorSampleCounts; ++ out->framebufferDepthSampleCounts = in->framebufferDepthSampleCounts; ++ out->framebufferStencilSampleCounts = in->framebufferStencilSampleCounts; ++ out->framebufferNoAttachmentsSampleCounts = in->framebufferNoAttachmentsSampleCounts; ++ out->maxColorAttachments = in->maxColorAttachments; ++ out->sampledImageColorSampleCounts = in->sampledImageColorSampleCounts; ++ out->sampledImageIntegerSampleCounts = in->sampledImageIntegerSampleCounts; ++ out->sampledImageDepthSampleCounts = in->sampledImageDepthSampleCounts; ++ out->sampledImageStencilSampleCounts = in->sampledImageStencilSampleCounts; ++ out->storageImageSampleCounts = in->storageImageSampleCounts; ++ out->maxSampleMaskWords = in->maxSampleMaskWords; ++ out->timestampComputeAndGraphics = in->timestampComputeAndGraphics; ++ out->timestampPeriod = in->timestampPeriod; ++ out->maxClipDistances = in->maxClipDistances; ++ out->maxCullDistances = in->maxCullDistances; ++ out->maxCombinedClipAndCullDistances = in->maxCombinedClipAndCullDistances; ++ out->discreteQueuePriorities = in->discreteQueuePriorities; ++ memcpy(out->pointSizeRange, in->pointSizeRange, sizeof(in->pointSizeRange)); ++ memcpy(out->lineWidthRange, in->lineWidthRange, sizeof(in->lineWidthRange)); ++ out->pointSizeGranularity = in->pointSizeGranularity; ++ out->lineWidthGranularity = in->lineWidthGranularity; ++ out->strictLines = in->strictLines; ++ out->standardSampleLocations = in->standardSampleLocations; ++ out->optimalBufferCopyOffsetAlignment = in->optimalBufferCopyOffsetAlignment; ++ out->optimalBufferCopyRowPitchAlignment = in->optimalBufferCopyRowPitchAlignment; ++ out->nonCoherentAtomSize = in->nonCoherentAtomSize; ++} ++ ++VkPhysicalDeviceLimits_host *convert_VkPhysicalDeviceLimits_array( ++ const VkPhysicalDeviceLimits *in, int count ) ++{ ++ VkPhysicalDeviceLimits_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkPhysicalDeviceLimits( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkPhysicalDeviceLimits_array( VkPhysicalDeviceLimits *out, ++ VkPhysicalDeviceLimits_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkPhysicalDeviceLimits( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkPhysicalDeviceProperties_host *convert_VkPhysicalDeviceProperties( ++ VkPhysicalDeviceProperties_host *out, const VkPhysicalDeviceProperties *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ /* return-only type, skipping conversion */ ++ return in ? out : NULL; ++} ++void release_VkPhysicalDeviceProperties( VkPhysicalDeviceProperties *out, ++ VkPhysicalDeviceProperties_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return; ++ ++ release_VkPhysicalDeviceLimits( out ? &out->limits : NULL, &in->limits ); ++ ++ if (!out) return; ++ ++ out->apiVersion = in->apiVersion; ++ out->driverVersion = in->driverVersion; ++ out->vendorID = in->vendorID; ++ out->deviceID = in->deviceID; ++ out->deviceType = in->deviceType; ++ memcpy(out->deviceName, in->deviceName, sizeof(in->deviceName)); ++ memcpy(out->pipelineCacheUUID, in->pipelineCacheUUID, sizeof(in->pipelineCacheUUID)); ++ out->sparseProperties = in->sparseProperties; ++} ++ ++VkPhysicalDeviceProperties_host *convert_VkPhysicalDeviceProperties_array( ++ const VkPhysicalDeviceProperties *in, int count ) ++{ ++ VkPhysicalDeviceProperties_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkPhysicalDeviceProperties( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkPhysicalDeviceProperties_array( VkPhysicalDeviceProperties *out, ++ VkPhysicalDeviceProperties_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkPhysicalDeviceProperties( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkSparseMemoryBind_host *convert_VkSparseMemoryBind( VkSparseMemoryBind_host *out, ++ const VkSparseMemoryBind *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->resourceOffset = in->resourceOffset; ++ out->size = in->size; ++ out->memory = in->memory; ++ out->memoryOffset = in->memoryOffset; ++ out->flags = in->flags; ++ ++ return out; ++} ++void release_VkSparseMemoryBind( VkSparseMemoryBind *out, VkSparseMemoryBind_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in || !out) return; ++ ++ out->resourceOffset = in->resourceOffset; ++ out->size = in->size; ++ out->memory = in->memory; ++ out->memoryOffset = in->memoryOffset; ++ out->flags = in->flags; ++} ++ ++VkSparseMemoryBind_host *convert_VkSparseMemoryBind_array( const VkSparseMemoryBind *in, int count ) ++{ ++ VkSparseMemoryBind_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkSparseMemoryBind( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkSparseMemoryBind_array( VkSparseMemoryBind *out, VkSparseMemoryBind_host *in, ++ int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkSparseMemoryBind( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkSparseBufferMemoryBindInfo_host *convert_VkSparseBufferMemoryBindInfo( ++ VkSparseBufferMemoryBindInfo_host *out, const VkSparseBufferMemoryBindInfo *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->buffer = in->buffer; ++ out->bindCount = in->bindCount; ++ out->pBinds = convert_VkSparseMemoryBind_array( in->pBinds, in->bindCount ); ++ ++ return out; ++} ++void release_VkSparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo *out, ++ VkSparseBufferMemoryBindInfo_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return; ++ ++ release_VkSparseMemoryBind_array( out ? out->pBinds : NULL, in->pBinds, in->bindCount ); ++ ++ if (!out) return; ++ ++ out->buffer = in->buffer; ++ out->bindCount = in->bindCount; ++} ++ ++VkSparseBufferMemoryBindInfo_host *convert_VkSparseBufferMemoryBindInfo_array( ++ const VkSparseBufferMemoryBindInfo *in, int count ) ++{ ++ VkSparseBufferMemoryBindInfo_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkSparseBufferMemoryBindInfo( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkSparseBufferMemoryBindInfo_array( VkSparseBufferMemoryBindInfo *out, ++ VkSparseBufferMemoryBindInfo_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkSparseBufferMemoryBindInfo( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkSparseImageOpaqueMemoryBindInfo_host *convert_VkSparseImageOpaqueMemoryBindInfo( ++ VkSparseImageOpaqueMemoryBindInfo_host *out, const VkSparseImageOpaqueMemoryBindInfo *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->image = in->image; ++ out->bindCount = in->bindCount; ++ out->pBinds = convert_VkSparseMemoryBind_array( in->pBinds, in->bindCount ); ++ ++ return out; ++} ++void release_VkSparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo *out, ++ VkSparseImageOpaqueMemoryBindInfo_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return; ++ ++ release_VkSparseMemoryBind_array( out ? out->pBinds : NULL, in->pBinds, in->bindCount ); ++ ++ if (!out) return; ++ ++ out->image = in->image; ++ out->bindCount = in->bindCount; ++} ++ ++VkSparseImageOpaqueMemoryBindInfo_host *convert_VkSparseImageOpaqueMemoryBindInfo_array( ++ const VkSparseImageOpaqueMemoryBindInfo *in, int count ) ++{ ++ VkSparseImageOpaqueMemoryBindInfo_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkSparseImageOpaqueMemoryBindInfo( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkSparseImageOpaqueMemoryBindInfo_array( VkSparseImageOpaqueMemoryBindInfo *out, ++ VkSparseImageOpaqueMemoryBindInfo_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkSparseImageOpaqueMemoryBindInfo( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkSparseImageMemoryBind_host *convert_VkSparseImageMemoryBind( VkSparseImageMemoryBind_host *out, ++ const VkSparseImageMemoryBind *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->subresource = in->subresource; ++ out->offset = in->offset; ++ out->extent = in->extent; ++ out->memory = in->memory; ++ out->memoryOffset = in->memoryOffset; ++ out->flags = in->flags; ++ ++ return out; ++} ++void release_VkSparseImageMemoryBind( VkSparseImageMemoryBind *out, ++ VkSparseImageMemoryBind_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in || !out) return; ++ ++ out->subresource = in->subresource; ++ out->offset = in->offset; ++ out->extent = in->extent; ++ out->memory = in->memory; ++ out->memoryOffset = in->memoryOffset; ++ out->flags = in->flags; ++} ++ ++VkSparseImageMemoryBind_host *convert_VkSparseImageMemoryBind_array( ++ const VkSparseImageMemoryBind *in, int count ) ++{ ++ VkSparseImageMemoryBind_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkSparseImageMemoryBind( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkSparseImageMemoryBind_array( VkSparseImageMemoryBind *out, ++ VkSparseImageMemoryBind_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkSparseImageMemoryBind( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkSparseImageMemoryBindInfo_host *convert_VkSparseImageMemoryBindInfo( ++ VkSparseImageMemoryBindInfo_host *out, const VkSparseImageMemoryBindInfo *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->image = in->image; ++ out->bindCount = in->bindCount; ++ out->pBinds = convert_VkSparseImageMemoryBind_array( in->pBinds, in->bindCount ); ++ ++ return out; ++} ++void release_VkSparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo *out, ++ VkSparseImageMemoryBindInfo_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return; ++ ++ release_VkSparseImageMemoryBind_array( out ? out->pBinds : NULL, in->pBinds, in->bindCount ); ++ ++ if (!out) return; ++ ++ out->image = in->image; ++ out->bindCount = in->bindCount; ++} ++ ++VkSparseImageMemoryBindInfo_host *convert_VkSparseImageMemoryBindInfo_array( ++ const VkSparseImageMemoryBindInfo *in, int count ) ++{ ++ VkSparseImageMemoryBindInfo_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkSparseImageMemoryBindInfo( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkSparseImageMemoryBindInfo_array( VkSparseImageMemoryBindInfo *out, ++ VkSparseImageMemoryBindInfo_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkSparseImageMemoryBindInfo( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkBindSparseInfo_host *convert_VkBindSparseInfo( VkBindSparseInfo_host *out, ++ const VkBindSparseInfo *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->waitSemaphoreCount = in->waitSemaphoreCount; ++ out->pWaitSemaphores = in->pWaitSemaphores; /* length is waitSemaphoreCount */ ++ out->bufferBindCount = in->bufferBindCount; ++ out->pBufferBinds = convert_VkSparseBufferMemoryBindInfo_array( in->pBufferBinds, in->bufferBindCount ); ++ out->imageOpaqueBindCount = in->imageOpaqueBindCount; ++ out->pImageOpaqueBinds = convert_VkSparseImageOpaqueMemoryBindInfo_array( in->pImageOpaqueBinds, in->imageOpaqueBindCount ); ++ out->imageBindCount = in->imageBindCount; ++ out->pImageBinds = convert_VkSparseImageMemoryBindInfo_array( in->pImageBinds, in->imageBindCount ); ++ out->signalSemaphoreCount = in->signalSemaphoreCount; ++ out->pSignalSemaphores = in->pSignalSemaphores; /* length is signalSemaphoreCount */ ++ ++ return out; ++} ++void release_VkBindSparseInfo( VkBindSparseInfo *out, VkBindSparseInfo_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return; ++ ++ release_VkSparseBufferMemoryBindInfo_array( out ? out->pBufferBinds : NULL, in->pBufferBinds, in->bufferBindCount ); ++ release_VkSparseImageOpaqueMemoryBindInfo_array( out ? out->pImageOpaqueBinds : NULL, in->pImageOpaqueBinds, in->imageOpaqueBindCount ); ++ release_VkSparseImageMemoryBindInfo_array( out ? out->pImageBinds : NULL, in->pImageBinds, in->imageBindCount ); ++ ++ if (!out) return; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->waitSemaphoreCount = in->waitSemaphoreCount; ++ out->pWaitSemaphores = in->pWaitSemaphores; /* length is waitSemaphoreCount */ ++ out->bufferBindCount = in->bufferBindCount; ++ out->imageOpaqueBindCount = in->imageOpaqueBindCount; ++ out->imageBindCount = in->imageBindCount; ++ out->signalSemaphoreCount = in->signalSemaphoreCount; ++ out->pSignalSemaphores = in->pSignalSemaphores; /* length is signalSemaphoreCount */ ++} ++ ++VkBindSparseInfo_host *convert_VkBindSparseInfo_array( const VkBindSparseInfo *in, int count ) ++{ ++ VkBindSparseInfo_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkBindSparseInfo( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkBindSparseInfo_array( VkBindSparseInfo *out, VkBindSparseInfo_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkBindSparseInfo( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkDescriptorImageInfo_host *convert_VkDescriptorImageInfo( VkDescriptorImageInfo_host *out, ++ const VkDescriptorImageInfo *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->sampler = in->sampler; ++ out->imageView = in->imageView; ++ out->imageLayout = in->imageLayout; ++ ++ return out; ++} ++void release_VkDescriptorImageInfo( VkDescriptorImageInfo *out, VkDescriptorImageInfo_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in || !out) return; ++ ++ out->sampler = in->sampler; ++ out->imageView = in->imageView; ++ out->imageLayout = in->imageLayout; ++} ++ ++VkDescriptorImageInfo_host *convert_VkDescriptorImageInfo_array( const VkDescriptorImageInfo *in, ++ int count ) ++{ ++ VkDescriptorImageInfo_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkDescriptorImageInfo( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkDescriptorImageInfo_array( VkDescriptorImageInfo *out, ++ VkDescriptorImageInfo_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkDescriptorImageInfo( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkDescriptorBufferInfo_host *convert_VkDescriptorBufferInfo( VkDescriptorBufferInfo_host *out, ++ const VkDescriptorBufferInfo *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->buffer = in->buffer; ++ out->offset = in->offset; ++ out->range = in->range; ++ ++ return out; ++} ++void release_VkDescriptorBufferInfo( VkDescriptorBufferInfo *out, VkDescriptorBufferInfo_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in || !out) return; ++ ++ out->buffer = in->buffer; ++ out->offset = in->offset; ++ out->range = in->range; ++} ++ ++VkDescriptorBufferInfo_host *convert_VkDescriptorBufferInfo_array( ++ const VkDescriptorBufferInfo *in, int count ) ++{ ++ VkDescriptorBufferInfo_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkDescriptorBufferInfo( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkDescriptorBufferInfo_array( VkDescriptorBufferInfo *out, ++ VkDescriptorBufferInfo_host *in, int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkDescriptorBufferInfo( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkWriteDescriptorSet_host *convert_VkWriteDescriptorSet( VkWriteDescriptorSet_host *out, ++ const VkWriteDescriptorSet *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->dstSet = in->dstSet; ++ out->dstBinding = in->dstBinding; ++ out->dstArrayElement = in->dstArrayElement; ++ out->descriptorCount = in->descriptorCount; ++ out->descriptorType = in->descriptorType; ++ out->pImageInfo = convert_VkDescriptorImageInfo_array( in->pImageInfo, in->descriptorCount ); ++ out->pBufferInfo = convert_VkDescriptorBufferInfo_array( in->pBufferInfo, in->descriptorCount ); ++ out->pTexelBufferView = in->pTexelBufferView; /* length is descriptorCount */ ++ ++ return out; ++} ++void release_VkWriteDescriptorSet( VkWriteDescriptorSet *out, VkWriteDescriptorSet_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return; ++ ++ release_VkDescriptorImageInfo_array( out ? out->pImageInfo : NULL, in->pImageInfo, in->descriptorCount ); ++ release_VkDescriptorBufferInfo_array( out ? out->pBufferInfo : NULL, in->pBufferInfo, in->descriptorCount ); ++ ++ if (!out) return; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->dstSet = in->dstSet; ++ out->dstBinding = in->dstBinding; ++ out->dstArrayElement = in->dstArrayElement; ++ out->descriptorCount = in->descriptorCount; ++ out->descriptorType = in->descriptorType; ++ out->pTexelBufferView = in->pTexelBufferView; /* length is descriptorCount */ ++} ++ ++VkWriteDescriptorSet_host *convert_VkWriteDescriptorSet_array( const VkWriteDescriptorSet *in, ++ int count ) ++{ ++ VkWriteDescriptorSet_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkWriteDescriptorSet( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkWriteDescriptorSet_array( VkWriteDescriptorSet *out, VkWriteDescriptorSet_host *in, ++ int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkWriteDescriptorSet( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++#if defined(USE_STRUCT_CONVERSION) ++VkCopyDescriptorSet_host *convert_VkCopyDescriptorSet( VkCopyDescriptorSet_host *out, ++ const VkCopyDescriptorSet *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in) return NULL; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->srcSet = in->srcSet; ++ out->srcBinding = in->srcBinding; ++ out->srcArrayElement = in->srcArrayElement; ++ out->dstSet = in->dstSet; ++ out->dstBinding = in->dstBinding; ++ out->dstArrayElement = in->dstArrayElement; ++ out->descriptorCount = in->descriptorCount; ++ ++ return out; ++} ++void release_VkCopyDescriptorSet( VkCopyDescriptorSet *out, VkCopyDescriptorSet_host *in ) ++{ ++ TRACE( "(%p, %p)\n", out, in ); ++ ++ if (!in || !out) return; ++ ++ out->sType = in->sType; ++ out->pNext = in->pNext; ++ out->srcSet = in->srcSet; ++ out->srcBinding = in->srcBinding; ++ out->srcArrayElement = in->srcArrayElement; ++ out->dstSet = in->dstSet; ++ out->dstBinding = in->dstBinding; ++ out->dstArrayElement = in->dstArrayElement; ++ out->descriptorCount = in->descriptorCount; ++} ++ ++VkCopyDescriptorSet_host *convert_VkCopyDescriptorSet_array( const VkCopyDescriptorSet *in, ++ int count ) ++{ ++ VkCopyDescriptorSet_host *out; ++ int i; ++ ++ TRACE( "(%p, %d)\n", in, count ); ++ ++ if (!in) return NULL; ++ ++ out = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*out) ); ++ for (i = 0; i < count; i++) ++ convert_VkCopyDescriptorSet( &out[i], &in[i] ); ++ ++ return out; ++} ++ ++void release_VkCopyDescriptorSet_array( VkCopyDescriptorSet *out, VkCopyDescriptorSet_host *in, ++ int count ) ++{ ++ int i; ++ ++ TRACE( "(%p, %p, %d)\n", out, in, count ); ++ ++ if (!in) return; ++ ++ for (i = 0; i < count; i++) ++ release_VkCopyDescriptorSet( out ? &out[i] : NULL, &in[i] ); ++ HeapFree( GetProcessHeap(), 0, in ); ++} ++#endif /* defined(USE_STRUCT_CONVERSION) */ ++ ++static VkResult null_vkAcquireNextImageKHR( VkDevice device, VkSwapchainKHR swapchain, ++ uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex ) ++{ ++ FIXME( "(%p, %s, %s, %s, %s, %p) not supported\n", device, wine_dbgstr_longlong(swapchain), ++ wine_dbgstr_longlong(timeout), wine_dbgstr_longlong(semaphore), ++ wine_dbgstr_longlong(fence), pImageIndex ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkAllocateCommandBuffers( VkDevice device, ++ const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers ) ++{ ++ FIXME( "(%p, %p, %p) not supported\n", device, pAllocateInfo, pCommandBuffers ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkAllocateDescriptorSets( VkDevice device, ++ const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets ) ++{ ++ FIXME( "(%p, %p, %p) not supported\n", device, pAllocateInfo, pDescriptorSets ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkAllocateMemory( VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, ++ const VkAllocationCallbacks_host *pAllocator, VkDeviceMemory *pMemory ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", device, pAllocateInfo, pAllocator, pMemory ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkBeginCommandBuffer( VkCommandBuffer commandBuffer, ++ const VkCommandBufferBeginInfo_host *pBeginInfo ) ++{ ++ FIXME( "(%p, %p) not supported\n", commandBuffer, pBeginInfo ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, ++ VkDeviceSize memoryOffset ) ++{ ++ FIXME( "(%p, %s, %s, %s) not supported\n", device, wine_dbgstr_longlong(buffer), ++ wine_dbgstr_longlong(memory), wine_dbgstr_longlong(memoryOffset) ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkBindImageMemory( VkDevice device, VkImage image, VkDeviceMemory memory, ++ VkDeviceSize memoryOffset ) ++{ ++ FIXME( "(%p, %s, %s, %s) not supported\n", device, wine_dbgstr_longlong(image), ++ wine_dbgstr_longlong(memory), wine_dbgstr_longlong(memoryOffset) ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static void null_vkCmdBeginQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, ++ uint32_t query, VkQueryControlFlags flags ) ++{ ++ FIXME( "(%p, %s, %u, %u) not supported\n", commandBuffer, wine_dbgstr_longlong(queryPool), ++ query, flags ); ++} ++ ++static void null_vkCmdBeginRenderPass( VkCommandBuffer commandBuffer, ++ const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents ) ++{ ++ FIXME( "(%p, %p, %d) not supported\n", commandBuffer, pRenderPassBegin, contents ); ++} ++ ++static void null_vkCmdBindDescriptorSets( VkCommandBuffer commandBuffer, ++ VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, ++ uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, ++ uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets ) ++{ ++ FIXME( "(%p, %d, %s, %u, %u, %p, %u, %p) not supported\n", commandBuffer, pipelineBindPoint, ++ wine_dbgstr_longlong(layout), firstSet, descriptorSetCount, pDescriptorSets, ++ dynamicOffsetCount, pDynamicOffsets ); ++} ++ ++static void null_vkCmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer buffer, ++ VkDeviceSize offset, VkIndexType indexType ) ++{ ++ FIXME( "(%p, %s, %s, %d) not supported\n", commandBuffer, wine_dbgstr_longlong(buffer), ++ wine_dbgstr_longlong(offset), indexType ); ++} ++ ++static void null_vkCmdBindPipeline( VkCommandBuffer commandBuffer, ++ VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline ) ++{ ++ FIXME( "(%p, %d, %s) not supported\n", commandBuffer, pipelineBindPoint, ++ wine_dbgstr_longlong(pipeline) ); ++} ++ ++static void null_vkCmdBindVertexBuffers( VkCommandBuffer commandBuffer, uint32_t firstBinding, ++ uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets ) ++{ ++ FIXME( "(%p, %u, %u, %p, %p) not supported\n", commandBuffer, firstBinding, bindingCount, ++ pBuffers, pOffsets ); ++} ++ ++static void null_vkCmdBlitImage( VkCommandBuffer commandBuffer, VkImage srcImage, ++ VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, ++ uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter ) ++{ ++ FIXME( "(%p, %s, %d, %s, %d, %u, %p, %d) not supported\n", commandBuffer, ++ wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstImage), ++ dstImageLayout, regionCount, pRegions, filter ); ++} ++ ++static void null_vkCmdClearAttachments( VkCommandBuffer commandBuffer, uint32_t attachmentCount, ++ const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects ) ++{ ++ FIXME( "(%p, %u, %p, %u, %p) not supported\n", commandBuffer, attachmentCount, pAttachments, ++ rectCount, pRects ); ++} ++ ++static void null_vkCmdClearColorImage( VkCommandBuffer commandBuffer, VkImage image, ++ VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, ++ const VkImageSubresourceRange *pRanges ) ++{ ++ FIXME( "(%p, %s, %d, %p, %u, %p) not supported\n", commandBuffer, wine_dbgstr_longlong(image), ++ imageLayout, pColor, rangeCount, pRanges ); ++} ++ ++static void null_vkCmdClearDepthStencilImage( VkCommandBuffer commandBuffer, VkImage image, ++ VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, ++ uint32_t rangeCount, const VkImageSubresourceRange *pRanges ) ++{ ++ FIXME( "(%p, %s, %d, %p, %u, %p) not supported\n", commandBuffer, wine_dbgstr_longlong(image), ++ imageLayout, pDepthStencil, rangeCount, pRanges ); ++} ++ ++static void null_vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, ++ VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions ) ++{ ++ FIXME( "(%p, %s, %s, %u, %p) not supported\n", commandBuffer, wine_dbgstr_longlong(srcBuffer), ++ wine_dbgstr_longlong(dstBuffer), regionCount, pRegions ); ++} ++ ++static void null_vkCmdCopyBufferToImage( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, ++ VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, ++ const VkBufferImageCopy *pRegions ) ++{ ++ FIXME( "(%p, %s, %s, %d, %u, %p) not supported\n", commandBuffer, ++ wine_dbgstr_longlong(srcBuffer), wine_dbgstr_longlong(dstImage), dstImageLayout, ++ regionCount, pRegions ); ++} ++ ++static void null_vkCmdCopyImage( VkCommandBuffer commandBuffer, VkImage srcImage, ++ VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, ++ uint32_t regionCount, const VkImageCopy *pRegions ) ++{ ++ FIXME( "(%p, %s, %d, %s, %d, %u, %p) not supported\n", commandBuffer, ++ wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstImage), ++ dstImageLayout, regionCount, pRegions ); ++} ++ ++static void null_vkCmdCopyImageToBuffer( VkCommandBuffer commandBuffer, VkImage srcImage, ++ VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, ++ const VkBufferImageCopy *pRegions ) ++{ ++ FIXME( "(%p, %s, %d, %s, %u, %p) not supported\n", commandBuffer, ++ wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstBuffer), ++ regionCount, pRegions ); ++} ++ ++static void null_vkCmdCopyQueryPoolResults( VkCommandBuffer commandBuffer, VkQueryPool queryPool, ++ uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, ++ VkDeviceSize stride, VkQueryResultFlags flags ) ++{ ++ FIXME( "(%p, %s, %u, %u, %s, %s, %s, %u) not supported\n", commandBuffer, ++ wine_dbgstr_longlong(queryPool), firstQuery, queryCount, ++ wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), ++ wine_dbgstr_longlong(stride), flags ); ++} ++ ++static void null_vkCmdDispatch( VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z ) ++{ ++ FIXME( "(%p, %u, %u, %u) not supported\n", commandBuffer, x, y, z ); ++} ++ ++static void null_vkCmdDispatchIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, ++ VkDeviceSize offset ) ++{ ++ FIXME( "(%p, %s, %s) not supported\n", commandBuffer, wine_dbgstr_longlong(buffer), ++ wine_dbgstr_longlong(offset) ); ++} ++ ++static void null_vkCmdDraw( VkCommandBuffer commandBuffer, uint32_t vertexCount, ++ uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) ++{ ++ FIXME( "(%p, %u, %u, %u, %u) not supported\n", commandBuffer, vertexCount, instanceCount, ++ firstVertex, firstInstance ); ++} ++ ++static void null_vkCmdDrawIndexed( VkCommandBuffer commandBuffer, uint32_t indexCount, ++ uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) ++{ ++ FIXME( "(%p, %u, %u, %u, %d, %u) not supported\n", commandBuffer, indexCount, instanceCount, ++ firstIndex, vertexOffset, firstInstance ); ++} ++ ++static void null_vkCmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, ++ VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) ++{ ++ FIXME( "(%p, %s, %s, %u, %u) not supported\n", commandBuffer, wine_dbgstr_longlong(buffer), ++ wine_dbgstr_longlong(offset), drawCount, stride ); ++} ++ ++static void null_vkCmdDrawIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, ++ VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) ++{ ++ FIXME( "(%p, %s, %s, %u, %u) not supported\n", commandBuffer, wine_dbgstr_longlong(buffer), ++ wine_dbgstr_longlong(offset), drawCount, stride ); ++} ++ ++static void null_vkCmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, ++ uint32_t query ) ++{ ++ FIXME( "(%p, %s, %u) not supported\n", commandBuffer, wine_dbgstr_longlong(queryPool), query ); ++} ++ ++static void null_vkCmdEndRenderPass( VkCommandBuffer commandBuffer ) ++{ ++ FIXME( "(%p) not supported\n", commandBuffer ); ++} ++ ++static void null_vkCmdExecuteCommands( VkCommandBuffer commandBuffer, uint32_t commandBufferCount, ++ const VkCommandBuffer *pCommandBuffers ) ++{ ++ FIXME( "(%p, %u, %p) not supported\n", commandBuffer, commandBufferCount, pCommandBuffers ); ++} ++ ++static void null_vkCmdFillBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, ++ VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data ) ++{ ++ FIXME( "(%p, %s, %s, %s, %u) not supported\n", commandBuffer, wine_dbgstr_longlong(dstBuffer), ++ wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(size), data ); ++} ++ ++static void null_vkCmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents ) ++{ ++ FIXME( "(%p, %d) not supported\n", commandBuffer, contents ); ++} ++ ++static void null_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_host *pImageMemoryBarriers ) ++{ ++ FIXME( "(%p, %u, %u, %u, %u, %p, %u, %p, %u, %p) not supported\n", commandBuffer, srcStageMask, ++ dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, ++ bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, ++ pImageMemoryBarriers ); ++} ++ ++static void null_vkCmdPushConstants( VkCommandBuffer commandBuffer, VkPipelineLayout layout, ++ VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues ) ++{ ++ FIXME( "(%p, %s, %u, %u, %u, %p) not supported\n", commandBuffer, wine_dbgstr_longlong(layout), ++ stageFlags, offset, size, pValues ); ++} ++ ++static void null_vkCmdResetEvent( VkCommandBuffer commandBuffer, VkEvent event, ++ VkPipelineStageFlags stageMask ) ++{ ++ FIXME( "(%p, %s, %u) not supported\n", commandBuffer, wine_dbgstr_longlong(event), stageMask ); ++} ++ ++static void null_vkCmdResetQueryPool( VkCommandBuffer commandBuffer, VkQueryPool queryPool, ++ uint32_t firstQuery, uint32_t queryCount ) ++{ ++ FIXME( "(%p, %s, %u, %u) not supported\n", commandBuffer, wine_dbgstr_longlong(queryPool), ++ firstQuery, queryCount ); ++} ++ ++static void null_vkCmdResolveImage( VkCommandBuffer commandBuffer, VkImage srcImage, ++ VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, ++ uint32_t regionCount, const VkImageResolve *pRegions ) ++{ ++ FIXME( "(%p, %s, %d, %s, %d, %u, %p) not supported\n", commandBuffer, ++ wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstImage), ++ dstImageLayout, regionCount, pRegions ); ++} ++ ++static void null_vkCmdSetBlendConstants( VkCommandBuffer commandBuffer, ++ const float blendConstants[4] ) ++{ ++ FIXME( "(%p, %p) not supported\n", commandBuffer, blendConstants ); ++} ++ ++static void null_vkCmdSetDepthBias( VkCommandBuffer commandBuffer, float depthBiasConstantFactor, ++ float depthBiasClamp, float depthBiasSlopeFactor ) ++{ ++ FIXME( "(%p, %f, %f, %f) not supported\n", commandBuffer, depthBiasConstantFactor, ++ depthBiasClamp, depthBiasSlopeFactor ); ++} ++ ++static void null_vkCmdSetDepthBounds( VkCommandBuffer commandBuffer, float minDepthBounds, ++ float maxDepthBounds ) ++{ ++ FIXME( "(%p, %f, %f) not supported\n", commandBuffer, minDepthBounds, maxDepthBounds ); ++} ++ ++static void null_vkCmdSetEvent( VkCommandBuffer commandBuffer, VkEvent event, ++ VkPipelineStageFlags stageMask ) ++{ ++ FIXME( "(%p, %s, %u) not supported\n", commandBuffer, wine_dbgstr_longlong(event), stageMask ); ++} ++ ++static void null_vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth ) ++{ ++ FIXME( "(%p, %f) not supported\n", commandBuffer, lineWidth ); ++} ++ ++static void null_vkCmdSetScissor( VkCommandBuffer commandBuffer, uint32_t firstScissor, ++ uint32_t scissorCount, const VkRect2D *pScissors ) ++{ ++ FIXME( "(%p, %u, %u, %p) not supported\n", commandBuffer, firstScissor, scissorCount, ++ pScissors ); ++} ++ ++static void null_vkCmdSetStencilCompareMask( VkCommandBuffer commandBuffer, ++ VkStencilFaceFlags faceMask, uint32_t compareMask ) ++{ ++ FIXME( "(%p, %u, %u) not supported\n", commandBuffer, faceMask, compareMask ); ++} ++ ++static void null_vkCmdSetStencilReference( VkCommandBuffer commandBuffer, ++ VkStencilFaceFlags faceMask, uint32_t reference ) ++{ ++ FIXME( "(%p, %u, %u) not supported\n", commandBuffer, faceMask, reference ); ++} ++ ++static void null_vkCmdSetStencilWriteMask( VkCommandBuffer commandBuffer, ++ VkStencilFaceFlags faceMask, uint32_t writeMask ) ++{ ++ FIXME( "(%p, %u, %u) not supported\n", commandBuffer, faceMask, writeMask ); ++} ++ ++static void null_vkCmdSetViewport( VkCommandBuffer commandBuffer, uint32_t firstViewport, ++ uint32_t viewportCount, const VkViewport *pViewports ) ++{ ++ FIXME( "(%p, %u, %u, %p) not supported\n", commandBuffer, firstViewport, viewportCount, ++ pViewports ); ++} ++ ++static void null_vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, ++ VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t *pData ) ++{ ++ FIXME( "(%p, %s, %s, %s, %p) not supported\n", commandBuffer, wine_dbgstr_longlong(dstBuffer), ++ wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(dataSize), pData ); ++} ++ ++static void null_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_host *pImageMemoryBarriers ) ++{ ++ FIXME( "(%p, %u, %p, %u, %u, %u, %p, %u, %p, %u, %p) not supported\n", commandBuffer, ++ eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, ++ bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, ++ pImageMemoryBarriers ); ++} ++ ++static void null_vkCmdWriteTimestamp( VkCommandBuffer commandBuffer, ++ VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query ) ++{ ++ FIXME( "(%p, %d, %s, %u) not supported\n", commandBuffer, pipelineStage, ++ wine_dbgstr_longlong(queryPool), query ); ++} ++ ++static VkResult null_vkCreateBuffer( VkDevice device, const VkBufferCreateInfo_host *pCreateInfo, ++ const VkAllocationCallbacks_host *pAllocator, VkBuffer *pBuffer ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", device, pCreateInfo, pAllocator, pBuffer ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateBufferView( VkDevice device, ++ const VkBufferViewCreateInfo_host *pCreateInfo, ++ const VkAllocationCallbacks_host *pAllocator, VkBufferView *pView ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", device, pCreateInfo, pAllocator, pView ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateCommandPool( VkDevice device, ++ const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks_host *pAllocator, ++ VkCommandPool *pCommandPool ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", device, pCreateInfo, pAllocator, pCommandPool ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateComputePipelines( VkDevice device, VkPipelineCache pipelineCache, ++ uint32_t createInfoCount, const VkComputePipelineCreateInfo_host *pCreateInfos, ++ const VkAllocationCallbacks_host *pAllocator, VkPipeline *pPipelines ) ++{ ++ FIXME( "(%p, %s, %u, %p, %p, %p) not supported\n", device, wine_dbgstr_longlong(pipelineCache), ++ createInfoCount, pCreateInfos, pAllocator, pPipelines ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateDebugReportCallbackEXT( VkInstance instance, ++ const VkDebugReportCallbackCreateInfoEXT_host *pCreateInfo, ++ const VkAllocationCallbacks_host *pAllocator, VkDebugReportCallbackEXT *pCallback ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", instance, pCreateInfo, pAllocator, pCallback ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateDescriptorPool( VkDevice device, ++ const VkDescriptorPoolCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks_host *pAllocator, VkDescriptorPool *pDescriptorPool ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", device, pCreateInfo, pAllocator, pDescriptorPool ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateDescriptorSetLayout( VkDevice device, ++ const VkDescriptorSetLayoutCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks_host *pAllocator, VkDescriptorSetLayout *pSetLayout ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", device, pCreateInfo, pAllocator, pSetLayout ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateDevice( VkPhysicalDevice physicalDevice, ++ const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks_host *pAllocator, ++ VkDevice *pDevice ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", physicalDevice, pCreateInfo, pAllocator, pDevice ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateDisplayModeKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, ++ const VkDisplayModeCreateInfoKHR *pCreateInfo, ++ const VkAllocationCallbacks_host *pAllocator, VkDisplayModeKHR *pMode ) ++{ ++ FIXME( "(%p, %s, %p, %p, %p) not supported\n", physicalDevice, wine_dbgstr_longlong(display), ++ pCreateInfo, pAllocator, pMode ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateDisplayPlaneSurfaceKHR( VkInstance instance, ++ const VkDisplaySurfaceCreateInfoKHR_host *pCreateInfo, ++ const VkAllocationCallbacks_host *pAllocator, VkSurfaceKHR *pSurface ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", instance, pCreateInfo, pAllocator, pSurface ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateEvent( VkDevice device, const VkEventCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks_host *pAllocator, VkEvent *pEvent ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", device, pCreateInfo, pAllocator, pEvent ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateFence( VkDevice device, const VkFenceCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks_host *pAllocator, VkFence *pFence ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", device, pCreateInfo, pAllocator, pFence ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateFramebuffer( VkDevice device, ++ const VkFramebufferCreateInfo_host *pCreateInfo, ++ const VkAllocationCallbacks_host *pAllocator, VkFramebuffer *pFramebuffer ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", device, pCreateInfo, pAllocator, pFramebuffer ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateGraphicsPipelines( VkDevice device, VkPipelineCache pipelineCache, ++ uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo_host *pCreateInfos, ++ const VkAllocationCallbacks_host *pAllocator, VkPipeline *pPipelines ) ++{ ++ FIXME( "(%p, %s, %u, %p, %p, %p) not supported\n", device, wine_dbgstr_longlong(pipelineCache), ++ createInfoCount, pCreateInfos, pAllocator, pPipelines ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateImage( VkDevice device, const VkImageCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks_host *pAllocator, VkImage *pImage ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", device, pCreateInfo, pAllocator, pImage ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateImageView( VkDevice device, ++ const VkImageViewCreateInfo_host *pCreateInfo, ++ const VkAllocationCallbacks_host *pAllocator, VkImageView *pView ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", device, pCreateInfo, pAllocator, pView ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateInstance( const VkInstanceCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks_host *pAllocator, VkInstance *pInstance ) ++{ ++ FIXME( "(%p, %p, %p) not supported\n", pCreateInfo, pAllocator, pInstance ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreatePipelineCache( VkDevice device, ++ const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks_host *pAllocator, ++ VkPipelineCache *pPipelineCache ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", device, pCreateInfo, pAllocator, pPipelineCache ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreatePipelineLayout( VkDevice device, ++ const VkPipelineLayoutCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks_host *pAllocator, VkPipelineLayout *pPipelineLayout ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", device, pCreateInfo, pAllocator, pPipelineLayout ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateQueryPool( VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks_host *pAllocator, VkQueryPool *pQueryPool ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", device, pCreateInfo, pAllocator, pQueryPool ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateRenderPass( VkDevice device, ++ const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks_host *pAllocator, ++ VkRenderPass *pRenderPass ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", device, pCreateInfo, pAllocator, pRenderPass ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateSampler( VkDevice device, const VkSamplerCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks_host *pAllocator, VkSampler *pSampler ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", device, pCreateInfo, pAllocator, pSampler ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateSemaphore( VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks_host *pAllocator, VkSemaphore *pSemaphore ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", device, pCreateInfo, pAllocator, pSemaphore ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateShaderModule( VkDevice device, ++ const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks_host *pAllocator, ++ VkShaderModule *pShaderModule ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", device, pCreateInfo, pAllocator, pShaderModule ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateSharedSwapchainsKHR( VkDevice device, uint32_t swapchainCount, ++ const VkSwapchainCreateInfoKHR_host *pCreateInfos, ++ const VkAllocationCallbacks_host *pAllocator, VkSwapchainKHR *pSwapchains ) ++{ ++ FIXME( "(%p, %u, %p, %p, %p) not supported\n", device, swapchainCount, pCreateInfos, ++ pAllocator, pSwapchains ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateSwapchainKHR( VkDevice device, ++ const VkSwapchainCreateInfoKHR_host *pCreateInfo, ++ const VkAllocationCallbacks_host *pAllocator, VkSwapchainKHR *pSwapchain ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", device, pCreateInfo, pAllocator, pSwapchain ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateXcbSurfaceKHR( VkInstance instance, ++ const VkXcbSurfaceCreateInfoKHR_host *pCreateInfo, ++ const VkAllocationCallbacks_host *pAllocator, VkSurfaceKHR *pSurface ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", instance, pCreateInfo, pAllocator, pSurface ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkCreateXlibSurfaceKHR( VkInstance instance, ++ const VkXlibSurfaceCreateInfoKHR_host *pCreateInfo, ++ const VkAllocationCallbacks_host *pAllocator, VkSurfaceKHR *pSurface ) ++{ ++ FIXME( "(%p, %p, %p, %p) not supported\n", instance, pCreateInfo, pAllocator, pSurface ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static void null_vkDebugReportMessageEXT( VkInstance instance, VkDebugReportFlagsEXT flags, ++ VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, ++ int32_t messageCode, const char *pLayerPrefix, const char *pMessage ) ++{ ++ FIXME( "(%p, %u, %d, %s, %lu, %d, %s, %s) not supported\n", instance, flags, objectType, ++ wine_dbgstr_longlong(object), (SIZE_T)location, messageCode, debugstr_a(pLayerPrefix), ++ debugstr_a(pMessage) ); ++} ++ ++static void null_vkDestroyBuffer( VkDevice device, VkBuffer buffer, ++ const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(buffer), pAllocator ); ++} ++ ++static void null_vkDestroyBufferView( VkDevice device, VkBufferView bufferView, ++ const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(bufferView), pAllocator ); ++} ++ ++static void null_vkDestroyCommandPool( VkDevice device, VkCommandPool commandPool, ++ const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(commandPool), pAllocator ); ++} ++ ++static void null_vkDestroyDebugReportCallbackEXT( VkInstance instance, ++ VkDebugReportCallbackEXT callback, const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", instance, wine_dbgstr_longlong(callback), pAllocator ); ++} ++ ++static void null_vkDestroyDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, ++ const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(descriptorPool), ++ pAllocator ); ++} ++ ++static void null_vkDestroyDescriptorSetLayout( VkDevice device, ++ VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(descriptorSetLayout), ++ pAllocator ); ++} ++ ++static void null_vkDestroyDevice( VkDevice device, const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %p) not supported\n", device, pAllocator ); ++} ++ ++static void null_vkDestroyEvent( VkDevice device, VkEvent event, ++ const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(event), pAllocator ); ++} ++ ++static void null_vkDestroyFence( VkDevice device, VkFence fence, ++ const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(fence), pAllocator ); ++} ++ ++static void null_vkDestroyFramebuffer( VkDevice device, VkFramebuffer framebuffer, ++ const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(framebuffer), pAllocator ); ++} ++ ++static void null_vkDestroyImage( VkDevice device, VkImage image, ++ const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(image), pAllocator ); ++} ++ ++static void null_vkDestroyImageView( VkDevice device, VkImageView imageView, ++ const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(imageView), pAllocator ); ++} ++ ++static void null_vkDestroyInstance( VkInstance instance, ++ const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %p) not supported\n", instance, pAllocator ); ++} ++ ++static void null_vkDestroyPipeline( VkDevice device, VkPipeline pipeline, ++ const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(pipeline), pAllocator ); ++} ++ ++static void null_vkDestroyPipelineCache( VkDevice device, VkPipelineCache pipelineCache, ++ const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(pipelineCache), ++ pAllocator ); ++} ++ ++static void null_vkDestroyPipelineLayout( VkDevice device, VkPipelineLayout pipelineLayout, ++ const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(pipelineLayout), ++ pAllocator ); ++} ++ ++static void null_vkDestroyQueryPool( VkDevice device, VkQueryPool queryPool, ++ const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(queryPool), pAllocator ); ++} ++ ++static void null_vkDestroyRenderPass( VkDevice device, VkRenderPass renderPass, ++ const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(renderPass), pAllocator ); ++} ++ ++static void null_vkDestroySampler( VkDevice device, VkSampler sampler, ++ const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(sampler), pAllocator ); ++} ++ ++static void null_vkDestroySemaphore( VkDevice device, VkSemaphore semaphore, ++ const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(semaphore), pAllocator ); ++} ++ ++static void null_vkDestroyShaderModule( VkDevice device, VkShaderModule shaderModule, ++ const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(shaderModule), pAllocator ); ++} ++ ++static void null_vkDestroySurfaceKHR( VkInstance instance, VkSurfaceKHR surface, ++ const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", instance, wine_dbgstr_longlong(surface), pAllocator ); ++} ++ ++static void null_vkDestroySwapchainKHR( VkDevice device, VkSwapchainKHR swapchain, ++ const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(swapchain), pAllocator ); ++} ++ ++static VkResult null_vkDeviceWaitIdle( VkDevice device ) ++{ ++ FIXME( "(%p) not supported\n", device ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkEndCommandBuffer( VkCommandBuffer commandBuffer ) ++{ ++ FIXME( "(%p) not supported\n", commandBuffer ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkEnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice, ++ const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties ) ++{ ++ FIXME( "(%p, %s, %p, %p) not supported\n", physicalDevice, debugstr_a(pLayerName), ++ pPropertyCount, pProperties ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkEnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, ++ uint32_t *pPropertyCount, VkLayerProperties *pProperties ) ++{ ++ FIXME( "(%p, %p, %p) not supported\n", physicalDevice, pPropertyCount, pProperties ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkEnumerateInstanceExtensionProperties( const char *pLayerName, ++ uint32_t *pPropertyCount, VkExtensionProperties *pProperties ) ++{ ++ FIXME( "(%s, %p, %p) not supported\n", debugstr_a(pLayerName), pPropertyCount, pProperties ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkEnumerateInstanceLayerProperties( uint32_t *pPropertyCount, ++ VkLayerProperties *pProperties ) ++{ ++ FIXME( "(%p, %p) not supported\n", pPropertyCount, pProperties ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkEnumeratePhysicalDevices( VkInstance instance, ++ uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices ) ++{ ++ FIXME( "(%p, %p, %p) not supported\n", instance, pPhysicalDeviceCount, pPhysicalDevices ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkFlushMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, ++ const VkMappedMemoryRange *pMemoryRanges ) ++{ ++ FIXME( "(%p, %u, %p) not supported\n", device, memoryRangeCount, pMemoryRanges ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static void null_vkFreeCommandBuffers( VkDevice device, VkCommandPool commandPool, ++ uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers ) ++{ ++ FIXME( "(%p, %s, %u, %p) not supported\n", device, wine_dbgstr_longlong(commandPool), ++ commandBufferCount, pCommandBuffers ); ++} ++ ++static VkResult null_vkFreeDescriptorSets( VkDevice device, VkDescriptorPool descriptorPool, ++ uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets ) ++{ ++ FIXME( "(%p, %s, %u, %p) not supported\n", device, wine_dbgstr_longlong(descriptorPool), ++ descriptorSetCount, pDescriptorSets ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static void null_vkFreeMemory( VkDevice device, VkDeviceMemory memory, ++ const VkAllocationCallbacks_host *pAllocator ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(memory), pAllocator ); ++} ++ ++static void null_vkGetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, ++ VkMemoryRequirements *pMemoryRequirements ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(buffer), ++ pMemoryRequirements ); ++} ++ ++static void null_vkGetDeviceMemoryCommitment( VkDevice device, VkDeviceMemory memory, ++ VkDeviceSize *pCommittedMemoryInBytes ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(memory), ++ pCommittedMemoryInBytes ); ++} ++ ++static PFN_vkVoidFunction_host null_vkGetDeviceProcAddr( VkDevice device, const char *pName ) ++{ ++ FIXME( "(%p, %s) not supported\n", device, debugstr_a(pName) ); ++ return NULL; ++} ++ ++static void null_vkGetDeviceQueue( VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, ++ VkQueue *pQueue ) ++{ ++ FIXME( "(%p, %u, %u, %p) not supported\n", device, queueFamilyIndex, queueIndex, pQueue ); ++} ++ ++static VkResult null_vkGetDisplayModePropertiesKHR( VkPhysicalDevice physicalDevice, ++ VkDisplayKHR display, uint32_t *pPropertyCount, ++ VkDisplayModePropertiesKHR_host *pProperties ) ++{ ++ FIXME( "(%p, %s, %p, %p) not supported\n", physicalDevice, wine_dbgstr_longlong(display), ++ pPropertyCount, pProperties ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice physicalDevice, ++ VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities ) ++{ ++ FIXME( "(%p, %s, %u, %p) not supported\n", physicalDevice, wine_dbgstr_longlong(mode), ++ planeIndex, pCapabilities ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice, ++ uint32_t planeIndex, uint32_t *pDisplayCount, VkDisplayKHR *pDisplays ) ++{ ++ FIXME( "(%p, %u, %p, %p) not supported\n", physicalDevice, planeIndex, pDisplayCount, ++ pDisplays ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkGetEventStatus( VkDevice device, VkEvent event ) ++{ ++ FIXME( "(%p, %s) not supported\n", device, wine_dbgstr_longlong(event) ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkGetFenceStatus( VkDevice device, VkFence fence ) ++{ ++ FIXME( "(%p, %s) not supported\n", device, wine_dbgstr_longlong(fence) ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static void null_vkGetImageMemoryRequirements( VkDevice device, VkImage image, ++ VkMemoryRequirements *pMemoryRequirements ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(image), ++ pMemoryRequirements ); ++} ++ ++static void null_vkGetImageSparseMemoryRequirements( VkDevice device, VkImage image, ++ uint32_t *pSparseMemoryRequirementCount, ++ VkSparseImageMemoryRequirements *pSparseMemoryRequirements ) ++{ ++ FIXME( "(%p, %s, %p, %p) not supported\n", device, wine_dbgstr_longlong(image), ++ pSparseMemoryRequirementCount, pSparseMemoryRequirements ); ++} ++ ++static void null_vkGetImageSubresourceLayout( VkDevice device, VkImage image, ++ const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout ) ++{ ++ FIXME( "(%p, %s, %p, %p) not supported\n", device, wine_dbgstr_longlong(image), pSubresource, ++ pLayout ); ++} ++ ++static PFN_vkVoidFunction_host null_vkGetInstanceProcAddr( VkInstance instance, const char *pName ) ++{ ++ FIXME( "(%p, %s) not supported\n", instance, debugstr_a(pName) ); ++ return NULL; ++} ++ ++static VkResult null_vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice physicalDevice, ++ uint32_t *pPropertyCount, VkDisplayPlanePropertiesKHR_host *pProperties ) ++{ ++ FIXME( "(%p, %p, %p) not supported\n", physicalDevice, pPropertyCount, pProperties ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkGetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice physicalDevice, ++ uint32_t *pPropertyCount, VkDisplayPropertiesKHR *pProperties ) ++{ ++ FIXME( "(%p, %p, %p) not supported\n", physicalDevice, pPropertyCount, pProperties ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static void null_vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, ++ VkPhysicalDeviceFeatures *pFeatures ) ++{ ++ FIXME( "(%p, %p) not supported\n", physicalDevice, pFeatures ); ++} ++ ++static void null_vkGetPhysicalDeviceFormatProperties( VkPhysicalDevice physicalDevice, ++ VkFormat format, VkFormatProperties *pFormatProperties ) ++{ ++ FIXME( "(%p, %d, %p) not supported\n", physicalDevice, format, pFormatProperties ); ++} ++ ++static VkResult null_vkGetPhysicalDeviceImageFormatProperties( VkPhysicalDevice physicalDevice, ++ VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, ++ VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties ) ++{ ++ FIXME( "(%p, %d, %d, %d, %u, %u, %p) not supported\n", physicalDevice, format, type, tiling, ++ usage, flags, pImageFormatProperties ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static void null_vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, ++ VkPhysicalDeviceMemoryProperties_host *pMemoryProperties ) ++{ ++ FIXME( "(%p, %p) not supported\n", physicalDevice, pMemoryProperties ); ++} ++ ++static void null_vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, ++ VkPhysicalDeviceProperties_host *pProperties ) ++{ ++ FIXME( "(%p, %p) not supported\n", physicalDevice, pProperties ); ++} ++ ++static void null_vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice, ++ uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties ) ++{ ++ FIXME( "(%p, %p, %p) not supported\n", physicalDevice, pQueueFamilyPropertyCount, ++ pQueueFamilyProperties ); ++} ++ ++static void null_vkGetPhysicalDeviceSparseImageFormatProperties( VkPhysicalDevice physicalDevice, ++ VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, ++ VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties ) ++{ ++ FIXME( "(%p, %d, %d, %d, %u, %d, %p, %p) not supported\n", physicalDevice, format, type, ++ samples, usage, tiling, pPropertyCount, pProperties ); ++} ++ ++static VkResult null_vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice physicalDevice, ++ VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", physicalDevice, wine_dbgstr_longlong(surface), ++ pSurfaceCapabilities ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkGetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice physicalDevice, ++ VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats ) ++{ ++ FIXME( "(%p, %s, %p, %p) not supported\n", physicalDevice, wine_dbgstr_longlong(surface), ++ pSurfaceFormatCount, pSurfaceFormats ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice, ++ VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes ) ++{ ++ FIXME( "(%p, %s, %p, %p) not supported\n", physicalDevice, wine_dbgstr_longlong(surface), ++ pPresentModeCount, pPresentModes ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkGetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice, ++ uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported ) ++{ ++ FIXME( "(%p, %u, %s, %p) not supported\n", physicalDevice, queueFamilyIndex, ++ wine_dbgstr_longlong(surface), pSupported ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkGetPipelineCacheData( VkDevice device, VkPipelineCache pipelineCache, ++ size_t *pDataSize, void *pData ) ++{ ++ FIXME( "(%p, %s, %p, %p) not supported\n", device, wine_dbgstr_longlong(pipelineCache), ++ pDataSize, pData ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkGetQueryPoolResults( VkDevice device, VkQueryPool queryPool, ++ uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, ++ VkDeviceSize stride, VkQueryResultFlags flags ) ++{ ++ FIXME( "(%p, %s, %u, %u, %lu, %p, %s, %u) not supported\n", device, ++ wine_dbgstr_longlong(queryPool), firstQuery, queryCount, (SIZE_T)dataSize, pData, ++ wine_dbgstr_longlong(stride), flags ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static void null_vkGetRenderAreaGranularity( VkDevice device, VkRenderPass renderPass, ++ VkExtent2D *pGranularity ) ++{ ++ FIXME( "(%p, %s, %p) not supported\n", device, wine_dbgstr_longlong(renderPass), pGranularity ); ++} ++ ++static VkResult null_vkGetSwapchainImagesKHR( VkDevice device, VkSwapchainKHR swapchain, ++ uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages ) ++{ ++ FIXME( "(%p, %s, %p, %p) not supported\n", device, wine_dbgstr_longlong(swapchain), ++ pSwapchainImageCount, pSwapchainImages ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkInvalidateMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, ++ const VkMappedMemoryRange *pMemoryRanges ) ++{ ++ FIXME( "(%p, %u, %p) not supported\n", device, memoryRangeCount, pMemoryRanges ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkMapMemory( VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, ++ VkDeviceSize size, VkMemoryMapFlags flags, void **ppData ) ++{ ++ FIXME( "(%p, %s, %s, %s, %u, %p) not supported\n", device, wine_dbgstr_longlong(memory), ++ wine_dbgstr_longlong(offset), wine_dbgstr_longlong(size), flags, ppData ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkMergePipelineCaches( VkDevice device, VkPipelineCache dstCache, ++ uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches ) ++{ ++ FIXME( "(%p, %s, %u, %p) not supported\n", device, wine_dbgstr_longlong(dstCache), ++ srcCacheCount, pSrcCaches ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkQueueBindSparse( VkQueue queue, uint32_t bindInfoCount, ++ const VkBindSparseInfo_host *pBindInfo, VkFence fence ) ++{ ++ FIXME( "(%p, %u, %p, %s) not supported\n", queue, bindInfoCount, pBindInfo, ++ wine_dbgstr_longlong(fence) ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkQueuePresentKHR( VkQueue queue, const VkPresentInfoKHR *pPresentInfo ) ++{ ++ FIXME( "(%p, %p) not supported\n", queue, pPresentInfo ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkQueueSubmit( VkQueue queue, uint32_t submitCount, ++ const VkSubmitInfo *pSubmits, VkFence fence ) ++{ ++ FIXME( "(%p, %u, %p, %s) not supported\n", queue, submitCount, pSubmits, ++ wine_dbgstr_longlong(fence) ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkQueueWaitIdle( VkQueue queue ) ++{ ++ FIXME( "(%p) not supported\n", queue ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkResetCommandBuffer( VkCommandBuffer commandBuffer, ++ VkCommandBufferResetFlags flags ) ++{ ++ FIXME( "(%p, %u) not supported\n", commandBuffer, flags ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkResetCommandPool( VkDevice device, VkCommandPool commandPool, ++ VkCommandPoolResetFlags flags ) ++{ ++ FIXME( "(%p, %s, %u) not supported\n", device, wine_dbgstr_longlong(commandPool), flags ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkResetDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, ++ VkDescriptorPoolResetFlags flags ) ++{ ++ FIXME( "(%p, %s, %u) not supported\n", device, wine_dbgstr_longlong(descriptorPool), flags ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkResetEvent( VkDevice device, VkEvent event ) ++{ ++ FIXME( "(%p, %s) not supported\n", device, wine_dbgstr_longlong(event) ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence *pFences ) ++{ ++ FIXME( "(%p, %u, %p) not supported\n", device, fenceCount, pFences ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static VkResult null_vkSetEvent( VkDevice device, VkEvent event ) ++{ ++ FIXME( "(%p, %s) not supported\n", device, wine_dbgstr_longlong(event) ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++static void null_vkUnmapMemory( VkDevice device, VkDeviceMemory memory ) ++{ ++ FIXME( "(%p, %s) not supported\n", device, wine_dbgstr_longlong(memory) ); ++} ++ ++static void null_vkUpdateDescriptorSets( VkDevice device, uint32_t descriptorWriteCount, ++ const VkWriteDescriptorSet_host *pDescriptorWrites, uint32_t descriptorCopyCount, ++ const VkCopyDescriptorSet_host *pDescriptorCopies ) ++{ ++ FIXME( "(%p, %u, %p, %u, %p) not supported\n", device, descriptorWriteCount, pDescriptorWrites, ++ descriptorCopyCount, pDescriptorCopies ); ++} ++ ++static VkResult null_vkWaitForFences( VkDevice device, uint32_t fenceCount, const VkFence *pFences, ++ VkBool32 waitAll, uint64_t timeout ) ++{ ++ FIXME( "(%p, %u, %p, %u, %s) not supported\n", device, fenceCount, pFences, waitAll, ++ wine_dbgstr_longlong(timeout) ); ++ return VK_ERROR_INCOMPATIBLE_DRIVER; ++} ++ ++VkResult (*p_vkAcquireNextImageKHR)( VkDevice, VkSwapchainKHR, uint64_t, VkSemaphore, VkFence, ++ uint32_t * ) = null_vkAcquireNextImageKHR; ++VkResult (*p_vkAllocateCommandBuffers)( VkDevice, const VkCommandBufferAllocateInfo *, ++ VkCommandBuffer * ) = null_vkAllocateCommandBuffers; ++VkResult (*p_vkAllocateDescriptorSets)( VkDevice, const VkDescriptorSetAllocateInfo *, ++ VkDescriptorSet * ) = null_vkAllocateDescriptorSets; ++VkResult (*p_vkAllocateMemory)( VkDevice, const VkMemoryAllocateInfo *, ++ const VkAllocationCallbacks_host *, VkDeviceMemory * ) = null_vkAllocateMemory; ++VkResult (*p_vkBeginCommandBuffer)( VkCommandBuffer, const VkCommandBufferBeginInfo_host * ) = ++ null_vkBeginCommandBuffer; ++VkResult (*p_vkBindBufferMemory)( VkDevice, VkBuffer, VkDeviceMemory, VkDeviceSize ) = ++ null_vkBindBufferMemory; ++VkResult (*p_vkBindImageMemory)( VkDevice, VkImage, VkDeviceMemory, VkDeviceSize ) = ++ null_vkBindImageMemory; ++void (*p_vkCmdBeginQuery)( VkCommandBuffer, VkQueryPool, uint32_t, VkQueryControlFlags ) = ++ null_vkCmdBeginQuery; ++void (*p_vkCmdBeginRenderPass)( VkCommandBuffer, const VkRenderPassBeginInfo *, ++ VkSubpassContents ) = null_vkCmdBeginRenderPass; ++void (*p_vkCmdBindDescriptorSets)( VkCommandBuffer, VkPipelineBindPoint, VkPipelineLayout, ++ uint32_t, uint32_t, const VkDescriptorSet *, uint32_t, const uint32_t * ) = ++ null_vkCmdBindDescriptorSets; ++void (*p_vkCmdBindIndexBuffer)( VkCommandBuffer, VkBuffer, VkDeviceSize, VkIndexType ) = ++ null_vkCmdBindIndexBuffer; ++void (*p_vkCmdBindPipeline)( VkCommandBuffer, VkPipelineBindPoint, VkPipeline ) = ++ null_vkCmdBindPipeline; ++void (*p_vkCmdBindVertexBuffers)( VkCommandBuffer, uint32_t, uint32_t, const VkBuffer *, ++ const VkDeviceSize * ) = null_vkCmdBindVertexBuffers; ++void (*p_vkCmdBlitImage)( VkCommandBuffer, VkImage, VkImageLayout, VkImage, VkImageLayout, ++ uint32_t, const VkImageBlit *, VkFilter ) = null_vkCmdBlitImage; ++void (*p_vkCmdClearAttachments)( VkCommandBuffer, uint32_t, const VkClearAttachment *, uint32_t, ++ const VkClearRect * ) = null_vkCmdClearAttachments; ++void (*p_vkCmdClearColorImage)( VkCommandBuffer, VkImage, VkImageLayout, const VkClearColorValue *, ++ uint32_t, const VkImageSubresourceRange * ) = null_vkCmdClearColorImage; ++void (*p_vkCmdClearDepthStencilImage)( VkCommandBuffer, VkImage, VkImageLayout, ++ const VkClearDepthStencilValue *, uint32_t, const VkImageSubresourceRange * ) = ++ null_vkCmdClearDepthStencilImage; ++void (*p_vkCmdCopyBuffer)( VkCommandBuffer, VkBuffer, VkBuffer, uint32_t, const VkBufferCopy * ) = ++ null_vkCmdCopyBuffer; ++void (*p_vkCmdCopyBufferToImage)( VkCommandBuffer, VkBuffer, VkImage, VkImageLayout, uint32_t, ++ const VkBufferImageCopy * ) = null_vkCmdCopyBufferToImage; ++void (*p_vkCmdCopyImage)( VkCommandBuffer, VkImage, VkImageLayout, VkImage, VkImageLayout, ++ uint32_t, const VkImageCopy * ) = null_vkCmdCopyImage; ++void (*p_vkCmdCopyImageToBuffer)( VkCommandBuffer, VkImage, VkImageLayout, VkBuffer, uint32_t, ++ const VkBufferImageCopy * ) = null_vkCmdCopyImageToBuffer; ++void (*p_vkCmdCopyQueryPoolResults)( VkCommandBuffer, VkQueryPool, uint32_t, uint32_t, VkBuffer, ++ VkDeviceSize, VkDeviceSize, VkQueryResultFlags ) = null_vkCmdCopyQueryPoolResults; ++void (*p_vkCmdDispatch)( VkCommandBuffer, uint32_t, uint32_t, uint32_t ) = null_vkCmdDispatch; ++void (*p_vkCmdDispatchIndirect)( VkCommandBuffer, VkBuffer, VkDeviceSize ) = ++ null_vkCmdDispatchIndirect; ++void (*p_vkCmdDraw)( VkCommandBuffer, uint32_t, uint32_t, uint32_t, uint32_t ) = null_vkCmdDraw; ++void (*p_vkCmdDrawIndexed)( VkCommandBuffer, uint32_t, uint32_t, uint32_t, int32_t, uint32_t ) = ++ null_vkCmdDrawIndexed; ++void (*p_vkCmdDrawIndexedIndirect)( VkCommandBuffer, VkBuffer, VkDeviceSize, uint32_t, uint32_t ) = ++ null_vkCmdDrawIndexedIndirect; ++void (*p_vkCmdDrawIndirect)( VkCommandBuffer, VkBuffer, VkDeviceSize, uint32_t, uint32_t ) = ++ null_vkCmdDrawIndirect; ++void (*p_vkCmdEndQuery)( VkCommandBuffer, VkQueryPool, uint32_t ) = null_vkCmdEndQuery; ++void (*p_vkCmdEndRenderPass)( VkCommandBuffer ) = null_vkCmdEndRenderPass; ++void (*p_vkCmdExecuteCommands)( VkCommandBuffer, uint32_t, const VkCommandBuffer * ) = ++ null_vkCmdExecuteCommands; ++void (*p_vkCmdFillBuffer)( VkCommandBuffer, VkBuffer, VkDeviceSize, VkDeviceSize, uint32_t ) = ++ null_vkCmdFillBuffer; ++void (*p_vkCmdNextSubpass)( VkCommandBuffer, VkSubpassContents ) = null_vkCmdNextSubpass; ++void (*p_vkCmdPipelineBarrier)( VkCommandBuffer, VkPipelineStageFlags, VkPipelineStageFlags, ++ VkDependencyFlags, uint32_t, const VkMemoryBarrier *, uint32_t, ++ const VkBufferMemoryBarrier *, uint32_t, const VkImageMemoryBarrier_host * ) = ++ null_vkCmdPipelineBarrier; ++void (*p_vkCmdPushConstants)( VkCommandBuffer, VkPipelineLayout, VkShaderStageFlags, uint32_t, ++ uint32_t, const void * ) = null_vkCmdPushConstants; ++void (*p_vkCmdResetEvent)( VkCommandBuffer, VkEvent, VkPipelineStageFlags ) = null_vkCmdResetEvent; ++void (*p_vkCmdResetQueryPool)( VkCommandBuffer, VkQueryPool, uint32_t, uint32_t ) = ++ null_vkCmdResetQueryPool; ++void (*p_vkCmdResolveImage)( VkCommandBuffer, VkImage, VkImageLayout, VkImage, VkImageLayout, ++ uint32_t, const VkImageResolve * ) = null_vkCmdResolveImage; ++void (*p_vkCmdSetBlendConstants)( VkCommandBuffer, const float[4] ) = null_vkCmdSetBlendConstants; ++void (*p_vkCmdSetDepthBias)( VkCommandBuffer, float, float, float ) = null_vkCmdSetDepthBias; ++void (*p_vkCmdSetDepthBounds)( VkCommandBuffer, float, float ) = null_vkCmdSetDepthBounds; ++void (*p_vkCmdSetEvent)( VkCommandBuffer, VkEvent, VkPipelineStageFlags ) = null_vkCmdSetEvent; ++void (*p_vkCmdSetLineWidth)( VkCommandBuffer, float ) = null_vkCmdSetLineWidth; ++void (*p_vkCmdSetScissor)( VkCommandBuffer, uint32_t, uint32_t, const VkRect2D * ) = ++ null_vkCmdSetScissor; ++void (*p_vkCmdSetStencilCompareMask)( VkCommandBuffer, VkStencilFaceFlags, uint32_t ) = ++ null_vkCmdSetStencilCompareMask; ++void (*p_vkCmdSetStencilReference)( VkCommandBuffer, VkStencilFaceFlags, uint32_t ) = ++ null_vkCmdSetStencilReference; ++void (*p_vkCmdSetStencilWriteMask)( VkCommandBuffer, VkStencilFaceFlags, uint32_t ) = ++ null_vkCmdSetStencilWriteMask; ++void (*p_vkCmdSetViewport)( VkCommandBuffer, uint32_t, uint32_t, const VkViewport * ) = ++ null_vkCmdSetViewport; ++void (*p_vkCmdUpdateBuffer)( VkCommandBuffer, VkBuffer, VkDeviceSize, VkDeviceSize, ++ const uint32_t * ) = null_vkCmdUpdateBuffer; ++void (*p_vkCmdWaitEvents)( VkCommandBuffer, uint32_t, const VkEvent *, VkPipelineStageFlags, ++ VkPipelineStageFlags, uint32_t, const VkMemoryBarrier *, uint32_t, ++ const VkBufferMemoryBarrier *, uint32_t, const VkImageMemoryBarrier_host * ) = ++ null_vkCmdWaitEvents; ++void (*p_vkCmdWriteTimestamp)( VkCommandBuffer, VkPipelineStageFlagBits, VkQueryPool, uint32_t ) = ++ null_vkCmdWriteTimestamp; ++VkResult (*p_vkCreateBuffer)( VkDevice, const VkBufferCreateInfo_host *, ++ const VkAllocationCallbacks_host *, VkBuffer * ) = null_vkCreateBuffer; ++VkResult (*p_vkCreateBufferView)( VkDevice, const VkBufferViewCreateInfo_host *, ++ const VkAllocationCallbacks_host *, VkBufferView * ) = null_vkCreateBufferView; ++VkResult (*p_vkCreateCommandPool)( VkDevice, const VkCommandPoolCreateInfo *, ++ const VkAllocationCallbacks_host *, VkCommandPool * ) = null_vkCreateCommandPool; ++VkResult (*p_vkCreateComputePipelines)( VkDevice, VkPipelineCache, uint32_t, ++ const VkComputePipelineCreateInfo_host *, const VkAllocationCallbacks_host *, ++ VkPipeline * ) = null_vkCreateComputePipelines; ++VkResult (*p_vkCreateDebugReportCallbackEXT)( VkInstance, ++ const VkDebugReportCallbackCreateInfoEXT_host *, const VkAllocationCallbacks_host *, ++ VkDebugReportCallbackEXT * ) = null_vkCreateDebugReportCallbackEXT; ++VkResult (*p_vkCreateDescriptorPool)( VkDevice, const VkDescriptorPoolCreateInfo *, ++ const VkAllocationCallbacks_host *, VkDescriptorPool * ) = null_vkCreateDescriptorPool; ++VkResult (*p_vkCreateDescriptorSetLayout)( VkDevice, const VkDescriptorSetLayoutCreateInfo *, ++ const VkAllocationCallbacks_host *, VkDescriptorSetLayout * ) = ++ null_vkCreateDescriptorSetLayout; ++VkResult (*p_vkCreateDevice)( VkPhysicalDevice, const VkDeviceCreateInfo *, ++ const VkAllocationCallbacks_host *, VkDevice * ) = null_vkCreateDevice; ++VkResult (*p_vkCreateDisplayModeKHR)( VkPhysicalDevice, VkDisplayKHR, ++ const VkDisplayModeCreateInfoKHR *, const VkAllocationCallbacks_host *, ++ VkDisplayModeKHR * ) = null_vkCreateDisplayModeKHR; ++VkResult (*p_vkCreateDisplayPlaneSurfaceKHR)( VkInstance, ++ const VkDisplaySurfaceCreateInfoKHR_host *, const VkAllocationCallbacks_host *, ++ VkSurfaceKHR * ) = null_vkCreateDisplayPlaneSurfaceKHR; ++VkResult (*p_vkCreateEvent)( VkDevice, const VkEventCreateInfo *, ++ const VkAllocationCallbacks_host *, VkEvent * ) = null_vkCreateEvent; ++VkResult (*p_vkCreateFence)( VkDevice, const VkFenceCreateInfo *, ++ const VkAllocationCallbacks_host *, VkFence * ) = null_vkCreateFence; ++VkResult (*p_vkCreateFramebuffer)( VkDevice, const VkFramebufferCreateInfo_host *, ++ const VkAllocationCallbacks_host *, VkFramebuffer * ) = null_vkCreateFramebuffer; ++VkResult (*p_vkCreateGraphicsPipelines)( VkDevice, VkPipelineCache, uint32_t, ++ const VkGraphicsPipelineCreateInfo_host *, const VkAllocationCallbacks_host *, ++ VkPipeline * ) = null_vkCreateGraphicsPipelines; ++VkResult (*p_vkCreateImage)( VkDevice, const VkImageCreateInfo *, ++ const VkAllocationCallbacks_host *, VkImage * ) = null_vkCreateImage; ++VkResult (*p_vkCreateImageView)( VkDevice, const VkImageViewCreateInfo_host *, ++ const VkAllocationCallbacks_host *, VkImageView * ) = null_vkCreateImageView; ++VkResult (*p_vkCreateInstance)( const VkInstanceCreateInfo *, const VkAllocationCallbacks_host *, ++ VkInstance * ) = null_vkCreateInstance; ++VkResult (*p_vkCreatePipelineCache)( VkDevice, const VkPipelineCacheCreateInfo *, ++ const VkAllocationCallbacks_host *, VkPipelineCache * ) = null_vkCreatePipelineCache; ++VkResult (*p_vkCreatePipelineLayout)( VkDevice, const VkPipelineLayoutCreateInfo *, ++ const VkAllocationCallbacks_host *, VkPipelineLayout * ) = null_vkCreatePipelineLayout; ++VkResult (*p_vkCreateQueryPool)( VkDevice, const VkQueryPoolCreateInfo *, ++ const VkAllocationCallbacks_host *, VkQueryPool * ) = null_vkCreateQueryPool; ++VkResult (*p_vkCreateRenderPass)( VkDevice, const VkRenderPassCreateInfo *, ++ const VkAllocationCallbacks_host *, VkRenderPass * ) = null_vkCreateRenderPass; ++VkResult (*p_vkCreateSampler)( VkDevice, const VkSamplerCreateInfo *, ++ const VkAllocationCallbacks_host *, VkSampler * ) = null_vkCreateSampler; ++VkResult (*p_vkCreateSemaphore)( VkDevice, const VkSemaphoreCreateInfo *, ++ const VkAllocationCallbacks_host *, VkSemaphore * ) = null_vkCreateSemaphore; ++VkResult (*p_vkCreateShaderModule)( VkDevice, const VkShaderModuleCreateInfo *, ++ const VkAllocationCallbacks_host *, VkShaderModule * ) = null_vkCreateShaderModule; ++VkResult (*p_vkCreateSharedSwapchainsKHR)( VkDevice, uint32_t, ++ const VkSwapchainCreateInfoKHR_host *, const VkAllocationCallbacks_host *, ++ VkSwapchainKHR * ) = null_vkCreateSharedSwapchainsKHR; ++VkResult (*p_vkCreateSwapchainKHR)( VkDevice, const VkSwapchainCreateInfoKHR_host *, ++ const VkAllocationCallbacks_host *, VkSwapchainKHR * ) = null_vkCreateSwapchainKHR; ++VkResult (*p_vkCreateXcbSurfaceKHR)( VkInstance, const VkXcbSurfaceCreateInfoKHR_host *, ++ const VkAllocationCallbacks_host *, VkSurfaceKHR * ) = null_vkCreateXcbSurfaceKHR; ++VkResult (*p_vkCreateXlibSurfaceKHR)( VkInstance, const VkXlibSurfaceCreateInfoKHR_host *, ++ const VkAllocationCallbacks_host *, VkSurfaceKHR * ) = null_vkCreateXlibSurfaceKHR; ++void (*p_vkDebugReportMessageEXT)( VkInstance, VkDebugReportFlagsEXT, VkDebugReportObjectTypeEXT, ++ uint64_t, size_t, int32_t, const char *, const char * ) = null_vkDebugReportMessageEXT; ++void (*p_vkDestroyBuffer)( VkDevice, VkBuffer, const VkAllocationCallbacks_host * ) = ++ null_vkDestroyBuffer; ++void (*p_vkDestroyBufferView)( VkDevice, VkBufferView, const VkAllocationCallbacks_host * ) = ++ null_vkDestroyBufferView; ++void (*p_vkDestroyCommandPool)( VkDevice, VkCommandPool, const VkAllocationCallbacks_host * ) = ++ null_vkDestroyCommandPool; ++void (*p_vkDestroyDebugReportCallbackEXT)( VkInstance, VkDebugReportCallbackEXT, ++ const VkAllocationCallbacks_host * ) = null_vkDestroyDebugReportCallbackEXT; ++void (*p_vkDestroyDescriptorPool)( VkDevice, VkDescriptorPool, ++ const VkAllocationCallbacks_host * ) = null_vkDestroyDescriptorPool; ++void (*p_vkDestroyDescriptorSetLayout)( VkDevice, VkDescriptorSetLayout, ++ const VkAllocationCallbacks_host * ) = null_vkDestroyDescriptorSetLayout; ++void (*p_vkDestroyDevice)( VkDevice, const VkAllocationCallbacks_host * ) = null_vkDestroyDevice; ++void (*p_vkDestroyEvent)( VkDevice, VkEvent, const VkAllocationCallbacks_host * ) = ++ null_vkDestroyEvent; ++void (*p_vkDestroyFence)( VkDevice, VkFence, const VkAllocationCallbacks_host * ) = ++ null_vkDestroyFence; ++void (*p_vkDestroyFramebuffer)( VkDevice, VkFramebuffer, const VkAllocationCallbacks_host * ) = ++ null_vkDestroyFramebuffer; ++void (*p_vkDestroyImage)( VkDevice, VkImage, const VkAllocationCallbacks_host * ) = ++ null_vkDestroyImage; ++void (*p_vkDestroyImageView)( VkDevice, VkImageView, const VkAllocationCallbacks_host * ) = ++ null_vkDestroyImageView; ++void (*p_vkDestroyInstance)( VkInstance, const VkAllocationCallbacks_host * ) = ++ null_vkDestroyInstance; ++void (*p_vkDestroyPipeline)( VkDevice, VkPipeline, const VkAllocationCallbacks_host * ) = ++ null_vkDestroyPipeline; ++void (*p_vkDestroyPipelineCache)( VkDevice, VkPipelineCache, const VkAllocationCallbacks_host * ) = ++ null_vkDestroyPipelineCache; ++void (*p_vkDestroyPipelineLayout)( VkDevice, VkPipelineLayout, ++ const VkAllocationCallbacks_host * ) = null_vkDestroyPipelineLayout; ++void (*p_vkDestroyQueryPool)( VkDevice, VkQueryPool, const VkAllocationCallbacks_host * ) = ++ null_vkDestroyQueryPool; ++void (*p_vkDestroyRenderPass)( VkDevice, VkRenderPass, const VkAllocationCallbacks_host * ) = ++ null_vkDestroyRenderPass; ++void (*p_vkDestroySampler)( VkDevice, VkSampler, const VkAllocationCallbacks_host * ) = ++ null_vkDestroySampler; ++void (*p_vkDestroySemaphore)( VkDevice, VkSemaphore, const VkAllocationCallbacks_host * ) = ++ null_vkDestroySemaphore; ++void (*p_vkDestroyShaderModule)( VkDevice, VkShaderModule, const VkAllocationCallbacks_host * ) = ++ null_vkDestroyShaderModule; ++void (*p_vkDestroySurfaceKHR)( VkInstance, VkSurfaceKHR, const VkAllocationCallbacks_host * ) = ++ null_vkDestroySurfaceKHR; ++void (*p_vkDestroySwapchainKHR)( VkDevice, VkSwapchainKHR, const VkAllocationCallbacks_host * ) = ++ null_vkDestroySwapchainKHR; ++VkResult (*p_vkDeviceWaitIdle)( VkDevice ) = null_vkDeviceWaitIdle; ++VkResult (*p_vkEndCommandBuffer)( VkCommandBuffer ) = null_vkEndCommandBuffer; ++VkResult (*p_vkEnumerateDeviceExtensionProperties)( VkPhysicalDevice, const char *, uint32_t *, ++ VkExtensionProperties * ) = null_vkEnumerateDeviceExtensionProperties; ++VkResult (*p_vkEnumerateDeviceLayerProperties)( VkPhysicalDevice, uint32_t *, ++ VkLayerProperties * ) = null_vkEnumerateDeviceLayerProperties; ++VkResult (*p_vkEnumerateInstanceExtensionProperties)( const char *, uint32_t *, ++ VkExtensionProperties * ) = null_vkEnumerateInstanceExtensionProperties; ++VkResult (*p_vkEnumerateInstanceLayerProperties)( uint32_t *, VkLayerProperties * ) = ++ null_vkEnumerateInstanceLayerProperties; ++VkResult (*p_vkEnumeratePhysicalDevices)( VkInstance, uint32_t *, VkPhysicalDevice * ) = ++ null_vkEnumeratePhysicalDevices; ++VkResult (*p_vkFlushMappedMemoryRanges)( VkDevice, uint32_t, const VkMappedMemoryRange * ) = ++ null_vkFlushMappedMemoryRanges; ++void (*p_vkFreeCommandBuffers)( VkDevice, VkCommandPool, uint32_t, const VkCommandBuffer * ) = ++ null_vkFreeCommandBuffers; ++VkResult (*p_vkFreeDescriptorSets)( VkDevice, VkDescriptorPool, uint32_t, ++ const VkDescriptorSet * ) = null_vkFreeDescriptorSets; ++void (*p_vkFreeMemory)( VkDevice, VkDeviceMemory, const VkAllocationCallbacks_host * ) = ++ null_vkFreeMemory; ++void (*p_vkGetBufferMemoryRequirements)( VkDevice, VkBuffer, VkMemoryRequirements * ) = ++ null_vkGetBufferMemoryRequirements; ++void (*p_vkGetDeviceMemoryCommitment)( VkDevice, VkDeviceMemory, VkDeviceSize * ) = ++ null_vkGetDeviceMemoryCommitment; ++PFN_vkVoidFunction_host (*p_vkGetDeviceProcAddr)( VkDevice, const char * ) = ++ null_vkGetDeviceProcAddr; ++void (*p_vkGetDeviceQueue)( VkDevice, uint32_t, uint32_t, VkQueue * ) = null_vkGetDeviceQueue; ++VkResult (*p_vkGetDisplayModePropertiesKHR)( VkPhysicalDevice, VkDisplayKHR, uint32_t *, ++ VkDisplayModePropertiesKHR_host * ) = null_vkGetDisplayModePropertiesKHR; ++VkResult (*p_vkGetDisplayPlaneCapabilitiesKHR)( VkPhysicalDevice, VkDisplayModeKHR, uint32_t, ++ VkDisplayPlaneCapabilitiesKHR * ) = null_vkGetDisplayPlaneCapabilitiesKHR; ++VkResult (*p_vkGetDisplayPlaneSupportedDisplaysKHR)( VkPhysicalDevice, uint32_t, uint32_t *, ++ VkDisplayKHR * ) = null_vkGetDisplayPlaneSupportedDisplaysKHR; ++VkResult (*p_vkGetEventStatus)( VkDevice, VkEvent ) = null_vkGetEventStatus; ++VkResult (*p_vkGetFenceStatus)( VkDevice, VkFence ) = null_vkGetFenceStatus; ++void (*p_vkGetImageMemoryRequirements)( VkDevice, VkImage, VkMemoryRequirements * ) = ++ null_vkGetImageMemoryRequirements; ++void (*p_vkGetImageSparseMemoryRequirements)( VkDevice, VkImage, uint32_t *, ++ VkSparseImageMemoryRequirements * ) = null_vkGetImageSparseMemoryRequirements; ++void (*p_vkGetImageSubresourceLayout)( VkDevice, VkImage, const VkImageSubresource *, ++ VkSubresourceLayout * ) = null_vkGetImageSubresourceLayout; ++PFN_vkVoidFunction_host (*p_vkGetInstanceProcAddr)( VkInstance, const char * ) = ++ null_vkGetInstanceProcAddr; ++VkResult (*p_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)( VkPhysicalDevice, uint32_t *, ++ VkDisplayPlanePropertiesKHR_host * ) = null_vkGetPhysicalDeviceDisplayPlanePropertiesKHR; ++VkResult (*p_vkGetPhysicalDeviceDisplayPropertiesKHR)( VkPhysicalDevice, uint32_t *, ++ VkDisplayPropertiesKHR * ) = null_vkGetPhysicalDeviceDisplayPropertiesKHR; ++void (*p_vkGetPhysicalDeviceFeatures)( VkPhysicalDevice, VkPhysicalDeviceFeatures * ) = ++ null_vkGetPhysicalDeviceFeatures; ++void (*p_vkGetPhysicalDeviceFormatProperties)( VkPhysicalDevice, VkFormat, VkFormatProperties * ) = ++ null_vkGetPhysicalDeviceFormatProperties; ++VkResult (*p_vkGetPhysicalDeviceImageFormatProperties)( VkPhysicalDevice, VkFormat, VkImageType, ++ VkImageTiling, VkImageUsageFlags, VkImageCreateFlags, VkImageFormatProperties * ) = ++ null_vkGetPhysicalDeviceImageFormatProperties; ++void (*p_vkGetPhysicalDeviceMemoryProperties)( VkPhysicalDevice, ++ VkPhysicalDeviceMemoryProperties_host * ) = null_vkGetPhysicalDeviceMemoryProperties; ++void (*p_vkGetPhysicalDeviceProperties)( VkPhysicalDevice, VkPhysicalDeviceProperties_host * ) = ++ null_vkGetPhysicalDeviceProperties; ++void (*p_vkGetPhysicalDeviceQueueFamilyProperties)( VkPhysicalDevice, uint32_t *, ++ VkQueueFamilyProperties * ) = null_vkGetPhysicalDeviceQueueFamilyProperties; ++void (*p_vkGetPhysicalDeviceSparseImageFormatProperties)( VkPhysicalDevice, VkFormat, VkImageType, ++ VkSampleCountFlagBits, VkImageUsageFlags, VkImageTiling, uint32_t *, ++ VkSparseImageFormatProperties * ) = null_vkGetPhysicalDeviceSparseImageFormatProperties; ++VkResult (*p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)( VkPhysicalDevice, VkSurfaceKHR, ++ VkSurfaceCapabilitiesKHR * ) = null_vkGetPhysicalDeviceSurfaceCapabilitiesKHR; ++VkResult (*p_vkGetPhysicalDeviceSurfaceFormatsKHR)( VkPhysicalDevice, VkSurfaceKHR, uint32_t *, ++ VkSurfaceFormatKHR * ) = null_vkGetPhysicalDeviceSurfaceFormatsKHR; ++VkResult (*p_vkGetPhysicalDeviceSurfacePresentModesKHR)( VkPhysicalDevice, VkSurfaceKHR, ++ uint32_t *, VkPresentModeKHR * ) = null_vkGetPhysicalDeviceSurfacePresentModesKHR; ++VkResult (*p_vkGetPhysicalDeviceSurfaceSupportKHR)( VkPhysicalDevice, uint32_t, VkSurfaceKHR, ++ VkBool32 * ) = null_vkGetPhysicalDeviceSurfaceSupportKHR; ++VkResult (*p_vkGetPipelineCacheData)( VkDevice, VkPipelineCache, size_t *, void * ) = ++ null_vkGetPipelineCacheData; ++VkResult (*p_vkGetQueryPoolResults)( VkDevice, VkQueryPool, uint32_t, uint32_t, size_t, void *, ++ VkDeviceSize, VkQueryResultFlags ) = null_vkGetQueryPoolResults; ++void (*p_vkGetRenderAreaGranularity)( VkDevice, VkRenderPass, VkExtent2D * ) = ++ null_vkGetRenderAreaGranularity; ++VkResult (*p_vkGetSwapchainImagesKHR)( VkDevice, VkSwapchainKHR, uint32_t *, VkImage * ) = ++ null_vkGetSwapchainImagesKHR; ++VkResult (*p_vkInvalidateMappedMemoryRanges)( VkDevice, uint32_t, const VkMappedMemoryRange * ) = ++ null_vkInvalidateMappedMemoryRanges; ++VkResult (*p_vkMapMemory)( VkDevice, VkDeviceMemory, VkDeviceSize, VkDeviceSize, VkMemoryMapFlags, ++ void ** ) = null_vkMapMemory; ++VkResult (*p_vkMergePipelineCaches)( VkDevice, VkPipelineCache, uint32_t, ++ const VkPipelineCache * ) = null_vkMergePipelineCaches; ++VkResult (*p_vkQueueBindSparse)( VkQueue, uint32_t, const VkBindSparseInfo_host *, VkFence ) = ++ null_vkQueueBindSparse; ++VkResult (*p_vkQueuePresentKHR)( VkQueue, const VkPresentInfoKHR * ) = null_vkQueuePresentKHR; ++VkResult (*p_vkQueueSubmit)( VkQueue, uint32_t, const VkSubmitInfo *, VkFence ) = ++ null_vkQueueSubmit; ++VkResult (*p_vkQueueWaitIdle)( VkQueue ) = null_vkQueueWaitIdle; ++VkResult (*p_vkResetCommandBuffer)( VkCommandBuffer, VkCommandBufferResetFlags ) = ++ null_vkResetCommandBuffer; ++VkResult (*p_vkResetCommandPool)( VkDevice, VkCommandPool, VkCommandPoolResetFlags ) = ++ null_vkResetCommandPool; ++VkResult (*p_vkResetDescriptorPool)( VkDevice, VkDescriptorPool, VkDescriptorPoolResetFlags ) = ++ null_vkResetDescriptorPool; ++VkResult (*p_vkResetEvent)( VkDevice, VkEvent ) = null_vkResetEvent; ++VkResult (*p_vkResetFences)( VkDevice, uint32_t, const VkFence * ) = null_vkResetFences; ++VkResult (*p_vkSetEvent)( VkDevice, VkEvent ) = null_vkSetEvent; ++void (*p_vkUnmapMemory)( VkDevice, VkDeviceMemory ) = null_vkUnmapMemory; ++void (*p_vkUpdateDescriptorSets)( VkDevice, uint32_t, const VkWriteDescriptorSet_host *, uint32_t, ++ const VkCopyDescriptorSet_host * ) = null_vkUpdateDescriptorSets; ++VkResult (*p_vkWaitForFences)( VkDevice, uint32_t, const VkFence *, VkBool32, uint64_t ) = ++ null_vkWaitForFences; ++ ++/*********************************************************************** ++ * vkAcquireNextImageKHR (VULKAN.@) ++ */ ++VkResult WINAPI vkAcquireNextImageKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, ++ VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex ) ++{ ++ TRACE( "(%p, %s, %s, %s, %s, %p)\n", device, wine_dbgstr_longlong(swapchain), ++ wine_dbgstr_longlong(timeout), wine_dbgstr_longlong(semaphore), ++ wine_dbgstr_longlong(fence), pImageIndex ); ++ return p_vkAcquireNextImageKHR( device, swapchain, timeout, semaphore, fence, pImageIndex ); ++} ++ ++/*********************************************************************** ++ * vkAllocateCommandBuffers (VULKAN.@) ++ */ ++VkResult WINAPI vkAllocateCommandBuffers( VkDevice device, ++ const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers ) ++{ ++ TRACE( "(%p, %p, %p)\n", device, pAllocateInfo, pCommandBuffers ); ++ return p_vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers ); ++} ++ ++/*********************************************************************** ++ * vkAllocateDescriptorSets (VULKAN.@) ++ */ ++VkResult WINAPI vkAllocateDescriptorSets( VkDevice device, ++ const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets ) ++{ ++ TRACE( "(%p, %p, %p)\n", device, pAllocateInfo, pDescriptorSets ); ++ return p_vkAllocateDescriptorSets( device, pAllocateInfo, pDescriptorSets ); ++} ++ ++/*********************************************************************** ++ * vkAllocateMemory (VULKAN.@) ++ */ ++VkResult WINAPI vkAllocateMemory( VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, ++ const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %p, %p, %p)\n", device, pAllocateInfo, pAllocator, pMemory ); ++ ++ /* conversion of pAllocateInfo not necessary, offsets match */ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkAllocateMemory( device, pAllocateInfo, ptr_pAllocator, pMemory ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkBeginCommandBuffer (VULKAN.@) ++ */ ++VkResult WINAPI vkBeginCommandBuffer( VkCommandBuffer commandBuffer, ++ const VkCommandBufferBeginInfo *pBeginInfo ) ++{ ++ VkCommandBufferBeginInfo_host tmp_pBeginInfo, *ptr_pBeginInfo; ++ VkResult res; ++ ++ TRACE( "(%p, %p)\n", commandBuffer, pBeginInfo ); ++ ++ ptr_pBeginInfo = convert_VkCommandBufferBeginInfo( &tmp_pBeginInfo, pBeginInfo ); ++ res = p_vkBeginCommandBuffer( commandBuffer, ptr_pBeginInfo ); ++ release_VkCommandBufferBeginInfo( NULL, ptr_pBeginInfo ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkBindBufferMemory (VULKAN.@) ++ */ ++VkResult WINAPI vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, ++ VkDeviceSize memoryOffset ) ++{ ++ TRACE( "(%p, %s, %s, %s)\n", device, wine_dbgstr_longlong(buffer), ++ wine_dbgstr_longlong(memory), wine_dbgstr_longlong(memoryOffset) ); ++ return p_vkBindBufferMemory( device, buffer, memory, memoryOffset ); ++} ++ ++/*********************************************************************** ++ * vkBindImageMemory (VULKAN.@) ++ */ ++VkResult WINAPI vkBindImageMemory( VkDevice device, VkImage image, VkDeviceMemory memory, ++ VkDeviceSize memoryOffset ) ++{ ++ TRACE( "(%p, %s, %s, %s)\n", device, wine_dbgstr_longlong(image), wine_dbgstr_longlong(memory), ++ wine_dbgstr_longlong(memoryOffset) ); ++ return p_vkBindImageMemory( device, image, memory, memoryOffset ); ++} ++ ++/*********************************************************************** ++ * vkCmdBeginQuery (VULKAN.@) ++ */ ++void WINAPI vkCmdBeginQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, ++ VkQueryControlFlags flags ) ++{ ++ TRACE( "(%p, %s, %u, %u)\n", commandBuffer, wine_dbgstr_longlong(queryPool), query, flags ); ++ p_vkCmdBeginQuery( commandBuffer, queryPool, query, flags ); ++} ++ ++/*********************************************************************** ++ * vkCmdBeginRenderPass (VULKAN.@) ++ */ ++void WINAPI vkCmdBeginRenderPass( VkCommandBuffer commandBuffer, ++ const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents ) ++{ ++ TRACE( "(%p, %p, %d)\n", commandBuffer, pRenderPassBegin, contents ); ++ p_vkCmdBeginRenderPass( commandBuffer, pRenderPassBegin, contents ); ++} ++ ++/*********************************************************************** ++ * vkCmdBindDescriptorSets (VULKAN.@) ++ */ ++void WINAPI vkCmdBindDescriptorSets( VkCommandBuffer commandBuffer, ++ VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, ++ uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, ++ uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets ) ++{ ++ TRACE( "(%p, %d, %s, %u, %u, %p, %u, %p)\n", commandBuffer, pipelineBindPoint, ++ wine_dbgstr_longlong(layout), firstSet, descriptorSetCount, pDescriptorSets, ++ dynamicOffsetCount, pDynamicOffsets ); ++ p_vkCmdBindDescriptorSets( commandBuffer, pipelineBindPoint, layout, firstSet, ++ descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets ); ++} ++ ++/*********************************************************************** ++ * vkCmdBindIndexBuffer (VULKAN.@) ++ */ ++void WINAPI vkCmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer buffer, ++ VkDeviceSize offset, VkIndexType indexType ) ++{ ++ TRACE( "(%p, %s, %s, %d)\n", commandBuffer, wine_dbgstr_longlong(buffer), ++ wine_dbgstr_longlong(offset), indexType ); ++ p_vkCmdBindIndexBuffer( commandBuffer, buffer, offset, indexType ); ++} ++ ++/*********************************************************************** ++ * vkCmdBindPipeline (VULKAN.@) ++ */ ++void WINAPI vkCmdBindPipeline( VkCommandBuffer commandBuffer, ++ VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline ) ++{ ++ TRACE( "(%p, %d, %s)\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(pipeline) ); ++ p_vkCmdBindPipeline( commandBuffer, pipelineBindPoint, pipeline ); ++} ++ ++/*********************************************************************** ++ * vkCmdBindVertexBuffers (VULKAN.@) ++ */ ++void WINAPI vkCmdBindVertexBuffers( VkCommandBuffer commandBuffer, uint32_t firstBinding, ++ uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets ) ++{ ++ TRACE( "(%p, %u, %u, %p, %p)\n", commandBuffer, firstBinding, bindingCount, pBuffers, ++ pOffsets ); ++ p_vkCmdBindVertexBuffers( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets ); ++} ++ ++/*********************************************************************** ++ * vkCmdBlitImage (VULKAN.@) ++ */ ++void WINAPI vkCmdBlitImage( VkCommandBuffer commandBuffer, VkImage srcImage, ++ VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, ++ uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter ) ++{ ++ TRACE( "(%p, %s, %d, %s, %d, %u, %p, %d)\n", commandBuffer, wine_dbgstr_longlong(srcImage), ++ srcImageLayout, wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions, ++ filter ); ++ p_vkCmdBlitImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, ++ regionCount, pRegions, filter ); ++} ++ ++/*********************************************************************** ++ * vkCmdClearAttachments (VULKAN.@) ++ */ ++void WINAPI vkCmdClearAttachments( VkCommandBuffer commandBuffer, uint32_t attachmentCount, ++ const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects ) ++{ ++ TRACE( "(%p, %u, %p, %u, %p)\n", commandBuffer, attachmentCount, pAttachments, rectCount, ++ pRects ); ++ p_vkCmdClearAttachments( commandBuffer, attachmentCount, pAttachments, rectCount, pRects ); ++} ++ ++/*********************************************************************** ++ * vkCmdClearColorImage (VULKAN.@) ++ */ ++void WINAPI vkCmdClearColorImage( VkCommandBuffer commandBuffer, VkImage image, ++ VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, ++ const VkImageSubresourceRange *pRanges ) ++{ ++ TRACE( "(%p, %s, %d, %p, %u, %p)\n", commandBuffer, wine_dbgstr_longlong(image), imageLayout, ++ pColor, rangeCount, pRanges ); ++ p_vkCmdClearColorImage( commandBuffer, image, imageLayout, pColor, rangeCount, pRanges ); ++} ++ ++/*********************************************************************** ++ * vkCmdClearDepthStencilImage (VULKAN.@) ++ */ ++void WINAPI vkCmdClearDepthStencilImage( VkCommandBuffer commandBuffer, VkImage image, ++ VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, ++ uint32_t rangeCount, const VkImageSubresourceRange *pRanges ) ++{ ++ TRACE( "(%p, %s, %d, %p, %u, %p)\n", commandBuffer, wine_dbgstr_longlong(image), imageLayout, ++ pDepthStencil, rangeCount, pRanges ); ++ p_vkCmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, ++ pRanges ); ++} ++ ++/*********************************************************************** ++ * vkCmdCopyBuffer (VULKAN.@) ++ */ ++void WINAPI vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, ++ uint32_t regionCount, const VkBufferCopy *pRegions ) ++{ ++ TRACE( "(%p, %s, %s, %u, %p)\n", commandBuffer, wine_dbgstr_longlong(srcBuffer), ++ wine_dbgstr_longlong(dstBuffer), regionCount, pRegions ); ++ p_vkCmdCopyBuffer( commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions ); ++} ++ ++/*********************************************************************** ++ * vkCmdCopyBufferToImage (VULKAN.@) ++ */ ++void WINAPI vkCmdCopyBufferToImage( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, ++ VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, ++ const VkBufferImageCopy *pRegions ) ++{ ++ TRACE( "(%p, %s, %s, %d, %u, %p)\n", commandBuffer, wine_dbgstr_longlong(srcBuffer), ++ wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions ); ++ p_vkCmdCopyBufferToImage( commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, ++ pRegions ); ++} ++ ++/*********************************************************************** ++ * vkCmdCopyImage (VULKAN.@) ++ */ ++void WINAPI vkCmdCopyImage( VkCommandBuffer commandBuffer, VkImage srcImage, ++ VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, ++ uint32_t regionCount, const VkImageCopy *pRegions ) ++{ ++ TRACE( "(%p, %s, %d, %s, %d, %u, %p)\n", commandBuffer, wine_dbgstr_longlong(srcImage), ++ srcImageLayout, wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions ); ++ p_vkCmdCopyImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, ++ regionCount, pRegions ); ++} ++ ++/*********************************************************************** ++ * vkCmdCopyImageToBuffer (VULKAN.@) ++ */ ++void WINAPI vkCmdCopyImageToBuffer( VkCommandBuffer commandBuffer, VkImage srcImage, ++ VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, ++ const VkBufferImageCopy *pRegions ) ++{ ++ TRACE( "(%p, %s, %d, %s, %u, %p)\n", commandBuffer, wine_dbgstr_longlong(srcImage), ++ srcImageLayout, wine_dbgstr_longlong(dstBuffer), regionCount, pRegions ); ++ p_vkCmdCopyImageToBuffer( commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, ++ pRegions ); ++} ++ ++/*********************************************************************** ++ * vkCmdCopyQueryPoolResults (VULKAN.@) ++ */ ++void WINAPI vkCmdCopyQueryPoolResults( VkCommandBuffer commandBuffer, VkQueryPool queryPool, ++ uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, ++ VkDeviceSize stride, VkQueryResultFlags flags ) ++{ ++ TRACE( "(%p, %s, %u, %u, %s, %s, %s, %u)\n", commandBuffer, wine_dbgstr_longlong(queryPool), ++ firstQuery, queryCount, wine_dbgstr_longlong(dstBuffer), ++ wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(stride), flags ); ++ p_vkCmdCopyQueryPoolResults( commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, ++ dstOffset, stride, flags ); ++} ++ ++/*********************************************************************** ++ * vkCmdDispatch (VULKAN.@) ++ */ ++void WINAPI vkCmdDispatch( VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z ) ++{ ++ TRACE( "(%p, %u, %u, %u)\n", commandBuffer, x, y, z ); ++ p_vkCmdDispatch( commandBuffer, x, y, z ); ++} ++ ++/*********************************************************************** ++ * vkCmdDispatchIndirect (VULKAN.@) ++ */ ++void WINAPI vkCmdDispatchIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, ++ VkDeviceSize offset ) ++{ ++ TRACE( "(%p, %s, %s)\n", commandBuffer, wine_dbgstr_longlong(buffer), ++ wine_dbgstr_longlong(offset) ); ++ p_vkCmdDispatchIndirect( commandBuffer, buffer, offset ); ++} ++ ++/*********************************************************************** ++ * vkCmdDraw (VULKAN.@) ++ */ ++void WINAPI vkCmdDraw( VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, ++ uint32_t firstVertex, uint32_t firstInstance ) ++{ ++ TRACE( "(%p, %u, %u, %u, %u)\n", commandBuffer, vertexCount, instanceCount, firstVertex, ++ firstInstance ); ++ p_vkCmdDraw( commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance ); ++} ++ ++/*********************************************************************** ++ * vkCmdDrawIndexed (VULKAN.@) ++ */ ++void WINAPI vkCmdDrawIndexed( VkCommandBuffer commandBuffer, uint32_t indexCount, ++ uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) ++{ ++ TRACE( "(%p, %u, %u, %u, %d, %u)\n", commandBuffer, indexCount, instanceCount, firstIndex, ++ vertexOffset, firstInstance ); ++ p_vkCmdDrawIndexed( commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, ++ firstInstance ); ++} ++ ++/*********************************************************************** ++ * vkCmdDrawIndexedIndirect (VULKAN.@) ++ */ ++void WINAPI vkCmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, ++ VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) ++{ ++ TRACE( "(%p, %s, %s, %u, %u)\n", commandBuffer, wine_dbgstr_longlong(buffer), ++ wine_dbgstr_longlong(offset), drawCount, stride ); ++ p_vkCmdDrawIndexedIndirect( commandBuffer, buffer, offset, drawCount, stride ); ++} ++ ++/*********************************************************************** ++ * vkCmdDrawIndirect (VULKAN.@) ++ */ ++void WINAPI vkCmdDrawIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, ++ uint32_t drawCount, uint32_t stride ) ++{ ++ TRACE( "(%p, %s, %s, %u, %u)\n", commandBuffer, wine_dbgstr_longlong(buffer), ++ wine_dbgstr_longlong(offset), drawCount, stride ); ++ p_vkCmdDrawIndirect( commandBuffer, buffer, offset, drawCount, stride ); ++} ++ ++/*********************************************************************** ++ * vkCmdEndQuery (VULKAN.@) ++ */ ++void WINAPI vkCmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query ) ++{ ++ TRACE( "(%p, %s, %u)\n", commandBuffer, wine_dbgstr_longlong(queryPool), query ); ++ p_vkCmdEndQuery( commandBuffer, queryPool, query ); ++} ++ ++/*********************************************************************** ++ * vkCmdEndRenderPass (VULKAN.@) ++ */ ++void WINAPI vkCmdEndRenderPass( VkCommandBuffer commandBuffer ) ++{ ++ TRACE( "(%p)\n", commandBuffer ); ++ p_vkCmdEndRenderPass( commandBuffer ); ++} ++ ++/*********************************************************************** ++ * vkCmdExecuteCommands (VULKAN.@) ++ */ ++void WINAPI vkCmdExecuteCommands( VkCommandBuffer commandBuffer, uint32_t commandBufferCount, ++ const VkCommandBuffer *pCommandBuffers ) ++{ ++ TRACE( "(%p, %u, %p)\n", commandBuffer, commandBufferCount, pCommandBuffers ); ++ p_vkCmdExecuteCommands( commandBuffer, commandBufferCount, pCommandBuffers ); ++} ++ ++/*********************************************************************** ++ * vkCmdFillBuffer (VULKAN.@) ++ */ ++void WINAPI vkCmdFillBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, ++ VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data ) ++{ ++ TRACE( "(%p, %s, %s, %s, %u)\n", commandBuffer, wine_dbgstr_longlong(dstBuffer), ++ wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(size), data ); ++ p_vkCmdFillBuffer( commandBuffer, dstBuffer, dstOffset, size, data ); ++} ++ ++/*********************************************************************** ++ * vkCmdNextSubpass (VULKAN.@) ++ */ ++void WINAPI vkCmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents ) ++{ ++ TRACE( "(%p, %d)\n", commandBuffer, contents ); ++ p_vkCmdNextSubpass( commandBuffer, contents ); ++} ++ ++/*********************************************************************** ++ * vkCmdPipelineBarrier (VULKAN.@) ++ */ ++void WINAPI 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 ) ++{ ++ VkImageMemoryBarrier_host *ptr_pImageMemoryBarriers; ++ ++ TRACE( "(%p, %u, %u, %u, %u, %p, %u, %p, %u, %p)\n", commandBuffer, srcStageMask, dstStageMask, ++ dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, ++ pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers ); ++ ++ ptr_pImageMemoryBarriers = convert_VkImageMemoryBarrier_array( pImageMemoryBarriers, ++ imageMemoryBarrierCount ); ++ p_vkCmdPipelineBarrier( commandBuffer, srcStageMask, dstStageMask, dependencyFlags, ++ memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, ++ imageMemoryBarrierCount, ptr_pImageMemoryBarriers ); ++ release_VkImageMemoryBarrier_array( NULL, ptr_pImageMemoryBarriers, imageMemoryBarrierCount ); ++} ++ ++/*********************************************************************** ++ * vkCmdPushConstants (VULKAN.@) ++ */ ++void WINAPI vkCmdPushConstants( VkCommandBuffer commandBuffer, VkPipelineLayout layout, ++ VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues ) ++{ ++ TRACE( "(%p, %s, %u, %u, %u, %p)\n", commandBuffer, wine_dbgstr_longlong(layout), stageFlags, ++ offset, size, pValues ); ++ p_vkCmdPushConstants( commandBuffer, layout, stageFlags, offset, size, pValues ); ++} ++ ++/*********************************************************************** ++ * vkCmdResetEvent (VULKAN.@) ++ */ ++void WINAPI vkCmdResetEvent( VkCommandBuffer commandBuffer, VkEvent event, ++ VkPipelineStageFlags stageMask ) ++{ ++ TRACE( "(%p, %s, %u)\n", commandBuffer, wine_dbgstr_longlong(event), stageMask ); ++ p_vkCmdResetEvent( commandBuffer, event, stageMask ); ++} ++ ++/*********************************************************************** ++ * vkCmdResetQueryPool (VULKAN.@) ++ */ ++void WINAPI vkCmdResetQueryPool( VkCommandBuffer commandBuffer, VkQueryPool queryPool, ++ uint32_t firstQuery, uint32_t queryCount ) ++{ ++ TRACE( "(%p, %s, %u, %u)\n", commandBuffer, wine_dbgstr_longlong(queryPool), firstQuery, ++ queryCount ); ++ p_vkCmdResetQueryPool( commandBuffer, queryPool, firstQuery, queryCount ); ++} ++ ++/*********************************************************************** ++ * vkCmdResolveImage (VULKAN.@) ++ */ ++void WINAPI vkCmdResolveImage( VkCommandBuffer commandBuffer, VkImage srcImage, ++ VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, ++ uint32_t regionCount, const VkImageResolve *pRegions ) ++{ ++ TRACE( "(%p, %s, %d, %s, %d, %u, %p)\n", commandBuffer, wine_dbgstr_longlong(srcImage), ++ srcImageLayout, wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions ); ++ p_vkCmdResolveImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, ++ regionCount, pRegions ); ++} ++ ++/*********************************************************************** ++ * vkCmdSetBlendConstants (VULKAN.@) ++ */ ++void WINAPI vkCmdSetBlendConstants( VkCommandBuffer commandBuffer, const float blendConstants[4] ) ++{ ++ TRACE( "(%p, %p)\n", commandBuffer, blendConstants ); ++ p_vkCmdSetBlendConstants( commandBuffer, blendConstants ); ++} ++ ++/*********************************************************************** ++ * vkCmdSetDepthBias (VULKAN.@) ++ */ ++void WINAPI vkCmdSetDepthBias( VkCommandBuffer commandBuffer, float depthBiasConstantFactor, ++ float depthBiasClamp, float depthBiasSlopeFactor ) ++{ ++ TRACE( "(%p, %f, %f, %f)\n", commandBuffer, depthBiasConstantFactor, depthBiasClamp, ++ depthBiasSlopeFactor ); ++ p_vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, ++ depthBiasSlopeFactor ); ++} ++ ++/*********************************************************************** ++ * vkCmdSetDepthBounds (VULKAN.@) ++ */ ++void WINAPI vkCmdSetDepthBounds( VkCommandBuffer commandBuffer, float minDepthBounds, ++ float maxDepthBounds ) ++{ ++ TRACE( "(%p, %f, %f)\n", commandBuffer, minDepthBounds, maxDepthBounds ); ++ p_vkCmdSetDepthBounds( commandBuffer, minDepthBounds, maxDepthBounds ); ++} ++ ++/*********************************************************************** ++ * vkCmdSetEvent (VULKAN.@) ++ */ ++void WINAPI vkCmdSetEvent( VkCommandBuffer commandBuffer, VkEvent event, ++ VkPipelineStageFlags stageMask ) ++{ ++ TRACE( "(%p, %s, %u)\n", commandBuffer, wine_dbgstr_longlong(event), stageMask ); ++ p_vkCmdSetEvent( commandBuffer, event, stageMask ); ++} ++ ++/*********************************************************************** ++ * vkCmdSetLineWidth (VULKAN.@) ++ */ ++void WINAPI vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth ) ++{ ++ TRACE( "(%p, %f)\n", commandBuffer, lineWidth ); ++ p_vkCmdSetLineWidth( commandBuffer, lineWidth ); ++} ++ ++/*********************************************************************** ++ * vkCmdSetScissor (VULKAN.@) ++ */ ++void WINAPI vkCmdSetScissor( VkCommandBuffer commandBuffer, uint32_t firstScissor, ++ uint32_t scissorCount, const VkRect2D *pScissors ) ++{ ++ TRACE( "(%p, %u, %u, %p)\n", commandBuffer, firstScissor, scissorCount, pScissors ); ++ p_vkCmdSetScissor( commandBuffer, firstScissor, scissorCount, pScissors ); ++} ++ ++/*********************************************************************** ++ * vkCmdSetStencilCompareMask (VULKAN.@) ++ */ ++void WINAPI vkCmdSetStencilCompareMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, ++ uint32_t compareMask ) ++{ ++ TRACE( "(%p, %u, %u)\n", commandBuffer, faceMask, compareMask ); ++ p_vkCmdSetStencilCompareMask( commandBuffer, faceMask, compareMask ); ++} ++ ++/*********************************************************************** ++ * vkCmdSetStencilReference (VULKAN.@) ++ */ ++void WINAPI vkCmdSetStencilReference( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, ++ uint32_t reference ) ++{ ++ TRACE( "(%p, %u, %u)\n", commandBuffer, faceMask, reference ); ++ p_vkCmdSetStencilReference( commandBuffer, faceMask, reference ); ++} ++ ++/*********************************************************************** ++ * vkCmdSetStencilWriteMask (VULKAN.@) ++ */ ++void WINAPI vkCmdSetStencilWriteMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, ++ uint32_t writeMask ) ++{ ++ TRACE( "(%p, %u, %u)\n", commandBuffer, faceMask, writeMask ); ++ p_vkCmdSetStencilWriteMask( commandBuffer, faceMask, writeMask ); ++} ++ ++/*********************************************************************** ++ * vkCmdSetViewport (VULKAN.@) ++ */ ++void WINAPI vkCmdSetViewport( VkCommandBuffer commandBuffer, uint32_t firstViewport, ++ uint32_t viewportCount, const VkViewport *pViewports ) ++{ ++ TRACE( "(%p, %u, %u, %p)\n", commandBuffer, firstViewport, viewportCount, pViewports ); ++ p_vkCmdSetViewport( commandBuffer, firstViewport, viewportCount, pViewports ); ++} ++ ++/*********************************************************************** ++ * vkCmdUpdateBuffer (VULKAN.@) ++ */ ++void WINAPI vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, ++ VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t *pData ) ++{ ++ TRACE( "(%p, %s, %s, %s, %p)\n", commandBuffer, wine_dbgstr_longlong(dstBuffer), ++ wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(dataSize), pData ); ++ p_vkCmdUpdateBuffer( commandBuffer, dstBuffer, dstOffset, dataSize, pData ); ++} ++ ++/*********************************************************************** ++ * vkCmdWaitEvents (VULKAN.@) ++ */ ++void WINAPI 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 ) ++{ ++ VkImageMemoryBarrier_host *ptr_pImageMemoryBarriers; ++ ++ TRACE( "(%p, %u, %p, %u, %u, %u, %p, %u, %p, %u, %p)\n", commandBuffer, eventCount, pEvents, ++ srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, ++ bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, ++ pImageMemoryBarriers ); ++ ++ ptr_pImageMemoryBarriers = convert_VkImageMemoryBarrier_array( pImageMemoryBarriers, ++ imageMemoryBarrierCount ); ++ p_vkCmdWaitEvents( commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, ++ memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, ++ imageMemoryBarrierCount, ptr_pImageMemoryBarriers ); ++ release_VkImageMemoryBarrier_array( NULL, ptr_pImageMemoryBarriers, imageMemoryBarrierCount ); ++} ++ ++/*********************************************************************** ++ * vkCmdWriteTimestamp (VULKAN.@) ++ */ ++void WINAPI vkCmdWriteTimestamp( VkCommandBuffer commandBuffer, ++ VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query ) ++{ ++ TRACE( "(%p, %d, %s, %u)\n", commandBuffer, pipelineStage, wine_dbgstr_longlong(queryPool), ++ query ); ++ p_vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query ); ++} ++ ++/*********************************************************************** ++ * vkCreateBuffer (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateBuffer( VkDevice device, const VkBufferCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer ) ++{ ++ VkBufferCreateInfo_host tmp_pCreateInfo, *ptr_pCreateInfo; ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %p, %p, %p)\n", device, pCreateInfo, pAllocator, pBuffer ); ++ ++ ptr_pCreateInfo = convert_VkBufferCreateInfo( &tmp_pCreateInfo, pCreateInfo ); ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateBuffer( device, ptr_pCreateInfo, ptr_pAllocator, pBuffer ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ release_VkBufferCreateInfo( NULL, ptr_pCreateInfo ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreateBufferView (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateBufferView( VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks *pAllocator, VkBufferView *pView ) ++{ ++ VkBufferViewCreateInfo_host tmp_pCreateInfo, *ptr_pCreateInfo; ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %p, %p, %p)\n", device, pCreateInfo, pAllocator, pView ); ++ ++ ptr_pCreateInfo = convert_VkBufferViewCreateInfo( &tmp_pCreateInfo, pCreateInfo ); ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateBufferView( device, ptr_pCreateInfo, ptr_pAllocator, pView ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ release_VkBufferViewCreateInfo( NULL, ptr_pCreateInfo ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreateCommandPool (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateCommandPool( VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %p, %p, %p)\n", device, pCreateInfo, pAllocator, pCommandPool ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateCommandPool( device, pCreateInfo, ptr_pAllocator, pCommandPool ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreateComputePipelines (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateComputePipelines( VkDevice device, VkPipelineCache pipelineCache, ++ uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, ++ const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines ) ++{ ++ VkComputePipelineCreateInfo_host *ptr_pCreateInfos; ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %s, %u, %p, %p, %p)\n", device, wine_dbgstr_longlong(pipelineCache), ++ createInfoCount, pCreateInfos, pAllocator, pPipelines ); ++ ++ ptr_pCreateInfos = convert_VkComputePipelineCreateInfo_array( pCreateInfos, createInfoCount ); ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateComputePipelines( device, pipelineCache, createInfoCount, ptr_pCreateInfos, ++ ptr_pAllocator, pPipelines ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ release_VkComputePipelineCreateInfo_array( NULL, ptr_pCreateInfos, createInfoCount ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreateDebugReportCallbackEXT (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateDebugReportCallbackEXT( VkInstance instance, ++ const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, ++ const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback ) ++{ ++ VkDebugReportCallbackCreateInfoEXT_host tmp_pCreateInfo, *ptr_pCreateInfo; ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %p, %p, %p)\n", instance, pCreateInfo, pAllocator, pCallback ); ++ ++ ptr_pCreateInfo = convert_VkDebugReportCallbackCreateInfoEXT( &tmp_pCreateInfo, pCreateInfo ); ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateDebugReportCallbackEXT( instance, ptr_pCreateInfo, ptr_pAllocator, pCallback ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ release_VkDebugReportCallbackCreateInfoEXT( NULL, ptr_pCreateInfo ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreateDescriptorPool (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateDescriptorPool( VkDevice device, ++ const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, ++ VkDescriptorPool *pDescriptorPool ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %p, %p, %p)\n", device, pCreateInfo, pAllocator, pDescriptorPool ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateDescriptorPool( device, pCreateInfo, ptr_pAllocator, pDescriptorPool ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreateDescriptorSetLayout (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateDescriptorSetLayout( VkDevice device, ++ const VkDescriptorSetLayoutCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %p, %p, %p)\n", device, pCreateInfo, pAllocator, pSetLayout ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateDescriptorSetLayout( device, pCreateInfo, ptr_pAllocator, pSetLayout ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreateDevice (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateDevice( VkPhysicalDevice physicalDevice, ++ const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, ++ VkDevice *pDevice ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %p, %p, %p)\n", physicalDevice, pCreateInfo, pAllocator, pDevice ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateDevice( physicalDevice, pCreateInfo, ptr_pAllocator, pDevice ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreateDisplayModeKHR (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateDisplayModeKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, ++ const VkDisplayModeCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, ++ VkDisplayModeKHR *pMode ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %s, %p, %p, %p)\n", physicalDevice, wine_dbgstr_longlong(display), pCreateInfo, ++ pAllocator, pMode ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateDisplayModeKHR( physicalDevice, display, pCreateInfo, ptr_pAllocator, pMode ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreateDisplayPlaneSurfaceKHR (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateDisplayPlaneSurfaceKHR( VkInstance instance, ++ const VkDisplaySurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, ++ VkSurfaceKHR *pSurface ) ++{ ++ VkDisplaySurfaceCreateInfoKHR_host tmp_pCreateInfo, *ptr_pCreateInfo; ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %p, %p, %p)\n", instance, pCreateInfo, pAllocator, pSurface ); ++ ++ ptr_pCreateInfo = convert_VkDisplaySurfaceCreateInfoKHR( &tmp_pCreateInfo, pCreateInfo ); ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateDisplayPlaneSurfaceKHR( instance, ptr_pCreateInfo, ptr_pAllocator, pSurface ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ release_VkDisplaySurfaceCreateInfoKHR( NULL, ptr_pCreateInfo ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreateEvent (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateEvent( VkDevice device, const VkEventCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks *pAllocator, VkEvent *pEvent ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %p, %p, %p)\n", device, pCreateInfo, pAllocator, pEvent ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateEvent( device, pCreateInfo, ptr_pAllocator, pEvent ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreateFence (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateFence( VkDevice device, const VkFenceCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks *pAllocator, VkFence *pFence ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %p, %p, %p)\n", device, pCreateInfo, pAllocator, pFence ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateFence( device, pCreateInfo, ptr_pAllocator, pFence ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreateFramebuffer (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateFramebuffer( VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer ) ++{ ++ VkFramebufferCreateInfo_host tmp_pCreateInfo, *ptr_pCreateInfo; ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %p, %p, %p)\n", device, pCreateInfo, pAllocator, pFramebuffer ); ++ ++ ptr_pCreateInfo = convert_VkFramebufferCreateInfo( &tmp_pCreateInfo, pCreateInfo ); ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateFramebuffer( device, ptr_pCreateInfo, ptr_pAllocator, pFramebuffer ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ release_VkFramebufferCreateInfo( NULL, ptr_pCreateInfo ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreateGraphicsPipelines (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateGraphicsPipelines( VkDevice device, VkPipelineCache pipelineCache, ++ uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, ++ const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines ) ++{ ++ VkGraphicsPipelineCreateInfo_host *ptr_pCreateInfos; ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %s, %u, %p, %p, %p)\n", device, wine_dbgstr_longlong(pipelineCache), ++ createInfoCount, pCreateInfos, pAllocator, pPipelines ); ++ ++ ptr_pCreateInfos = convert_VkGraphicsPipelineCreateInfo_array( pCreateInfos, createInfoCount ); ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateGraphicsPipelines( device, pipelineCache, createInfoCount, ptr_pCreateInfos, ++ ptr_pAllocator, pPipelines ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ release_VkGraphicsPipelineCreateInfo_array( NULL, ptr_pCreateInfos, createInfoCount ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreateImage (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateImage( VkDevice device, const VkImageCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks *pAllocator, VkImage *pImage ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %p, %p, %p)\n", device, pCreateInfo, pAllocator, pImage ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateImage( device, pCreateInfo, ptr_pAllocator, pImage ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreateImageView (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateImageView( VkDevice device, const VkImageViewCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks *pAllocator, VkImageView *pView ) ++{ ++ VkImageViewCreateInfo_host tmp_pCreateInfo, *ptr_pCreateInfo; ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %p, %p, %p)\n", device, pCreateInfo, pAllocator, pView ); ++ ++ ptr_pCreateInfo = convert_VkImageViewCreateInfo( &tmp_pCreateInfo, pCreateInfo ); ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateImageView( device, ptr_pCreateInfo, ptr_pAllocator, pView ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ release_VkImageViewCreateInfo( NULL, ptr_pCreateInfo ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreatePipelineCache (VULKAN.@) ++ */ ++VkResult WINAPI vkCreatePipelineCache( VkDevice device, ++ const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, ++ VkPipelineCache *pPipelineCache ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %p, %p, %p)\n", device, pCreateInfo, pAllocator, pPipelineCache ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreatePipelineCache( device, pCreateInfo, ptr_pAllocator, pPipelineCache ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreatePipelineLayout (VULKAN.@) ++ */ ++VkResult WINAPI vkCreatePipelineLayout( VkDevice device, ++ const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, ++ VkPipelineLayout *pPipelineLayout ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %p, %p, %p)\n", device, pCreateInfo, pAllocator, pPipelineLayout ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreatePipelineLayout( device, pCreateInfo, ptr_pAllocator, pPipelineLayout ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreateQueryPool (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateQueryPool( VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %p, %p, %p)\n", device, pCreateInfo, pAllocator, pQueryPool ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateQueryPool( device, pCreateInfo, ptr_pAllocator, pQueryPool ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreateRenderPass (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateRenderPass( VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %p, %p, %p)\n", device, pCreateInfo, pAllocator, pRenderPass ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateRenderPass( device, pCreateInfo, ptr_pAllocator, pRenderPass ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreateSampler (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateSampler( VkDevice device, const VkSamplerCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks *pAllocator, VkSampler *pSampler ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %p, %p, %p)\n", device, pCreateInfo, pAllocator, pSampler ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateSampler( device, pCreateInfo, ptr_pAllocator, pSampler ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreateSemaphore (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateSemaphore( VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %p, %p, %p)\n", device, pCreateInfo, pAllocator, pSemaphore ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateSemaphore( device, pCreateInfo, ptr_pAllocator, pSemaphore ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreateShaderModule (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateShaderModule( VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, ++ const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %p, %p, %p)\n", device, pCreateInfo, pAllocator, pShaderModule ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateShaderModule( device, pCreateInfo, ptr_pAllocator, pShaderModule ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreateSharedSwapchainsKHR (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateSharedSwapchainsKHR( VkDevice device, uint32_t swapchainCount, ++ const VkSwapchainCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, ++ VkSwapchainKHR *pSwapchains ) ++{ ++ VkSwapchainCreateInfoKHR_host *ptr_pCreateInfos; ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %u, %p, %p, %p)\n", device, swapchainCount, pCreateInfos, pAllocator, ++ pSwapchains ); ++ ++ ptr_pCreateInfos = convert_VkSwapchainCreateInfoKHR_array( pCreateInfos, swapchainCount ); ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateSharedSwapchainsKHR( device, swapchainCount, ptr_pCreateInfos, ptr_pAllocator, ++ pSwapchains ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ release_VkSwapchainCreateInfoKHR_array( NULL, ptr_pCreateInfos, swapchainCount ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkCreateSwapchainKHR (VULKAN.@) ++ */ ++VkResult WINAPI vkCreateSwapchainKHR( VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, ++ const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain ) ++{ ++ VkSwapchainCreateInfoKHR_host tmp_pCreateInfo, *ptr_pCreateInfo; ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ VkResult res; ++ ++ TRACE( "(%p, %p, %p, %p)\n", device, pCreateInfo, pAllocator, pSwapchain ); ++ ++ ptr_pCreateInfo = convert_VkSwapchainCreateInfoKHR( &tmp_pCreateInfo, pCreateInfo ); ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ res = p_vkCreateSwapchainKHR( device, ptr_pCreateInfo, ptr_pAllocator, pSwapchain ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++ release_VkSwapchainCreateInfoKHR( NULL, ptr_pCreateInfo ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkDebugReportMessageEXT (VULKAN.@) ++ */ ++void WINAPI vkDebugReportMessageEXT( VkInstance instance, VkDebugReportFlagsEXT flags, ++ VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, ++ int32_t messageCode, const char *pLayerPrefix, const char *pMessage ) ++{ ++ TRACE( "(%p, %u, %d, %s, %lu, %d, %s, %s)\n", instance, flags, objectType, ++ wine_dbgstr_longlong(object), (SIZE_T)location, messageCode, debugstr_a(pLayerPrefix), ++ debugstr_a(pMessage) ); ++ p_vkDebugReportMessageEXT( instance, flags, objectType, object, location, messageCode, ++ pLayerPrefix, pMessage ); ++} ++ ++/*********************************************************************** ++ * vkDestroyBuffer (VULKAN.@) ++ */ ++void WINAPI vkDestroyBuffer( VkDevice device, VkBuffer buffer, ++ const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(buffer), pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkDestroyBuffer( device, buffer, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkDestroyBufferView (VULKAN.@) ++ */ ++void WINAPI vkDestroyBufferView( VkDevice device, VkBufferView bufferView, ++ const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(bufferView), pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkDestroyBufferView( device, bufferView, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkDestroyCommandPool (VULKAN.@) ++ */ ++void WINAPI vkDestroyCommandPool( VkDevice device, VkCommandPool commandPool, ++ const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(commandPool), pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkDestroyCommandPool( device, commandPool, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkDestroyDebugReportCallbackEXT (VULKAN.@) ++ */ ++void WINAPI vkDestroyDebugReportCallbackEXT( VkInstance instance, ++ VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %s, %p)\n", instance, wine_dbgstr_longlong(callback), pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkDestroyDebugReportCallbackEXT( instance, callback, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkDestroyDescriptorPool (VULKAN.@) ++ */ ++void WINAPI vkDestroyDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, ++ const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(descriptorPool), pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkDestroyDescriptorPool( device, descriptorPool, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkDestroyDescriptorSetLayout (VULKAN.@) ++ */ ++void WINAPI vkDestroyDescriptorSetLayout( VkDevice device, ++ VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(descriptorSetLayout), pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkDestroyDescriptorSetLayout( device, descriptorSetLayout, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkDestroyDevice (VULKAN.@) ++ */ ++void WINAPI vkDestroyDevice( VkDevice device, const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %p)\n", device, pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkDestroyDevice( device, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkDestroyEvent (VULKAN.@) ++ */ ++void WINAPI vkDestroyEvent( VkDevice device, VkEvent event, ++ const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(event), pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkDestroyEvent( device, event, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkDestroyFence (VULKAN.@) ++ */ ++void WINAPI vkDestroyFence( VkDevice device, VkFence fence, ++ const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(fence), pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkDestroyFence( device, fence, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkDestroyFramebuffer (VULKAN.@) ++ */ ++void WINAPI vkDestroyFramebuffer( VkDevice device, VkFramebuffer framebuffer, ++ const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(framebuffer), pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkDestroyFramebuffer( device, framebuffer, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkDestroyImage (VULKAN.@) ++ */ ++void WINAPI vkDestroyImage( VkDevice device, VkImage image, ++ const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(image), pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkDestroyImage( device, image, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkDestroyImageView (VULKAN.@) ++ */ ++void WINAPI vkDestroyImageView( VkDevice device, VkImageView imageView, ++ const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(imageView), pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkDestroyImageView( device, imageView, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkDestroyInstance (VULKAN.@) ++ */ ++void WINAPI vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %p)\n", instance, pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkDestroyInstance( instance, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkDestroyPipeline (VULKAN.@) ++ */ ++void WINAPI vkDestroyPipeline( VkDevice device, VkPipeline pipeline, ++ const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(pipeline), pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkDestroyPipeline( device, pipeline, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkDestroyPipelineCache (VULKAN.@) ++ */ ++void WINAPI vkDestroyPipelineCache( VkDevice device, VkPipelineCache pipelineCache, ++ const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(pipelineCache), pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkDestroyPipelineCache( device, pipelineCache, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkDestroyPipelineLayout (VULKAN.@) ++ */ ++void WINAPI vkDestroyPipelineLayout( VkDevice device, VkPipelineLayout pipelineLayout, ++ const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(pipelineLayout), pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkDestroyPipelineLayout( device, pipelineLayout, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkDestroyQueryPool (VULKAN.@) ++ */ ++void WINAPI vkDestroyQueryPool( VkDevice device, VkQueryPool queryPool, ++ const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(queryPool), pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkDestroyQueryPool( device, queryPool, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkDestroyRenderPass (VULKAN.@) ++ */ ++void WINAPI vkDestroyRenderPass( VkDevice device, VkRenderPass renderPass, ++ const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(renderPass), pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkDestroyRenderPass( device, renderPass, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkDestroySampler (VULKAN.@) ++ */ ++void WINAPI vkDestroySampler( VkDevice device, VkSampler sampler, ++ const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(sampler), pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkDestroySampler( device, sampler, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkDestroySemaphore (VULKAN.@) ++ */ ++void WINAPI vkDestroySemaphore( VkDevice device, VkSemaphore semaphore, ++ const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(semaphore), pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkDestroySemaphore( device, semaphore, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkDestroyShaderModule (VULKAN.@) ++ */ ++void WINAPI vkDestroyShaderModule( VkDevice device, VkShaderModule shaderModule, ++ const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(shaderModule), pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkDestroyShaderModule( device, shaderModule, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkDestroySurfaceKHR (VULKAN.@) ++ */ ++void WINAPI vkDestroySurfaceKHR( VkInstance instance, VkSurfaceKHR surface, ++ const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %s, %p)\n", instance, wine_dbgstr_longlong(surface), pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkDestroySurfaceKHR( instance, surface, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkDestroySwapchainKHR (VULKAN.@) ++ */ ++void WINAPI vkDestroySwapchainKHR( VkDevice device, VkSwapchainKHR swapchain, ++ const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(swapchain), pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkDestroySwapchainKHR( device, swapchain, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkDeviceWaitIdle (VULKAN.@) ++ */ ++VkResult WINAPI vkDeviceWaitIdle( VkDevice device ) ++{ ++ TRACE( "(%p)\n", device ); ++ return p_vkDeviceWaitIdle( device ); ++} ++ ++/*********************************************************************** ++ * vkEndCommandBuffer (VULKAN.@) ++ */ ++VkResult WINAPI vkEndCommandBuffer( VkCommandBuffer commandBuffer ) ++{ ++ TRACE( "(%p)\n", commandBuffer ); ++ return p_vkEndCommandBuffer( commandBuffer ); ++} ++ ++/*********************************************************************** ++ * vkEnumerateDeviceExtensionProperties (VULKAN.@) ++ */ ++VkResult WINAPI vkEnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice, ++ const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties ) ++{ ++ TRACE( "(%p, %s, %p, %p)\n", physicalDevice, debugstr_a(pLayerName), pPropertyCount, ++ pProperties ); ++ return p_vkEnumerateDeviceExtensionProperties( physicalDevice, pLayerName, pPropertyCount, ++ pProperties ); ++} ++ ++/*********************************************************************** ++ * vkEnumerateDeviceLayerProperties (VULKAN.@) ++ */ ++VkResult WINAPI vkEnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, ++ uint32_t *pPropertyCount, VkLayerProperties *pProperties ) ++{ ++ TRACE( "(%p, %p, %p)\n", physicalDevice, pPropertyCount, pProperties ); ++ return p_vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties ); ++} ++ ++/*********************************************************************** ++ * vkEnumerateInstanceLayerProperties (VULKAN.@) ++ */ ++VkResult WINAPI vkEnumerateInstanceLayerProperties( uint32_t *pPropertyCount, ++ VkLayerProperties *pProperties ) ++{ ++ TRACE( "(%p, %p)\n", pPropertyCount, pProperties ); ++ return p_vkEnumerateInstanceLayerProperties( pPropertyCount, pProperties ); ++} ++ ++/*********************************************************************** ++ * vkEnumeratePhysicalDevices (VULKAN.@) ++ */ ++VkResult WINAPI vkEnumeratePhysicalDevices( VkInstance instance, uint32_t *pPhysicalDeviceCount, ++ VkPhysicalDevice *pPhysicalDevices ) ++{ ++ TRACE( "(%p, %p, %p)\n", instance, pPhysicalDeviceCount, pPhysicalDevices ); ++ return p_vkEnumeratePhysicalDevices( instance, pPhysicalDeviceCount, pPhysicalDevices ); ++} ++ ++/*********************************************************************** ++ * vkFlushMappedMemoryRanges (VULKAN.@) ++ */ ++VkResult WINAPI vkFlushMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, ++ const VkMappedMemoryRange *pMemoryRanges ) ++{ ++ TRACE( "(%p, %u, %p)\n", device, memoryRangeCount, pMemoryRanges ); ++ return p_vkFlushMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges ); ++} ++ ++/*********************************************************************** ++ * vkFreeCommandBuffers (VULKAN.@) ++ */ ++void WINAPI vkFreeCommandBuffers( VkDevice device, VkCommandPool commandPool, ++ uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers ) ++{ ++ TRACE( "(%p, %s, %u, %p)\n", device, wine_dbgstr_longlong(commandPool), commandBufferCount, ++ pCommandBuffers ); ++ p_vkFreeCommandBuffers( device, commandPool, commandBufferCount, pCommandBuffers ); ++} ++ ++/*********************************************************************** ++ * vkFreeDescriptorSets (VULKAN.@) ++ */ ++VkResult WINAPI vkFreeDescriptorSets( VkDevice device, VkDescriptorPool descriptorPool, ++ uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets ) ++{ ++ TRACE( "(%p, %s, %u, %p)\n", device, wine_dbgstr_longlong(descriptorPool), descriptorSetCount, ++ pDescriptorSets ); ++ return p_vkFreeDescriptorSets( device, descriptorPool, descriptorSetCount, pDescriptorSets ); ++} ++ ++/*********************************************************************** ++ * vkFreeMemory (VULKAN.@) ++ */ ++void WINAPI vkFreeMemory( VkDevice device, VkDeviceMemory memory, ++ const VkAllocationCallbacks *pAllocator ) ++{ ++ VkAllocationCallbacks_host tmp_pAllocator, *ptr_pAllocator; ++ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(memory), pAllocator ); ++ ++ ptr_pAllocator = convert_VkAllocationCallbacks( &tmp_pAllocator, pAllocator ); ++ p_vkFreeMemory( device, memory, ptr_pAllocator ); ++ release_VkAllocationCallbacks( NULL, ptr_pAllocator ); ++} ++ ++/*********************************************************************** ++ * vkGetBufferMemoryRequirements (VULKAN.@) ++ */ ++void WINAPI vkGetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, ++ VkMemoryRequirements *pMemoryRequirements ) ++{ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(buffer), pMemoryRequirements ); ++ p_vkGetBufferMemoryRequirements( device, buffer, pMemoryRequirements ); ++} ++ ++/*********************************************************************** ++ * vkGetDeviceMemoryCommitment (VULKAN.@) ++ */ ++void WINAPI vkGetDeviceMemoryCommitment( VkDevice device, VkDeviceMemory memory, ++ VkDeviceSize *pCommittedMemoryInBytes ) ++{ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(memory), pCommittedMemoryInBytes ); ++ p_vkGetDeviceMemoryCommitment( device, memory, pCommittedMemoryInBytes ); ++} ++ ++/*********************************************************************** ++ * vkGetDeviceQueue (VULKAN.@) ++ */ ++void WINAPI vkGetDeviceQueue( VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, ++ VkQueue *pQueue ) ++{ ++ TRACE( "(%p, %u, %u, %p)\n", device, queueFamilyIndex, queueIndex, pQueue ); ++ p_vkGetDeviceQueue( device, queueFamilyIndex, queueIndex, pQueue ); ++} ++ ++/*********************************************************************** ++ * vkGetDisplayModePropertiesKHR (VULKAN.@) ++ */ ++VkResult WINAPI vkGetDisplayModePropertiesKHR( VkPhysicalDevice physicalDevice, ++ VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties ) ++{ ++ VkDisplayModePropertiesKHR_host *ptr_pProperties; ++ VkResult res; ++ ++ TRACE( "(%p, %s, %p, %p)\n", physicalDevice, wine_dbgstr_longlong(display), pPropertyCount, ++ pProperties ); ++ ++ ptr_pProperties = convert_VkDisplayModePropertiesKHR_array( pProperties, *pPropertyCount ); ++ res = p_vkGetDisplayModePropertiesKHR( physicalDevice, display, pPropertyCount, ++ ptr_pProperties ); ++ release_VkDisplayModePropertiesKHR_array( pProperties, ptr_pProperties, *pPropertyCount ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkGetDisplayPlaneCapabilitiesKHR (VULKAN.@) ++ */ ++VkResult WINAPI vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice physicalDevice, ++ VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities ) ++{ ++ TRACE( "(%p, %s, %u, %p)\n", physicalDevice, wine_dbgstr_longlong(mode), planeIndex, ++ pCapabilities ); ++ return p_vkGetDisplayPlaneCapabilitiesKHR( physicalDevice, mode, planeIndex, pCapabilities ); ++} ++ ++/*********************************************************************** ++ * vkGetDisplayPlaneSupportedDisplaysKHR (VULKAN.@) ++ */ ++VkResult WINAPI vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice, ++ uint32_t planeIndex, uint32_t *pDisplayCount, VkDisplayKHR *pDisplays ) ++{ ++ TRACE( "(%p, %u, %p, %p)\n", physicalDevice, planeIndex, pDisplayCount, pDisplays ); ++ return p_vkGetDisplayPlaneSupportedDisplaysKHR( physicalDevice, planeIndex, pDisplayCount, ++ pDisplays ); ++} ++ ++/*********************************************************************** ++ * vkGetEventStatus (VULKAN.@) ++ */ ++VkResult WINAPI vkGetEventStatus( VkDevice device, VkEvent event ) ++{ ++ TRACE( "(%p, %s)\n", device, wine_dbgstr_longlong(event) ); ++ return p_vkGetEventStatus( device, event ); ++} ++ ++/*********************************************************************** ++ * vkGetFenceStatus (VULKAN.@) ++ */ ++VkResult WINAPI vkGetFenceStatus( VkDevice device, VkFence fence ) ++{ ++ TRACE( "(%p, %s)\n", device, wine_dbgstr_longlong(fence) ); ++ return p_vkGetFenceStatus( device, fence ); ++} ++ ++/*********************************************************************** ++ * vkGetImageMemoryRequirements (VULKAN.@) ++ */ ++void WINAPI vkGetImageMemoryRequirements( VkDevice device, VkImage image, ++ VkMemoryRequirements *pMemoryRequirements ) ++{ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(image), pMemoryRequirements ); ++ p_vkGetImageMemoryRequirements( device, image, pMemoryRequirements ); ++} ++ ++/*********************************************************************** ++ * vkGetImageSparseMemoryRequirements (VULKAN.@) ++ */ ++void WINAPI vkGetImageSparseMemoryRequirements( VkDevice device, VkImage image, ++ uint32_t *pSparseMemoryRequirementCount, ++ VkSparseImageMemoryRequirements *pSparseMemoryRequirements ) ++{ ++ TRACE( "(%p, %s, %p, %p)\n", device, wine_dbgstr_longlong(image), ++ pSparseMemoryRequirementCount, pSparseMemoryRequirements ); ++ p_vkGetImageSparseMemoryRequirements( device, image, pSparseMemoryRequirementCount, ++ pSparseMemoryRequirements ); ++} ++ ++/*********************************************************************** ++ * vkGetImageSubresourceLayout (VULKAN.@) ++ */ ++void WINAPI vkGetImageSubresourceLayout( VkDevice device, VkImage image, ++ const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout ) ++{ ++ TRACE( "(%p, %s, %p, %p)\n", device, wine_dbgstr_longlong(image), pSubresource, pLayout ); ++ p_vkGetImageSubresourceLayout( device, image, pSubresource, pLayout ); ++} ++ ++/*********************************************************************** ++ * vkGetPhysicalDeviceDisplayPlanePropertiesKHR (VULKAN.@) ++ */ ++VkResult WINAPI vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice physicalDevice, ++ uint32_t *pPropertyCount, VkDisplayPlanePropertiesKHR *pProperties ) ++{ ++ VkDisplayPlanePropertiesKHR_host *ptr_pProperties; ++ VkResult res; ++ ++ TRACE( "(%p, %p, %p)\n", physicalDevice, pPropertyCount, pProperties ); ++ ++ ptr_pProperties = convert_VkDisplayPlanePropertiesKHR_array( pProperties, *pPropertyCount ); ++ res = p_vkGetPhysicalDeviceDisplayPlanePropertiesKHR( physicalDevice, pPropertyCount, ++ ptr_pProperties ); ++ release_VkDisplayPlanePropertiesKHR_array( pProperties, ptr_pProperties, *pPropertyCount ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkGetPhysicalDeviceDisplayPropertiesKHR (VULKAN.@) ++ */ ++VkResult WINAPI vkGetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice physicalDevice, ++ uint32_t *pPropertyCount, VkDisplayPropertiesKHR *pProperties ) ++{ ++ TRACE( "(%p, %p, %p)\n", physicalDevice, pPropertyCount, pProperties ); ++ return p_vkGetPhysicalDeviceDisplayPropertiesKHR( physicalDevice, pPropertyCount, pProperties ); ++} ++ ++/*********************************************************************** ++ * vkGetPhysicalDeviceFeatures (VULKAN.@) ++ */ ++void WINAPI vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, ++ VkPhysicalDeviceFeatures *pFeatures ) ++{ ++ TRACE( "(%p, %p)\n", physicalDevice, pFeatures ); ++ p_vkGetPhysicalDeviceFeatures( physicalDevice, pFeatures ); ++} ++ ++/*********************************************************************** ++ * vkGetPhysicalDeviceFormatProperties (VULKAN.@) ++ */ ++void WINAPI vkGetPhysicalDeviceFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, ++ VkFormatProperties *pFormatProperties ) ++{ ++ TRACE( "(%p, %d, %p)\n", physicalDevice, format, pFormatProperties ); ++ p_vkGetPhysicalDeviceFormatProperties( physicalDevice, format, pFormatProperties ); ++} ++ ++/*********************************************************************** ++ * vkGetPhysicalDeviceImageFormatProperties (VULKAN.@) ++ */ ++VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties( VkPhysicalDevice physicalDevice, ++ VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, ++ VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties ) ++{ ++ TRACE( "(%p, %d, %d, %d, %u, %u, %p)\n", physicalDevice, format, type, tiling, usage, flags, ++ pImageFormatProperties ); ++ return p_vkGetPhysicalDeviceImageFormatProperties( physicalDevice, format, type, tiling, usage, ++ flags, pImageFormatProperties ); ++} ++ ++/*********************************************************************** ++ * vkGetPhysicalDeviceMemoryProperties (VULKAN.@) ++ */ ++void WINAPI vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, ++ VkPhysicalDeviceMemoryProperties *pMemoryProperties ) ++{ ++ VkPhysicalDeviceMemoryProperties_host tmp_pMemoryProperties, *ptr_pMemoryProperties; ++ ++ TRACE( "(%p, %p)\n", physicalDevice, pMemoryProperties ); ++ ++ ptr_pMemoryProperties = convert_VkPhysicalDeviceMemoryProperties( &tmp_pMemoryProperties, ++ pMemoryProperties ); ++ p_vkGetPhysicalDeviceMemoryProperties( physicalDevice, ptr_pMemoryProperties ); ++ release_VkPhysicalDeviceMemoryProperties( pMemoryProperties, ptr_pMemoryProperties ); ++} ++ ++/*********************************************************************** ++ * vkGetPhysicalDeviceProperties (VULKAN.@) ++ */ ++void WINAPI vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, ++ VkPhysicalDeviceProperties *pProperties ) ++{ ++ VkPhysicalDeviceProperties_host tmp_pProperties, *ptr_pProperties; ++ ++ TRACE( "(%p, %p)\n", physicalDevice, pProperties ); ++ ++ ptr_pProperties = convert_VkPhysicalDeviceProperties( &tmp_pProperties, pProperties ); ++ p_vkGetPhysicalDeviceProperties( physicalDevice, ptr_pProperties ); ++ release_VkPhysicalDeviceProperties( pProperties, ptr_pProperties ); ++} ++ ++/*********************************************************************** ++ * vkGetPhysicalDeviceQueueFamilyProperties (VULKAN.@) ++ */ ++void WINAPI vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice, ++ uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties ) ++{ ++ TRACE( "(%p, %p, %p)\n", physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties ); ++ p_vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, pQueueFamilyPropertyCount, ++ pQueueFamilyProperties ); ++} ++ ++/*********************************************************************** ++ * vkGetPhysicalDeviceSparseImageFormatProperties (VULKAN.@) ++ */ ++void WINAPI vkGetPhysicalDeviceSparseImageFormatProperties( VkPhysicalDevice physicalDevice, ++ VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, ++ VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties ) ++{ ++ TRACE( "(%p, %d, %d, %d, %u, %d, %p, %p)\n", physicalDevice, format, type, samples, usage, ++ tiling, pPropertyCount, pProperties ); ++ p_vkGetPhysicalDeviceSparseImageFormatProperties( physicalDevice, format, type, samples, usage, ++ tiling, pPropertyCount, pProperties ); ++} ++ ++/*********************************************************************** ++ * vkGetPhysicalDeviceSurfaceCapabilitiesKHR (VULKAN.@) ++ */ ++VkResult WINAPI vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice physicalDevice, ++ VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities ) ++{ ++ TRACE( "(%p, %s, %p)\n", physicalDevice, wine_dbgstr_longlong(surface), pSurfaceCapabilities ); ++ return p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR( physicalDevice, surface, ++ pSurfaceCapabilities ); ++} ++ ++/*********************************************************************** ++ * vkGetPhysicalDeviceSurfaceFormatsKHR (VULKAN.@) ++ */ ++VkResult WINAPI vkGetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice physicalDevice, ++ VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats ) ++{ ++ TRACE( "(%p, %s, %p, %p)\n", physicalDevice, wine_dbgstr_longlong(surface), ++ pSurfaceFormatCount, pSurfaceFormats ); ++ return p_vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDevice, surface, pSurfaceFormatCount, ++ pSurfaceFormats ); ++} ++ ++/*********************************************************************** ++ * vkGetPhysicalDeviceSurfacePresentModesKHR (VULKAN.@) ++ */ ++VkResult WINAPI vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice, ++ VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes ) ++{ ++ TRACE( "(%p, %s, %p, %p)\n", physicalDevice, wine_dbgstr_longlong(surface), pPresentModeCount, ++ pPresentModes ); ++ return p_vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDevice, surface, pPresentModeCount, ++ pPresentModes ); ++} ++ ++/*********************************************************************** ++ * vkGetPhysicalDeviceSurfaceSupportKHR (VULKAN.@) ++ */ ++VkResult WINAPI vkGetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice, ++ uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported ) ++{ ++ TRACE( "(%p, %u, %s, %p)\n", physicalDevice, queueFamilyIndex, wine_dbgstr_longlong(surface), ++ pSupported ); ++ return p_vkGetPhysicalDeviceSurfaceSupportKHR( physicalDevice, queueFamilyIndex, surface, ++ pSupported ); ++} ++ ++/*********************************************************************** ++ * vkGetPipelineCacheData (VULKAN.@) ++ */ ++VkResult WINAPI vkGetPipelineCacheData( VkDevice device, VkPipelineCache pipelineCache, ++ size_t *pDataSize, void *pData ) ++{ ++ TRACE( "(%p, %s, %p, %p)\n", device, wine_dbgstr_longlong(pipelineCache), pDataSize, pData ); ++ return p_vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData ); ++} ++ ++/*********************************************************************** ++ * vkGetQueryPoolResults (VULKAN.@) ++ */ ++VkResult WINAPI vkGetQueryPoolResults( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, ++ uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, ++ VkQueryResultFlags flags ) ++{ ++ TRACE( "(%p, %s, %u, %u, %lu, %p, %s, %u)\n", device, wine_dbgstr_longlong(queryPool), ++ firstQuery, queryCount, (SIZE_T)dataSize, pData, wine_dbgstr_longlong(stride), flags ); ++ return p_vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, ++ stride, flags ); ++} ++ ++/*********************************************************************** ++ * vkGetRenderAreaGranularity (VULKAN.@) ++ */ ++void WINAPI vkGetRenderAreaGranularity( VkDevice device, VkRenderPass renderPass, ++ VkExtent2D *pGranularity ) ++{ ++ TRACE( "(%p, %s, %p)\n", device, wine_dbgstr_longlong(renderPass), pGranularity ); ++ p_vkGetRenderAreaGranularity( device, renderPass, pGranularity ); ++} ++ ++/*********************************************************************** ++ * vkGetSwapchainImagesKHR (VULKAN.@) ++ */ ++VkResult WINAPI vkGetSwapchainImagesKHR( VkDevice device, VkSwapchainKHR swapchain, ++ uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages ) ++{ ++ TRACE( "(%p, %s, %p, %p)\n", device, wine_dbgstr_longlong(swapchain), pSwapchainImageCount, ++ pSwapchainImages ); ++ return p_vkGetSwapchainImagesKHR( device, swapchain, pSwapchainImageCount, pSwapchainImages ); ++} ++ ++/*********************************************************************** ++ * vkInvalidateMappedMemoryRanges (VULKAN.@) ++ */ ++VkResult WINAPI vkInvalidateMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, ++ const VkMappedMemoryRange *pMemoryRanges ) ++{ ++ TRACE( "(%p, %u, %p)\n", device, memoryRangeCount, pMemoryRanges ); ++ return p_vkInvalidateMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges ); ++} ++ ++/*********************************************************************** ++ * vkMapMemory (VULKAN.@) ++ */ ++VkResult WINAPI vkMapMemory( VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, ++ VkDeviceSize size, VkMemoryMapFlags flags, void **ppData ) ++{ ++ TRACE( "(%p, %s, %s, %s, %u, %p)\n", device, wine_dbgstr_longlong(memory), ++ wine_dbgstr_longlong(offset), wine_dbgstr_longlong(size), flags, ppData ); ++ return p_vkMapMemory( device, memory, offset, size, flags, ppData ); ++} ++ ++/*********************************************************************** ++ * vkMergePipelineCaches (VULKAN.@) ++ */ ++VkResult WINAPI vkMergePipelineCaches( VkDevice device, VkPipelineCache dstCache, ++ uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches ) ++{ ++ TRACE( "(%p, %s, %u, %p)\n", device, wine_dbgstr_longlong(dstCache), srcCacheCount, ++ pSrcCaches ); ++ return p_vkMergePipelineCaches( device, dstCache, srcCacheCount, pSrcCaches ); ++} ++ ++/*********************************************************************** ++ * vkQueueBindSparse (VULKAN.@) ++ */ ++VkResult WINAPI vkQueueBindSparse( VkQueue queue, uint32_t bindInfoCount, ++ const VkBindSparseInfo *pBindInfo, VkFence fence ) ++{ ++ VkBindSparseInfo_host *ptr_pBindInfo; ++ VkResult res; ++ ++ TRACE( "(%p, %u, %p, %s)\n", queue, bindInfoCount, pBindInfo, wine_dbgstr_longlong(fence) ); ++ ++ ptr_pBindInfo = convert_VkBindSparseInfo_array( pBindInfo, bindInfoCount ); ++ res = p_vkQueueBindSparse( queue, bindInfoCount, ptr_pBindInfo, fence ); ++ release_VkBindSparseInfo_array( NULL, ptr_pBindInfo, bindInfoCount ); ++ ++ return res; ++} ++ ++/*********************************************************************** ++ * vkQueuePresentKHR (VULKAN.@) ++ */ ++VkResult WINAPI vkQueuePresentKHR( VkQueue queue, const VkPresentInfoKHR *pPresentInfo ) ++{ ++ TRACE( "(%p, %p)\n", queue, pPresentInfo ); ++ return p_vkQueuePresentKHR( queue, pPresentInfo ); ++} ++ ++/*********************************************************************** ++ * vkQueueSubmit (VULKAN.@) ++ */ ++VkResult WINAPI vkQueueSubmit( VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, ++ VkFence fence ) ++{ ++ TRACE( "(%p, %u, %p, %s)\n", queue, submitCount, pSubmits, wine_dbgstr_longlong(fence) ); ++ return p_vkQueueSubmit( queue, submitCount, pSubmits, fence ); ++} ++ ++/*********************************************************************** ++ * vkQueueWaitIdle (VULKAN.@) ++ */ ++VkResult WINAPI vkQueueWaitIdle( VkQueue queue ) ++{ ++ TRACE( "(%p)\n", queue ); ++ return p_vkQueueWaitIdle( queue ); ++} ++ ++/*********************************************************************** ++ * vkResetCommandBuffer (VULKAN.@) ++ */ ++VkResult WINAPI vkResetCommandBuffer( VkCommandBuffer commandBuffer, ++ VkCommandBufferResetFlags flags ) ++{ ++ TRACE( "(%p, %u)\n", commandBuffer, flags ); ++ return p_vkResetCommandBuffer( commandBuffer, flags ); ++} ++ ++/*********************************************************************** ++ * vkResetCommandPool (VULKAN.@) ++ */ ++VkResult WINAPI vkResetCommandPool( VkDevice device, VkCommandPool commandPool, ++ VkCommandPoolResetFlags flags ) ++{ ++ TRACE( "(%p, %s, %u)\n", device, wine_dbgstr_longlong(commandPool), flags ); ++ return p_vkResetCommandPool( device, commandPool, flags ); ++} ++ ++/*********************************************************************** ++ * vkResetDescriptorPool (VULKAN.@) ++ */ ++VkResult WINAPI vkResetDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, ++ VkDescriptorPoolResetFlags flags ) ++{ ++ TRACE( "(%p, %s, %u)\n", device, wine_dbgstr_longlong(descriptorPool), flags ); ++ return p_vkResetDescriptorPool( device, descriptorPool, flags ); ++} ++ ++/*********************************************************************** ++ * vkResetEvent (VULKAN.@) ++ */ ++VkResult WINAPI vkResetEvent( VkDevice device, VkEvent event ) ++{ ++ TRACE( "(%p, %s)\n", device, wine_dbgstr_longlong(event) ); ++ return p_vkResetEvent( device, event ); ++} ++ ++/*********************************************************************** ++ * vkResetFences (VULKAN.@) ++ */ ++VkResult WINAPI vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence *pFences ) ++{ ++ TRACE( "(%p, %u, %p)\n", device, fenceCount, pFences ); ++ return p_vkResetFences( device, fenceCount, pFences ); ++} ++ ++/*********************************************************************** ++ * vkSetEvent (VULKAN.@) ++ */ ++VkResult WINAPI vkSetEvent( VkDevice device, VkEvent event ) ++{ ++ TRACE( "(%p, %s)\n", device, wine_dbgstr_longlong(event) ); ++ return p_vkSetEvent( device, event ); ++} ++ ++/*********************************************************************** ++ * vkUnmapMemory (VULKAN.@) ++ */ ++void WINAPI vkUnmapMemory( VkDevice device, VkDeviceMemory memory ) ++{ ++ TRACE( "(%p, %s)\n", device, wine_dbgstr_longlong(memory) ); ++ p_vkUnmapMemory( device, memory ); ++} ++ ++/*********************************************************************** ++ * vkUpdateDescriptorSets (VULKAN.@) ++ */ ++void WINAPI vkUpdateDescriptorSets( VkDevice device, uint32_t descriptorWriteCount, ++ const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, ++ const VkCopyDescriptorSet *pDescriptorCopies ) ++{ ++ VkWriteDescriptorSet_host *ptr_pDescriptorWrites; ++ VkCopyDescriptorSet_host *ptr_pDescriptorCopies; ++ ++ TRACE( "(%p, %u, %p, %u, %p)\n", device, descriptorWriteCount, pDescriptorWrites, ++ descriptorCopyCount, pDescriptorCopies ); ++ ++ ptr_pDescriptorWrites = convert_VkWriteDescriptorSet_array( pDescriptorWrites, ++ descriptorWriteCount ); ++ ptr_pDescriptorCopies = convert_VkCopyDescriptorSet_array( pDescriptorCopies, ++ descriptorCopyCount ); ++ p_vkUpdateDescriptorSets( device, descriptorWriteCount, ptr_pDescriptorWrites, ++ descriptorCopyCount, ptr_pDescriptorCopies ); ++ release_VkCopyDescriptorSet_array( NULL, ptr_pDescriptorCopies, descriptorCopyCount ); ++ release_VkWriteDescriptorSet_array( NULL, ptr_pDescriptorWrites, descriptorWriteCount ); ++} ++ ++/*********************************************************************** ++ * vkWaitForFences (VULKAN.@) ++ */ ++VkResult WINAPI vkWaitForFences( VkDevice device, uint32_t fenceCount, const VkFence *pFences, ++ VkBool32 waitAll, uint64_t timeout ) ++{ ++ TRACE( "(%p, %u, %p, %u, %s)\n", device, fenceCount, pFences, waitAll, ++ wine_dbgstr_longlong(timeout) ); ++ return p_vkWaitForFences( device, fenceCount, pFences, waitAll, timeout ); ++} ++ ++static const struct ++{ ++ const char *name; ++ void **host_func; ++ void *null_func; ++} ++function_table[] = ++{ ++#define DEFINE_FUNCTION( f ) { #f, (void **)&p_##f, null_##f }, ++ DEFINE_FUNCTION( vkAcquireNextImageKHR ) ++ DEFINE_FUNCTION( vkAllocateCommandBuffers ) ++ DEFINE_FUNCTION( vkAllocateDescriptorSets ) ++ DEFINE_FUNCTION( vkAllocateMemory ) ++ DEFINE_FUNCTION( vkBeginCommandBuffer ) ++ DEFINE_FUNCTION( vkBindBufferMemory ) ++ DEFINE_FUNCTION( vkBindImageMemory ) ++ DEFINE_FUNCTION( vkCmdBeginQuery ) ++ DEFINE_FUNCTION( vkCmdBeginRenderPass ) ++ DEFINE_FUNCTION( vkCmdBindDescriptorSets ) ++ DEFINE_FUNCTION( vkCmdBindIndexBuffer ) ++ DEFINE_FUNCTION( vkCmdBindPipeline ) ++ DEFINE_FUNCTION( vkCmdBindVertexBuffers ) ++ DEFINE_FUNCTION( vkCmdBlitImage ) ++ DEFINE_FUNCTION( vkCmdClearAttachments ) ++ DEFINE_FUNCTION( vkCmdClearColorImage ) ++ DEFINE_FUNCTION( vkCmdClearDepthStencilImage ) ++ DEFINE_FUNCTION( vkCmdCopyBuffer ) ++ DEFINE_FUNCTION( vkCmdCopyBufferToImage ) ++ DEFINE_FUNCTION( vkCmdCopyImage ) ++ DEFINE_FUNCTION( vkCmdCopyImageToBuffer ) ++ DEFINE_FUNCTION( vkCmdCopyQueryPoolResults ) ++ DEFINE_FUNCTION( vkCmdDispatch ) ++ DEFINE_FUNCTION( vkCmdDispatchIndirect ) ++ DEFINE_FUNCTION( vkCmdDraw ) ++ DEFINE_FUNCTION( vkCmdDrawIndexed ) ++ DEFINE_FUNCTION( vkCmdDrawIndexedIndirect ) ++ DEFINE_FUNCTION( vkCmdDrawIndirect ) ++ DEFINE_FUNCTION( vkCmdEndQuery ) ++ DEFINE_FUNCTION( vkCmdEndRenderPass ) ++ DEFINE_FUNCTION( vkCmdExecuteCommands ) ++ DEFINE_FUNCTION( vkCmdFillBuffer ) ++ DEFINE_FUNCTION( vkCmdNextSubpass ) ++ DEFINE_FUNCTION( vkCmdPipelineBarrier ) ++ DEFINE_FUNCTION( vkCmdPushConstants ) ++ DEFINE_FUNCTION( vkCmdResetEvent ) ++ DEFINE_FUNCTION( vkCmdResetQueryPool ) ++ DEFINE_FUNCTION( vkCmdResolveImage ) ++ DEFINE_FUNCTION( vkCmdSetBlendConstants ) ++ DEFINE_FUNCTION( vkCmdSetDepthBias ) ++ DEFINE_FUNCTION( vkCmdSetDepthBounds ) ++ DEFINE_FUNCTION( vkCmdSetEvent ) ++ DEFINE_FUNCTION( vkCmdSetLineWidth ) ++ DEFINE_FUNCTION( vkCmdSetScissor ) ++ DEFINE_FUNCTION( vkCmdSetStencilCompareMask ) ++ DEFINE_FUNCTION( vkCmdSetStencilReference ) ++ DEFINE_FUNCTION( vkCmdSetStencilWriteMask ) ++ DEFINE_FUNCTION( vkCmdSetViewport ) ++ DEFINE_FUNCTION( vkCmdUpdateBuffer ) ++ DEFINE_FUNCTION( vkCmdWaitEvents ) ++ DEFINE_FUNCTION( vkCmdWriteTimestamp ) ++ DEFINE_FUNCTION( vkCreateBuffer ) ++ DEFINE_FUNCTION( vkCreateBufferView ) ++ DEFINE_FUNCTION( vkCreateCommandPool ) ++ DEFINE_FUNCTION( vkCreateComputePipelines ) ++ DEFINE_FUNCTION( vkCreateDebugReportCallbackEXT ) ++ DEFINE_FUNCTION( vkCreateDescriptorPool ) ++ DEFINE_FUNCTION( vkCreateDescriptorSetLayout ) ++ DEFINE_FUNCTION( vkCreateDevice ) ++ DEFINE_FUNCTION( vkCreateDisplayModeKHR ) ++ DEFINE_FUNCTION( vkCreateDisplayPlaneSurfaceKHR ) ++ DEFINE_FUNCTION( vkCreateEvent ) ++ DEFINE_FUNCTION( vkCreateFence ) ++ DEFINE_FUNCTION( vkCreateFramebuffer ) ++ DEFINE_FUNCTION( vkCreateGraphicsPipelines ) ++ DEFINE_FUNCTION( vkCreateImage ) ++ DEFINE_FUNCTION( vkCreateImageView ) ++ DEFINE_FUNCTION( vkCreateInstance ) ++ DEFINE_FUNCTION( vkCreatePipelineCache ) ++ DEFINE_FUNCTION( vkCreatePipelineLayout ) ++ DEFINE_FUNCTION( vkCreateQueryPool ) ++ DEFINE_FUNCTION( vkCreateRenderPass ) ++ DEFINE_FUNCTION( vkCreateSampler ) ++ DEFINE_FUNCTION( vkCreateSemaphore ) ++ DEFINE_FUNCTION( vkCreateShaderModule ) ++ DEFINE_FUNCTION( vkCreateSharedSwapchainsKHR ) ++ DEFINE_FUNCTION( vkCreateSwapchainKHR ) ++ DEFINE_FUNCTION( vkCreateXcbSurfaceKHR ) ++ DEFINE_FUNCTION( vkCreateXlibSurfaceKHR ) ++ DEFINE_FUNCTION( vkDebugReportMessageEXT ) ++ DEFINE_FUNCTION( vkDestroyBuffer ) ++ DEFINE_FUNCTION( vkDestroyBufferView ) ++ DEFINE_FUNCTION( vkDestroyCommandPool ) ++ DEFINE_FUNCTION( vkDestroyDebugReportCallbackEXT ) ++ DEFINE_FUNCTION( vkDestroyDescriptorPool ) ++ DEFINE_FUNCTION( vkDestroyDescriptorSetLayout ) ++ DEFINE_FUNCTION( vkDestroyDevice ) ++ DEFINE_FUNCTION( vkDestroyEvent ) ++ DEFINE_FUNCTION( vkDestroyFence ) ++ DEFINE_FUNCTION( vkDestroyFramebuffer ) ++ DEFINE_FUNCTION( vkDestroyImage ) ++ DEFINE_FUNCTION( vkDestroyImageView ) ++ DEFINE_FUNCTION( vkDestroyInstance ) ++ DEFINE_FUNCTION( vkDestroyPipeline ) ++ DEFINE_FUNCTION( vkDestroyPipelineCache ) ++ DEFINE_FUNCTION( vkDestroyPipelineLayout ) ++ DEFINE_FUNCTION( vkDestroyQueryPool ) ++ DEFINE_FUNCTION( vkDestroyRenderPass ) ++ DEFINE_FUNCTION( vkDestroySampler ) ++ DEFINE_FUNCTION( vkDestroySemaphore ) ++ DEFINE_FUNCTION( vkDestroyShaderModule ) ++ DEFINE_FUNCTION( vkDestroySurfaceKHR ) ++ DEFINE_FUNCTION( vkDestroySwapchainKHR ) ++ DEFINE_FUNCTION( vkDeviceWaitIdle ) ++ DEFINE_FUNCTION( vkEndCommandBuffer ) ++ DEFINE_FUNCTION( vkEnumerateDeviceExtensionProperties ) ++ DEFINE_FUNCTION( vkEnumerateDeviceLayerProperties ) ++ DEFINE_FUNCTION( vkEnumerateInstanceExtensionProperties ) ++ DEFINE_FUNCTION( vkEnumerateInstanceLayerProperties ) ++ DEFINE_FUNCTION( vkEnumeratePhysicalDevices ) ++ DEFINE_FUNCTION( vkFlushMappedMemoryRanges ) ++ DEFINE_FUNCTION( vkFreeCommandBuffers ) ++ DEFINE_FUNCTION( vkFreeDescriptorSets ) ++ DEFINE_FUNCTION( vkFreeMemory ) ++ DEFINE_FUNCTION( vkGetBufferMemoryRequirements ) ++ DEFINE_FUNCTION( vkGetDeviceMemoryCommitment ) ++ DEFINE_FUNCTION( vkGetDeviceProcAddr ) ++ DEFINE_FUNCTION( vkGetDeviceQueue ) ++ DEFINE_FUNCTION( vkGetDisplayModePropertiesKHR ) ++ DEFINE_FUNCTION( vkGetDisplayPlaneCapabilitiesKHR ) ++ DEFINE_FUNCTION( vkGetDisplayPlaneSupportedDisplaysKHR ) ++ DEFINE_FUNCTION( vkGetEventStatus ) ++ DEFINE_FUNCTION( vkGetFenceStatus ) ++ DEFINE_FUNCTION( vkGetImageMemoryRequirements ) ++ DEFINE_FUNCTION( vkGetImageSparseMemoryRequirements ) ++ DEFINE_FUNCTION( vkGetImageSubresourceLayout ) ++ DEFINE_FUNCTION( vkGetInstanceProcAddr ) ++ DEFINE_FUNCTION( vkGetPhysicalDeviceDisplayPlanePropertiesKHR ) ++ DEFINE_FUNCTION( vkGetPhysicalDeviceDisplayPropertiesKHR ) ++ DEFINE_FUNCTION( vkGetPhysicalDeviceFeatures ) ++ DEFINE_FUNCTION( vkGetPhysicalDeviceFormatProperties ) ++ DEFINE_FUNCTION( vkGetPhysicalDeviceImageFormatProperties ) ++ DEFINE_FUNCTION( vkGetPhysicalDeviceMemoryProperties ) ++ DEFINE_FUNCTION( vkGetPhysicalDeviceProperties ) ++ DEFINE_FUNCTION( vkGetPhysicalDeviceQueueFamilyProperties ) ++ DEFINE_FUNCTION( vkGetPhysicalDeviceSparseImageFormatProperties ) ++ DEFINE_FUNCTION( vkGetPhysicalDeviceSurfaceCapabilitiesKHR ) ++ DEFINE_FUNCTION( vkGetPhysicalDeviceSurfaceFormatsKHR ) ++ DEFINE_FUNCTION( vkGetPhysicalDeviceSurfacePresentModesKHR ) ++ DEFINE_FUNCTION( vkGetPhysicalDeviceSurfaceSupportKHR ) ++ DEFINE_FUNCTION( vkGetPipelineCacheData ) ++ DEFINE_FUNCTION( vkGetQueryPoolResults ) ++ DEFINE_FUNCTION( vkGetRenderAreaGranularity ) ++ DEFINE_FUNCTION( vkGetSwapchainImagesKHR ) ++ DEFINE_FUNCTION( vkInvalidateMappedMemoryRanges ) ++ DEFINE_FUNCTION( vkMapMemory ) ++ DEFINE_FUNCTION( vkMergePipelineCaches ) ++ DEFINE_FUNCTION( vkQueueBindSparse ) ++ DEFINE_FUNCTION( vkQueuePresentKHR ) ++ DEFINE_FUNCTION( vkQueueSubmit ) ++ DEFINE_FUNCTION( vkQueueWaitIdle ) ++ DEFINE_FUNCTION( vkResetCommandBuffer ) ++ DEFINE_FUNCTION( vkResetCommandPool ) ++ DEFINE_FUNCTION( vkResetDescriptorPool ) ++ DEFINE_FUNCTION( vkResetEvent ) ++ DEFINE_FUNCTION( vkResetFences ) ++ DEFINE_FUNCTION( vkSetEvent ) ++ DEFINE_FUNCTION( vkUnmapMemory ) ++ DEFINE_FUNCTION( vkUpdateDescriptorSets ) ++ DEFINE_FUNCTION( vkWaitForFences ) ++#undef DEFINE_FUNCTION ++}; ++ ++static void *libvulkan_handle; ++ ++BOOL init_vulkan( void ) ++{ ++ void *ptr; ++ int i; ++ ++ if (!(function_heap = HeapCreate( HEAP_CREATE_ENABLE_EXECUTE, 0, 0 ))) ++ return FALSE; ++ ++ if (!(libvulkan_handle = wine_dlopen( "libvulkan.so", RTLD_NOW, NULL, 0 ))) ++ { ++ ERR_(winediag)( "failed to load libvulkan.so, no support for vulkan\n" ); ++ HeapDestroy( function_heap ); ++ return FALSE; ++ } ++ ++ for (i = 0; i < ARRAY_SIZE(function_table); i++) ++ { ++ if ((ptr = wine_dlsym( libvulkan_handle, function_table[i].name, NULL, 0 ))) ++ *function_table[i].host_func = ptr; ++ else ++ WARN( "failed to load %s\n", function_table[i].name ); ++ } ++ ++ return TRUE; ++} ++ ++BOOL is_null_func( const char *name ) ++{ ++ int i; ++ ++ for (i = 0; i < ARRAY_SIZE(function_table); i++) ++ { ++ if (strcmp( function_table[i].name, name )) continue; ++ return (*function_table[i].host_func == function_table[i].null_func); ++ } ++ ++ return FALSE; ++} ++ ++void free_vulkan( void ) ++{ ++ if (!libvulkan_handle) return; ++ HeapDestroy( function_heap ); ++ wine_dlclose( libvulkan_handle, NULL, 0 ); ++ libvulkan_handle = NULL; ++} +-- +2.7.1 + diff --git a/patches/vulkan-Vulkan_Implementation/definition b/patches/vulkan-Vulkan_Implementation/definition new file mode 100644 index 00000000..3db70a3a --- /dev/null +++ b/patches/vulkan-Vulkan_Implementation/definition @@ -0,0 +1 @@ +Fixes: [40164] Implement support for Vulkan