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