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/SkBlendMode.h"
10 #include "include/core/SkCanvas.h"
11 #include "include/core/SkColor.h"
12 #include "include/core/SkFilterQuality.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/SkPoint.h"
18 #include "include/core/SkRect.h"
19 #include "include/core/SkRefCnt.h"
20 #include "include/core/SkScalar.h"
21 #include "include/core/SkShader.h"
22 #include "include/core/SkSize.h"
23 #include "include/core/SkString.h"
24 #include "include/core/SkSurface.h"
25 #include "include/core/SkTileMode.h"
26 #include "include/core/SkTypes.h"
27 #include "include/effects/SkGradientShader.h"
28 #include "tools/ToolUtils.h"
29
30 #include <algorithm>
31 #include <initializer_list>
32 #include <utility>
33
34 // Makes a set of m x n tiled images to be drawn with SkCanvas::experimental_drawImageSetV1().
make_image_tiles(int tileW,int tileH,int m,int n,const SkColor colors[4],SkCanvas::ImageSetEntry set[])35 static void make_image_tiles(int tileW, int tileH, int m, int n, const SkColor colors[4],
36 SkCanvas::ImageSetEntry set[]) {
37 const int w = tileW * m;
38 const int h = tileH * n;
39 auto surf = SkSurface::MakeRaster(
40 SkImageInfo::Make(w, h, kRGBA_8888_SkColorType, kPremul_SkAlphaType));
41 surf->getCanvas()->clear(SK_ColorLTGRAY);
42
43 static constexpr SkScalar kStripeW = 10;
44 static constexpr SkScalar kStripeSpacing = 30;
45 SkPaint paint;
46
47 SkPoint pts1[] = {{0.f, 0.f}, {(SkScalar)w, (SkScalar)h}};
48 auto grad = SkGradientShader::MakeLinear(pts1, colors, nullptr, 2, SkTileMode::kClamp);
49 paint.setShader(std::move(grad));
50 paint.setAntiAlias(true);
51 paint.setStyle(SkPaint::kStroke_Style);
52 paint.setStrokeWidth(kStripeW);
53 SkPoint stripePts[] = {{-w - kStripeW, -kStripeW}, {kStripeW, h + kStripeW}};
54 while (stripePts[0].fX <= w) {
55 surf->getCanvas()->drawPoints(SkCanvas::kLines_PointMode, 2, stripePts, paint);
56 stripePts[0].fX += kStripeSpacing;
57 stripePts[1].fX += kStripeSpacing;
58 }
59
60 SkPoint pts2[] = {{0.f, (SkScalar)h}, {(SkScalar)w, 0.f}};
61 grad = SkGradientShader::MakeLinear(pts2, colors + 2, nullptr, 2, SkTileMode::kClamp);
62 paint.setShader(std::move(grad));
63 paint.setBlendMode(SkBlendMode::kMultiply);
64 stripePts[0] = {-w - kStripeW, h + kStripeW};
65 stripePts[1] = {kStripeW, -kStripeW};
66 while (stripePts[0].fX <= w) {
67 surf->getCanvas()->drawPoints(SkCanvas::kLines_PointMode, 2, stripePts, paint);
68 stripePts[0].fX += kStripeSpacing;
69 stripePts[1].fX += kStripeSpacing;
70 }
71 auto fullImage = surf->makeImageSnapshot();
72 for (int y = 0; y < n; ++y) {
73 for (int x = 0; x < m; ++x) {
74 // Images will have 1 pixel of overlap at interior seams for filtering continuity.
75 SkIRect subset = SkIRect::MakeXYWH(x * tileW - 1, y * tileH - 1, tileW + 2, tileH + 2);
76 set[y * m + x].fAAFlags = SkCanvas::kNone_QuadAAFlags;
77 if (x == 0) {
78 subset.fLeft = 0;
79 set[y * m + x].fAAFlags |= SkCanvas::kLeft_QuadAAFlag;
80 }
81 if (x == m - 1) {
82 subset.fRight = w;
83 set[y * m + x].fAAFlags |= SkCanvas::kRight_QuadAAFlag;
84 }
85 if (y == 0) {
86 subset.fTop = 0;
87 set[y * m + x].fAAFlags |= SkCanvas::kTop_QuadAAFlag;
88 }
89 if (y == n - 1) {
90 subset.fBottom = h;
91 set[y * m + x].fAAFlags |= SkCanvas::kBottom_QuadAAFlag;
92 }
93 set[y * m + x].fImage = fullImage->makeSubset(subset);
94 set[y * m + x].fSrcRect =
95 SkRect::MakeXYWH(x == 0 ? 0 : 1, y == 0 ? 0 : 1, tileW, tileH);
96 set[y * m + x].fDstRect = SkRect::MakeXYWH(x * tileW, y * tileH, tileW, tileH);
97 set[y * m + x].fAlpha = 1.f;
98 SkASSERT(set[y * m + x].fImage);
99 }
100 }
101 }
102
103 namespace skiagm {
104
105 class DrawImageSetGM : public GM {
106 private:
onShortName()107 SkString onShortName() override { return SkString("draw_image_set"); }
onISize()108 SkISize onISize() override { return {1000, 725}; }
onOnceBeforeDraw()109 void onOnceBeforeDraw() override {
110 static constexpr SkColor kColors[] = {SK_ColorCYAN, SK_ColorBLACK,
111 SK_ColorMAGENTA, SK_ColorBLACK};
112 make_image_tiles(kTileW, kTileH, kM, kN, kColors, fSet);
113 }
114
onDraw(SkCanvas * canvas)115 void onDraw(SkCanvas* canvas) override {
116 SkScalar d = SkVector{kM * kTileW, kN * kTileH}.length();
117 SkMatrix matrices[4];
118 // rotation
119 matrices[0].setRotate(30);
120 matrices[0].postTranslate(d / 3, 0);
121 // perespective
122 SkPoint src[4];
123 SkRect::MakeWH(kM * kTileW, kN * kTileH).toQuad(src);
124 SkPoint dst[4] = {{0, 0},
125 {kM * kTileW + 10.f, -5.f},
126 {kM * kTileW - 28.f, kN * kTileH + 40.f},
127 {45.f, kN * kTileH - 25.f}};
128 SkAssertResult(matrices[1].setPolyToPoly(src, dst, 4));
129 matrices[1].postTranslate(d, 50.f);
130 // skew
131 matrices[2].setRotate(-60.f);
132 matrices[2].postSkew(0.5f, -1.15f);
133 matrices[2].postScale(0.6f, 1.05f);
134 matrices[2].postTranslate(d, 2.6f * d);
135 // perspective + mirror in x.
136 dst[1] = {-.25 * kM * kTileW, 0};
137 dst[0] = {5.f / 4.f * kM * kTileW, 0};
138 dst[3] = {2.f / 3.f * kM * kTileW, 1 / 2.f * kN * kTileH};
139 dst[2] = {1.f / 3.f * kM * kTileW, 1 / 2.f * kN * kTileH - 0.1f * kTileH};
140 SkAssertResult(matrices[3].setPolyToPoly(src, dst, 4));
141 matrices[3].postTranslate(100.f, d);
142 for (auto fm : {kNone_SkFilterQuality, kLow_SkFilterQuality}) {
143 SkPaint setPaint;
144 setPaint.setFilterQuality(fm);
145 setPaint.setBlendMode(SkBlendMode::kSrcOver);
146
147 for (size_t m = 0; m < SK_ARRAY_COUNT(matrices); ++m) {
148 // Draw grid of red lines at interior tile boundaries.
149 static constexpr SkScalar kLineOutset = 10.f;
150 SkPaint paint;
151 paint.setAntiAlias(true);
152 paint.setColor(SK_ColorRED);
153 paint.setStyle(SkPaint::kStroke_Style);
154 paint.setStrokeWidth(0.f);
155 for (int x = 1; x < kM; ++x) {
156 SkPoint pts[] = {{x * kTileW, 0}, {x * kTileW, kN * kTileH}};
157 matrices[m].mapPoints(pts, 2);
158 SkVector v = pts[1] - pts[0];
159 v.setLength(v.length() + kLineOutset);
160 canvas->drawLine(pts[1] - v, pts[0] + v, paint);
161 }
162 for (int y = 1; y < kN; ++y) {
163 SkPoint pts[] = {{0, y * kTileH}, {kTileW * kM, y * kTileH}};
164 matrices[m].mapPoints(pts, 2);
165 SkVector v = pts[1] - pts[0];
166 v.setLength(v.length() + kLineOutset);
167 canvas->drawLine(pts[1] - v, pts[0] + v, paint);
168 }
169 canvas->save();
170 canvas->concat(matrices[m]);
171 canvas->experimental_DrawEdgeAAImageSet(fSet, kM * kN, nullptr, nullptr, &setPaint,
172 SkCanvas::kFast_SrcRectConstraint);
173 canvas->restore();
174 }
175 // A more exotic case with an unusual blend mode, mixed aa flags set, and alpha,
176 // subsets the image
177 SkCanvas::ImageSetEntry entry;
178 entry.fSrcRect = SkRect::MakeWH(kTileW, kTileH).makeInset(kTileW / 4.f, kTileH / 4.f);
179 entry.fDstRect = SkRect::MakeWH(2 * kTileW, 2 * kTileH).makeOffset(d / 4, 2 * d);
180 entry.fImage = fSet[0].fImage;
181 entry.fAlpha = 0.7f;
182 entry.fAAFlags = SkCanvas::kLeft_QuadAAFlag | SkCanvas::kTop_QuadAAFlag;
183 canvas->save();
184 canvas->rotate(3.f);
185
186 setPaint.setBlendMode(SkBlendMode::kExclusion);
187 canvas->experimental_DrawEdgeAAImageSet(&entry, 1, nullptr, nullptr, &setPaint,
188 SkCanvas::kFast_SrcRectConstraint);
189 canvas->restore();
190 canvas->translate(2 * d, 0);
191 }
192 }
193 static constexpr int kM = 4;
194 static constexpr int kN = 3;
195 static constexpr SkScalar kTileW = 30;
196 static constexpr SkScalar kTileH = 60;
197 SkCanvas::ImageSetEntry fSet[kM * kN];
198 };
199
200 // This GM exercises rect-stays-rect type matrices to test that filtering and antialiasing are not
201 // incorrectly disabled.
202 class DrawImageSetRectToRectGM : public GM {
203 private:
onShortName()204 SkString onShortName() override { return SkString("draw_image_set_rect_to_rect"); }
onISize()205 SkISize onISize() override { return {1250, 850}; }
onOnceBeforeDraw()206 void onOnceBeforeDraw() override {
207 static constexpr SkColor kColors[] = {SK_ColorBLUE, SK_ColorWHITE,
208 SK_ColorRED, SK_ColorWHITE};
209 make_image_tiles(kTileW, kTileH, kM, kN, kColors, fSet);
210 }
211
onDraw(SkCanvas * canvas)212 void onDraw(SkCanvas* canvas) override {
213 ToolUtils::draw_checkerboard(canvas, SK_ColorBLACK, SK_ColorWHITE, 50);
214 static constexpr SkScalar kW = kM * kTileW;
215 static constexpr SkScalar kH = kN * kTileH;
216 SkMatrix matrices[5];
217 // Identity
218 matrices[0].reset();
219 // 90 degree rotation
220 matrices[1].setRotate(90, kW / 2.f, kH / 2.f);
221 // Scaling
222 matrices[2].setScale(2.f, 0.5f);
223 // Mirror in x and y
224 matrices[3].setScale(-1.f, -1.f);
225 matrices[3].postTranslate(kW, kH);
226 // Mirror in y, rotate, and scale.
227 matrices[4].setScale(1.f, -1.f);
228 matrices[4].postTranslate(0, kH);
229 matrices[4].postRotate(90, kW / 2.f, kH / 2.f);
230 matrices[4].postScale(2.f, 0.5f);
231
232 SkPaint paint;
233 paint.setFilterQuality(kLow_SkFilterQuality);
234 paint.setBlendMode(SkBlendMode::kSrcOver);
235
236 static constexpr SkScalar kTranslate = SkTMax(kW, kH) * 2.f + 10.f;
237 canvas->translate(5.f, 5.f);
238 canvas->save();
239 for (SkScalar frac : {0.f, 0.5f}) {
240 canvas->save();
241 canvas->translate(frac, frac);
242 for (size_t m = 0; m < SK_ARRAY_COUNT(matrices); ++m) {
243 canvas->save();
244 canvas->concat(matrices[m]);
245 canvas->experimental_DrawEdgeAAImageSet(fSet, kM * kN, nullptr, nullptr, &paint,
246 SkCanvas::kFast_SrcRectConstraint);
247 canvas->restore();
248 canvas->translate(kTranslate, 0);
249 }
250 canvas->restore();
251 canvas->restore();
252 canvas->translate(0, kTranslate);
253 canvas->save();
254 }
255 for (SkVector scale : {SkVector{2.f, 0.5f}, SkVector{0.5, 2.f}}) {
256 SkCanvas::ImageSetEntry scaledSet[kM * kN];
257 std::copy_n(fSet, kM * kN, scaledSet);
258 for (int i = 0; i < kM * kN; ++i) {
259 scaledSet[i].fDstRect.fLeft *= scale.fX;
260 scaledSet[i].fDstRect.fTop *= scale.fY;
261 scaledSet[i].fDstRect.fRight *= scale.fX;
262 scaledSet[i].fDstRect.fBottom *= scale.fY;
263 scaledSet[i].fAlpha = 0 == (i % 3) ? 0.4f : 1.f;
264 }
265 for (size_t m = 0; m < SK_ARRAY_COUNT(matrices); ++m) {
266 canvas->save();
267 canvas->concat(matrices[m]);
268 canvas->experimental_DrawEdgeAAImageSet(scaledSet, kM * kN, nullptr, nullptr,
269 &paint, SkCanvas::kFast_SrcRectConstraint);
270 canvas->restore();
271 canvas->translate(kTranslate, 0);
272 }
273 canvas->restore();
274 canvas->translate(0, kTranslate);
275 canvas->save();
276 }
277 }
278 static constexpr int kM = 2;
279 static constexpr int kN = 2;
280 static constexpr int kTileW = 40;
281 static constexpr int kTileH = 50;
282 SkCanvas::ImageSetEntry fSet[kM * kN];
283 };
284
285 DEF_GM(return new DrawImageSetGM();)
286 DEF_GM(return new DrawImageSetRectToRectGM();)
287
288 } // namespace skiagm
289