// // File: vk_icd.h // /* * 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. * */ #ifndef VKICD_H #define VKICD_H #include "vulkan.h" #include <stdbool.h> // Loader-ICD version negotiation API. Versions add the following features: // Version 0 - Initial. Doesn't support vk_icdGetInstanceProcAddr // or vk_icdNegotiateLoaderICDInterfaceVersion. // Version 1 - Add support for vk_icdGetInstanceProcAddr. // Version 2 - Add Loader/ICD Interface version negotiation // via vk_icdNegotiateLoaderICDInterfaceVersion. // Version 3 - Add ICD creation/destruction of KHR_surface objects. // Version 4 - Add unknown physical device extension querying via // vk_icdGetPhysicalDeviceProcAddr. // Version 5 - Tells ICDs that the loader is now paying attention to the // application version of Vulkan passed into the ApplicationInfo // structure during vkCreateInstance. This will tell the ICD // that if the loader is older, it should automatically fail a // call for any API version > 1.0. Otherwise, the loader will // manually determine if it can support the expected version. // Version 6 - Add support for vk_icdEnumerateAdapterPhysicalDevices. #define CURRENT_LOADER_ICD_INTERFACE_VERSION 6 #define MIN_SUPPORTED_LOADER_ICD_INTERFACE_VERSION 0 #define MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION 4 // Old typedefs that don't follow a proper naming convention but are preserved for compatibility typedef VkResult(VKAPI_PTR *PFN_vkNegotiateLoaderICDInterfaceVersion)(uint32_t *pVersion); // This is defined in vk_layer.h which will be found by the loader, but if an ICD is building against this // file directly, it won't be found. #ifndef PFN_GetPhysicalDeviceProcAddr typedef PFN_vkVoidFunction(VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char *pName); #endif // Typedefs for loader/ICD interface typedef VkResult (VKAPI_PTR *PFN_vk_icdNegotiateLoaderICDInterfaceVersion)(uint32_t* pVersion); typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vk_icdGetInstanceProcAddr)(VkInstance instance, const char* pName); typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vk_icdGetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName); #if defined(VK_USE_PLATFORM_WIN32_KHR) typedef VkResult (VKAPI_PTR *PFN_vk_icdEnumerateAdapterPhysicalDevices)(VkInstance instance, LUID adapterLUID, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); #endif // Prototypes for loader/ICD interface #if !defined(VK_NO_PROTOTYPES) #ifdef __cplusplus extern "C" { #endif VKAPI_ATTR VkResult VKAPI_CALL vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t* pVersion); VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetInstanceProcAddr(VkInstance instance, const char* pName); VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetPhysicalDeviceProcAddr(VkInstance isntance, const char* pName); #if defined(VK_USE_PLATFORM_WIN32_KHR) VKAPI_ATTR VkResult VKAPI_CALL vk_icdEnumerateAdapterPhysicalDevices(VkInstance instance, LUID adapterLUID, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); #endif #ifdef __cplusplus } #endif #endif /* * The ICD must reserve space for a pointer for the loader's dispatch * table, at the start of <each object>. * The ICD must initialize this variable using the SET_LOADER_MAGIC_VALUE macro. */ #define ICD_LOADER_MAGIC 0x01CDC0DE typedef union { uintptr_t loaderMagic; void *loaderData; } VK_LOADER_DATA; static inline void set_loader_magic_value(void *pNewObject) { VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject; loader_info->loaderMagic = ICD_LOADER_MAGIC; } static inline bool valid_loader_magic_value(void *pNewObject) { const VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject; return (loader_info->loaderMagic & 0xffffffff) == ICD_LOADER_MAGIC; } /* * Windows and Linux ICDs will treat VkSurfaceKHR as a pointer to a struct that * contains the platform-specific connection and surface information. */ typedef enum { VK_ICD_WSI_PLATFORM_MIR, VK_ICD_WSI_PLATFORM_WAYLAND, VK_ICD_WSI_PLATFORM_WIN32, VK_ICD_WSI_PLATFORM_XCB, VK_ICD_WSI_PLATFORM_XLIB, VK_ICD_WSI_PLATFORM_ANDROID, VK_ICD_WSI_PLATFORM_MACOS, VK_ICD_WSI_PLATFORM_IOS, VK_ICD_WSI_PLATFORM_DISPLAY, VK_ICD_WSI_PLATFORM_HEADLESS, VK_ICD_WSI_PLATFORM_METAL, VK_ICD_WSI_PLATFORM_DIRECTFB, VK_ICD_WSI_PLATFORM_VI, VK_ICD_WSI_PLATFORM_GGP, VK_ICD_WSI_PLATFORM_SCREEN, } VkIcdWsiPlatform; typedef struct { VkIcdWsiPlatform platform; } VkIcdSurfaceBase; #ifdef VK_USE_PLATFORM_MIR_KHR typedef struct { VkIcdSurfaceBase base; MirConnection *connection; MirSurface *mirSurface; } VkIcdSurfaceMir; #endif // VK_USE_PLATFORM_MIR_KHR #ifdef VK_USE_PLATFORM_WAYLAND_KHR typedef struct { VkIcdSurfaceBase base; struct wl_display *display; struct wl_surface *surface; } VkIcdSurfaceWayland; #endif // VK_USE_PLATFORM_WAYLAND_KHR #ifdef VK_USE_PLATFORM_WIN32_KHR typedef struct { VkIcdSurfaceBase base; HINSTANCE hinstance; HWND hwnd; } VkIcdSurfaceWin32; #endif // VK_USE_PLATFORM_WIN32_KHR #ifdef VK_USE_PLATFORM_XCB_KHR typedef struct { VkIcdSurfaceBase base; xcb_connection_t *connection; xcb_window_t window; } VkIcdSurfaceXcb; #endif // VK_USE_PLATFORM_XCB_KHR #ifdef VK_USE_PLATFORM_XLIB_KHR typedef struct { VkIcdSurfaceBase base; Display *dpy; Window window; } VkIcdSurfaceXlib; #endif // VK_USE_PLATFORM_XLIB_KHR #ifdef VK_USE_PLATFORM_DIRECTFB_EXT typedef struct { VkIcdSurfaceBase base; IDirectFB *dfb; IDirectFBSurface *surface; } VkIcdSurfaceDirectFB; #endif // VK_USE_PLATFORM_DIRECTFB_EXT #ifdef VK_USE_PLATFORM_ANDROID_KHR typedef struct { VkIcdSurfaceBase base; struct ANativeWindow *window; } VkIcdSurfaceAndroid; #endif // VK_USE_PLATFORM_ANDROID_KHR #ifdef VK_USE_PLATFORM_MACOS_MVK typedef struct { VkIcdSurfaceBase base; const void *pView; } VkIcdSurfaceMacOS; #endif // VK_USE_PLATFORM_MACOS_MVK #ifdef VK_USE_PLATFORM_IOS_MVK typedef struct { VkIcdSurfaceBase base; const void *pView; } VkIcdSurfaceIOS; #endif // VK_USE_PLATFORM_IOS_MVK #ifdef VK_USE_PLATFORM_GGP typedef struct { VkIcdSurfaceBase base; GgpStreamDescriptor streamDescriptor; } VkIcdSurfaceGgp; #endif // VK_USE_PLATFORM_GGP typedef struct { VkIcdSurfaceBase base; VkDisplayModeKHR displayMode; uint32_t planeIndex; uint32_t planeStackIndex; VkSurfaceTransformFlagBitsKHR transform; float globalAlpha; VkDisplayPlaneAlphaFlagBitsKHR alphaMode; VkExtent2D imageExtent; } VkIcdSurfaceDisplay; typedef struct { VkIcdSurfaceBase base; } VkIcdSurfaceHeadless; #ifdef VK_USE_PLATFORM_METAL_EXT typedef struct { VkIcdSurfaceBase base; const CAMetalLayer *pLayer; } VkIcdSurfaceMetal; #endif // VK_USE_PLATFORM_METAL_EXT #ifdef VK_USE_PLATFORM_VI_NN typedef struct { VkIcdSurfaceBase base; void *window; } VkIcdSurfaceVi; #endif // VK_USE_PLATFORM_VI_NN #ifdef VK_USE_PLATFORM_SCREEN_QNX typedef struct { VkIcdSurfaceBase base; struct _screen_context *context; struct _screen_window *window; } VkIcdSurfaceScreen; #endif // VK_USE_PLATFORM_SCREEN_QNX #endif // VKICD_H