@shopify/react-native-skia 1.3.12 → 1.4.0

package/cpp/skia/include/gpu/graphite/precompile/PaintOptions.h

@@ -0,0 +1,197 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_precompile_PaintOptions_DEFINED
+#define skgpu_graphite_precompile_PaintOptions_DEFINED
+
+#include "include/core/SkBlendMode.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSpan.h"
+#include "include/private/base/SkTArray.h"
+#include "include/private/base/SkTDArray.h"
+
+#include <functional>
+
+namespace skgpu::graphite {
+
+class PrecompileBlender;
+class PrecompileColorFilter;
+class PrecompileImageFilter;
+class PrecompileMaskFilter;
+class PrecompileShader;
+
+enum class Coverage;
+enum DrawTypeFlags : uint16_t;
+enum class PrecompileImageFilterFlags : uint32_t;
+
+class KeyContext;
+class PaintOptionsPriv;
+class PaintParamsKeyBuilder;
+class PipelineDataGatherer;
+class UniquePaintParamsID;
+
+/** \class PaintOptions
+    This is the Precompilation analog to SkPaint. It encapsulates a set of options for each
+    field of the SkPaint (e.g., colorFilters, imageFilters, etc). Many of the specific details
+    of an SkPaint that are irrelevant to the final compiled Pipelines are abstracted away
+    (e.g., the SkPaint's color field).
+
+    How Precompilation works in practice is a PaintOptions object is created and a set of options
+    for each slot (e.g., shader, blender) are added. When passed to the Precompile() function,
+    all the combinations specified by the PaintOptions will be created and precompiled.
+
+    To be concrete, if a PaintOptions object had two shader options and two blender options,
+    four combinations would be precompiled.
+*/
+class SK_API PaintOptions {
+public:
+    /** Constructs a PaintOptions object with default values. It is equivalent to a default
+     *  initialized SkPaint.
+
+        @return  default initialized PaintOptions
+    */
+    PaintOptions();
+    PaintOptions(const PaintOptions&);
+    ~PaintOptions();
+    PaintOptions& operator=(const PaintOptions&);
+
+    /** Sets the shader options used when generating precompilation combinations.
+
+        This corresponds to SkPaint's setShader() method
+
+        @param shaders  The options used for shading when generating precompilation combinations.
+    */
+    void setShaders(SkSpan<const sk_sp<PrecompileShader>> shaders);
+    SkSpan<const sk_sp<PrecompileShader>> getShaders() const {
+        return SkSpan<const sk_sp<PrecompileShader>>(fShaderOptions);
+    }
+
+    /** Sets the image filter options used when generating precompilation combinations.
+
+        This corresponds to SkPaint's setImageFilter() method
+
+        @param imageFilters  The options used for image filtering when generating precompilation
+                             combinations.
+    */
+    void setImageFilters(SkSpan<const sk_sp<PrecompileImageFilter>> imageFilters);
+    SkSpan<const sk_sp<PrecompileImageFilter>> getImageFilters() const {
+        return SkSpan<const sk_sp<PrecompileImageFilter>>(fImageFilterOptions);
+    }
+
+    /** Sets the mask filter options used when generating precompilation combinations.
+
+        This corresponds to SkPaint's setMaskFilter() method
+
+        @param maskFilters  The options used for mask filtering when generating precompilation
+                            combinations.
+    */
+    void setMaskFilters(SkSpan<const sk_sp<PrecompileMaskFilter>> maskFilters);
+    SkSpan<const sk_sp<PrecompileMaskFilter>> getMaskFilters() const {
+        return SkSpan<const sk_sp<PrecompileMaskFilter>>(fMaskFilterOptions);
+    }
+
+    /** Sets the color filter options used when generating precompilation combinations.
+
+        This corresponds to SkPaint's setColorFilter() method
+
+        @param colorFilters  The options used for color filtering when generating precompilation
+                             combinations.
+    */
+    void setColorFilters(SkSpan<const sk_sp<PrecompileColorFilter>> colorFilters);
+    SkSpan<const sk_sp<PrecompileColorFilter>> getColorFilters() const {
+        return SkSpan<const sk_sp<PrecompileColorFilter>>(fColorFilterOptions);
+    }
+
+    /** Sets the blend mode options used when generating precompilation combinations.
+
+        This corresponds to SkPaint's setBlendMode() method
+
+        @param blendModes  The options used for blending when generating precompilation
+                           combinations.
+    */
+    void setBlendModes(SkSpan<const SkBlendMode> blendModes);
+    SkSpan<const SkBlendMode> getBlendModes() const {
+        return SkSpan<const SkBlendMode>(fBlendModeOptions.data(), fBlendModeOptions.size());
+    }
+
+    /** Sets the blender options used when generating precompilation combinations.
+
+        This corresponds to SkPaint's setBlender() method
+
+        @param blenders  The options used for blending when generating precompilation combinations.
+    */
+    void setBlenders(SkSpan<const sk_sp<PrecompileBlender>> blenders);
+    SkSpan<const sk_sp<PrecompileBlender>> getBlenders() const {
+        return SkSpan<const sk_sp<PrecompileBlender>>(fBlenderOptions);
+    }
+
+    /** Sets the dither setting used when generating precompilation combinations
+
+        This corresponds to SkPaint's setDither() method
+
+        @param dither  the dither setting used when generating precompilation combinations.
+    */
+    void setDither(bool dither) { fDither = dither; }
+    bool isDither() const { return fDither; }
+
+    // Provides access to functions that aren't part of the public API.
+    PaintOptionsPriv priv();
+    const PaintOptionsPriv priv() const;  // NOLINT(readability-const-return-type)
+
+private:
+    friend class PaintOptionsPriv;
+    friend class PrecompileImageFilter; // for ProcessCombination access
+    friend class PrecompileMaskFilter;  // for ProcessCombination access
+
+    void addColorFilter(sk_sp<PrecompileColorFilter> cf);
+    void addBlendMode(SkBlendMode bm) {
+        fBlendModeOptions.push_back(bm);
+    }
+
+    void setClipShaders(SkSpan<const sk_sp<PrecompileShader>> clipShaders);
+
+    int numShaderCombinations() const;
+    int numColorFilterCombinations() const;
+    int numBlendCombinations() const;
+    int numClipShaderCombinations() const;
+
+    int numCombinations() const;
+    // 'desiredCombination' must be less than the result of the numCombinations call
+    void createKey(const KeyContext&,
+                   PaintParamsKeyBuilder*,
+                   PipelineDataGatherer*,
+                   int desiredCombination,
+                   bool addPrimitiveBlender,
+                   Coverage coverage) const;
+
+    typedef std::function<void(UniquePaintParamsID id,
+                               DrawTypeFlags,
+                               bool withPrimitiveBlender,
+                               Coverage)> ProcessCombination;
+
+    void buildCombinations(const KeyContext&,
+                           PipelineDataGatherer*,
+                           DrawTypeFlags drawTypes,
+                           bool addPrimitiveBlender,
+                           Coverage coverage,
+                           const ProcessCombination& processCombination) const;
+
+    skia_private::TArray<sk_sp<PrecompileShader>> fShaderOptions;
+    skia_private::TArray<sk_sp<PrecompileColorFilter>> fColorFilterOptions;
+    skia_private::TArray<SkBlendMode> fBlendModeOptions;
+    skia_private::TArray<sk_sp<PrecompileBlender>> fBlenderOptions;
+    skia_private::TArray<sk_sp<PrecompileShader>> fClipShaderOptions;
+
+    skia_private::TArray<sk_sp<PrecompileImageFilter>> fImageFilterOptions;
+    skia_private::TArray<sk_sp<PrecompileMaskFilter>> fMaskFilterOptions;
+
+    bool fDither = false;
+};
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_precompile_PaintOptions_DEFINED

package/cpp/skia/include/gpu/graphite/precompile/Precompile.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_precompile_Precompile_DEFINED
+#define skgpu_graphite_precompile_Precompile_DEFINED
+
+#include "include/core/SkSpan.h"
+#include "include/gpu/graphite/GraphiteTypes.h"
+
+namespace skgpu::graphite {
+
+class Context;
+class PaintOptions;
+
+/**
+ *  Describes the required properties of a RenderPass that will be combined with the
+ *  other portions of the Precompilation API (i.e., paintOptions and drawTypes) to yield
+ *  a pipeline.
+ */
+struct SK_API RenderPassProperties {
+    DepthStencilFlags fDSFlags      = DepthStencilFlags::kNone;
+    SkColorType       fDstCT        = kRGBA_8888_SkColorType;
+    bool              fRequiresMSAA = false;
+};
+
+/**
+ * Precompilation allows clients to create pipelines ahead of time based on what they expect
+ * to draw. This can reduce performance hitches, due to inline compilation, during the actual
+ * drawing. Graphite will always be able to perform an inline compilation if some SkPaint
+ * combination was omitted from precompilation.
+ *
+ *   @param context              the Context to which the actual draws will be submitted
+ *   @param paintOptions         captures a set of SkPaints that will be drawn
+ *   @param drawTypes            communicates which primitives those paints will be drawn with
+ *   @param renderPassProperties describes the RenderPasses needed for the desired Pipelines
+ */
+void SK_API Precompile(Context* context,
+                       const PaintOptions& paintOptions,
+                       DrawTypeFlags drawTypes,
+                       SkSpan<const RenderPassProperties> renderPassProperties);
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_precompile_Precompile_DEFINED

package/cpp/skia/include/gpu/graphite/precompile/PrecompileBase.h

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_precompile_PrecompileBase_DEFINED
+#define skgpu_graphite_precompile_PrecompileBase_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSpan.h"
+
+namespace skgpu::graphite {
+
+class KeyContext;
+class PaintParamsKeyBuilder;
+class PipelineDataGatherer;
+class PrecompileBasePriv;
+
+/** \class PrecompileBase
+    This is the base class for all the objects that can be attached to PaintOptions.
+*/
+class SK_API PrecompileBase : public SkRefCnt {
+public:
+    enum class Type {
+        kBlender,
+        kColorFilter,
+        kImageFilter,
+        kMaskFilter,
+        kShader,
+    };
+
+    Type type() const { return fType; }
+
+    // Provides access to functions that aren't part of the public API.
+    PrecompileBasePriv priv();
+    const PrecompileBasePriv priv() const;  // NOLINT(readability-const-return-type)
+
+protected:
+    PrecompileBase(Type type) : fType(type) {}
+
+    virtual int numIntrinsicCombinations() const { return 1; }
+    virtual int numChildCombinations() const { return 1; }
+
+    /** This call returns the number of combinations generated from this object and its childen.
+
+        @return       number of precompilation combinations generated by this object
+    */
+    int numCombinations() const {
+        return this->numIntrinsicCombinations() * this->numChildCombinations();
+    }
+
+    virtual void addToKey(const KeyContext&,
+                          PaintParamsKeyBuilder*,
+                          PipelineDataGatherer*,
+                          int desiredCombination) const = 0;
+
+    // This returns the desired option along with the child options.
+    template<typename T>
+    static std::pair<sk_sp<T>, int> SelectOption(SkSpan<const sk_sp<T>> options,
+                                                 int desiredOption);
+
+    // In general, derived classes should use AddToKey to select the desired child option from
+    // a span and then have it added to the key with its reduced/nested child option.
+    template<typename T>
+    static void AddToKey(const KeyContext&,
+                         PaintParamsKeyBuilder*,
+                         PipelineDataGatherer*,
+                         SkSpan<const sk_sp<T>> options,
+                         int desiredOption);
+
+private:
+    friend class PrecompileBasePriv;
+
+    friend class PaintOptions;          // for access to SelectOption
+    friend class PrecompileBlenderList; // ""
+
+    Type fType;
+};
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_precompile_PrecompileBase_DEFINED

package/cpp/skia/include/gpu/graphite/precompile/PrecompileBlender.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_precompile_PrecompileBlender_DEFINED
+#define skgpu_graphite_precompile_PrecompileBlender_DEFINED
+
+#include "include/core/SkBlendMode.h"
+#include "include/gpu/graphite/precompile/PrecompileBase.h"
+
+#include <optional>
+
+namespace skgpu::graphite {
+
+class PrecompileBlenderPriv;
+
+/** \class PrecompileBlender
+    This class corresponds to the SkBlender class in the main API.
+*/
+class SK_API PrecompileBlender : public PrecompileBase {
+public:
+    // Provides access to functions that aren't part of the public API.
+    PrecompileBlenderPriv priv();
+    const PrecompileBlenderPriv priv() const;  // NOLINT(readability-const-return-type)
+
+protected:
+    friend class PrecompileBlenderPriv;
+
+    virtual std::optional<SkBlendMode> asBlendMode() const { return {}; }
+
+    PrecompileBlender() : PrecompileBase(Type::kBlender) {}
+    ~PrecompileBlender() override;
+};
+
+//--------------------------------------------------------------------------------------------------
+// This is the Precompile correlate to the SkBlenders namespace in the main API
+namespace PrecompileBlenders {
+
+    // This factory creates a Precompilation object that represents the Arithmetic SkBlender from
+    // the main API. Note that the actual Arithmetic parameters (i.e., k1, k2, k3 and k4) are
+    // abstracted away since they do not impact the generated shader.
+    SK_API sk_sp<PrecompileBlender> Arithmetic();
+
+    // This is the Precompilation correlate to the SkBlender::Mode factory in the main API. It
+    // creates an object that represents SkBlendMode-based blending.
+    SK_API sk_sp<PrecompileBlender> Mode(SkBlendMode);
+
+} // namespace PrecompileBlenders
+
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_precompile_PrecompileBlender_DEFINED

package/cpp/skia/include/gpu/graphite/precompile/PrecompileColorFilter.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_precompile_PrecompileColorFilter_DEFINED
+#define skgpu_graphite_precompile_PrecompileColorFilter_DEFINED
+
+#include "include/gpu/graphite/precompile/PrecompileBase.h"
+
+enum class SkBlendMode;
+
+namespace skgpu::graphite {
+
+/** \class PrecompileColorFilter
+    This class corresponds to the SkColorFilter class in the main API.
+*/
+class SK_API PrecompileColorFilter : public PrecompileBase {
+public:
+    /**
+     *  This is the Precompile correlate to SkColorFilter::makeComposed.
+     *
+     *  The PrecompileColorFilters::Compose factory can be used to generate a set of color filters
+     *  that would've been generated via multiple makeComposed calls. That is, rather than
+     *  performing:
+     *     sk_sp<PrecompileColorFilter> option1 = outer->makeComposed(colorFilter1);
+     *     sk_sp<PrecompileColorFilter> option2 = outer->makeComposed(colorFilter2);
+     *  one could call:
+     *     sk_sp<PrecompileColorFilter> combinedOptions = Compose({ outer },
+     *                                                            { colorFilter1, colorFilter2 });
+     *  With an alternative use case one could also use the Compose factory thusly:
+     *     sk_sp<PrecompileColorFilter> combinedOptions = Compose({ outer1, outer2 },
+     *                                                            { innerColorFilter });
+     */
+    sk_sp<PrecompileColorFilter> makeComposed(sk_sp<PrecompileColorFilter> inner) const;
+
+protected:
+    PrecompileColorFilter() : PrecompileBase(Type::kColorFilter) {}
+    ~PrecompileColorFilter() override;
+};
+
+//--------------------------------------------------------------------------------------------------
+// This is the Precompile correlate to the SkColorFilters namespace in the main API
+namespace PrecompileColorFilters {
+
+    // --- The next 9 entries match those in include/core/SkColorFilter.h
+    SK_API sk_sp<PrecompileColorFilter> Compose(SkSpan<const sk_sp<PrecompileColorFilter>> outer,
+                                                SkSpan<const sk_sp<PrecompileColorFilter>> inner);
+
+    // This encompasses both variants of SkColorFilters::Blend
+    SK_API sk_sp<PrecompileColorFilter> Blend(SkSpan<const SkBlendMode> blendModes);
+    SK_API sk_sp<PrecompileColorFilter> Blend(); // Prefer the explicit blend mode variant
+
+    // This encompasses both variants of SkColorFilters::Matrix
+    SK_API sk_sp<PrecompileColorFilter> Matrix();
+
+    // This encompasses both variants of SkColorFilters::HSLAMatrix
+    SK_API sk_sp<PrecompileColorFilter> HSLAMatrix();
+
+    SK_API sk_sp<PrecompileColorFilter> LinearToSRGBGamma();
+    SK_API sk_sp<PrecompileColorFilter> SRGBToLinearGamma();
+    SK_API sk_sp<PrecompileColorFilter> Lerp(SkSpan<const sk_sp<PrecompileColorFilter>> dstOptions,
+                                             SkSpan<const sk_sp<PrecompileColorFilter>> srcOptions);
+
+    // This encompases both the SkColorFilters::Table and TableARGB variants
+    SK_API sk_sp<PrecompileColorFilter> Table();
+
+    SK_API sk_sp<PrecompileColorFilter> Lighting();
+
+    // This matches the main API's factory in include/effects/SkHighContrastFilter.h
+    SK_API sk_sp<PrecompileColorFilter> HighContrast();
+
+    // This matches the main API's factory in include/effects/SkLumaColorFilter.h
+    SK_API sk_sp<PrecompileColorFilter> Luma();
+
+    // This matches the main API's factory in include/effects/SkOverdrawColorFilter.h
+    SK_API sk_sp<PrecompileColorFilter> Overdraw();
+
+} // namespace PrecompileColorFilters
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_precompile_PrecompileColorFilter_DEFINED

package/cpp/skia/include/gpu/graphite/precompile/PrecompileImageFilter.h

@@ -0,0 +1,119 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_precompile_PrecompileImageFilter_DEFINED
+#define skgpu_graphite_precompile_PrecompileImageFilter_DEFINED
+
+#include "include/gpu/graphite/precompile/PrecompileBase.h"
+
+#include "include/core/SkBlendMode.h"
+#include "include/gpu/graphite/precompile/PaintOptions.h"
+#include "include/private/base/SkTemplates.h"
+
+namespace skgpu::graphite {
+
+class PrecompileBlender;
+class PrecompileColorFilter;
+class PrecompileImageFilterPriv;
+
+/** \class PrecompileImageFilter
+    This class corresponds to the SkImageFilter class in the main API.
+*/
+class SK_API PrecompileImageFilter : public PrecompileBase {
+public:
+    ~PrecompileImageFilter() override;
+
+    // Provides access to functions that aren't part of the public API.
+    PrecompileImageFilterPriv priv();
+    const PrecompileImageFilterPriv priv() const;  // NOLINT(readability-const-return-type)
+
+protected:
+    PrecompileImageFilter(SkSpan<sk_sp<PrecompileImageFilter>> inputs);
+
+private:
+    friend class PaintOptions;  // for createPipelines() access
+    friend class PrecompileImageFilterPriv;
+
+    int countInputs() const { return fInputs.count(); }
+
+    const PrecompileImageFilter* getInput(int index) const {
+        SkASSERT(index < this->countInputs());
+        return fInputs[index].get();
+    }
+
+    virtual sk_sp<PrecompileColorFilter> isColorFilterNode() const { return nullptr; }
+
+    sk_sp<PrecompileColorFilter> asAColorFilter() const;
+
+    // The PrecompileImageFilter classes do not use the PrecompileBase::addToKey virtual since
+    // they, in general, do not themselves contribute to a given SkPaint/Pipeline but, rather,
+    // create separate SkPaints/Pipelines from whole cloth (in onCreatePipelines).
+    void addToKey(const KeyContext& /* keyContext */,
+                  PaintParamsKeyBuilder* /* builder */,
+                  PipelineDataGatherer* /* gatherer */,
+                  int /* desiredCombination */) const final {
+        SkASSERT(false);
+    }
+
+    virtual void onCreatePipelines(const KeyContext&,
+                                   PipelineDataGatherer*,
+                                   const PaintOptions::ProcessCombination&) const = 0;
+
+    void createPipelines(const KeyContext&,
+                         PipelineDataGatherer*,
+                         const PaintOptions::ProcessCombination&);
+
+    skia_private::AutoSTArray<2, sk_sp<PrecompileImageFilter>> fInputs;
+};
+
+//--------------------------------------------------------------------------------------------------
+// This is the Precompile correlate to the SkImageFilters class' factories in the main API
+//
+// Note: In order to make precompilation analysis more tractable we don't allow options for the
+// internals of an PrecompileImageFilter nor in the structure of the DAG.
+namespace PrecompileImageFilters {
+
+    // This is the Precompile correlate to SkImageFilters::Arithmetic
+    SK_API sk_sp<PrecompileImageFilter> Arithmetic(sk_sp<PrecompileImageFilter> background,
+                                                   sk_sp<PrecompileImageFilter> foreground);
+
+    // This is the Precompile correlate to SkImageFilters::Blend(SkBlendMode, ...)
+    SK_API sk_sp<PrecompileImageFilter> Blend(SkBlendMode bm,
+                                              sk_sp<PrecompileImageFilter> background,
+                                              sk_sp<PrecompileImageFilter> foreground);
+
+    // This is the Precompile correlate to SkImageFilters::Blend(sk_sp<SkBlender>, ...)
+    SK_API sk_sp<PrecompileImageFilter> Blend(sk_sp<PrecompileBlender> blender,
+                                              sk_sp<PrecompileImageFilter> background,
+                                              sk_sp<PrecompileImageFilter> foreground);
+
+    // This is the Precompile correlate to the two SkImageFilters::Blur factories
+    SK_API sk_sp<PrecompileImageFilter> Blur(sk_sp<PrecompileImageFilter> input);
+
+    // This is the Precompile correlate to SkImageFilters::ColorFilter.
+    SK_API sk_sp<PrecompileImageFilter> ColorFilter(sk_sp<PrecompileColorFilter> colorFilter,
+                                                    sk_sp<PrecompileImageFilter> input);
+
+    // This is the Precompile correlate to SkImageFilters::DisplacementMap
+    SK_API sk_sp<PrecompileImageFilter> DisplacementMap(sk_sp<PrecompileImageFilter> input);
+
+    // This is the Precompile correlate to all of SkImageFilters::
+    //      DistantLitDiffuse,  PointLitDiffuse,  SpotLitDiffuse
+    //      DistantLitSpecular, PointLitSpecular, SpotLitSpecular
+    SK_API sk_sp<PrecompileImageFilter> Lighting(sk_sp<PrecompileImageFilter> input);
+
+    // This is the Precompile correlate to SkImageFilters::MatrixConvolution
+    SK_API sk_sp<PrecompileImageFilter> MatrixConvolution(sk_sp<PrecompileImageFilter> input);
+
+    // This is the Precompile correlate to SkImageFilters::Erode and SkImageFilters::Dilate
+    SK_API sk_sp<PrecompileImageFilter> Morphology(sk_sp<PrecompileImageFilter> input);
+
+} // namespace PrecompileImageFilters
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_precompile_PrecompileImageFilter_DEFINED

package/cpp/skia/include/gpu/graphite/precompile/PrecompileMaskFilter.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_precompile_PrecompileMaskFilter_DEFINED
+#define skgpu_graphite_precompile_PrecompileMaskFilter_DEFINED
+
+#include "include/gpu/graphite/precompile/PrecompileBase.h"
+
+#include "include/gpu/graphite/precompile/PaintOptions.h"
+
+namespace skgpu::graphite {
+
+/** \class PrecompileMaskFilter
+    This class corresponds to the SkMaskFilter class in the main API.
+*/
+class SK_API PrecompileMaskFilter : public PrecompileBase {
+protected:
+    friend class PaintOptions;  // for createPipelines() access
+
+    PrecompileMaskFilter() : PrecompileBase(Type::kMaskFilter) {}
+    ~PrecompileMaskFilter() override;
+
+    void addToKey(const KeyContext&,
+                  PaintParamsKeyBuilder*,
+                  PipelineDataGatherer*,
+                  int desiredCombination) const final;
+
+    virtual void createPipelines(const KeyContext&,
+                                 PipelineDataGatherer*,
+                                 const PaintOptions::ProcessCombination&) const = 0;
+};
+
+//--------------------------------------------------------------------------------------------------
+// This is the Precompile correlate to the SkMaskFilter class' factories in the main API
+namespace PrecompileMaskFilters {
+
+    // This corresponds to the SkMaskFilter::MakeBlur factory in the main Skia API.
+    // The specific details of the blur have been elided since they don't impact the generated
+    // shader.
+    SK_API sk_sp<PrecompileMaskFilter> Blur();
+
+} // namespace PrecompileMaskFilters
+
+} // namespace skgpu::graphite
+
+
+#endif // skgpu_graphite_precompile_PrecompileMaskFilter_DEFINED