Fixup SkRRectsGaussianEdgeShader's shaders

gm/reveal.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gm.h"
 #include "SkAnimTimer.h"
 #include "SkBlurMaskFilter.h"
@@ skipping 10 matching lines @@
 constexpr SkScalar kPad = 8.0f;
 constexpr SkScalar kPeriod = 8.0f;
 constexpr int kClipOffset = 32;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 class Object {
 public:
     virtual ~Object() {}
     virtual bool asRRect(SkRRect* rr) const = 0;
-    virtual SkPath asPath() const = 0;
+    virtual SkPath asPath(SkScalar inset) const = 0;
     virtual void draw(SkCanvas* canvas, const SkPaint& paint) const = 0;
     virtual void clip(SkCanvas* canvas) const = 0;
     virtual bool contains(const SkRect& r) const = 0;
     virtual const SkRect& bounds() const = 0;
 };
 
 typedef Object* (*PFMakeMthd)(const SkRect& r);
 
 class RRect : public Object {
 public:
     RRect(const SkRect& r) {
         fRRect = SkRRect::MakeRectXY(r, 4*kPad, 4*kPad);
     }
 
     bool asRRect(SkRRect* rr) const override {
         *rr = fRRect;
         return true;
     }
 
-    SkPath asPath() const override { 
+    SkPath asPath(SkScalar inset) const override {
+        SkRRect tmp = fRRect;
+        tmp.inset(inset, inset);
         SkPath p;
-        p.addRRect(fRRect);
+        p.addRRect(tmp);
         return p;
     }
 
     void draw(SkCanvas* canvas, const SkPaint& paint) const override {
         canvas->drawRRect(fRRect, paint);
     }
 
     void clip(SkCanvas* canvas) const override {
         canvas->clipRRect(fRRect);
     }
@@ skipping 18 matching lines @@
 public:
     StrokedRRect(const SkRect& r) {
         fRRect = SkRRect::MakeRectXY(r, 2*kPad, 2*kPad);
         fStrokedBounds = r.makeOutset(kPad, kPad);
     }
 
     bool asRRect(SkRRect* rr) const override {
         return false;
     }
 
-    SkPath asPath() const override {
+    SkPath asPath(SkScalar inset) const override {
+        SkRRect tmp = fRRect;
+        tmp.inset(inset, inset);
+
         // In this case we want the outline of the stroked rrect
         SkPaint paint;
         paint.setAntiAlias(true);
         paint.setStyle(SkPaint::kStroke_Style);
         paint.setStrokeWidth(kPad);
 
         SkPath p, stroked;
-        p.addRRect(fRRect);
+        p.addRRect(tmp);
         SkStroke stroke(paint);
         stroke.strokePath(p, &stroked);
         return stroked;
     }
 
     void draw(SkCanvas* canvas, const SkPaint& paint) const override {
         SkPaint stroke(paint);
         stroke.setStyle(SkPaint::kStroke_Style);
         stroke.setStrokeWidth(kPad);
 
         canvas->drawRRect(fRRect, stroke);
     }
 
     void clip(SkCanvas* canvas) const override {
-        canvas->clipPath(this->asPath());
+        canvas->clipPath(this->asPath(0.0f));
     }
 
     bool contains(const SkRect& r) const override {
         return false;
     }
 
     const SkRect& bounds() const override {
         return fStrokedBounds;
     }
 
@@ skipping 10 matching lines @@
 public:
     Oval(const SkRect& r) {
         fRRect = SkRRect::MakeOval(r);
     }
 
     bool asRRect(SkRRect* rr) const override {
         *rr = fRRect;
         return true;
     }
 
-    SkPath asPath() const override { 
+    SkPath asPath(SkScalar inset) const override { 
+        SkRRect tmp = fRRect;
+        tmp.inset(inset, inset);
+
         SkPath p;
-        p.addRRect(fRRect);
+        p.addRRect(tmp);
         return p;
     }
 
     void draw(SkCanvas* canvas, const SkPaint& paint) const override {
         canvas->drawRRect(fRRect, paint);
     }
 
     void clip(SkCanvas* canvas) const override {
         canvas->clipRRect(fRRect);
     }
@@ skipping 16 matching lines @@
 
 class Rect : public Object {
 public:
     Rect(const SkRect& r) : fRect(r) { }
 
     bool asRRect(SkRRect* rr) const override {
         *rr = SkRRect::MakeRect(fRect);
         return true;
     }
 
-    SkPath asPath() const override { 
+    SkPath asPath(SkScalar inset) const override { 
+        SkRect tmp = fRect;
+        tmp.inset(inset, inset);
+
         SkPath p;
-        p.addRect(fRect);
+        p.addRect(tmp);
         return p;
     }
 
     void draw(SkCanvas* canvas, const SkPaint& paint) const override {
         canvas->drawRect(fRect, paint);
     }
 
     void clip(SkCanvas* canvas) const override {
         canvas->clipRect(fRect);
     }
@@ skipping 33 matching lines @@
         fPath.lineTo(r.centerX() + points[2].fX * width, r.centerY() + points[2].fY * height);
         fPath.lineTo(r.centerX() + points[3].fX * width, r.centerY() + points[3].fY * height);
         fPath.lineTo(r.centerX() + points[4].fX * width, r.centerY() + points[4].fY * height);
         fPath.close();
     }
 
     bool asRRect(SkRRect* rr) const override {
         return false;
     }
 
-    SkPath asPath() const override { return fPath; }
+    SkPath asPath(SkScalar inset) const override { return fPath; }
 
     void draw(SkCanvas* canvas, const SkPaint& paint) const override {
         canvas->drawPath(fPath, paint);
     }
 
     void clip(SkCanvas* canvas) const override {
-        canvas->clipPath(this->asPath());
+        canvas->clipPath(this->asPath(0.0f));
     }
 
     bool contains(const SkRect& r) const override {
         return false;
     }
 
     const SkRect& bounds() const override {
         return fPath.getBounds();
     }
 
@@ skipping 14 matching lines @@
     enum Mode {
         kGaussianEdge_Mode,
         kBlurMask_Mode,
         kRRectsGaussianEdge_Mode,
 
         kLast_Mode = kRRectsGaussianEdge_Mode
     };
 
     static const int kModeCount = kLast_Mode + 1;
 
-    RevealGM() : fFraction(0.5f), fMode(kRRectsGaussianEdge_Mode) {
+    RevealGM() : fFraction(0.5f), fMode(kRRectsGaussianEdge_Mode), fPause(false) {
         this->setBGColor(sk_tool_utils::color_to_565(0xFFCCCCCC));
     }
 
 protected:
 
     SkString onShortName() override {
         return SkString("reveal");
     }
 
     SkISize onISize() override {
@@ skipping 43 matching lines @@
                         SkPaint paint;
                         paint.setAntiAlias(true);
                         // G channel is an F6.2 radius
                         paint.setColor(SkColorSetARGB(255, 255, (unsigned char)(4*kPad), 0));
                         paint.setShader(SkGaussianEdgeShader::Make());
                         drawObj->draw(canvas, paint);
                     canvas->restore();
                 } else if (kBlurMask_Mode == fMode) {
                     SkPath clippedPath;
 
+                    SkScalar sigma = kPad / 4.0f;
+
                     if (clipObj->contains(drawObj->bounds())) {
-                        clippedPath = drawObj->asPath();
+                        clippedPath = drawObj->asPath(2.0f*sigma);
                     } else {
-                        SkPath drawnPath = drawObj->asPath();
-                        SkPath clipPath  = clipObj->asPath();
+                        SkPath drawnPath = drawObj->asPath(2.0f*sigma);
+                        SkPath clipPath  = clipObj->asPath(2.0f*sigma);
 
                         SkAssertResult(Op(clipPath, drawnPath, kIntersect_SkPathOp, &clippedPath));
                     }
 
                     SkPaint blurPaint;
                     blurPaint.setAntiAlias(true);
-                    blurPaint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, 3.0f));
+                    blurPaint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, sigma));
                     canvas->drawPath(clippedPath, blurPaint);
                 } else {
                     SkASSERT(kRRectsGaussianEdge_Mode == fMode);
 
                     SkRect cover = drawObj->bounds();
                     SkAssertResult(cover.intersect(clipObj->bounds()));
 
                     SkPaint paint;
 
                     SkRRect clipRR, drawnRR;
 
                     if (clipObj->asRRect(&clipRR) && drawObj->asRRect(&drawnRR)) {
                         paint.setShader(SkRRectsGaussianEdgeShader::Make(clipRR, drawnRR,
                                                                          kPad, 0.0f));
                     }
 
                     canvas->drawRect(cover, paint);
                 }
 
                 // Draw the clip and draw objects for reference
                 SkPaint strokePaint;
                 strokePaint.setStyle(SkPaint::kStroke_Style);
                 strokePaint.setStrokeWidth(0);
                 strokePaint.setColor(SK_ColorRED);
-                canvas->drawPath(drawObj->asPath(), strokePaint);
+                canvas->drawPath(drawObj->asPath(0.0f), strokePaint);
                 strokePaint.setColor(SK_ColorGREEN);
-                canvas->drawPath(clipObj->asPath(), strokePaint);
+                canvas->drawPath(clipObj->asPath(0.0f), strokePaint);
 
                 canvas->restore();
             }
         }
     }
 
     bool onHandleKey(SkUnichar uni) override {
         switch (uni) {
             case 'C':
                 fMode = (Mode)((fMode + 1) % kModeCount);
                 return true;
+            case 'p':
+                fPause = !fPause;
+                return true;
         }        
     
         return false;
     }
 
     bool onAnimate(const SkAnimTimer& timer) override {
-        fFraction = timer.pingPong(kPeriod, 0.0f, 0.0f, 1.0f);
+        if (!fPause) {
+            fFraction = timer.pingPong(kPeriod, 0.0f, 0.0f, 1.0f);
+        }
         return true;
     }
 
 private:
     SkScalar fFraction;
     Mode     fMode;
+    bool     fPause;
 
     typedef GM INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 DEF_GM(return new RevealGM;)
 }