xref: /aosp_15_r20/external/skia/modules/sksg/include/SkSGRenderEffect.h (revision c8dee2aa9b3f27cf6c858bd81872bdeb2c07ed17) 
1 /*
2  * Copyright 2019 Google Inc.
3  *
4  * Use of this source code is governed by a BSD-style license that can be
5  * found in the LICENSE file.
6  */
7 
8 #ifndef SkSGRenderEffect_DEFINED
9 #define SkSGRenderEffect_DEFINED
10 
11 #include "include/core/SkBlendMode.h"
12 #include "include/core/SkBlender.h"
13 #include "include/core/SkColor.h"
14 #include "include/core/SkImageFilter.h"
15 #include "include/core/SkPoint.h"
16 #include "include/core/SkRect.h"
17 #include "include/core/SkRefCnt.h"
18 #include "include/core/SkShader.h"
19 #include "include/core/SkTileMode.h"
20 #include "include/effects/SkImageFilters.h"
21 #include "include/private/base/SkAssert.h"
22 #include "modules/sksg/include/SkSGEffectNode.h"
23 #include "modules/sksg/include/SkSGNode.h"
24 
25 #include <optional>
26 
27 class SkCanvas;
28 class SkMatrix;
29 
30 // TODO: merge EffectNode.h with this header
31 
32 namespace sksg {
33 class InvalidationController;
34 class RenderNode;
35 
36 /**
37  * Shader base class.
38  */
39 class Shader : public Node {
40 public:
41     ~Shader() override;
42 
getShader()43     const sk_sp<SkShader>& getShader() const {
44         SkASSERT(!this->hasInval());
45         return fShader;
46     }
47 
48 protected:
49     Shader();
50 
51     SkRect onRevalidate(InvalidationController*, const SkMatrix&) final;
52 
53     virtual sk_sp<SkShader> onRevalidateShader() = 0;
54 
55 private:
56     sk_sp<SkShader> fShader;
57 
58     using INHERITED = Node;
59 };
60 
61 /**
62  * Attaches a shader to the render DAG.
63  */
64 class ShaderEffect final : public EffectNode {
65 public:
66     ~ShaderEffect() override;
67 
68     static sk_sp<ShaderEffect> Make(sk_sp<RenderNode> child, sk_sp<Shader> shader = nullptr);
69 
70     void setShader(sk_sp<Shader>);
71 
72 protected:
73     void onRender(SkCanvas*, const RenderContext*) const override;
74 
75     SkRect onRevalidate(InvalidationController*, const SkMatrix&) override;
76 
77 private:
78     ShaderEffect(sk_sp<RenderNode> child, sk_sp<Shader> shader);
79 
80     sk_sp<Shader> fShader;
81 
82     using INHERITED = EffectNode;
83 };
84 
85 /**
86  * Attaches a mask shader to the render DAG.
87  */
88 class MaskShaderEffect final : public EffectNode {
89 public:
90     static sk_sp<MaskShaderEffect> Make(sk_sp<RenderNode>, sk_sp<SkShader> = nullptr);
91 
92     SG_ATTRIBUTE(Shader, sk_sp<SkShader>, fShader)
93 
94 protected:
95     void onRender(SkCanvas*, const RenderContext*) const override;
96 
97 private:
98     MaskShaderEffect(sk_sp<RenderNode>, sk_sp<SkShader>);
99 
100     sk_sp<SkShader> fShader;
101 
102     using INHERITED = EffectNode;
103 };
104 
105 /**
106  * ImageFilter base class.
107  */
108 class ImageFilter : public Node {
109 public:
110     ~ImageFilter() override;
111 
getFilter()112     const sk_sp<SkImageFilter>& getFilter() const {
113         SkASSERT(!this->hasInval());
114         return fFilter;
115     }
116 
117     SG_ATTRIBUTE(CropRect, SkImageFilters::CropRect, fCropRect)
118 
119 protected:
120     ImageFilter();
121 
122     SkRect onRevalidate(InvalidationController*, const SkMatrix&) final;
123 
124     virtual sk_sp<SkImageFilter> onRevalidateFilter() = 0;
125 
126 private:
127     sk_sp<SkImageFilter>     fFilter;
128     SkImageFilters::CropRect fCropRect = std::nullopt;
129 
130     using INHERITED = Node;
131 };
132 
133 /**
134  * Attaches an ImageFilter (chain) to the render DAG.
135  */
136 class ImageFilterEffect final : public EffectNode {
137 public:
138     ~ImageFilterEffect() override;
139 
140     static sk_sp<RenderNode> Make(sk_sp<RenderNode> child, sk_sp<ImageFilter> filter);
141 
142     enum class Cropping {
143         kNone,    // Doesn't use a crop rect.
144         kContent, // Uses the content bounding box as a crop rect.
145     };
146 
147     SG_ATTRIBUTE(Cropping, Cropping, fCropping)
148 
149 protected:
150     void onRender(SkCanvas*, const RenderContext*) const override;
151     const RenderNode* onNodeAt(const SkPoint&)     const override;
152 
153     SkRect onRevalidate(InvalidationController*, const SkMatrix&) override;
154 
155 private:
156     ImageFilterEffect(sk_sp<RenderNode> child, sk_sp<ImageFilter> filter);
157 
158     sk_sp<ImageFilter> fImageFilter;
159     Cropping           fCropping = Cropping::kNone;
160 
161     using INHERITED = EffectNode;
162 };
163 
164 /**
165  * Wrapper for externally-managed SkImageFilters.
166  */
167 class ExternalImageFilter final : public ImageFilter {
168 public:
169     ~ExternalImageFilter() override;
170 
Make()171     static sk_sp<ExternalImageFilter> Make() {
172         return sk_sp<ExternalImageFilter>(new ExternalImageFilter());
173     }
174 
175     SG_ATTRIBUTE(ImageFilter, sk_sp<SkImageFilter>, fImageFilter)
176 
177 private:
178     ExternalImageFilter();
179 
onRevalidateFilter()180     sk_sp<SkImageFilter> onRevalidateFilter() override { return fImageFilter; }
181 
182     sk_sp<SkImageFilter> fImageFilter;
183 };
184 
185 /**
186  * SkDropShadowImageFilter node.
187  */
188 class DropShadowImageFilter final : public ImageFilter {
189 public:
190     ~DropShadowImageFilter() override;
191 
192     static sk_sp<DropShadowImageFilter> Make();
193 
194     enum class Mode { kShadowAndForeground, kShadowOnly };
195 
196     SG_ATTRIBUTE(Offset, SkVector, fOffset)
197     SG_ATTRIBUTE(Sigma , SkVector, fSigma )
198     SG_ATTRIBUTE(Color , SkColor , fColor )
199     SG_ATTRIBUTE(Mode  , Mode    , fMode  )
200 
201 protected:
202     sk_sp<SkImageFilter> onRevalidateFilter() override;
203 
204 private:
205     explicit DropShadowImageFilter();
206 
207     SkVector             fOffset = { 0, 0 },
208                          fSigma  = { 0, 0 };
209     SkColor              fColor  = SK_ColorBLACK;
210     Mode                 fMode   = Mode::kShadowAndForeground;
211 
212     using INHERITED = ImageFilter;
213 };
214 
215 /**
216  * SkBlurImageFilter node.
217  */
218 class BlurImageFilter final : public ImageFilter {
219 public:
220     ~BlurImageFilter() override;
221 
222     static sk_sp<BlurImageFilter> Make();
223 
224     SG_ATTRIBUTE(Sigma   , SkVector  , fSigma   )
225     SG_ATTRIBUTE(TileMode, SkTileMode, fTileMode)
226 
227 protected:
228     sk_sp<SkImageFilter> onRevalidateFilter() override;
229 
230 private:
231     explicit BlurImageFilter();
232 
233     SkVector   fSigma    = { 0, 0 };
234     SkTileMode fTileMode = SkTileMode::kDecal;
235 
236     using INHERITED = ImageFilter;
237 };
238 
239 /**
240  * Applies an SkBlender to descendant render nodes.
241  */
242 class BlenderEffect final : public EffectNode {
243 public:
244     ~BlenderEffect() override;
245 
246     static sk_sp<BlenderEffect> Make(sk_sp<RenderNode> child, sk_sp<SkBlender> = nullptr);
247 
248     SG_ATTRIBUTE(Blender, sk_sp<SkBlender>, fBlender)
249 
250 protected:
251     void onRender(SkCanvas*, const RenderContext*) const override;
252     const RenderNode* onNodeAt(const SkPoint&)     const override;
253 
254 private:
255     BlenderEffect(sk_sp<RenderNode>, sk_sp<SkBlender>);
256 
257     sk_sp<SkBlender> fBlender;
258 
259     using INHERITED = EffectNode;
260 };
261 
262 class LayerEffect final : public EffectNode {
263 public:
264     ~LayerEffect() override;
265 
266     static sk_sp<LayerEffect> Make(sk_sp<RenderNode> child,
267                                    SkBlendMode mode = SkBlendMode::kSrcOver);
268 
269     SG_ATTRIBUTE(Mode, SkBlendMode, fMode)
270 
271 private:
272     LayerEffect(sk_sp<RenderNode> child, SkBlendMode mode);
273 
274     void onRender(SkCanvas*, const RenderContext*) const override;
275 
276     SkBlendMode fMode;
277 
278     using INHERITED = EffectNode;
279 };
280 
281 } // namespace sksg
282 
283 #endif // SkSGRenderEffect_DEFINED
284