/* * Copyright (c) 2015-2016 The Khronos Group Inc. * Copyright (c) 2015-2016 Valve Corporation * Copyright (c) 2015-2016 LunarG, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * * Author: Ian Elliott * Author: Jon Ashburn * Author: Ian Elliott * Author: Mark Lobodzinski */ //#define _ISOC11_SOURCE /* for aligned_alloc() */ #define _GNU_SOURCE #include #include #include #include "vk_loader_platform.h" #include "loader.h" #include "wsi.h" #include static const VkExtensionProperties wsi_surface_extension_info = { .extensionName = VK_KHR_SURFACE_EXTENSION_NAME, .specVersion = VK_KHR_SURFACE_SPEC_VERSION, }; #ifdef VK_USE_PLATFORM_WIN32_KHR static const VkExtensionProperties wsi_win32_surface_extension_info = { .extensionName = VK_KHR_WIN32_SURFACE_EXTENSION_NAME, .specVersion = VK_KHR_WIN32_SURFACE_SPEC_VERSION, }; #endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_MIR_KHR static const VkExtensionProperties wsi_mir_surface_extension_info = { .extensionName = VK_KHR_MIR_SURFACE_EXTENSION_NAME, .specVersion = VK_KHR_MIR_SURFACE_SPEC_VERSION, }; #endif // VK_USE_PLATFORM_MIR_KHR #ifdef VK_USE_PLATFORM_WAYLAND_KHR static const VkExtensionProperties wsi_wayland_surface_extension_info = { .extensionName = VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME, .specVersion = VK_KHR_WAYLAND_SURFACE_SPEC_VERSION, }; #endif // VK_USE_PLATFORM_WAYLAND_KHR #ifdef VK_USE_PLATFORM_XCB_KHR static const VkExtensionProperties wsi_xcb_surface_extension_info = { .extensionName = VK_KHR_XCB_SURFACE_EXTENSION_NAME, .specVersion = VK_KHR_XCB_SURFACE_SPEC_VERSION, }; #endif // VK_USE_PLATFORM_XCB_KHR #ifdef VK_USE_PLATFORM_XLIB_KHR static const VkExtensionProperties wsi_xlib_surface_extension_info = { .extensionName = VK_KHR_XLIB_SURFACE_EXTENSION_NAME, .specVersion = VK_KHR_XLIB_SURFACE_SPEC_VERSION, }; #endif // VK_USE_PLATFORM_XLIB_KHR #ifdef VK_USE_PLATFORM_ANDROID_KHR static const VkExtensionProperties wsi_android_surface_extension_info = { .extensionName = VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, .specVersion = VK_KHR_ANDROID_SURFACE_REVISION, }; #endif // VK_USE_PLATFORM_ANDROID_KHR void wsi_create_instance(struct loader_instance *ptr_instance, const VkInstanceCreateInfo *pCreateInfo) { ptr_instance->wsi_surface_enabled = false; #ifdef VK_USE_PLATFORM_WIN32_KHR ptr_instance->wsi_win32_surface_enabled = false; #endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_MIR_KHR ptr_instance->wsi_mir_surface_enabled = false; #endif // VK_USE_PLATFORM_MIR_KHR #ifdef VK_USE_PLATFORM_WAYLAND_KHR ptr_instance->wsi_wayland_surface_enabled = false; #endif // VK_USE_PLATFORM_WAYLAND_KHR #ifdef VK_USE_PLATFORM_XCB_KHR ptr_instance->wsi_xcb_surface_enabled = false; #endif // VK_USE_PLATFORM_XCB_KHR #ifdef VK_USE_PLATFORM_XLIB_KHR ptr_instance->wsi_xlib_surface_enabled = false; #endif // VK_USE_PLATFORM_XLIB_KHR #ifdef VK_USE_PLATFORM_ANDROID_KHR ptr_instance->wsi_android_surface_enabled = false; #endif // VK_USE_PLATFORM_ANDROID_KHR ptr_instance->wsi_display_enabled = false; for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SURFACE_EXTENSION_NAME) == 0) { ptr_instance->wsi_surface_enabled = true; continue; } #ifdef VK_USE_PLATFORM_WIN32_KHR if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_WIN32_SURFACE_EXTENSION_NAME) == 0) { ptr_instance->wsi_win32_surface_enabled = true; continue; } #endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_MIR_KHR if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_MIR_SURFACE_EXTENSION_NAME) == 0) { ptr_instance->wsi_mir_surface_enabled = true; continue; } #endif // VK_USE_PLATFORM_MIR_KHR #ifdef VK_USE_PLATFORM_WAYLAND_KHR if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME) == 0) { ptr_instance->wsi_wayland_surface_enabled = true; continue; } #endif // VK_USE_PLATFORM_WAYLAND_KHR #ifdef VK_USE_PLATFORM_XCB_KHR if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_XCB_SURFACE_EXTENSION_NAME) == 0) { ptr_instance->wsi_xcb_surface_enabled = true; continue; } #endif // VK_USE_PLATFORM_XCB_KHR #ifdef VK_USE_PLATFORM_XLIB_KHR if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_XLIB_SURFACE_EXTENSION_NAME) == 0) { ptr_instance->wsi_xlib_surface_enabled = true; continue; } #endif // VK_USE_PLATFORM_XLIB_KHR #ifdef VK_USE_PLATFORM_ANDROID_KHR if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_ANDROID_SURFACE_EXTENSION_NAME) == 0) { ptr_instance->wsi_android_surface_enabled = true; continue; } #endif // VK_USE_PLATFORM_ANDROID_KHR if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_DISPLAY_EXTENSION_NAME) == 0) { ptr_instance->wsi_display_enabled = true; continue; } } } /* * Linux WSI surface extensions are not always compiled into the loader. (Assume * for Windows the KHR_win32_surface is always compiled into loader). A given * Linux build environment might not have the headers required for building one * of the four extensions (Xlib, Xcb, Mir, Wayland). Thus, need to check if * the built loader actually supports the particular Linux surface extension. * If not supported by the built loader it will not be included in the list of * enumerated instance extensions. This solves the issue where an ICD or layer * advertises support for a given Linux surface extension but the loader was not * built to support the extension. */ bool wsi_unsupported_instance_extension(const VkExtensionProperties *ext_prop) { #ifndef VK_USE_PLATFORM_MIR_KHR if (!strcmp(ext_prop->extensionName, "VK_KHR_mir_surface")) return true; #endif // VK_USE_PLATFORM_MIR_KHR #ifndef VK_USE_PLATFORM_WAYLAND_KHR if (!strcmp(ext_prop->extensionName, "VK_KHR_wayland_surface")) return true; #endif // VK_USE_PLATFORM_WAYLAND_KHR #ifndef VK_USE_PLATFORM_XCB_KHR if (!strcmp(ext_prop->extensionName, "VK_KHR_xcb_surface")) return true; #endif // VK_USE_PLATFORM_XCB_KHR #ifndef VK_USE_PLATFORM_XLIB_KHR if (!strcmp(ext_prop->extensionName, "VK_KHR_xlib_surface")) return true; #endif // VK_USE_PLATFORM_XLIB_KHR return false; } /* * Functions for the VK_KHR_surface extension: */ /* * This is the trampoline entrypoint * for DestroySurfaceKHR */ LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator) { const VkLayerInstanceDispatchTable *disp; disp = loader_get_instance_dispatch(instance); disp->DestroySurfaceKHR(instance, surface, pAllocator); } // TODO probably need to lock around all the loader_get_instance() calls. /* * This is the instance chain terminator function * for DestroySurfaceKHR */ VKAPI_ATTR void VKAPI_CALL terminator_DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator) { struct loader_instance *ptr_instance = loader_get_instance(instance); loader_heap_free(ptr_instance, (void *)surface); } /* * This is the trampoline entrypoint * for GetPhysicalDeviceSurfaceSupportKHR */ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported) { const VkLayerInstanceDispatchTable *disp; VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); disp = loader_get_instance_dispatch(physicalDevice); VkResult res = disp->GetPhysicalDeviceSurfaceSupportKHR( unwrapped_phys_dev, queueFamilyIndex, surface, pSupported); return res; } /* * This is the instance chain terminator function * for GetPhysicalDeviceSurfaceSupportKHR */ VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported) { // First, check to ensure the appropriate extension was enabled: struct loader_physical_device *phys_dev = (struct loader_physical_device *)physicalDevice; struct loader_instance *ptr_instance = (struct loader_instance *)phys_dev->this_icd->this_instance; if (!ptr_instance->wsi_surface_enabled) { loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_VK_KHR_surface extension not enabled. " "vkGetPhysicalDeviceSurfaceSupportKHR not executed!\n"); return VK_SUCCESS; } // Next, if so, proceed with the implementation of this function: struct loader_icd *icd = phys_dev->this_icd; assert(pSupported && "GetPhysicalDeviceSurfaceSupportKHR: Error, null pSupported"); *pSupported = false; assert(icd->GetPhysicalDeviceSurfaceSupportKHR && "loader: null GetPhysicalDeviceSurfaceSupportKHR ICD pointer"); return icd->GetPhysicalDeviceSurfaceSupportKHR( phys_dev->phys_dev, queueFamilyIndex, surface, pSupported); } /* * This is the trampoline entrypoint * for GetPhysicalDeviceSurfaceCapabilitiesKHR */ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) { const VkLayerInstanceDispatchTable *disp; VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); disp = loader_get_instance_dispatch(physicalDevice); VkResult res = disp->GetPhysicalDeviceSurfaceCapabilitiesKHR( unwrapped_phys_dev, surface, pSurfaceCapabilities); return res; } /* * This is the instance chain terminator function * for GetPhysicalDeviceSurfaceCapabilitiesKHR */ VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) { // First, check to ensure the appropriate extension was enabled: struct loader_physical_device *phys_dev = (struct loader_physical_device *)physicalDevice; struct loader_instance *ptr_instance = (struct loader_instance *)phys_dev->this_icd->this_instance; if (!ptr_instance->wsi_surface_enabled) { loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_surface extension not enabled. " "vkGetPhysicalDeviceSurfaceCapabilitiesKHR not executed!\n"); return VK_SUCCESS; } // Next, if so, proceed with the implementation of this function: struct loader_icd *icd = phys_dev->this_icd; assert(pSurfaceCapabilities && "GetPhysicalDeviceSurfaceCapabilitiesKHR: " "Error, null pSurfaceCapabilities"); assert(icd->GetPhysicalDeviceSurfaceCapabilitiesKHR && "loader: null GetPhysicalDeviceSurfaceCapabilitiesKHR ICD pointer"); return icd->GetPhysicalDeviceSurfaceCapabilitiesKHR( phys_dev->phys_dev, surface, pSurfaceCapabilities); } /* * This is the trampoline entrypoint * for GetPhysicalDeviceSurfaceFormatsKHR */ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats) { VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); const VkLayerInstanceDispatchTable *disp; disp = loader_get_instance_dispatch(physicalDevice); VkResult res = disp->GetPhysicalDeviceSurfaceFormatsKHR( unwrapped_phys_dev, surface, pSurfaceFormatCount, pSurfaceFormats); return res; } /* * This is the instance chain terminator function * for GetPhysicalDeviceSurfaceFormatsKHR */ VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats) { // First, check to ensure the appropriate extension was enabled: struct loader_physical_device *phys_dev = (struct loader_physical_device *)physicalDevice; struct loader_instance *ptr_instance = (struct loader_instance *)phys_dev->this_icd->this_instance; if (!ptr_instance->wsi_surface_enabled) { loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_surface extension not enabled. " "vkGetPhysicalDeviceSurfaceFormatsKHR not executed!\n"); return VK_SUCCESS; } // Next, if so, proceed with the implementation of this function: struct loader_icd *icd = phys_dev->this_icd; assert( pSurfaceFormatCount && "GetPhysicalDeviceSurfaceFormatsKHR: Error, null pSurfaceFormatCount"); assert(icd->GetPhysicalDeviceSurfaceFormatsKHR && "loader: null GetPhysicalDeviceSurfaceFormatsKHR ICD pointer"); return icd->GetPhysicalDeviceSurfaceFormatsKHR( phys_dev->phys_dev, surface, pSurfaceFormatCount, pSurfaceFormats); } /* * This is the trampoline entrypoint * for GetPhysicalDeviceSurfacePresentModesKHR */ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes) { VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); const VkLayerInstanceDispatchTable *disp; disp = loader_get_instance_dispatch(physicalDevice); VkResult res = disp->GetPhysicalDeviceSurfacePresentModesKHR( unwrapped_phys_dev, surface, pPresentModeCount, pPresentModes); return res; } /* * This is the instance chain terminator function * for GetPhysicalDeviceSurfacePresentModesKHR */ VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes) { // First, check to ensure the appropriate extension was enabled: struct loader_physical_device *phys_dev = (struct loader_physical_device *)physicalDevice; struct loader_instance *ptr_instance = (struct loader_instance *)phys_dev->this_icd->this_instance; if (!ptr_instance->wsi_surface_enabled) { loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_surface extension not enabled. " "vkGetPhysicalDeviceSurfacePresentModesKHR not executed!\n"); return VK_SUCCESS; } // Next, if so, proceed with the implementation of this function: struct loader_icd *icd = phys_dev->this_icd; assert(pPresentModeCount && "GetPhysicalDeviceSurfacePresentModesKHR: " "Error, null pPresentModeCount"); assert(icd->GetPhysicalDeviceSurfacePresentModesKHR && "loader: null GetPhysicalDeviceSurfacePresentModesKHR ICD pointer"); return icd->GetPhysicalDeviceSurfacePresentModesKHR( phys_dev->phys_dev, surface, pPresentModeCount, pPresentModes); } /* * Functions for the VK_KHR_swapchain extension: */ /* * This is the trampoline entrypoint * for CreateSwapchainKHR */ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); VkResult res = disp->CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); return res; } /* * This is the trampoline entrypoint * for DestroySwapchainKHR */ LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); disp->DestroySwapchainKHR(device, swapchain, pAllocator); } /* * This is the trampoline entrypoint * for GetSwapchainImagesKHR */ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); VkResult res = disp->GetSwapchainImagesKHR( device, swapchain, pSwapchainImageCount, pSwapchainImages); return res; } /* * This is the trampoline entrypoint * for AcquireNextImageKHR */ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(device); VkResult res = disp->AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); return res; } /* * This is the trampoline entrypoint * for QueuePresentKHR */ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) { const VkLayerDispatchTable *disp; disp = loader_get_dispatch(queue); VkResult res = disp->QueuePresentKHR(queue, pPresentInfo); return res; } #ifdef VK_USE_PLATFORM_WIN32_KHR /* * Functions for the VK_KHR_win32_surface extension: */ /* * This is the trampoline entrypoint * for CreateWin32SurfaceKHR */ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { const VkLayerInstanceDispatchTable *disp; disp = loader_get_instance_dispatch(instance); VkResult res; res = disp->CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); return res; } /* * This is the instance chain terminator function * for CreateWin32SurfaceKHR */ VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { // First, check to ensure the appropriate extension was enabled: struct loader_instance *ptr_instance = loader_get_instance(instance); if (!ptr_instance->wsi_win32_surface_enabled) { loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_win32_surface extension not enabled. " "vkCreateWin32SurfaceKHR not executed!\n"); return VK_ERROR_EXTENSION_NOT_PRESENT; } // Next, if so, proceed with the implementation of this function: VkIcdSurfaceWin32 *pIcdSurface = NULL; pIcdSurface = loader_heap_alloc(ptr_instance, sizeof(VkIcdSurfaceWin32), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (pIcdSurface == NULL) { return VK_ERROR_OUT_OF_HOST_MEMORY; } pIcdSurface->base.platform = VK_ICD_WSI_PLATFORM_WIN32; pIcdSurface->hinstance = pCreateInfo->hinstance; pIcdSurface->hwnd = pCreateInfo->hwnd; *pSurface = (VkSurfaceKHR)pIcdSurface; return VK_SUCCESS; } /* * This is the trampoline entrypoint * for GetPhysicalDeviceWin32PresentationSupportKHR */ LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) { VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); const VkLayerInstanceDispatchTable *disp; disp = loader_get_instance_dispatch(physicalDevice); VkBool32 res = disp->GetPhysicalDeviceWin32PresentationSupportKHR( unwrapped_phys_dev, queueFamilyIndex); return res; } /* * This is the instance chain terminator function * for GetPhysicalDeviceWin32PresentationSupportKHR */ VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceWin32PresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) { // First, check to ensure the appropriate extension was enabled: struct loader_physical_device *phys_dev = (struct loader_physical_device *)physicalDevice; struct loader_instance *ptr_instance = (struct loader_instance *)phys_dev->this_icd->this_instance; if (!ptr_instance->wsi_win32_surface_enabled) { loader_log( ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_win32_surface extension not enabled. " "vkGetPhysicalDeviceWin32PresentationSupportKHR not executed!\n"); return VK_SUCCESS; } // Next, if so, proceed with the implementation of this function: struct loader_icd *icd = phys_dev->this_icd; assert(icd->GetPhysicalDeviceWin32PresentationSupportKHR && "loader: null GetPhysicalDeviceWin32PresentationSupportKHR ICD " "pointer"); return icd->GetPhysicalDeviceWin32PresentationSupportKHR(phys_dev->phys_dev, queueFamilyIndex); } #endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_MIR_KHR /* * Functions for the VK_KHR_mir_surface extension: */ /* * This is the trampoline entrypoint * for CreateMirSurfaceKHR */ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR(VkInstance instance, const VkMirSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { const VkLayerInstanceDispatchTable *disp; disp = loader_get_instance_dispatch(instance); VkResult res; res = disp->CreateMirSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); return res; } /* * This is the instance chain terminator function * for CreateMirSurfaceKHR */ VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateMirSurfaceKHR(VkInstance instance, const VkMirSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { // First, check to ensure the appropriate extension was enabled: struct loader_instance *ptr_instance = loader_get_instance(instance); if (!ptr_instance->wsi_mir_surface_enabled) { loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_mir_surface extension not enabled. " "vkCreateMirSurfaceKHR not executed!\n"); return VK_ERROR_EXTENSION_NOT_PRESENT; } // Next, if so, proceed with the implementation of this function: VkIcdSurfaceMir *pIcdSurface = NULL; pIcdSurface = loader_heap_alloc(ptr_instance, sizeof(VkIcdSurfaceMir), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (pIcdSurface == NULL) { return VK_ERROR_OUT_OF_HOST_MEMORY; } pIcdSurface->base.platform = VK_ICD_WSI_PLATFORM_MIR; pIcdSurface->connection = pCreateInfo->connection; pIcdSurface->mirSurface = pCreateInfo->mirSurface; *pSurface = (VkSurfaceKHR)pIcdSurface; return VK_SUCCESS; } /* * This is the trampoline entrypoint * for GetPhysicalDeviceMirPresentationSupportKHR */ LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection *connection) { VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); const VkLayerInstanceDispatchTable *disp; disp = loader_get_instance_dispatch(physicalDevice); VkBool32 res = disp->GetPhysicalDeviceMirPresentationSupportKHR( unwrapped_phys_dev, queueFamilyIndex, connection); return res; } /* * This is the instance chain terminator function * for GetPhysicalDeviceMirPresentationSupportKHR */ VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceMirPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection *connection) { // First, check to ensure the appropriate extension was enabled: struct loader_physical_device *phys_dev = (struct loader_physical_device *)physicalDevice; struct loader_instance *ptr_instance = (struct loader_instance *)phys_dev->this_icd->this_instance; if (!ptr_instance->wsi_mir_surface_enabled) { loader_log( ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_mir_surface extension not enabled. " "vkGetPhysicalDeviceMirPresentationSupportKHR not executed!\n"); return VK_SUCCESS; } // Next, if so, proceed with the implementation of this function: struct loader_icd *icd = phys_dev->this_icd; assert( icd->GetPhysicalDeviceMirPresentationSupportKHR && "loader: null GetPhysicalDeviceMirPresentationSupportKHR ICD pointer"); return icd->GetPhysicalDeviceMirPresentationSupportKHR( phys_dev->phys_dev, queueFamilyIndex, connection); } #endif // VK_USE_PLATFORM_MIR_KHR #ifdef VK_USE_PLATFORM_WAYLAND_KHR /* * Functions for the VK_KHR_wayland_surface extension: */ /* * This is the trampoline entrypoint * for CreateWaylandSurfaceKHR */ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { const VkLayerInstanceDispatchTable *disp; disp = loader_get_instance_dispatch(instance); VkResult res; res = disp->CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); return res; } /* * This is the instance chain terminator function * for CreateWaylandSurfaceKHR */ VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateWaylandSurfaceKHR( VkInstance instance, const VkWaylandSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { // First, check to ensure the appropriate extension was enabled: struct loader_instance *ptr_instance = loader_get_instance(instance); if (!ptr_instance->wsi_wayland_surface_enabled) { loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_wayland_surface extension not enabled. " "vkCreateWaylandSurfaceKHR not executed!\n"); return VK_ERROR_EXTENSION_NOT_PRESENT; } // Next, if so, proceed with the implementation of this function: VkIcdSurfaceWayland *pIcdSurface = NULL; pIcdSurface = loader_heap_alloc(ptr_instance, sizeof(VkIcdSurfaceWayland), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (pIcdSurface == NULL) { return VK_ERROR_OUT_OF_HOST_MEMORY; } pIcdSurface->base.platform = VK_ICD_WSI_PLATFORM_WAYLAND; pIcdSurface->display = pCreateInfo->display; pIcdSurface->surface = pCreateInfo->surface; *pSurface = (VkSurfaceKHR)pIcdSurface; return VK_SUCCESS; } /* * This is the trampoline entrypoint * for GetPhysicalDeviceWaylandPresentationSupportKHR */ LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display *display) { VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); const VkLayerInstanceDispatchTable *disp; disp = loader_get_instance_dispatch(physicalDevice); VkBool32 res = disp->GetPhysicalDeviceWaylandPresentationSupportKHR( unwrapped_phys_dev, queueFamilyIndex, display); return res; } /* * This is the instance chain terminator function * for GetPhysicalDeviceWaylandPresentationSupportKHR */ VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceWaylandPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display *display) { // First, check to ensure the appropriate extension was enabled: struct loader_physical_device *phys_dev = (struct loader_physical_device *)physicalDevice; struct loader_instance *ptr_instance = (struct loader_instance *)phys_dev->this_icd->this_instance; if (!ptr_instance->wsi_wayland_surface_enabled) { loader_log( ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_wayland_surface extension not enabled. " "vkGetPhysicalDeviceWaylandPresentationSupportKHR not executed!\n"); return VK_SUCCESS; } // Next, if so, proceed with the implementation of this function: struct loader_icd *icd = phys_dev->this_icd; assert(icd->GetPhysicalDeviceWaylandPresentationSupportKHR && "loader: null GetPhysicalDeviceWaylandPresentationSupportKHR ICD " "pointer"); return icd->GetPhysicalDeviceWaylandPresentationSupportKHR( phys_dev->phys_dev, queueFamilyIndex, display); } #endif // VK_USE_PLATFORM_WAYLAND_KHR #ifdef VK_USE_PLATFORM_XCB_KHR /* * Functions for the VK_KHR_xcb_surface extension: */ /* * This is the trampoline entrypoint * for CreateXcbSurfaceKHR */ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { const VkLayerInstanceDispatchTable *disp; disp = loader_get_instance_dispatch(instance); VkResult res; res = disp->CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); return res; } /* * This is the instance chain terminator function * for CreateXcbSurfaceKHR */ VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { // First, check to ensure the appropriate extension was enabled: struct loader_instance *ptr_instance = loader_get_instance(instance); if (!ptr_instance->wsi_xcb_surface_enabled) { loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_xcb_surface extension not enabled. " "vkCreateXcbSurfaceKHR not executed!\n"); return VK_ERROR_EXTENSION_NOT_PRESENT; } // Next, if so, proceed with the implementation of this function: VkIcdSurfaceXcb *pIcdSurface = NULL; pIcdSurface = loader_heap_alloc(ptr_instance, sizeof(VkIcdSurfaceXcb), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (pIcdSurface == NULL) { return VK_ERROR_OUT_OF_HOST_MEMORY; } pIcdSurface->base.platform = VK_ICD_WSI_PLATFORM_XCB; pIcdSurface->connection = pCreateInfo->connection; pIcdSurface->window = pCreateInfo->window; *pSurface = (VkSurfaceKHR)pIcdSurface; return VK_SUCCESS; } /* * This is the trampoline entrypoint * for GetPhysicalDeviceXcbPresentationSupportKHR */ LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t *connection, xcb_visualid_t visual_id) { VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); const VkLayerInstanceDispatchTable *disp; disp = loader_get_instance_dispatch(physicalDevice); VkBool32 res = disp->GetPhysicalDeviceXcbPresentationSupportKHR( unwrapped_phys_dev, queueFamilyIndex, connection, visual_id); return res; } /* * This is the instance chain terminator function * for GetPhysicalDeviceXcbPresentationSupportKHR */ VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceXcbPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t *connection, xcb_visualid_t visual_id) { // First, check to ensure the appropriate extension was enabled: struct loader_physical_device *phys_dev = (struct loader_physical_device *)physicalDevice; struct loader_instance *ptr_instance = (struct loader_instance *)phys_dev->this_icd->this_instance; if (!ptr_instance->wsi_xcb_surface_enabled) { loader_log( ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_xcb_surface extension not enabled. " "vkGetPhysicalDeviceXcbPresentationSupportKHR not executed!\n"); return VK_SUCCESS; } // Next, if so, proceed with the implementation of this function: struct loader_icd *icd = phys_dev->this_icd; assert( icd->GetPhysicalDeviceXcbPresentationSupportKHR && "loader: null GetPhysicalDeviceXcbPresentationSupportKHR ICD pointer"); return icd->GetPhysicalDeviceXcbPresentationSupportKHR( phys_dev->phys_dev, queueFamilyIndex, connection, visual_id); } #endif // VK_USE_PLATFORM_XCB_KHR #ifdef VK_USE_PLATFORM_XLIB_KHR /* * Functions for the VK_KHR_xlib_surface extension: */ /* * This is the trampoline entrypoint * for CreateXlibSurfaceKHR */ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { const VkLayerInstanceDispatchTable *disp; disp = loader_get_instance_dispatch(instance); VkResult res; res = disp->CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); return res; } /* * This is the instance chain terminator function * for CreateXlibSurfaceKHR */ VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { // First, check to ensure the appropriate extension was enabled: struct loader_instance *ptr_instance = loader_get_instance(instance); if (!ptr_instance->wsi_xlib_surface_enabled) { loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_xlib_surface extension not enabled. " "vkCreateXlibSurfaceKHR not executed!\n"); return VK_ERROR_EXTENSION_NOT_PRESENT; } // Next, if so, proceed with the implementation of this function: VkIcdSurfaceXlib *pIcdSurface = NULL; pIcdSurface = loader_heap_alloc(ptr_instance, sizeof(VkIcdSurfaceXlib), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (pIcdSurface == NULL) { return VK_ERROR_OUT_OF_HOST_MEMORY; } pIcdSurface->base.platform = VK_ICD_WSI_PLATFORM_XLIB; pIcdSurface->dpy = pCreateInfo->dpy; pIcdSurface->window = pCreateInfo->window; *pSurface = (VkSurfaceKHR)pIcdSurface; return VK_SUCCESS; } /* * This is the trampoline entrypoint * for GetPhysicalDeviceXlibPresentationSupportKHR */ LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display *dpy, VisualID visualID) { VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); const VkLayerInstanceDispatchTable *disp; disp = loader_get_instance_dispatch(physicalDevice); VkBool32 res = disp->GetPhysicalDeviceXlibPresentationSupportKHR( unwrapped_phys_dev, queueFamilyIndex, dpy, visualID); return res; } /* * This is the instance chain terminator function * for GetPhysicalDeviceXlibPresentationSupportKHR */ VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceXlibPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display *dpy, VisualID visualID) { // First, check to ensure the appropriate extension was enabled: struct loader_physical_device *phys_dev = (struct loader_physical_device *)physicalDevice; struct loader_instance *ptr_instance = (struct loader_instance *)phys_dev->this_icd->this_instance; if (!ptr_instance->wsi_xlib_surface_enabled) { loader_log( ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_xlib_surface extension not enabled. " "vkGetPhysicalDeviceXlibPresentationSupportKHR not executed!\n"); return VK_SUCCESS; } // Next, if so, proceed with the implementation of this function: struct loader_icd *icd = phys_dev->this_icd; assert( icd->GetPhysicalDeviceXlibPresentationSupportKHR && "loader: null GetPhysicalDeviceXlibPresentationSupportKHR ICD pointer"); return icd->GetPhysicalDeviceXlibPresentationSupportKHR( phys_dev->phys_dev, queueFamilyIndex, dpy, visualID); } #endif // VK_USE_PLATFORM_XLIB_KHR #ifdef VK_USE_PLATFORM_ANDROID_KHR /* * Functions for the VK_KHR_android_surface extension: */ /* * This is the trampoline entrypoint * for CreateAndroidSurfaceKHR */ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(VkInstance instance, ANativeWindow *window, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { const VkLayerInstanceDispatchTable *disp; disp = loader_get_instance_dispatch(instance); VkResult res; res = disp->CreateAndroidSurfaceKHR(instance, window, pAllocator, pSurface); return res; } /* * This is the instance chain terminator function * for CreateAndroidSurfaceKHR */ VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateAndroidSurfaceKHR(VkInstance instance, Window window, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { // First, check to ensure the appropriate extension was enabled: struct loader_instance *ptr_instance = loader_get_instance(instance); if (!ptr_instance->wsi_display_enabled) { loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_display extension not enabled. " "vkCreateAndroidSurfaceKHR not executed!\n"); return VK_ERROR_EXTENSION_NOT_PRESENT; } // Next, if so, proceed with the implementation of this function: VkIcdSurfaceAndroid *pIcdSurface = NULL; pIcdSurface = loader_heap_alloc(ptr_instance, sizeof(VkIcdSurfaceAndroid), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (pIcdSurface == NULL) { return VK_ERROR_OUT_OF_HOST_MEMORY; } pIcdSurface->base.platform = VK_ICD_WSI_PLATFORM_ANDROID; pIcdSurface->dpy = dpy; pIcdSurface->window = window; *pSurface = (VkSurfaceKHR)pIcdSurface; return VK_SUCCESS; } #endif // VK_USE_PLATFORM_ANDROID_KHR /* * Functions for the VK_KHR_display instance extension: */ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPropertiesKHR *pProperties) { VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); const VkLayerInstanceDispatchTable *disp; disp = loader_get_instance_dispatch(physicalDevice); VkResult res = disp->GetPhysicalDeviceDisplayPropertiesKHR( unwrapped_phys_dev, pPropertyCount, pProperties); return res; } VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPropertiesKHR *pProperties) { // First, check to ensure the appropriate extension was enabled: struct loader_physical_device *phys_dev = (struct loader_physical_device *)physicalDevice; struct loader_instance *ptr_instance = (struct loader_instance *)phys_dev->this_icd->this_instance; if (!ptr_instance->wsi_display_enabled) { loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_display extension not enabled. " "vkGetPhysicalDeviceDisplayPropertiesKHR not executed!\n"); return VK_SUCCESS; } // Next, if so, proceed with the implementation of this function: struct loader_icd *icd = phys_dev->this_icd; assert(icd->GetPhysicalDeviceDisplayPropertiesKHR && "loader: null GetPhysicalDeviceDisplayPropertiesKHR ICD pointer"); return icd->GetPhysicalDeviceDisplayPropertiesKHR( phys_dev->phys_dev, pPropertyCount, pProperties); } LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlanePropertiesKHR *pProperties) { VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); const VkLayerInstanceDispatchTable *disp; disp = loader_get_instance_dispatch(physicalDevice); VkResult res = disp->GetPhysicalDeviceDisplayPlanePropertiesKHR( unwrapped_phys_dev, pPropertyCount, pProperties); return res; } VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlanePropertiesKHR *pProperties) { // First, check to ensure the appropriate extension was enabled: struct loader_physical_device *phys_dev = (struct loader_physical_device *)physicalDevice; struct loader_instance *ptr_instance = (struct loader_instance *)phys_dev->this_icd->this_instance; if (!ptr_instance->wsi_display_enabled) { loader_log( ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_display extension not enabled. " "vkGetPhysicalDeviceDisplayPlanePropertiesKHR not executed!\n"); return VK_SUCCESS; } // Next, if so, proceed with the implementation of this function: struct loader_icd *icd = phys_dev->this_icd; assert( icd->GetPhysicalDeviceDisplayPlanePropertiesKHR && "loader: null GetPhysicalDeviceDisplayPlanePropertiesKHR ICD pointer"); return icd->GetPhysicalDeviceDisplayPlanePropertiesKHR( phys_dev->phys_dev, pPropertyCount, pProperties); } LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t *pDisplayCount, VkDisplayKHR *pDisplays) { VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); const VkLayerInstanceDispatchTable *disp; disp = loader_get_instance_dispatch(physicalDevice); VkResult res = disp->GetDisplayPlaneSupportedDisplaysKHR( unwrapped_phys_dev, planeIndex, pDisplayCount, pDisplays); return res; } VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t *pDisplayCount, VkDisplayKHR *pDisplays) { // First, check to ensure the appropriate extension was enabled: struct loader_physical_device *phys_dev = (struct loader_physical_device *)physicalDevice; struct loader_instance *ptr_instance = (struct loader_instance *)phys_dev->this_icd->this_instance; if (!ptr_instance->wsi_display_enabled) { loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_display extension not enabled. " "vkGetDisplayPlaneSupportedDisplaysKHR not executed!\n"); return VK_SUCCESS; } // Next, if so, proceed with the implementation of this function: struct loader_icd *icd = phys_dev->this_icd; assert(icd->GetDisplayPlaneSupportedDisplaysKHR && "loader: null GetDisplayPlaneSupportedDisplaysKHR ICD pointer"); return icd->GetDisplayPlaneSupportedDisplaysKHR( phys_dev->phys_dev, planeIndex, pDisplayCount, pDisplays); } LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties) { VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); const VkLayerInstanceDispatchTable *disp; disp = loader_get_instance_dispatch(physicalDevice); VkResult res = disp->GetDisplayModePropertiesKHR( unwrapped_phys_dev, display, pPropertyCount, pProperties); return res; } VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayModePropertiesKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties) { // First, check to ensure the appropriate extension was enabled: struct loader_physical_device *phys_dev = (struct loader_physical_device *)physicalDevice; struct loader_instance *ptr_instance = (struct loader_instance *)phys_dev->this_icd->this_instance; if (!ptr_instance->wsi_display_enabled) { loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_display extension not enabled. " "vkGetDisplayModePropertiesKHR not executed!\n"); return VK_SUCCESS; } // Next, if so, proceed with the implementation of this function: struct loader_icd *icd = phys_dev->this_icd; assert(icd->GetDisplayModePropertiesKHR && "loader: null GetDisplayModePropertiesKHR ICD pointer"); return icd->GetDisplayModePropertiesKHR(phys_dev->phys_dev, display, pPropertyCount, pProperties); } LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode) { VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); const VkLayerInstanceDispatchTable *disp; disp = loader_get_instance_dispatch(physicalDevice); VkResult res = disp->CreateDisplayModeKHR(unwrapped_phys_dev, display, pCreateInfo, pAllocator, pMode); return res; } VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode) { // First, check to ensure the appropriate extension was enabled: struct loader_physical_device *phys_dev = (struct loader_physical_device *)physicalDevice; struct loader_instance *ptr_instance = (struct loader_instance *)phys_dev->this_icd->this_instance; if (!ptr_instance->wsi_display_enabled) { loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_display extension not enabled. " "vkCreateDisplayModeKHR not executed!\n"); return VK_ERROR_EXTENSION_NOT_PRESENT; } // Next, if so, proceed with the implementation of this function: struct loader_icd *icd = phys_dev->this_icd; assert(icd->CreateDisplayModeKHR && "loader: null CreateDisplayModeKHR ICD pointer"); return icd->CreateDisplayModeKHR(phys_dev->phys_dev, display, pCreateInfo, pAllocator, pMode); } LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities) { VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); const VkLayerInstanceDispatchTable *disp; disp = loader_get_instance_dispatch(physicalDevice); VkResult res = disp->GetDisplayPlaneCapabilitiesKHR( unwrapped_phys_dev, mode, planeIndex, pCapabilities); return res; } VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities) { // First, check to ensure the appropriate extension was enabled: struct loader_physical_device *phys_dev = (struct loader_physical_device *)physicalDevice; struct loader_instance *ptr_instance = (struct loader_instance *)phys_dev->this_icd->this_instance; if (!ptr_instance->wsi_display_enabled) { loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_display extension not enabled. " "vkGetDisplayPlaneCapabilitiesKHR not executed!\n"); return VK_SUCCESS; } // Next, if so, proceed with the implementation of this function: struct loader_icd *icd = phys_dev->this_icd; assert(icd->GetDisplayPlaneCapabilitiesKHR && "loader: null GetDisplayPlaneCapabilitiesKHR ICD pointer"); return icd->GetDisplayPlaneCapabilitiesKHR(phys_dev->phys_dev, mode, planeIndex, pCapabilities); } LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { const VkLayerInstanceDispatchTable *disp; disp = loader_get_instance_dispatch(instance); VkResult res; res = disp->CreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); return res; } VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDisplayPlaneSurfaceKHR( VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { struct loader_instance *inst = loader_get_instance(instance); VkIcdSurfaceDisplay *pIcdSurface = NULL; if (!inst->wsi_surface_enabled) { loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "VK_KHR_surface extension not enabled. " "vkCreateDisplayPlaneSurfaceKHR not executed!\n"); return VK_ERROR_EXTENSION_NOT_PRESENT; } pIcdSurface = loader_heap_alloc(inst, sizeof(VkIcdSurfaceDisplay), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (pIcdSurface == NULL) { return VK_ERROR_OUT_OF_HOST_MEMORY; } pIcdSurface->base.platform = VK_ICD_WSI_PLATFORM_DISPLAY; pIcdSurface->displayMode = pCreateInfo->displayMode; pIcdSurface->planeIndex = pCreateInfo->planeIndex; pIcdSurface->planeStackIndex = pCreateInfo->planeStackIndex; pIcdSurface->transform = pCreateInfo->transform; pIcdSurface->globalAlpha = pCreateInfo->globalAlpha; pIcdSurface->alphaMode = pCreateInfo->alphaMode; pIcdSurface->imageExtent = pCreateInfo->imageExtent; *pSurface = (VkSurfaceKHR)pIcdSurface; return VK_SUCCESS; } bool wsi_swapchain_instance_gpa(struct loader_instance *ptr_instance, const char *name, void **addr) { *addr = NULL; /* * Functions for the VK_KHR_surface extension: */ if (!strcmp("vkDestroySurfaceKHR", name)) { *addr = ptr_instance->wsi_surface_enabled ? (void *)vkDestroySurfaceKHR : NULL; return true; } if (!strcmp("vkGetPhysicalDeviceSurfaceSupportKHR", name)) { *addr = ptr_instance->wsi_surface_enabled ? (void *)vkGetPhysicalDeviceSurfaceSupportKHR : NULL; return true; } if (!strcmp("vkGetPhysicalDeviceSurfaceCapabilitiesKHR", name)) { *addr = ptr_instance->wsi_surface_enabled ? (void *)vkGetPhysicalDeviceSurfaceCapabilitiesKHR : NULL; return true; } if (!strcmp("vkGetPhysicalDeviceSurfaceFormatsKHR", name)) { *addr = ptr_instance->wsi_surface_enabled ? (void *)vkGetPhysicalDeviceSurfaceFormatsKHR : NULL; return true; } if (!strcmp("vkGetPhysicalDeviceSurfacePresentModesKHR", name)) { *addr = ptr_instance->wsi_surface_enabled ? (void *)vkGetPhysicalDeviceSurfacePresentModesKHR : NULL; return true; } /* * Functions for the VK_KHR_swapchain extension: * * Note: This is a device extension, and its functions are statically * exported from the loader. Per Khronos decisions, the the loader's GIPA * function will return the trampoline function for such device-extension * functions, regardless of whether the extension has been enabled. */ if (!strcmp("vkCreateSwapchainKHR", name)) { *addr = (void *)vkCreateSwapchainKHR; return true; } if (!strcmp("vkDestroySwapchainKHR", name)) { *addr = (void *)vkDestroySwapchainKHR; return true; } if (!strcmp("vkGetSwapchainImagesKHR", name)) { *addr = (void *)vkGetSwapchainImagesKHR; return true; } if (!strcmp("vkAcquireNextImageKHR", name)) { *addr = (void *)vkAcquireNextImageKHR; return true; } if (!strcmp("vkQueuePresentKHR", name)) { *addr = (void *)vkQueuePresentKHR; return true; } #ifdef VK_USE_PLATFORM_WIN32_KHR /* * Functions for the VK_KHR_win32_surface extension: */ if (!strcmp("vkCreateWin32SurfaceKHR", name)) { *addr = ptr_instance->wsi_win32_surface_enabled ? (void *)vkCreateWin32SurfaceKHR : NULL; return true; } if (!strcmp("vkGetPhysicalDeviceWin32PresentationSupportKHR", name)) { *addr = ptr_instance->wsi_win32_surface_enabled ? (void *)vkGetPhysicalDeviceWin32PresentationSupportKHR : NULL; return true; } #endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_MIR_KHR /* * Functions for the VK_KHR_mir_surface extension: */ if (!strcmp("vkCreateMirSurfaceKHR", name)) { *addr = ptr_instance->wsi_mir_surface_enabled ? (void *)vkCreateMirSurfaceKHR : NULL; return true; } if (!strcmp("vkGetPhysicalDeviceMirPresentationSupportKHR", name)) { *addr = ptr_instance->wsi_mir_surface_enabled ? (void *)vkGetPhysicalDeviceMirPresentationSupportKHR : NULL; return true; } #endif // VK_USE_PLATFORM_MIR_KHR #ifdef VK_USE_PLATFORM_WAYLAND_KHR /* * Functions for the VK_KHR_wayland_surface extension: */ if (!strcmp("vkCreateWaylandSurfaceKHR", name)) { *addr = ptr_instance->wsi_wayland_surface_enabled ? (void *)vkCreateWaylandSurfaceKHR : NULL; return true; } if (!strcmp("vkGetPhysicalDeviceWaylandPresentationSupportKHR", name)) { *addr = ptr_instance->wsi_wayland_surface_enabled ? (void *)vkGetPhysicalDeviceWaylandPresentationSupportKHR : NULL; return true; } #endif // VK_USE_PLATFORM_WAYLAND_KHR #ifdef VK_USE_PLATFORM_XCB_KHR /* * Functions for the VK_KHR_xcb_surface extension: */ if (!strcmp("vkCreateXcbSurfaceKHR", name)) { *addr = ptr_instance->wsi_xcb_surface_enabled ? (void *)vkCreateXcbSurfaceKHR : NULL; return true; } if (!strcmp("vkGetPhysicalDeviceXcbPresentationSupportKHR", name)) { *addr = ptr_instance->wsi_xcb_surface_enabled ? (void *)vkGetPhysicalDeviceXcbPresentationSupportKHR : NULL; return true; } #endif // VK_USE_PLATFORM_XCB_KHR #ifdef VK_USE_PLATFORM_XLIB_KHR /* * Functions for the VK_KHR_xlib_surface extension: */ if (!strcmp("vkCreateXlibSurfaceKHR", name)) { *addr = ptr_instance->wsi_xlib_surface_enabled ? (void *)vkCreateXlibSurfaceKHR : NULL; return true; } if (!strcmp("vkGetPhysicalDeviceXlibPresentationSupportKHR", name)) { *addr = ptr_instance->wsi_xlib_surface_enabled ? (void *)vkGetPhysicalDeviceXlibPresentationSupportKHR : NULL; return true; } #endif // VK_USE_PLATFORM_XLIB_KHR #ifdef VK_USE_PLATFORM_ANDROID_KHR /* * Functions for the VK_KHR_android_surface extension: */ if (!strcmp("vkCreateAndroidSurfaceKHR", name)) { *addr = ptr_instance->wsi_xlib_surface_enabled ? (void *)vkCreateAndroidSurfaceKHR : NULL; return true; } #endif // VK_USE_PLATFORM_ANDROID_KHR /* * Functions for VK_KHR_display extension: */ if (!strcmp("vkGetPhysicalDeviceDisplayPropertiesKHR", name)) { *addr = ptr_instance->wsi_display_enabled ? (void *)vkGetPhysicalDeviceDisplayPropertiesKHR : NULL; return true; } if (!strcmp("vkGetPhysicalDeviceDisplayPlanePropertiesKHR", name)) { *addr = ptr_instance->wsi_display_enabled ? (void *)vkGetPhysicalDeviceDisplayPlanePropertiesKHR : NULL; return true; } if (!strcmp("vkGetDisplayPlaneSupportedDisplaysKHR", name)) { *addr = ptr_instance->wsi_display_enabled ? (void *)vkGetDisplayPlaneSupportedDisplaysKHR : NULL; return true; } if (!strcmp("vkGetDisplayModePropertiesKHR", name)) { *addr = ptr_instance->wsi_display_enabled ? (void *)vkGetDisplayModePropertiesKHR : NULL; return true; } if (!strcmp("vkCreateDisplayModeKHR", name)) { *addr = ptr_instance->wsi_display_enabled ? (void *)vkCreateDisplayModeKHR : NULL; return true; } if (!strcmp("vkGetDisplayPlaneCapabilitiesKHR", name)) { *addr = ptr_instance->wsi_display_enabled ? (void *)vkGetDisplayPlaneCapabilitiesKHR : NULL; return true; } if (!strcmp("vkCreateDisplayPlaneSurfaceKHR", name)) { *addr = ptr_instance->wsi_display_enabled ? (void *)vkCreateDisplayPlaneSurfaceKHR : NULL; return true; } return false; }