Handle rrects with one circular corner and three square corners in GrRRectEffect.

src/gpu/effects/GrRRectEffect.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrRRectEffect.h"
 
 #include "gl/GrGLEffect.h"
@@ skipping 147 matching lines @@
 void GLRRectEffect::emitCode(GrGLShaderBuilder* builder,
                              const GrDrawEffect& drawEffect,
                              EffectKey key,
                              const char* outputColor,
                              const char* inputColor,
                              const TransformedCoordsArray&,
                              const TextureSamplerArray& samplers) {
     const RRectEffect& rre = drawEffect.castEffect<RRectEffect>();
     const char *rectName;
     const char *radiusPlusHalfName;
-    // The inner rect is the rrect bounds inset by the radius. Its top, left, right, and bottom
-    // edges correspond to components x, y, z, and w, respectively. When one side of the rrect has
-    // rectangular corners, that side's value corresponds to the rect edge's value outset by half a
-    // pixel.
+    // The inner rect is the rrect bounds inset by the radius. Its left, top, right, and bottom
+    // edges correspond to components x, y, z, and w, respectively. When a side of the rrect has
+    // only rectangular corners, that side's value corresponds to the rect edge's value outset by
+    // half a pixel.
     fInnerRectUniform = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
                                             kVec4f_GrSLType,
                                             "innerRect",
                                             &rectName);
     fRadiusPlusHalfUniform = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
                                                  kFloat_GrSLType,
                                                  "radiusPlusHalf",
                                                  &radiusPlusHalfName);
     const char* fragmentPos = builder->fragmentPosition();
     // At each quarter-circle corner we compute a vector that is the offset of the fragment position
@@ skipping 12 matching lines @@
     // computations, compute a separate rect edge alpha for the rect side, and mul the two computed
     // alphas together.
     switch (rre.getCircularCornerFlags()) {
         case RRectEffect::kAll_CornerFlags:
             builder->fsCodeAppendf("\t\tvec2 dxy0 = %s.xy - %s.xy;\n", rectName, fragmentPos);
             builder->fsCodeAppendf("\t\tvec2 dxy1 = %s.xy - %s.zw;\n", fragmentPos, rectName);
             builder->fsCodeAppend("\t\tvec2 dxy = max(max(dxy0, dxy1), 0.0);\n");
             builder->fsCodeAppendf("\t\tfloat alpha = clamp(%s - length(dxy), 0.0, 1.0);\n",
                                    radiusPlusHalfName);
             break;
+        case RRectEffect::kTopLeft_CornerFlag:
+            builder->fsCodeAppendf("\t\tvec2 dxy = max(%s.xy - %s.xy, 0.0);\n", rectName, fragmentPos);
+            builder->fsCodeAppendf("\t\tfloat rightAlpha = clamp(%s.z - %s.x, 0.0, 1.0);\n",
+                                    rectName, fragmentPos);
+            builder->fsCodeAppendf("\t\tfloat bottomAlpha = clamp(%s.w - %s.y, 0.0, 1.0);\n",
+                                    rectName, fragmentPos);
+            builder->fsCodeAppendf("\t\tfloat alpha = bottomAlpha * rightAlpha * clamp(%s - length(dxy), 0.0, 1.0);\n",
+                                   radiusPlusHalfName);
+            break;
+        case RRectEffect::kTopRight_CornerFlag:
+            builder->fsCodeAppendf("\t\tvec2 dxy = max(vec2(%s.x - %s.z, %s.y - %s.y), 0.0);\n",
+                                   fragmentPos, rectName, rectName, fragmentPos);

[jvanverth1, 2014/03/11 14:53:23]

I suppose it doesn't matter because you're taking the length of dxy, but I found
it confusing that you have x - right and top - y. I'd expect right-x and top-y
(assuming y up).

[bsalomon, 2014/03/11 15:11:04]

Yup, it's a bit weird. It's done that way so that for each corner dxy is >= 0 if
the frag is in the relevant quadrant. It allows max(dxy, 0) to clamp out the
interior for all the (non-square) corners.

+            builder->fsCodeAppendf("\t\tfloat leftAlpha = clamp(%s.x - %s.x, 0.0, 1.0);\n",
+                                   fragmentPos, rectName);
+            builder->fsCodeAppendf("\t\tfloat bottomAlpha = clamp(%s.w - %s.y, 0.0, 1.0);\n",
+                                    rectName, fragmentPos);
+            builder->fsCodeAppendf("\t\tfloat alpha = bottomAlpha * leftAlpha * clamp(%s - length(dxy), 0.0, 1.0);\n",
+                                   radiusPlusHalfName);
+            break;
+        case RRectEffect::kBottomRight_CornerFlag:
+            builder->fsCodeAppendf("\t\tvec2 dxy = max(%s.xy - %s.zw, 0.0);\n",
+                                   fragmentPos, rectName);
+            builder->fsCodeAppendf("\t\tfloat leftAlpha = clamp(%s.x - %s.x, 0.0, 1.0);\n",
+                                   fragmentPos, rectName);
+            builder->fsCodeAppendf("\t\tfloat topAlpha = clamp(%s.y - %s.y, 0.0, 1.0);\n",
+                                   fragmentPos, rectName);
+            builder->fsCodeAppendf("\t\tfloat alpha = topAlpha * leftAlpha * clamp(%s - length(dxy), 0.0, 1.0);\n",
+                                   radiusPlusHalfName);
+            break;
+        case RRectEffect::kBottomLeft_CornerFlag:
+            builder->fsCodeAppendf("\t\tvec2 dxy = max(vec2(%s.x - %s.x, %s.y - %s.w), 0.0);\n",
+                                   rectName, fragmentPos, fragmentPos, rectName);
+            builder->fsCodeAppendf("\t\tfloat rightAlpha = clamp(%s.z - %s.x, 0.0, 1.0);\n",
+                                    rectName, fragmentPos);
+            builder->fsCodeAppendf("\t\tfloat topAlpha = clamp(%s.y - %s.y, 0.0, 1.0);\n",
+                                   fragmentPos, rectName);
+            builder->fsCodeAppendf("\t\tfloat alpha = topAlpha * rightAlpha * clamp(%s - length(dxy), 0.0, 1.0);\n",
+                                   radiusPlusHalfName);
+            break;
         case RRectEffect::kLeft_CornerFlags:
             builder->fsCodeAppendf("\t\tvec2 dxy0 = %s.xy - %s.xy;\n", rectName, fragmentPos);
             builder->fsCodeAppendf("\t\tfloat dy1 = %s.y - %s.w;\n", fragmentPos, rectName);
             builder->fsCodeAppend("\t\tvec2 dxy = max(vec2(dxy0.x, max(dxy0.y, dy1)), 0.0);\n");
             builder->fsCodeAppendf("\t\tfloat rightAlpha = clamp(%s.z - %s.x, 0.0, 1.0);\n",
                                     rectName, fragmentPos);
             builder->fsCodeAppendf("\t\tfloat alpha = rightAlpha * clamp(%s - length(dxy), 0.0, 1.0);\n",
                                    radiusPlusHalfName);
             break;
         case RRectEffect::kTop_CornerFlags:
@@ skipping 45 matching lines @@
     if (rrect != fPrevRRect) {
         SkRect rect = rrect.getBounds();
         SkScalar radius = 0;
         switch (rre.getCircularCornerFlags()) {
             case RRectEffect::kAll_CornerFlags:
                 SkASSERT(rrect.isSimpleCircular());
                 radius = rrect.getSimpleRadii().fX;
                 SkASSERT(radius >= RRectEffect::kRadiusMin);
                 rect.inset(radius, radius);
                 break;
+            case RRectEffect::kTopLeft_CornerFlag:
+                radius = rrect.radii(SkRRect::kUpperLeft_Corner).fX;
+                rect.fLeft += radius;
+                rect.fTop += radius;
+                rect.fRight += 0.5f;
+                rect.fBottom += 0.5f;
+                break;
+            case RRectEffect::kTopRight_CornerFlag:
+                radius = rrect.radii(SkRRect::kUpperRight_Corner).fX;
+                rect.fLeft -= 0.5;
+                rect.fTop += radius;
+                rect.fRight -= radius;
+                rect.fBottom += 0.5f;
+                break;
+            case RRectEffect::kBottomRight_CornerFlag:
+                radius = rrect.radii(SkRRect::kLowerRight_Corner).fX;
+                rect.fLeft -= 0.5;
+                rect.fTop -= 0.5;
+                rect.fRight -= radius;
+                rect.fBottom -= radius;
+                break;
+            case RRectEffect::kBottomLeft_CornerFlag:
+                radius = rrect.radii(SkRRect::kLowerLeft_Corner).fX;
+                rect.fLeft += radius;
+                rect.fTop -= 0.5;
+                rect.fRight += 0.5;
+                rect.fBottom -= radius;
+                break;
             case RRectEffect::kLeft_CornerFlags:
                 radius = rrect.radii(SkRRect::kUpperLeft_Corner).fX;
                 rect.fLeft += radius;
                 rect.fTop += radius;
                 rect.fRight += 0.5f;
                 rect.fBottom -= radius;
                 break;
             case RRectEffect::kTop_CornerFlags:
                 radius = rrect.radii(SkRRect::kUpperLeft_Corner).fX;
                 rect.fLeft += radius;
@@ skipping 57 matching lines @@
                 cornerFlags = 1 << c;
             } else {
                 if (r.fX != radius) {
                     return NULL;
                 }
                 cornerFlags |= 1 << c;
             }
         }
 
         switch (cornerFlags) {
+            case RRectEffect::kTopLeft_CornerFlag:
+            case RRectEffect::kTopRight_CornerFlag:
+            case RRectEffect::kBottomRight_CornerFlag:
+            case RRectEffect::kBottomLeft_CornerFlag:
             case RRectEffect::kLeft_CornerFlags:
             case RRectEffect::kTop_CornerFlags:
             case RRectEffect::kRight_CornerFlags:
             case RRectEffect::kBottom_CornerFlags:
             case RRectEffect::kAll_CornerFlags:
                 break;
             default:
                 return NULL;
         }
     } else {
         return NULL;
     }
     return RRectEffect::Create(edgeType, cornerFlags, rrect);
 }