@shopify/react-native-skia 2.6.0 → 2.6.2

package/cpp/skia/include/effects/SkGradient.h

@@ -0,0 +1,206 @@
+/*
+ * 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 SkGradient_DEFINED
+#define SkGradient_DEFINED
+
+#include "include/core/SkColor.h"
+#include "include/core/SkColorSpace.h"
+#include "include/core/SkPoint.h"
+#include "include/core/SkShader.h"
+#include "include/core/SkSpan.h"
+#include "include/core/SkTileMode.h"
+#include "include/private/base/SkAPI.h"
+
+class SkMatrix;
+
+class SkGradient {
+public:
+    struct Interpolation {
+        enum class InPremul : bool { kNo = false, kYes = true };
+
+        enum class ColorSpace : uint8_t {
+            // Default Skia behavior: interpolate in the color space of the destination surface
+            kDestination,
+
+            // https://www.w3.org/TR/css-color-4/#interpolation-space
+            kSRGBLinear,
+            kLab,
+            kOKLab,
+            // This is the same as kOKLab, except it has a simplified version of the CSS gamut
+            // mapping algorithm (https://www.w3.org/TR/css-color-4/#css-gamut-mapping)
+            // into Rec2020 space applied to it.
+            // Warning: This space is experimental and should not be used in production.
+            kOKLabGamutMap,
+            kLCH,
+            kOKLCH,
+            // This is the same as kOKLCH, except it has the same gamut mapping applied to it
+            // as kOKLabGamutMap does.
+            // Warning: This space is experimental and should not be used in production.
+            kOKLCHGamutMap,
+            kSRGB,
+            kHSL,
+            kHWB,
+
+            kDisplayP3,
+            kRec2020,
+            kProphotoRGB,
+            kA98RGB,
+
+            kLastColorSpace = kA98RGB,
+        };
+        static constexpr int kColorSpaceCount = static_cast<int>(ColorSpace::kLastColorSpace) + 1;
+
+        enum class HueMethod : uint8_t {
+            // https://www.w3.org/TR/css-color-4/#hue-interpolation
+            kShorter,
+            kLonger,
+            kIncreasing,
+            kDecreasing,
+
+            kLastHueMethod = kDecreasing,
+        };
+        static constexpr int kHueMethodCount = static_cast<int>(HueMethod::kLastHueMethod) + 1;
+
+        InPremul fInPremul = InPremul::kNo;
+        ColorSpace fColorSpace = ColorSpace::kDestination;
+        HueMethod fHueMethod = HueMethod::kShorter;  // Only relevant for LCH, OKLCH, HSL, or HWB
+
+        // legacy compatibility -- remove when we can
+        static Interpolation FromFlags(uint32_t flags) {
+            return {flags & 1 ? InPremul::kYes : InPremul::kNo,
+                    ColorSpace::kDestination,
+                    HueMethod::kShorter};
+        }
+    };
+
+    /**
+     *  Specification for the colors in a gradient.
+     *
+     *  @param  colors  The span of colors for the gradient.
+     *  @param  pos     Relative positions of each color across the gradient. If empty,
+     *                  the the colors are distributed evenly. If this is not null, the values
+     *                  must lie between 0.0 and 1.0, and be strictly increasing. If the first
+     *                  value is not 0.0, then an additional color stop is added at position 0.0,
+     *                  with the same color as colors[0]. If the the last value is less than 1.0,
+     *                  then an additional color stop is added at position 1.0, with the same color
+     *                  as colors[count - 1].
+     *  @param mode     Tiling mode for the gradient.
+     *  @param cs       Optional colorspace associated with the span of colors. If this is null,
+     *                  the colors are treated as sRGB.
+     */
+    class Colors {
+    public:
+        Colors() {}
+        Colors(SkSpan<const SkColor4f> colors,
+               SkSpan<const float> pos,
+               SkTileMode mode,
+               sk_sp<SkColorSpace> cs = nullptr)
+                : fColors(colors), fPos(pos), fColorSpace(std::move(cs)), fTileMode(mode) {
+            SkASSERT(fPos.size() == 0 || fPos.size() == fColors.size());
+
+            // throw away inconsistent inputs
+            if (fPos.size() != fColors.size()) {
+                fPos = {};
+            }
+        }
+
+        Colors(SkSpan<const SkColor4f> colors, SkTileMode tm, sk_sp<SkColorSpace> cs = nullptr)
+                : Colors(colors, {}, tm, std::move(cs)) {}
+
+        SkSpan<const SkColor4f> colors() const { return fColors; }
+        SkSpan<const float> positions() const { return fPos; }
+        const sk_sp<SkColorSpace>& colorSpace() const { return fColorSpace; }
+        SkTileMode tileMode() const { return fTileMode; }
+
+    private:
+        SkSpan<const SkColor4f> fColors;
+        SkSpan<const float> fPos;
+        sk_sp<SkColorSpace> fColorSpace;
+        SkTileMode fTileMode = SkTileMode::kClamp;
+    };
+
+    SkGradient() {}
+    SkGradient(const Colors& colors, const Interpolation& interp)
+            : fColors(colors), fInterpolation(interp) {}
+
+    const Colors& colors() const { return fColors; }
+    const Interpolation& interpolation() const { return fInterpolation; }
+
+private:
+    Colors fColors;
+    Interpolation fInterpolation;
+};
+
+namespace SkShaders {
+/** Returns a shader that generates a linear gradient between the two specified points.
+ *  If the inputs are invalid, this will return nullptr.
+ *  @param points  Array of 2 points, the end-points of the line segment
+ *  @param grad    Description of the colors and interpolation method
+ *  @param lm      Optional local matrix, may be null
+ */
+SK_API sk_sp<SkShader> LinearGradient(const SkPoint pts[2],
+                                      const SkGradient&,
+                                      const SkMatrix* lm = nullptr);
+
+/** Returns a shader that generates a radial gradient given the center and radius.
+ *  @param center  The center of the circle for this gradient
+ *  @param radius  Must be positive. The radius of the circle for this gradient
+ *  @param grad    Description of the colors and interpolation method
+ *  @param lm      Optional local matrix, may be null
+ */
+SK_API sk_sp<SkShader> RadialGradient(SkPoint center,
+                                      float radius,
+                                      const SkGradient& grad,
+                                      const SkMatrix* lm = nullptr);
+
+/** Returns a shader that generates a conical gradient given two circles, or
+ *  returns null if the inputs are invalid. The gradient interprets the
+ *  two circles according to the following HTML spec.
+ *  http://dev.w3.org/html5/2dcontext/#dom-context-2d-createradialgradient
+ *  @param start        The center of the circle for this gradient
+ *  @param startRadius  Must be positive. The radius of the circle for this gradient
+ *  @param end          The center of the circle for this gradient
+ *  @param startRadius  Must be positive. The radius of the circle for this gradient
+ *  @param grad         Description of the colors and interpolation method
+ *  @param lm           Optional local matrix, may be null
+ */
+SK_API sk_sp<SkShader> TwoPointConicalGradient(SkPoint start,
+                                               float startRadius,
+                                               SkPoint end,
+                                               float endRadius,
+                                               const SkGradient& grad,
+                                               const SkMatrix* lm = nullptr);
+
+/** Returns a shader that generates a sweep gradient given a center.
+ *  The shader accepts negative angles and angles larger than 360, draws
+ *  between 0 and 360 degrees, similar to the CSS conic-gradient
+ *  semantics. 0 degrees means horizontal positive x axis. The start angle
+ *  must be less than the end angle, otherwise a null pointer is
+ *  returned. If color stops do not contain 0 and 1 but are within this
+ *  range, the respective outer color stop is repeated for 0 and 1. Color
+ *  stops less than 0 are clamped to 0, and greater than 1 are clamped to 1.
+ *  @param center      The center of the sweep
+ *  @param startAngle  Start of the angular range, corresponding to pos == 0.
+ *  @param endAngle    End of the angular range, corresponding to pos == 1.
+ *  @param grad        Description of the colors and interpolation method
+ *  @param lm          Optional local matrix, may be null
+ */
+SK_API sk_sp<SkShader> SweepGradient(SkPoint center,
+                                     float startAngle,
+                                     float endAngle,
+                                     const SkGradient&,
+                                     const SkMatrix* lm = nullptr);
+static inline sk_sp<SkShader> SweepGradient(SkPoint center,
+                                     const SkGradient& grad,
+                                     const SkMatrix* lm = nullptr) {
+    return SweepGradient(center, 0, 360, grad, lm);
+}
+
+}  // namespace SkShaders
+
+#endif

package/cpp/skia/include/effects/SkHighContrastFilter.h

@@ -45,8 +45,8 @@ struct SkHighContrastConfig {
     bool isValid() const {
         return fInvertStyle >= InvertStyle::kNoInvert &&
                fInvertStyle <= InvertStyle::kInvertLightness &&
-               fContrast >= -1.0 &&
-               fContrast <= 1.0;
+               fContrast >= -1.0f &&
+               fContrast <= 1.0f;
     }
 
     // If true, the color will be converted to grayscale.

package/cpp/skia/include/gpu/GpuTypes.h

@@ -82,10 +82,12 @@ enum class Origin : unsigned {
 enum class GpuStatsFlags : uint32_t {
     kNone = 0b00,
     kElapsedTime = 0b01,
+    kOcclusionPassSamples = 0b10,
 };
 
 struct GpuStats {
     uint64_t elapsedTime = 0;
+    uint64_t numOcclusionPassSamples = 0;
 };
 
 } // namespace skgpu

package/cpp/skia/include/gpu/ganesh/GrBackendSemaphore.h

@@ -4,18 +4,13 @@
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
-
 #ifndef GrBackendSemaphore_DEFINED
 #define GrBackendSemaphore_DEFINED
 
-#include "include/gpu/ganesh/GrTypes.h"  // IWYU pragma: keep
+#include "include/gpu/ganesh/GrTypes.h"
 #include "include/private/base/SkAPI.h"
 #include "include/private/base/SkAnySubclass.h"
 
-#ifdef SK_DIRECT3D
-#include "include/private/gpu/ganesh/GrD3DTypesMinimal.h"
-#endif
-
 #include <cstddef>
 
 class GrBackendSemaphoreData;
@@ -25,27 +20,14 @@ class GrBackendSemaphoreData;
  */
 class SK_API GrBackendSemaphore {
 public:
-    // The GrBackendSemaphore cannot be used until either init* is called, which will set the
-    // appropriate GrBackend.
+    // An empty semaphore. To instantiate, see GrBackendSemaphores::MakeVk and similar
     GrBackendSemaphore();
     ~GrBackendSemaphore();
     GrBackendSemaphore(const GrBackendSemaphore&);
     GrBackendSemaphore& operator=(const GrBackendSemaphore&);
 
-#ifdef SK_DIRECT3D
-    void initDirect3D(const GrD3DFenceInfo& info) {
-        fBackend = GrBackendApi::kDirect3D;
-        this->assignD3DFenceInfo(info);
-        fIsInitialized = true;
-    }
-#endif
-
-    bool isInitialized() const { return fIsInitialized; }
     GrBackendApi backend() const { return fBackend; }
-
-#ifdef SK_DIRECT3D
-    bool getD3DFenceInfo(GrD3DFenceInfo* outInfo) const;
-#endif
+    bool isInitialized() const { return fBackend != GrBackendApi::kUnsupported; }
 
 private:
     friend class GrBackendSemaphorePriv;
@@ -57,24 +39,12 @@ private:
     using AnySemaphoreData = SkAnySubclass<GrBackendSemaphoreData, kMaxSubclassSize>;
 
     template <typename SemaphoreData>
-    GrBackendSemaphore(GrBackendApi api, SemaphoreData data) : fBackend(api), fIsInitialized(true) {
+    GrBackendSemaphore(GrBackendApi api, SemaphoreData data) : fBackend(api) {
         fSemaphoreData.emplace<SemaphoreData>(data);
     }
 
-#ifdef SK_DIRECT3D
-    void assignD3DFenceInfo(const GrD3DFenceInfo& info);
-#endif
-
-    GrBackendApi fBackend;
+    GrBackendApi fBackend = GrBackendApi::kUnsupported;
     AnySemaphoreData fSemaphoreData;
-
-    union {
-        void* fPlaceholder;  // TODO(293490566)
-#ifdef SK_DIRECT3D
-        GrD3DFenceInfo* fD3DFenceInfo;
-#endif
-    };
-    bool fIsInitialized;
 };
 
 #endif

package/cpp/skia/include/gpu/ganesh/GrBackendSurface.h

@@ -27,11 +27,6 @@ namespace skgpu {
 class MutableTextureState;
 }
 
-#ifdef SK_DIRECT3D
-#include "include/private/gpu/ganesh/GrD3DTypesMinimal.h"
-class GrD3DResourceState;
-#endif
-
 #if defined(SK_DEBUG) || defined(GPU_TEST_UTILS)
 class SkString;
 #endif
@@ -49,12 +44,6 @@ public:
     GrBackendFormat& operator=(const GrBackendFormat&);
     ~GrBackendFormat();
 
-#ifdef SK_DIRECT3D
-    static GrBackendFormat MakeDxgi(DXGI_FORMAT format) {
-        return GrBackendFormat(format);
-    }
-#endif
-
     static GrBackendFormat MakeMock(GrColorType colorType,
                                     SkTextureCompressionType compression,
                                     bool isStencilFormat = false);
@@ -73,14 +62,6 @@ public:
 
     GrColorFormatDesc desc() const;
 
-#ifdef SK_DIRECT3D
-    /**
-     * If the backend API is Direct3D this gets the format as a DXGI_FORMAT and returns true.
-     * Otherwise, returns false.
-     */
-    bool asDxgiFormat(DXGI_FORMAT*) const;
-#endif
-
     /**
      * If the backend API is not Mock these three calls will return kUnknown, kNone or false,
      * respectively. Otherwise, only one of the following can be true. The GrColorType is not
@@ -119,10 +100,6 @@ private:
         fFormatData.emplace<FormatData>(formatData);
     }
 
-#ifdef SK_DIRECT3D
-    explicit GrBackendFormat(DXGI_FORMAT dxgiFormat);
-#endif
-
     GrBackendFormat(GrColorType, SkTextureCompressionType, bool isStencilFormat);
 
 #ifdef SK_DEBUG
@@ -133,16 +110,11 @@ private:
     bool fValid = false;
     AnyFormatData fFormatData;
 
-    union {
-#ifdef SK_DIRECT3D
-        DXGI_FORMAT fDxgiFormat;
-#endif
-        struct {
-            GrColorType fColorType;
-            SkTextureCompressionType fCompressionType;
-            bool fIsStencilFormat;
-        } fMock;
-    };
+    struct {
+        GrColorType fColorType;
+        SkTextureCompressionType fCompressionType;
+        bool fIsStencilFormat;
+    } fMock;
     GrTextureType fTextureType = GrTextureType::kNone;
 };
 
@@ -151,13 +123,6 @@ public:
     // Creates an invalid backend texture.
     GrBackendTexture();
 
-#ifdef SK_DIRECT3D
-    GrBackendTexture(int width,
-                     int height,
-                     const GrD3DTextureResourceInfo& d3dInfo,
-                     std::string_view label = {});
-#endif
-
     GrBackendTexture(int width,
                      int height,
                      skgpu::Mipmapped,
@@ -179,17 +144,6 @@ public:
     GrBackendApi backend() const {return fBackend; }
     GrTextureType textureType() const { return fTextureType; }
 
-#ifdef SK_DIRECT3D
-    // If the backend API is Direct3D, copies a snapshot of the GrD3DTextureResourceInfo struct into
-    // the passed in pointer and returns true. This snapshot will set the fResourceState to the
-    // current resource state. Otherwise returns false if the backend API is not D3D.
-    bool getD3DTextureResourceInfo(GrD3DTextureResourceInfo*) const;
-
-    // Anytime the client changes the D3D12_RESOURCE_STATES of the D3D12_RESOURCE captured by this
-    // GrBackendTexture, they must call this function to notify Skia of the changed layout.
-    void setD3DResourceState(GrD3DResourceStateEnum);
-#endif
-
     // Get the GrBackendFormat for this texture (or an invalid format if this is not valid).
     GrBackendFormat getBackendFormat() const;
 
@@ -249,20 +203,6 @@ private:
     friend class GrVkGpu;  // for getMutableState
     sk_sp<skgpu::MutableTextureState> getMutableState() const;
 
-#ifdef SK_DIRECT3D
-    friend class GrD3DTexture;
-    friend class GrD3DGpu;     // for getGrD3DResourceState
-    GrBackendTexture(int width,
-                     int height,
-                     const GrD3DTextureResourceInfo& vkInfo,
-                     sk_sp<GrD3DResourceState> state,
-                     std::string_view label = {});
-    sk_sp<GrD3DResourceState> getGrD3DResourceState() const;
-#endif
-
-    // Free and release and resources being held by the GrBackendTexture.
-    void cleanup();
-
     bool fIsValid;
     int fWidth;         //<! width in pixels
     int fHeight;        //<! height in pixels
@@ -272,12 +212,7 @@ private:
     GrTextureType fTextureType;
     AnyTextureData fTextureData;
 
-    union {
-        GrMockTextureInfo fMockInfo;
-#ifdef SK_DIRECT3D
-        GrD3DBackendSurfaceInfo fD3DInfo;
-#endif
-    };
+    GrMockTextureInfo fMockInfo;
 };
 
 class SK_API GrBackendRenderTarget {
@@ -285,12 +220,6 @@ public:
     // Creates an invalid backend texture.
     GrBackendRenderTarget();
 
-#ifdef SK_DIRECT3D
-    GrBackendRenderTarget(int width,
-                          int height,
-                          const GrD3DTextureResourceInfo& d3dInfo);
-#endif
-
     GrBackendRenderTarget(int width,
                           int height,
                           int sampleCnt,
@@ -310,16 +239,6 @@ public:
     GrBackendApi backend() const {return fBackend; }
     bool isFramebufferOnly() const { return fFramebufferOnly; }
 
-#ifdef SK_DIRECT3D
-    // If the backend API is Direct3D, copies a snapshot of the GrMtlTextureInfo struct into the
-    // passed in pointer and returns true. Otherwise returns false if the backend API is not D3D.
-    bool getD3DTextureResourceInfo(GrD3DTextureResourceInfo*) const;
-
-    // Anytime the client changes the D3D12_RESOURCE_STATES of the D3D12_RESOURCE captured by this
-    // GrBackendTexture, they must call this function to notify Skia of the changed layout.
-    void setD3DResourceState(GrD3DResourceStateEnum);
-#endif
-
     // Get the GrBackendFormat for this render target (or an invalid format if this is not valid).
     GrBackendFormat getBackendFormat() const;
 
@@ -377,19 +296,6 @@ private:
     friend class GrVkGpu; // for getMutableState
     sk_sp<skgpu::MutableTextureState> getMutableState() const;
 
-#ifdef SK_DIRECT3D
-    friend class GrD3DGpu;
-    friend class GrD3DRenderTarget;
-    GrBackendRenderTarget(int width,
-                          int height,
-                          const GrD3DTextureResourceInfo& d3dInfo,
-                          sk_sp<GrD3DResourceState> state);
-    sk_sp<GrD3DResourceState> getGrD3DResourceState() const;
-#endif
-
-    // Free and release and resources being held by the GrBackendTexture.
-    void cleanup();
-
     bool fIsValid;
     bool fFramebufferOnly = false;
     int fWidth;         //<! width in pixels
@@ -401,12 +307,7 @@ private:
     GrBackendApi fBackend;
     AnyRenderTargetData fRTData;
 
-    union {
-        GrMockRenderTargetInfo fMockInfo;
-#ifdef SK_DIRECT3D
-        GrD3DBackendSurfaceInfo fD3DInfo;
-#endif
-    };
+    GrMockRenderTargetInfo fMockInfo;
 };
 
 #endif

package/cpp/skia/include/gpu/ganesh/GrContextOptions.h

@@ -75,17 +75,6 @@ struct SK_API GrContextOptions {
 
     GrContextOptions() {}
 
-    /**
-     * If Skia is creating a default VMA allocator for the Vulkan backend this value will be used
-     * for the preferredLargeHeapBlockSize. If the value is not set, then Skia will use an
-     * inernally defined default size.
-     *
-     * However, it is highly discouraged to have Skia make a default allocator (and support for
-     * doing so will be removed soon,  b/321962001). Instead clients should create their own
-     * allocator to pass into Skia where they can fine tune this value themeselves.
-     */
-    std::optional<uint64_t> fVulkanVMALargeHeapBlockSize;
-
     /**
      * Optional callback that can be passed into the GrDirectContext which will be called when the
      * GrDirectContext is about to be destroyed. When this call is made, it will be safe for the

package/cpp/skia/include/gpu/ganesh/GrDirectContext.h

@@ -42,7 +42,6 @@ class SkTraceMemoryDump;
 enum SkColorType : int;
 enum class SkTextureCompressionType;
 struct GrMockOptions;
-struct GrD3DBackendContext; // IWYU pragma: keep
 
 namespace skgpu {
     class MutableTextureState;
@@ -59,14 +58,6 @@ enum class BackendSurfaceAccess;
 
 class SK_API GrDirectContext : public GrRecordingContext {
 public:
-#ifdef SK_DIRECT3D
-    /**
-     * Makes a GrDirectContext which uses Direct3D as the backend. The Direct3D context
-     * must be kept alive until the returned GrDirectContext is first destroyed or abandoned.
-     */
-    static sk_sp<GrDirectContext> MakeDirect3D(const GrD3DBackendContext&, const GrContextOptions&);
-    static sk_sp<GrDirectContext> MakeDirect3D(const GrD3DBackendContext&);
-#endif
 
     static sk_sp<GrDirectContext> MakeMock(const GrMockOptions*, const GrContextOptions&);
     static sk_sp<GrDirectContext> MakeMock(const GrMockOptions*);

package/cpp/skia/include/gpu/ganesh/d3d/GrD3DBackendSemaphore.h

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ */
+#ifndef GrD3DBackendSemaphore_DEFINED
+#define GrD3DBackendSemaphore_DEFINED
+
+#include "include/gpu/ganesh/GrBackendSemaphore.h"
+#include "include/private/base/SkAPI.h"
+#include "include/private/gpu/ganesh/GrD3DTypesMinimal.h"
+
+namespace GrBackendSemaphores {
+SK_API GrBackendSemaphore MakeD3D(const GrD3DFenceInfo& info);
+SK_API GrD3DFenceInfo GetD3DFenceInfo(const GrBackendSemaphore&);
+}  // namespace GrBackendSemaphores
+
+#endif

package/cpp/skia/include/gpu/ganesh/d3d/GrD3DBackendSurface.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef GrD3DBackendSurface_DEFINED
+#define GrD3DBackendSurface_DEFINED
+
+#include "include/private/base/SkAPI.h"
+#include "include/private/gpu/ganesh/GrD3DTypesMinimal.h"
+
+#include <string_view>
+
+class GrBackendFormat;
+class GrBackendTexture;
+class GrBackendRenderTarget;
+
+namespace GrBackendFormats {
+
+SK_API GrBackendFormat MakeD3D(DXGI_FORMAT);
+SK_API DXGI_FORMAT AsDxgiFormat(const GrBackendFormat&);
+
+}  // namespace GrBackendFormats
+
+namespace GrBackendTextures {
+
+SK_API GrBackendTexture MakeD3D(int width,
+                                int height,
+                                const GrD3DTextureResourceInfo& d3dInfo,
+                                std::string_view label = {});
+
+// Return a snapshot of the GrD3DTextureResourceInfo struct.
+// This snapshot will set the fResourceState to the current resource state.
+SK_API GrD3DTextureResourceInfo GetD3DTextureResourceInfo(const GrBackendTexture&);
+
+// Anytime the client changes the D3D12_RESOURCE_STATES of the D3D12_RESOURCE captured by this
+// GrBackendTexture, they must call this function to notify Skia of the changed layout.
+SK_API void SetD3DResourceState(GrBackendTexture*, GrD3DResourceStateEnum);
+
+}  // namespace GrBackendTextures
+
+namespace GrBackendRenderTargets {
+
+SK_API GrBackendRenderTarget MakeD3D(int width,
+                                     int height,
+                                     const GrD3DTextureResourceInfo& d3dInfo);
+
+// Return a snapshot of the GrD3DTextureResourceInfo struct.
+// This snapshot will set the fResourceState to the current resource state.
+SK_API GrD3DTextureResourceInfo GetD3DTextureResourceInfo(const GrBackendRenderTarget&);
+
+// Anytime the client changes the D3D12_RESOURCE_STATES of the D3D12_RESOURCE captured by this
+// GrBackendRenderTarget, they must call this function to notify Skia of the changed layout.
+SK_API void SetD3DResourceState(GrBackendRenderTarget*, GrD3DResourceStateEnum);
+
+}  // namespace GrBackendRenderTargets
+
+#endif

package/cpp/skia/include/gpu/ganesh/d3d/GrD3DDirectContext.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrD3DDirectContext_DEFINED
+#define GrD3DDirectContext_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
+
+class GrDirectContext;
+struct GrContextOptions;
+struct GrD3DBackendContext;
+
+namespace GrDirectContexts {
+/**
+ * Makes a GrDirectContext which uses Direct3D as the backend. The Direct3D context
+ * must be kept alive until the returned GrDirectContext is first destroyed or abandoned.
+ */
+SK_API sk_sp<GrDirectContext> MakeD3D(const GrD3DBackendContext& backendContext,
+                                      const GrContextOptions& options);
+SK_API sk_sp<GrDirectContext> MakeD3D(const GrD3DBackendContext& backendContext);
+}  // namespace GrDirectContexts
+
+#endif

package/cpp/skia/include/gpu/ganesh/gl/GrGLFunctions.h

@@ -12,6 +12,9 @@
 #include "include/gpu/ganesh/gl/GrGLTypes.h"
 #include "include/private/base/SkTLogic.h"
 
+#if defined(__EMSCRIPTEN__)
+#include <emscripten/version.h>
+#endif
 
 extern "C" {
 
@@ -218,7 +221,7 @@ using GrGLMultiDrawElementsInstancedBaseVertexBaseInstanceFn = GrGLvoid GR_GL_FU
 /* ARB_sync */
 using GrGLFenceSyncFn = GrGLsync GR_GL_FUNCTION_TYPE(GrGLenum condition, GrGLbitfield flags);
 using GrGLIsSyncFn = GrGLboolean GR_GL_FUNCTION_TYPE(GrGLsync sync);
-#if defined(__EMSCRIPTEN__)
+#if defined(__EMSCRIPTEN__) && (__EMSCRIPTEN_major__ < 5)
 using GrGLClientWaitSyncFn = GrGLenum GR_GL_FUNCTION_TYPE(GrGLsync sync, GrGLbitfield flags, GrGLint timeoutLo, GrGLint timeoutHi);
 using GrGLWaitSyncFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsync sync, GrGLbitfield flags, GrGLuint timeoutLo, GrGLuint timeoutHi);
 #else