GrRRectEffect.cpp 36 KB

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