src/gpu/effects/GrRRectEffect.cpp

   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 "GrRRectEffect.h"
   9
  10 #include "GrConvexPolyEffect.h"
  11 #include "GrFragmentProcessor.h"
  12 #include "GrInvariantOutput.h"
  13 #include "GrOvalEffect.h"
  14 #include "SkRRect.h"
  15 #include "glsl/GrGLSLFragmentProcessor.h"
  16 #include "glsl/GrGLSLFragmentShaderBuilder.h"
  17 #include "glsl/GrGLSLProgramBuilder.h"
  18 #include "glsl/GrGLSLProgramDataManager.h"
  19
  20 // The effects defined here only handle rrect radii >= kRadiusMin.
  21 static const SkScalar kRadiusMin = SK_ScalarHalf;
  22
  23 //////////////////////////////////////////////////////////////////////////////
  24
  25 class CircularRRectEffect : public GrFragmentProcessor {
  26 public:
  27
  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 GrFragmentProcessor* Create(GrPrimitiveEdgeType, uint32_t circularCornerFlags,
  48                                        const SkRRect&);
  49
  50     virtual ~CircularRRectEffect() {};
  51
  52     const char* name() const override { return "CircularRRect"; }
  53
  54     const SkRRect& getRRect() const { return fRRect; }
  55
  56     uint32_t getCircularCornerFlags() const { return fCircularCornerFlags; }
  57
  58     GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; }
  59
  60 private:
  61     CircularRRectEffect(GrPrimitiveEdgeType, uint32_t circularCornerFlags, const SkRRect&);
  62
  63     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
  64
  65     void onGetGLSLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
  66
  67     bool onIsEqual(const GrFragmentProcessor& other) const override;
  68
  69     void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
  70
  71     SkRRect                fRRect;
  72     GrPrimitiveEdgeType    fEdgeType;
  73     uint32_t               fCircularCornerFlags;
  74
  75     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
  76
  77     typedef GrFragmentProcessor INHERITED;
  78 };
  79
  80 GrFragmentProcessor* CircularRRectEffect::Create(GrPrimitiveEdgeType edgeType,
  81                                                  uint32_t circularCornerFlags,
  82                                                  const SkRRect& rrect) {
  83     if (kFillAA_GrProcessorEdgeType != edgeType && kInverseFillAA_GrProcessorEdgeType != edgeType) {
  84         return nullptr;
  85     }
  86     return new CircularRRectEffect(edgeType, circularCornerFlags, rrect);
  87 }
  88
  89 void CircularRRectEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
  90     inout->mulByUnknownSingleComponent();
  91 }
  92
  93 CircularRRectEffect::CircularRRectEffect(GrPrimitiveEdgeType edgeType, uint32_t circularCornerFlags,
  94                                          const SkRRect& rrect)
  95     : fRRect(rrect)
  96     , fEdgeType(edgeType)
  97     , fCircularCornerFlags(circularCornerFlags) {
  98     this->initClassID<CircularRRectEffect>();
  99     this->setWillReadFragmentPosition();
 100 }
 101
 102 bool CircularRRectEffect::onIsEqual(const GrFragmentProcessor& other) const {
 103     const CircularRRectEffect& crre = other.cast<CircularRRectEffect>();
 104     // The corner flags are derived from fRRect, so no need to check them.
 105     return fEdgeType == crre.fEdgeType && fRRect == crre.fRRect;
 106 }
 107
 108 //////////////////////////////////////////////////////////////////////////////
 109
 110 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircularRRectEffect);
 111
 112 const GrFragmentProcessor* CircularRRectEffect::TestCreate(GrProcessorTestData* d) {
 113     SkScalar w = d->fRandom->nextRangeScalar(20.f, 1000.f);
 114     SkScalar h = d->fRandom->nextRangeScalar(20.f, 1000.f);
 115     SkScalar r = d->fRandom->nextRangeF(kRadiusMin, 9.f);
 116     SkRRect rrect;
 117     rrect.setRectXY(SkRect::MakeWH(w, h), r, r);
 118     GrFragmentProcessor* fp;
 119     do {
 120         GrPrimitiveEdgeType et =
 121                 (GrPrimitiveEdgeType)d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt);
 122         fp = GrRRectEffect::Create(et, rrect);
 123     } while (nullptr == fp);
 124     return fp;
 125 }
 126
 127 //////////////////////////////////////////////////////////////////////////////
 128
 129 class GLCircularRRectEffect : public GrGLSLFragmentProcessor {
 130 public:
 131     GLCircularRRectEffect(const GrProcessor&);
 132
 133     virtual void emitCode(EmitArgs&) override;
 134
 135     static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*);
 136
 137 protected:
 138     void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
 139
 140 private:
 141     GrGLSLProgramDataManager::UniformHandle fInnerRectUniform;
 142     GrGLSLProgramDataManager::UniformHandle fRadiusPlusHalfUniform;
 143     SkRRect                               fPrevRRect;
 144     typedef GrGLSLFragmentProcessor INHERITED;
 145 };
 146
 147 GLCircularRRectEffect::GLCircularRRectEffect(const GrProcessor& ) {
 148     fPrevRRect.setEmpty();
 149 }
 150
 151 void GLCircularRRectEffect::emitCode(EmitArgs& args) {
 152     const CircularRRectEffect& crre = args.fFp.cast<CircularRRectEffect>();
 153     const char *rectName;
 154     const char *radiusPlusHalfName;
 155     // The inner rect is the rrect bounds inset by the radius. Its left, top, right, and bottom
 156     // edges correspond to components x, y, z, and w, respectively. When a side of the rrect has
 157     // only rectangular corners, that side's value corresponds to the rect edge's value outset by
 158     // half a pixel.
 159     fInnerRectUniform = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
 160                                                   kVec4f_GrSLType, kDefault_GrSLPrecision,
 161                                                   "innerRect",
 162                                                   &rectName);
 163     fRadiusPlusHalfUniform = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
 164                                                        kFloat_GrSLType, kDefault_GrSLPrecision,
 165                                                        "radiusPlusHalf",
 166                                                        &radiusPlusHalfName);
 167
 168     GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
 169     const char* fragmentPos = fragBuilder->fragmentPosition();
 170     // At each quarter-circle corner we compute a vector that is the offset of the fragment position
 171     // from the circle center. The vector is pinned in x and y to be in the quarter-plane relevant
 172     // to that corner. This means that points near the interior near the rrect top edge will have
 173     // a vector that points straight up for both the TL left and TR corners. Computing an
 174     // alpha from this vector at either the TR or TL corner will give the correct result. Similarly,
 175     // fragments near the other three edges will get the correct AA. Fragments in the interior of
 176     // the rrect will have a (0,0) vector at all four corners. So long as the radius > 0.5 they will
 177     // correctly produce an alpha value of 1 at all four corners. We take the min of all the alphas.
 178     // The code below is a simplified version of the above that performs maxs on the vector
 179     // components before computing distances and alpha values so that only one distance computation
 180     // need be computed to determine the min alpha.
 181     //
 182     // For the cases where one half of the rrect is rectangular we drop one of the x or y
 183     // computations, compute a separate rect edge alpha for the rect side, and mul the two computed
 184     // alphas together.
 185     switch (crre.getCircularCornerFlags()) {
 186         case CircularRRectEffect::kAll_CornerFlags:
 187             fragBuilder->codeAppendf("\t\tvec2 dxy0 = %s.xy - %s.xy;\n", rectName, fragmentPos);
 188             fragBuilder->codeAppendf("\t\tvec2 dxy1 = %s.xy - %s.zw;\n", fragmentPos, rectName);
 189             fragBuilder->codeAppend("\t\tvec2 dxy = max(max(dxy0, dxy1), 0.0);\n");
 190             fragBuilder->codeAppendf("\t\tfloat alpha = clamp(%s - length(dxy), 0.0, 1.0);\n",
 191                                    radiusPlusHalfName);
 192             break;
 193         case CircularRRectEffect::kTopLeft_CornerFlag:
 194             fragBuilder->codeAppendf("\t\tvec2 dxy = max(%s.xy - %s.xy, 0.0);\n",
 195                                      rectName, fragmentPos);
 196             fragBuilder->codeAppendf("\t\tfloat rightAlpha = clamp(%s.z - %s.x, 0.0, 1.0);\n",
 197                                      rectName, fragmentPos);
 198             fragBuilder->codeAppendf("\t\tfloat bottomAlpha = clamp(%s.w - %s.y, 0.0, 1.0);\n",
 199                                      rectName, fragmentPos);
 200             fragBuilder->codeAppendf(
 201                 "\t\tfloat alpha = bottomAlpha * rightAlpha * clamp(%s - length(dxy), 0.0, 1.0);\n",
 202                 radiusPlusHalfName);
 203             break;
 204         case CircularRRectEffect::kTopRight_CornerFlag:
 205             fragBuilder->codeAppendf("\t\tvec2 dxy = max(vec2(%s.x - %s.z, %s.y - %s.y), 0.0);\n",
 206                                      fragmentPos, rectName, rectName, fragmentPos);
 207             fragBuilder->codeAppendf("\t\tfloat leftAlpha = clamp(%s.x - %s.x, 0.0, 1.0);\n",
 208                                      fragmentPos, rectName);
 209             fragBuilder->codeAppendf("\t\tfloat bottomAlpha = clamp(%s.w - %s.y, 0.0, 1.0);\n",
 210                                      rectName, fragmentPos);
 211             fragBuilder->codeAppendf(
 212                 "\t\tfloat alpha = bottomAlpha * leftAlpha * clamp(%s - length(dxy), 0.0, 1.0);\n",
 213                 radiusPlusHalfName);
 214             break;
 215         case CircularRRectEffect::kBottomRight_CornerFlag:
 216             fragBuilder->codeAppendf("\t\tvec2 dxy = max(%s.xy - %s.zw, 0.0);\n",
 217                                      fragmentPos, rectName);
 218             fragBuilder->codeAppendf("\t\tfloat leftAlpha = clamp(%s.x - %s.x, 0.0, 1.0);\n",
 219                                      fragmentPos, rectName);
 220             fragBuilder->codeAppendf("\t\tfloat topAlpha = clamp(%s.y - %s.y, 0.0, 1.0);\n",
 221                                      fragmentPos, rectName);
 222             fragBuilder->codeAppendf(
 223                 "\t\tfloat alpha = topAlpha * leftAlpha * clamp(%s - length(dxy), 0.0, 1.0);\n",
 224                 radiusPlusHalfName);
 225             break;
 226         case CircularRRectEffect::kBottomLeft_CornerFlag:
 227             fragBuilder->codeAppendf("\t\tvec2 dxy = max(vec2(%s.x - %s.x, %s.y - %s.w), 0.0);\n",
 228                                      rectName, fragmentPos, fragmentPos, rectName);
 229             fragBuilder->codeAppendf("\t\tfloat rightAlpha = clamp(%s.z - %s.x, 0.0, 1.0);\n",
 230                                      rectName, fragmentPos);
 231             fragBuilder->codeAppendf("\t\tfloat topAlpha = clamp(%s.y - %s.y, 0.0, 1.0);\n",
 232                                      fragmentPos, rectName);
 233             fragBuilder->codeAppendf(
 234                 "\t\tfloat alpha = topAlpha * rightAlpha * clamp(%s - length(dxy), 0.0, 1.0);\n",
 235                 radiusPlusHalfName);
 236             break;
 237         case CircularRRectEffect::kLeft_CornerFlags:
 238             fragBuilder->codeAppendf("\t\tvec2 dxy0 = %s.xy - %s.xy;\n", rectName, fragmentPos);
 239             fragBuilder->codeAppendf("\t\tfloat dy1 = %s.y - %s.w;\n", fragmentPos, rectName);
 240             fragBuilder->codeAppend("\t\tvec2 dxy = max(vec2(dxy0.x, max(dxy0.y, dy1)), 0.0);\n");
 241             fragBuilder->codeAppendf("\t\tfloat rightAlpha = clamp(%s.z - %s.x, 0.0, 1.0);\n",
 242                                      rectName, fragmentPos);
 243             fragBuilder->codeAppendf(
 244                 "\t\tfloat alpha = rightAlpha * clamp(%s - length(dxy), 0.0, 1.0);\n",
 245                 radiusPlusHalfName);
 246             break;
 247         case CircularRRectEffect::kTop_CornerFlags:
 248             fragBuilder->codeAppendf("\t\tvec2 dxy0 = %s.xy - %s.xy;\n", rectName, fragmentPos);
 249             fragBuilder->codeAppendf("\t\tfloat dx1 = %s.x - %s.z;\n", fragmentPos, rectName);
 250             fragBuilder->codeAppend("\t\tvec2 dxy = max(vec2(max(dxy0.x, dx1), dxy0.y), 0.0);\n");
 251             fragBuilder->codeAppendf("\t\tfloat bottomAlpha = clamp(%s.w - %s.y, 0.0, 1.0);\n",
 252                                      rectName, fragmentPos);
 253             fragBuilder->codeAppendf(
 254                 "\t\tfloat alpha = bottomAlpha * clamp(%s - length(dxy), 0.0, 1.0);\n",
 255                 radiusPlusHalfName);
 256             break;
 257         case CircularRRectEffect::kRight_CornerFlags:
 258             fragBuilder->codeAppendf("\t\tfloat dy0 = %s.y - %s.y;\n", rectName, fragmentPos);
 259             fragBuilder->codeAppendf("\t\tvec2 dxy1 = %s.xy - %s.zw;\n", fragmentPos, rectName);
 260             fragBuilder->codeAppend("\t\tvec2 dxy = max(vec2(dxy1.x, max(dy0, dxy1.y)), 0.0);\n");
 261             fragBuilder->codeAppendf("\t\tfloat leftAlpha = clamp(%s.x - %s.x, 0.0, 1.0);\n",
 262                                      fragmentPos, rectName);
 263             fragBuilder->codeAppendf(
 264                 "\t\tfloat alpha = leftAlpha * clamp(%s - length(dxy), 0.0, 1.0);\n",
 265                 radiusPlusHalfName);
 266             break;
 267         case CircularRRectEffect::kBottom_CornerFlags:
 268             fragBuilder->codeAppendf("\t\tfloat dx0 = %s.x - %s.x;\n", rectName, fragmentPos);
 269             fragBuilder->codeAppendf("\t\tvec2 dxy1 = %s.xy - %s.zw;\n", fragmentPos, rectName);
 270             fragBuilder->codeAppend("\t\tvec2 dxy = max(vec2(max(dx0, dxy1.x), dxy1.y), 0.0);\n");
 271             fragBuilder->codeAppendf("\t\tfloat topAlpha = clamp(%s.y - %s.y, 0.0, 1.0);\n",
 272                                      fragmentPos, rectName);
 273             fragBuilder->codeAppendf(
 274                 "\t\tfloat alpha = topAlpha * clamp(%s - length(dxy), 0.0, 1.0);\n",
 275                 radiusPlusHalfName);
 276             break;
 277     }
 278
 279     if (kInverseFillAA_GrProcessorEdgeType == crre.getEdgeType()) {
 280         fragBuilder->codeAppend("\t\talpha = 1.0 - alpha;\n");
 281     }
 282
 283     fragBuilder->codeAppendf("\t\t%s = %s;\n", args.fOutputColor,
 284                              (GrGLSLExpr4(args.fInputColor) * GrGLSLExpr1("alpha")).c_str());
 285 }
 286
 287 void GLCircularRRectEffect::GenKey(const GrProcessor& processor, const GrGLSLCaps&,
 288                                    GrProcessorKeyBuilder* b) {
 289     const CircularRRectEffect& crre = processor.cast<CircularRRectEffect>();
 290     GR_STATIC_ASSERT(kGrProcessorEdgeTypeCnt <= 8);
 291     b->add32((crre.getCircularCornerFlags() << 3) | crre.getEdgeType());
 292 }
 293
 294 void GLCircularRRectEffect::onSetData(const GrGLSLProgramDataManager& pdman,
 295                                       const GrProcessor& processor) {
 296     const CircularRRectEffect& crre = processor.cast<CircularRRectEffect>();
 297     const SkRRect& rrect = crre.getRRect();
 298     if (rrect != fPrevRRect) {
 299         SkRect rect = rrect.getBounds();
 300         SkScalar radius = 0;
 301         switch (crre.getCircularCornerFlags()) {
 302             case CircularRRectEffect::kAll_CornerFlags:
 303                 SkASSERT(rrect.isSimpleCircular());
 304                 radius = rrect.getSimpleRadii().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                 SkFAIL("Should have been one of the above cases.");
 366         }
 367         pdman.set4f(fInnerRectUniform, rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
 368         pdman.set1f(fRadiusPlusHalfUniform, radius + 0.5f);
 369         fPrevRRect = rrect;
 370     }
 371 }
 372
 373 ////////////////////////////////////////////////////////////////////////////////////////////////////
 374
 375 void CircularRRectEffect::onGetGLSLProcessorKey(const GrGLSLCaps& caps,
 376                                                 GrProcessorKeyBuilder* b) const {
 377     GLCircularRRectEffect::GenKey(*this, caps, b);
 378 }
 379
 380 GrGLSLFragmentProcessor* CircularRRectEffect::onCreateGLSLInstance() const  {
 381     return new GLCircularRRectEffect(*this);
 382 }
 383
 384 //////////////////////////////////////////////////////////////////////////////
 385
 386 class EllipticalRRectEffect : public GrFragmentProcessor {
 387 public:
 388     static GrFragmentProcessor* Create(GrPrimitiveEdgeType, const SkRRect&);
 389
 390     virtual ~EllipticalRRectEffect() {};
 391
 392     const char* name() const override { return "EllipticalRRect"; }
 393
 394     const SkRRect& getRRect() const { return fRRect; }
 395
 396     GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; }
 397
 398 private:
 399     EllipticalRRectEffect(GrPrimitiveEdgeType, const SkRRect&);
 400
 401     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
 402
 403     void onGetGLSLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
 404
 405     bool onIsEqual(const GrFragmentProcessor& other) const override;
 406
 407     void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
 408
 409     SkRRect             fRRect;
 410     GrPrimitiveEdgeType    fEdgeType;
 411
 412     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 413
 414     typedef GrFragmentProcessor INHERITED;
 415 };
 416
 417 GrFragmentProcessor*
 418 EllipticalRRectEffect::Create(GrPrimitiveEdgeType edgeType, const SkRRect& rrect) {
 419     if (kFillAA_GrProcessorEdgeType != edgeType && kInverseFillAA_GrProcessorEdgeType != edgeType) {
 420         return nullptr;
 421     }
 422     return new EllipticalRRectEffect(edgeType, rrect);
 423 }
 424
 425 void EllipticalRRectEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
 426     inout->mulByUnknownSingleComponent();
 427 }
 428
 429 EllipticalRRectEffect::EllipticalRRectEffect(GrPrimitiveEdgeType edgeType, const SkRRect& rrect)
 430     : fRRect(rrect)
 431     , fEdgeType(edgeType) {
 432     this->initClassID<EllipticalRRectEffect>();
 433     this->setWillReadFragmentPosition();
 434 }
 435
 436 bool EllipticalRRectEffect::onIsEqual(const GrFragmentProcessor& other) const {
 437     const EllipticalRRectEffect& erre = other.cast<EllipticalRRectEffect>();
 438     return fEdgeType == erre.fEdgeType && fRRect == erre.fRRect;
 439 }
 440
 441 //////////////////////////////////////////////////////////////////////////////
 442
 443 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(EllipticalRRectEffect);
 444
 445 const GrFragmentProcessor* EllipticalRRectEffect::TestCreate(GrProcessorTestData* d) {
 446     SkScalar w = d->fRandom->nextRangeScalar(20.f, 1000.f);
 447     SkScalar h = d->fRandom->nextRangeScalar(20.f, 1000.f);
 448     SkVector r[4];
 449     r[SkRRect::kUpperLeft_Corner].fX = d->fRandom->nextRangeF(kRadiusMin, 9.f);
 450     // ensure at least one corner really is elliptical
 451     do {
 452         r[SkRRect::kUpperLeft_Corner].fY = d->fRandom->nextRangeF(kRadiusMin, 9.f);
 453     } while (r[SkRRect::kUpperLeft_Corner].fY == r[SkRRect::kUpperLeft_Corner].fX);
 454
 455     SkRRect rrect;
 456     if (d->fRandom->nextBool()) {
 457         // half the time create a four-radii rrect.
 458         r[SkRRect::kLowerRight_Corner].fX = d->fRandom->nextRangeF(kRadiusMin, 9.f);
 459         r[SkRRect::kLowerRight_Corner].fY = d->fRandom->nextRangeF(kRadiusMin, 9.f);
 460
 461         r[SkRRect::kUpperRight_Corner].fX = r[SkRRect::kLowerRight_Corner].fX;
 462         r[SkRRect::kUpperRight_Corner].fY = r[SkRRect::kUpperLeft_Corner].fY;
 463
 464         r[SkRRect::kLowerLeft_Corner].fX = r[SkRRect::kUpperLeft_Corner].fX;
 465         r[SkRRect::kLowerLeft_Corner].fY = r[SkRRect::kLowerRight_Corner].fY;
 466
 467         rrect.setRectRadii(SkRect::MakeWH(w, h), r);
 468     } else {
 469         rrect.setRectXY(SkRect::MakeWH(w, h), r[SkRRect::kUpperLeft_Corner].fX,
 470                                               r[SkRRect::kUpperLeft_Corner].fY);
 471     }
 472     GrFragmentProcessor* fp;
 473     do {
 474         GrPrimitiveEdgeType et =
 475                 (GrPrimitiveEdgeType)d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt);
 476         fp = GrRRectEffect::Create(et, rrect);
 477     } while (nullptr == fp);
 478     return fp;
 479 }
 480
 481 //////////////////////////////////////////////////////////////////////////////
 482
 483 class GLEllipticalRRectEffect : public GrGLSLFragmentProcessor {
 484 public:
 485     GLEllipticalRRectEffect(const GrProcessor&);
 486
 487     virtual void emitCode(EmitArgs&) override;
 488
 489     static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*);
 490
 491 protected:
 492     void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
 493
 494 private:
 495     GrGLSLProgramDataManager::UniformHandle fInnerRectUniform;
 496     GrGLSLProgramDataManager::UniformHandle fInvRadiiSqdUniform;
 497     SkRRect                               fPrevRRect;
 498     typedef GrGLSLFragmentProcessor INHERITED;
 499 };
 500
 501 GLEllipticalRRectEffect::GLEllipticalRRectEffect(const GrProcessor& effect) {
 502     fPrevRRect.setEmpty();
 503 }
 504
 505 void GLEllipticalRRectEffect::emitCode(EmitArgs& args) {
 506     const EllipticalRRectEffect& erre = args.fFp.cast<EllipticalRRectEffect>();
 507     const char *rectName;
 508     // The inner rect is the rrect bounds inset by the x/y radii
 509     fInnerRectUniform = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
 510                                             kVec4f_GrSLType, kDefault_GrSLPrecision,
 511                                             "innerRect",
 512                                             &rectName);
 513
 514     GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
 515     const char* fragmentPos = fragBuilder->fragmentPosition();
 516     // At each quarter-ellipse corner we compute a vector that is the offset of the fragment pos
 517     // to the ellipse center. The vector is pinned in x and y to be in the quarter-plane relevant
 518     // to that corner. This means that points near the interior near the rrect top edge will have
 519     // a vector that points straight up for both the TL left and TR corners. Computing an
 520     // alpha from this vector at either the TR or TL corner will give the correct result. Similarly,
 521     // fragments near the other three edges will get the correct AA. Fragments in the interior of
 522     // the rrect will have a (0,0) vector at all four corners. So long as the radii > 0.5 they will
 523     // correctly produce an alpha value of 1 at all four corners. We take the min of all the alphas.
 524     //
 525     // The code below is a simplified version of the above that performs maxs on the vector
 526     // components before computing distances and alpha values so that only one distance computation
 527     // need be computed to determine the min alpha.
 528     fragBuilder->codeAppendf("\t\tvec2 dxy0 = %s.xy - %s.xy;\n", rectName, fragmentPos);
 529     fragBuilder->codeAppendf("\t\tvec2 dxy1 = %s.xy - %s.zw;\n", fragmentPos, rectName);
 530     // The uniforms with the inv squared radii are highp to prevent underflow.
 531     switch (erre.getRRect().getType()) {
 532         case SkRRect::kSimple_Type: {
 533             const char *invRadiiXYSqdName;
 534             fInvRadiiSqdUniform = args.fBuilder->addUniform(
 535                                                          GrGLSLProgramBuilder::kFragment_Visibility,
 536                                                          kVec2f_GrSLType, kHigh_GrSLPrecision,
 537                                                          "invRadiiXY",
 538                                                          &invRadiiXYSqdName);
 539             fragBuilder->codeAppend("\t\tvec2 dxy = max(max(dxy0, dxy1), 0.0);\n");
 540             // Z is the x/y offsets divided by squared radii.
 541             fragBuilder->codeAppendf("\t\tvec2 Z = dxy * %s;\n", invRadiiXYSqdName);
 542             break;
 543         }
 544         case SkRRect::kNinePatch_Type: {
 545             const char *invRadiiLTRBSqdName;
 546             fInvRadiiSqdUniform = args.fBuilder->addUniform(
 547                                                          GrGLSLProgramBuilder::kFragment_Visibility,
 548                                                          kVec4f_GrSLType, kHigh_GrSLPrecision,
 549                                                          "invRadiiLTRB",
 550                                                          &invRadiiLTRBSqdName);
 551             fragBuilder->codeAppend("\t\tvec2 dxy = max(max(dxy0, dxy1), 0.0);\n");
 552             // Z is the x/y offsets divided by squared radii. We only care about the (at most) one
 553             // corner where both the x and y offsets are positive, hence the maxes. (The inverse
 554             // squared radii will always be positive.)
 555             fragBuilder->codeAppendf("\t\tvec2 Z = max(max(dxy0 * %s.xy, dxy1 * %s.zw), 0.0);\n",
 556                                      invRadiiLTRBSqdName, invRadiiLTRBSqdName);
 557             break;
 558         }
 559         default:
 560             SkFAIL("RRect should always be simple or nine-patch.");
 561     }
 562     // implicit is the evaluation of (x/a)^2 + (y/b)^2 - 1.
 563     fragBuilder->codeAppend("\t\tfloat implicit = dot(Z, dxy) - 1.0;\n");
 564     // grad_dot is the squared length of the gradient of the implicit.
 565     fragBuilder->codeAppendf("\t\tfloat grad_dot = 4.0 * dot(Z, Z);\n");
 566     // avoid calling inversesqrt on zero.
 567     fragBuilder->codeAppend("\t\tgrad_dot = max(grad_dot, 1.0e-4);\n");
 568     fragBuilder->codeAppendf("\t\tfloat approx_dist = implicit * inversesqrt(grad_dot);\n");
 569
 570     if (kFillAA_GrProcessorEdgeType == erre.getEdgeType()) {
 571         fragBuilder->codeAppend("\t\tfloat alpha = clamp(0.5 - approx_dist, 0.0, 1.0);\n");
 572     } else {
 573         fragBuilder->codeAppend("\t\tfloat alpha = clamp(0.5 + approx_dist, 0.0, 1.0);\n");
 574     }
 575
 576     fragBuilder->codeAppendf("\t\t%s = %s;\n", args.fOutputColor,
 577                              (GrGLSLExpr4(args.fInputColor) * GrGLSLExpr1("alpha")).c_str());
 578 }
 579
 580 void GLEllipticalRRectEffect::GenKey(const GrProcessor& effect, const GrGLSLCaps&,
 581                                      GrProcessorKeyBuilder* b) {
 582     const EllipticalRRectEffect& erre = effect.cast<EllipticalRRectEffect>();
 583     GR_STATIC_ASSERT(kLast_GrProcessorEdgeType < (1 << 3));
 584     b->add32(erre.getRRect().getType() | erre.getEdgeType() << 3);
 585 }
 586
 587 void GLEllipticalRRectEffect::onSetData(const GrGLSLProgramDataManager& pdman,
 588                                         const GrProcessor& effect) {
 589     const EllipticalRRectEffect& erre = effect.cast<EllipticalRRectEffect>();
 590     const SkRRect& rrect = erre.getRRect();
 591     if (rrect != fPrevRRect) {
 592         SkRect rect = rrect.getBounds();
 593         const SkVector& r0 = rrect.radii(SkRRect::kUpperLeft_Corner);
 594         SkASSERT(r0.fX >= kRadiusMin);
 595         SkASSERT(r0.fY >= kRadiusMin);
 596         switch (erre.getRRect().getType()) {
 597             case SkRRect::kSimple_Type:
 598                 rect.inset(r0.fX, r0.fY);
 599                 pdman.set2f(fInvRadiiSqdUniform, 1.f / (r0.fX * r0.fX),
 600                                                 1.f / (r0.fY * r0.fY));
 601                 break;
 602             case SkRRect::kNinePatch_Type: {
 603                 const SkVector& r1 = rrect.radii(SkRRect::kLowerRight_Corner);
 604                 SkASSERT(r1.fX >= kRadiusMin);
 605                 SkASSERT(r1.fY >= kRadiusMin);
 606                 rect.fLeft += r0.fX;
 607                 rect.fTop += r0.fY;
 608                 rect.fRight -= r1.fX;
 609                 rect.fBottom -= r1.fY;
 610                 pdman.set4f(fInvRadiiSqdUniform, 1.f / (r0.fX * r0.fX),
 611                                                 1.f / (r0.fY * r0.fY),
 612                                                 1.f / (r1.fX * r1.fX),
 613                                                 1.f / (r1.fY * r1.fY));
 614                 break;
 615             }
 616         default:
 617             SkFAIL("RRect should always be simple or nine-patch.");
 618         }
 619         pdman.set4f(fInnerRectUniform, rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
 620         fPrevRRect = rrect;
 621     }
 622 }
 623
 624 ////////////////////////////////////////////////////////////////////////////////////////////////////
 625
 626 void EllipticalRRectEffect::onGetGLSLProcessorKey(const GrGLSLCaps& caps,
 627                                                   GrProcessorKeyBuilder* b) const {
 628     GLEllipticalRRectEffect::GenKey(*this, caps, b);
 629 }
 630
 631 GrGLSLFragmentProcessor* EllipticalRRectEffect::onCreateGLSLInstance() const  {
 632     return new GLEllipticalRRectEffect(*this);
 633 }
 634
 635 //////////////////////////////////////////////////////////////////////////////
 636
 637 GrFragmentProcessor* GrRRectEffect::Create(GrPrimitiveEdgeType edgeType, const SkRRect& rrect) {
 638     if (rrect.isRect()) {
 639         return GrConvexPolyEffect::Create(edgeType, rrect.getBounds());
 640     }
 641
 642     if (rrect.isOval()) {
 643         return GrOvalEffect::Create(edgeType, rrect.getBounds());
 644     }
 645
 646     if (rrect.isSimple()) {
 647         if (rrect.getSimpleRadii().fX < kRadiusMin || rrect.getSimpleRadii().fY < kRadiusMin) {
 648             // In this case the corners are extremely close to rectangular and we collapse the
 649             // clip to a rectangular clip.
 650             return GrConvexPolyEffect::Create(edgeType, rrect.getBounds());
 651         }
 652         if (rrect.getSimpleRadii().fX == rrect.getSimpleRadii().fY) {
 653             return CircularRRectEffect::Create(edgeType, CircularRRectEffect::kAll_CornerFlags,
 654                                                rrect);
 655         } else {
 656             return EllipticalRRectEffect::Create(edgeType, rrect);
 657         }
 658     }
 659
 660     if (rrect.isComplex() || rrect.isNinePatch()) {
 661         // Check for the "tab" cases - two adjacent circular corners and two square corners.
 662         SkScalar circularRadius = 0;
 663         uint32_t cornerFlags  = 0;
 664
 665         SkVector radii[4];
 666         bool squashedRadii = false;
 667         for (int c = 0; c < 4; ++c) {
 668             radii[c] = rrect.radii((SkRRect::Corner)c);
 669             SkASSERT((0 == radii[c].fX) == (0 == radii[c].fY));
 670             if (0 == radii[c].fX) {
 671                 // The corner is square, so no need to squash or flag as circular.
 672                 continue;
 673             }
 674             if (radii[c].fX < kRadiusMin || radii[c].fY < kRadiusMin) {
 675                 radii[c].set(0, 0);
 676                 squashedRadii = true;
 677                 continue;
 678             }
 679             if (radii[c].fX != radii[c].fY) {
 680                 cornerFlags = ~0U;
 681                 break;
 682             }
 683             if (!cornerFlags) {
 684                 circularRadius = radii[c].fX;
 685                 cornerFlags = 1 << c;
 686             } else {
 687                 if (radii[c].fX != circularRadius) {
 688                    cornerFlags = ~0U;
 689                    break;
 690                 }
 691                 cornerFlags |= 1 << c;
 692             }
 693         }
 694
 695         switch (cornerFlags) {
 696             case CircularRRectEffect::kAll_CornerFlags:
 697                 // This rrect should have been caught in the simple case above. Though, it would
 698                 // be correctly handled in the fallthrough code.
 699                 SkASSERT(false);
 700             case CircularRRectEffect::kTopLeft_CornerFlag:
 701             case CircularRRectEffect::kTopRight_CornerFlag:
 702             case CircularRRectEffect::kBottomRight_CornerFlag:
 703             case CircularRRectEffect::kBottomLeft_CornerFlag:
 704             case CircularRRectEffect::kLeft_CornerFlags:
 705             case CircularRRectEffect::kTop_CornerFlags:
 706             case CircularRRectEffect::kRight_CornerFlags:
 707             case CircularRRectEffect::kBottom_CornerFlags: {
 708                 SkTCopyOnFirstWrite<SkRRect> rr(rrect);
 709                 if (squashedRadii) {
 710                     rr.writable()->setRectRadii(rrect.getBounds(), radii);
 711                 }
 712                 return CircularRRectEffect::Create(edgeType, cornerFlags, *rr);
 713             }
 714             case CircularRRectEffect::kNone_CornerFlags:
 715                 return GrConvexPolyEffect::Create(edgeType, rrect.getBounds());
 716             default: {
 717                 if (squashedRadii) {
 718                     // If we got here then we squashed some but not all the radii to zero. (If all
 719                     // had been squashed cornerFlags would be 0.) The elliptical effect doesn't
 720                     // support some rounded and some square corners.
 721                     return nullptr;
 722                 }
 723                 if (rrect.isNinePatch()) {
 724                     return EllipticalRRectEffect::Create(edgeType, rrect);
 725                 }
 726                 return nullptr;
 727             }
 728         }
 729     }
 730
 731     return nullptr;
 732 }