1 /*
2 * Copyright 2014 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 "src/gpu/ganesh/effects/GrRRectEffect.h"
9
10 #include "src/base/SkTLazy.h"
11 #include "src/core/SkRRectPriv.h"
12 #include "src/gpu/KeyBuilder.h"
13 #include "src/gpu/ganesh/GrFragmentProcessor.h"
14 #include "src/gpu/ganesh/GrProcessorUnitTest.h"
15 #include "src/gpu/ganesh/GrShaderCaps.h"
16 #include "src/gpu/ganesh/effects/GrConvexPolyEffect.h"
17 #include "src/gpu/ganesh/effects/GrOvalEffect.h"
18 #include "src/gpu/ganesh/glsl/GrGLSLFragmentShaderBuilder.h"
19 #include "src/gpu/ganesh/glsl/GrGLSLProgramDataManager.h"
20 #include "src/gpu/ganesh/glsl/GrGLSLUniformHandler.h"
21
22 // The effects defined here only handle rrect radii >= kRadiusMin.
23 static const SkScalar kRadiusMin = SK_ScalarHalf;
24
25 //////////////////////////////////////////////////////////////////////////////
26
27 namespace {
28 class CircularRRectEffect : public GrFragmentProcessor {
29 public:
30 enum CornerFlags {
31 kTopLeft_CornerFlag = (1 << SkRRect::kUpperLeft_Corner),
32 kTopRight_CornerFlag = (1 << SkRRect::kUpperRight_Corner),
33 kBottomRight_CornerFlag = (1 << SkRRect::kLowerRight_Corner),
34 kBottomLeft_CornerFlag = (1 << SkRRect::kLowerLeft_Corner),
35
36 kLeft_CornerFlags = kTopLeft_CornerFlag | kBottomLeft_CornerFlag,
37 kTop_CornerFlags = kTopLeft_CornerFlag | kTopRight_CornerFlag,
38 kRight_CornerFlags = kTopRight_CornerFlag | kBottomRight_CornerFlag,
39 kBottom_CornerFlags = kBottomLeft_CornerFlag | kBottomRight_CornerFlag,
40
41 kAll_CornerFlags = kTopLeft_CornerFlag | kTopRight_CornerFlag |
42 kBottomLeft_CornerFlag | kBottomRight_CornerFlag,
43
44 kNone_CornerFlags = 0
45 };
46
47 // The flags are used to indicate which corners are circluar (unflagged corners are assumed to
48 // be square).
49 static GrFPResult Make(std::unique_ptr<GrFragmentProcessor>, GrClipEdgeType,
50 uint32_t circularCornerFlags, const SkRRect&);
51
~CircularRRectEffect()52 ~CircularRRectEffect() override {}
53
name() const54 const char* name() const override { return "CircularRRect"; }
55
56 std::unique_ptr<GrFragmentProcessor> clone() const override;
57
58 private:
59 class Impl;
60
61 CircularRRectEffect(std::unique_ptr<GrFragmentProcessor> inputFP,
62 GrClipEdgeType, uint32_t circularCornerFlags, const SkRRect&);
63 CircularRRectEffect(const CircularRRectEffect& that);
64
65 std::unique_ptr<ProgramImpl> onMakeProgramImpl() const override;
66
67 void onAddToKey(const GrShaderCaps&, skgpu::KeyBuilder*) const override;
68
69 bool onIsEqual(const GrFragmentProcessor& other) const override;
70
71 SkRRect fRRect;
72 GrClipEdgeType fEdgeType;
73 uint32_t fCircularCornerFlags;
74
75 GR_DECLARE_FRAGMENT_PROCESSOR_TEST
76
77 using INHERITED = GrFragmentProcessor;
78 };
79 } // anonymous namespace
80
Make(std::unique_ptr<GrFragmentProcessor> inputFP,GrClipEdgeType edgeType,uint32_t circularCornerFlags,const SkRRect & rrect)81 GrFPResult CircularRRectEffect::Make(std::unique_ptr<GrFragmentProcessor> inputFP,
82 GrClipEdgeType edgeType,
83 uint32_t circularCornerFlags, const SkRRect& rrect) {
84 if (GrClipEdgeType::kFillAA != edgeType && GrClipEdgeType::kInverseFillAA != edgeType) {
85 return GrFPFailure(std::move(inputFP));
86 }
87 return GrFPSuccess(std::unique_ptr<GrFragmentProcessor>(
88 new CircularRRectEffect(std::move(inputFP), edgeType, circularCornerFlags, rrect)));
89 }
90
CircularRRectEffect(std::unique_ptr<GrFragmentProcessor> inputFP,GrClipEdgeType edgeType,uint32_t circularCornerFlags,const SkRRect & rrect)91 CircularRRectEffect::CircularRRectEffect(std::unique_ptr<GrFragmentProcessor> inputFP,
92 GrClipEdgeType edgeType,
93 uint32_t circularCornerFlags,
94 const SkRRect& rrect)
95 : INHERITED(kCircularRRectEffect_ClassID,
96 ProcessorOptimizationFlags(inputFP.get()) &
97 kCompatibleWithCoverageAsAlpha_OptimizationFlag)
98 , fRRect(rrect)
99 , fEdgeType(edgeType)
100 , fCircularCornerFlags(circularCornerFlags) {
101 this->registerChild(std::move(inputFP));
102 }
103
CircularRRectEffect(const CircularRRectEffect & that)104 CircularRRectEffect::CircularRRectEffect(const CircularRRectEffect& that)
105 : INHERITED(that)
106 , fRRect(that.fRRect)
107 , fEdgeType(that.fEdgeType)
108 , fCircularCornerFlags(that.fCircularCornerFlags) {}
109
clone() const110 std::unique_ptr<GrFragmentProcessor> CircularRRectEffect::clone() const {
111 return std::unique_ptr<GrFragmentProcessor>(new CircularRRectEffect(*this));
112 }
113
onIsEqual(const GrFragmentProcessor & other) const114 bool CircularRRectEffect::onIsEqual(const GrFragmentProcessor& other) const {
115 const CircularRRectEffect& crre = other.cast<CircularRRectEffect>();
116 // The corner flags are derived from fRRect, so no need to check them.
117 return fEdgeType == crre.fEdgeType && fRRect == crre.fRRect;
118 }
119
120 //////////////////////////////////////////////////////////////////////////////
121
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircularRRectEffect)122 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircularRRectEffect)
123
124 #if GR_TEST_UTILS
125 std::unique_ptr<GrFragmentProcessor> CircularRRectEffect::TestCreate(GrProcessorTestData* d) {
126 SkScalar w = d->fRandom->nextRangeScalar(20.f, 1000.f);
127 SkScalar h = d->fRandom->nextRangeScalar(20.f, 1000.f);
128 SkScalar r = d->fRandom->nextRangeF(kRadiusMin, 9.f);
129 SkRRect rrect;
130 rrect.setRectXY(SkRect::MakeWH(w, h), r, r);
131 std::unique_ptr<GrFragmentProcessor> fp = d->inputFP();
132 bool success;
133 do {
134 GrClipEdgeType et =
135 (GrClipEdgeType)d->fRandom->nextULessThan(kGrClipEdgeTypeCnt);
136 std::tie(success, fp) = GrRRectEffect::Make(std::move(fp), et, rrect,
137 *d->caps()->shaderCaps());
138 } while (!success);
139 return fp;
140 }
141 #endif
142
143 //////////////////////////////////////////////////////////////////////////////
144
145 class CircularRRectEffect::Impl : public ProgramImpl {
146 public:
147 void emitCode(EmitArgs&) override;
148
149 private:
150 void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
151
152 GrGLSLProgramDataManager::UniformHandle fInnerRectUniform;
153 GrGLSLProgramDataManager::UniformHandle fRadiusPlusHalfUniform;
154 SkRRect fPrevRRect;
155 };
156
emitCode(EmitArgs & args)157 void CircularRRectEffect::Impl::emitCode(EmitArgs& args) {
158 const CircularRRectEffect& crre = args.fFp.cast<CircularRRectEffect>();
159 GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
160 const char *rectName;
161 const char *radiusPlusHalfName;
162 // The inner rect is the rrect bounds inset by the radius. Its left, top, right, and bottom
163 // edges correspond to components x, y, z, and w, respectively. When a side of the rrect has
164 // only rectangular corners, that side's value corresponds to the rect edge's value outset by
165 // half a pixel.
166 fInnerRectUniform = uniformHandler->addUniform(&crre, kFragment_GrShaderFlag, SkSLType::kFloat4,
167 "innerRect", &rectName);
168 // x is (r + .5) and y is 1/(r + .5)
169 fRadiusPlusHalfUniform = uniformHandler->addUniform(&crre, kFragment_GrShaderFlag,
170 SkSLType::kHalf2, "radiusPlusHalf",
171 &radiusPlusHalfName);
172
173 // If we're on a device where float != fp32 then the length calculation could overflow.
174 SkString clampedCircleDistance;
175 if (!args.fShaderCaps->fFloatIs32Bits) {
176 clampedCircleDistance.printf("saturate(%s.x * (1.0 - length(dxy * %s.y)))",
177 radiusPlusHalfName, radiusPlusHalfName);
178 } else {
179 clampedCircleDistance.printf("saturate(%s.x - length(dxy))", radiusPlusHalfName);
180 }
181
182 GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
183 // At each quarter-circle corner we compute a vector that is the offset of the fragment position
184 // from the circle center. The vector is pinned in x and y to be in the quarter-plane relevant
185 // to that corner. This means that points near the interior near the rrect top edge will have
186 // a vector that points straight up for both the TL left and TR corners. Computing an
187 // alpha from this vector at either the TR or TL corner will give the correct result. Similarly,
188 // fragments near the other three edges will get the correct AA. Fragments in the interior of
189 // the rrect will have a (0,0) vector at all four corners. So long as the radius > 0.5 they will
190 // correctly produce an alpha value of 1 at all four corners. We take the min of all the alphas.
191 // The code below is a simplified version of the above that performs maxs on the vector
192 // components before computing distances and alpha values so that only one distance computation
193 // need be computed to determine the min alpha.
194 //
195 // For the cases where one half of the rrect is rectangular we drop one of the x or y
196 // computations, compute a separate rect edge alpha for the rect side, and mul the two computed
197 // alphas together.
198 switch (crre.fCircularCornerFlags) {
199 case CircularRRectEffect::kAll_CornerFlags:
200 fragBuilder->codeAppendf("float2 dxy0 = %s.LT - sk_FragCoord.xy;", rectName);
201 fragBuilder->codeAppendf("float2 dxy1 = sk_FragCoord.xy - %s.RB;", rectName);
202 fragBuilder->codeAppend("float2 dxy = max(max(dxy0, dxy1), 0.0);");
203 fragBuilder->codeAppendf("half alpha = half(%s);", clampedCircleDistance.c_str());
204 break;
205 case CircularRRectEffect::kTopLeft_CornerFlag:
206 fragBuilder->codeAppendf("float2 dxy = max(%s.LT - sk_FragCoord.xy, 0.0);",
207 rectName);
208 fragBuilder->codeAppendf("half rightAlpha = half(saturate(%s.R - sk_FragCoord.x));",
209 rectName);
210 fragBuilder->codeAppendf("half bottomAlpha = half(saturate(%s.B - sk_FragCoord.y));",
211 rectName);
212 fragBuilder->codeAppendf("half alpha = bottomAlpha * rightAlpha * half(%s);",
213 clampedCircleDistance.c_str());
214 break;
215 case CircularRRectEffect::kTopRight_CornerFlag:
216 fragBuilder->codeAppendf("float2 dxy = max(float2(sk_FragCoord.x - %s.R, "
217 "%s.T - sk_FragCoord.y), 0.0);",
218 rectName, rectName);
219 fragBuilder->codeAppendf("half leftAlpha = half(saturate(sk_FragCoord.x - %s.L));",
220 rectName);
221 fragBuilder->codeAppendf("half bottomAlpha = half(saturate(%s.B - sk_FragCoord.y));",
222 rectName);
223 fragBuilder->codeAppendf("half alpha = bottomAlpha * leftAlpha * half(%s);",
224 clampedCircleDistance.c_str());
225 break;
226 case CircularRRectEffect::kBottomRight_CornerFlag:
227 fragBuilder->codeAppendf("float2 dxy = max(sk_FragCoord.xy - %s.RB, 0.0);",
228 rectName);
229 fragBuilder->codeAppendf("half leftAlpha = half(saturate(sk_FragCoord.x - %s.L));",
230 rectName);
231 fragBuilder->codeAppendf("half topAlpha = half(saturate(sk_FragCoord.y - %s.T));",
232 rectName);
233 fragBuilder->codeAppendf("half alpha = topAlpha * leftAlpha * half(%s);",
234 clampedCircleDistance.c_str());
235 break;
236 case CircularRRectEffect::kBottomLeft_CornerFlag:
237 fragBuilder->codeAppendf("float2 dxy = max(float2(%s.L - sk_FragCoord.x, "
238 "sk_FragCoord.y - %s.B), 0.0);",
239 rectName, rectName);
240 fragBuilder->codeAppendf("half rightAlpha = half(saturate(%s.R - sk_FragCoord.x));",
241 rectName);
242 fragBuilder->codeAppendf("half topAlpha = half(saturate(sk_FragCoord.y - %s.T));",
243 rectName);
244 fragBuilder->codeAppendf("half alpha = topAlpha * rightAlpha * half(%s);",
245 clampedCircleDistance.c_str());
246 break;
247 case CircularRRectEffect::kLeft_CornerFlags:
248 fragBuilder->codeAppendf("float2 dxy0 = %s.LT - sk_FragCoord.xy;", rectName);
249 fragBuilder->codeAppendf("float dy1 = sk_FragCoord.y - %s.B;", rectName);
250 fragBuilder->codeAppend("float2 dxy = max(float2(dxy0.x, max(dxy0.y, dy1)), 0.0);");
251 fragBuilder->codeAppendf("half rightAlpha = half(saturate(%s.R - sk_FragCoord.x));",
252 rectName);
253 fragBuilder->codeAppendf("half alpha = rightAlpha * half(%s);",
254 clampedCircleDistance.c_str());
255 break;
256 case CircularRRectEffect::kTop_CornerFlags:
257 fragBuilder->codeAppendf("float2 dxy0 = %s.LT - sk_FragCoord.xy;", rectName);
258 fragBuilder->codeAppendf("float dx1 = sk_FragCoord.x - %s.R;", rectName);
259 fragBuilder->codeAppend("float2 dxy = max(float2(max(dxy0.x, dx1), dxy0.y), 0.0);");
260 fragBuilder->codeAppendf("half bottomAlpha = half(saturate(%s.B - sk_FragCoord.y));",
261 rectName);
262 fragBuilder->codeAppendf("half alpha = bottomAlpha * half(%s);",
263 clampedCircleDistance.c_str());
264 break;
265 case CircularRRectEffect::kRight_CornerFlags:
266 fragBuilder->codeAppendf("float dy0 = %s.T - sk_FragCoord.y;", rectName);
267 fragBuilder->codeAppendf("float2 dxy1 = sk_FragCoord.xy - %s.RB;", rectName);
268 fragBuilder->codeAppend("float2 dxy = max(float2(dxy1.x, max(dy0, dxy1.y)), 0.0);");
269 fragBuilder->codeAppendf("half leftAlpha = half(saturate(sk_FragCoord.x - %s.L));",
270 rectName);
271 fragBuilder->codeAppendf("half alpha = leftAlpha * half(%s);",
272 clampedCircleDistance.c_str());
273 break;
274 case CircularRRectEffect::kBottom_CornerFlags:
275 fragBuilder->codeAppendf("float dx0 = %s.L - sk_FragCoord.x;", rectName);
276 fragBuilder->codeAppendf("float2 dxy1 = sk_FragCoord.xy - %s.RB;", rectName);
277 fragBuilder->codeAppend("float2 dxy = max(float2(max(dx0, dxy1.x), dxy1.y), 0.0);");
278 fragBuilder->codeAppendf("half topAlpha = half(saturate(sk_FragCoord.y - %s.T));",
279 rectName);
280 fragBuilder->codeAppendf("half alpha = topAlpha * half(%s);",
281 clampedCircleDistance.c_str());
282 break;
283 }
284
285 if (GrClipEdgeType::kInverseFillAA == crre.fEdgeType) {
286 fragBuilder->codeAppend("alpha = 1.0 - alpha;");
287 }
288
289 SkString inputSample = this->invokeChild(/*childIndex=*/0, args);
290
291 fragBuilder->codeAppendf("return %s * alpha;", inputSample.c_str());
292 }
293
onSetData(const GrGLSLProgramDataManager & pdman,const GrFragmentProcessor & processor)294 void CircularRRectEffect::Impl::onSetData(const GrGLSLProgramDataManager& pdman,
295 const GrFragmentProcessor& processor) {
296 const CircularRRectEffect& crre = processor.cast<CircularRRectEffect>();
297 const SkRRect& rrect = crre.fRRect;
298 if (rrect != fPrevRRect) {
299 SkRect rect = rrect.getBounds();
300 SkScalar radius = 0;
301 switch (crre.fCircularCornerFlags) {
302 case CircularRRectEffect::kAll_CornerFlags:
303 SkASSERT(SkRRectPriv::IsSimpleCircular(rrect));
304 radius = SkRRectPriv::GetSimpleRadii(rrect).fX;
305 SkASSERT(radius >= kRadiusMin);
306 rect.inset(radius, radius);
307 break;
308 case CircularRRectEffect::kTopLeft_CornerFlag:
309 radius = rrect.radii(SkRRect::kUpperLeft_Corner).fX;
310 rect.fLeft += radius;
311 rect.fTop += radius;
312 rect.fRight += 0.5f;
313 rect.fBottom += 0.5f;
314 break;
315 case CircularRRectEffect::kTopRight_CornerFlag:
316 radius = rrect.radii(SkRRect::kUpperRight_Corner).fX;
317 rect.fLeft -= 0.5f;
318 rect.fTop += radius;
319 rect.fRight -= radius;
320 rect.fBottom += 0.5f;
321 break;
322 case CircularRRectEffect::kBottomRight_CornerFlag:
323 radius = rrect.radii(SkRRect::kLowerRight_Corner).fX;
324 rect.fLeft -= 0.5f;
325 rect.fTop -= 0.5f;
326 rect.fRight -= radius;
327 rect.fBottom -= radius;
328 break;
329 case CircularRRectEffect::kBottomLeft_CornerFlag:
330 radius = rrect.radii(SkRRect::kLowerLeft_Corner).fX;
331 rect.fLeft += radius;
332 rect.fTop -= 0.5f;
333 rect.fRight += 0.5f;
334 rect.fBottom -= radius;
335 break;
336 case CircularRRectEffect::kLeft_CornerFlags:
337 radius = rrect.radii(SkRRect::kUpperLeft_Corner).fX;
338 rect.fLeft += radius;
339 rect.fTop += radius;
340 rect.fRight += 0.5f;
341 rect.fBottom -= radius;
342 break;
343 case CircularRRectEffect::kTop_CornerFlags:
344 radius = rrect.radii(SkRRect::kUpperLeft_Corner).fX;
345 rect.fLeft += radius;
346 rect.fTop += radius;
347 rect.fRight -= radius;
348 rect.fBottom += 0.5f;
349 break;
350 case CircularRRectEffect::kRight_CornerFlags:
351 radius = rrect.radii(SkRRect::kUpperRight_Corner).fX;
352 rect.fLeft -= 0.5f;
353 rect.fTop += radius;
354 rect.fRight -= radius;
355 rect.fBottom -= radius;
356 break;
357 case CircularRRectEffect::kBottom_CornerFlags:
358 radius = rrect.radii(SkRRect::kLowerLeft_Corner).fX;
359 rect.fLeft += radius;
360 rect.fTop -= 0.5f;
361 rect.fRight -= radius;
362 rect.fBottom -= radius;
363 break;
364 default:
365 SK_ABORT("Should have been one of the above cases.");
366 }
367 pdman.set4f(fInnerRectUniform, rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
368 radius += 0.5f;
369 pdman.set2f(fRadiusPlusHalfUniform, radius, 1.f / radius);
370 fPrevRRect = rrect;
371 }
372 }
373
374 ////////////////////////////////////////////////////////////////////////////////////////////////////
375
onAddToKey(const GrShaderCaps & caps,skgpu::KeyBuilder * b) const376 void CircularRRectEffect::onAddToKey(const GrShaderCaps& caps, skgpu::KeyBuilder* b) const {
377 static_assert(kGrClipEdgeTypeCnt <= 8);
378 b->add32((fCircularCornerFlags << 3) | static_cast<int>(fEdgeType));
379 }
380
onMakeProgramImpl() const381 std::unique_ptr<GrFragmentProcessor::ProgramImpl> CircularRRectEffect::onMakeProgramImpl() const {
382 return std::make_unique<Impl>();
383 }
384
385 //////////////////////////////////////////////////////////////////////////////
386
387 namespace {
388 class EllipticalRRectEffect : public GrFragmentProcessor {
389 public:
390 static GrFPResult Make(std::unique_ptr<GrFragmentProcessor>, GrClipEdgeType, const SkRRect&);
391
~EllipticalRRectEffect()392 ~EllipticalRRectEffect() override {}
393
name() const394 const char* name() const override { return "EllipticalRRect"; }
395
396 std::unique_ptr<GrFragmentProcessor> clone() const override;
397
398 private:
399 class Impl;
400
401 EllipticalRRectEffect(std::unique_ptr<GrFragmentProcessor>, GrClipEdgeType, const SkRRect&);
402 EllipticalRRectEffect(const EllipticalRRectEffect& that);
403
404 std::unique_ptr<ProgramImpl> onMakeProgramImpl() const override;
405
406 void onAddToKey(const GrShaderCaps&, skgpu::KeyBuilder*) const override;
407
408 bool onIsEqual(const GrFragmentProcessor& other) const override;
409
410 SkRRect fRRect;
411 GrClipEdgeType fEdgeType;
412
413 GR_DECLARE_FRAGMENT_PROCESSOR_TEST
414
415 using INHERITED = GrFragmentProcessor;
416 };
417
Make(std::unique_ptr<GrFragmentProcessor> inputFP,GrClipEdgeType edgeType,const SkRRect & rrect)418 GrFPResult EllipticalRRectEffect::Make(std::unique_ptr<GrFragmentProcessor> inputFP,
419 GrClipEdgeType edgeType,
420 const SkRRect& rrect) {
421 if (GrClipEdgeType::kFillAA != edgeType && GrClipEdgeType::kInverseFillAA != edgeType) {
422 return GrFPFailure(std::move(inputFP));
423 }
424 return GrFPSuccess(std::unique_ptr<GrFragmentProcessor>(
425 new EllipticalRRectEffect(std::move(inputFP), edgeType, rrect)));
426 }
427
EllipticalRRectEffect(std::unique_ptr<GrFragmentProcessor> inputFP,GrClipEdgeType edgeType,const SkRRect & rrect)428 EllipticalRRectEffect::EllipticalRRectEffect(std::unique_ptr<GrFragmentProcessor> inputFP,
429 GrClipEdgeType edgeType,
430 const SkRRect& rrect)
431 : INHERITED(kEllipticalRRectEffect_ClassID,
432 ProcessorOptimizationFlags(inputFP.get()) &
433 kCompatibleWithCoverageAsAlpha_OptimizationFlag)
434 , fRRect(rrect)
435 , fEdgeType(edgeType) {
436 this->registerChild(std::move(inputFP));
437 }
438
EllipticalRRectEffect(const EllipticalRRectEffect & that)439 EllipticalRRectEffect::EllipticalRRectEffect(const EllipticalRRectEffect& that)
440 : INHERITED(that)
441 , fRRect(that.fRRect)
442 , fEdgeType(that.fEdgeType) {}
443
clone() const444 std::unique_ptr<GrFragmentProcessor> EllipticalRRectEffect::clone() const {
445 return std::unique_ptr<GrFragmentProcessor>(new EllipticalRRectEffect(*this));
446 }
447
onIsEqual(const GrFragmentProcessor & other) const448 bool EllipticalRRectEffect::onIsEqual(const GrFragmentProcessor& other) const {
449 const EllipticalRRectEffect& erre = other.cast<EllipticalRRectEffect>();
450 return fEdgeType == erre.fEdgeType && fRRect == erre.fRRect;
451 }
452 } // anonymous namespace
453
454 //////////////////////////////////////////////////////////////////////////////
455
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(EllipticalRRectEffect)456 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(EllipticalRRectEffect)
457
458 #if GR_TEST_UTILS
459 std::unique_ptr<GrFragmentProcessor> EllipticalRRectEffect::TestCreate(GrProcessorTestData* d) {
460 SkScalar w = d->fRandom->nextRangeScalar(20.f, 1000.f);
461 SkScalar h = d->fRandom->nextRangeScalar(20.f, 1000.f);
462 SkVector r[4];
463 r[SkRRect::kUpperLeft_Corner].fX = d->fRandom->nextRangeF(kRadiusMin, 9.f);
464 // ensure at least one corner really is elliptical
465 do {
466 r[SkRRect::kUpperLeft_Corner].fY = d->fRandom->nextRangeF(kRadiusMin, 9.f);
467 } while (r[SkRRect::kUpperLeft_Corner].fY == r[SkRRect::kUpperLeft_Corner].fX);
468
469 SkRRect rrect;
470 if (d->fRandom->nextBool()) {
471 // half the time create a four-radii rrect.
472 r[SkRRect::kLowerRight_Corner].fX = d->fRandom->nextRangeF(kRadiusMin, 9.f);
473 r[SkRRect::kLowerRight_Corner].fY = d->fRandom->nextRangeF(kRadiusMin, 9.f);
474
475 r[SkRRect::kUpperRight_Corner].fX = r[SkRRect::kLowerRight_Corner].fX;
476 r[SkRRect::kUpperRight_Corner].fY = r[SkRRect::kUpperLeft_Corner].fY;
477
478 r[SkRRect::kLowerLeft_Corner].fX = r[SkRRect::kUpperLeft_Corner].fX;
479 r[SkRRect::kLowerLeft_Corner].fY = r[SkRRect::kLowerRight_Corner].fY;
480
481 rrect.setRectRadii(SkRect::MakeWH(w, h), r);
482 } else {
483 rrect.setRectXY(SkRect::MakeWH(w, h), r[SkRRect::kUpperLeft_Corner].fX,
484 r[SkRRect::kUpperLeft_Corner].fY);
485 }
486 std::unique_ptr<GrFragmentProcessor> fp = d->inputFP();
487 bool success;
488 do {
489 GrClipEdgeType et = (GrClipEdgeType)d->fRandom->nextULessThan(kGrClipEdgeTypeCnt);
490 std::tie(success, fp) = GrRRectEffect::Make(std::move(fp), et, rrect,
491 *d->caps()->shaderCaps());
492 } while (!success);
493 return fp;
494 }
495 #endif
496
497 //////////////////////////////////////////////////////////////////////////////
498
elliptical_effect_uses_scale(const GrShaderCaps & caps,const SkRRect & rrect)499 static bool elliptical_effect_uses_scale(const GrShaderCaps& caps, const SkRRect& rrect) {
500 // If we're on a device where float != fp32 then we'll do the distance computation in a space
501 // that is normalized by the largest radius. The scale uniform will be scale, 1/scale. The
502 // radii uniform values are already in this normalized space.
503 if (!caps.fFloatIs32Bits) {
504 return true;
505 }
506 // Additionally, even if we have fp32, large radii can underflow 1/radii^2 terms leading to
507 // blurry coverage. This effect applies to simple and nine-patch, so only need to check TL+BR
508 const SkVector& r0 = rrect.radii(SkRRect::kUpperLeft_Corner);
509 const SkVector& r1 = rrect.radii(SkRRect::kLowerRight_Corner);
510 float maxRadius = std::max(std::max(r0.fX, r0.fY), std::max(r1.fX, r1.fY));
511 return SkScalarNearlyZero(1.f / (maxRadius * maxRadius));
512 }
513
514 class EllipticalRRectEffect::Impl : public ProgramImpl {
515 public:
516 void emitCode(EmitArgs&) override;
517
518 private:
519 void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
520
521 GrGLSLProgramDataManager::UniformHandle fInnerRectUniform;
522 GrGLSLProgramDataManager::UniformHandle fInvRadiiSqdUniform;
523 GrGLSLProgramDataManager::UniformHandle fScaleUniform;
524 SkRRect fPrevRRect;
525 };
526
emitCode(EmitArgs & args)527 void EllipticalRRectEffect::Impl::emitCode(EmitArgs& args) {
528 const EllipticalRRectEffect& erre = args.fFp.cast<EllipticalRRectEffect>();
529 GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
530 const char *rectName;
531 // The inner rect is the rrect bounds inset by the x/y radii
532 fInnerRectUniform = uniformHandler->addUniform(&erre, kFragment_GrShaderFlag, SkSLType::kFloat4,
533 "innerRect", &rectName);
534
535 GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
536 // At each quarter-ellipse corner we compute a vector that is the offset of the fragment pos
537 // to the ellipse center. The vector is pinned in x and y to be in the quarter-plane relevant
538 // to that corner. This means that points near the interior near the rrect top edge will have
539 // a vector that points straight up for both the TL left and TR corners. Computing an
540 // alpha from this vector at either the TR or TL corner will give the correct result. Similarly,
541 // fragments near the other three edges will get the correct AA. Fragments in the interior of
542 // the rrect will have a (0,0) vector at all four corners. So long as the radii > 0.5 they will
543 // correctly produce an alpha value of 1 at all four corners. We take the min of all the alphas.
544 //
545 // The code below is a simplified version of the above that performs maxs on the vector
546 // components before computing distances and alpha values so that only one distance computation
547 // need be computed to determine the min alpha.
548 fragBuilder->codeAppendf("float2 dxy0 = %s.LT - sk_FragCoord.xy;", rectName);
549 fragBuilder->codeAppendf("float2 dxy1 = sk_FragCoord.xy - %s.RB;", rectName);
550
551
552 const char* scaleName = nullptr;
553 if (elliptical_effect_uses_scale(*args.fShaderCaps, erre.fRRect)) {
554 fScaleUniform = uniformHandler->addUniform(&erre, kFragment_GrShaderFlag, SkSLType::kHalf2,
555 "scale", &scaleName);
556 }
557
558 // The uniforms with the inv squared radii are highp to prevent underflow.
559 switch (erre.fRRect.getType()) {
560 case SkRRect::kSimple_Type: {
561 const char *invRadiiXYSqdName;
562 fInvRadiiSqdUniform = uniformHandler->addUniform(&erre,
563 kFragment_GrShaderFlag,
564 SkSLType::kFloat2,
565 "invRadiiXY",
566 &invRadiiXYSqdName);
567 fragBuilder->codeAppend("float2 dxy = max(max(dxy0, dxy1), 0.0);");
568 if (scaleName) {
569 fragBuilder->codeAppendf("dxy *= %s.y;", scaleName);
570 }
571 // Z is the x/y offsets divided by squared radii.
572 fragBuilder->codeAppendf("float2 Z = dxy * %s.xy;", invRadiiXYSqdName);
573 break;
574 }
575 case SkRRect::kNinePatch_Type: {
576 const char *invRadiiLTRBSqdName;
577 fInvRadiiSqdUniform = uniformHandler->addUniform(&erre,
578 kFragment_GrShaderFlag,
579 SkSLType::kFloat4,
580 "invRadiiLTRB",
581 &invRadiiLTRBSqdName);
582 if (scaleName) {
583 fragBuilder->codeAppendf("dxy0 *= %s.y;", scaleName);
584 fragBuilder->codeAppendf("dxy1 *= %s.y;", scaleName);
585 }
586 fragBuilder->codeAppend("float2 dxy = max(max(dxy0, dxy1), 0.0);");
587 // Z is the x/y offsets divided by squared radii. We only care about the (at most) one
588 // corner where both the x and y offsets are positive, hence the maxes. (The inverse
589 // squared radii will always be positive.)
590 fragBuilder->codeAppendf("float2 Z = max(max(dxy0 * %s.xy, dxy1 * %s.zw), 0.0);",
591 invRadiiLTRBSqdName, invRadiiLTRBSqdName);
592
593 break;
594 }
595 default:
596 SK_ABORT("RRect should always be simple or nine-patch.");
597 }
598 // implicit is the evaluation of (x/a)^2 + (y/b)^2 - 1.
599 fragBuilder->codeAppend("half implicit = half(dot(Z, dxy) - 1.0);");
600 // grad_dot is the squared length of the gradient of the implicit.
601 fragBuilder->codeAppend("half grad_dot = half(4.0 * dot(Z, Z));");
602 // avoid calling inversesqrt on zero.
603 fragBuilder->codeAppend("grad_dot = max(grad_dot, 1.0e-4);");
604 fragBuilder->codeAppend("half approx_dist = implicit * half(inversesqrt(grad_dot));");
605 if (scaleName) {
606 fragBuilder->codeAppendf("approx_dist *= %s.x;", scaleName);
607 }
608
609 if (erre.fEdgeType == GrClipEdgeType::kFillAA) {
610 fragBuilder->codeAppend("half alpha = clamp(0.5 - approx_dist, 0.0, 1.0);");
611 } else {
612 fragBuilder->codeAppend("half alpha = clamp(0.5 + approx_dist, 0.0, 1.0);");
613 }
614
615 SkString inputSample = this->invokeChild(/*childIndex=*/0, args);
616
617 fragBuilder->codeAppendf("return %s * alpha;", inputSample.c_str());
618 }
619
onSetData(const GrGLSLProgramDataManager & pdman,const GrFragmentProcessor & effect)620 void EllipticalRRectEffect::Impl::onSetData(const GrGLSLProgramDataManager& pdman,
621 const GrFragmentProcessor& effect) {
622 const EllipticalRRectEffect& erre = effect.cast<EllipticalRRectEffect>();
623 const SkRRect& rrect = erre.fRRect;
624 // If we're using a scale factor to work around precision issues, choose the largest radius
625 // as the scale factor. The inv radii need to be pre-adjusted by the scale factor.
626 if (rrect != fPrevRRect) {
627 SkRect rect = rrect.getBounds();
628 const SkVector& r0 = rrect.radii(SkRRect::kUpperLeft_Corner);
629 SkASSERT(r0.fX >= kRadiusMin);
630 SkASSERT(r0.fY >= kRadiusMin);
631 switch (rrect.getType()) {
632 case SkRRect::kSimple_Type:
633 rect.inset(r0.fX, r0.fY);
634 if (fScaleUniform.isValid()) {
635 if (r0.fX > r0.fY) {
636 pdman.set2f(fInvRadiiSqdUniform, 1.f, (r0.fX * r0.fX) / (r0.fY * r0.fY));
637 pdman.set2f(fScaleUniform, r0.fX, 1.f / r0.fX);
638 } else {
639 pdman.set2f(fInvRadiiSqdUniform, (r0.fY * r0.fY) / (r0.fX * r0.fX), 1.f);
640 pdman.set2f(fScaleUniform, r0.fY, 1.f / r0.fY);
641 }
642 } else {
643 pdman.set2f(fInvRadiiSqdUniform, 1.f / (r0.fX * r0.fX),
644 1.f / (r0.fY * r0.fY));
645 }
646 break;
647 case SkRRect::kNinePatch_Type: {
648 const SkVector& r1 = rrect.radii(SkRRect::kLowerRight_Corner);
649 SkASSERT(r1.fX >= kRadiusMin);
650 SkASSERT(r1.fY >= kRadiusMin);
651 rect.fLeft += r0.fX;
652 rect.fTop += r0.fY;
653 rect.fRight -= r1.fX;
654 rect.fBottom -= r1.fY;
655 if (fScaleUniform.isValid()) {
656 float scale = std::max(std::max(r0.fX, r0.fY), std::max(r1.fX, r1.fY));
657 float scaleSqd = scale * scale;
658 pdman.set4f(fInvRadiiSqdUniform, scaleSqd / (r0.fX * r0.fX),
659 scaleSqd / (r0.fY * r0.fY),
660 scaleSqd / (r1.fX * r1.fX),
661 scaleSqd / (r1.fY * r1.fY));
662 pdman.set2f(fScaleUniform, scale, 1.f / scale);
663 } else {
664 pdman.set4f(fInvRadiiSqdUniform, 1.f / (r0.fX * r0.fX),
665 1.f / (r0.fY * r0.fY),
666 1.f / (r1.fX * r1.fX),
667 1.f / (r1.fY * r1.fY));
668 }
669 break;
670 }
671 default:
672 SK_ABORT("RRect should always be simple or nine-patch.");
673 }
674 pdman.set4f(fInnerRectUniform, rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
675 fPrevRRect = rrect;
676 }
677 }
678
679 ////////////////////////////////////////////////////////////////////////////////////////////////////
680
onAddToKey(const GrShaderCaps & caps,skgpu::KeyBuilder * b) const681 void EllipticalRRectEffect::onAddToKey(const GrShaderCaps& caps, skgpu::KeyBuilder* b) const {
682 static_assert(kGrClipEdgeTypeCnt <= 4); // 2 bits
683 static_assert((int)SkRRect::kLastType + 1 <= 8); // 3 bits
684 b->addBits(2, static_cast<int>(fEdgeType), "edge_type");
685 b->addBits(3, static_cast<int>(fRRect.getType()), "rrect_type");
686 b->addBool(elliptical_effect_uses_scale(caps, fRRect), "scale_radii");
687 }
688
onMakeProgramImpl() const689 std::unique_ptr<GrFragmentProcessor::ProgramImpl> EllipticalRRectEffect::onMakeProgramImpl() const {
690 return std::make_unique<Impl>();
691 }
692
693 //////////////////////////////////////////////////////////////////////////////
694
Make(std::unique_ptr<GrFragmentProcessor> inputFP,GrClipEdgeType edgeType,const SkRRect & rrect,const GrShaderCaps & caps)695 GrFPResult GrRRectEffect::Make(std::unique_ptr<GrFragmentProcessor> inputFP,
696 GrClipEdgeType edgeType, const SkRRect& rrect,
697 const GrShaderCaps& caps) {
698 if (rrect.isRect()) {
699 auto fp = GrFragmentProcessor::Rect(std::move(inputFP), edgeType, rrect.getBounds());
700 return GrFPSuccess(std::move(fp));
701 }
702
703 if (rrect.isOval()) {
704 return GrOvalEffect::Make(std::move(inputFP), edgeType, rrect.getBounds(), caps);
705 }
706
707 if (rrect.isSimple()) {
708 if (SkRRectPriv::GetSimpleRadii(rrect).fX < kRadiusMin ||
709 SkRRectPriv::GetSimpleRadii(rrect).fY < kRadiusMin) {
710 // In this case the corners are extremely close to rectangular and we collapse the
711 // clip to a rectangular clip.
712 auto fp = GrFragmentProcessor::Rect(std::move(inputFP), edgeType, rrect.getBounds());
713 return GrFPSuccess(std::move(fp));
714 }
715 if (SkRRectPriv::IsSimpleCircular(rrect)) {
716 return CircularRRectEffect::Make(std::move(inputFP), edgeType,
717 CircularRRectEffect::kAll_CornerFlags, rrect);
718 } else {
719 return EllipticalRRectEffect::Make(std::move(inputFP), edgeType, rrect);
720 }
721 }
722
723 if (rrect.isComplex() || rrect.isNinePatch()) {
724 // Check for the "tab" cases - two adjacent circular corners and two square corners.
725 SkScalar circularRadius = 0;
726 uint32_t cornerFlags = 0;
727
728 SkVector radii[4];
729 bool squashedRadii = false;
730 for (int c = 0; c < 4; ++c) {
731 radii[c] = rrect.radii((SkRRect::Corner)c);
732 SkASSERT((0 == radii[c].fX) == (0 == radii[c].fY));
733 if (0 == radii[c].fX) {
734 // The corner is square, so no need to squash or flag as circular.
735 continue;
736 }
737 if (radii[c].fX < kRadiusMin || radii[c].fY < kRadiusMin) {
738 radii[c].set(0, 0);
739 squashedRadii = true;
740 continue;
741 }
742 if (radii[c].fX != radii[c].fY) {
743 cornerFlags = ~0U;
744 break;
745 }
746 if (!cornerFlags) {
747 circularRadius = radii[c].fX;
748 cornerFlags = 1 << c;
749 } else {
750 if (radii[c].fX != circularRadius) {
751 cornerFlags = ~0U;
752 break;
753 }
754 cornerFlags |= 1 << c;
755 }
756 }
757
758 switch (cornerFlags) {
759 case CircularRRectEffect::kAll_CornerFlags:
760 // This rrect should have been caught in the simple case above. Though, it would
761 // be correctly handled in the fallthrough code.
762 SkASSERT(false);
763 [[fallthrough]];
764 case CircularRRectEffect::kTopLeft_CornerFlag:
765 case CircularRRectEffect::kTopRight_CornerFlag:
766 case CircularRRectEffect::kBottomRight_CornerFlag:
767 case CircularRRectEffect::kBottomLeft_CornerFlag:
768 case CircularRRectEffect::kLeft_CornerFlags:
769 case CircularRRectEffect::kTop_CornerFlags:
770 case CircularRRectEffect::kRight_CornerFlags:
771 case CircularRRectEffect::kBottom_CornerFlags: {
772 SkTCopyOnFirstWrite<SkRRect> rr(rrect);
773 if (squashedRadii) {
774 rr.writable()->setRectRadii(rrect.getBounds(), radii);
775 }
776 return CircularRRectEffect::Make(std::move(inputFP), edgeType, cornerFlags, *rr);
777 }
778 case CircularRRectEffect::kNone_CornerFlags: {
779 auto fp =
780 GrFragmentProcessor::Rect(std::move(inputFP), edgeType, rrect.getBounds());
781 return GrFPSuccess(std::move(fp));
782 }
783 default: {
784 const SkVector ul = rrect.radii(SkRRect::kUpperLeft_Corner);
785 const SkVector lr = rrect.radii(SkRRect::kLowerRight_Corner);
786 if (rrect.isNinePatch() &&
787 ul.fX >= kRadiusMin &&
788 ul.fY >= kRadiusMin &&
789 lr.fX >= kRadiusMin &&
790 lr.fY >= kRadiusMin) {
791 return EllipticalRRectEffect::Make(std::move(inputFP), edgeType, rrect);
792 }
793 return GrFPFailure(std::move(inputFP));
794 }
795 }
796 }
797 return GrFPFailure(std::move(inputFP));
798 }
799