text: /*
   * Copyright (c) 2015-2021 The Khronos Group Inc.
   * Copyright (c) 2015-2021 Valve Corporation
   * Copyright (c) 2015-2021 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 <ian@lunarg.com>
   * Author: Charles Giessen <charles@lunarg.com>
   *
   */
  
  #pragma once
  
  #include "loader_common.h"
  
  typedef struct {
      union {
  #ifdef VK_USE_PLATFORM_WAYLAND_KHR
          VkIcdSurfaceWayland wayland_surf;
  #endif  // VK_USE_PLATFORM_WAYLAND_KHR
  #ifdef VK_USE_PLATFORM_WIN32_KHR
          VkIcdSurfaceWin32 win_surf;
  #endif  // VK_USE_PLATFORM_WIN32_KHR
  #ifdef VK_USE_PLATFORM_XCB_KHR
          VkIcdSurfaceXcb xcb_surf;
  #endif  // VK_USE_PLATFORM_XCB_KHR
  #ifdef VK_USE_PLATFORM_XLIB_KHR
          VkIcdSurfaceXlib xlib_surf;
  #endif  // VK_USE_PLATFORM_XLIB_KHR
  #ifdef VK_USE_PLATFORM_DIRECTFB_EXT
          VkIcdSurfaceDirectFB directfb_surf;
  #endif  // VK_USE_PLATFORM_DIRECTFB_EXT
  #ifdef VK_USE_PLATFORM_MACOS_MVK
          VkIcdSurfaceMacOS macos_surf;
  #endif  // VK_USE_PLATFORM_MACOS_MVK
  #ifdef VK_USE_PLATFORM_GGP
          VkIcdSurfaceGgp ggp_surf;
  #endif  // VK_USE_PLATFORM_GGP
  #ifdef VK_USE_PLATFORM_FUCHSIA
          VkIcdSurfaceImagePipe imagepipe_surf;
  #endif  // VK_USE_PLATFORM_FUCHSIA
  #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
  #ifdef VK_USE_PLATFORM_VI_NN
          VkIcdSurfaceVi vi_surf;
  #endif  // VK_USE_PLATFORM_VI_NN
  #ifdef VK_USE_PLATFORM_ANDROID_KHR
          VkIcdSurfaceAndroid android_surf;
  #endif // VK_USE_PLATFORM_ANDROID_KHR
          VkIcdSurfaceDisplay display_surf;
          VkIcdSurfaceHeadless headless_surf;
      };
      uint32_t base_size;            // Size of VkIcdSurfaceBase
      uint32_t platform_size;        // Size of corresponding VkIcdSurfaceXXX
      uint32_t non_platform_offset;  // Start offset to base_size
      uint32_t entire_size;          // Size of entire VkIcdSurface
      VkSurfaceKHR *real_icd_surfaces;
  } VkIcdSurface;
  
  bool wsi_swapchain_instance_gpa(struct loader_instance *ptr_instance, const char *name, void **addr);
  
  void wsi_create_instance(struct loader_instance *ptr_instance, const VkInstanceCreateInfo *pCreateInfo);
  bool wsi_unsupported_instance_extension(const VkExtensionProperties *ext_prop);
  
  VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateHeadlessSurfaceEXT(VkInstance instance,
                                                                     const VkHeadlessSurfaceCreateInfoEXT *pCreateInfo,
                                                                     const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
  
  VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo,
                                                               const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain);
  
  VKAPI_ATTR void VKAPI_CALL terminator_DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
                                                          const VkAllocationCallbacks *pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,
                                                                               uint32_t queueFamilyIndex, VkSurfaceKHR surface,
                                                                               VkBool32 *pSupported);
  
  VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice,
                                                                                    VkSurfaceKHR surface,
                                                                                    VkSurfaceCapabilitiesKHR *pSurfaceCapabilities);
  
  VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
                                                                               uint32_t *pSurfaceFormatCount,
                                                                               VkSurfaceFormatKHR *pSurfaceFormats);
  
  VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice,
                                                                                    VkSurfaceKHR surface, uint32_t *pPresentModeCount,
                                                                                    VkPresentModeKHR *pPresentModes);
  
  VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface,
                                                                                 VkDeviceGroupPresentModeFlagsKHR *pModes);
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
                                                                  const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
  VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice,
                                                                                         uint32_t queueFamilyIndex);
  #endif
  #ifdef VK_USE_PLATFORM_WAYLAND_KHR
  VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateWaylandSurfaceKHR(VkInstance instance,
                                                                    const VkWaylandSurfaceCreateInfoKHR *pCreateInfo,
                                                                    const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
  VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice,
                                                                                           uint32_t queueFamilyIndex,
                                                                                           struct wl_display *display);
  #endif
  #ifdef VK_USE_PLATFORM_XCB_KHR
  VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo,
                                                                const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
  
  VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,
                                                                                       uint32_t queueFamilyIndex,
                                                                                       xcb_connection_t *connection,
                                                                                       xcb_visualid_t visual_id);
  #endif
  #ifdef VK_USE_PLATFORM_XLIB_KHR
  VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo,
                                                                 const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
  VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
                                                                                        uint32_t queueFamilyIndex, Display *dpy,
                                                                                        VisualID visualID);
  #endif
  #ifdef VK_USE_PLATFORM_DIRECTFB_EXT
  VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDirectFBSurfaceEXT(VkInstance instance,
                                                                     const VkDirectFBSurfaceCreateInfoEXT *pCreateInfo,
                                                                     const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
  VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceDirectFBPresentationSupportEXT(VkPhysicalDevice physicalDevice,
                                                                                            uint32_t queueFamilyIndex,
                                                                                            IDirectFB *dfb);
  #endif
  #ifdef VK_USE_PLATFORM_MACOS_MVK
  VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK *pCreateInfo,
                                                                  const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
  #endif
  #ifdef VK_USE_PLATFORM_IOS_MVK
  VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK *pCreateInfo,
                                                                const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
  #endif
  #ifdef VK_USE_PLATFORM_GGP
  VKAPI_ATTR VkResult VKAPI_CALL
  terminator_CreateStreamDescriptorSurfaceGGP(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP *pCreateInfo,
                                              const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
  #endif
  #if defined(VK_USE_PLATFORM_METAL_EXT)
  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
  #ifdef VK_USE_PLATFORM_VI_NN
  VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateViSurfaceNN(VkInstance instance, const VkViSurfaceCreateInfoNN *pCreateInfo,
                                                              const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
  #endif  // VK_USE_PLATFORM_VI_NN
  #ifdef VK_USE_PLATFORM_ANDROID_KHR
  VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR *pCreateInfo,
                                                                    const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
  #endif
  VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
                                                                                  uint32_t *pPropertyCount,
                                                                                  VkDisplayPropertiesKHR *pProperties);
  VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice,
                                                                                       uint32_t *pPropertyCount,
                                                                                       VkDisplayPlanePropertiesKHR *pProperties);
  VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex,
                                                                                uint32_t *pDisplayCount, VkDisplayKHR *pDisplays);
  VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
                                                                        uint32_t *pPropertyCount,
                                                                        VkDisplayModePropertiesKHR *pProperties);
  VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
                                                                 const VkDisplayModeCreateInfoKHR *pCreateInfo,
                                                                 const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode);
  VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode,
                                                                           uint32_t planeIndex,
                                                                           VkDisplayPlaneCapabilitiesKHR *pCapabilities);
  VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDisplayPlaneSurfaceKHR(VkInstance instance,
                                                                         const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
                                                                         const VkAllocationCallbacks *pAllocator,
                                                                         VkSurfaceKHR *pSurface);
  
  VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
                                                                      const VkSwapchainCreateInfoKHR *pCreateInfos,
                                                                      const VkAllocationCallbacks *pAllocator,
                                                                      VkSwapchainKHR *pSwapchains);
  
  VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice,
                                                                                  VkSurfaceKHR surface, uint32_t *pRectCount,
                                                                                  VkRect2D *pRects);
  
  VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice,
                                                                                   uint32_t *pPropertyCount,
                                                                                   VkDisplayProperties2KHR *pProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice,
                                                                                        uint32_t *pPropertyCount,
                                                                                        VkDisplayPlaneProperties2KHR *pProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
                                                                         uint32_t *pPropertyCount,
                                                                         VkDisplayModeProperties2KHR *pProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice,
                                                                            const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo,
                                                                            VkDisplayPlaneCapabilities2KHR *pCapabilities);
  #ifdef VK_USE_PLATFORM_FUCHSIA
  VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateImagePipeSurfaceFUCHSIA(VkInstance instance,
                                                                          const VkImagePipeSurfaceCreateInfoFUCHSIA *pCreateInfo,
                                                                          const VkAllocationCallbacks *pAllocator,
                                                                          VkSurfaceKHR *pSurface);
  #endif
  
  #ifdef VK_USE_PLATFORM_ANDROID_KHR
  VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateAndroidSurfaceKHR(VkInstance instance,
                                                                    const VkAndroidSurfaceCreateInfoKHR *pCreateInfo,
                                                                    const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
  #endif
  
  VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilities2KHR(
      VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
      VkSurfaceCapabilities2KHR *pSurfaceCapabilities);
  
  VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice,
                                                                                const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
                                                                                uint32_t *pSurfaceFormatCount,
                                                                                VkSurfaceFormat2KHR *pSurfaceFormats);
  