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.h"
9 #include "SkCanvas.h"
10 #include "SkColorFilter.h"
11 #include "SkGradientShader.h"
12 #include "SkLocalMatrixShader.h"
13 #include "SkRandom.h"
14 #include "SkVertices.h"
15
16 static constexpr SkScalar kShaderSize = 40;
make_shader1(SkScalar shaderScale)17 static sk_sp<SkShader> make_shader1(SkScalar shaderScale) {
18 const SkColor colors[] = {
19 SK_ColorRED, SK_ColorCYAN, SK_ColorGREEN, SK_ColorWHITE,
20 SK_ColorMAGENTA, SK_ColorBLUE, SK_ColorYELLOW,
21 };
22 const SkPoint pts[] = {{kShaderSize / 4, 0}, {3 * kShaderSize / 4, kShaderSize}};
23 const SkMatrix localMatrix = SkMatrix::MakeScale(shaderScale, shaderScale);
24
25 sk_sp<SkShader> grad = SkGradientShader::MakeLinear(pts, colors, nullptr,
26 SK_ARRAY_COUNT(colors),
27 SkShader::kMirror_TileMode, 0,
28 &localMatrix);
29 // Throw in a couple of local matrix wrappers for good measure.
30 return shaderScale == 1
31 ? grad
32 : sk_make_sp<SkLocalMatrixShader>(
33 sk_make_sp<SkLocalMatrixShader>(std::move(grad), SkMatrix::MakeTrans(-10, 0)),
34 SkMatrix::MakeTrans(10, 0));
35 }
36
make_shader2()37 static sk_sp<SkShader> make_shader2() {
38 return SkShader::MakeColorShader(SK_ColorBLUE);
39 }
40
make_color_filter()41 static sk_sp<SkColorFilter> make_color_filter() {
42 return SkColorFilter::MakeModeFilter(0xFFAABBCC, SkBlendMode::kDarken);
43 }
44
45 static constexpr SkScalar kMeshSize = 30;
46
47 // start with the center of a 3x3 grid of vertices.
48 static constexpr uint16_t kMeshFan[] = {
49 4,
50 0, 1, 2, 5, 8, 7, 6, 3, 0
51 };
52
53 static const int kMeshIndexCnt = (int)SK_ARRAY_COUNT(kMeshFan);
54 static const int kMeshVertexCnt = 9;
55
fill_mesh(SkPoint pts[kMeshVertexCnt],SkPoint texs[kMeshVertexCnt],SkColor colors[kMeshVertexCnt],SkScalar shaderScale)56 static void fill_mesh(SkPoint pts[kMeshVertexCnt], SkPoint texs[kMeshVertexCnt],
57 SkColor colors[kMeshVertexCnt], SkScalar shaderScale) {
58 pts[0].set(0, 0);
59 pts[1].set(kMeshSize / 2, 3);
60 pts[2].set(kMeshSize, 0);
61 pts[3].set(3, kMeshSize / 2);
62 pts[4].set(kMeshSize / 2, kMeshSize / 2);
63 pts[5].set(kMeshSize - 3, kMeshSize / 2);
64 pts[6].set(0, kMeshSize);
65 pts[7].set(kMeshSize / 2, kMeshSize - 3);
66 pts[8].set(kMeshSize, kMeshSize);
67
68 const auto shaderSize = kShaderSize * shaderScale;
69 texs[0].set(0, 0);
70 texs[1].set(shaderSize / 2, 0);
71 texs[2].set(shaderSize, 0);
72 texs[3].set(0, shaderSize / 2);
73 texs[4].set(shaderSize / 2, shaderSize / 2);
74 texs[5].set(shaderSize, shaderSize / 2);
75 texs[6].set(0, shaderSize);
76 texs[7].set(shaderSize / 2, shaderSize);
77 texs[8].set(shaderSize, shaderSize);
78
79 SkRandom rand;
80 for (size_t i = 0; i < kMeshVertexCnt; ++i) {
81 colors[i] = rand.nextU() | 0xFF000000;
82 }
83 }
84
85 class VerticesGM : public skiagm::GM {
86 SkPoint fPts[kMeshVertexCnt];
87 SkPoint fTexs[kMeshVertexCnt];
88 SkColor fColors[kMeshVertexCnt];
89 sk_sp<SkShader> fShader1;
90 sk_sp<SkShader> fShader2;
91 sk_sp<SkColorFilter> fColorFilter;
92 bool fUseObject;
93 SkScalar fShaderScale;
94
95 public:
VerticesGM(bool useObject,SkScalar shaderScale=1)96 VerticesGM(bool useObject, SkScalar shaderScale = 1)
97 : fUseObject(useObject), fShaderScale(shaderScale) {}
98
99 protected:
100
onOnceBeforeDraw()101 void onOnceBeforeDraw() override {
102 fill_mesh(fPts, fTexs, fColors, fShaderScale);
103 fShader1 = make_shader1(fShaderScale);
104 fShader2 = make_shader2();
105 fColorFilter = make_color_filter();
106 }
107
onShortName()108 SkString onShortName() override {
109 SkString name("vertices");
110 if (fUseObject) {
111 name.append("_object");
112 }
113 if (fShaderScale != 1) {
114 name.append("_scaled_shader");
115 }
116 return name;
117 }
118
onISize()119 SkISize onISize() override {
120 return SkISize::Make(975, 1175);
121 }
122
onDraw(SkCanvas * canvas)123 void onDraw(SkCanvas* canvas) override {
124 const SkBlendMode modes[] = {
125 SkBlendMode::kClear,
126 SkBlendMode::kSrc,
127 SkBlendMode::kDst,
128 SkBlendMode::kSrcOver,
129 SkBlendMode::kDstOver,
130 SkBlendMode::kSrcIn,
131 SkBlendMode::kDstIn,
132 SkBlendMode::kSrcOut,
133 SkBlendMode::kDstOut,
134 SkBlendMode::kSrcATop,
135 SkBlendMode::kDstATop,
136 SkBlendMode::kXor,
137 SkBlendMode::kPlus,
138 SkBlendMode::kModulate,
139 SkBlendMode::kScreen,
140 SkBlendMode::kOverlay,
141 SkBlendMode::kDarken,
142 SkBlendMode::kLighten,
143 SkBlendMode::kColorDodge,
144 SkBlendMode::kColorBurn,
145 SkBlendMode::kHardLight,
146 SkBlendMode::kSoftLight,
147 SkBlendMode::kDifference,
148 SkBlendMode::kExclusion,
149 SkBlendMode::kMultiply,
150 SkBlendMode::kHue,
151 SkBlendMode::kSaturation,
152 SkBlendMode::kColor,
153 SkBlendMode::kLuminosity,
154 };
155
156 SkPaint paint;
157
158 canvas->translate(4, 4);
159 int x = 0;
160 for (auto mode : modes) {
161 canvas->save();
162 for (uint8_t alpha : {0xFF, 0x80}) {
163 for (const auto& cf : {sk_sp<SkColorFilter>(nullptr), fColorFilter}) {
164 for (const auto& shader : {fShader1, fShader2}) {
165 static constexpr struct {
166 bool fHasColors;
167 bool fHasTexs;
168 } kAttrs[] = {{true, false}, {false, true}, {true, true}};
169 for (auto attrs : kAttrs) {
170 paint.setShader(shader);
171 paint.setColorFilter(cf);
172 paint.setAlpha(alpha);
173
174 const SkColor* colors = attrs.fHasColors ? fColors : nullptr;
175 const SkPoint* texs = attrs.fHasTexs ? fTexs : nullptr;
176 if (fUseObject) {
177 auto v = SkVertices::MakeCopy(SkCanvas::kTriangleFan_VertexMode,
178 kMeshVertexCnt, fPts, texs, colors,
179 kMeshIndexCnt, kMeshFan);
180 canvas->drawVertices(v, mode, paint);
181 } else {
182 canvas->drawVertices(SkCanvas::kTriangleFan_VertexMode,
183 kMeshVertexCnt, fPts, texs, colors, mode,
184 kMeshFan, kMeshIndexCnt, paint);
185 }
186 canvas->translate(40, 0);
187 ++x;
188 }
189 }
190 }
191 }
192 canvas->restore();
193 canvas->translate(0, 40);
194 }
195 }
196
197 private:
198 typedef skiagm::GM INHERITED;
199 };
200
201 /////////////////////////////////////////////////////////////////////////////////////
202
203 DEF_GM(return new VerticesGM(true);)
DEF_GM(return new VerticesGM (false);)204 DEF_GM(return new VerticesGM(false);)
205 DEF_GM(return new VerticesGM(false, 1 / kShaderSize);)
206
207 static void draw_batching(SkCanvas* canvas, bool useObject) {
208 // Triangle fans can't batch so we convert to regular triangles,
209 static constexpr int kNumTris = kMeshIndexCnt - 2;
210 SkVertices::Builder builder(SkCanvas::kTriangles_VertexMode, kMeshVertexCnt, 3 * kNumTris,
211 SkVertices::kHasColors_BuilderFlag |
212 SkVertices::kHasTexCoords_BuilderFlag);
213
214 SkPoint* pts = builder.positions();
215 SkPoint* texs = builder.texCoords();
216 SkColor* colors = builder.colors();
217 fill_mesh(pts, texs, colors, 1);
218
219 SkTDArray<SkMatrix> matrices;
220 matrices.push()->reset();
221 matrices.push()->setTranslate(0, 40);
222 SkMatrix* m = matrices.push();
223 m->setRotate(45, kMeshSize / 2, kMeshSize / 2);
224 m->postScale(1.2f, .8f, kMeshSize / 2, kMeshSize / 2);
225 m->postTranslate(0, 80);
226
227 auto shader = make_shader1(1);
228
229 uint16_t* indices = builder.indices();
230 for (size_t i = 0; i < kNumTris; ++i) {
231 indices[3 * i] = kMeshFan[0];
232 indices[3 * i + 1] = kMeshFan[i + 1];
233 indices[3 * i + 2] = kMeshFan[i + 2];
234
235 }
236
237 canvas->save();
238 canvas->translate(10, 10);
239 for (bool useShader : {false, true}) {
240 for (bool useTex : {false, true}) {
241 for (const auto& m : matrices) {
242 canvas->save();
243 canvas->concat(m);
244 SkPaint paint;
245 paint.setShader(useShader ? shader : nullptr);
246
247 const SkPoint* t = useTex ? texs : nullptr;
248 if (useObject) {
249 auto v = SkVertices::MakeCopy(SkCanvas::kTriangles_VertexMode, kMeshVertexCnt,
250 pts, t, colors, kNumTris * 3, indices);
251 canvas->drawVertices(v, SkBlendMode::kModulate, paint);
252 } else {
253 canvas->drawVertices(SkCanvas::kTriangles_VertexMode, kMeshVertexCnt, pts,
254 t, colors, indices, kNumTris * 3, paint);
255 }
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, false);
267 canvas->translate(50, 0);
268 draw_batching(canvas, true);
269 }
270