/*

 * Copyright (c) 2015-2022 The Khronos Group Inc.

 * Copyright (c) 2015-2022 Valve Corporation

 * Copyright (c) 2015-2022 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: Jon Ashburn <jon@lunarg.com>

 * Author: Ian Elliott <ianelliott@google.com>

 * Author: Mark Lobodzinski <mark@lunarg.com>

 * Author: Lenny Komow <lenny@lunarg.com>

 * Author: Charles Giessen <charles@lunarg.com>

 */

#include <stdio.h>

#include <stdlib.h>

#include <vulkan/vk_icd.h>

#include "allocation.h"

#include "loader.h"

#include "log.h"

#include "stack_allocation.h"

#include "vk_loader_platform.h"

#include "wsi.h"

// The first ICD/Loader interface that support querying the SurfaceKHR from

// the ICDs.

#define ICD_VER_SUPPORTS_ICD_SURFACE_KHR 3

struct loader_struct_type_info {

    VkStructureType stype;

    size_t size;

};

// This function unwraps the application-provided surface handle into the ICD-specific surface handle

// corresponding to the specified physical device. If the ICD-specific surface handle does not exist

// yet, then this function also creates of the ICD-specific surface object. This enables lazy creation

// of ICD-specific surface objects and therefore avoids creating surfaces for ICDs that may not be able

// to or should not create the specific type of surface (one example is the VK_KHR_display extension

// where the VkDisplayModeKHR handles the surfaces are created from are physical-device-specific

// non-dispatchable handles and therefore they should not be passed down to a foreign ICD).

VkResult wsi_unwrap_icd_surface(struct loader_icd_term *icd_term, VkSurfaceKHR *surface) {

    VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)(*surface);

#if defined(VK_USE_PLATFORM_ANDROID_KHR)

    if (icd_surface->base.platform == VK_ICD_WSI_PLATFORM_ANDROID) {

        // Android does not use ICD-created surfaces

        // NOTE: This may be incorrect and in fact the legacy code could result in out-of-bounds

        // accesses to VkIcdSurface::surface_index in case of Android, but we preserved the legacy

        // behavior (while also eliminating the chance for out-of-bounds accesses).

        return VK_SUCCESS;

    }

#endif  // VK_USE_PLATFORM_ANDROID_KHR

#if defined(VK_USE_PLATFORM_MACOS_MVK)

    if (icd_surface->base.platform == VK_ICD_WSI_PLATFORM_IOS) {

        // iOS does not use ICD-created surfaces (matching legacy behavior)

        // NOTE: This may be incorrect and in fact the legacy code could result in out-of-bounds

        // accesses to VkIcdSurface::surface_index in case of Android, but we preserved the legacy

        // behavior (while also eliminating the chance for out-of-bounds accesses).

        return VK_SUCCESS;

    }

#endif  // VK_USE_PLATFORM_MACOS_MVK

    if (NULL == icd_term->surface_list.list ||

        icd_term->surface_list.capacity <= icd_surface->surface_index * sizeof(VkSurfaceKHR)) {

        // This surface handle is not one that was created by the loader, therefore we simply return

        // the input surface handle unmodified. This matches legacy behavior.

        return VK_SUCCESS;

    }

    VkResult result = VK_SUCCESS;

    if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {

        VkAllocationCallbacks *pAllocator = icd_surface->callbacks_valid ? &icd_surface->callbacks : NULL;

        if (VK_NULL_HANDLE == icd_term->surface_list.list[icd_surface->surface_index]) {

            // If the surface does not exist yet for the target ICD, then create it lazily

            switch (icd_surface->base.platform) {

#if defined(VK_USE_PLATFORM_WAYLAND_KHR)

                case VK_ICD_WSI_PLATFORM_WAYLAND:

                    if (NULL != icd_term->dispatch.CreateWaylandSurfaceKHR &&

                        icd_term->enabled_instance_extensions.khr_wayland_surface) {

                        result = icd_term->dispatch.CreateWaylandSurfaceKHR(

                            icd_term->instance, (const VkWaylandSurfaceCreateInfoKHR *)icd_surface->create_info, pAllocator,

                            &icd_term->surface_list.list[icd_surface->surface_index]);

                    } else {

                        result = VK_ERROR_EXTENSION_NOT_PRESENT;

                    }

                    break;

#endif  // VK_USE_PLATFORM_WAYLAND_KHR

#if defined(VK_USE_PLATFORM_WIN32_KHR)

                case VK_ICD_WSI_PLATFORM_WIN32:

                    if (NULL != icd_term->dispatch.CreateWin32SurfaceKHR &&

                        icd_term->enabled_instance_extensions.khr_win32_surface) {

                        result = icd_term->dispatch.CreateWin32SurfaceKHR(

                            icd_term->instance, (const VkWin32SurfaceCreateInfoKHR *)icd_surface->create_info, pAllocator,

                            &icd_term->surface_list.list[icd_surface->surface_index]);

                    } else {

                        result = VK_ERROR_EXTENSION_NOT_PRESENT;

                    }

                    break;

#endif  // VK_USE_PLATFORM_WIN32_KHR

#if defined(VK_USE_PLATFORM_XCB_KHR)

                case VK_ICD_WSI_PLATFORM_XCB:

                    if (NULL != icd_term->dispatch.CreateXcbSurfaceKHR && icd_term->enabled_instance_extensions.khr_xcb_surface) {

                        result = icd_term->dispatch.CreateXcbSurfaceKHR(

                            icd_term->instance, (const VkXcbSurfaceCreateInfoKHR *)icd_surface->create_info, pAllocator,

                            &icd_term->surface_list.list[icd_surface->surface_index]);

                    } else {

                        result = VK_ERROR_EXTENSION_NOT_PRESENT;

                    }

                    break;

#endif  // VK_USE_PLATFORM_XCB_KHR

#if defined(VK_USE_PLATFORM_XLIB_KHR)

                case VK_ICD_WSI_PLATFORM_XLIB:

                    if (NULL != icd_term->dispatch.CreateXlibSurfaceKHR && icd_term->enabled_instance_extensions.khr_xlib_surface) {

                        result = icd_term->dispatch.CreateXlibSurfaceKHR(

                            icd_term->instance, (const VkXlibSurfaceCreateInfoKHR *)icd_surface->create_info, pAllocator,

                            &icd_term->surface_list.list[icd_surface->surface_index]);

                    } else {

                        result = VK_ERROR_EXTENSION_NOT_PRESENT;

                    }

                    break;

#endif  // VK_USE_PLATFORM_XLIB_KHR

#if defined(VK_USE_PLATFORM_MACOS_MVK)

                case VK_ICD_WSI_PLATFORM_MACOS:

                    if (NULL != icd_term->dispatch.CreateMacOSSurfaceMVK &&

                        icd_term->enabled_instance_extensions.mvk_macos_surface) {

                        result = icd_term->dispatch.CreateMacOSSurfaceMVK(

                            icd_term->instance, (const VkMacOSSurfaceCreateInfoMVK *)icd_surface->create_info, pAllocator,

                            &icd_term->surface_list.list[icd_surface->surface_index]);

                    } else {

                        result = VK_ERROR_EXTENSION_NOT_PRESENT;

                    }

                    break;

#endif  // VK_USE_PLATFORM_MACOS_MVK

                case VK_ICD_WSI_PLATFORM_DISPLAY:

                    if (NULL != icd_term->dispatch.CreateDisplayPlaneSurfaceKHR &&

                        icd_term->enabled_instance_extensions.khr_display) {

                        result = icd_term->dispatch.CreateDisplayPlaneSurfaceKHR(

                            icd_term->instance, (const VkDisplaySurfaceCreateInfoKHR *)icd_surface->create_info, pAllocator,

                            &icd_term->surface_list.list[icd_surface->surface_index]);

                    } else {

                        result = VK_ERROR_EXTENSION_NOT_PRESENT;

                    }

                    break;

                case VK_ICD_WSI_PLATFORM_HEADLESS:

                    if (NULL != icd_term->dispatch.CreateHeadlessSurfaceEXT &&

                        icd_term->enabled_instance_extensions.ext_headless_surface) {

                        result = icd_term->dispatch.CreateHeadlessSurfaceEXT(

                            icd_term->instance, (const VkHeadlessSurfaceCreateInfoEXT *)icd_surface->create_info, pAllocator,

                            &icd_term->surface_list.list[icd_surface->surface_index]);

                    } else {

                        result = VK_ERROR_EXTENSION_NOT_PRESENT;

                    }

                    break;

#if defined(VK_USE_PLATFORM_METAL_EXT)

                case VK_ICD_WSI_PLATFORM_METAL:

                    if (NULL != icd_term->dispatch.CreateMetalSurfaceEXT &&

                        icd_term->enabled_instance_extensions.ext_metal_surface) {

                        result = icd_term->dispatch.CreateMetalSurfaceEXT(

                            icd_term->instance, (const VkMetalSurfaceCreateInfoEXT *)icd_surface->create_info, pAllocator,

                            &icd_term->surface_list.list[icd_surface->surface_index]);

                    } else {

                        result = VK_ERROR_EXTENSION_NOT_PRESENT;

                    }

                    break;

#endif  // VK_USE_PLATFORM_METAL_EXT

#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)

                case VK_ICD_WSI_PLATFORM_DIRECTFB:

                    if (NULL != icd_term->dispatch.CreateDirectFBSurfaceEXT &&

                        icd_term->enabled_instance_extensions.ext_directfb_surface) {

                        result = icd_term->dispatch.CreateDirectFBSurfaceEXT(

                            icd_term->instance, (const VkDirectFBSurfaceCreateInfoEXT *)icd_surface->create_info, pAllocator,

                            &icd_term->surface_list.list[icd_surface->surface_index]);

                    } else {

                        result = VK_ERROR_EXTENSION_NOT_PRESENT;

                    }

                    break;

#endif  // VK_USE_PLATFORM_DIRECTFB_EXT

#if defined(VK_USE_PLATFORM_VI_NN)

                case VK_ICD_WSI_PLATFORM_VI:

                    if (NULL != icd_term->dispatch.CreateViSurfaceNN && icd_term->enabled_instance_extensions.nn_vi_surface) {

                        result = icd_term->dispatch.CreateViSurfaceNN(

                            icd_term->instance, (const VkViSurfaceCreateInfoNN *)icd_surface->create_info, pAllocator,

                            &icd_term->surface_list.list[icd_surface->surface_index]);

                    } else {

                        result = VK_ERROR_EXTENSION_NOT_PRESENT;

                    }

                    break;

#endif  // VK_USE_PLATFORM_VI_NN

#if defined(VK_USE_PLATFORM_GGP)

                case VK_ICD_WSI_PLATFORM_GGP:

                    if (NULL != icd_term->dispatch.CreateStreamDescriptorSurfaceGGP &&

                        icd_term->enabled_instance_extensions.qnx_screen_surface) {

                        result = icd_term->dispatch.CreateStreamDescriptorSurfaceGGP(

                            icd_term->instance, (const VkStreamDescriptorSurfaceCreateInfoGGP *)icd_surface->create_info,

                            pAllocator, &icd_term->surface_list.list[icd_surface->surface_index]);

                    } else {

                        result = VK_ERROR_EXTENSION_NOT_PRESENT;

                    }

                    break;

#endif  // VK_USE_PLATFORM_GGP

#if defined(VK_USE_PLATFORM_SCREEN_QNX)

                case VK_ICD_WSI_PLATFORM_SCREEN:

                    if (NULL != icd_term->dispatch.CreateScreenSurfaceQNX &&

                        icd_term->enabled_instance_extensions.qnx_screen_surface) {

                        result = icd_term->dispatch.CreateScreenSurfaceQNX(

                            icd_term->instance, (const VkScreenSurfaceCreateInfoQNX *)icd_surface->create_info, pAllocator,

                            &icd_term->surface_list.list[icd_surface->surface_index]);

                    } else {

                        result = VK_ERROR_EXTENSION_NOT_PRESENT;

                    }

                    break;

#endif  // VK_USE_PLATFORM_SCREEN_QNX

#if defined(VK_USE_PLATFORM_FUCHSIA)

                case VK_ICD_WSI_PLATFORM_FUCHSIA:

                    if (NULL != icd_term->dispatch.CreateImagePipeSurfaceFUCHSIA &&

                        icd_term->enabled_instance_extensions.fuchsia_imagepipe_surface) {

                        result = icd_term->dispatch.CreateImagePipeSurfaceFUCHSIA(

                            icd_term->instance, (const VkImagePipeSurfaceCreateInfoFUCHSIA *)icd_surface->create_info, pAllocator,

                            &icd_term->surface_list.list[icd_surface->surface_index]);

                    } else {

                        result = VK_ERROR_EXTENSION_NOT_PRESENT;

                    }

                    break;

#endif  // VK_USE_PLATFORM_FUCHSIA

                default:

                    // Not supported

                    result = VK_ERROR_EXTENSION_NOT_PRESENT;

                    break;

            }

        }

        *surface = icd_term->surface_list.list[icd_surface->surface_index];

    }

    return result;

}

// 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 three extensions  (Xlib, Xcb, 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) {

#if !defined(VK_USE_PLATFORM_WAYLAND_KHR)

    if (!strcmp(ext_prop->extensionName, "VK_KHR_wayland_surface")) return true;

#endif  // VK_USE_PLATFORM_WAYLAND_KHR

#if !defined(VK_USE_PLATFORM_XCB_KHR)

    if (!strcmp(ext_prop->extensionName, "VK_KHR_xcb_surface")) return true;

#endif  // VK_USE_PLATFORM_XCB_KHR

#if !defined(VK_USE_PLATFORM_XLIB_KHR)

    if (!strcmp(ext_prop->extensionName, "VK_KHR_xlib_surface")) return true;

#endif  // VK_USE_PLATFORM_XLIB_KHR

#if !defined(VK_USE_PLATFORM_DIRECTFB_EXT)

    if (!strcmp(ext_prop->extensionName, "VK_EXT_directfb_surface")) return true;

#endif  // VK_USE_PLATFORM_DIRECTFB_EXT

#if !defined(VK_USE_PLATFORM_SCREEN_QNX)

    if (!strcmp(ext_prop->extensionName, "VK_QNX_screen_surface")) return true;

#endif  // VK_USE_PLATFORM_SCREEN_QNX

    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) {

    struct loader_instance *loader_inst = loader_get_instance(instance);

    if (NULL == loader_inst) {

        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,

                   "vkDestroySurfaceKHR: Invalid instance [VUID-vkDestroySurfaceKHR-instance-parameter]");

        abort(); /* Intentionally fail so user can correct issue. */

    }

    loader_inst->disp->layer_inst_disp.DestroySurfaceKHR(loader_inst->instance, surface, pAllocator);

}

// 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 *loader_inst = loader_get_instance(instance);

    VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)(surface);

    if (NULL != icd_surface) {

        for (struct loader_icd_term *icd_term = loader_inst->icd_terms; icd_term != NULL; icd_term = icd_term->next) {

            if (icd_term->enabled_instance_extensions.khr_surface &&

                icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR &&

                NULL != icd_term->dispatch.DestroySurfaceKHR && icd_term->surface_list.list[icd_surface->surface_index]) {

                icd_term->dispatch.DestroySurfaceKHR(icd_term->instance, icd_term->surface_list.list[icd_surface->surface_index],

                                                     pAllocator);

                icd_term->surface_list.list[icd_surface->surface_index] = (VkSurfaceKHR)(uintptr_t)NULL;

            } else {

                // The real_icd_surface for any ICD not supporting the

                // proper interface version should be NULL.  If not, then

                // we have a problem.

                assert((VkSurfaceKHR)(uintptr_t)NULL == icd_term->surface_list.list[icd_surface->surface_index]);

            }

        }

        if (NULL != icd_surface->create_info) {

            loader_instance_heap_free(loader_inst, icd_surface->create_info);

        }

        loader_release_object_from_list(&loader_inst->surfaces_list, icd_surface->surface_index);

        loader_instance_heap_free(loader_inst, (void *)(uintptr_t)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);

    if (VK_NULL_HANDLE == unwrapped_phys_dev) {

        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,

                   "vkGetPhysicalDeviceSurfaceSupportKHR: Invalid physicalDevice "

                   "[VUID-vkGetPhysicalDeviceSurfaceSupportKHR-physicalDevice-parameter]");

        abort(); /* Intentionally fail so user can correct issue. */

    }

    disp = loader_get_instance_layer_dispatch(physicalDevice);

    return disp->GetPhysicalDeviceSurfaceSupportKHR(unwrapped_phys_dev, queueFamilyIndex, surface, pSupported);

}

// 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_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 *loader_inst = (struct loader_instance *)icd_term->this_instance;

    if (!loader_inst->enabled_extensions.khr_surface) {

        loader_log(loader_inst, VULKAN_LOADER_ERROR_BIT, 0,

                   "VK_KHR_surface extension not enabled. vkGetPhysicalDeviceSurfaceSupportKHR not executed!");

        return VK_SUCCESS;

    }

    if (NULL == pSupported) {

        loader_log(loader_inst, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT, 0,

                   "NULL pointer passed into vkGetPhysicalDeviceSurfaceSupportKHR for pSupported!");

        abort();

    }

    *pSupported = false;

    if (NULL == icd_term->dispatch.GetPhysicalDeviceSurfaceSupportKHR) {

        // set pSupported to false as this driver doesn't support WSI functionality

        *pSupported = false;

        loader_log(loader_inst, VULKAN_LOADER_ERROR_BIT, 0,

                   "ICD for selected physical device does not export vkGetPhysicalDeviceSurfaceSupportKHR!");

        return VK_SUCCESS;

    }

    VkResult res = wsi_unwrap_icd_surface(icd_term, &surface);

    if (res != VK_SUCCESS) {

        // set pSupported to false as this driver doesn't support WSI functionality

        *pSupported = false;

        return VK_SUCCESS;

    }

    return icd_term->dispatch.GetPhysicalDeviceSurfaceSupportKHR(phys_dev_term->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);

    if (VK_NULL_HANDLE == unwrapped_phys_dev) {

        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,

                   "vkGetPhysicalDeviceSurfaceCapabilitiesKHR: Invalid physicalDevice "

                   "[VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-physicalDevice-parameter]");

        abort(); /* Intentionally fail so user can correct issue. */

    }

    disp = loader_get_instance_layer_dispatch(physicalDevice);

    return disp->GetPhysicalDeviceSurfaceCapabilitiesKHR(unwrapped_phys_dev, surface, pSurfaceCapabilities);

}

// 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_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 *loader_inst = (struct loader_instance *)icd_term->this_instance;

    if (!loader_inst->enabled_extensions.khr_surface) {

        loader_log(loader_inst, VULKAN_LOADER_ERROR_BIT, 0,

                   "VK_KHR_surface extension not enabled. vkGetPhysicalDeviceSurfaceCapabilitiesKHR not executed!");

        return VK_SUCCESS;

    }

    if (NULL == pSurfaceCapabilities) {

        loader_log(loader_inst, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT, 0,

                   "NULL pointer passed into vkGetPhysicalDeviceSurfaceCapabilitiesKHR for pSurfaceCapabilities!");

        abort();

    }

    if (NULL == icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR) {

        // Zero out the capabilities as this driver doesn't support WSI functionality

        memset(pSurfaceCapabilities, 0, sizeof(VkSurfaceCapabilitiesKHR));

        loader_log(loader_inst, VULKAN_LOADER_ERROR_BIT, 0,

                   "ICD for selected physical device does not export vkGetPhysicalDeviceSurfaceCapabilitiesKHR!");

        return VK_SUCCESS;

    }

    VkResult res = wsi_unwrap_icd_surface(icd_term, &surface);

    if (res != VK_SUCCESS) {

        return res;

    }

    return icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR(phys_dev_term->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) {

    const VkLayerInstanceDispatchTable *disp;

    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);

    if (VK_NULL_HANDLE == unwrapped_phys_dev) {

        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,

                   "vkGetPhysicalDeviceSurfaceFormatsKHR: Invalid physicalDevice "

                   "[VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-physicalDevice-parameter]");

        abort(); /* Intentionally fail so user can correct issue. */

    }

    disp = loader_get_instance_layer_dispatch(physicalDevice);

    return disp->GetPhysicalDeviceSurfaceFormatsKHR(unwrapped_phys_dev, surface, pSurfaceFormatCount, pSurfaceFormats);

}

// 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_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 *loader_inst = (struct loader_instance *)icd_term->this_instance;

    if (!loader_inst->enabled_extensions.khr_surface) {

        loader_log(loader_inst, VULKAN_LOADER_ERROR_BIT, 0,

                   "VK_KHR_surface extension not enabled. vkGetPhysicalDeviceSurfaceFormatsKHR not executed!");

        return VK_SUCCESS;

    }

    if (NULL == pSurfaceFormatCount) {

        loader_log(loader_inst, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT, 0,

                   "NULL pointer passed into vkGetPhysicalDeviceSurfaceFormatsKHR for pSurfaceFormatCount!");

        abort();

    }

    if (NULL == icd_term->dispatch.GetPhysicalDeviceSurfaceFormatsKHR) {

        // Zero out the format count as this driver doesn't support WSI functionality

        *pSurfaceFormatCount = 0;

        loader_log(loader_inst, VULKAN_LOADER_ERROR_BIT, 0,

                   "ICD for selected physical device does not export vkGetPhysicalDeviceSurfaceFormatsKHR!");

        return VK_SUCCESS;

    }

    if (VK_NULL_HANDLE != surface) {

        VkResult res = wsi_unwrap_icd_surface(icd_term, &surface);

        if (res != VK_SUCCESS) {

            return res;

        }

    }

    return icd_term->dispatch.GetPhysicalDeviceSurfaceFormatsKHR(phys_dev_term->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) {

    const VkLayerInstanceDispatchTable *disp;

    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);

    if (VK_NULL_HANDLE == unwrapped_phys_dev) {

        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,

                   "vkGetPhysicalDeviceSurfacePresentModesKHR: Invalid physicalDevice "

                   "[VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-physicalDevice-parameter]");

        abort(); /* Intentionally fail so user can correct issue. */

    }

    disp = loader_get_instance_layer_dispatch(physicalDevice);

    return disp->GetPhysicalDeviceSurfacePresentModesKHR(unwrapped_phys_dev, surface, pPresentModeCount, pPresentModes);

}

// 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_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 *loader_inst = (struct loader_instance *)icd_term->this_instance;

    if (!loader_inst->enabled_extensions.khr_surface) {

        loader_log(loader_inst, VULKAN_LOADER_ERROR_BIT, 0,

                   "VK_KHR_surface extension not enabled. vkGetPhysicalDeviceSurfacePresentModesKHR not executed!");

        return VK_SUCCESS;

    }

    if (NULL == pPresentModeCount) {

        loader_log(loader_inst, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT, 0,

                   "NULL pointer passed into vkGetPhysicalDeviceSurfacePresentModesKHR for pPresentModeCount!");

        abort();

    }

    if (NULL == icd_term->dispatch.GetPhysicalDeviceSurfacePresentModesKHR) {

        // Zero out the present mode count as this driver doesn't support WSI functionality

        *pPresentModeCount = 0;

        loader_log(loader_inst, VULKAN_LOADER_ERROR_BIT, 0,

                   "ICD for selected physical device does not export vkGetPhysicalDeviceSurfacePresentModesKHR!");

        return VK_SUCCESS;

    }

    if (VK_NULL_HANDLE != surface) {

        VkResult res = wsi_unwrap_icd_surface(icd_term, &surface);

        if (res != VK_SUCCESS) {

            return res;

        }

    }

    return icd_term->dispatch.GetPhysicalDeviceSurfacePresentModesKHR(phys_dev_term->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 = loader_get_dispatch(device);

    if (NULL == disp) {

        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,

                   "vkCreateSwapchainKHR: Invalid device [VUID-vkCreateSwapchainKHR-device-parameter]");

        abort(); /* Intentionally fail so user can correct issue. */

    }

    if (NULL == disp->CreateSwapchainKHR) {

        struct loader_device *dev = *((struct loader_device **)device);

        loader_log(NULL != dev ? dev->phys_dev_term->this_icd_term->this_instance : NULL,

                   VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,

                   "vkCreateSwapchainKHR: Driver's function pointer was NULL, returning VK_SUCCESS. Was the VK_KHR_swapchain "

                   "extension enabled?");

        abort();

    }

    return disp->CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);

}

VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo,

                                                             const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) {

    struct loader_device *dev;

    struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev);

    if (NULL == icd_term || NULL == dev) {

        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,

                   "vkCreateSwapchainKHR Terminator: device handle. This is likely the result of a "

                   "layer wrapping device handles and failing to unwrap them in all functions. "

                   "[VUID-vkCreateSwapchainKHR-device-parameter]");

        abort(); /* Intentionally fail so user can correct issue. */

    }

    if (NULL == pCreateInfo) {

        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,

                   "vkCreateSwapchainKHR: Invalid pCreateInfo pointer [VUID-vkCreateSwapchainKHR-pCreateInfo-parameter]");

        abort(); /* Intentionally fail so user can correct issue. */

    }

    // Need to gracefully handle the function pointer not being found.

    if (NULL == dev->loader_dispatch.extension_terminator_dispatch.CreateSwapchainKHR) {

        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,

                   "vkCreateSwapchainKHR: Driver's function pointer was NULL, returning VK_SUCCESS. Was the VK_KHR_swapchain "

                   "extension enabled?");

        return VK_SUCCESS;

    }

    VkSwapchainCreateInfoKHR create_info_copy = *pCreateInfo;

    VkResult res = wsi_unwrap_icd_surface(icd_term, &create_info_copy.surface);

    if (res != VK_SUCCESS) {

        return res;

    }

    return dev->loader_dispatch.extension_terminator_dispatch.CreateSwapchainKHR(device, &create_info_copy, pAllocator, pSwapchain);

}

// 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 = loader_get_dispatch(device);

    if (NULL == disp) {

        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,

                   "vkDestroySwapchainKHR: Invalid device [VUID-vkDestroySwapchainKHR-device-parameter]");

        abort(); /* Intentionally fail so user can correct issue. */

    }

    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 = loader_get_dispatch(device);

    if (NULL == disp) {

        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,

                   "vkGetSwapchainImagesKHR: Invalid device [VUID-vkGetSwapchainImagesKHR-device-parameter]");

        abort(); /* Intentionally fail so user can correct issue. */

    }

    return disp->GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);

}

// 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 = loader_get_dispatch(device);

    if (NULL == disp) {

        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,

                   "vkAcquireNextImageKHR: Invalid device [VUID-vkAcquireNextImageKHR-device-parameter]");

        abort(); /* Intentionally fail so user can correct issue. */

    }

    return disp->AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);

}

// This is the trampoline entrypoint for QueuePresentKHR

LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) {

    const VkLayerDispatchTable *disp = loader_get_dispatch(queue);

    if (NULL == disp) {

        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,

                   "vkQueuePresentKHR: Invalid queue [VUID-vkQueuePresentKHR-queue-parameter]");

        abort(); /* Intentionally fail so user can correct issue. */

    }

    return disp->QueuePresentKHR(queue, pPresentInfo);

}

VkResult allocate_icd_surface_struct(struct loader_instance *instance, size_t base_size, size_t platform_size,

                                     const VkAllocationCallbacks *pAllocator, VkIcdSurface **out_icd_surface) {

    uint32_t next_index = 0;

    VkIcdSurface *icd_surface = NULL;

    VkResult res = loader_get_next_available_entry(instance, &instance->surfaces_list, &next_index, pAllocator);

    if (res != VK_SUCCESS) {

        goto out;

    }

    // Next, if so, proceed with the implementation of this function:

    icd_surface = loader_instance_heap_calloc(instance, sizeof(VkIcdSurface), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);

    if (icd_surface == NULL) {

        res = VK_ERROR_OUT_OF_HOST_MEMORY;

        goto out;

    }

    // Setup the new sizes and offsets so we can grow the structures in the

    // future without having problems

    icd_surface->base_size = (uint32_t)base_size;

    icd_surface->platform_size = (uint32_t)platform_size;

    icd_surface->non_platform_offset = (uint32_t)((uint8_t *)(&icd_surface->base_size) - (uint8_t *)icd_surface);

    icd_surface->entire_size = sizeof(VkIcdSurface);

    icd_surface->surface_index = next_index;

    icd_surface->create_info = NULL;

    for (struct loader_icd_term *icd_term = instance->icd_terms; icd_term != NULL; icd_term = icd_term->next) {

        if (icd_term->enabled_instance_extensions.khr_surface &&

            icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {

            if (icd_term->surface_list.list == NULL) {

                res =

                    loader_init_generic_list(instance, (struct loader_generic_list *)&icd_term->surface_list, sizeof(VkSurfaceKHR));

                if (res != VK_SUCCESS) {

                    goto out;

                }

            } else if (icd_term->surface_list.capacity <= next_index * sizeof(VkSurfaceKHR)) {

                res = loader_resize_generic_list(instance, (struct loader_generic_list *)&icd_term->surface_list);

                if (res != VK_SUCCESS) {

                    goto out;

                }

            }

        }

    }

    *out_icd_surface = icd_surface;

out:

    if (res != VK_SUCCESS) {

        loader_instance_heap_free(instance, icd_surface);

        // cleanup of icd_term->surface_list is done during instance destruction

    }

    return res;

}

VkResult copy_surface_create_info(struct loader_instance *loader_inst, VkIcdSurface *icd_surface, const void *create_info,

                                  size_t struct_type_info_count, const struct loader_struct_type_info *struct_type_info,

                                  const char *base_struct_name, const VkAllocationCallbacks *pAllocator) {

    size_t create_info_total_size = 0;

    const void *pnext = create_info;

    while (NULL != pnext) {

        VkBaseInStructure base = {0};

        memcpy(&base, pnext, sizeof(VkBaseInStructure));

        bool known_struct = false;

        for (size_t i = 0; i < struct_type_info_count; ++i) {

            if (base.sType == struct_type_info[i].stype) {

                create_info_total_size += loader_aligned_size(struct_type_info[i].size);

                pnext = base.pNext;

                known_struct = true;

                break;

            }

        }

        if (!known_struct) {

            loader_log(loader_inst, VULKAN_LOADER_ERROR_BIT, 0, "Unsupported extension structure in %s pNext chain.",

                       base_struct_name);

            return VK_ERROR_EXTENSION_NOT_PRESENT;

        }

    }

    icd_surface->create_info = loader_instance_heap_alloc(loader_inst, create_info_total_size, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);

    if (NULL == icd_surface->create_info) {

        return VK_ERROR_OUT_OF_HOST_MEMORY;

    }

    uint8_t *dst = (uint8_t *)icd_surface->create_info;

    VkBaseInStructure *prev_struct = NULL;

    pnext = create_info;

    while (NULL != pnext) {

        VkBaseInStructure base = {0};

        memcpy(&base, pnext, sizeof(VkBaseInStructure));

        for (size_t i = 0; i < struct_type_info_count; ++i) {

            if (base.sType == struct_type_info[i].stype) {

                memcpy(dst, pnext, struct_type_info[i].size);

                if (NULL != prev_struct) {

                    prev_struct->pNext = (const VkBaseInStructure *)dst;

                }

                prev_struct = (VkBaseInStructure *)dst;

                dst += loader_aligned_size(struct_type_info[i].size);

                pnext = base.pNext;

                break;

            }

        }

    }

    if (pAllocator) {

        icd_surface->callbacks_valid = true;

        icd_surface->callbacks = *pAllocator;

    }

    return VK_SUCCESS;

}

void cleanup_surface_creation(struct loader_instance *loader_inst, VkResult result, VkIcdSurface *icd_surface,

                              const VkAllocationCallbacks *pAllocator) {

    if (VK_SUCCESS != result && NULL != icd_surface) {

        for (struct loader_icd_term *icd_term = loader_inst->icd_terms; icd_term != NULL; icd_term = icd_term->next) {

            if (icd_term->enabled_instance_extensions.khr_surface && NULL != icd_term->surface_list.list &&

                icd_term->surface_list.capacity > icd_surface->surface_index * sizeof(VkSurfaceKHR) &&

                icd_term->surface_list.list[icd_surface->surface_index] && NULL != icd_term->dispatch.DestroySurfaceKHR) {

                icd_term->dispatch.DestroySurfaceKHR(icd_term->instance, icd_term->surface_list.list[icd_surface->surface_index],

                                                     pAllocator);

            }

        }

        if (loader_inst->surfaces_list.list &&

            loader_inst->surfaces_list.capacity > icd_surface->surface_index * sizeof(struct loader_used_object_status)) {

            loader_inst->surfaces_list.list[icd_surface->surface_index].status = VK_FALSE;

            if (NULL != pAllocator) {

                loader_inst->surfaces_list.list[icd_surface->surface_index].allocation_callbacks = *pAllocator;

            }

        }

        if (NULL != icd_surface->create_info) {

            loader_instance_heap_free(loader_inst, icd_surface->create_info);

        }

        loader_instance_heap_free(loader_inst, icd_surface);

    }

}

#if defined(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) {

    struct loader_instance *loader_inst = loader_get_instance(instance);

    if (NULL == loader_inst) {

        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,

                   "vkCreateWin32SurfaceKHR: Invalid instance [VUID-vkCreateWin32SurfaceKHR-instance-parameter]");

        abort(); /* Intentionally fail so user can correct issue. */

    }

    return loader_inst->disp->layer_inst_disp.CreateWin32SurfaceKHR(loader_inst->instance, pCreateInfo, pAllocator, pSurface);

}

// 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) {

    VkResult result = VK_SUCCESS;

    VkIcdSurface *icd_surface = NULL;

    loader_platform_thread_lock_mutex(&loader_lock);

    // Initialize pSurface to NULL just to be safe.

    *pSurface = VK_NULL_HANDLE;

    // First, check to ensure the appropriate extension was enabled:

    struct loader_instance *loader_inst = loader_get_instance(instance);

    if (!loader_inst->enabled_extensions.khr_win32_surface) {

        loader_log(loader_inst, VULKAN_LOADER_ERROR_BIT, 0,

                   "VK_KHR_win32_surface extension not enabled. vkCreateWin32SurfaceKHR not executed!");

        result = VK_ERROR_EXTENSION_NOT_PRESENT;

        goto out;

    }

    // Next, if so, proceed with the implementation of this function:

    result = allocate_icd_surface_struct(loader_inst, sizeof(icd_surface->win_surf.base), sizeof(icd_surface->win_surf), pAllocator,

                                         &icd_surface);

    if (VK_SUCCESS != result) {

        goto out;

    }

    icd_surface->win_surf.base.platform = VK_ICD_WSI_PLATFORM_WIN32;

    icd_surface->win_surf.hinstance = pCreateInfo->hinstance;

    icd_surface->win_surf.hwnd = pCreateInfo->hwnd;

    const struct loader_struct_type_info ci_types[] = {

        {VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR, sizeof(VkWin32SurfaceCreateInfoKHR)},

    };

    copy_surface_create_info(loader_inst, icd_surface, pCreateInfo, sizeof(ci_types) / sizeof(ci_types[0]), ci_types,

                             "VkWin32SurfaceCreateInfoKHR", pAllocator);

    *pSurface = (VkSurfaceKHR)(uintptr_t)icd_surface;

out:

    cleanup_surface_creation(loader_inst, result, icd_surface, pAllocator);

    loader_platform_thread_unlock_mutex(&loader_lock);

    return result;

}

// This is the trampoline entrypoint for

// GetPhysicalDeviceWin32PresentationSupportKHR

LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice,

                                                                                            uint32_t queueFamilyIndex) {

    const VkLayerInstanceDispatchTable *disp;

    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);

    if (VK_NULL_HANDLE == unwrapped_phys_dev) {

        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,

                   "vkGetPhysicalDeviceWin32PresentationSupportKHR: Invalid physicalDevice "

                   "[VUID-vkGetPhysicalDeviceWin32PresentationSupportKHR-physicalDevice-parameter]");

        abort(); /* Intentionally fail so user can correct issue. */

    }

    disp = loader_get_instance_layer_dispatch(physicalDevice);

    return disp->GetPhysicalDeviceWin32PresentationSupportKHR(unwrapped_phys_dev, queueFamilyIndex);

}

// 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_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 *loader_inst = (struct loader_instance *)icd_term->this_instance;

    if (!loader_inst->enabled_extensions.khr_win32_surface) {

        loader_log(loader_inst, VULKAN_LOADER_ERROR_BIT, 0,

                   "VK_KHR_win32_surface extension not enabled. vkGetPhysicalDeviceWin32PresentationSupportKHR not executed!");

        return VK_FALSE;

    }

    if (NULL == icd_term->dispatch.GetPhysicalDeviceWin32PresentationSupportKHR) {

        // return VK_FALSE as this driver doesn't support WSI functionality

        loader_log(loader_inst, VULKAN_LOADER_ERROR_BIT, 0,

                   "ICD for selected physical device does not export vkGetPhysicalDeviceWin32PresentationSupportKHR!");

        return VK_FALSE;

    }

    return icd_term->dispatch.GetPhysicalDeviceWin32PresentationSupportKHR(phys_dev_term->phys_dev, queueFamilyIndex);

}

#endif  // VK_USE_PLATFORM_WIN32_KHR

#if defined(VK_USE_PLATFORM_WAYLAND_KHR)

// 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) {

    struct loader_instance *loader_inst = loader_get_instance(instance);

    if (NULL == loader_inst) {

        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,

                   "vkCreateWaylandSurfaceKHR: Invalid instance [VUID-vkCreateWaylandSurfaceKHR-instance-parameter]");

        abort(); /* Intentionally fail so user can correct issue. */

    }

    return loader_inst->disp->layer_inst_disp.CreateWaylandSurfaceKHR(loader_inst->instance, pCreateInfo, pAllocator, pSurface);

}

// 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) {

    VkResult result = VK_SUCCESS;

    VkIcdSurface *icd_surface = NULL;

    loader_platform_thread_lock_mutex(&loader_lock);

    // First, check to ensure the appropriate extension was enabled:

    struct loader_instance *loader_inst = loader_get_instance(instance);

    if (!loader_inst->enabled_extensions.khr_wayland_surface) {

        loader_log(loader_inst, VULKAN_LOADER_ERROR_BIT, 0,

                   "VK_KHR_wayland_surface extension not enabled. vkCreateWaylandSurfaceKHR not executed!");

        result = VK_ERROR_EXTENSION_NOT_PRESENT;

        goto out;

    }

    // Next, if so, proceed with the implementation of this function:

    result = allocate_icd_surface_struct(loader_inst, sizeof(icd_surface->wayland_surf.base), sizeof(icd_surface->wayland_surf),

                                         pAllocator, &icd_surface);

    if (VK_SUCCESS != result) {

        goto out;

    }

    icd_surface->wayland_surf.base.platform = VK_ICD_WSI_PLATFORM_WAYLAND;

    icd_surface->wayland_surf.display = pCreateInfo->display;

    icd_surface->wayland_surf.surface = pCreateInfo->surface;

    const struct loader_struct_type_info ci_types[] = {

        {VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR, sizeof(VkWaylandSurfaceCreateInfoKHR)},

    };

    copy_surface_create_info(loader_inst, icd_surface, pCreateInfo, sizeof(ci_types) / sizeof(ci_types[0]), ci_types,

                             "VkWaylandSurfaceCreateInfoKHR", pAllocator);