rngine 0.7.2 → 0.8.1

package/shared/skia/include/gpu/graphite/mtl/MtlGraphiteTypes_cpp.h

@@ -0,0 +1,50 @@
+/*
+ * 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_MtlGraphiteTypesUtils_DEFINED
+#define skgpu_graphite_MtlGraphiteTypesUtils_DEFINED
+
+#include "include/core/SkTypes.h"
+
+#include "include/gpu/graphite/BackendTexture.h"
+#include "include/gpu/graphite/TextureInfo.h"
+#include "include/private/SkAPI.h"
+
+#import <CoreFoundation/CoreFoundation.h>
+
+namespace skgpu::graphite {
+
+// MtlTextureInfo requires compiling with Objective-C, so this header is split to allow invoking
+// the various backend wrapping APIs from a C++-only compilation unit.
+class SK_API MtlTextureInfo;
+
+namespace TextureInfos {
+SK_API TextureInfo MakeMetal(const MtlTextureInfo&);
+SK_API TextureInfo MakeMetal(CFTypeRef mtlTexture);
+
+SK_API bool GetMtlTextureInfo(const TextureInfo&, MtlTextureInfo*);
+}  // namespace TextureInfos
+
+namespace BackendTextures {
+// The BackendTexture will not call retain or release on the passed in CFTypeRef. Thus the
+// client must keep the CFTypeRef valid until they are no longer using the BackendTexture.
+SK_API BackendTexture MakeMetal(SkISize dimensions, CFTypeRef mtlTexture);
+
+SK_API CFTypeRef GetMtlTexture(const BackendTexture&);
+}  // namespace BackendTextures
+
+namespace BackendSemaphores {
+// TODO(b/286088355) Determine creator's responsibility for setting refcnt.
+SK_API BackendSemaphore MakeMetal(CFTypeRef mtlEvent, uint64_t value);
+
+SK_API CFTypeRef GetMtlEvent(const BackendSemaphore&);
+SK_API uint64_t GetMtlValue(const BackendSemaphore&);
+}  // namespace BackendSemaphores
+
+}  // namespace skgpu::graphite
+
+#endif  // skgpu_graphite_MtlGraphiteTypesUtils_DEFINED

package/shared/skia/include/gpu/graphite/mtl/MtlGraphiteUtils.h

@@ -0,0 +1,9 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// DEPRECRATED: MtlGraphiteUtils.h will be removed in the future, please include MtlBackendContext.h
+#include "include/gpu/graphite/mtl/MtlBackendContext.h"

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

@@ -0,0 +1,211 @@
+/*
+ * 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/SkTArray.h"
+#include "include/private/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;
+enum class TextureFormat : uint8_t;
+
+class KeyContext;
+class PaintOptionsPriv;
+class PaintParamsKeyBuilder;
+struct RenderPassDesc;
+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());
+    }
+    void addBlendMode(SkBlendMode bm) {
+        fBlendModeOptions.push_back(bm);
+    }
+
+    /** 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; }
+
+    void setPaintColorIsOpaque(bool paintColorIsOpaque) {
+        fPaintColorIsOpaque = paintColorIsOpaque;
+    }
+    bool isPaintColorOpaque() const { return fPaintColorIsOpaque; }
+
+    // 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 setClipShaders(SkSpan<const sk_sp<PrecompileShader>> clipShaders);
+
+    // In the main API this is specified via the SkBlender parameter to drawVertices
+    void setPrimitiveBlendMode(SkBlendMode bm) { fPrimitiveBlendMode = bm; }
+    void setSkipColorXform(bool skipColorXform) { fSkipColorXform = skipColorXform; }
+
+    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&,
+                   TextureFormat,
+                   int desiredCombination,
+                   bool addPrimitiveBlender,
+                   bool addAnalyticClip,
+                   Coverage coverage) const;
+
+    typedef std::function<void(UniquePaintParamsID id,
+                               DrawTypeFlags,
+                               bool withPrimitiveBlender,
+                               Coverage,
+                               const RenderPassDesc&)> ProcessCombination;
+
+    void buildCombinations(const KeyContext&,
+                           DrawTypeFlags,
+                           bool addPrimitiveBlender,
+                           Coverage,
+                           const RenderPassDesc&,
+                           const 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;
+
+    SkBlendMode fPrimitiveBlendMode = SkBlendMode::kSrcOver;
+    bool fSkipColorXform = false;
+    bool fDither = false;
+    bool fPaintColorIsOpaque = true;
+};
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_precompile_PaintOptions_DEFINED

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

@@ -0,0 +1,59 @@
+/*
+ * 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/SkColorSpace.h"
+#include "include/core/SkColorType.h"
+#include "include/core/SkSpan.h"
+#include "include/gpu/graphite/GraphiteTypes.h"
+
+namespace skgpu::graphite {
+
+class PaintOptions;
+class PrecompileContext;
+
+/**
+ *  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 {
+    bool operator==(const RenderPassProperties& other) const {
+        return fDSFlags == other.fDSFlags &&
+               fDstCT == other.fDstCT &&
+               fRequiresMSAA == other.fRequiresMSAA &&
+               SkColorSpace::Equals(fDstCS.get(), other.fDstCS.get());
+    }
+    bool operator!= (const RenderPassProperties& other) const { return !(*this == other); }
+
+    DepthStencilFlags   fDSFlags      = DepthStencilFlags::kNone;
+    SkColorType         fDstCT        = kRGBA_8888_SkColorType;
+    sk_sp<SkColorSpace> fDstCS        = nullptr;
+    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 precompileContext    thread-safe helper holding required portions of the Context
+ *   @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(PrecompileContext* precompileContext,
+                       const PaintOptions& paintOptions,
+                       DrawTypeFlags drawTypes,
+                       SkSpan<const RenderPassProperties> renderPassProperties);
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_precompile_Precompile_DEFINED

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

@@ -0,0 +1,76 @@
+/*
+ * 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 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&, 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&, 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/shared/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/shared/skia/include/gpu/graphite/precompile/PrecompileColorFilter.h

@@ -0,0 +1,95 @@
+/*
+ * 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 PrecompileColorFilterPriv;
+
+/** \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;
+
+    // Provides access to functions that aren't part of the public API.
+    PrecompileColorFilterPriv priv();
+    const PrecompileColorFilterPriv priv() const;  // NOLINT(readability-const-return-type)
+
+protected:
+    friend class PrecompileColorFilterPriv;
+
+    PrecompileColorFilter() : PrecompileBase(Type::kColorFilter) {}
+    ~PrecompileColorFilter() override;
+
+    virtual bool isAlphaUnchanged(int /*desiredCombination*/) const = 0;
+};
+
+//--------------------------------------------------------------------------------------------------
+// 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(bool clamp=true);
+
+    // 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/shared/skia/include/gpu/graphite/precompile/PrecompileImageFilter.h

@@ -0,0 +1,116 @@
+/*
+ * 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/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 */, int /* desiredCombination */) const final {
+        SkASSERT(false);
+    }
+
+    virtual void onCreatePipelines(const KeyContext&,
+                                   const RenderPassDesc&,
+                                   const PaintOptions::ProcessCombination&) const = 0;
+
+    void createPipelines(const KeyContext&,
+                         const RenderPassDesc&,
+                         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