• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2017 Google Inc.
3  *
4  * Use of this source code is governed by a BD-style license that can be
5  * found in the LICENSE file.
6  */
7 
8 #include "gm.h"
9 #include "sk_tool_utils.h"
10 
11 #include "SkBlurMask.h"
12 #include "SkBlurMaskFilter.h"
13 #include "SkCanvas.h"
14 #include "SkPaint.h"
15 
16 // This GM tests out the SkBlurMaskFilter's kIgnoreTransform flag. That flag causes the blur mask
17 // filter to not apply the CTM to the blur's radius.
18 class BlurIgnoreXformGM : public skiagm::GM {
19 public:
20     enum class DrawType {
21         kCircle,
22         kRect,
23         kRRect,
24     };
25 
BlurIgnoreXformGM(DrawType drawType)26     BlurIgnoreXformGM(DrawType drawType) : fDrawType(drawType) { }
27 
28 protected:
runAsBench() const29     bool runAsBench() const override { return true; }
30 
onShortName()31     SkString onShortName() override {
32         SkString name;
33         name.printf("blur_ignore_xform_%s",
34                     DrawType::kCircle == fDrawType ? "circle"
35                         : DrawType::kRect == fDrawType ? "rect" : "rrect");
36         return name;
37     }
38 
onISize()39     SkISize onISize() override {
40         return SkISize::Make(375, 475);
41     }
42 
onOnceBeforeDraw()43     void onOnceBeforeDraw() override {
44         for (int i = 0; i < kNumBlurs; ++i) {
45             fBlurFilters[i] = SkBlurMaskFilter::Make(
46                                     kNormal_SkBlurStyle,
47                                     SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(20)),
48                                     SkBlurMaskFilter::kHighQuality_BlurFlag | kBlurFlags[i].fFlags);
49         }
50     }
51 
onDraw(SkCanvas * canvas)52     void onDraw(SkCanvas* canvas) override {
53         SkPaint paint;
54         paint.setColor(SK_ColorBLACK);
55         paint.setAntiAlias(true);
56 
57         canvas->translate(10, 25);
58         canvas->save();
59         canvas->translate(80, 0);
60         for (size_t i = 0; i < kNumBlurs; ++i) {
61             SkAutoCanvasRestore autoRestore(canvas, true);
62             canvas->translate(SkIntToScalar(i * 150), 0);
63             for (auto scale : kMatrixScales) {
64                 canvas->save();
65                 canvas->scale(scale.fScale, scale.fScale);
66                 static const SkScalar kRadius = 20.0f;
67                 SkScalar coord = 50.0f * 1.0f / scale.fScale;
68                 SkRect rect = SkRect::MakeXYWH(coord - kRadius , coord - kRadius,
69                                                2 * kRadius, 2 * kRadius);
70                 SkRRect rrect = SkRRect::MakeRectXY(rect, kRadius/2.0f, kRadius/2.0f);
71 
72                 paint.setMaskFilter(fBlurFilters[i]);
73                 for (int j = 0; j < 2; ++j) {
74                     canvas->save();
75                     canvas->translate(10 * (1 - j), 10 * (1 - j));
76                     if (DrawType::kCircle == fDrawType) {
77                         canvas->drawCircle(coord, coord, kRadius, paint);
78                     } else if (DrawType::kRect == fDrawType) {
79                         canvas->drawRect(rect, paint);
80                     } else {
81                         canvas->drawRRect(rrect, paint);
82                     }
83                     paint.setMaskFilter(nullptr);
84                     canvas->restore();
85                 }
86                 canvas->restore();
87                 canvas->translate(0, SkIntToScalar(150));
88             }
89         }
90         canvas->restore();
91         if (kBench_Mode != this->getMode()) {
92             this->drawOverlay(canvas);
93         }
94     }
95 
drawOverlay(SkCanvas * canvas)96     void drawOverlay(SkCanvas* canvas) {
97         canvas->translate(10, 0);
98         SkPaint textPaint;
99         sk_tool_utils::set_portable_typeface(&textPaint);
100         textPaint.setAntiAlias(true);
101         canvas->save();
102         for (int i = 0; i < kNumBlurs; ++i) {
103             canvas->drawString(kBlurFlags[i].fName, 100, 0, textPaint);
104             canvas->translate(SkIntToScalar(130), 0);
105         }
106         canvas->restore();
107         for (auto scale : kMatrixScales) {
108             canvas->drawString(scale.fName, 0, 50, textPaint);
109             canvas->translate(0, SkIntToScalar(150));
110         }
111     }
112 
113 private:
114     static constexpr int kNumBlurs = 2;
115 
116     static const struct BlurFlags {
117         uint32_t fFlags;
118         const char* fName;
119     } kBlurFlags[kNumBlurs];
120 
121     static const struct MatrixScale {
122         float fScale;
123         const char* fName;
124     } kMatrixScales[3];
125 
126     DrawType fDrawType;
127     sk_sp<SkMaskFilter> fBlurFilters[kNumBlurs];
128 
129     typedef         skiagm::GM INHERITED;
130 };
131 
132 const BlurIgnoreXformGM::BlurFlags BlurIgnoreXformGM::kBlurFlags[] = {
133     {0, "none"},
134     {SkBlurMaskFilter::kIgnoreTransform_BlurFlag, "IgnoreTransform"}
135 };
136 
137 const BlurIgnoreXformGM::MatrixScale BlurIgnoreXformGM::kMatrixScales[] = {
138     {1.0f, "Identity"},
139     {0.5f, "Scale = 0.5"},
140     {2.0f, "Scale = 2.0"}
141 };
142 
143 DEF_GM(return new BlurIgnoreXformGM(BlurIgnoreXformGM::DrawType::kCircle);)
144 DEF_GM(return new BlurIgnoreXformGM(BlurIgnoreXformGM::DrawType::kRect);)
145 DEF_GM(return new BlurIgnoreXformGM(BlurIgnoreXformGM::DrawType::kRRect);)
146 
147 
148 
149