Home | History | Annotate | Download | only in gm 
      1 /*
      2  * Copyright 2011 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 
     12 class BlursGM : public skiagm::GM {
     13 public:
     14     BlursGM() {
     15         this->setBGColor(0xFFDDDDDD);
     16     }
     17 
     18 protected:
     19 
     20     SkString onShortName() override {
     21         return SkString("blurs");
     22     }
     23 
     24     SkISize onISize() override {
     25         return SkISize::Make(700, 500);
     26     }
     27 
     28     void onDraw(SkCanvas* canvas) override {
     29         SkBlurStyle NONE = SkBlurStyle(-999);
     30         static const struct {
     31             SkBlurStyle fStyle;
     32             int         fCx, fCy;
     33         } gRecs[] = {
     34             { NONE,                 0,  0 },
     35             { kInner_SkBlurStyle,  -1,  0 },
     36             { kNormal_SkBlurStyle,  0,  1 },
     37             { kSolid_SkBlurStyle,   0, -1 },
     38             { kOuter_SkBlurStyle,   1,  0 },
     39         };
     40 
     41         SkPaint paint;
     42         paint.setAntiAlias(true);
     43         sk_tool_utils::set_portable_typeface(&paint);
     44         paint.setTextSize(SkIntToScalar(25));
     45         canvas->translate(SkIntToScalar(-40), SkIntToScalar(0));
     46 
     47         SkBlurMaskFilter::BlurFlags flags = SkBlurMaskFilter::kNone_BlurFlag;
     48         for (int j = 0; j < 2; j++) {
     49             canvas->save();
     50             paint.setColor(SK_ColorBLUE);
     51             for (size_t i = 0; i < SK_ARRAY_COUNT(gRecs); i++) {
     52                 if (gRecs[i].fStyle != NONE) {
     53                     SkMaskFilter* mf = SkBlurMaskFilter::Create(gRecs[i].fStyle,
     54                                            SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(20)),
     55                                            flags);
     56                     paint.setMaskFilter(mf)->unref();
     57                 } else {
     58                     paint.setMaskFilter(NULL);
     59                 }
     60                 canvas->drawCircle(SkIntToScalar(200 + gRecs[i].fCx*100),
     61                                    SkIntToScalar(200 + gRecs[i].fCy*100),
     62                                    SkIntToScalar(50),
     63                                    paint);
     64             }
     65             // draw text
     66             {
     67                 SkMaskFilter* mf = SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
     68                                            SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(4)),
     69                                            flags);
     70                 paint.setMaskFilter(mf)->unref();
     71                 SkScalar x = SkIntToScalar(70);
     72                 SkScalar y = SkIntToScalar(400);
     73                 paint.setColor(SK_ColorBLACK);
     74                 canvas->drawText("Hamburgefons Style", 18, x, y, paint);
     75                 canvas->drawText("Hamburgefons Style", 18,
     76                                  x, y + SkIntToScalar(50), paint);
     77                 paint.setMaskFilter(NULL);
     78                 paint.setColor(SK_ColorWHITE);
     79                 x -= SkIntToScalar(2);
     80                 y -= SkIntToScalar(2);
     81                 canvas->drawText("Hamburgefons Style", 18, x, y, paint);
     82             }
     83             canvas->restore();
     84             flags = SkBlurMaskFilter::kHighQuality_BlurFlag;
     85             canvas->translate(SkIntToScalar(350), SkIntToScalar(0));
     86         }
     87     }
     88 
     89 private:
     90     typedef skiagm::GM INHERITED;
     91 };
     92 DEF_GM( return new BlursGM; )
     93 
     94 //////////////////////////////////////////////////////////////////////////////////////////////
     95 
     96 // exercise a special-case of blurs, which is two nested rects. These are drawn specially,
     97 // and possibly cached.
     98 //
     99 // in particular, we want to notice that the 2nd rect draws slightly differently, since it
    100 // is translated a fractional amount.
    101 //
    102 class Blur2RectsGM : public skiagm::GM {
    103 public:
    104     SkString onShortName() override {
    105         return SkString("blur2rects");
    106     }
    107 
    108     SkISize onISize() override {
    109         return SkISize::Make(700, 500);
    110     }
    111 
    112     void onDraw(SkCanvas* canvas) override {
    113         SkPaint paint;
    114 
    115         paint.setMaskFilter(SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
    116                                                      2.3f))->unref();
    117 
    118         SkRect outer = SkRect::MakeXYWH(10.125f, 10.125f, 100.125f, 100);
    119         SkRect inner = SkRect::MakeXYWH(20.25f, 20.125f, 80, 80);
    120         SkPath path;
    121         path.addRect(outer, SkPath::kCW_Direction);
    122         path.addRect(inner, SkPath::kCCW_Direction);
    123 
    124         canvas->drawPath(path, paint);
    125         // important to translate by a factional amount to exercise a different "phase"
    126         // of the same path w.r.t. the pixel grid
    127         SkScalar dx = SkScalarRoundToScalar(path.getBounds().width()) + 14 + 0.25f;
    128         canvas->translate(dx, 0);
    129         canvas->drawPath(path, paint);
    130     }
    131 };
    132 DEF_GM( return new Blur2RectsGM; )
    133 
    134 class Blur2RectsNonNinePatchGM : public skiagm::GM {
    135 public:
    136     SkString onShortName() override {
    137         return SkString("blur2rectsnonninepatch");
    138     }
    139 
    140     SkISize onISize() override {
    141         return SkISize::Make(700, 500);
    142     }
    143 
    144     void onDraw(SkCanvas* canvas) override {
    145         SkPaint paint;
    146         paint.setMaskFilter(SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
    147                                                      4.3f))->unref();
    148 
    149         SkRect outer = SkRect::MakeXYWH(10, 110, 100, 100);
    150         SkRect inner = SkRect::MakeXYWH(50, 150, 10, 10);
    151         SkPath path;
    152         path.addRect(outer, SkPath::kCW_Direction);
    153         path.addRect(inner, SkPath::kCW_Direction);
    154         canvas->drawPath(path, paint);
    155 
    156         SkScalar dx = SkScalarRoundToScalar(path.getBounds().width()) + 40 + 0.25f;
    157         canvas->translate(dx, 0);
    158         canvas->drawPath(path, paint);
    159 
    160         // Translate to outside of clip bounds.
    161         canvas->translate(-dx, 0);
    162         canvas->translate(-30, -150);
    163         canvas->drawPath(path, paint);
    164     }
    165 };
    166 DEF_GM( return new Blur2RectsNonNinePatchGM; )
    167