blob: 9c9dc313204eb52549d29560028c0bf339e0cf1f [file] [log] [blame]
commit-bot@chromium.orgc2f78242014-02-19 15:18:05 +00001/*
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
Mike Kleinc0bd9f92019-04-23 12:05:21 -05008#include "src/gpu/effects/GrRRectEffect.h"
commit-bot@chromium.orgc2f78242014-02-19 15:18:05 +00009
Mike Kleinc0bd9f92019-04-23 12:05:21 -050010#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/GrGLSLFragmentProcessor.h"
17#include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"
18#include "src/gpu/glsl/GrGLSLProgramDataManager.h"
19#include "src/gpu/glsl/GrGLSLUniformHandler.h"
commit-bot@chromium.orgc2f78242014-02-19 15:18:05 +000020
commit-bot@chromium.org2a8be902014-03-24 19:24:59 +000021// The effects defined here only handle rrect radii >= kRadiusMin.
22static const SkScalar kRadiusMin = SK_ScalarHalf;
23
24//////////////////////////////////////////////////////////////////////////////
25
joshualittb0a8a372014-09-23 09:50:21 -070026class CircularRRectEffect : public GrFragmentProcessor {
commit-bot@chromium.orge5280892014-02-21 17:52:29 +000027public:
skia.committer@gmail.comf1f66c02014-03-05 03:02:06 +000028
commit-bot@chromium.orgdd584222014-03-10 16:08:22 +000029 enum CornerFlags {
30 kTopLeft_CornerFlag = (1 << SkRRect::kUpperLeft_Corner),
31 kTopRight_CornerFlag = (1 << SkRRect::kUpperRight_Corner),
32 kBottomRight_CornerFlag = (1 << SkRRect::kLowerRight_Corner),
33 kBottomLeft_CornerFlag = (1 << SkRRect::kLowerLeft_Corner),
34
35 kLeft_CornerFlags = kTopLeft_CornerFlag | kBottomLeft_CornerFlag,
36 kTop_CornerFlags = kTopLeft_CornerFlag | kTopRight_CornerFlag,
37 kRight_CornerFlags = kTopRight_CornerFlag | kBottomRight_CornerFlag,
38 kBottom_CornerFlags = kBottomLeft_CornerFlag | kBottomRight_CornerFlag,
39
40 kAll_CornerFlags = kTopLeft_CornerFlag | kTopRight_CornerFlag |
41 kBottomLeft_CornerFlag | kBottomRight_CornerFlag,
42
commit-bot@chromium.org2a8be902014-03-24 19:24:59 +000043 kNone_CornerFlags = 0
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +000044 };
45
commit-bot@chromium.orgdd584222014-03-10 16:08:22 +000046 // The flags are used to indicate which corners are circluar (unflagged corners are assumed to
47 // be square).
Ethan Nicholas0f3c7322017-11-09 14:51:17 -050048 static std::unique_ptr<GrFragmentProcessor> Make(GrClipEdgeType,
Brian Salomonaff329b2017-08-11 09:40:37 -040049 uint32_t circularCornerFlags, const SkRRect&);
commit-bot@chromium.orge5280892014-02-21 17:52:29 +000050
Brian Salomond3b65972017-03-22 12:05:03 -040051 ~CircularRRectEffect() override {}
joshualitteb2a6762014-12-04 11:35:33 -080052
mtklein36352bf2015-03-25 18:17:31 -070053 const char* name() const override { return "CircularRRect"; }
joshualitteb2a6762014-12-04 11:35:33 -080054
Brian Salomonaff329b2017-08-11 09:40:37 -040055 std::unique_ptr<GrFragmentProcessor> clone() const override;
Brian Salomon1a2a7ab2017-07-26 13:11:51 -040056
commit-bot@chromium.orge5280892014-02-21 17:52:29 +000057 const SkRRect& getRRect() const { return fRRect; }
58
commit-bot@chromium.orgdd584222014-03-10 16:08:22 +000059 uint32_t getCircularCornerFlags() const { return fCircularCornerFlags; }
skia.committer@gmail.com06acb582014-03-06 03:02:32 +000060
Ethan Nicholas0f3c7322017-11-09 14:51:17 -050061 GrClipEdgeType getEdgeType() const { return fEdgeType; }
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +000062
commit-bot@chromium.orge5280892014-02-21 17:52:29 +000063private:
Ethan Nicholas0f3c7322017-11-09 14:51:17 -050064 CircularRRectEffect(GrClipEdgeType, uint32_t circularCornerFlags, const SkRRect&);
commit-bot@chromium.orge5280892014-02-21 17:52:29 +000065
egdaniel57d3b032015-11-13 11:57:27 -080066 GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
wangyixb1daa862015-08-18 11:29:31 -070067
Brian Salomon94efbf52016-11-29 13:43:05 -050068 void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
wangyix4b3050b2015-08-04 07:59:37 -070069
mtklein36352bf2015-03-25 18:17:31 -070070 bool onIsEqual(const GrFragmentProcessor& other) const override;
commit-bot@chromium.orge5280892014-02-21 17:52:29 +000071
joshualittb0a8a372014-09-23 09:50:21 -070072 SkRRect fRRect;
Ethan Nicholas0f3c7322017-11-09 14:51:17 -050073 GrClipEdgeType fEdgeType;
joshualittb0a8a372014-09-23 09:50:21 -070074 uint32_t fCircularCornerFlags;
commit-bot@chromium.orge5280892014-02-21 17:52:29 +000075
Brian Salomon0c26a9d2017-07-06 10:09:38 -040076 GR_DECLARE_FRAGMENT_PROCESSOR_TEST
commit-bot@chromium.orge5280892014-02-21 17:52:29 +000077
joshualittb0a8a372014-09-23 09:50:21 -070078 typedef GrFragmentProcessor INHERITED;
commit-bot@chromium.orge5280892014-02-21 17:52:29 +000079};
80
Ethan Nicholas0f3c7322017-11-09 14:51:17 -050081std::unique_ptr<GrFragmentProcessor> CircularRRectEffect::Make(GrClipEdgeType edgeType,
Brian Salomonaff329b2017-08-11 09:40:37 -040082 uint32_t circularCornerFlags,
83 const SkRRect& rrect) {
Ethan Nicholas1706f842017-11-10 11:58:19 -050084 if (GrClipEdgeType::kFillAA != edgeType && GrClipEdgeType::kInverseFillAA != edgeType) {
halcanary96fcdcc2015-08-27 07:41:13 -070085 return nullptr;
commit-bot@chromium.org3eedb802014-03-28 15:58:31 +000086 }
Brian Salomonaff329b2017-08-11 09:40:37 -040087 return std::unique_ptr<GrFragmentProcessor>(
88 new CircularRRectEffect(edgeType, circularCornerFlags, rrect));
commit-bot@chromium.orge5280892014-02-21 17:52:29 +000089}
90
Ethan Nicholas0f3c7322017-11-09 14:51:17 -050091CircularRRectEffect::CircularRRectEffect(GrClipEdgeType edgeType, uint32_t circularCornerFlags,
joshualittb0a8a372014-09-23 09:50:21 -070092 const SkRRect& rrect)
Ethan Nicholasabff9562017-10-09 10:54:08 -040093 : INHERITED(kCircularRRectEffect_ClassID, kCompatibleWithCoverageAsAlpha_OptimizationFlag)
Brian Salomon587e08f2017-01-27 10:59:27 -050094 , fRRect(rrect)
95 , fEdgeType(edgeType)
96 , fCircularCornerFlags(circularCornerFlags) {
commit-bot@chromium.orge5280892014-02-21 17:52:29 +000097}
98
Brian Salomonaff329b2017-08-11 09:40:37 -040099std::unique_ptr<GrFragmentProcessor> CircularRRectEffect::clone() const {
100 return std::unique_ptr<GrFragmentProcessor>(
Brian Salomon1a2a7ab2017-07-26 13:11:51 -0400101 new CircularRRectEffect(fEdgeType, fCircularCornerFlags, fRRect));
102}
103
bsalomon0e08fc12014-10-15 08:19:04 -0700104bool CircularRRectEffect::onIsEqual(const GrFragmentProcessor& other) const {
joshualitt49586be2014-09-16 08:21:41 -0700105 const CircularRRectEffect& crre = other.cast<CircularRRectEffect>();
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000106 // The corner flags are derived from fRRect, so no need to check them.
107 return fEdgeType == crre.fEdgeType && fRRect == crre.fRRect;
commit-bot@chromium.orge5280892014-02-21 17:52:29 +0000108}
commit-bot@chromium.orgc2f78242014-02-19 15:18:05 +0000109
110//////////////////////////////////////////////////////////////////////////////
commit-bot@chromium.orge5280892014-02-21 17:52:29 +0000111
joshualittb0a8a372014-09-23 09:50:21 -0700112GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircularRRectEffect);
commit-bot@chromium.orge5280892014-02-21 17:52:29 +0000113
Hal Canary6f6961e2017-01-31 13:50:44 -0500114#if GR_TEST_UTILS
Brian Salomonaff329b2017-08-11 09:40:37 -0400115std::unique_ptr<GrFragmentProcessor> CircularRRectEffect::TestCreate(GrProcessorTestData* d) {
joshualitt0067ff52015-07-08 14:26:19 -0700116 SkScalar w = d->fRandom->nextRangeScalar(20.f, 1000.f);
117 SkScalar h = d->fRandom->nextRangeScalar(20.f, 1000.f);
118 SkScalar r = d->fRandom->nextRangeF(kRadiusMin, 9.f);
commit-bot@chromium.orge5280892014-02-21 17:52:29 +0000119 SkRRect rrect;
120 rrect.setRectXY(SkRect::MakeWH(w, h), r, r);
Brian Salomonaff329b2017-08-11 09:40:37 -0400121 std::unique_ptr<GrFragmentProcessor> fp;
commit-bot@chromium.orgcabf4b22014-03-05 18:27:43 +0000122 do {
Ethan Nicholas0f3c7322017-11-09 14:51:17 -0500123 GrClipEdgeType et =
Ethan Nicholas1706f842017-11-10 11:58:19 -0500124 (GrClipEdgeType)d->fRandom->nextULessThan(kGrClipEdgeTypeCnt);
Ethan Nicholaseace9352018-10-15 20:09:54 +0000125 fp = GrRRectEffect::Make(et, rrect, *d->caps()->shaderCaps());
halcanary96fcdcc2015-08-27 07:41:13 -0700126 } while (nullptr == fp);
joshualittb0a8a372014-09-23 09:50:21 -0700127 return fp;
commit-bot@chromium.orge5280892014-02-21 17:52:29 +0000128}
Hal Canary6f6961e2017-01-31 13:50:44 -0500129#endif
commit-bot@chromium.orge5280892014-02-21 17:52:29 +0000130
131//////////////////////////////////////////////////////////////////////////////
132
egdaniel64c47282015-11-13 06:54:19 -0800133class GLCircularRRectEffect : public GrGLSLFragmentProcessor {
commit-bot@chromium.orgc2f78242014-02-19 15:18:05 +0000134public:
Brian Salomon0a241ce2017-12-15 11:31:05 -0500135 GLCircularRRectEffect() = default;
commit-bot@chromium.orgc2f78242014-02-19 15:18:05 +0000136
wangyix7c157a92015-07-22 15:08:53 -0700137 virtual void emitCode(EmitArgs&) override;
commit-bot@chromium.orgc2f78242014-02-19 15:18:05 +0000138
Brian Salomon94efbf52016-11-29 13:43:05 -0500139 static inline void GenKey(const GrProcessor&, const GrShaderCaps&, GrProcessorKeyBuilder*);
commit-bot@chromium.orgc2f78242014-02-19 15:18:05 +0000140
wangyixb1daa862015-08-18 11:29:31 -0700141protected:
Brian Salomonab015ef2017-04-04 10:15:51 -0400142 void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
commit-bot@chromium.orgc2f78242014-02-19 15:18:05 +0000143
144private:
egdaniel018fb622015-10-28 07:26:40 -0700145 GrGLSLProgramDataManager::UniformHandle fInnerRectUniform;
146 GrGLSLProgramDataManager::UniformHandle fRadiusPlusHalfUniform;
robertphillipsbf536af2016-02-04 06:11:53 -0800147 SkRRect fPrevRRect;
egdaniel64c47282015-11-13 06:54:19 -0800148 typedef GrGLSLFragmentProcessor INHERITED;
commit-bot@chromium.orgc2f78242014-02-19 15:18:05 +0000149};
150
wangyix7c157a92015-07-22 15:08:53 -0700151void GLCircularRRectEffect::emitCode(EmitArgs& args) {
152 const CircularRRectEffect& crre = args.fFp.cast<CircularRRectEffect>();
egdaniel7ea439b2015-12-03 09:20:44 -0800153 GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
commit-bot@chromium.orgc2f78242014-02-19 15:18:05 +0000154 const char *rectName;
155 const char *radiusPlusHalfName;
commit-bot@chromium.orgc5c748c2014-03-11 15:54:51 +0000156 // The inner rect is the rrect bounds inset by the radius. Its left, top, right, and bottom
157 // edges correspond to components x, y, z, and w, respectively. When a side of the rrect has
158 // only rectangular corners, that side's value corresponds to the rect edge's value outset by
159 // half a pixel.
Robert Phillips0cace8e2019-01-03 12:42:43 -0500160 fInnerRectUniform = uniformHandler->addUniform(kFragment_GrShaderFlag, kFloat4_GrSLType,
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400161 "innerRect", &rectName);
bsalomoncd074912015-12-09 10:33:51 -0800162 // x is (r + .5) and y is 1/(r + .5)
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400163 fRadiusPlusHalfUniform = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf2_GrSLType,
164 "radiusPlusHalf", &radiusPlusHalfName);
joshualitt30ba4362014-08-21 20:18:45 -0700165
Chris Dalton47c8ed32017-11-15 18:27:09 -0700166 // If we're on a device where float != fp32 then the length calculation could overflow.
bsalomoncd074912015-12-09 10:33:51 -0800167 SkString clampedCircleDistance;
Chris Dalton47c8ed32017-11-15 18:27:09 -0700168 if (!args.fShaderCaps->floatIs32Bits()) {
Ethan Nicholase1f55022019-02-05 17:17:40 -0500169 clampedCircleDistance.printf("saturate(%s.x * (1.0 - length(dxy * %s.y)))",
bsalomoncd074912015-12-09 10:33:51 -0800170 radiusPlusHalfName, radiusPlusHalfName);
171 } else {
Ethan Nicholase1f55022019-02-05 17:17:40 -0500172 clampedCircleDistance.printf("saturate(%s.x - length(dxy))", radiusPlusHalfName);
bsalomoncd074912015-12-09 10:33:51 -0800173 }
174
cdalton85285412016-02-18 12:37:07 -0800175 GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
commit-bot@chromium.orgc2f78242014-02-19 15:18:05 +0000176 // At each quarter-circle corner we compute a vector that is the offset of the fragment position
177 // from the circle center. The vector is pinned in x and y to be in the quarter-plane relevant
178 // to that corner. This means that points near the interior near the rrect top edge will have
179 // a vector that points straight up for both the TL left and TR corners. Computing an
180 // alpha from this vector at either the TR or TL corner will give the correct result. Similarly,
181 // fragments near the other three edges will get the correct AA. Fragments in the interior of
182 // the rrect will have a (0,0) vector at all four corners. So long as the radius > 0.5 they will
183 // correctly produce an alpha value of 1 at all four corners. We take the min of all the alphas.
184 // The code below is a simplified version of the above that performs maxs on the vector
185 // components before computing distances and alpha values so that only one distance computation
186 // need be computed to determine the min alpha.
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +0000187 //
188 // For the cases where one half of the rrect is rectangular we drop one of the x or y
189 // computations, compute a separate rect edge alpha for the rect side, and mul the two computed
190 // alphas together.
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000191 switch (crre.getCircularCornerFlags()) {
192 case CircularRRectEffect::kAll_CornerFlags:
Chris Dalton47c8ed32017-11-15 18:27:09 -0700193 fragBuilder->codeAppendf("float2 dxy0 = %s.xy - sk_FragCoord.xy;", rectName);
194 fragBuilder->codeAppendf("float2 dxy1 = sk_FragCoord.xy - %s.zw;", rectName);
195 fragBuilder->codeAppend("float2 dxy = max(max(dxy0, dxy1), 0.0);");
Ethan Nicholase1f55022019-02-05 17:17:40 -0500196 fragBuilder->codeAppendf("half alpha = half(%s);", clampedCircleDistance.c_str());
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +0000197 break;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000198 case CircularRRectEffect::kTopLeft_CornerFlag:
Chris Dalton47c8ed32017-11-15 18:27:09 -0700199 fragBuilder->codeAppendf("float2 dxy = max(%s.xy - sk_FragCoord.xy, 0.0);",
Ethan Nicholas38657112017-02-09 17:01:22 -0500200 rectName);
Ethan Nicholase1f55022019-02-05 17:17:40 -0500201 fragBuilder->codeAppendf("half rightAlpha = half(saturate(%s.z - sk_FragCoord.x));",
Ethan Nicholas38657112017-02-09 17:01:22 -0500202 rectName);
Ethan Nicholase1f55022019-02-05 17:17:40 -0500203 fragBuilder->codeAppendf("half bottomAlpha = half(saturate(%s.w - sk_FragCoord.y));",
Ethan Nicholas38657112017-02-09 17:01:22 -0500204 rectName);
Ethan Nicholase1f55022019-02-05 17:17:40 -0500205 fragBuilder->codeAppendf("half alpha = bottomAlpha * rightAlpha * half(%s);",
bsalomoncd074912015-12-09 10:33:51 -0800206 clampedCircleDistance.c_str());
commit-bot@chromium.orgc5c748c2014-03-11 15:54:51 +0000207 break;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000208 case CircularRRectEffect::kTopRight_CornerFlag:
Chris Dalton47c8ed32017-11-15 18:27:09 -0700209 fragBuilder->codeAppendf("float2 dxy = max(float2(sk_FragCoord.x - %s.z, "
210 "%s.y - sk_FragCoord.y), 0.0);",
Ethan Nicholas38657112017-02-09 17:01:22 -0500211 rectName, rectName);
Ethan Nicholase1f55022019-02-05 17:17:40 -0500212 fragBuilder->codeAppendf("half leftAlpha = half(saturate(sk_FragCoord.x - %s.x));",
Ethan Nicholas38657112017-02-09 17:01:22 -0500213 rectName);
Ethan Nicholase1f55022019-02-05 17:17:40 -0500214 fragBuilder->codeAppendf("half bottomAlpha = half(saturate(%s.w - sk_FragCoord.y));",
Ethan Nicholas38657112017-02-09 17:01:22 -0500215 rectName);
Ethan Nicholase1f55022019-02-05 17:17:40 -0500216 fragBuilder->codeAppendf("half alpha = bottomAlpha * leftAlpha * half(%s);",
bsalomoncd074912015-12-09 10:33:51 -0800217 clampedCircleDistance.c_str());
commit-bot@chromium.orgc5c748c2014-03-11 15:54:51 +0000218 break;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000219 case CircularRRectEffect::kBottomRight_CornerFlag:
Chris Dalton47c8ed32017-11-15 18:27:09 -0700220 fragBuilder->codeAppendf("float2 dxy = max(sk_FragCoord.xy - %s.zw, 0.0);",
Ethan Nicholas38657112017-02-09 17:01:22 -0500221 rectName);
Ethan Nicholase1f55022019-02-05 17:17:40 -0500222 fragBuilder->codeAppendf("half leftAlpha = half(saturate(sk_FragCoord.x - %s.x));",
Ethan Nicholas38657112017-02-09 17:01:22 -0500223 rectName);
Ethan Nicholase1f55022019-02-05 17:17:40 -0500224 fragBuilder->codeAppendf("half topAlpha = half(saturate(sk_FragCoord.y - %s.y));",
Ethan Nicholas38657112017-02-09 17:01:22 -0500225 rectName);
Ethan Nicholase1f55022019-02-05 17:17:40 -0500226 fragBuilder->codeAppendf("half alpha = topAlpha * leftAlpha * half(%s);",
bsalomoncd074912015-12-09 10:33:51 -0800227 clampedCircleDistance.c_str());
commit-bot@chromium.orgc5c748c2014-03-11 15:54:51 +0000228 break;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000229 case CircularRRectEffect::kBottomLeft_CornerFlag:
Chris Dalton47c8ed32017-11-15 18:27:09 -0700230 fragBuilder->codeAppendf("float2 dxy = max(float2(%s.x - sk_FragCoord.x, "
231 "sk_FragCoord.y - %s.w), 0.0);",
Ethan Nicholas38657112017-02-09 17:01:22 -0500232 rectName, rectName);
Ethan Nicholase1f55022019-02-05 17:17:40 -0500233 fragBuilder->codeAppendf("half rightAlpha = half(saturate(%s.z - sk_FragCoord.x));",
Ethan Nicholas38657112017-02-09 17:01:22 -0500234 rectName);
Ethan Nicholase1f55022019-02-05 17:17:40 -0500235 fragBuilder->codeAppendf("half topAlpha = half(saturate(sk_FragCoord.y - %s.y));",
Ethan Nicholas38657112017-02-09 17:01:22 -0500236 rectName);
Ethan Nicholase1f55022019-02-05 17:17:40 -0500237 fragBuilder->codeAppendf("half alpha = topAlpha * rightAlpha * half(%s);",
bsalomoncd074912015-12-09 10:33:51 -0800238 clampedCircleDistance.c_str());
commit-bot@chromium.orgc5c748c2014-03-11 15:54:51 +0000239 break;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000240 case CircularRRectEffect::kLeft_CornerFlags:
Chris Dalton47c8ed32017-11-15 18:27:09 -0700241 fragBuilder->codeAppendf("float2 dxy0 = %s.xy - sk_FragCoord.xy;", rectName);
242 fragBuilder->codeAppendf("float dy1 = sk_FragCoord.y - %s.w;", rectName);
243 fragBuilder->codeAppend("float2 dxy = max(float2(dxy0.x, max(dxy0.y, dy1)), 0.0);");
Ethan Nicholase1f55022019-02-05 17:17:40 -0500244 fragBuilder->codeAppendf("half rightAlpha = half(saturate(%s.z - sk_FragCoord.x));",
Ethan Nicholas38657112017-02-09 17:01:22 -0500245 rectName);
Ethan Nicholase1f55022019-02-05 17:17:40 -0500246 fragBuilder->codeAppendf("half alpha = rightAlpha * half(%s);",
bsalomoncd074912015-12-09 10:33:51 -0800247 clampedCircleDistance.c_str());
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +0000248 break;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000249 case CircularRRectEffect::kTop_CornerFlags:
Chris Dalton47c8ed32017-11-15 18:27:09 -0700250 fragBuilder->codeAppendf("float2 dxy0 = %s.xy - sk_FragCoord.xy;", rectName);
251 fragBuilder->codeAppendf("float dx1 = sk_FragCoord.x - %s.z;", rectName);
252 fragBuilder->codeAppend("float2 dxy = max(float2(max(dxy0.x, dx1), dxy0.y), 0.0);");
Ethan Nicholase1f55022019-02-05 17:17:40 -0500253 fragBuilder->codeAppendf("half bottomAlpha = half(saturate(%s.w - sk_FragCoord.y));",
Ethan Nicholas38657112017-02-09 17:01:22 -0500254 rectName);
Ethan Nicholase1f55022019-02-05 17:17:40 -0500255 fragBuilder->codeAppendf("half alpha = bottomAlpha * half(%s);",
bsalomoncd074912015-12-09 10:33:51 -0800256 clampedCircleDistance.c_str());
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +0000257 break;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000258 case CircularRRectEffect::kRight_CornerFlags:
Chris Dalton47c8ed32017-11-15 18:27:09 -0700259 fragBuilder->codeAppendf("float dy0 = %s.y - sk_FragCoord.y;", rectName);
260 fragBuilder->codeAppendf("float2 dxy1 = sk_FragCoord.xy - %s.zw;", rectName);
261 fragBuilder->codeAppend("float2 dxy = max(float2(dxy1.x, max(dy0, dxy1.y)), 0.0);");
Ethan Nicholase1f55022019-02-05 17:17:40 -0500262 fragBuilder->codeAppendf("half leftAlpha = half(saturate(sk_FragCoord.x - %s.x));",
Ethan Nicholas38657112017-02-09 17:01:22 -0500263 rectName);
Ethan Nicholase1f55022019-02-05 17:17:40 -0500264 fragBuilder->codeAppendf("half alpha = leftAlpha * half(%s);",
bsalomoncd074912015-12-09 10:33:51 -0800265 clampedCircleDistance.c_str());
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +0000266 break;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000267 case CircularRRectEffect::kBottom_CornerFlags:
Chris Dalton47c8ed32017-11-15 18:27:09 -0700268 fragBuilder->codeAppendf("float dx0 = %s.x - sk_FragCoord.x;", rectName);
269 fragBuilder->codeAppendf("float2 dxy1 = sk_FragCoord.xy - %s.zw;", rectName);
270 fragBuilder->codeAppend("float2 dxy = max(float2(max(dx0, dxy1.x), dxy1.y), 0.0);");
Ethan Nicholase1f55022019-02-05 17:17:40 -0500271 fragBuilder->codeAppendf("half topAlpha = half(saturate(sk_FragCoord.y - %s.y));",
Ethan Nicholas38657112017-02-09 17:01:22 -0500272 rectName);
Ethan Nicholase1f55022019-02-05 17:17:40 -0500273 fragBuilder->codeAppendf("half alpha = topAlpha * half(%s);",
bsalomoncd074912015-12-09 10:33:51 -0800274 clampedCircleDistance.c_str());
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +0000275 break;
276 }
skia.committer@gmail.com06acb582014-03-06 03:02:32 +0000277
Ethan Nicholas1706f842017-11-10 11:58:19 -0500278 if (GrClipEdgeType::kInverseFillAA == crre.getEdgeType()) {
bsalomoncd074912015-12-09 10:33:51 -0800279 fragBuilder->codeAppend("alpha = 1.0 - alpha;");
commit-bot@chromium.orgfbde87f2014-03-04 16:25:34 +0000280 }
commit-bot@chromium.orgc2f78242014-02-19 15:18:05 +0000281
Ethan Nicholas2983f402017-05-08 09:36:08 -0400282 fragBuilder->codeAppendf("%s = %s * alpha;", args.fOutputColor, args.fInputColor);
commit-bot@chromium.orgc2f78242014-02-19 15:18:05 +0000283}
284
Brian Salomon94efbf52016-11-29 13:43:05 -0500285void GLCircularRRectEffect::GenKey(const GrProcessor& processor, const GrShaderCaps&,
joshualittb0a8a372014-09-23 09:50:21 -0700286 GrProcessorKeyBuilder* b) {
287 const CircularRRectEffect& crre = processor.cast<CircularRRectEffect>();
Ethan Nicholas1706f842017-11-10 11:58:19 -0500288 GR_STATIC_ASSERT(kGrClipEdgeTypeCnt <= 8);
289 b->add32((crre.getCircularCornerFlags() << 3) | (int) crre.getEdgeType());
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +0000290}
291
egdaniel018fb622015-10-28 07:26:40 -0700292void GLCircularRRectEffect::onSetData(const GrGLSLProgramDataManager& pdman,
Brian Salomonab015ef2017-04-04 10:15:51 -0400293 const GrFragmentProcessor& processor) {
joshualittb0a8a372014-09-23 09:50:21 -0700294 const CircularRRectEffect& crre = processor.cast<CircularRRectEffect>();
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000295 const SkRRect& rrect = crre.getRRect();
commit-bot@chromium.orgc2f78242014-02-19 15:18:05 +0000296 if (rrect != fPrevRRect) {
commit-bot@chromium.orgc2f78242014-02-19 15:18:05 +0000297 SkRect rect = rrect.getBounds();
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +0000298 SkScalar radius = 0;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000299 switch (crre.getCircularCornerFlags()) {
300 case CircularRRectEffect::kAll_CornerFlags:
Mike Reed242135a2018-02-22 13:41:39 -0500301 SkASSERT(SkRRectPriv::IsSimpleCircular(rrect));
302 radius = SkRRectPriv::GetSimpleRadii(rrect).fX;
commit-bot@chromium.org2a8be902014-03-24 19:24:59 +0000303 SkASSERT(radius >= kRadiusMin);
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +0000304 rect.inset(radius, radius);
305 break;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000306 case CircularRRectEffect::kTopLeft_CornerFlag:
commit-bot@chromium.orgc5c748c2014-03-11 15:54:51 +0000307 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;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000313 case CircularRRectEffect::kTopRight_CornerFlag:
commit-bot@chromium.orgc5c748c2014-03-11 15:54:51 +0000314 radius = rrect.radii(SkRRect::kUpperRight_Corner).fX;
bsalomon@google.comde9f2512014-03-11 17:09:17 +0000315 rect.fLeft -= 0.5f;
commit-bot@chromium.orgc5c748c2014-03-11 15:54:51 +0000316 rect.fTop += radius;
317 rect.fRight -= radius;
318 rect.fBottom += 0.5f;
319 break;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000320 case CircularRRectEffect::kBottomRight_CornerFlag:
commit-bot@chromium.orgc5c748c2014-03-11 15:54:51 +0000321 radius = rrect.radii(SkRRect::kLowerRight_Corner).fX;
bsalomon@google.comde9f2512014-03-11 17:09:17 +0000322 rect.fLeft -= 0.5f;
323 rect.fTop -= 0.5f;
commit-bot@chromium.orgc5c748c2014-03-11 15:54:51 +0000324 rect.fRight -= radius;
325 rect.fBottom -= radius;
326 break;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000327 case CircularRRectEffect::kBottomLeft_CornerFlag:
commit-bot@chromium.orgc5c748c2014-03-11 15:54:51 +0000328 radius = rrect.radii(SkRRect::kLowerLeft_Corner).fX;
329 rect.fLeft += radius;
bsalomon@google.comde9f2512014-03-11 17:09:17 +0000330 rect.fTop -= 0.5f;
331 rect.fRight += 0.5f;
commit-bot@chromium.orgc5c748c2014-03-11 15:54:51 +0000332 rect.fBottom -= radius;
333 break;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000334 case CircularRRectEffect::kLeft_CornerFlags:
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +0000335 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;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000341 case CircularRRectEffect::kTop_CornerFlags:
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +0000342 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;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000348 case CircularRRectEffect::kRight_CornerFlags:
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +0000349 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;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000355 case CircularRRectEffect::kBottom_CornerFlags:
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +0000356 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;
commit-bot@chromium.orgdd584222014-03-10 16:08:22 +0000362 default:
Ben Wagnerb4aab9a2017-08-16 10:53:04 -0400363 SK_ABORT("Should have been one of the above cases.");
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +0000364 }
kkinnunen7510b222014-07-30 00:04:16 -0700365 pdman.set4f(fInnerRectUniform, rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
bsalomoncd074912015-12-09 10:33:51 -0800366 radius += 0.5f;
367 pdman.set2f(fRadiusPlusHalfUniform, radius, 1.f / radius);
commit-bot@chromium.orgc2f78242014-02-19 15:18:05 +0000368 fPrevRRect = rrect;
369 }
370}
371
joshualitteb2a6762014-12-04 11:35:33 -0800372////////////////////////////////////////////////////////////////////////////////////////////////////
commit-bot@chromium.orgc2f78242014-02-19 15:18:05 +0000373
Brian Salomon94efbf52016-11-29 13:43:05 -0500374void CircularRRectEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps,
egdaniel57d3b032015-11-13 11:57:27 -0800375 GrProcessorKeyBuilder* b) const {
joshualitteb2a6762014-12-04 11:35:33 -0800376 GLCircularRRectEffect::GenKey(*this, caps, b);
377}
378
egdaniel57d3b032015-11-13 11:57:27 -0800379GrGLSLFragmentProcessor* CircularRRectEffect::onCreateGLSLInstance() const {
robertphillips9cdb9922016-02-03 12:25:40 -0800380 return new GLCircularRRectEffect;
joshualitteb2a6762014-12-04 11:35:33 -0800381}
382
383//////////////////////////////////////////////////////////////////////////////
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000384
joshualittb0a8a372014-09-23 09:50:21 -0700385class EllipticalRRectEffect : public GrFragmentProcessor {
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000386public:
Ethan Nicholas0f3c7322017-11-09 14:51:17 -0500387 static std::unique_ptr<GrFragmentProcessor> Make(GrClipEdgeType, const SkRRect&);
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000388
Brian Salomond3b65972017-03-22 12:05:03 -0400389 ~EllipticalRRectEffect() override {}
joshualitteb2a6762014-12-04 11:35:33 -0800390
mtklein36352bf2015-03-25 18:17:31 -0700391 const char* name() const override { return "EllipticalRRect"; }
joshualitteb2a6762014-12-04 11:35:33 -0800392
Brian Salomonaff329b2017-08-11 09:40:37 -0400393 std::unique_ptr<GrFragmentProcessor> clone() const override;
Brian Salomon1a2a7ab2017-07-26 13:11:51 -0400394
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000395 const SkRRect& getRRect() const { return fRRect; }
396
Ethan Nicholas0f3c7322017-11-09 14:51:17 -0500397 GrClipEdgeType getEdgeType() const { return fEdgeType; }
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000398
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000399private:
Ethan Nicholas0f3c7322017-11-09 14:51:17 -0500400 EllipticalRRectEffect(GrClipEdgeType, const SkRRect&);
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000401
egdaniel57d3b032015-11-13 11:57:27 -0800402 GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
wangyixb1daa862015-08-18 11:29:31 -0700403
Brian Salomon94efbf52016-11-29 13:43:05 -0500404 void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
wangyix4b3050b2015-08-04 07:59:37 -0700405
mtklein36352bf2015-03-25 18:17:31 -0700406 bool onIsEqual(const GrFragmentProcessor& other) const override;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000407
Brian Salomon587e08f2017-01-27 10:59:27 -0500408 SkRRect fRRect;
Ethan Nicholas0f3c7322017-11-09 14:51:17 -0500409 GrClipEdgeType fEdgeType;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000410
Brian Salomon0c26a9d2017-07-06 10:09:38 -0400411 GR_DECLARE_FRAGMENT_PROCESSOR_TEST
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000412
joshualittb0a8a372014-09-23 09:50:21 -0700413 typedef GrFragmentProcessor INHERITED;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000414};
415
Ethan Nicholas0f3c7322017-11-09 14:51:17 -0500416std::unique_ptr<GrFragmentProcessor> EllipticalRRectEffect::Make(GrClipEdgeType edgeType,
Brian Salomonaff329b2017-08-11 09:40:37 -0400417 const SkRRect& rrect) {
Ethan Nicholas1706f842017-11-10 11:58:19 -0500418 if (GrClipEdgeType::kFillAA != edgeType && GrClipEdgeType::kInverseFillAA != edgeType) {
halcanary96fcdcc2015-08-27 07:41:13 -0700419 return nullptr;
commit-bot@chromium.org3eedb802014-03-28 15:58:31 +0000420 }
Brian Salomonaff329b2017-08-11 09:40:37 -0400421 return std::unique_ptr<GrFragmentProcessor>(new EllipticalRRectEffect(edgeType, rrect));
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000422}
423
Ethan Nicholas0f3c7322017-11-09 14:51:17 -0500424EllipticalRRectEffect::EllipticalRRectEffect(GrClipEdgeType edgeType, const SkRRect& rrect)
Ethan Nicholasabff9562017-10-09 10:54:08 -0400425 : INHERITED(kEllipticalRRectEffect_ClassID, kCompatibleWithCoverageAsAlpha_OptimizationFlag)
Brian Salomonf3b995b2017-02-15 10:22:23 -0500426 , fRRect(rrect)
427 , fEdgeType(edgeType) {
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000428}
429
Brian Salomonaff329b2017-08-11 09:40:37 -0400430std::unique_ptr<GrFragmentProcessor> EllipticalRRectEffect::clone() const {
431 return std::unique_ptr<GrFragmentProcessor>(new EllipticalRRectEffect(fEdgeType, fRRect));
Brian Salomon1a2a7ab2017-07-26 13:11:51 -0400432}
433
bsalomon0e08fc12014-10-15 08:19:04 -0700434bool EllipticalRRectEffect::onIsEqual(const GrFragmentProcessor& other) const {
joshualitt49586be2014-09-16 08:21:41 -0700435 const EllipticalRRectEffect& erre = other.cast<EllipticalRRectEffect>();
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000436 return fEdgeType == erre.fEdgeType && fRRect == erre.fRRect;
437}
438
439//////////////////////////////////////////////////////////////////////////////
440
joshualittb0a8a372014-09-23 09:50:21 -0700441GR_DEFINE_FRAGMENT_PROCESSOR_TEST(EllipticalRRectEffect);
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000442
Hal Canary6f6961e2017-01-31 13:50:44 -0500443#if GR_TEST_UTILS
Brian Salomonaff329b2017-08-11 09:40:37 -0400444std::unique_ptr<GrFragmentProcessor> EllipticalRRectEffect::TestCreate(GrProcessorTestData* d) {
joshualitt0067ff52015-07-08 14:26:19 -0700445 SkScalar w = d->fRandom->nextRangeScalar(20.f, 1000.f);
446 SkScalar h = d->fRandom->nextRangeScalar(20.f, 1000.f);
commit-bot@chromium.orgfa5edbe2014-03-13 18:01:05 +0000447 SkVector r[4];
joshualitt0067ff52015-07-08 14:26:19 -0700448 r[SkRRect::kUpperLeft_Corner].fX = d->fRandom->nextRangeF(kRadiusMin, 9.f);
commit-bot@chromium.orgfa5edbe2014-03-13 18:01:05 +0000449 // ensure at least one corner really is elliptical
450 do {
joshualitt0067ff52015-07-08 14:26:19 -0700451 r[SkRRect::kUpperLeft_Corner].fY = d->fRandom->nextRangeF(kRadiusMin, 9.f);
commit-bot@chromium.orgfa5edbe2014-03-13 18:01:05 +0000452 } while (r[SkRRect::kUpperLeft_Corner].fY == r[SkRRect::kUpperLeft_Corner].fX);
453
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000454 SkRRect rrect;
joshualitt0067ff52015-07-08 14:26:19 -0700455 if (d->fRandom->nextBool()) {
commit-bot@chromium.orgfa5edbe2014-03-13 18:01:05 +0000456 // half the time create a four-radii rrect.
joshualitt0067ff52015-07-08 14:26:19 -0700457 r[SkRRect::kLowerRight_Corner].fX = d->fRandom->nextRangeF(kRadiusMin, 9.f);
458 r[SkRRect::kLowerRight_Corner].fY = d->fRandom->nextRangeF(kRadiusMin, 9.f);
commit-bot@chromium.orgfa5edbe2014-03-13 18:01:05 +0000459
460 r[SkRRect::kUpperRight_Corner].fX = r[SkRRect::kLowerRight_Corner].fX;
461 r[SkRRect::kUpperRight_Corner].fY = r[SkRRect::kUpperLeft_Corner].fY;
462
463 r[SkRRect::kLowerLeft_Corner].fX = r[SkRRect::kUpperLeft_Corner].fX;
464 r[SkRRect::kLowerLeft_Corner].fY = r[SkRRect::kLowerRight_Corner].fY;
465
466 rrect.setRectRadii(SkRect::MakeWH(w, h), r);
467 } else {
468 rrect.setRectXY(SkRect::MakeWH(w, h), r[SkRRect::kUpperLeft_Corner].fX,
469 r[SkRRect::kUpperLeft_Corner].fY);
470 }
Brian Salomonaff329b2017-08-11 09:40:37 -0400471 std::unique_ptr<GrFragmentProcessor> fp;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000472 do {
Ethan Nicholas1706f842017-11-10 11:58:19 -0500473 GrClipEdgeType et = (GrClipEdgeType)d->fRandom->nextULessThan(kGrClipEdgeTypeCnt);
Ethan Nicholaseace9352018-10-15 20:09:54 +0000474 fp = GrRRectEffect::Make(et, rrect, *d->caps()->shaderCaps());
halcanary96fcdcc2015-08-27 07:41:13 -0700475 } while (nullptr == fp);
joshualittb0a8a372014-09-23 09:50:21 -0700476 return fp;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000477}
Hal Canary6f6961e2017-01-31 13:50:44 -0500478#endif
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000479
480//////////////////////////////////////////////////////////////////////////////
481
egdaniel64c47282015-11-13 06:54:19 -0800482class GLEllipticalRRectEffect : public GrGLSLFragmentProcessor {
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000483public:
Brian Salomon0a241ce2017-12-15 11:31:05 -0500484 GLEllipticalRRectEffect() = default;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000485
robertphillips9cdb9922016-02-03 12:25:40 -0800486 void emitCode(EmitArgs&) override;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000487
Brian Salomon94efbf52016-11-29 13:43:05 -0500488 static inline void GenKey(const GrProcessor&, const GrShaderCaps&, GrProcessorKeyBuilder*);
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000489
wangyixb1daa862015-08-18 11:29:31 -0700490protected:
Brian Salomonab015ef2017-04-04 10:15:51 -0400491 void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) override;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000492
493private:
egdaniel018fb622015-10-28 07:26:40 -0700494 GrGLSLProgramDataManager::UniformHandle fInnerRectUniform;
495 GrGLSLProgramDataManager::UniformHandle fInvRadiiSqdUniform;
bsalomone87256c42015-12-09 17:14:40 -0800496 GrGLSLProgramDataManager::UniformHandle fScaleUniform;
497 SkRRect fPrevRRect;
egdaniel64c47282015-11-13 06:54:19 -0800498 typedef GrGLSLFragmentProcessor INHERITED;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000499};
500
wangyix7c157a92015-07-22 15:08:53 -0700501void GLEllipticalRRectEffect::emitCode(EmitArgs& args) {
502 const EllipticalRRectEffect& erre = args.fFp.cast<EllipticalRRectEffect>();
egdaniel7ea439b2015-12-03 09:20:44 -0800503 GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000504 const char *rectName;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000505 // The inner rect is the rrect bounds inset by the x/y radii
Robert Phillips0cace8e2019-01-03 12:42:43 -0500506 fInnerRectUniform = uniformHandler->addUniform(kFragment_GrShaderFlag, kFloat4_GrSLType,
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400507 "innerRect", &rectName);
joshualitt30ba4362014-08-21 20:18:45 -0700508
cdalton85285412016-02-18 12:37:07 -0800509 GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000510 // At each quarter-ellipse corner we compute a vector that is the offset of the fragment pos
511 // to the ellipse center. The vector is pinned in x and y to be in the quarter-plane relevant
512 // to that corner. This means that points near the interior near the rrect top edge will have
513 // a vector that points straight up for both the TL left and TR corners. Computing an
514 // alpha from this vector at either the TR or TL corner will give the correct result. Similarly,
515 // fragments near the other three edges will get the correct AA. Fragments in the interior of
516 // the rrect will have a (0,0) vector at all four corners. So long as the radii > 0.5 they will
517 // correctly produce an alpha value of 1 at all four corners. We take the min of all the alphas.
bsalomonc41f4d62015-08-03 14:23:03 -0700518 //
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000519 // The code below is a simplified version of the above that performs maxs on the vector
520 // components before computing distances and alpha values so that only one distance computation
521 // need be computed to determine the min alpha.
Chris Dalton47c8ed32017-11-15 18:27:09 -0700522 fragBuilder->codeAppendf("float2 dxy0 = %s.xy - sk_FragCoord.xy;", rectName);
523 fragBuilder->codeAppendf("float2 dxy1 = sk_FragCoord.xy - %s.zw;", rectName);
bsalomone87256c42015-12-09 17:14:40 -0800524
Chris Dalton47c8ed32017-11-15 18:27:09 -0700525 // If we're on a device where float != fp32 then we'll do the distance computation in a space
bsalomone87256c42015-12-09 17:14:40 -0800526 // that is normalized by the largest radius. The scale uniform will be scale, 1/scale. The
527 // radii uniform values are already in this normalized space.
528 const char* scaleName = nullptr;
Chris Dalton47c8ed32017-11-15 18:27:09 -0700529 if (!args.fShaderCaps->floatIs32Bits()) {
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400530 fScaleUniform = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf2_GrSLType, "scale",
531 &scaleName);
bsalomone87256c42015-12-09 17:14:40 -0800532 }
533
bsalomonc41f4d62015-08-03 14:23:03 -0700534 // The uniforms with the inv squared radii are highp to prevent underflow.
commit-bot@chromium.org9615d5f2014-03-20 21:39:03 +0000535 switch (erre.getRRect().getType()) {
536 case SkRRect::kSimple_Type: {
commit-bot@chromium.orgfa5edbe2014-03-13 18:01:05 +0000537 const char *invRadiiXYSqdName;
cdalton5e58cee2016-02-11 12:49:47 -0800538 fInvRadiiSqdUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
Ethan Nicholas10e93b62019-03-20 10:46:14 -0400539 kFloat2_GrSLType,
cdalton5e58cee2016-02-11 12:49:47 -0800540 "invRadiiXY",
541 &invRadiiXYSqdName);
Chris Dalton47c8ed32017-11-15 18:27:09 -0700542 fragBuilder->codeAppend("float2 dxy = max(max(dxy0, dxy1), 0.0);");
bsalomone87256c42015-12-09 17:14:40 -0800543 if (scaleName) {
544 fragBuilder->codeAppendf("dxy *= %s.y;", scaleName);
545 }
commit-bot@chromium.orgfa5edbe2014-03-13 18:01:05 +0000546 // Z is the x/y offsets divided by squared radii.
Chris Dalton47c8ed32017-11-15 18:27:09 -0700547 fragBuilder->codeAppendf("float2 Z = dxy * %s.xy;", invRadiiXYSqdName);
commit-bot@chromium.orgfa5edbe2014-03-13 18:01:05 +0000548 break;
549 }
commit-bot@chromium.org9615d5f2014-03-20 21:39:03 +0000550 case SkRRect::kNinePatch_Type: {
commit-bot@chromium.orgfa5edbe2014-03-13 18:01:05 +0000551 const char *invRadiiLTRBSqdName;
cdalton5e58cee2016-02-11 12:49:47 -0800552 fInvRadiiSqdUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
Ethan Nicholas10e93b62019-03-20 10:46:14 -0400553 kFloat4_GrSLType,
cdalton5e58cee2016-02-11 12:49:47 -0800554 "invRadiiLTRB",
555 &invRadiiLTRBSqdName);
bsalomone87256c42015-12-09 17:14:40 -0800556 if (scaleName) {
557 fragBuilder->codeAppendf("dxy0 *= %s.y;", scaleName);
558 fragBuilder->codeAppendf("dxy1 *= %s.y;", scaleName);
559 }
Chris Dalton47c8ed32017-11-15 18:27:09 -0700560 fragBuilder->codeAppend("float2 dxy = max(max(dxy0, dxy1), 0.0);");
commit-bot@chromium.orgfa5edbe2014-03-13 18:01:05 +0000561 // Z is the x/y offsets divided by squared radii. We only care about the (at most) one
562 // corner where both the x and y offsets are positive, hence the maxes. (The inverse
563 // squared radii will always be positive.)
Chris Dalton47c8ed32017-11-15 18:27:09 -0700564 fragBuilder->codeAppendf("float2 Z = max(max(dxy0 * %s.xy, dxy1 * %s.zw), 0.0);",
egdaniel4ca2e602015-11-18 08:01:26 -0800565 invRadiiLTRBSqdName, invRadiiLTRBSqdName);
bsalomone87256c42015-12-09 17:14:40 -0800566
commit-bot@chromium.orgfa5edbe2014-03-13 18:01:05 +0000567 break;
commit-bot@chromium.org9615d5f2014-03-20 21:39:03 +0000568 }
569 default:
Ben Wagnerb4aab9a2017-08-16 10:53:04 -0400570 SK_ABORT("RRect should always be simple or nine-patch.");
commit-bot@chromium.orgfa5edbe2014-03-13 18:01:05 +0000571 }
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000572 // implicit is the evaluation of (x/a)^2 + (y/b)^2 - 1.
Ethan Nicholase1f55022019-02-05 17:17:40 -0500573 fragBuilder->codeAppend("half implicit = half(dot(Z, dxy) - 1.0);");
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000574 // grad_dot is the squared length of the gradient of the implicit.
Ethan Nicholase1f55022019-02-05 17:17:40 -0500575 fragBuilder->codeAppend("half grad_dot = half(4.0 * dot(Z, Z));");
commit-bot@chromium.org1b035d82014-04-09 17:11:09 +0000576 // avoid calling inversesqrt on zero.
bsalomone87256c42015-12-09 17:14:40 -0800577 fragBuilder->codeAppend("grad_dot = max(grad_dot, 1.0e-4);");
Ethan Nicholase1f55022019-02-05 17:17:40 -0500578 fragBuilder->codeAppend("half approx_dist = implicit * half(inversesqrt(grad_dot));");
bsalomone87256c42015-12-09 17:14:40 -0800579 if (scaleName) {
580 fragBuilder->codeAppendf("approx_dist *= %s.x;", scaleName);
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000581 }
582
Ethan Nicholas1706f842017-11-10 11:58:19 -0500583 if (GrClipEdgeType::kFillAA == erre.getEdgeType()) {
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400584 fragBuilder->codeAppend("half alpha = clamp(0.5 - approx_dist, 0.0, 1.0);");
bsalomone87256c42015-12-09 17:14:40 -0800585 } else {
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400586 fragBuilder->codeAppend("half alpha = clamp(0.5 + approx_dist, 0.0, 1.0);");
bsalomone87256c42015-12-09 17:14:40 -0800587 }
588
Ethan Nicholas2983f402017-05-08 09:36:08 -0400589 fragBuilder->codeAppendf("%s = %s * alpha;", args.fOutputColor, args.fInputColor);
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000590}
591
Brian Salomon94efbf52016-11-29 13:43:05 -0500592void GLEllipticalRRectEffect::GenKey(const GrProcessor& effect, const GrShaderCaps&,
joshualittb0a8a372014-09-23 09:50:21 -0700593 GrProcessorKeyBuilder* b) {
joshualitt49586be2014-09-16 08:21:41 -0700594 const EllipticalRRectEffect& erre = effect.cast<EllipticalRRectEffect>();
Ethan Nicholas1706f842017-11-10 11:58:19 -0500595 GR_STATIC_ASSERT((int) GrClipEdgeType::kLast < (1 << 3));
596 b->add32(erre.getRRect().getType() | (int) erre.getEdgeType() << 3);
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000597}
598
egdaniel018fb622015-10-28 07:26:40 -0700599void GLEllipticalRRectEffect::onSetData(const GrGLSLProgramDataManager& pdman,
Brian Salomonab015ef2017-04-04 10:15:51 -0400600 const GrFragmentProcessor& effect) {
joshualitt49586be2014-09-16 08:21:41 -0700601 const EllipticalRRectEffect& erre = effect.cast<EllipticalRRectEffect>();
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000602 const SkRRect& rrect = erre.getRRect();
bsalomone87256c42015-12-09 17:14:40 -0800603 // If we're using a scale factor to work around precision issues, choose the largest radius
604 // as the scale factor. The inv radii need to be pre-adjusted by the scale factor.
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000605 if (rrect != fPrevRRect) {
606 SkRect rect = rrect.getBounds();
commit-bot@chromium.orgfa5edbe2014-03-13 18:01:05 +0000607 const SkVector& r0 = rrect.radii(SkRRect::kUpperLeft_Corner);
commit-bot@chromium.org2a8be902014-03-24 19:24:59 +0000608 SkASSERT(r0.fX >= kRadiusMin);
609 SkASSERT(r0.fY >= kRadiusMin);
commit-bot@chromium.org9615d5f2014-03-20 21:39:03 +0000610 switch (erre.getRRect().getType()) {
611 case SkRRect::kSimple_Type:
commit-bot@chromium.orgfa5edbe2014-03-13 18:01:05 +0000612 rect.inset(r0.fX, r0.fY);
bsalomone87256c42015-12-09 17:14:40 -0800613 if (fScaleUniform.isValid()) {
614 if (r0.fX > r0.fY) {
615 pdman.set2f(fInvRadiiSqdUniform, 1.f, (r0.fX * r0.fX) / (r0.fY * r0.fY));
616 pdman.set2f(fScaleUniform, r0.fX, 1.f / r0.fX);
617 } else {
618 pdman.set2f(fInvRadiiSqdUniform, (r0.fY * r0.fY) / (r0.fX * r0.fX), 1.f);
619 pdman.set2f(fScaleUniform, r0.fY, 1.f / r0.fY);
620 }
621 } else {
622 pdman.set2f(fInvRadiiSqdUniform, 1.f / (r0.fX * r0.fX),
623 1.f / (r0.fY * r0.fY));
624 }
commit-bot@chromium.orgfa5edbe2014-03-13 18:01:05 +0000625 break;
commit-bot@chromium.org9615d5f2014-03-20 21:39:03 +0000626 case SkRRect::kNinePatch_Type: {
commit-bot@chromium.orgfa5edbe2014-03-13 18:01:05 +0000627 const SkVector& r1 = rrect.radii(SkRRect::kLowerRight_Corner);
commit-bot@chromium.org2a8be902014-03-24 19:24:59 +0000628 SkASSERT(r1.fX >= kRadiusMin);
629 SkASSERT(r1.fY >= kRadiusMin);
commit-bot@chromium.orgfa5edbe2014-03-13 18:01:05 +0000630 rect.fLeft += r0.fX;
631 rect.fTop += r0.fY;
632 rect.fRight -= r1.fX;
633 rect.fBottom -= r1.fY;
bsalomone87256c42015-12-09 17:14:40 -0800634 if (fScaleUniform.isValid()) {
635 float scale = SkTMax(SkTMax(r0.fX, r0.fY), SkTMax(r1.fX, r1.fY));
636 float scaleSqd = scale * scale;
637 pdman.set4f(fInvRadiiSqdUniform, scaleSqd / (r0.fX * r0.fX),
638 scaleSqd / (r0.fY * r0.fY),
639 scaleSqd / (r1.fX * r1.fX),
640 scaleSqd / (r1.fY * r1.fY));
641 pdman.set2f(fScaleUniform, scale, 1.f / scale);
642 } else {
643 pdman.set4f(fInvRadiiSqdUniform, 1.f / (r0.fX * r0.fX),
644 1.f / (r0.fY * r0.fY),
645 1.f / (r1.fX * r1.fX),
646 1.f / (r1.fY * r1.fY));
647 }
commit-bot@chromium.orgfa5edbe2014-03-13 18:01:05 +0000648 break;
649 }
commit-bot@chromium.org9615d5f2014-03-20 21:39:03 +0000650 default:
Ben Wagnerb4aab9a2017-08-16 10:53:04 -0400651 SK_ABORT("RRect should always be simple or nine-patch.");
commit-bot@chromium.orgfa5edbe2014-03-13 18:01:05 +0000652 }
kkinnunen7510b222014-07-30 00:04:16 -0700653 pdman.set4f(fInnerRectUniform, rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000654 fPrevRRect = rrect;
655 }
656}
657
joshualitteb2a6762014-12-04 11:35:33 -0800658////////////////////////////////////////////////////////////////////////////////////////////////////
659
Brian Salomon94efbf52016-11-29 13:43:05 -0500660void EllipticalRRectEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps,
egdaniel57d3b032015-11-13 11:57:27 -0800661 GrProcessorKeyBuilder* b) const {
joshualitteb2a6762014-12-04 11:35:33 -0800662 GLEllipticalRRectEffect::GenKey(*this, caps, b);
663}
664
egdaniel57d3b032015-11-13 11:57:27 -0800665GrGLSLFragmentProcessor* EllipticalRRectEffect::onCreateGLSLInstance() const {
robertphillips9cdb9922016-02-03 12:25:40 -0800666 return new GLEllipticalRRectEffect;
joshualitteb2a6762014-12-04 11:35:33 -0800667}
668
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000669//////////////////////////////////////////////////////////////////////////////
670
Ethan Nicholas0f3c7322017-11-09 14:51:17 -0500671std::unique_ptr<GrFragmentProcessor> GrRRectEffect::Make(GrClipEdgeType edgeType,
Brian Salomon14471772017-12-05 10:35:15 -0500672 const SkRRect& rrect,
Ethan Nicholaseace9352018-10-15 20:09:54 +0000673 const GrShaderCaps& caps) {
commit-bot@chromium.org2a8be902014-03-24 19:24:59 +0000674 if (rrect.isRect()) {
Ethan Nicholaseace9352018-10-15 20:09:54 +0000675 return GrConvexPolyEffect::Make(edgeType, rrect.getBounds());
commit-bot@chromium.org2a8be902014-03-24 19:24:59 +0000676 }
677
commit-bot@chromium.org3eedb802014-03-28 15:58:31 +0000678 if (rrect.isOval()) {
Ethan Nicholaseace9352018-10-15 20:09:54 +0000679 return GrOvalEffect::Make(edgeType, rrect.getBounds(), caps);
commit-bot@chromium.org3eedb802014-03-28 15:58:31 +0000680 }
681
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000682 if (rrect.isSimple()) {
Mike Reed242135a2018-02-22 13:41:39 -0500683 if (SkRRectPriv::GetSimpleRadii(rrect).fX < kRadiusMin ||
684 SkRRectPriv::GetSimpleRadii(rrect).fY < kRadiusMin) {
commit-bot@chromium.org2a8be902014-03-24 19:24:59 +0000685 // In this case the corners are extremely close to rectangular and we collapse the
686 // clip to a rectangular clip.
Ethan Nicholaseace9352018-10-15 20:09:54 +0000687 return GrConvexPolyEffect::Make(edgeType, rrect.getBounds());
commit-bot@chromium.org2a8be902014-03-24 19:24:59 +0000688 }
Mike Reed242135a2018-02-22 13:41:39 -0500689 if (SkRRectPriv::GetSimpleRadii(rrect).fX == SkRRectPriv::GetSimpleRadii(rrect).fY) {
bungeman06ca8ec2016-06-09 08:01:03 -0700690 return CircularRRectEffect::Make(edgeType, CircularRRectEffect::kAll_CornerFlags,
commit-bot@chromium.org2a8be902014-03-24 19:24:59 +0000691 rrect);
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000692 } else {
bungeman06ca8ec2016-06-09 08:01:03 -0700693 return EllipticalRRectEffect::Make(edgeType, rrect);
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +0000694 }
commit-bot@chromium.org2a8be902014-03-24 19:24:59 +0000695 }
696
697 if (rrect.isComplex() || rrect.isNinePatch()) {
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +0000698 // Check for the "tab" cases - two adjacent circular corners and two square corners.
commit-bot@chromium.org2a8be902014-03-24 19:24:59 +0000699 SkScalar circularRadius = 0;
700 uint32_t cornerFlags = 0;
701
702 SkVector radii[4];
703 bool squashedRadii = false;
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +0000704 for (int c = 0; c < 4; ++c) {
commit-bot@chromium.org2a8be902014-03-24 19:24:59 +0000705 radii[c] = rrect.radii((SkRRect::Corner)c);
706 SkASSERT((0 == radii[c].fX) == (0 == radii[c].fY));
707 if (0 == radii[c].fX) {
708 // The corner is square, so no need to squash or flag as circular.
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +0000709 continue;
710 }
commit-bot@chromium.org2a8be902014-03-24 19:24:59 +0000711 if (radii[c].fX < kRadiusMin || radii[c].fY < kRadiusMin) {
712 radii[c].set(0, 0);
713 squashedRadii = true;
714 continue;
715 }
716 if (radii[c].fX != radii[c].fY) {
bsalomon@google.com44a435b2014-03-13 19:20:32 +0000717 cornerFlags = ~0U;
commit-bot@chromium.orgfa5edbe2014-03-13 18:01:05 +0000718 break;
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +0000719 }
commit-bot@chromium.orgdd584222014-03-10 16:08:22 +0000720 if (!cornerFlags) {
commit-bot@chromium.org2a8be902014-03-24 19:24:59 +0000721 circularRadius = radii[c].fX;
commit-bot@chromium.orgdd584222014-03-10 16:08:22 +0000722 cornerFlags = 1 << c;
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +0000723 } else {
commit-bot@chromium.org2a8be902014-03-24 19:24:59 +0000724 if (radii[c].fX != circularRadius) {
bsalomon@google.com44a435b2014-03-13 19:20:32 +0000725 cornerFlags = ~0U;
commit-bot@chromium.orgfa5edbe2014-03-13 18:01:05 +0000726 break;
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +0000727 }
commit-bot@chromium.orgdd584222014-03-10 16:08:22 +0000728 cornerFlags |= 1 << c;
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +0000729 }
730 }
731
commit-bot@chromium.orgdd584222014-03-10 16:08:22 +0000732 switch (cornerFlags) {
commit-bot@chromium.org2a8be902014-03-24 19:24:59 +0000733 case CircularRRectEffect::kAll_CornerFlags:
734 // This rrect should have been caught in the simple case above. Though, it would
735 // be correctly handled in the fallthrough code.
736 SkASSERT(false);
commit-bot@chromium.org4355f212014-03-12 15:32:50 +0000737 case CircularRRectEffect::kTopLeft_CornerFlag:
738 case CircularRRectEffect::kTopRight_CornerFlag:
739 case CircularRRectEffect::kBottomRight_CornerFlag:
740 case CircularRRectEffect::kBottomLeft_CornerFlag:
741 case CircularRRectEffect::kLeft_CornerFlags:
742 case CircularRRectEffect::kTop_CornerFlags:
743 case CircularRRectEffect::kRight_CornerFlags:
commit-bot@chromium.org2a8be902014-03-24 19:24:59 +0000744 case CircularRRectEffect::kBottom_CornerFlags: {
745 SkTCopyOnFirstWrite<SkRRect> rr(rrect);
746 if (squashedRadii) {
747 rr.writable()->setRectRadii(rrect.getBounds(), radii);
748 }
bungeman06ca8ec2016-06-09 08:01:03 -0700749 return CircularRRectEffect::Make(edgeType, cornerFlags, *rr);
commit-bot@chromium.org2a8be902014-03-24 19:24:59 +0000750 }
751 case CircularRRectEffect::kNone_CornerFlags:
Ethan Nicholaseace9352018-10-15 20:09:54 +0000752 return GrConvexPolyEffect::Make(edgeType, rrect.getBounds());
commit-bot@chromium.org2a8be902014-03-24 19:24:59 +0000753 default: {
754 if (squashedRadii) {
755 // If we got here then we squashed some but not all the radii to zero. (If all
756 // had been squashed cornerFlags would be 0.) The elliptical effect doesn't
757 // support some rounded and some square corners.
halcanary96fcdcc2015-08-27 07:41:13 -0700758 return nullptr;
commit-bot@chromium.org2a8be902014-03-24 19:24:59 +0000759 }
commit-bot@chromium.orgfa5edbe2014-03-13 18:01:05 +0000760 if (rrect.isNinePatch()) {
bungeman06ca8ec2016-06-09 08:01:03 -0700761 return EllipticalRRectEffect::Make(edgeType, rrect);
commit-bot@chromium.orgfa5edbe2014-03-13 18:01:05 +0000762 }
halcanary96fcdcc2015-08-27 07:41:13 -0700763 return nullptr;
commit-bot@chromium.org2a8be902014-03-24 19:24:59 +0000764 }
commit-bot@chromium.orgcb3672e2014-02-21 22:41:56 +0000765 }
commit-bot@chromium.orgc2f78242014-02-19 15:18:05 +0000766 }
commit-bot@chromium.org2a8be902014-03-24 19:24:59 +0000767
halcanary96fcdcc2015-08-27 07:41:13 -0700768 return nullptr;
commit-bot@chromium.orgc2f78242014-02-19 15:18:05 +0000769}