Add support for QNX platform.
diff --git a/BUILD.md b/BUILD.md index 098ce88..69bc8b4 100644 --- a/BUILD.md +++ b/BUILD.md
@@ -172,6 +172,7 @@ | BUILD_WSI_XLIB_SUPPORT | Linux | `ON` | Build the loader with the Xlib entry points enabled. Without this, the X11 headers should not be needed, but the extension `VK_KHR_xlib_surface` won't be available. | | BUILD_WSI_WAYLAND_SUPPORT | Linux | `ON` | Build the loader with the Wayland entry points enabled. Without this, the Wayland headers should not be needed, but the extension `VK_KHR_wayland_surface` won't be available. | | BUILD_WSI_DIRECTFB_SUPPORT | Linux | `OFF` | Build the loader with the DirectFB entry points enabled. Without this, the DirectFB headers should not be needed, but the extension `VK_EXT_directfb_surface` won't be available. | +| BUILD_WSI_SCREEN_SUPPORT | QNX | `OFF` | Build the loader with the QNX Screen entry points enabled. Without this the extension `VK_QNX_screen_surface` won't be available. | | ENABLE_WIN10_ONECORE | Windows | `OFF` | Link the loader to the [OneCore](https://msdn.microsoft.com/en-us/library/windows/desktop/mt654039.aspx) umbrella library, instead of the standard Win32 ones. | | USE_CCACHE | Linux | `OFF` | Enable caching with the CCache program. | | USE_MASM | Windows | `ON` | Controls whether to build assembly files with MS assembler, else fallback to C code |
diff --git a/CMakeLists.txt b/CMakeLists.txt index a26e384..3dadc63 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt
@@ -122,6 +122,7 @@ option(BUILD_WSI_XLIB_SUPPORT "Build Xlib WSI support" ON) option(BUILD_WSI_WAYLAND_SUPPORT "Build Wayland WSI support" ON) option(BUILD_WSI_DIRECTFB_SUPPORT "Build DirectFB WSI support" OFF) + option(BUILD_WSI_SCREEN_SUPPORT "Build QNX Screen WSI support" OFF) if(BUILD_WSI_XCB_SUPPORT) find_package(XCB REQUIRED) @@ -140,6 +141,10 @@ find_package(DirectFB REQUIRED) include_directories(SYSTEM ${DIRECTFB_INCLUDE_DIR}) endif() + + if(BUILD_WSI_SCREEN_SUPPORT) + # Part of OS, no additional include directories are required + endif() endif() if(WIN32)
diff --git a/build-qnx/common.mk b/build-qnx/common.mk new file mode 100644 index 0000000..c5aa587 --- /dev/null +++ b/build-qnx/common.mk
@@ -0,0 +1,44 @@ +ifndef QCONFIG +QCONFIG=qconfig.mk +endif +include $(QCONFIG) + +define PINFO +PINFO DESCRIPTION = "Vulkan ICD Loader" +endef + +ICD_ROOT=$(CURDIR)/../../../.. + +EXTRA_INCVPATH+=$(ICD_ROOT)/build_qnx + +EXTRA_SRCVPATH+=$(ICD_ROOT)/loader +EXTRA_SRCVPATH+=$(ICD_ROOT)/loader/generated + +SO_VERSION=1 +NAME=vulkan + +# Make the library + +SRCS = cJSON.c debug_utils.c dev_ext_trampoline.c loader.c murmurhash.c \ + phys_dev_ext.c trampoline.c unknown_ext_chain.c wsi.c \ + extension_manual.c + +LDFLAGS += -Wl,--unresolved-symbols=report-all -Wl,--no-undefined -Wl,-fPIC + +include $(MKFILES_ROOT)/qtargets.mk + +CCFLAGS += -DVK_USE_PLATFORM_SCREEN_QNX=1 -Dvulkan_EXPORTS +CCFLAGS += -Wall -Wextra -Wno-unused-parameter -Wno-missing-field-initializers +CCFLAGS += -fno-strict-aliasing -fno-builtin-memcmp -Wno-stringop-truncation +CCFLAGS += -Wno-stringop-overflow -Wimplicit-fallthrough=0 -fvisibility=hidden +CCFLAGS += -Wpointer-arith -fPIC + +# Enable this if required +# CCFLAGS += -DVK_ENABLE_BETA_EXTENSIONS + +CXXFLAGS += $(CCFLAGS) + +# cJSON requires math library for pow() function +LIBS += m + +INSTALLDIR=usr/lib
diff --git a/build-qnx/loader_cmake_config.h b/build-qnx/loader_cmake_config.h new file mode 100644 index 0000000..37d318f --- /dev/null +++ b/build-qnx/loader_cmake_config.h
@@ -0,0 +1,2 @@ +#undef HAVE_SECURE_GETENV +#undef HAVE___SECURE_GETENV
diff --git a/loader/CMakeLists.txt b/loader/CMakeLists.txt index db1ad78..7c07efc 100644 --- a/loader/CMakeLists.txt +++ b/loader/CMakeLists.txt
@@ -57,6 +57,10 @@ if(BUILD_WSI_DIRECTFB_SUPPORT) set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS VK_USE_PLATFORM_DIRECTFB_EXT) endif() + + if(BUILD_WSI_SCREEN_SUPPORT) + set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS VK_USE_PLATFORM_SCREEN_QNX) + endif() else() message(FATAL_ERROR "Unsupported Platform!") endif() @@ -284,6 +288,7 @@ ${VulkanHeaders_INCLUDE_DIRS}/vulkan/vulkan_xcb.h ${VulkanHeaders_INCLUDE_DIRS}/vulkan/vulkan_xlib.h ${VulkanHeaders_INCLUDE_DIRS}/vulkan/vulkan_xlib_xrandr.h + ${VulkanHeaders_INCLUDE_DIRS}/vulkan/vulkan_screen.h ${VulkanHeaders_INCLUDE_DIRS}/vulkan/vulkan.h ${VulkanHeaders_INCLUDE_DIRS}/vulkan/vulkan.hpp) if(BUILD_STATIC_LOADER)
diff --git a/loader/LoaderAndLayerInterface.md b/loader/LoaderAndLayerInterface.md index 257deee..98d8d9b 100644 --- a/loader/LoaderAndLayerInterface.md +++ b/loader/LoaderAndLayerInterface.md
@@ -697,6 +697,7 @@ | Linux (Wayland) | VK_KHR_wayland_surface | | Linux (X11) | VK_KHR_xcb_surface and VK_KHR_xlib_surface | | macOS (MoltenVK) | VK_MVK_macos_surface | +| QNX (Screen) | VK_QNX_screen_surface | It is important to understand that while the loader may support the various entry points for these extensions, there is a handshake required to actually @@ -2553,9 +2554,9 @@ ### Handling KHR Surface Objects in WSI Extensions Normally, ICDs handle object creation and destruction for various Vulkan -objects. The WSI surface extensions for Linux, Windows, and macOS +objects. The WSI surface extensions for Linux, Windows, macOS, and QNX ("VK\_KHR\_win32\_surface", "VK\_KHR\_xcb\_surface", "VK\_KHR\_xlib\_surface", -"VK\_KHR\_wayland\_surface", "VK\_MVK\_macos\_surface" +"VK\_KHR\_wayland\_surface", "VK\_MVK\_macos\_surface", "VK\_QNX\_screen\_surface" and "VK\_KHR\_surface") are handled differently. For these extensions, the `VkSurfaceKHR` object creation and destruction may be handled by either the loader or an ICD. @@ -2571,6 +2572,7 @@ * Windows * Android * MacOS (`vkCreateMacOSSurfaceMVK`) + * QNX (`vkCreateScreenSurfaceQNX`) 2. The loader creates a `VkIcdSurfaceXXX` object for the corresponding `vkCreateXXXSurfaceKHR` call. * The `VkIcdSurfaceXXX` structures are defined in `include/vulkan/vk_icd.h`. @@ -2578,7 +2580,7 @@ `VkIcdSurfaceXXX` structure. 4. The first field of all the `VkIcdSurfaceXXX` structures is a `VkIcdSurfaceBase` enumerant that indicates whether the - surface object is Win32, XCB, Xlib, or Wayland. + surface object is Win32, XCB, Xlib, Wayland, or Screen. The ICD may choose to handle `VkSurfaceKHR` object creation instead. If an ICD desires to handle creating and destroying it must do the following:
diff --git a/loader/loader.c b/loader/loader.c index 6a60ee7..e12b24d 100644 --- a/loader/loader.c +++ b/loader/loader.c
@@ -253,7 +253,7 @@ } // Environment variables -#if defined(__linux__) || defined(__APPLE__) || defined(__Fuchsia__) +#if defined(__linux__) || defined(__APPLE__) || defined(__Fuchsia__) || defined(__QNXNTO__) static inline bool IsHighIntegrity() { return geteuid() != getuid() || getegid() != getgid(); @@ -3940,7 +3940,7 @@ if (xdgdatadirs == NULL) { xdgdata_alloc = false; } -#if !defined(__Fuchsia__) +#if !defined(__Fuchsia__) && !defined(__QNXNTO__) if (xdgconfdirs == NULL || xdgconfdirs[0] == '\0') { xdgconfdirs = FALLBACK_CONFIG_DIRS; }
diff --git a/loader/loader.h b/loader/loader.h index ea0c976..2182f18 100644 --- a/loader/loader.h +++ b/loader/loader.h
@@ -348,6 +348,9 @@ #ifdef VK_USE_PLATFORM_FUCHSIA bool wsi_imagepipe_surface_enabled; #endif +#ifdef VK_USE_PLATFORM_SCREEN_QNX + bool wsi_screen_surface_enabled; +#endif bool wsi_display_enabled; bool wsi_display_props2_enabled; };
diff --git a/loader/vk_loader_platform.h b/loader/vk_loader_platform.h index abf078c..437b3c3 100644 --- a/loader/vk_loader_platform.h +++ b/loader/vk_loader_platform.h
@@ -35,7 +35,7 @@ #include "vulkan/vk_platform.h" #include "vulkan/vk_sdk_platform.h" -#if defined(__linux__) || defined(__APPLE__) || defined(__Fuchsia__) +#if defined(__linux__) || defined(__APPLE__) || defined(__Fuchsia__) || defined(__QNXNTO__) /* Linux-specific common code: */ // Headers: @@ -124,7 +124,31 @@ } #elif defined(__Fuchsia__) static inline char *loader_platform_executable_path(char *buffer, size_t size) { return NULL; } -#endif // defined (__APPLE__) +#elif defined(__QNXNTO__) + +#define SYSCONFDIR "/etc" + +#include <fcntl.h> +#include <sys/stat.h> + +static inline char *loader_platform_executable_path(char *buffer, size_t size) { + int fd = open("/proc/self/exefile", O_RDONLY); + size_t rdsize; + + if (fd == -1 ) { + return NULL; + } + + rdsize = read(fd, buffer, size); + if (rdsize == size) { + return NULL; + } + buffer[rdsize] = 0x00; + close(fd); + + return buffer; +} +#endif // defined (__QNXNTO__) // Compatability with compilers that don't support __has_feature #ifndef __has_feature
diff --git a/loader/wsi.c b/loader/wsi.c index 756225a..7e87776 100644 --- a/loader/wsi.c +++ b/loader/wsi.c
@@ -75,6 +75,9 @@ #ifdef VK_USE_PLATFORM_METAL_EXT ptr_instance->wsi_metal_surface_enabled = false; #endif // VK_USE_PLATFORM_METAL_EXT +#ifdef VK_USE_PLATFORM_SCREEN_QNX + ptr_instance->wsi_screen_surface_enabled = false; +#endif // VK_USE_PLATFORM_SCREEN_QNX for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SURFACE_EXTENSION_NAME) == 0) { @@ -151,6 +154,12 @@ continue; } #endif +#if defined(VK_USE_PLATFORM_SCREEN_QNX) + if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_QNX_SCREEN_SURFACE_EXTENSION_NAME) == 0) { + ptr_instance->wsi_screen_surface_enabled = true; + continue; + } +#endif // VK_USE_PLATFORM_SCREEN_QNX if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_DISPLAY_EXTENSION_NAME) == 0) { ptr_instance->wsi_display_enabled = true; continue; @@ -184,6 +193,9 @@ #ifndef VK_USE_PLATFORM_DIRECTFB_EXT if (!strcmp(ext_prop->extensionName, "VK_EXT_directfb_surface")) return true; #endif // VK_USE_PLATFORM_DIRECTFB_EXT +#ifndef VK_USE_PLATFORM_SCREEN_QNX + if (!strcmp(ext_prop->extensionName, "VK_QNX_screen_surface")) return true; +#endif // VK_USE_PLATFORM_WAYLAND_KHR return false; } @@ -1469,6 +1481,120 @@ #endif +#ifdef VK_USE_PLATFORM_SCREEN_QNX + +// This is the trampoline entrypoint for CreateScrenSurfaceQNX +LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateScreenSurfaceQNX(VkInstance instance, + const VkScreenSurfaceCreateInfoQNX *pCreateInfo, + const VkAllocationCallbacks *pAllocator, + VkSurfaceKHR *pSurface) { + const VkLayerInstanceDispatchTable *disp; + disp = loader_get_instance_layer_dispatch(instance); + VkResult res; + + res = disp->CreateScreenSurfaceQNX(instance, pCreateInfo, pAllocator, pSurface); + return res; +} + +// This is the instance chain terminator function for CreateScreenSurfaceQNX +VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateScreenSurfaceQNX(VkInstance instance, + const VkScreenSurfaceCreateInfoQNX *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) { + VkResult vkRes = VK_SUCCESS; + VkIcdSurface *pIcdSurface = NULL; + uint32_t i = 0; + + // First, check to ensure the appropriate extension was enabled: + struct loader_instance *ptr_instance = loader_get_instance(instance); + if (!ptr_instance->wsi_screen_surface_enabled) { + loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, + "VK_QNX_screen_surface extension not enabled. vkCreateScreenSurfaceQNX not executed!\n"); + vkRes = VK_ERROR_EXTENSION_NOT_PRESENT; + goto out; + } + + // Next, if so, proceed with the implementation of this function: + pIcdSurface = AllocateIcdSurfaceStruct(ptr_instance, sizeof(pIcdSurface->screen_surf.base), sizeof(pIcdSurface->screen_surf)); + if (pIcdSurface == NULL) { + vkRes = VK_ERROR_OUT_OF_HOST_MEMORY; + goto out; + } + + pIcdSurface->screen_surf.base.platform = VK_ICD_WSI_PLATFORM_SCREEN; + pIcdSurface->screen_surf.context = pCreateInfo->context; + pIcdSurface->screen_surf.window = pCreateInfo->window; + + // Loop through each ICD and determine if they need to create a surface + for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) { + if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) { + if (NULL != icd_term->dispatch.CreateScreenSurfaceQNX) { + vkRes = icd_term->dispatch.CreateScreenSurfaceQNX(icd_term->instance, pCreateInfo, pAllocator, + &pIcdSurface->real_icd_surfaces[i]); + if (VK_SUCCESS != vkRes) { + goto out; + } + } + } + } + + *pSurface = (VkSurfaceKHR)pIcdSurface; + +out: + + if (VK_SUCCESS != vkRes && NULL != pIcdSurface) { + if (NULL != pIcdSurface->real_icd_surfaces) { + i = 0; + for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) { + if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] && NULL != icd_term->dispatch.DestroySurfaceKHR) { + icd_term->dispatch.DestroySurfaceKHR(icd_term->instance, pIcdSurface->real_icd_surfaces[i], pAllocator); + } + } + loader_instance_heap_free(ptr_instance, pIcdSurface->real_icd_surfaces); + } + loader_instance_heap_free(ptr_instance, pIcdSurface); + } + + return vkRes; +} + +// This is the trampoline entrypoint for +// GetPhysicalDeviceScreenPresentationSupportQNX +LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct _screen_window *window) { + VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); + const VkLayerInstanceDispatchTable *disp; + disp = loader_get_instance_layer_dispatch(physicalDevice); + VkBool32 res = disp->GetPhysicalDeviceScreenPresentationSupportQNX(unwrapped_phys_dev, queueFamilyIndex, window); + return res; +} + +// This is the instance chain terminator function for +// GetPhysicalDeviceScreenPresentationSupportQNX +VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct _screen_window *window) { + // First, check to ensure the appropriate extension was enabled: + struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; + struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; + struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance; + if (!ptr_instance->wsi_screen_surface_enabled) { + loader_log( + ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, + "VK_QNX_screen_surface extension not enabled. vkGetPhysicalDeviceScreenPresentationSupportQNX not executed!\n"); + return VK_SUCCESS; + } + + if (NULL == icd_term->dispatch.GetPhysicalDeviceScreenPresentationSupportQNX) { + loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, + "ICD for selected physical device is not exporting vkGetPhysicalDeviceScreenPresentationSupportQNX!\n"); + assert(false && "loader: null GetPhysicalDeviceScreenPresentationSupportQNX ICD pointer"); + } + + return icd_term->dispatch.GetPhysicalDeviceScreenPresentationSupportQNX(phys_dev_term->phys_dev, queueFamilyIndex, window); +} +#endif // VK_USE_PLATFORM_SCREEN_QNX + // Functions for the VK_KHR_display instance extension: LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, @@ -2468,6 +2594,19 @@ } #endif // VK_USE_PLATFORM_METAL_EXT +#ifdef VK_USE_PLATFORM_SCREEN_QNX + + // Functions for the VK_QNX_screen_surface extension: + if (!strcmp("vkCreateScreenSurfaceQNX", name)) { + *addr = ptr_instance->wsi_screen_surface_enabled ? (void *)vkCreateScreenSurfaceQNX : NULL; + return true; + } + if (!strcmp("vkGetPhysicalDeviceScreenPresentationSupportQNX", name)) { + *addr = ptr_instance->wsi_screen_surface_enabled ? (void *)vkGetPhysicalDeviceScreenPresentationSupportQNX : NULL; + return true; + } +#endif // VK_USE_PLATFORM_SCREEN_QNX + // Functions for VK_KHR_display extension: if (!strcmp("vkGetPhysicalDeviceDisplayPropertiesKHR", name)) { *addr = ptr_instance->wsi_display_enabled ? (void *)vkGetPhysicalDeviceDisplayPropertiesKHR : NULL;
diff --git a/loader/wsi.h b/loader/wsi.h index cad0d45..fbeeb2e 100644 --- a/loader/wsi.h +++ b/loader/wsi.h
@@ -54,6 +54,9 @@ #ifdef VK_USE_PLATFORM_METAL_EXT VkIcdSurfaceMetal metal_surf; #endif // VK_USE_PLATFORM_METAL_EXT +#ifdef VK_USE_PLATFORM_SCREEN_QNX + VkIcdSurfaceScreen screen_surf; +#endif // VK_USE_PLATFORM_SCREEN_QNX VkIcdSurfaceDisplay display_surf; VkIcdSurfaceHeadless headless_surf; }; @@ -155,6 +158,14 @@ VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateMetalSurfaceEXT(VkInstance instance, const VkMetalSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface); #endif +#ifdef VK_USE_PLATFORM_SCREEN_QNX +VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateScreenSurfaceQNX(VkInstance instance, + const VkScreenSurfaceCreateInfoQNX *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface); +VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct _screen_window *window); +#endif // VK_USE_PLATFORM_SCREEN_QNX VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPropertiesKHR *pProperties);
diff --git a/scripts/loader_extension_generator.py b/scripts/loader_extension_generator.py index e8c4ac6..421dc84 100644 --- a/scripts/loader_extension_generator.py +++ b/scripts/loader_extension_generator.py
@@ -44,7 +44,8 @@ 'VK_KHR_swapchain', 'VK_KHR_display_swapchain', 'VK_KHR_get_display_properties2', - 'VK_KHR_get_surface_capabilities2'] + 'VK_KHR_get_surface_capabilities2', + 'VK_QNX_screen_surface'] ADD_INST_CMDS = ['vkCreateInstance', 'vkEnumerateInstanceExtensionProperties',
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 7e6d4fd..fe8d965 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt
@@ -45,6 +45,10 @@ if(BUILD_WSI_WAYLAND_SUPPORT) add_definitions(-DVK_USE_PLATFORM_WAYLAND_KHR) endif() + + if(BUILD_WSI_SCREEN_SUPPORT) + add_definitions(-DVK_USE_PLATFORM_SCREEN_QNX) + endif() else() message(FATAL_ERROR "Unsupported Platform!") endif()
diff --git a/tests/layers/wrap_objects.cpp b/tests/layers/wrap_objects.cpp index f25ff27..4317fde 100644 --- a/tests/layers/wrap_objects.cpp +++ b/tests/layers/wrap_objects.cpp
@@ -1104,6 +1104,25 @@ } #endif // VK_USE_PLATFORM_WAYLAND_KHR +#ifdef VK_USE_PLATFORM_SCREEN_QNX + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateScreenSurfaceQNX(VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) +{ + wrapped_inst_obj *inst; + auto vk_inst = unwrap_instance(instance, &inst); + VkResult result = inst->layer_disp.CreateScreenSurfaceQNX(vk_inst, pCreateInfo, pAllocator, pSurface); + return result; +} + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window* window) +{ + wrapped_phys_dev_obj *phys_dev; + auto vk_phys_dev = unwrap_phys_dev(physicalDevice, &phys_dev); + VkBool32 result = phys_dev->inst->layer_disp.GetPhysicalDeviceScreenPresentationSupportQNX(vk_phys_dev, queueFamilyIndex, window); + return result; +} +#endif // VK_USE_PLATFORM_SCREEN_QNX + VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pMsgCallback) {