1 /*
2 * Copyright 2017 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 #include "modules/sksg/include/SkSGRenderNode.h"
9
10 #include "include/core/SkBlendMode.h"
11 #include "include/core/SkCanvas.h"
12 #include "include/core/SkColor.h"
13 #include "include/core/SkImageFilter.h"
14 #include "include/core/SkPaint.h"
15 #include "include/core/SkPoint.h"
16 #include "include/core/SkRect.h"
17 #include "include/private/base/SkAssert.h"
18 #include "include/private/base/SkFloatingPoint.h"
19 #include "include/private/base/SkTo.h"
20 #include "modules/sksg/src/SkSGNodePriv.h"
21
22 namespace sksg {
23
24 namespace {
25
26 enum Flags : uint8_t {
27 kInvisible_Flag = 1 << 0,
28 };
29
30 } // namespace
31
RenderNode(uint32_t inval_traits)32 RenderNode::RenderNode(uint32_t inval_traits) : INHERITED(inval_traits) {}
33
isVisible() const34 bool RenderNode::isVisible() const {
35 return !(fNodeFlags & kInvisible_Flag);
36 }
37
setVisible(bool v)38 void RenderNode::setVisible(bool v) {
39 if (v == this->isVisible()) {
40 return;
41 }
42
43 this->invalidate();
44 fNodeFlags = v ? (fNodeFlags & ~kInvisible_Flag)
45 : (fNodeFlags | kInvisible_Flag);
46 }
47
render(SkCanvas * canvas,const RenderContext * ctx) const48 void RenderNode::render(SkCanvas* canvas, const RenderContext* ctx) const {
49 SkASSERT(!this->hasInval());
50 if (this->isVisible() && !this->bounds().isEmpty()) {
51 this->onRender(canvas, ctx);
52 }
53 SkASSERT(!this->hasInval());
54 }
55
nodeAt(const SkPoint & p) const56 const RenderNode* RenderNode::nodeAt(const SkPoint& p) const {
57 return this->bounds().contains(p.x(), p.y()) ? this->onNodeAt(p) : nullptr;
58 }
59
ScaleAlpha(SkAlpha alpha,float opacity)60 static SkAlpha ScaleAlpha(SkAlpha alpha, float opacity) {
61 return SkToU8(sk_float_round2int(alpha * opacity));
62 }
63
LocalShader(const sk_sp<SkShader> & shader,const SkMatrix & base,const SkMatrix & ctm)64 static sk_sp<SkShader> LocalShader(const sk_sp<SkShader>& shader,
65 const SkMatrix& base,
66 const SkMatrix& ctm) {
67 // Mask filters / shaders are declared to operate under a specific transform, but due to the
68 // deferral mechanism, other transformations might have been pushed to the state.
69 // We want to undo these transforms (T):
70 //
71 // baseCTM x T = ctm
72 //
73 // => T = Inv(baseCTM) x ctm
74 //
75 // => Inv(T) = Inv(Inv(baseCTM) x ctm)
76 //
77 // => Inv(T) = Inv(ctm) x baseCTM
78
79 SkMatrix lm;
80 if (base != ctm && ctm.invert(&lm)) {
81 lm.preConcat(base);
82 } else {
83 lm = SkMatrix::I();
84 }
85
86 // Note: this doesn't play ball with existing shader local matrices (what we really want is
87 // SkShader::makeWithPostLocalMatrix). Probably a good signal that the whole mechanism is
88 // contrived and should be redesigned (use SkCanvas::clipShader when available, drop shader
89 // "effects" completely, etc).
90 return shader->makeWithLocalMatrix(lm);
91 }
92
requiresIsolation() const93 bool RenderNode::RenderContext::requiresIsolation() const {
94 // Note: fShader is never applied on isolation layers.
95 return ScaleAlpha(SK_AlphaOPAQUE, fOpacity) != SK_AlphaOPAQUE
96 || fColorFilter
97 || fMaskShader
98 || fBlender;
99 }
100
modulatePaint(const SkMatrix & ctm,SkPaint * paint,bool is_layer_paint) const101 void RenderNode::RenderContext::modulatePaint(const SkMatrix& ctm, SkPaint* paint,
102 bool is_layer_paint) const {
103 paint->setAlpha(ScaleAlpha(paint->getAlpha(), fOpacity));
104 paint->setColorFilter(SkColorFilters::Compose(fColorFilter, paint->refColorFilter()));
105 if (fShader) {
106 paint->setShader(LocalShader(fShader, fShaderCTM, ctm));
107 }
108 if (fBlender) {
109 paint->setBlender(fBlender);
110 }
111
112 // Only apply the shader mask for regular paints. Isolation layers require
113 // special handling on restore.
114 if (!is_layer_paint && fMaskShader) {
115 paint->setShader(SkShaders::Blend(SkBlendMode::kSrcIn,
116 LocalShader(fMaskShader, fMaskCTM, ctm),
117 paint->refShader()));
118 }
119 }
120
ScopedRenderContext(SkCanvas * canvas,const RenderContext * ctx)121 RenderNode::ScopedRenderContext::ScopedRenderContext(SkCanvas* canvas, const RenderContext* ctx)
122 : fCanvas(canvas)
123 , fCtx(ctx ? *ctx : RenderContext())
124 , fRestoreCount(canvas->getSaveCount()) {}
125
~ScopedRenderContext()126 RenderNode::ScopedRenderContext::~ScopedRenderContext() {
127 if (fRestoreCount >= 0) {
128 if (fMaskShader) {
129 SkPaint mask_paint;
130 mask_paint.setBlendMode(SkBlendMode::kDstIn);
131 mask_paint.setShader(std::move(fMaskShader));
132 fCanvas->drawPaint(mask_paint);
133 }
134 fCanvas->restoreToCount(fRestoreCount);
135 }
136 }
137
138 RenderNode::ScopedRenderContext&&
modulateOpacity(float opacity)139 RenderNode::ScopedRenderContext::modulateOpacity(float opacity) {
140 SkASSERT(opacity >= 0 && opacity <= 1);
141 fCtx.fOpacity *= opacity;
142 return std::move(*this);
143 }
144
145 RenderNode::ScopedRenderContext&&
modulateColorFilter(sk_sp<SkColorFilter> cf)146 RenderNode::ScopedRenderContext::modulateColorFilter(sk_sp<SkColorFilter> cf) {
147 fCtx.fColorFilter = SkColorFilters::Compose(std::move(fCtx.fColorFilter), std::move(cf));
148 return std::move(*this);
149 }
150
151 RenderNode::ScopedRenderContext&&
modulateShader(sk_sp<SkShader> sh,const SkMatrix & shader_ctm)152 RenderNode::ScopedRenderContext::modulateShader(sk_sp<SkShader> sh, const SkMatrix& shader_ctm) {
153 // Topmost shader takes precedence.
154 if (!fCtx.fShader) {
155 fCtx.fShader = std::move(sh);
156 fCtx.fShaderCTM = shader_ctm;
157 }
158
159 return std::move(*this);
160 }
161
162 RenderNode::ScopedRenderContext&&
modulateMaskShader(sk_sp<SkShader> ms,const SkMatrix & ctm)163 RenderNode::ScopedRenderContext::modulateMaskShader(sk_sp<SkShader> ms, const SkMatrix& ctm) {
164 if (fCtx.fMaskShader) {
165 // As we compose mask filters, use the relative transform T for the inner mask:
166 //
167 // maskCTM x T = ctm
168 //
169 // => T = Inv(maskCTM) x ctm
170 //
171 SkMatrix invMaskCTM;
172 if (ms && fCtx.fMaskCTM.invert(&invMaskCTM)) {
173 const auto relative_transform = SkMatrix::Concat(invMaskCTM, ctm);
174 fCtx.fMaskShader = SkShaders::Blend(SkBlendMode::kSrcIn,
175 std::move(fCtx.fMaskShader),
176 ms->makeWithLocalMatrix(relative_transform));
177 }
178 } else {
179 fCtx.fMaskShader = std::move(ms);
180 fCtx.fMaskCTM = ctm;
181 }
182
183 return std::move(*this);
184 }
185
186 RenderNode::ScopedRenderContext&&
modulateBlender(sk_sp<SkBlender> blender)187 RenderNode::ScopedRenderContext::modulateBlender(sk_sp<SkBlender> blender) {
188 fCtx.fBlender = std::move(blender);
189 return std::move(*this);
190 }
191
192 RenderNode::ScopedRenderContext&&
setIsolation(const SkRect & bounds,const SkMatrix & ctm,bool isolation)193 RenderNode::ScopedRenderContext::setIsolation(const SkRect& bounds, const SkMatrix& ctm,
194 bool isolation) {
195 if (isolation && fCtx.requiresIsolation()) {
196 SkPaint layer_paint;
197 fCtx.modulatePaint(ctm, &layer_paint, /*is_layer_paint = */true);
198 fCanvas->saveLayer(bounds, &layer_paint);
199
200 // Fetch the mask shader for restore.
201 if (fCtx.fMaskShader) {
202 fMaskShader = LocalShader(fCtx.fMaskShader, fCtx.fMaskCTM, ctm);
203 }
204
205 // Reset only the props applied via isolation layers.
206 fCtx.fColorFilter = nullptr;
207 fCtx.fMaskShader = nullptr;
208 fCtx.fBlender = nullptr;
209 fCtx.fOpacity = 1;
210 }
211
212 return std::move(*this);
213 }
214
215 RenderNode::ScopedRenderContext&&
setFilterIsolation(const SkRect & bounds,const SkMatrix & ctm,sk_sp<SkImageFilter> filter)216 RenderNode::ScopedRenderContext::setFilterIsolation(const SkRect& bounds, const SkMatrix& ctm,
217 sk_sp<SkImageFilter> filter) {
218 if (filter) {
219 SkPaint layer_paint;
220 fCtx.modulatePaint(ctm, &layer_paint);
221
222 SkASSERT(!layer_paint.getImageFilter());
223 layer_paint.setImageFilter(std::move(filter));
224 fCanvas->saveLayer(bounds, &layer_paint);
225 fCtx = RenderContext();
226 }
227
228 return std::move(*this);
229 }
230
CustomRenderNode(std::vector<sk_sp<RenderNode>> && children)231 CustomRenderNode::CustomRenderNode(std::vector<sk_sp<RenderNode>>&& children)
232 : INHERITED(kOverrideDamage_Trait) // We cannot make any assumptions - override conservatively.
233 , fChildren(std::move(children)) {
234 for (const auto& child : fChildren) {
235 this->observeInval(child);
236 }
237 }
238
~CustomRenderNode()239 CustomRenderNode::~CustomRenderNode() {
240 for (const auto& child : fChildren) {
241 this->unobserveInval(child);
242 }
243 }
244
hasChildrenInval() const245 bool CustomRenderNode::hasChildrenInval() const {
246 for (const auto& child : fChildren) {
247 if (NodePriv::HasInval(child)) {
248 return true;
249 }
250 }
251
252 return false;
253 }
254
255 } // namespace sksg
256