@shopify/react-native-skia 2.0.5 → 2.0.7

package/cpp/skia/include/gpu/vk/VulkanPreferredFeatures.h

@@ -0,0 +1,214 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_VulkanPreferredFeatures_DEFINED
+#define skgpu_VulkanPreferredFeatures_DEFINED
+
+#include "include/private/base/SkAPI.h"
+#include "include/private/gpu/vk/SkiaVulkan.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+namespace skgpu {
+
+class SK_API VulkanPreferredFeatures {
+public:
+    ~VulkanPreferredFeatures();
+
+    /*
+     * VulkanPreferredFeatures is used by Skia to add extensions and features on top of what the app
+     * wants to enable. The flow of Vulkan initialization for an app that wants to use Skia would
+     * be:
+     *
+     * ```
+     * // Query the loader for instance information, decide on API version to use
+     *
+     * // Prepare for Skia-enabled extensions and features
+     * skgpu::VulkanPreferredFeatures skiaFeatures;
+     * skiaFeatures.init(apiVersion);
+     *
+     * // Decide on instance extensions to use in the app.
+     *
+     * // Allow Skia to add to the instance extension list.
+     * skiaFeatures.addToInstanceExtensions(...);
+     *
+     * // Create the instance, choose physical device, query available extensions, decide on
+     * // device features to query
+     *
+     * // Allow Skia to add to the feature query list.
+     * skiaFeatures.addFeaturesToQuery(...);
+     *
+     * // Query features, decide on extensions and features to enable.
+     *
+     * // Allow Skia to add to the device extension and feature list.
+     * skiaFeatures.addFeaturesToEnable(...);
+     *
+     * // Create the Vulkan device.
+     * ```
+     *
+     * Parameters:
+     *
+     * * appAPIVersion: The API version the app has specified in VkApplicationInfo::apiVersion (and
+     *   will later provide in VulkanBackendContext::fMaxAPIVersion). The minimum supported version
+     *   is VK_API_VERSION_1_1, maximum is VK_API_VERSION_1_4.
+     */
+    void init(uint32_t appAPIVersion);
+
+    /*
+     * Before creating a Vulkan instance, call addToInstanceExtensions to give Skia a chance to add
+     * instance extensions it may take advantage of. Extensions are only added to appExtensions if
+     * caller hasn't already included them to be enabled.
+     *
+     * Parameters:
+     *
+     * * instanceExtensions, instanceExtensionCount: The list of available instance extensions as
+     *   queried from the loader.
+     * * appExtensions: The list of extensions to be enabled on the instance; more extensions may be
+     *   added to this list by this call.
+     */
+    void addToInstanceExtensions(const VkExtensionProperties* instanceExtensions,
+                                 size_t instanceExtensionCount,
+                                 std::vector<const char*>& appExtensions);
+
+    /*
+     * Before querying Vulkan device features, call addFeaturesToQuery to give Skia a chance to add
+     * device extension features it may take advantage of to the query. Features are only added to
+     * appFeatures if caller hasn't already included them in the query.
+     *
+     * Beware that the structs that get chained to appFeatures are member variables of this class,
+     * so this object must not leave scope until feature query and device creation is complete.
+     *
+     * Parameters:
+     *
+     * * deviceExtensions, deviceExtensionCount: The list of available device extensions as queried
+     *   from the physical device.
+     * * appFeatures: The features to be queried from the physical device; more features may be
+     *   added to the pNext chain by this call.
+     */
+    void addFeaturesToQuery(const VkExtensionProperties* deviceExtensions,
+                            size_t deviceExtensionCount,
+                            VkPhysicalDeviceFeatures2& appFeatures);
+
+    /*
+     * Before creating the Vulkan device, call addFeaturesToEnable to give Skia a chance to add
+     * device extensions and features it may take advantage of. Extensions and features are only
+     * added to appExtensions and appFeatures respectively if caller hasn't already included them to
+     * be enabled. This function may replace chained features with VkPhysicalDeviceVulkanNNFeatures
+     * structs instead in order to add features. Features that are already enabled by the
+     * application are retained in that case in the new struct.
+     *
+     * Parameters:
+     *
+     * * appExtensions: The list of extensions to be enabled on the device; more extensions may be
+     *   added to this list by this call.
+     * * appFeatures: The features to be enabled on the device; more features may be
+     *   added to the pNext chain by this call.
+     */
+    void addFeaturesToEnable(std::vector<const char*>& appExtensions,
+                             VkPhysicalDeviceFeatures2& appFeatures);
+
+private:
+    uint32_t fAPIVersion = 0;
+    // Track what the application did, so warnings can be generated if the class is not
+    // fully/correctly used.
+    bool fHasAddedToInstanceExtensions = false;
+    bool fHasAddedFeaturesToQuery = false;
+    bool fHasAddedFeaturesToEnable = false;
+
+    // The list of device features Skia is interested in. If any are included in
+    // VkPhysicalDeviceFeatures2::pNext by the app, it is not included again by Skia. However, to
+    // take best advantage of the Vulkan API, the app should not intentionally include these feature
+    // structs only to forcefully disable the feature - this blocks Skia from leveraging it.
+    //
+    // When ambiguous, the extension name is included to determine which extension a feature struct
+    // has come from. This is usually needed when addFeaturesToQuery has included a feature struct
+    // that is present in multiple extensions (e.g. due to extension promotion). It is later used by
+    // addFeaturesToEnable to know which extension to enable.
+
+    // Available since Vulkan 1.2
+    VkPhysicalDeviceVulkan11Features fVulkan11 = {};
+
+    // Available since Vulkan 1.2
+    VkPhysicalDeviceVulkan12Features fVulkan12 = {};
+
+    // Available since Vulkan 1.3
+    VkPhysicalDeviceVulkan13Features fVulkan13 = {};
+
+    // Available since Vulkan 1.4
+    VkPhysicalDeviceVulkan14Features fVulkan14 = {};
+
+    // Feature of VK_EXT_rasterization_order_attachment_access or
+    // VK_ARM_rasterization_order_attachment_access.
+    VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT
+            fRasterizationOrderAttachmentAccess = {};
+    const char* fRasterizationOrderAttachmentAccessExtension = nullptr;
+
+    // Feature of VK_EXT_blend_operation_advanced
+    VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT fBlendOperationAdvanced = {};
+
+    // Feature of VK_EXT_extended_dynamic_state
+    VkPhysicalDeviceExtendedDynamicStateFeaturesEXT fExtendedDynamicState = {};
+
+    // Feature of VK_EXT_extended_dynamic_state2
+    VkPhysicalDeviceExtendedDynamicState2FeaturesEXT fExtendedDynamicState2 = {};
+
+    // Feature of VK_EXT_vertex_input_dynamic_state
+    VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT fVertexInputDynamicState = {};
+
+    // Feature of VK_EXT_graphics_pipeline_library
+    VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT fGraphicsPipelineLibrary = {};
+
+    // Feature of VK_KHR_sampler_ycbcr_conversion or Vulkan 1.1
+    VkPhysicalDeviceSamplerYcbcrConversionFeatures fSamplerYcbcrConversion = {};
+
+    // Feature of VK_EXT_rgba10x6_formats
+    VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT fRGBA10x6Formats = {};
+
+    // Feature of VK_KHR_synchronization2 or Vulkan 1.3
+    VkPhysicalDeviceDynamicRenderingFeatures fSynchronization2 = {};
+
+    // Feature of VK_KHR_dynamic_rendering or Vulkan 1.3
+    VkPhysicalDeviceDynamicRenderingFeatures fDynamicRendering = {};
+
+    // Feature of VK_KHR_dynamic_rendering_local_read or Vulkan 1.4
+    VkPhysicalDeviceDynamicRenderingLocalReadFeatures fDynamicRenderingLocalRead = {};
+
+    // Feature of VK_EXT_multisampled_render_to_single_sampled
+    VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT
+            fMultisampledRenderToSingleSampled = {};
+
+    // Feature of VK_EXT_host_image_copy or Vulkan 1.4
+    VkPhysicalDeviceHostImageCopyFeatures fHostImageCopy = {};
+
+    // Feature of VK_EXT_pipeline_creation_cache_control or Vulkan 1.3
+    VkPhysicalDevicePipelineCreationCacheControlFeatures fPipelineCreationCacheControl = {};
+
+    // Extensions that don't have a feature:
+    // VK_KHR_driver_properties or Vulkan 1.2
+    const char* fDriverPropertiesExtension = nullptr;
+    // VK_KHR_create_renderpass2 or Vulkan 1.2
+    const char* fCreateRenderpass2Extension = nullptr;
+    // VK_EXT_load_store_op_none, VK_KHR_load_store_op_none or Vulkan 1.4
+    const char* fLoadStoreOpNoneExtension = nullptr;
+    // VK_EXT_conservative_rasterization
+    const char* fConservativeRasterizationExtension = nullptr;
+
+    // Extensions that the other extensions above depend on:
+    // Dependency of VK_EXT_graphics_pipeline_library: VK_KHR_pipeline_library
+    const char* fPipelineLibraryExtension = nullptr;
+    // Dependencies of VK_EXT_host_image_copy: VK_KHR_copy_commands2, VK_KHR_format_feature_flags2
+    const char* fCopyCommands2Extension = nullptr;
+    const char* fFormatFeatureFlags2Extension = nullptr;
+    // Dependency of VK_EXT_multisampled_render_to_single_sampled: VK_KHR_depth_stencil_resolve
+    const char* fDepthStencilResolveExtension = nullptr;
+};
+
+}  // namespace skgpu
+
+#endif  // skgpu_VulkanPreferredFeatures_DEFINED

package/cpp/skia/include/ports/SkFontMgr_fontconfig.h

@@ -20,5 +20,8 @@ class SkFontMgr;
  */
 class SkFontScanner;
 SK_API sk_sp<SkFontMgr> SkFontMgr_New_FontConfig(FcConfig* fc, std::unique_ptr<SkFontScanner> scanner);
+
+#if !defined(SK_DISABLE_LEGACY_FONTCONFIG_FACTORY)
 SK_API sk_sp<SkFontMgr> SkFontMgr_New_FontConfig(FcConfig* fc);
+#endif
 #endif // #ifndef SkFontMgr_fontconfig_DEFINED

package/cpp/skia/include/private/SkGainmapShader.h

@@ -34,11 +34,17 @@ public:
      *  map to the rectangle dstRect. Sampling will be done according to gainmapSamplingOptions.
      *
      *  The gainmap will be applied according to the HDR to SDR ratio specified in dstHdrRatio.
-     *
-     *  This shader must know the color space of the canvas that it will be rendered to. This color
-     *  space must be specified in dstColorSpace.
-     *  TODO(ccameron): Remove the need for dstColorSpace.
      */
+    static sk_sp<SkShader> Make(const sk_sp<const SkImage>& baseImage,
+                                const SkRect& baseRect,
+                                const SkSamplingOptions& baseSamplingOptions,
+                                const sk_sp<const SkImage>& gainmapImage,
+                                const SkRect& gainmapRect,
+                                const SkSamplingOptions& gainmapSamplingOptions,
+                                const SkGainmapInfo& gainmapInfo,
+                                const SkRect& dstRect,
+                                float dstHdrRatio);
+
     static sk_sp<SkShader> Make(const sk_sp<const SkImage>& baseImage,
                                 const SkRect& baseRect,
                                 const SkSamplingOptions& baseSamplingOptions,

package/cpp/skia/include/private/SkPathRef.h

@@ -9,6 +9,7 @@
 #define SkPathRef_DEFINED
 
 #include "include/core/SkArc.h"
+#include "include/core/SkPathTypes.h" // IWYU pragma: keep
 #include "include/core/SkPoint.h"
 #include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
@@ -310,6 +311,9 @@ public:
      */
     const uint8_t* verbsEnd() const { return fVerbs.end(); }
 
+    SkSpan<const SkPathVerb> verbs() const {
+        return {reinterpret_cast<const SkPathVerb*>(fVerbs.begin()), fVerbs.size()};
+    }
     /**
      * Returns a const pointer to the first point.
      */
@@ -337,7 +341,7 @@ public:
      * Gets an ID that uniquely identifies the contents of the path ref. If two path refs have the
      * same ID then they have the same verbs and points. However, two path refs may have the same
      * contents but different genIDs.
-     * skbug.com/1762 for background on why fillType is necessary (for now).
+     * skbug.com/40032862 for background on why fillType is necessary (for now).
      */
     uint32_t genID(uint8_t fillType) const;
 
@@ -395,7 +399,7 @@ private:
 
     // Return true if the computed bounds are finite.
     static bool ComputePtBounds(SkRect* bounds, const SkPathRef& ref) {
-        return bounds->setBoundsCheck(ref.points(), ref.countPoints());
+        return bounds->setBoundsCheck({ref.points(), ref.countPoints()});
     }
 
     // called, if dirty, by getBounds()

package/cpp/skia/include/private/base/SkAlign.h

@@ -41,4 +41,15 @@ static inline constexpr size_t SkAlignTo(size_t x, size_t alignment) {
     return (x + alignment - 1) & ~(alignment - 1);
 }
 
+/**
+ *  align up to a non power of 2
+ */
+static inline constexpr size_t SkAlignNonPow2(size_t x, size_t alignment) {
+    const size_t misalignment = x % alignment;
+    if (misalignment) {
+        x += alignment - misalignment;
+    }
+    return x;
+}
+
 #endif

package/cpp/skia/include/private/gpu/ganesh/GrTypesPriv.h

@@ -473,7 +473,7 @@ constexpr static int kGrInternalTextureFlagsMask = static_cast<int>(
 // if the proxy has it set then the surface must also have it set. All other flags listed here must
 // match on the proxy and surface.
 // TODO: Add back kFramebufferOnly flag here once we update GrSurfaceCharacterization to take it
-// as a flag. skbug.com/10672
+// as a flag. skbug.com/40042017
 constexpr static int kGrInternalRenderTargetFlagsMask = static_cast<int>(
         GrInternalSurfaceFlags::kGLRTFBOIDIs0 |
         GrInternalSurfaceFlags::kRequiresManualMSAAResolve/* |

package/cpp/skia/include/third_party/vulkan/vulkan/vk_icd.h

@@ -0,0 +1,255 @@
+/*
+ * Copyright 2015-2023 The Khronos Group Inc.
+ * Copyright 2015-2023 Valve Corporation
+ * Copyright 2015-2023 LunarG, Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#pragma once
+
+#include <stdbool.h>
+#include "vulkan.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.
+//   Version 7 - If an ICD supports any of the following functions, they must be
+//               queryable with vk_icdGetInstanceProcAddr:
+//                   vk_icdNegotiateLoaderICDInterfaceVersion
+//                   vk_icdGetPhysicalDeviceProcAddr
+//                   vk_icdEnumerateAdapterPhysicalDevices (Windows only)
+//               In addition, these functions no longer need to be exported directly.
+//               This version allows drivers provided through the extension
+//               VK_LUNARG_direct_driver_loading be able to support the entire
+//               Driver-Loader interface.
+
+#define CURRENT_LOADER_ICD_INTERFACE_VERSION 7
+#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 instance,
+                                                                         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,
+    VK_ICD_WSI_PLATFORM_FUCHSIA,
+} 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
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+typedef struct {
+    VkIcdSurfaceBase base;
+} VkIcdSurfaceImagePipe;
+#endif  // VK_USE_PLATFORM_FUCHSIA