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
50 ~CircularRRectEffect() override {}
51
52 const char* name() const override { return "CircularRRect"; }
53
54 SkString getShaderDfxInfo() const override;
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&, GrProcessorKeyBuilder*) 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
122 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircularRRectEffect);
123
124 #if GR_TEST_UTILS
TestCreate(GrProcessorTestData* d)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, kFloat4_GrSLType,
167 "innerRect", &rectName);
168 // x is (r + .5) and y is 1/(r + .5)
169 fRadiusPlusHalfUniform = uniformHandler->addUniform(&crre, kFragment_GrShaderFlag,
170 kHalf2_GrSLType, "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->floatIs32Bits()) {
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
getShaderDfxInfo() const376 SkString CircularRRectEffect::getShaderDfxInfo() const {
377 SkString format;
378 format.printf("ShaderDfx_CircularRRectEffect_%d_%d", fCircularCornerFlags, fEdgeType);
379 return format;
380 }
381
onAddToKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const382 void CircularRRectEffect::onAddToKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const {
383 static_assert(kGrClipEdgeTypeCnt <= 8);
384 b->add32((fCircularCornerFlags << 3) | static_cast<int>(fEdgeType));
385 }
386
onMakeProgramImpl() const387 std::unique_ptr<GrFragmentProcessor::ProgramImpl> CircularRRectEffect::onMakeProgramImpl() const {
388 return std::make_unique<Impl>();
389 }
390
391 //////////////////////////////////////////////////////////////////////////////
392
393 namespace {
394 class EllipticalRRectEffect : public GrFragmentProcessor {
395 public:
396 static GrFPResult Make(std::unique_ptr<GrFragmentProcessor>, GrClipEdgeType, const SkRRect&);
397
398 ~EllipticalRRectEffect() override {}
399
400 const char* name() const override { return "EllipticalRRect"; }
401
402 SkString getShaderDfxInfo() const override;
403
404 std::unique_ptr<GrFragmentProcessor> clone() const override;
405
406 private:
407 class Impl;
408
409 EllipticalRRectEffect(std::unique_ptr<GrFragmentProcessor>, GrClipEdgeType, const SkRRect&);
410 EllipticalRRectEffect(const EllipticalRRectEffect& that);
411
412 std::unique_ptr<ProgramImpl> onMakeProgramImpl() const override;
413
414 void onAddToKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
415
416 bool onIsEqual(const GrFragmentProcessor& other) const override;
417
418 SkRRect fRRect;
419 GrClipEdgeType fEdgeType;
420
421 GR_DECLARE_FRAGMENT_PROCESSOR_TEST
422
423 using INHERITED = GrFragmentProcessor;
424 };
425
Make(std::unique_ptr<GrFragmentProcessor> inputFP, GrClipEdgeType edgeType, const SkRRect& rrect)426 GrFPResult EllipticalRRectEffect::Make(std::unique_ptr<GrFragmentProcessor> inputFP,
427 GrClipEdgeType edgeType,
428 const SkRRect& rrect) {
429 if (GrClipEdgeType::kFillAA != edgeType && GrClipEdgeType::kInverseFillAA != edgeType) {
430 return GrFPFailure(std::move(inputFP));
431 }
432 return GrFPSuccess(std::unique_ptr<GrFragmentProcessor>(
433 new EllipticalRRectEffect(std::move(inputFP), edgeType, rrect)));
434 }
435
EllipticalRRectEffect(std::unique_ptr<GrFragmentProcessor> inputFP, GrClipEdgeType edgeType, const SkRRect& rrect)436 EllipticalRRectEffect::EllipticalRRectEffect(std::unique_ptr<GrFragmentProcessor> inputFP,
437 GrClipEdgeType edgeType,
438 const SkRRect& rrect)
439 : INHERITED(kEllipticalRRectEffect_ClassID,
440 ProcessorOptimizationFlags(inputFP.get()) &
441 kCompatibleWithCoverageAsAlpha_OptimizationFlag)
442 , fRRect(rrect)
443 , fEdgeType(edgeType) {
444 this->registerChild(std::move(inputFP));
445 }
446
EllipticalRRectEffect(const EllipticalRRectEffect& that)447 EllipticalRRectEffect::EllipticalRRectEffect(const EllipticalRRectEffect& that)
448 : INHERITED(that)
449 , fRRect(that.fRRect)
450 , fEdgeType(that.fEdgeType) {}
451
clone() const452 std::unique_ptr<GrFragmentProcessor> EllipticalRRectEffect::clone() const {
453 return std::unique_ptr<GrFragmentProcessor>(new EllipticalRRectEffect(*this));
454 }
455
onIsEqual(const GrFragmentProcessor& other) const456 bool EllipticalRRectEffect::onIsEqual(const GrFragmentProcessor& other) const {
457 const EllipticalRRectEffect& erre = other.cast<EllipticalRRectEffect>();
458 return fEdgeType == erre.fEdgeType && fRRect == erre.fRRect;
459 }
460 } // anonymous namespace
461
462 //////////////////////////////////////////////////////////////////////////////
463
464 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(EllipticalRRectEffect);
465
466 #if GR_TEST_UTILS
TestCreate(GrProcessorTestData* d)467 std::unique_ptr<GrFragmentProcessor> EllipticalRRectEffect::TestCreate(GrProcessorTestData* d) {
468 SkScalar w = d->fRandom->nextRangeScalar(20.f, 1000.f);
469 SkScalar h = d->fRandom->nextRangeScalar(20.f, 1000.f);
470 SkVector r[4];
471 r[SkRRect::kUpperLeft_Corner].fX = d->fRandom->nextRangeF(kRadiusMin, 9.f);
472 // ensure at least one corner really is elliptical
473 do {
474 r[SkRRect::kUpperLeft_Corner].fY = d->fRandom->nextRangeF(kRadiusMin, 9.f);
475 } while (r[SkRRect::kUpperLeft_Corner].fY == r[SkRRect::kUpperLeft_Corner].fX);
476
477 SkRRect rrect;
478 if (d->fRandom->nextBool()) {
479 // half the time create a four-radii rrect.
480 r[SkRRect::kLowerRight_Corner].fX = d->fRandom->nextRangeF(kRadiusMin, 9.f);
481 r[SkRRect::kLowerRight_Corner].fY = d->fRandom->nextRangeF(kRadiusMin, 9.f);
482
483 r[SkRRect::kUpperRight_Corner].fX = r[SkRRect::kLowerRight_Corner].fX;
484 r[SkRRect::kUpperRight_Corner].fY = r[SkRRect::kUpperLeft_Corner].fY;
485
486 r[SkRRect::kLowerLeft_Corner].fX = r[SkRRect::kUpperLeft_Corner].fX;
487 r[SkRRect::kLowerLeft_Corner].fY = r[SkRRect::kLowerRight_Corner].fY;
488
489 rrect.setRectRadii(SkRect::MakeWH(w, h), r);
490 } else {
491 rrect.setRectXY(SkRect::MakeWH(w, h), r[SkRRect::kUpperLeft_Corner].fX,
492 r[SkRRect::kUpperLeft_Corner].fY);
493 }
494 std::unique_ptr<GrFragmentProcessor> fp = d->inputFP();
495 bool success;
496 do {
497 GrClipEdgeType et = (GrClipEdgeType)d->fRandom->nextULessThan(kGrClipEdgeTypeCnt);
498 std::tie(success, fp) = GrRRectEffect::Make(std::move(fp), et, rrect,
499 *d->caps()->shaderCaps());
500 } while (!success);
501 return fp;
502 }
503 #endif
504
505 //////////////////////////////////////////////////////////////////////////////
506
507 class EllipticalRRectEffect::Impl : public ProgramImpl {
508 public:
509 void emitCode(EmitArgs&) override;
510
511 private:
512 void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
513
514 GrGLSLProgramDataManager::UniformHandle fInnerRectUniform;
515 GrGLSLProgramDataManager::UniformHandle fInvRadiiSqdUniform;
516 GrGLSLProgramDataManager::UniformHandle fScaleUniform;
517 SkRRect fPrevRRect;
518 };
519
emitCode(EmitArgs& args)520 void EllipticalRRectEffect::Impl::emitCode(EmitArgs& args) {
521 const EllipticalRRectEffect& erre = args.fFp.cast<EllipticalRRectEffect>();
522 GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
523 const char *rectName;
524 // The inner rect is the rrect bounds inset by the x/y radii
525 fInnerRectUniform = uniformHandler->addUniform(&erre, kFragment_GrShaderFlag, kFloat4_GrSLType,
526 "innerRect", &rectName);
527
528 GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
529 // At each quarter-ellipse corner we compute a vector that is the offset of the fragment pos
530 // to the ellipse center. The vector is pinned in x and y to be in the quarter-plane relevant
531 // to that corner. This means that points near the interior near the rrect top edge will have
532 // a vector that points straight up for both the TL left and TR corners. Computing an
533 // alpha from this vector at either the TR or TL corner will give the correct result. Similarly,
534 // fragments near the other three edges will get the correct AA. Fragments in the interior of
535 // the rrect will have a (0,0) vector at all four corners. So long as the radii > 0.5 they will
536 // correctly produce an alpha value of 1 at all four corners. We take the min of all the alphas.
537 //
538 // The code below is a simplified version of the above that performs maxs on the vector
539 // components before computing distances and alpha values so that only one distance computation
540 // need be computed to determine the min alpha.
541 fragBuilder->codeAppendf("float2 dxy0 = %s.LT - sk_FragCoord.xy;", rectName);
542 fragBuilder->codeAppendf("float2 dxy1 = sk_FragCoord.xy - %s.RB;", rectName);
543
544 // If we're on a device where float != fp32 then we'll do the distance computation in a space
545 // that is normalized by the largest radius. The scale uniform will be scale, 1/scale. The
546 // radii uniform values are already in this normalized space.
547 const char* scaleName = nullptr;
548 if (!args.fShaderCaps->floatIs32Bits()) {
549 fScaleUniform = uniformHandler->addUniform(&erre, kFragment_GrShaderFlag, kHalf2_GrSLType,
550 "scale", &scaleName);
551 }
552
553 // The uniforms with the inv squared radii are highp to prevent underflow.
554 switch (erre.fRRect.getType()) {
555 case SkRRect::kSimple_Type: {
556 const char *invRadiiXYSqdName;
557 fInvRadiiSqdUniform = uniformHandler->addUniform(&erre,
558 kFragment_GrShaderFlag,
559 kFloat2_GrSLType,
560 "invRadiiXY",
561 &invRadiiXYSqdName);
562 fragBuilder->codeAppend("float2 dxy = max(max(dxy0, dxy1), 0.0);");
563 if (scaleName) {
564 fragBuilder->codeAppendf("dxy *= %s.y;", scaleName);
565 }
566 // Z is the x/y offsets divided by squared radii.
567 fragBuilder->codeAppendf("float2 Z = dxy * %s.xy;", invRadiiXYSqdName);
568 break;
569 }
570 case SkRRect::kNinePatch_Type: {
571 const char *invRadiiLTRBSqdName;
572 fInvRadiiSqdUniform = uniformHandler->addUniform(&erre,
573 kFragment_GrShaderFlag,
574 kFloat4_GrSLType,
575 "invRadiiLTRB",
576 &invRadiiLTRBSqdName);
577 if (scaleName) {
578 fragBuilder->codeAppendf("dxy0 *= %s.y;", scaleName);
579 fragBuilder->codeAppendf("dxy1 *= %s.y;", scaleName);
580 }
581 fragBuilder->codeAppend("float2 dxy = max(max(dxy0, dxy1), 0.0);");
582 // Z is the x/y offsets divided by squared radii. We only care about the (at most) one
583 // corner where both the x and y offsets are positive, hence the maxes. (The inverse
584 // squared radii will always be positive.)
585 fragBuilder->codeAppendf("float2 Z = max(max(dxy0 * %s.xy, dxy1 * %s.zw), 0.0);",
586 invRadiiLTRBSqdName, invRadiiLTRBSqdName);
587
588 break;
589 }
590 default:
591 SK_ABORT("RRect should always be simple or nine-patch.");
592 }
593 // implicit is the evaluation of (x/a)^2 + (y/b)^2 - 1.
594 fragBuilder->codeAppend("half implicit = half(dot(Z, dxy) - 1.0);");
595 // grad_dot is the squared length of the gradient of the implicit.
596 fragBuilder->codeAppend("half grad_dot = half(4.0 * dot(Z, Z));");
597 // avoid calling inversesqrt on zero.
598 fragBuilder->codeAppend("grad_dot = max(grad_dot, 1.0e-4);");
599 fragBuilder->codeAppend("half approx_dist = implicit * half(inversesqrt(grad_dot));");
600 if (scaleName) {
601 fragBuilder->codeAppendf("approx_dist *= %s.x;", scaleName);
602 }
603
604 if (erre.fEdgeType == GrClipEdgeType::kFillAA) {
605 fragBuilder->codeAppend("half alpha = clamp(0.5 - approx_dist, 0.0, 1.0);");
606 } else {
607 fragBuilder->codeAppend("half alpha = clamp(0.5 + approx_dist, 0.0, 1.0);");
608 }
609
610 SkString inputSample = this->invokeChild(/*childIndex=*/0, args);
611
612 fragBuilder->codeAppendf("return %s * alpha;", inputSample.c_str());
613 }
614
onSetData(const GrGLSLProgramDataManager& pdman, const GrFragmentProcessor& effect)615 void EllipticalRRectEffect::Impl::onSetData(const GrGLSLProgramDataManager& pdman,
616 const GrFragmentProcessor& effect) {
617 const EllipticalRRectEffect& erre = effect.cast<EllipticalRRectEffect>();
618 const SkRRect& rrect = erre.fRRect;
619 // If we're using a scale factor to work around precision issues, choose the largest radius
620 // as the scale factor. The inv radii need to be pre-adjusted by the scale factor.
621 if (rrect != fPrevRRect) {
622 SkRect rect = rrect.getBounds();
623 const SkVector& r0 = rrect.radii(SkRRect::kUpperLeft_Corner);
624 SkASSERT(r0.fX >= kRadiusMin);
625 SkASSERT(r0.fY >= kRadiusMin);
626 switch (rrect.getType()) {
627 case SkRRect::kSimple_Type:
628 rect.inset(r0.fX, r0.fY);
629 if (fScaleUniform.isValid()) {
630 if (r0.fX > r0.fY) {
631 pdman.set2f(fInvRadiiSqdUniform, 1.f, (r0.fX * r0.fX) / (r0.fY * r0.fY));
632 pdman.set2f(fScaleUniform, r0.fX, 1.f / r0.fX);
633 } else {
634 pdman.set2f(fInvRadiiSqdUniform, (r0.fY * r0.fY) / (r0.fX * r0.fX), 1.f);
635 pdman.set2f(fScaleUniform, r0.fY, 1.f / r0.fY);
636 }
637 } else {
638 pdman.set2f(fInvRadiiSqdUniform, 1.f / (r0.fX * r0.fX),
639 1.f / (r0.fY * r0.fY));
640 }
641 break;
642 case SkRRect::kNinePatch_Type: {
643 const SkVector& r1 = rrect.radii(SkRRect::kLowerRight_Corner);
644 SkASSERT(r1.fX >= kRadiusMin);
645 SkASSERT(r1.fY >= kRadiusMin);
646 rect.fLeft += r0.fX;
647 rect.fTop += r0.fY;
648 rect.fRight -= r1.fX;
649 rect.fBottom -= r1.fY;
650 if (fScaleUniform.isValid()) {
651 float scale = std::max(std::max(r0.fX, r0.fY), std::max(r1.fX, r1.fY));
652 float scaleSqd = scale * scale;
653 pdman.set4f(fInvRadiiSqdUniform, scaleSqd / (r0.fX * r0.fX),
654 scaleSqd / (r0.fY * r0.fY),
655 scaleSqd / (r1.fX * r1.fX),
656 scaleSqd / (r1.fY * r1.fY));
657 pdman.set2f(fScaleUniform, scale, 1.f / scale);
658 } else {
659 pdman.set4f(fInvRadiiSqdUniform, 1.f / (r0.fX * r0.fX),
660 1.f / (r0.fY * r0.fY),
661 1.f / (r1.fX * r1.fX),
662 1.f / (r1.fY * r1.fY));
663 }
664 break;
665 }
666 default:
667 SK_ABORT("RRect should always be simple or nine-patch.");
668 }
669 pdman.set4f(fInnerRectUniform, rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
670 fPrevRRect = rrect;
671 }
672 }
673
674 ////////////////////////////////////////////////////////////////////////////////////////////////////
675
getShaderDfxInfo() const676 SkString EllipticalRRectEffect::getShaderDfxInfo() const {
677 SkString format;
678 format.printf("ShaderDfx_EllipticalRRectEffect_%d_%d", fRRect.getType(), fEdgeType);
679 return format;
680 }
681
onAddToKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const682 void EllipticalRRectEffect::onAddToKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const {
683 static_assert((int)GrClipEdgeType::kLast < (1 << 3));
684 b->add32(fRRect.getType() | static_cast<int>(fEdgeType) << 3);
685 }
686
onMakeProgramImpl() const687 std::unique_ptr<GrFragmentProcessor::ProgramImpl> EllipticalRRectEffect::onMakeProgramImpl() const {
688 return std::make_unique<Impl>();
689 }
690
691 //////////////////////////////////////////////////////////////////////////////
692
Make(std::unique_ptr<GrFragmentProcessor> inputFP, GrClipEdgeType edgeType, const SkRRect& rrect, const GrShaderCaps& caps)693 GrFPResult GrRRectEffect::Make(std::unique_ptr<GrFragmentProcessor> inputFP,
694 GrClipEdgeType edgeType, const SkRRect& rrect,
695 const GrShaderCaps& caps) {
696 if (rrect.isRect()) {
697 auto fp = GrFragmentProcessor::Rect(std::move(inputFP), edgeType, rrect.getBounds());
698 return GrFPSuccess(std::move(fp));
699 }
700
701 if (rrect.isOval()) {
702 return GrOvalEffect::Make(std::move(inputFP), edgeType, rrect.getBounds(), caps);
703 }
704
705 if (rrect.isSimple()) {
706 if (SkRRectPriv::GetSimpleRadii(rrect).fX < kRadiusMin ||
707 SkRRectPriv::GetSimpleRadii(rrect).fY < kRadiusMin) {
708 // In this case the corners are extremely close to rectangular and we collapse the
709 // clip to a rectangular clip.
710 auto fp = GrFragmentProcessor::Rect(std::move(inputFP), edgeType, rrect.getBounds());
711 return GrFPSuccess(std::move(fp));
712 }
713 if (SkRRectPriv::GetSimpleRadii(rrect).fX == SkRRectPriv::GetSimpleRadii(rrect).fY) {
714 return CircularRRectEffect::Make(std::move(inputFP), edgeType,
715 CircularRRectEffect::kAll_CornerFlags, rrect);
716 } else {
717 return EllipticalRRectEffect::Make(std::move(inputFP), edgeType, rrect);
718 }
719 }
720
721 if (rrect.isComplex() || rrect.isNinePatch()) {
722 // Check for the "tab" cases - two adjacent circular corners and two square corners.
723 SkScalar circularRadius = 0;
724 uint32_t cornerFlags = 0;
725
726 SkVector radii[4];
727 bool squashedRadii = false;
728 for (int c = 0; c < 4; ++c) {
729 radii[c] = rrect.radii((SkRRect::Corner)c);
730 SkASSERT((0 == radii[c].fX) == (0 == radii[c].fY));
731 if (0 == radii[c].fX) {
732 // The corner is square, so no need to squash or flag as circular.
733 continue;
734 }
735 if (radii[c].fX < kRadiusMin || radii[c].fY < kRadiusMin) {
736 radii[c].set(0, 0);
737 squashedRadii = true;
738 continue;
739 }
740 if (radii[c].fX != radii[c].fY) {
741 cornerFlags = ~0U;
742 break;
743 }
744 if (!cornerFlags) {
745 circularRadius = radii[c].fX;
746 cornerFlags = 1 << c;
747 } else {
748 if (radii[c].fX != circularRadius) {
749 cornerFlags = ~0U;
750 break;
751 }
752 cornerFlags |= 1 << c;
753 }
754 }
755
756 switch (cornerFlags) {
757 case CircularRRectEffect::kAll_CornerFlags:
758 // This rrect should have been caught in the simple case above. Though, it would
759 // be correctly handled in the fallthrough code.
760 SkASSERT(false);
761 [[fallthrough]];
762 case CircularRRectEffect::kTopLeft_CornerFlag:
763 case CircularRRectEffect::kTopRight_CornerFlag:
764 case CircularRRectEffect::kBottomRight_CornerFlag:
765 case CircularRRectEffect::kBottomLeft_CornerFlag:
766 case CircularRRectEffect::kLeft_CornerFlags:
767 case CircularRRectEffect::kTop_CornerFlags:
768 case CircularRRectEffect::kRight_CornerFlags:
769 case CircularRRectEffect::kBottom_CornerFlags: {
770 SkTCopyOnFirstWrite<SkRRect> rr(rrect);
771 if (squashedRadii) {
772 rr.writable()->setRectRadii(rrect.getBounds(), radii);
773 }
774 return CircularRRectEffect::Make(std::move(inputFP), edgeType, cornerFlags, *rr);
775 }
776 case CircularRRectEffect::kNone_CornerFlags: {
777 auto fp =
778 GrFragmentProcessor::Rect(std::move(inputFP), edgeType, rrect.getBounds());
779 return GrFPSuccess(std::move(fp));
780 }
781 default: {
782 const SkVector ul = rrect.radii(SkRRect::kUpperLeft_Corner);
783 const SkVector lr = rrect.radii(SkRRect::kLowerRight_Corner);
784 if (rrect.isNinePatch() &&
785 ul.fX >= kRadiusMin &&
786 ul.fY >= kRadiusMin &&
787 lr.fX >= kRadiusMin &&
788 lr.fY >= kRadiusMin) {
789 return EllipticalRRectEffect::Make(std::move(inputFP), edgeType, rrect);
790 }
791 return GrFPFailure(std::move(inputFP));
792 }
793 }
794 }
795 return GrFPFailure(std::move(inputFP));
796 }
797