@shopify/react-native-skia 0.1.196 → 0.1.199

package/cpp/skia/include/core/SkSurfaceCharacterization.h

@@ -5,259 +5,11 @@
  * found in the LICENSE file.
  */
 
-#ifndef SkSurfaceCharacterization_DEFINED
-#define SkSurfaceCharacterization_DEFINED
-
-
-#include "include/core/SkColorSpace.h"
-#include "include/core/SkImageInfo.h"
-#include "include/core/SkRefCnt.h"
-#include "include/core/SkSurfaceProps.h"
-
-class SkColorSpace;
-
-
-#if defined(SK_GANESH)
-#include "include/gpu/GrBackendSurface.h"
-#include "include/gpu/GrContextThreadSafeProxy.h"
-#include "include/gpu/GrTypes.h"
-
-/** \class SkSurfaceCharacterization
-    A surface characterization contains all the information Ganesh requires to makes its internal
-    rendering decisions. When passed into a SkDeferredDisplayListRecorder it will copy the
-    data and pass it on to the SkDeferredDisplayList if/when it is created. Note that both of
-    those objects (the Recorder and the DisplayList) will take a ref on the
-    GrContextThreadSafeProxy and SkColorSpace objects.
-*/
-class SK_API SkSurfaceCharacterization {
-public:
-    enum class Textureable : bool { kNo = false, kYes = true };
-    enum class MipMapped : bool { kNo = false, kYes = true };
-    enum class UsesGLFBO0 : bool { kNo = false, kYes = true };
-    // This flag indicates that the backing VkImage for this Vulkan surface will have the
-    // VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set. This bit allows skia to handle advanced blends
-    // more optimally in a shader by being able to directly read the dst values.
-    enum class VkRTSupportsInputAttachment : bool { kNo = false, kYes = true };
-    // This flag indicates if the surface is wrapping a raw Vulkan secondary command buffer.
-    enum class VulkanSecondaryCBCompatible : bool { kNo = false, kYes = true };
-
-    SkSurfaceCharacterization()
-            : fCacheMaxResourceBytes(0)
-            , fOrigin(kBottomLeft_GrSurfaceOrigin)
-            , fSampleCnt(0)
-            , fIsTextureable(Textureable::kYes)
-            , fIsMipMapped(MipMapped::kYes)
-            , fUsesGLFBO0(UsesGLFBO0::kNo)
-            , fVulkanSecondaryCBCompatible(VulkanSecondaryCBCompatible::kNo)
-            , fIsProtected(GrProtected::kNo)
-            , fSurfaceProps(0, kUnknown_SkPixelGeometry) {
-    }
-
-    SkSurfaceCharacterization(SkSurfaceCharacterization&&) = default;
-    SkSurfaceCharacterization& operator=(SkSurfaceCharacterization&&) = default;
-
-    SkSurfaceCharacterization(const SkSurfaceCharacterization&) = default;
-    SkSurfaceCharacterization& operator=(const SkSurfaceCharacterization& other) = default;
-    bool operator==(const SkSurfaceCharacterization& other) const;
-    bool operator!=(const SkSurfaceCharacterization& other) const {
-        return !(*this == other);
-    }
-
-    /*
-     * Return a new surface characterization with the only difference being a different width
-     * and height
-     */
-    SkSurfaceCharacterization createResized(int width, int height) const;
-
-    /*
-     * Return a new surface characterization with only a replaced color space
-     */
-    SkSurfaceCharacterization createColorSpace(sk_sp<SkColorSpace>) const;
-
-    /*
-     * Return a new surface characterization with the backend format replaced. A colorType
-     * must also be supplied to indicate the interpretation of the new format.
-     */
-    SkSurfaceCharacterization createBackendFormat(SkColorType colorType,
-                                                  const GrBackendFormat& backendFormat) const;
-
-    /*
-     * Return a new surface characterization with just a different use of FBO0 (in GL)
-     */
-    SkSurfaceCharacterization createFBO0(bool usesGLFBO0) const;
-
-    GrContextThreadSafeProxy* contextInfo() const { return fContextInfo.get(); }
-    sk_sp<GrContextThreadSafeProxy> refContextInfo() const { return fContextInfo; }
-    size_t cacheMaxResourceBytes() const { return fCacheMaxResourceBytes; }
-
-    bool isValid() const { return kUnknown_SkColorType != fImageInfo.colorType(); }
-
-    const SkImageInfo& imageInfo() const { return fImageInfo; }
-    const GrBackendFormat& backendFormat() const { return fBackendFormat; }
-    GrSurfaceOrigin origin() const { return fOrigin; }
-    SkISize dimensions() const { return fImageInfo.dimensions(); }
-    int width() const { return fImageInfo.width(); }
-    int height() const { return fImageInfo.height(); }
-    SkColorType colorType() const { return fImageInfo.colorType(); }
-    int sampleCount() const { return fSampleCnt; }
-    bool isTextureable() const { return Textureable::kYes == fIsTextureable; }
-    bool isMipMapped() const { return MipMapped::kYes == fIsMipMapped; }
-    bool usesGLFBO0() const { return UsesGLFBO0::kYes == fUsesGLFBO0; }
-    bool vkRTSupportsInputAttachment() const {
-        return VkRTSupportsInputAttachment::kYes == fVkRTSupportsInputAttachment;
-    }
-    bool vulkanSecondaryCBCompatible() const {
-        return VulkanSecondaryCBCompatible::kYes == fVulkanSecondaryCBCompatible;
-    }
-    GrProtected isProtected() const { return fIsProtected; }
-    SkColorSpace* colorSpace() const { return fImageInfo.colorSpace(); }
-    sk_sp<SkColorSpace> refColorSpace() const { return fImageInfo.refColorSpace(); }
-    const SkSurfaceProps& surfaceProps()const { return fSurfaceProps; }
-
-    // Is the provided backend texture compatible with this surface characterization?
-    bool isCompatible(const GrBackendTexture&) const;
-
-private:
-    friend class SkSurface_Ganesh;           // for 'set' & 'config'
-    friend class GrVkSecondaryCBDrawContext; // for 'set' & 'config'
-    friend class GrContextThreadSafeProxy; // for private ctor
-    friend class SkDeferredDisplayListRecorder; // for 'config'
-    friend class SkSurface; // for 'config'
-
-    SkDEBUGCODE(void validate() const;)
-
-    SkSurfaceCharacterization(sk_sp<GrContextThreadSafeProxy> contextInfo,
-                              size_t cacheMaxResourceBytes,
-                              const SkImageInfo& ii,
-                              const GrBackendFormat& backendFormat,
-                              GrSurfaceOrigin origin,
-                              int sampleCnt,
-                              Textureable isTextureable,
-                              MipMapped isMipMapped,
-                              UsesGLFBO0 usesGLFBO0,
-                              VkRTSupportsInputAttachment vkRTSupportsInputAttachment,
-                              VulkanSecondaryCBCompatible vulkanSecondaryCBCompatible,
-                              GrProtected isProtected,
-                              const SkSurfaceProps& surfaceProps)
-            : fContextInfo(std::move(contextInfo))
-            , fCacheMaxResourceBytes(cacheMaxResourceBytes)
-            , fImageInfo(ii)
-            , fBackendFormat(backendFormat)
-            , fOrigin(origin)
-            , fSampleCnt(sampleCnt)
-            , fIsTextureable(isTextureable)
-            , fIsMipMapped(isMipMapped)
-            , fUsesGLFBO0(usesGLFBO0)
-            , fVkRTSupportsInputAttachment(vkRTSupportsInputAttachment)
-            , fVulkanSecondaryCBCompatible(vulkanSecondaryCBCompatible)
-            , fIsProtected(isProtected)
-            , fSurfaceProps(surfaceProps) {
-        if (fSurfaceProps.flags() & SkSurfaceProps::kDynamicMSAA_Flag) {
-            // Dynamic MSAA is not currently supported with DDL.
-            *this = {};
-        }
-        SkDEBUGCODE(this->validate());
-    }
-
-    void set(sk_sp<GrContextThreadSafeProxy> contextInfo,
-             size_t cacheMaxResourceBytes,
-             const SkImageInfo& ii,
-             const GrBackendFormat& backendFormat,
-             GrSurfaceOrigin origin,
-             int sampleCnt,
-             Textureable isTextureable,
-             MipMapped isMipMapped,
-             UsesGLFBO0 usesGLFBO0,
-             VkRTSupportsInputAttachment vkRTSupportsInputAttachment,
-             VulkanSecondaryCBCompatible vulkanSecondaryCBCompatible,
-             GrProtected isProtected,
-             const SkSurfaceProps& surfaceProps) {
-        if (surfaceProps.flags() & SkSurfaceProps::kDynamicMSAA_Flag) {
-            // Dynamic MSAA is not currently supported with DDL.
-            *this = {};
-        } else {
-            fContextInfo = contextInfo;
-            fCacheMaxResourceBytes = cacheMaxResourceBytes;
-
-            fImageInfo = ii;
-            fBackendFormat = backendFormat;
-            fOrigin = origin;
-            fSampleCnt = sampleCnt;
-            fIsTextureable = isTextureable;
-            fIsMipMapped = isMipMapped;
-            fUsesGLFBO0 = usesGLFBO0;
-            fVkRTSupportsInputAttachment = vkRTSupportsInputAttachment;
-            fVulkanSecondaryCBCompatible = vulkanSecondaryCBCompatible;
-            fIsProtected = isProtected;
-            fSurfaceProps = surfaceProps;
-        }
-        SkDEBUGCODE(this->validate());
-    }
-
-    sk_sp<GrContextThreadSafeProxy> fContextInfo;
-    size_t                          fCacheMaxResourceBytes;
-
-    SkImageInfo                     fImageInfo;
-    GrBackendFormat                 fBackendFormat;
-    GrSurfaceOrigin                 fOrigin;
-    int                             fSampleCnt;
-    Textureable                     fIsTextureable;
-    MipMapped                       fIsMipMapped;
-    UsesGLFBO0                      fUsesGLFBO0;
-    VkRTSupportsInputAttachment     fVkRTSupportsInputAttachment;
-    VulkanSecondaryCBCompatible     fVulkanSecondaryCBCompatible;
-    GrProtected                     fIsProtected;
-    SkSurfaceProps                  fSurfaceProps;
-};
-
-#else// !defined(SK_GANESH)
-class GrBackendFormat;
-
-class SK_API SkSurfaceCharacterization {
-public:
-    SkSurfaceCharacterization() : fSurfaceProps(0, kUnknown_SkPixelGeometry) { }
-
-    SkSurfaceCharacterization createResized(int width, int height) const {
-        return *this;
-    }
-
-    SkSurfaceCharacterization createColorSpace(sk_sp<SkColorSpace>) const {
-        return *this;
-    }
-
-    SkSurfaceCharacterization createBackendFormat(SkColorType, const GrBackendFormat&) const {
-        return *this;
-    }
-
-    SkSurfaceCharacterization createFBO0(bool usesGLFBO0) const {
-        return *this;
-    }
-
-    bool operator==(const SkSurfaceCharacterization& other) const { return false; }
-    bool operator!=(const SkSurfaceCharacterization& other) const {
-        return !(*this == other);
-    }
-
-    size_t cacheMaxResourceBytes() const { return 0; }
-
-    bool isValid() const { return false; }
-
-    int width() const { return 0; }
-    int height() const { return 0; }
-    int stencilCount() const { return 0; }
-    bool isTextureable() const { return false; }
-    bool isMipMapped() const { return false; }
-    bool usesGLFBO0() const { return false; }
-    bool vkRTSupportsAttachmentInput() const { return false; }
-    bool vulkanSecondaryCBCompatible() const { return false; }
-    SkColorSpace* colorSpace() const { return nullptr; }
-    sk_sp<SkColorSpace> refColorSpace() const { return nullptr; }
-    const SkSurfaceProps& surfaceProps()const { return fSurfaceProps; }
-
-private:
-    SkSurfaceProps fSurfaceProps;
-};
-
-#endif
-
-#endif
+// TODO(kjlubick, robertphillips) migrate Chromium to use the new location and name
+#include "include/private/chromium/GrSurfaceCharacterization.h" // IWYU pragma: export
+
+class GrDeferredDisplayList;
+class GrDeferredDisplayListRecorder;
+using SkDeferredDisplayList = GrDeferredDisplayList;
+using SkDeferredDisplayListRecorder = GrDeferredDisplayListRecorder;
+using SkSurfaceCharacterization = GrSurfaceCharacterization;

package/cpp/skia/include/core/SkTiledImageUtils.h

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkTiledImageUtils_DEFINED
+#define SkTiledImageUtils_DEFINED
+
+#include "include/core/SkCanvas.h"
+#include "include/core/SkImage.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSamplingOptions.h"
+#include "include/core/SkScalar.h"
+#include "include/private/base/SkAPI.h"
+class SkPaint;
+
+namespace SkTiledImageUtils {
+
+SK_API void DrawImageRect(SkCanvas* canvas,
+                          const SkImage* image,
+                          const SkRect& src,
+                          const SkRect& dst,
+                          const SkSamplingOptions& sampling = {},
+                          const SkPaint* paint = nullptr,
+                          SkCanvas::SrcRectConstraint constraint =
+                                  SkCanvas::kFast_SrcRectConstraint);
+
+inline void DrawImageRect(SkCanvas* canvas,
+                          const sk_sp<SkImage>& image,
+                          const SkRect& src,
+                          const SkRect& dst,
+                          const SkSamplingOptions& sampling = {},
+                          const SkPaint* paint = nullptr,
+                          SkCanvas::SrcRectConstraint constraint =
+                                  SkCanvas::kFast_SrcRectConstraint) {
+    DrawImageRect(canvas, image.get(), src, dst, sampling, paint, constraint);
+}
+
+inline void DrawImageRect(SkCanvas* canvas,
+                          const SkImage* image,
+                          const SkRect& dst,
+                          const SkSamplingOptions& sampling = {},
+                          const SkPaint* paint = nullptr,
+                          SkCanvas::SrcRectConstraint constraint =
+                                  SkCanvas::kFast_SrcRectConstraint) {
+    if (!image) {
+        return;
+    }
+
+    SkRect src = SkRect::MakeIWH(image->width(), image->height());
+
+    DrawImageRect(canvas, image, src, dst, sampling, paint, constraint);
+}
+
+inline void DrawImageRect(SkCanvas* canvas,
+                          const sk_sp<SkImage>& image,
+                          const SkRect& dst,
+                          const SkSamplingOptions& sampling = {},
+                          const SkPaint* paint = nullptr,
+                          SkCanvas::SrcRectConstraint constraint =
+                                  SkCanvas::kFast_SrcRectConstraint) {
+    DrawImageRect(canvas, image.get(), dst, sampling, paint, constraint);
+}
+
+inline void DrawImage(SkCanvas* canvas,
+                      const SkImage* image,
+                      SkScalar x, SkScalar y,
+                      const SkSamplingOptions& sampling = {},
+                      const SkPaint* paint = nullptr,
+                      SkCanvas::SrcRectConstraint constraint =
+                              SkCanvas::kFast_SrcRectConstraint) {
+    if (!image) {
+        return;
+    }
+
+    SkRect src = SkRect::MakeIWH(image->width(), image->height());
+    SkRect dst = SkRect::MakeXYWH(x, y, image->width(), image->height());
+
+    DrawImageRect(canvas, image, src, dst, sampling, paint, constraint);
+}
+
+inline void DrawImage(SkCanvas* canvas,
+                      const sk_sp<SkImage>& image,
+                      SkScalar x, SkScalar y,
+                      const SkSamplingOptions& sampling = {},
+                      const SkPaint* paint = nullptr,
+                      SkCanvas::SrcRectConstraint constraint =
+                              SkCanvas::kFast_SrcRectConstraint) {
+    DrawImage(canvas, image.get(), x, y, sampling, paint, constraint);
+}
+
+}  // namespace SkTiledImageUtils
+
+#endif // SkTiledImageUtils_DEFINED

package/cpp/skia/include/core/SkTypes.h

@@ -125,8 +125,10 @@
 
 // The top-level define SK_ENABLE_OPTIMIZE_SIZE can be used to remove several large features at once
 #if defined(SK_ENABLE_OPTIMIZE_SIZE)
-#   define SK_FORCE_RASTER_PIPELINE_BLITTER
-#   define SK_DISABLE_SDF_TEXT
+    #if !defined(SK_FORCE_RASTER_PIPELINE_BLITTER)
+        #define SK_FORCE_RASTER_PIPELINE_BLITTER
+    #endif
+    #define SK_DISABLE_SDF_TEXT
 #endif
 
 #ifndef SK_DISABLE_LEGACY_SHADERCONTEXT

package/cpp/skia/include/core/SkYUVAPixmaps.h

@@ -23,8 +23,6 @@
 #include <cstddef>
 #include <tuple>
 
-class GrImageContext;
-
 /**
  * SkYUVAInfo combined with per-plane SkColorTypes and row bytes. Fully specifies the SkPixmaps
  * for a YUVA image without the actual pixel memory and data.
@@ -55,9 +53,6 @@ public:
         /** Defaults to nothing supported. */
         constexpr SupportedDataTypes() = default;
 
-        /** Init based on texture formats supported by the context. */
-        SupportedDataTypes(const GrImageContext&);
-
         /** All legal combinations of PlaneConfig and DataType are supported. */
         static constexpr SupportedDataTypes All();
 

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

@@ -8,10 +8,19 @@
 #ifndef SkGradientShader_DEFINED
 #define SkGradientShader_DEFINED
 
+#include "include/core/SkColor.h"
 #include "include/core/SkColorSpace.h"
+#include "include/core/SkPoint.h"
 #include "include/core/SkRefCnt.h"
-#include "include/core/SkShader.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkShader.h" // IWYU pragma: keep
 #include "include/core/SkTileMode.h"
+#include "include/private/base/SkAPI.h"
+
+#include <cstdint>
+#include <utility>
+
+class SkMatrix;
 
 /** \class SkGradientShader
 

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

@@ -56,23 +56,6 @@ public:
         SkRect fCropRect;
     };
 
-    /**
-     *  Create a filter that updates the alpha of the image based on 'region'. Pixels inside the
-     *  region are made more opaque and pixels outside are made more transparent.
-     *
-     *  Specifically, if a pixel is inside the region, its alpha will be set to
-     *  max(innerMin, pixel's alpha). If a pixel is outside the region, its alpha will be updated to
-     *  min(outerMax, pixel's alpha).
-     *  @param region   The geometric region controlling the inner and outer alpha thresholds.
-     *  @param innerMin The minimum alpha value for pixels inside 'region'.
-     *  @param outerMax The maximum alpha value for pixels outside of 'region'.
-     *  @param input    The input filter, or uses the source bitmap if this is null.
-     *  @param cropRect Optional rectangle that crops the input and output.
-     */
-    static sk_sp<SkImageFilter> AlphaThreshold(const SkRegion& region, SkScalar innerMin,
-                                               SkScalar outerMax, sk_sp<SkImageFilter> input,
-                                               const CropRect& cropRect = {});
-
     /**
      *  Create a filter that implements a custom blend mode. Each output pixel is the result of
      *  combining the corresponding background and foreground pixels using the 4 coefficients:
@@ -198,7 +181,9 @@ public:
 
     /**
      *  Create a filter that draws the 'srcRect' portion of image into 'dstRect' using the given
-     *  filter quality. Similar to SkCanvas::drawImageRect. Returns null if 'image' is null.
+     *  filter quality. Similar to SkCanvas::drawImageRect. The returned image filter evaluates
+     *  to transparent black if 'image' is null.
+     *
      *  @param image    The image that is output by the filter, subset by 'srcRect'.
      *  @param srcRect  The source pixels sampled into 'dstRect'
      *  @param dstRect  The local rectangle to draw the image into.
@@ -209,7 +194,9 @@ public:
 
     /**
      *  Create a filter that draws the image using the given sampling.
-     *  Similar to SkCanvas::drawImage. Returns null if 'image' is null.
+     *  Similar to SkCanvas::drawImage. The returned image filter evaluates to transparent black if
+     *  'image' is null.
+     *
      *  @param image    The image that is output by the filter.
      *  @param sampling The sampling to use when drawing the image.
      */
@@ -223,21 +210,19 @@ public:
     }
 
     /**
-     *  Create a filter that draws the image using Mitchel cubic resampling.
-     *  @param image    The image that is output by the filter.
-     */
-    static sk_sp<SkImageFilter> Image(sk_sp<SkImage> image) {
-        return Image(std::move(image), SkSamplingOptions({1/3.0f, 1/3.0f}));
-    }
-
-    /**
-     *  Create a filter that mimics a zoom/magnifying lens effect.
-     *  @param srcRect
-     *  @param inset
-     *  @param input    The input filter that is magnified, if null the source bitmap is used.
-     *  @param cropRect Optional rectangle that crops the input and output.
-     */
-    static sk_sp<SkImageFilter> Magnifier(const SkRect& srcRect, SkScalar inset,
+     *  Create a filter that fills 'lensBounds' with a magnification of the input.
+     *
+     *  @param lensBounds The outer bounds of the magnifier effect
+     *  @param zoomAmount The amount of magnification applied to the input image
+     *  @param inset      The size or width of the fish-eye distortion around the magnified content
+     *  @param sampling   The SkSamplingOptions applied to the input image when magnified
+     *  @param input      The input filter that is magnified; if null the source bitmap is used
+     *  @param cropRect   Optional rectangle that crops the input and output.
+     */
+    static sk_sp<SkImageFilter> Magnifier(const SkRect& lensBounds,
+                                          SkScalar zoomAmount,
+                                          SkScalar inset,
+                                          const SkSamplingOptions& sampling,
                                           sk_sp<SkImageFilter> input,
                                           const CropRect& cropRect = {});
 
@@ -311,9 +296,11 @@ public:
                                        const CropRect& cropRect = {});
 
     /**
-     *  Create a filter that produces the SkPicture as its output, drawn into targetRect. Note that
-     *  the targetRect is not the same as the SkIRect cropRect that many filters accept. Returns
-     *  null if 'pic' is null.
+     *  Create a filter that produces the SkPicture as its output, clipped to both 'targetRect' and
+     *  the picture's internal cull rect.
+     *
+     *  If 'pic' is null, the returned image filter produces transparent black.
+     *
      *  @param pic        The picture that is drawn for the filter output.
      *  @param targetRect The drawing region for the picture.
      */
@@ -330,6 +317,9 @@ public:
      *  by the SkRuntimeShaderBuilder. The shader is defined in the image filter's local coordinate
      *  system, so it will automatically be affected by SkCanvas' transform.
      *
+     *  This variant assumes that the runtime shader samples 'childShaderName' with the same input
+     *  coordinate passed to to shader.
+     *
      *  @param builder         The builder used to produce the runtime shader, that will in turn
      *                         fill the result image
      *  @param childShaderName The name of the child shader defined in the builder that will be
@@ -340,6 +330,22 @@ public:
      *                         shader. If null the implicit source image is used instead
      */
     static sk_sp<SkImageFilter> RuntimeShader(const SkRuntimeShaderBuilder& builder,
+                                              std::string_view childShaderName,
+                                              sk_sp<SkImageFilter> input) {
+        return RuntimeShader(builder, /*sampleRadius=*/0.f, childShaderName, std::move(input));
+    }
+
+    /**
+     * As above, but 'sampleRadius' defines the sampling radius of 'childShaderName' relative to
+     * the runtime shader produced by 'builder'. If greater than 0, the coordinate passed to
+     * childShader.eval() will be up to 'sampleRadius' away (maximum absolute offset in 'x' or 'y')
+     * from the coordinate passed into the runtime shader.
+     *
+     * This allows Skia to provide sampleable values for the image filter without worrying about
+     * boundary conditions.
+    */
+    static sk_sp<SkImageFilter> RuntimeShader(const SkRuntimeShaderBuilder& builder,
+                                              SkScalar sampleRadius,
                                               std::string_view childShaderName,
                                               sk_sp<SkImageFilter> input);
 
@@ -359,6 +365,22 @@ public:
      *  @param inputCount       How many entries are present in 'childShaderNames' and 'inputs'.
      */
     static sk_sp<SkImageFilter> RuntimeShader(const SkRuntimeShaderBuilder& builder,
+                                              std::string_view childShaderNames[],
+                                              const sk_sp<SkImageFilter> inputs[],
+                                              int inputCount) {
+        return RuntimeShader(builder, /*maxSampleRadius=*/0.f, childShaderNames,
+                             inputs, inputCount);
+    }
+
+    /**
+     * As above, but 'maxSampleRadius' defines the sampling limit on coordinates provided to all
+     * child shaders. Like the single-child variant with a sample radius, this can be used to
+     * inform Skia that the runtime shader guarantees that all dynamic children (defined in
+     * childShaderNames) will be evaluated with coordinates at most 'maxSampleRadius' away from the
+     * coordinate provided to the runtime shader itself.
+     */
+    static sk_sp<SkImageFilter> RuntimeShader(const SkRuntimeShaderBuilder& builder,
+                                              SkScalar maxSampleRadius,
                                               std::string_view childShaderNames[],
                                               const sk_sp<SkImageFilter> inputs[],
                                               int inputCount);
@@ -377,6 +399,9 @@ public:
      *  Like Image() and Picture(), this is a leaf filter that can be used to introduce inputs to
      *  a complex filter graph, but should generally be combined with a filter that as at least
      *  one null input to use the implicit source image.
+     *
+     *  Returns an image filter that evaluates to transparent black if 'shader' is null.
+     *
      *  @param shader The shader that fills the result image
      */
     static sk_sp<SkImageFilter> Shader(sk_sp<SkShader> shader, const CropRect& cropRect = {}) {

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

@@ -8,7 +8,12 @@
 #ifndef SkPerlinNoiseShader_DEFINED
 #define SkPerlinNoiseShader_DEFINED
 
-#include "include/core/SkShader.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkShader.h" // IWYU pragma: keep
+#include "include/private/base/SkAPI.h"
+
+struct SkISize;
 
 /** \class SkPerlinNoiseShader
 
@@ -22,33 +27,27 @@
     The algorithm used is described here :
     http://www.w3.org/TR/SVG/filters.html#feTurbulenceElement
 */
-class SK_API SkPerlinNoiseShader {
-public:
-    /**
-     *  This will construct Perlin noise of the given type (Fractal Noise or Turbulence).
-     *
-     *  Both base frequencies (X and Y) have a usual range of (0..1) and must be non-negative.
-     *
-     *  The number of octaves provided should be fairly small, with a limit of 255 enforced.
-     *  Each octave doubles the frequency, so 10 octaves would produce noise from
-     *  baseFrequency * 1, * 2, * 4, ..., * 512, which quickly yields insignificantly small
-     *  periods and resembles regular unstructured noise rather than Perlin noise.
-     *
-     *  If tileSize isn't NULL or an empty size, the tileSize parameter will be used to modify
-     *  the frequencies so that the noise will be tileable for the given tile size. If tileSize
-     *  is NULL or an empty size, the frequencies will be used as is without modification.
-     */
-    static sk_sp<SkShader> MakeFractalNoise(SkScalar baseFrequencyX, SkScalar baseFrequencyY,
-                                            int numOctaves, SkScalar seed,
-                                            const SkISize* tileSize = nullptr);
-    static sk_sp<SkShader> MakeTurbulence(SkScalar baseFrequencyX, SkScalar baseFrequencyY,
-                                          int numOctaves, SkScalar seed,
-                                          const SkISize* tileSize = nullptr);
-
-    static void RegisterFlattenables();
-
-private:
-    SkPerlinNoiseShader() = delete;
-};
+namespace SkShaders {
+/**
+ *  This will construct Perlin noise of the given type (Fractal Noise or Turbulence).
+ *
+ *  Both base frequencies (X and Y) have a usual range of (0..1) and must be non-negative.
+ *
+ *  The number of octaves provided should be fairly small, with a limit of 255 enforced.
+ *  Each octave doubles the frequency, so 10 octaves would produce noise from
+ *  baseFrequency * 1, * 2, * 4, ..., * 512, which quickly yields insignificantly small
+ *  periods and resembles regular unstructured noise rather than Perlin noise.
+ *
+ *  If tileSize isn't NULL or an empty size, the tileSize parameter will be used to modify
+ *  the frequencies so that the noise will be tileable for the given tile size. If tileSize
+ *  is NULL or an empty size, the frequencies will be used as is without modification.
+ */
+SK_API sk_sp<SkShader> MakeFractalNoise(SkScalar baseFrequencyX, SkScalar baseFrequencyY,
+                                        int numOctaves, SkScalar seed,
+                                        const SkISize* tileSize = nullptr);
+SK_API sk_sp<SkShader> MakeTurbulence(SkScalar baseFrequencyX, SkScalar baseFrequencyY,
+                                      int numOctaves, SkScalar seed,
+                                      const SkISize* tileSize = nullptr);
+}  // namespace SkShaders
 
 #endif