1 /*
2 * Copyright 2018 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/SkBlendMode.h"
11 #include "include/core/SkCanvas.h"
12 #include "include/core/SkColor.h"
13 #include "include/core/SkImage.h"
14 #include "include/core/SkImageInfo.h"
15 #include "include/core/SkMatrix.h"
16 #include "include/core/SkPaint.h"
17 #include "include/core/SkRect.h"
18 #include "include/core/SkRefCnt.h"
19 #include "include/core/SkScalar.h"
20 #include "include/core/SkShader.h"
21 #include "include/core/SkSurface.h"
22 #include "include/core/SkTypes.h"
23 #include "include/effects/SkGradientShader.h"
24 #include "tools/DecodeUtils.h"
25 #include "tools/GpuToolUtils.h"
26 #include "tools/Resources.h"
27 #include "tools/ToolUtils.h"
28 #include "tools/timer/TimeUtils.h"
29
make_image(SkCanvas * rootCanvas)30 static sk_sp<SkImage> make_image(SkCanvas* rootCanvas) {
31 static constexpr SkScalar kSize = 50;
32 SkImageInfo info = SkImageInfo::MakeN32Premul(kSize, kSize);
33 auto surface(SkSurfaces::Raster(info));
34
35 SkPaint p;
36 p.setAntiAlias(true);
37 p.setColor(SK_ColorGREEN);
38
39 surface->getCanvas()->drawCircle(kSize / 2, kSize / 2, kSize / 2, p);
40
41 p.setStyle(SkPaint::kStroke_Style);
42 p.setColor(SK_ColorRED);
43 surface->getCanvas()->drawLine(kSize * .25f, kSize * .50f, kSize * .75f, kSize * .50f, p);
44 surface->getCanvas()->drawLine(kSize * .50f, kSize * .25f, kSize * .50f, kSize * .75f, p);
45
46 sk_sp<SkImage> img = surface->makeImageSnapshot();
47 return ToolUtils::MakeTextureImage(rootCanvas, std::move(img));
48 }
49
50 DEF_SIMPLE_GM(localmatrixshader_nested, canvas, 450, 1200) {
51 auto image = make_image(canvas);
52 if (!image) {
53 return;
54 }
55
56 using FactoryT = sk_sp<SkShader> (*)(const sk_sp<SkImage>&,
57 const SkMatrix& inner,
58 const SkMatrix& outer);
59 static const FactoryT gFactories[] = {
60 // SkLocalMatrixShader(SkImageShader(inner), outer)
__anon55eb75a90102() 61 [](const sk_sp<SkImage>& img, const SkMatrix& inner, const SkMatrix& outer) {
62 return img->makeShader(SkSamplingOptions(), inner)->makeWithLocalMatrix(outer);
63 },
64
65 // SkLocalMatrixShader(SkLocalMatrixShader(SkImageShader(I), inner), outer)
__anon55eb75a90202() 66 [](const sk_sp<SkImage>& img, const SkMatrix& inner, const SkMatrix& outer) {
67 return img->makeShader(SkSamplingOptions())->makeWithLocalMatrix(inner)->makeWithLocalMatrix(outer);
68 },
69
70 // SkLocalMatrixShader(SkComposeShader(SkImageShader(inner)), outer)
__anon55eb75a90302() 71 [](const sk_sp<SkImage>& img, const SkMatrix& inner, const SkMatrix& outer) {
72 return SkShaders::Blend(SkBlendMode::kSrcOver,
73 SkShaders::Color(SK_ColorTRANSPARENT),
74 img->makeShader(SkSamplingOptions(), inner))
75 ->makeWithLocalMatrix(outer);
76 },
77
78 // SkLocalMatrixShader(SkComposeShader(SkLocalMatrixShader(SkImageShader(I), inner)), outer)
__anon55eb75a90402() 79 [](const sk_sp<SkImage>& img, const SkMatrix& inner, const SkMatrix& outer) {
80 return SkShaders::Blend(SkBlendMode::kSrcOver,
81 SkShaders::Color(SK_ColorTRANSPARENT),
82 img->makeShader(SkSamplingOptions())->makeWithLocalMatrix(inner))
83 ->makeWithLocalMatrix(outer);
84 },
85 };
86
87 static const auto outer = SkMatrix::Scale(2, 2),
88 inner = SkMatrix::Translate(20, 20);
89
90 SkPaint border;
91 border.setAntiAlias(true);
92 border.setStyle(SkPaint::kStroke_Style);
93
94 auto rect = SkRect::Make(image->bounds());
95 SkAssertResult(SkMatrix::Concat(outer, inner).mapRect(&rect));
96
__anon55eb75a90502() 97 const auto drawColumn = [&]() {
98 SkAutoCanvasRestore acr(canvas, true);
99 for (const auto& f : gFactories) {
100 SkPaint p;
101 p.setShader(f(image, inner, outer));
102
103 canvas->drawRect(rect, p);
104 canvas->drawRect(rect, border);
105
106 canvas->translate(0, rect.height() * 1.5f);
107 }
108 };
109
110 drawColumn();
111
112 {
113 SkAutoCanvasRestore acr(canvas, true);
114 canvas->translate(0, rect.height() * std::size(gFactories) * 1.5f);
115 drawColumn();
116 }
117
118 canvas->translate(rect.width() * 1.5f, 0);
119 canvas->scale(2, 2);
120 drawColumn();
121 }
122
123 DEF_SIMPLE_GM(localmatrixshader_persp, canvas, 542, 266) {
124 auto image = ToolUtils::GetResourceAsImage("images/yellow_rose.png");
125
126 SkBitmap downsized;
127 downsized.allocPixels(image->imageInfo().makeWH(128, 128));
128 image->scalePixels(downsized.pixmap(), SkSamplingOptions(SkFilterMode::kLinear));
129 image = downsized.asImage();
130 SkRect imgRect = SkRect::MakeIWH(image->width(), image->height());
131
132 // scale matrix
133 SkMatrix scale = SkMatrix::Scale(1.f / 5.f, 1.f / 5.f);
134
135 // perspective matrix
136 SkPoint src[4];
137 imgRect.toQuad(src);
138 SkPoint dst[4] = {{0, 10.f},
139 {image->width() + 28.f, -100.f},
140 {image->width() - 28.f, image->height() + 100.f},
141 {0.f, image->height() - 10.f}};
142 SkMatrix persp;
143 SkAssertResult(persp.setPolyToPoly(src, dst, 4));
144
145 // combined persp * scale
146 SkMatrix perspScale = SkMatrix::Concat(persp, scale);
147
__anon55eb75a90602(sk_sp<SkShader> shader, bool applyPerspToCTM) 148 auto draw = [&](sk_sp<SkShader> shader, bool applyPerspToCTM) {
149 canvas->save();
150 canvas->clipRect(imgRect);
151 if (applyPerspToCTM) {
152 canvas->concat(persp);
153 }
154 SkPaint imgShaderPaint;
155 imgShaderPaint.setShader(std::move(shader));
156 canvas->drawPaint(imgShaderPaint);
157 canvas->restore();
158
159 canvas->translate(10.f + image->width(), 0.f); // advance
160 };
161
162 // SkImageShader
163 canvas->save();
164 // 4 variants that all attempt to apply sample at persp * scale w/ an image shader
165 // 1. scale provided to SkImage::makeShader(...) but drawn with persp
166 auto s1 = image->makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat,
167 SkSamplingOptions(), &scale);
168 draw(s1, true);
169
170 // 2. scale provided to SkImage::makeShader, then wrapped in persp makeWithLocalMatrix
171 // These post-concat, so it ends up as persp * scale.
172 auto s2 = image->makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat,
173 SkSamplingOptions(), &scale)
174 ->makeWithLocalMatrix(persp);
175 draw(s2, false);
176
177 // 3. Providing pre-computed persp*scale to SkImage::makeShader()
178 auto s3 = image->makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat,
179 SkSamplingOptions(), &perspScale);
180 draw(s3, false);
181
182 // 4. Providing pre-computed persp*scale to makeWithLocalMatrix
183 auto s4 = image->makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat, SkSamplingOptions())
184 ->makeWithLocalMatrix(perspScale);
185 draw(s4, false);
186 canvas->restore();
187
188 canvas->translate(0.f, 10.f + image->height()); // advance to next row
189
190 // SkGradientShader
191 const SkColor kGradColors[] = { SK_ColorBLACK, SK_ColorTRANSPARENT };
192 canvas->save();
193 // 1. scale provided to Make, drawn with persp
194 auto g1 = SkGradientShader::MakeRadial({imgRect.centerX(), imgRect.centerY()},
195 imgRect.width() / 2.f, kGradColors, nullptr, 2,
196 SkTileMode::kRepeat, 0, &scale);
197 draw(g1, true);
198
199 // 2. scale provided to Make, then wrapped with makeWithLocalMatrix (post-concat as before).
200 auto g2 = SkGradientShader::MakeRadial({imgRect.centerX(), imgRect.centerY()},
201 imgRect.width() / 2.f, kGradColors, nullptr, 2,
202 SkTileMode::kRepeat, 0, &scale)
203 ->makeWithLocalMatrix(persp);
204 draw(g2, false);
205
206 // 3. Provide per-computed persp*scale to Make
207 auto g3 = SkGradientShader::MakeRadial({imgRect.centerX(), imgRect.centerY()},
208 imgRect.width() / 2.f, kGradColors, nullptr, 2,
209 SkTileMode::kRepeat, 0, &perspScale);
210 draw(g3, false);
211
212 // 4. Providing pre-computed persp*scale to makeWithLocalMatrix
213 auto g4 = SkGradientShader::MakeRadial({imgRect.centerX(), imgRect.centerY()},
214 imgRect.width() / 2.f, kGradColors, nullptr, 2,
215 SkTileMode::kRepeat)
216 ->makeWithLocalMatrix(perspScale);
217 draw(g4, false);
218 canvas->restore();
219 }
220
221 namespace skiagm {
222 class LocalMatrixOrder : public GM {
223 public:
LocalMatrixOrder()224 LocalMatrixOrder() {}
225
226 protected:
getName() const227 SkString getName() const override { return SkString("localmatrix_order"); }
228
getISize()229 SkISize getISize() override { return SkISize::Make(500, 500); }
230
onOnceBeforeDraw()231 void onOnceBeforeDraw() override {
232 auto mandrill = ToolUtils::GetResourceAsImage("images/mandrill_256.png"); // 256x256
233 auto example5 = ToolUtils::GetResourceAsImage("images/example_5.png"); // 128x128
234
235 auto mshader = mandrill->makeShader(
236 SkTileMode::kRepeat,
237 SkTileMode::kRepeat,
238 SkFilterMode::kNearest,
239 SkMatrix::RotateDeg(45, {128, 128})); // rotate about center
240 auto eshader = example5->makeShader(
241 SkTileMode::kRepeat,
242 SkTileMode::kRepeat,
243 SkFilterMode::kNearest,
244 SkMatrix::Scale(2, 2)); // make same size as mandrill and...
245 // ... rotate about center
246 eshader = eshader->makeWithLocalMatrix(SkMatrix::RotateDeg(45, {128, 128}));
247
248 // blend the two rotated and aligned images.
249 fShader = SkShaders::Blend(SkBlendMode::kModulate, mshader, eshader);
250 }
251
onDraw(SkCanvas * canvas)252 void onDraw(SkCanvas* canvas) override {
253 // Rotate fShader about the canvas center
254 auto center = SkRect::Make(canvas->imageInfo().bounds()).center();
255
256 // viewer can insert a dpi scaling matrix. Make the animation always rotate about the device
257 // center.
258 if (auto ictm = canvas->getTotalMatrix(); ictm.invert(&ictm)) {
259 center = ictm.mapPoint(center);
260 }
261
262 auto shader = fShader->makeWithLocalMatrix(SkMatrix::RotateDeg(fAngle, center));
263
264 SkPaint paint;
265 paint.setShader(shader);
266 canvas->drawPaint(paint);
267 }
268
onAnimate(double nanos)269 bool onAnimate(double nanos) override {
270 fAngle = TimeUtils::NanosToSeconds(nanos) * 5.f;
271 return true;
272 }
273
274 sk_sp<SkShader> fShader;
275 float fAngle = 0.f;
276 };
277
278 DEF_GM(return new LocalMatrixOrder;)
279 } // namespace skiagm
280
