1 /*
2 * Copyright 2013 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/SkColorFilter.h"
13 #include "include/core/SkMatrix.h"
14 #include "include/core/SkPaint.h"
15 #include "include/core/SkPoint.h"
16 #include "include/core/SkRefCnt.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/SkTypes.h"
23 #include "include/core/SkVertices.h"
24 #include "include/effects/SkGradientShader.h"
25 #include "include/effects/SkRuntimeEffect.h"
26 #include "include/private/base/SkTDArray.h"
27 #include "src/base/SkRandom.h"
28 #include "src/core/SkVerticesPriv.h"
29 #include "src/shaders/SkLocalMatrixShader.h"
30 #include "src/utils/SkPatchUtils.h"
31 #include "tools/DecodeUtils.h"
32 #include "tools/Resources.h"
33 #include "tools/ToolUtils.h"
34
35 #include <initializer_list>
36 #include <utility>
37
38 static constexpr SkScalar kShaderSize = 40;
make_shader1(SkScalar shaderScale)39 static sk_sp<SkShader> make_shader1(SkScalar shaderScale) {
40 const SkColor colors[] = {
41 SK_ColorRED, SK_ColorCYAN, SK_ColorGREEN, SK_ColorWHITE,
42 SK_ColorMAGENTA, SK_ColorBLUE, SK_ColorYELLOW,
43 };
44 const SkPoint pts[] = {{kShaderSize / 4, 0}, {3 * kShaderSize / 4, kShaderSize}};
45 const SkMatrix localMatrix = SkMatrix::Scale(shaderScale, shaderScale);
46
47 sk_sp<SkShader> grad = SkGradientShader::MakeLinear(pts, colors, nullptr,
48 std::size(colors),
49 SkTileMode::kMirror, 0,
50 &localMatrix);
51 // Throw in a couple of local matrix wrappers for good measure.
52 return shaderScale == 1 ? grad
53 : grad->makeWithLocalMatrix(SkMatrix::Translate(-10, 0))
54 ->makeWithLocalMatrix(SkMatrix::Translate(10, 0));
55 }
56
make_shader2()57 static sk_sp<SkShader> make_shader2() {
58 return SkShaders::Color(SK_ColorBLUE);
59 }
60
make_color_filter()61 static sk_sp<SkColorFilter> make_color_filter() {
62 return SkColorFilters::Blend(0xFFAABBCC, SkBlendMode::kDarken);
63 }
64
65 static constexpr SkScalar kMeshSize = 30;
66
67 // start with the center of a 3x3 grid of vertices.
68 static constexpr uint16_t kMeshFan[] = {
69 4,
70 0, 1, 2, 5, 8, 7, 6, 3, 0
71 };
72
73 static const int kMeshIndexCnt = (int)std::size(kMeshFan);
74 static const int kMeshVertexCnt = 9;
75
fill_mesh(SkPoint pts[kMeshVertexCnt],SkPoint texs[kMeshVertexCnt],SkColor colors[kMeshVertexCnt],SkScalar shaderScale)76 static void fill_mesh(SkPoint pts[kMeshVertexCnt], SkPoint texs[kMeshVertexCnt],
77 SkColor colors[kMeshVertexCnt], SkScalar shaderScale) {
78 pts[0].set(0, 0);
79 pts[1].set(kMeshSize / 2, 3);
80 pts[2].set(kMeshSize, 0);
81 pts[3].set(3, kMeshSize / 2);
82 pts[4].set(kMeshSize / 2, kMeshSize / 2);
83 pts[5].set(kMeshSize - 3, kMeshSize / 2);
84 pts[6].set(0, kMeshSize);
85 pts[7].set(kMeshSize / 2, kMeshSize - 3);
86 pts[8].set(kMeshSize, kMeshSize);
87
88 const auto shaderSize = kShaderSize * shaderScale;
89 texs[0].set(0, 0);
90 texs[1].set(shaderSize / 2, 0);
91 texs[2].set(shaderSize, 0);
92 texs[3].set(0, shaderSize / 2);
93 texs[4].set(shaderSize / 2, shaderSize / 2);
94 texs[5].set(shaderSize, shaderSize / 2);
95 texs[6].set(0, shaderSize);
96 texs[7].set(shaderSize / 2, shaderSize);
97 texs[8].set(shaderSize, shaderSize);
98
99 SkRandom rand;
100 for (size_t i = 0; i < kMeshVertexCnt; ++i) {
101 colors[i] = rand.nextU() | 0xFF000000;
102 }
103 }
104
105 class VerticesGM : public skiagm::GM {
106 SkPoint fPts[kMeshVertexCnt];
107 SkPoint fTexs[kMeshVertexCnt];
108 SkColor fColors[kMeshVertexCnt];
109 sk_sp<SkShader> fShader1;
110 sk_sp<SkShader> fShader2;
111 sk_sp<SkColorFilter> fColorFilter;
112 SkScalar fShaderScale;
113
114 public:
VerticesGM(SkScalar shaderScale)115 VerticesGM(SkScalar shaderScale) : fShaderScale(shaderScale) {}
116
117 protected:
118
onOnceBeforeDraw()119 void onOnceBeforeDraw() override {
120 fill_mesh(fPts, fTexs, fColors, fShaderScale);
121 fShader1 = make_shader1(fShaderScale);
122 fShader2 = make_shader2();
123 fColorFilter = make_color_filter();
124 }
125
getName() const126 SkString getName() const override {
127 SkString name("vertices");
128 if (fShaderScale != 1) {
129 name.append("_scaled_shader");
130 }
131 return name;
132 }
133
getISize()134 SkISize getISize() override { return SkISize::Make(975, 1175); }
135
onDraw(SkCanvas * canvas)136 void onDraw(SkCanvas* canvas) override {
137 const SkBlendMode modes[] = {
138 SkBlendMode::kClear,
139 SkBlendMode::kSrc,
140 SkBlendMode::kDst,
141 SkBlendMode::kSrcOver,
142 SkBlendMode::kDstOver,
143 SkBlendMode::kSrcIn,
144 SkBlendMode::kDstIn,
145 SkBlendMode::kSrcOut,
146 SkBlendMode::kDstOut,
147 SkBlendMode::kSrcATop,
148 SkBlendMode::kDstATop,
149 SkBlendMode::kXor,
150 SkBlendMode::kPlus,
151 SkBlendMode::kModulate,
152 SkBlendMode::kScreen,
153 SkBlendMode::kOverlay,
154 SkBlendMode::kDarken,
155 SkBlendMode::kLighten,
156 SkBlendMode::kColorDodge,
157 SkBlendMode::kColorBurn,
158 SkBlendMode::kHardLight,
159 SkBlendMode::kSoftLight,
160 SkBlendMode::kDifference,
161 SkBlendMode::kExclusion,
162 SkBlendMode::kMultiply,
163 SkBlendMode::kHue,
164 SkBlendMode::kSaturation,
165 SkBlendMode::kColor,
166 SkBlendMode::kLuminosity,
167 };
168
169 SkPaint paint;
170
171 canvas->translate(4, 4);
172 for (auto mode : modes) {
173 canvas->save();
174 for (float alpha : {1.0f, 0.5f}) {
175 for (const auto& cf : {sk_sp<SkColorFilter>(nullptr), fColorFilter}) {
176 for (const auto& shader : {fShader1, fShader2}) {
177 static constexpr struct {
178 bool fHasColors;
179 bool fHasTexs;
180 } kAttrs[] = {{true, false}, {false, true}, {true, true}};
181 for (auto attrs : kAttrs) {
182 paint.setShader(shader);
183 paint.setColorFilter(cf);
184 paint.setAlphaf(alpha);
185
186 const SkColor* colors = attrs.fHasColors ? fColors : nullptr;
187 const SkPoint* texs = attrs.fHasTexs ? fTexs : nullptr;
188 auto v = SkVertices::MakeCopy(SkVertices::kTriangleFan_VertexMode,
189 kMeshVertexCnt, fPts, texs, colors,
190 kMeshIndexCnt, kMeshFan);
191 canvas->drawVertices(v, mode, paint);
192 canvas->translate(40, 0);
193 }
194 }
195 }
196 }
197 canvas->restore();
198 canvas->translate(0, 40);
199 }
200 }
201
202 private:
203 using INHERITED = skiagm::GM;
204 };
205
206 /////////////////////////////////////////////////////////////////////////////////////
207
208 DEF_GM(return new VerticesGM(1);)
209 DEF_GM(return new VerticesGM(1 / kShaderSize);)
210
draw_batching(SkCanvas * canvas)211 static void draw_batching(SkCanvas* canvas) {
212 // Triangle fans can't batch so we convert to regular triangles,
213 static constexpr int kNumTris = kMeshIndexCnt - 2;
214 SkVertices::Builder builder(SkVertices::kTriangles_VertexMode, kMeshVertexCnt, 3 * kNumTris,
215 SkVertices::kHasColors_BuilderFlag |
216 SkVertices::kHasTexCoords_BuilderFlag);
217
218 SkPoint* pts = builder.positions();
219 SkPoint* texs = builder.texCoords();
220 SkColor* colors = builder.colors();
221 fill_mesh(pts, texs, colors, 1);
222
223 SkTDArray<SkMatrix> matrices;
224 matrices.append()->reset();
225 matrices.append()->setTranslate(0, 40);
226 matrices.append()
227 ->setRotate(45, kMeshSize / 2, kMeshSize / 2)
228 .postScale(1.2f, .8f, kMeshSize / 2, kMeshSize / 2)
229 .postTranslate(0, 80);
230
231 auto shader = make_shader1(1);
232
233 uint16_t* indices = builder.indices();
234 for (size_t i = 0; i < kNumTris; ++i) {
235 indices[3 * i] = kMeshFan[0];
236 indices[3 * i + 1] = kMeshFan[i + 1];
237 indices[3 * i + 2] = kMeshFan[i + 2];
238
239 }
240
241 canvas->save();
242 canvas->translate(10, 10);
243 for (bool useShader : {false, true}) {
244 for (bool useTex : {false, true}) {
245 for (const auto& m : matrices) {
246 canvas->save();
247 canvas->concat(m);
248 SkPaint paint;
249 paint.setShader(useShader ? shader : nullptr);
250 paint.setColor(SK_ColorWHITE);
251
252 const SkPoint* t = useTex ? texs : nullptr;
253 auto v = SkVertices::MakeCopy(SkVertices::kTriangles_VertexMode, kMeshVertexCnt,
254 pts, t, colors, kNumTris * 3, indices);
255 canvas->drawVertices(v, SkBlendMode::kModulate, paint);
256 canvas->restore();
257 }
258 canvas->translate(0, 120);
259 }
260 }
261 canvas->restore();
262 }
263
264 // This test exists to exercise batching in the gpu backend.
265 DEF_SIMPLE_GM(vertices_batching, canvas, 100, 500) {
266 draw_batching(canvas);
267 canvas->translate(50, 0);
268 draw_batching(canvas);
269 }
270
271 // Test case for skbug.com/10069. We need to draw the vertices twice (with different matrices) to
272 // trigger the bug.
273 DEF_SIMPLE_GM(vertices_perspective, canvas, 256, 256) {
274 SkPaint paint;
275 paint.setShader(ToolUtils::create_checkerboard_shader(SK_ColorBLACK, SK_ColorWHITE, 32));
276
277 SkRect r = SkRect::MakeWH(128, 128);
278
279 SkPoint pos[4];
280 r.toQuad(pos);
281 auto verts = SkVertices::MakeCopy(SkVertices::kTriangleFan_VertexMode, 4, pos, pos, nullptr);
282
283 SkMatrix persp;
284 persp.setPerspY(SK_Scalar1 / 100);
285
286 canvas->save();
287 canvas->concat(persp);
288 canvas->drawRect(r, paint);
289 canvas->restore();
290
291 canvas->save();
292 canvas->translate(r.width(), 0);
293 canvas->concat(persp);
294 canvas->drawRect(r, paint);
295 canvas->restore();
296
297 canvas->save();
298 canvas->translate(0, r.height());
299 canvas->concat(persp);
300 canvas->drawVertices(verts, SkBlendMode::kModulate, paint);
301 canvas->restore();
302
303 canvas->save();
304 canvas->translate(r.width(), r.height());
305 canvas->concat(persp);
306 canvas->drawVertices(verts, SkBlendMode::kModulate, paint);
307 canvas->restore();
308 }
309
310 DEF_SIMPLE_GM(skbug_13047, canvas, 200, 200) {
311 auto image = ToolUtils::GetResourceAsImage("images/mandrill_128.png");
312
313 const float w = image->width();
314 const float h = image->height();
315
316 SkPoint verts[] = {{0, 0}, {200, 0}, {200, 200}, {0, 200}};
317 SkPoint texs[] = {{0, 0}, {w, 0}, {w, h}, {0, h}};
318 uint16_t indices[] = {0, 1, 2, 2, 3, 0};
319
320 auto v = SkVertices::MakeCopy(
321 SkVertices::kTriangles_VertexMode, 4, verts, texs, nullptr, 6, indices);
322
323 auto m = SkMatrix::Scale(2, 2); // ignored in CPU ???
324 auto s = image->makeShader(SkSamplingOptions(SkFilterMode::kLinear), &m);
325
326 SkPaint p;
327 p.setShader(s);
328
329 canvas->drawVertices(v, SkBlendMode::kModulate, p);
330 }
331
332 // Makes sure that drawVertices allows for triangles with "collapsed" UVs, where all three vertices
333 // have the same texture coordinate. b/40044794
334 DEF_SIMPLE_GM_BG(vertices_collapsed, canvas, 50, 50, SK_ColorWHITE) {
335 SkPoint verts[] = {{5, 5}, {45, 5}, {45, 45}, {5, 45}};
336 SkPoint texs[] = {{0, 0}, {0, 0}, {0, 0}, {0, 0}};
337 uint16_t indices[] = {0, 1, 2, 2, 3, 0};
338
339 sk_sp<SkVertices> v = SkVertices::MakeCopy(
340 SkVertices::kTriangles_VertexMode, 4, verts, texs, nullptr, 6, indices);
341
342 sk_sp<SkSurface> surf = SkSurfaces::Raster(SkImageInfo::MakeN32Premul(1, 1));
343 surf->getCanvas()->clear(SK_ColorGREEN);
344 sk_sp<SkShader> shader = surf->makeImageSnapshot()->makeShader(SkSamplingOptions{});
345 SkPaint paint;
346 paint.setShader(shader);
347
348 canvas->drawVertices(v, SkBlendMode::kDst, paint);
349 }
350
