When clipping treat rrect corners where either the x or y radius is < 0.5 as square.

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"
 #include "gl/GrGLSL.h"
+#include "GrConvexPolyEffect.h"
 #include "GrTBackendEffectFactory.h"
 
 #include "SkRRect.h"
 
+// The effects defined here only handle rrect radii >= kRadiusMin.
+static const SkScalar kRadiusMin = SK_ScalarHalf;
+
+//////////////////////////////////////////////////////////////////////////////
+
 class GLCircularRRectEffect;
 
 class CircularRRectEffect : public GrEffect {
 public:
-    // This effect only supports circular corner rrects where the radius is >= kRadiusMin.
-    static const SkScalar kRadiusMin;
 
     enum CornerFlags {
         kTopLeft_CornerFlag     = (1 << SkRRect::kUpperLeft_Corner),
         kTopRight_CornerFlag    = (1 << SkRRect::kUpperRight_Corner),
         kBottomRight_CornerFlag = (1 << SkRRect::kLowerRight_Corner),
         kBottomLeft_CornerFlag  = (1 << SkRRect::kLowerLeft_Corner),
 
         kLeft_CornerFlags   = kTopLeft_CornerFlag    | kBottomLeft_CornerFlag,
         kTop_CornerFlags    = kTopLeft_CornerFlag    | kTopRight_CornerFlag,
         kRight_CornerFlags  = kTopRight_CornerFlag   | kBottomRight_CornerFlag,
         kBottom_CornerFlags = kBottomLeft_CornerFlag | kBottomRight_CornerFlag,
 
         kAll_CornerFlags = kTopLeft_CornerFlag    | kTopRight_CornerFlag |
                            kBottomLeft_CornerFlag | kBottomRight_CornerFlag,
 
+        kNone_CornerFlags = 0
     };
 
     // The flags are used to indicate which corners are circluar (unflagged corners are assumed to
     // be square).
     static GrEffectRef* Create(GrEffectEdgeType, uint32_t circularCornerFlags, const SkRRect&);
 
     virtual ~CircularRRectEffect() {};
     static const char* Name() { return "CircularRRect"; }
 
     const SkRRect& getRRect() const { return fRRect; }
@@ skipping 15 matching lines @@
 
     SkRRect             fRRect;
     GrEffectEdgeType    fEdgeType;
     uint32_t            fCircularCornerFlags;
 
     GR_DECLARE_EFFECT_TEST;
 
     typedef GrEffect INHERITED;
 };
 
-const SkScalar CircularRRectEffect::kRadiusMin = 0.5f;
-
 GrEffectRef* CircularRRectEffect::Create(GrEffectEdgeType edgeType,
                                  uint32_t circularCornerFlags,
                                  const SkRRect& rrect) {
     SkASSERT(kFillAA_GrEffectEdgeType == edgeType || kInverseFillAA_GrEffectEdgeType == edgeType);
     return CreateEffectRef(AutoEffectUnref(SkNEW_ARGS(CircularRRectEffect,
                                                       (edgeType, circularCornerFlags, rrect))));
 }
 
 void CircularRRectEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
     *validFlags = 0;
@@ skipping 212 matching lines @@
                                     const GrDrawEffect& drawEffect) {
     const CircularRRectEffect& crre = drawEffect.castEffect<CircularRRectEffect>();
     const SkRRect& rrect = crre.getRRect();
     if (rrect != fPrevRRect) {
         SkRect rect = rrect.getBounds();
         SkScalar radius = 0;
         switch (crre.getCircularCornerFlags()) {
             case CircularRRectEffect::kAll_CornerFlags:
                 SkASSERT(rrect.isSimpleCircular());
                 radius = rrect.getSimpleRadii().fX;
-                SkASSERT(radius >= CircularRRectEffect::kRadiusMin);
+                SkASSERT(radius >= kRadiusMin);
                 rect.inset(radius, radius);
                 break;
             case CircularRRectEffect::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 CircularRRectEffect::kTopRight_CornerFlag:
@@ skipping 53 matching lines @@
         fPrevRRect = rrect;
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLEllipticalRRectEffect;
 
 class EllipticalRRectEffect : public GrEffect {
 public:
-    // This effect only supports rrects where the radii are >= kRadiusMin.
-    static const SkScalar kRadiusMin;
-
     static GrEffectRef* Create(GrEffectEdgeType, const SkRRect&);
 
     virtual ~EllipticalRRectEffect() {};
     static const char* Name() { return "EllipticalRRect"; }
 
     const SkRRect& getRRect() const { return fRRect; }
 
 
     GrEffectEdgeType getEdgeType() const { return fEdgeType; }
 
     typedef GLEllipticalRRectEffect GLEffect;
 
     virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
 
     virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
 
 private:
     EllipticalRRectEffect(GrEffectEdgeType, const SkRRect&);
 
     virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE;
 
     SkRRect             fRRect;
     GrEffectEdgeType    fEdgeType;
 
     GR_DECLARE_EFFECT_TEST;
 
     typedef GrEffect INHERITED;
 };
 
-const SkScalar EllipticalRRectEffect::kRadiusMin = 0.5f;
-
 GrEffectRef* EllipticalRRectEffect::Create(GrEffectEdgeType edgeType, const SkRRect& rrect) {
     SkASSERT(kFillAA_GrEffectEdgeType == edgeType || kInverseFillAA_GrEffectEdgeType == edgeType);
     return CreateEffectRef(AutoEffectUnref(SkNEW_ARGS(EllipticalRRectEffect, (edgeType, rrect))));
 }
 
 void EllipticalRRectEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
     *validFlags = 0;
 }
 
 const GrBackendEffectFactory& EllipticalRRectEffect::getFactory() const {
@@ skipping 165 matching lines @@
     return erre.getRRect().getType() | erre.getEdgeType() << 3;
 }
 
 void GLEllipticalRRectEffect::setData(const GrGLUniformManager& uman,
                                       const GrDrawEffect& drawEffect) {
     const EllipticalRRectEffect& erre = drawEffect.castEffect<EllipticalRRectEffect>();
     const SkRRect& rrect = erre.getRRect();
     if (rrect != fPrevRRect) {
         SkRect rect = rrect.getBounds();
         const SkVector& r0 = rrect.radii(SkRRect::kUpperLeft_Corner);
-        SkASSERT(r0.fX >= EllipticalRRectEffect::kRadiusMin);
-        SkASSERT(r0.fY >= EllipticalRRectEffect::kRadiusMin);
+        SkASSERT(r0.fX >= kRadiusMin);
+        SkASSERT(r0.fY >= kRadiusMin);
         switch (erre.getRRect().getType()) {
             case SkRRect::kSimple_Type:
                 rect.inset(r0.fX, r0.fY);
                 uman.set2f(fInvRadiiSqdUniform, 1.f / (r0.fX * r0.fX),
                                                 1.f / (r0.fY * r0.fY));
                 break;
             case SkRRect::kNinePatch_Type: {
                 const SkVector& r1 = rrect.radii(SkRRect::kLowerRight_Corner);
-                SkASSERT(r1.fX >= EllipticalRRectEffect::kRadiusMin);
-                SkASSERT(r1.fY >= EllipticalRRectEffect::kRadiusMin);
+                SkASSERT(r1.fX >= kRadiusMin);
+                SkASSERT(r1.fY >= kRadiusMin);
                 rect.fLeft += r0.fX;
                 rect.fTop += r0.fY;
                 rect.fRight -= r1.fX;
                 rect.fBottom -= r1.fY;
                 uman.set4f(fInvRadiiSqdUniform, 1.f / (r0.fX * r0.fX),
                                                 1.f / (r0.fY * r0.fY),
                                                 1.f / (r1.fX * r1.fX),
                                                 1.f / (r1.fY * r1.fY));
                 break;
             }
         default:
             GrCrash("RRect should always be simple or nine-patch.");
         }
         uman.set4f(fInnerRectUniform, rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
         fPrevRRect = rrect;
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrEffectRef* GrRRectEffect::Create(GrEffectEdgeType edgeType, const SkRRect& rrect) {
     if (kFillAA_GrEffectEdgeType != edgeType && kInverseFillAA_GrEffectEdgeType != edgeType) {
         return NULL;
     }
-    uint32_t cornerFlags;
+
+    if (rrect.isRect()) {
+        return GrConvexPolyEffect::Create(edgeType, rrect.getBounds());
+    }
+
     if (rrect.isSimple()) {
+        if (rrect.getSimpleRadii().fX < kRadiusMin || rrect.getSimpleRadii().fY < kRadiusMin) {
+            // In this case the corners are extremely close to rectangular and we collapse the
+            // clip to a rectangular clip.
+            return GrConvexPolyEffect::Create(edgeType, rrect.getBounds());
+        }
         if (rrect.getSimpleRadii().fX == rrect.getSimpleRadii().fY) {
-            if (rrect.getSimpleRadii().fX < CircularRRectEffect::kRadiusMin) {
-                return NULL;
-            }
-            cornerFlags = CircularRRectEffect::kAll_CornerFlags;
+            return CircularRRectEffect::Create(edgeType, CircularRRectEffect::kAll_CornerFlags, 
+                                               rrect);
         } else {
-            if (rrect.getSimpleRadii().fX < EllipticalRRectEffect::kRadiusMin ||
-                rrect.getSimpleRadii().fY < EllipticalRRectEffect::kRadiusMin) {
-                return NULL;
-            }
             return EllipticalRRectEffect::Create(edgeType, rrect);
         }
-    } else if (rrect.isComplex() || rrect.isNinePatch()) {
+    }
+
+    if (rrect.isComplex() || rrect.isNinePatch()) {
         // Check for the "tab" cases - two adjacent circular corners and two square corners.
-        SkScalar radius = 0;
-        cornerFlags = 0;
+        SkScalar circularRadius = 0;
+        uint32_t cornerFlags  = 0;
+
+        SkVector radii[4];
+        bool squashedRadii = false;
         for (int c = 0; c < 4; ++c) {
-            const SkVector& r = rrect.radii((SkRRect::Corner)c);
-            SkASSERT((0 == r.fX) == (0 == r.fY));
-            if (0 == r.fX) {
+            radii[c] = rrect.radii((SkRRect::Corner)c);
+            SkASSERT((0 == radii[c].fX) == (0 == radii[c].fY));
+            if (0 == radii[c].fX) {
+                // The corner is square, so no need to squash or flag as circular.
                 continue;
             }
-            if (r.fX != r.fY) {
+            if (radii[c].fX < kRadiusMin || radii[c].fY < kRadiusMin) {
+                radii[c].set(0, 0);
+                squashedRadii = true;
+                continue;
+            }
+            if (radii[c].fX != radii[c].fY) {
                 cornerFlags = ~0U;
                 break;
             }
             if (!cornerFlags) {
-                radius = r.fX;
-                if (radius < CircularRRectEffect::kRadiusMin) {
-                    cornerFlags = ~0U;
-                    break;
-                }
+                circularRadius = radii[c].fX;
                 cornerFlags = 1 << c;
             } else {
-                if (r.fX != radius) {
+                if (radii[c].fX != circularRadius) {
                    cornerFlags = ~0U;
                    break;
                 }
                 cornerFlags |= 1 << c;
             }
         }
 
         switch (cornerFlags) {
+            case CircularRRectEffect::kAll_CornerFlags:
+                // This rrect should have been caught in the simple case above. Though, it would
+                // be correctly handled in the fallthrough code.
+                SkASSERT(false);
             case CircularRRectEffect::kTopLeft_CornerFlag:
             case CircularRRectEffect::kTopRight_CornerFlag:
             case CircularRRectEffect::kBottomRight_CornerFlag:
             case CircularRRectEffect::kBottomLeft_CornerFlag:
             case CircularRRectEffect::kLeft_CornerFlags:
             case CircularRRectEffect::kTop_CornerFlags:
             case CircularRRectEffect::kRight_CornerFlags:
-            case CircularRRectEffect::kBottom_CornerFlags:
-            case CircularRRectEffect::kAll_CornerFlags:
-                break;
-            default:
+            case CircularRRectEffect::kBottom_CornerFlags: {
+                SkTCopyOnFirstWrite<SkRRect> rr(rrect);
+                if (squashedRadii) {
+                    rr.writable()->setRectRadii(rrect.getBounds(), radii);
+                }
+                return CircularRRectEffect::Create(edgeType, cornerFlags, *rr);
+            }
+            case CircularRRectEffect::kNone_CornerFlags:
+                return GrConvexPolyEffect::Create(edgeType, rrect.getBounds());
+            default: {
+                if (squashedRadii) {
+                    // If we got here then we squashed some but not all the radii to zero. (If all
+                    // had been squashed cornerFlags would be 0.) The elliptical effect doesn't
+                    // support some rounded and some square corners.
+                    return NULL;
+                }
                 if (rrect.isNinePatch()) {
-                    const SkVector& r0 = rrect.radii(SkRRect::kUpperLeft_Corner);
-                    const SkVector& r1 = rrect.radii(SkRRect::kLowerRight_Corner);
-                    if (r0.fX >= EllipticalRRectEffect::kRadiusMin &&
-                        r0.fY >= EllipticalRRectEffect::kRadiusMin &&
-                        r1.fX >= EllipticalRRectEffect::kRadiusMin &&
-                        r1.fY >= EllipticalRRectEffect::kRadiusMin) {
-                        return EllipticalRRectEffect::Create(edgeType, rrect);
-                    }
+                    return EllipticalRRectEffect::Create(edgeType, rrect);
                 }
                 return NULL;
+            }
         }
-    } else {
-        return NULL;
     }
-    return CircularRRectEffect::Create(edgeType, cornerFlags, rrect);
+
+    return NULL;
 }