src/third_party/skia/gm/blurroundrect.cpp

   1 /*
   2 * Copyright 2013 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 "gm.h"
   9 #include "SkBlurMask.h"
  10 #include "SkBlurMaskFilter.h"
  11 #include "SkCanvas.h"
  12 #include "SkColorFilter.h"
  13 #include "SkLayerDrawLooper.h"
  14 #include "SkPaint.h"
  15 #include "SkPath.h"
  16 #include "SkPoint.h"
  17 #include "SkRect.h"
  18 #include "SkRRect.h"
  19 #include "SkString.h"
  20 #include "SkXfermode.h"
  21
  22 // This GM mimics a blurred RR seen in the wild.
  23 class BlurRoundRectGM : public skiagm::GM {
  24 public:
  25     BlurRoundRectGM(int width, int height, int radius)
  26         : fName("blurroundrect")
  27     {
  28         SkRect r = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
  29         fRRect.setRectXY(r, SkIntToScalar(radius), SkIntToScalar(radius));
  30         fName.appendf("-WH-%ix%i-corner-%i", width, height, radius);
  31     }
  32
  33     BlurRoundRectGM(int width, int height)
  34         : fName("blurroundrect") {
  35         fName.appendf("-WH-%ix%i-unevenCorners", width,  height);
  36         SkVector radii[4];
  37         radii[0].set(SkIntToScalar(30), SkIntToScalar(30));
  38         radii[1].set(SkIntToScalar(10), SkIntToScalar(10));
  39         radii[2].set(SkIntToScalar(30), SkIntToScalar(30));
  40         radii[3].set(SkIntToScalar(10), SkIntToScalar(10));
  41         SkRect r = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
  42         fRRect.setRectRadii(r, radii);
  43     }
  44
  45     virtual SkString onShortName() SK_OVERRIDE {
  46         return fName;
  47     }
  48
  49     virtual SkISize onISize() SK_OVERRIDE {
  50         return SkISize::Make(SkScalarCeilToInt(fRRect.rect().width()),
  51                              SkScalarCeilToInt(fRRect.rect().height()));
  52     }
  53
  54     virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
  55         SkLayerDrawLooper::Builder looperBuilder;
  56         {
  57             SkLayerDrawLooper::LayerInfo info;
  58             info.fPaintBits = SkLayerDrawLooper::kMaskFilter_Bit
  59                               | SkLayerDrawLooper::kColorFilter_Bit;
  60             info.fColorMode = SkXfermode::kSrc_Mode;
  61             info.fOffset = SkPoint::Make(SkIntToScalar(-1), SkIntToScalar(0));
  62             info.fPostTranslate = false;
  63             SkPaint* paint = looperBuilder.addLayerOnTop(info);
  64             SkMaskFilter* maskFilter = SkBlurMaskFilter::Create(
  65                     kNormal_SkBlurStyle,
  66                     SkBlurMask::ConvertRadiusToSigma(SK_ScalarHalf),
  67                     SkBlurMaskFilter::kHighQuality_BlurFlag);
  68             paint->setMaskFilter(maskFilter)->unref();
  69             SkColorFilter* colorFilter = SkColorFilter::CreateModeFilter(SK_ColorLTGRAY,
  70                     SkXfermode::kSrcIn_Mode);
  71             paint->setColorFilter(colorFilter)->unref();
  72             paint->setColor(SK_ColorGRAY);
  73         }
  74         {
  75             SkLayerDrawLooper::LayerInfo info;
  76             looperBuilder.addLayerOnTop(info);
  77         }
  78         SkPaint paint;
  79         canvas->drawRect(fRRect.rect(), paint);
  80
  81         paint.setLooper(looperBuilder.detachLooper())->unref();
  82         paint.setColor(SK_ColorCYAN);
  83         paint.setAntiAlias(true);
  84
  85         canvas->drawRRect(fRRect, paint);
  86     }
  87
  88 private:
  89     SkString        fName;
  90     SkRRect         fRRect;
  91
  92     typedef skiagm::GM INHERITED;
  93 };
  94
  95 // Simpler blurred RR test cases where all the radii are the same.
  96 class SimpleBlurRoundRectGM : public skiagm::GM {
  97 public:
  98     SimpleBlurRoundRectGM()
  99         : fName("simpleblurroundrect") {
 100     }
 101
 102 protected:
 103     virtual SkString onShortName() SK_OVERRIDE {
 104         return fName;
 105     }
 106
 107     virtual SkISize onISize() SK_OVERRIDE {
 108         return SkISize::Make(950, 950);
 109     }
 110
 111     virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
 112         canvas->scale(1.5f, 1.5f);
 113         canvas->translate(50,50);
 114
 115         const float blurRadii[] = { 1,5,10,20 };
 116         const int cornerRadii[] = { 1,5,10,20 };
 117         const SkRect r = SkRect::MakeWH(SkIntToScalar(100), SkIntToScalar(100));
 118         for (size_t i = 0; i < SK_ARRAY_COUNT(blurRadii); ++i) {
 119             SkAutoCanvasRestore autoRestore(canvas, true);
 120             canvas->translate(0, (r.height() + SkIntToScalar(50)) * i);
 121             for (size_t j = 0; j < SK_ARRAY_COUNT(cornerRadii); ++j) {
 122                 SkMaskFilter* filter = SkBlurMaskFilter::Create(
 123                     kNormal_SkBlurStyle,
 124                     SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(blurRadii[i])),
 125                     SkBlurMaskFilter::kHighQuality_BlurFlag);
 126                 SkPaint paint;
 127                 paint.setColor(SK_ColorBLACK);
 128                 paint.setMaskFilter(filter)->unref();
 129
 130                 SkRRect rrect;
 131                 rrect.setRectXY(r, SkIntToScalar(cornerRadii[j]), SkIntToScalar(cornerRadii[j]));
 132                 canvas->drawRRect(rrect, paint);
 133                 canvas->translate(r.width() + SkIntToScalar(50), 0);
 134             }
 135         }
 136     }
 137 private:
 138     const SkString  fName;
 139
 140     typedef         skiagm::GM INHERITED;
 141 };
 142
 143 // Create one with dimensions/rounded corners based on the skp
 144 //
 145 // TODO(scroggo): Disabled in an attempt to rememdy
 146 // https://code.google.com/p/skia/issues/detail?id=1801 ('Win7 Test bots all failing GenerateGMs:
 147 // ran wrong number of tests')
 148 //DEF_GM(return new BlurRoundRectGM(600, 5514, 6);)
 149
 150 // Rounded rect with two opposite corners with large radii, the other two
 151 // small.
 152 DEF_GM(return new BlurRoundRectGM(100, 100);)
 153
 154 DEF_GM(return new SimpleBlurRoundRectGM();)