1 /*
2  * Copyright 2012 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/gm.h"
9 #include "include/core/SkBitmap.h"
10 #include "include/core/SkCanvas.h"
11 #include "include/core/SkColor.h"
12 #include "include/core/SkFont.h"
13 #include "include/core/SkImageFilter.h"
14 #include "include/core/SkPaint.h"
15 #include "include/core/SkPoint.h"
16 #include "include/core/SkRect.h"
17 #include "include/core/SkScalar.h"
18 #include "include/core/SkShader.h"
19 #include "include/core/SkSize.h"
20 #include "include/core/SkString.h"
21 #include "include/core/SkTileMode.h"
22 #include "include/core/SkTypeface.h"
23 #include "include/effects/SkGradientShader.h"
24 #include "include/effects/SkImageFilters.h"
25 #include "src/gpu/effects/GrMatrixConvolutionEffect.h"
26 #include "tools/ToolUtils.h"
27 
28 #include <vector>
29 
30 namespace skiagm {
31 
32 enum KernelFixture {
33     kBasic_KernelFixture,
34     kLarge_KernelFixture
35 };
36 
37 class MatrixConvolutionGM : public GM {
38 public:
MatrixConvolutionGM(SkColor colorOne,SkColor colorTwo,KernelFixture kernelFixture,const char * nameSuffix)39     MatrixConvolutionGM(SkColor colorOne, SkColor colorTwo, KernelFixture kernelFixture, const char* nameSuffix)
40             : fNameSuffix(nameSuffix),
41               fKernelFixture(kernelFixture) {
42         this->setBGColor(0x00000000);
43         fColors[0] = colorOne;
44         fColors[1] = colorTwo;
45     }
46 
47 protected:
48 
onShortName()49     SkString onShortName() override {
50         return SkStringPrintf("matrixconvolution%s", fNameSuffix);
51     }
52 
makeBitmap()53     void makeBitmap() {
54         // Draw our bitmap in N32, so legacy devices get "premul" values they understand
55         fBitmap.allocN32Pixels(80, 80);
56         SkCanvas canvas(fBitmap);
57         canvas.clear(0x00000000);
58         SkPaint paint;
59         paint.setColor(0xFFFFFFFF);
60         SkPoint pts[2] = { {0, 0},
61                            {0, 80.0f} };
62         SkScalar pos[2] = { 0, 80.0f };
63         paint.setShader(SkGradientShader::MakeLinear(
64             pts, fColors, pos, 2, SkTileMode::kClamp));
65         SkFont font(ToolUtils::create_portable_typeface(), 180.0f);
66         canvas.drawString("e", -10.0f, 80.0f, font, paint);
67     }
68 
onISize()69     SkISize onISize() override {
70         return SkISize::Make(500, 300);
71     }
72 
makeFilter(const SkIPoint & kernelOffset,SkTileMode tileMode,bool convolveAlpha,const SkIRect * cropRect=nullptr)73     sk_sp<SkImageFilter> makeFilter(const SkIPoint &kernelOffset, SkTileMode tileMode,
74                                     bool convolveAlpha, const SkIRect *cropRect = nullptr) {
75         switch (fKernelFixture) {
76             case kBasic_KernelFixture: {
77                 // All 1s except center value, which is -7 (sum of 1).
78                 std::vector<SkScalar> kernel(9, SkIntToScalar(1));
79                 kernel[4] = SkIntToScalar(-7);
80                 return SkImageFilters::MatrixConvolution({3,3}, kernel.data(), /* gain */ 0.3f, /* bias */ SkIntToScalar(100), kernelOffset, tileMode, convolveAlpha, nullptr, cropRect);
81             }
82             case kLarge_KernelFixture: {
83                 static_assert(49 > GrMatrixConvolutionEffect::kMaxUniformSize);
84                 // All 1s except center value, which is -47 (sum of 1).
85                 std::vector<SkScalar> kernel(49, SkIntToScalar(1));
86                 kernel[24] = SkIntToScalar(-47);
87                 return SkImageFilters::MatrixConvolution({7,7}, kernel.data(), /* gain */ 0.3f, /* bias */ SkIntToScalar(100), kernelOffset, tileMode, convolveAlpha, nullptr, cropRect);
88             }
89             default:
90                 return nullptr;
91         }
92     }
93 
draw(SkCanvas * canvas,int x,int y,const SkIPoint & kernelOffset,SkTileMode tileMode,bool convolveAlpha,const SkIRect * cropRect=nullptr)94     void draw(SkCanvas* canvas, int x, int y, const SkIPoint& kernelOffset,
95               SkTileMode tileMode, bool convolveAlpha,
96               const SkIRect* cropRect = nullptr) {
97         SkPaint paint;
98         paint.setImageFilter(this->makeFilter(kernelOffset, tileMode, convolveAlpha, cropRect));
99         canvas->save();
100         canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
101         const SkRect layerBounds = SkRect::MakeIWH(fBitmap.width(), fBitmap.height());
102         canvas->clipRect(layerBounds);
103         // This GM is, in part, intended to display the wrapping behavior of the
104         // matrix image filter. The only (rational) way to achieve that for repeat mode
105         // is to create a tight layer.
106         canvas->saveLayer(layerBounds, &paint);
107             canvas->drawBitmap(fBitmap, 0, 0, nullptr);
108         canvas->restore();
109         canvas->restore();
110     }
111 
onOnceBeforeDraw()112     void onOnceBeforeDraw() override {
113         this->makeBitmap();
114     }
115 
onDraw(SkCanvas * canvas)116     void onDraw(SkCanvas* canvas) override {
117         canvas->clear(SK_ColorBLACK);
118         SkIPoint kernelOffset = SkIPoint::Make(1, 0);
119         SkIRect rect = fBitmap.bounds();
120         for (int x = 10; x < 310; x += 100) {
121             this->draw(canvas, x, 10, kernelOffset, SkTileMode::kClamp, true, &rect);
122             this->draw(canvas, x, 110, kernelOffset, SkTileMode::kDecal, true, &rect);
123             this->draw(canvas, x, 210, kernelOffset, SkTileMode::kRepeat, true, &rect);
124             kernelOffset.fY++;
125         }
126         kernelOffset.fY = 1;
127         SkIRect smallRect = SkIRect::MakeXYWH(10, 5, 60, 60);
128         this->draw(canvas, 310, 10, kernelOffset, SkTileMode::kClamp, true, &smallRect);
129         this->draw(canvas, 310, 110, kernelOffset, SkTileMode::kDecal, true, &smallRect);
130         this->draw(canvas, 310, 210, kernelOffset, SkTileMode::kRepeat, true, &smallRect);
131 
132         this->draw(canvas, 410, 10, kernelOffset, SkTileMode::kClamp, false, &rect);
133         this->draw(canvas, 410, 110, kernelOffset, SkTileMode::kDecal, false, &rect);
134         this->draw(canvas, 410, 210, kernelOffset, SkTileMode::kRepeat, false, &rect);
135     }
136 
137 private:
138     SkBitmap fBitmap;
139     SkColor fColors[2];
140     const char* fNameSuffix;
141     KernelFixture fKernelFixture;
142 
143     using INHERITED = GM;
144 };
145 
146 //////////////////////////////////////////////////////////////////////////////
147 
148 DEF_GM(return new MatrixConvolutionGM(0xFFFFFFFF, 0x40404040, KernelFixture::kBasic_KernelFixture, "");)
149 DEF_GM(return new MatrixConvolutionGM(0xFFFF0000, 0xFF00FF00, KernelFixture::kBasic_KernelFixture, "_color");)
150 DEF_GM(return new MatrixConvolutionGM(0xFFFFFFFF, 0x40404040, KernelFixture::kLarge_KernelFixture, "_big");)
151 DEF_GM(return new MatrixConvolutionGM(0xFFFF0000, 0xFF00FF00, KernelFixture::kLarge_KernelFixture, "_big_color");)
152 
153 }  // namespace skiagm
154