1 /*
2 * Copyright 2016 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/SkPaint.h"
16 #include "include/core/SkRect.h"
17 #include "include/core/SkRefCnt.h"
18 #include "include/core/SkScalar.h"
19 #include "include/core/SkSize.h"
20 #include "include/core/SkString.h"
21 #include "include/core/SkSurface.h"
22 #include "include/private/SkMalloc.h"
23 #include "tools/ToolUtils.h"
24
make_surface(SkCanvas * root,int N,int padLeft,int padTop,int padRight,int padBottom)25 static sk_sp<SkSurface> make_surface(SkCanvas* root, int N, int padLeft, int padTop,
26 int padRight, int padBottom) {
27 SkImageInfo info = SkImageInfo::MakeN32Premul(N + padLeft + padRight, N + padTop + padBottom);
28 return ToolUtils::makeSurface(root, info);
29 }
30
make_image(SkCanvas * root,int * xDivs,int * yDivs,int padLeft,int padTop,int padRight,int padBottom)31 static sk_sp<SkImage> make_image(SkCanvas* root, int* xDivs, int* yDivs, int padLeft, int padTop,
32 int padRight, int padBottom) {
33 const int kCap = 28;
34 const int kMid = 8;
35 const int kSize = 2*kCap + 3*kMid;
36
37 auto surface(make_surface(root, kSize, padLeft, padTop, padRight, padBottom));
38 SkCanvas* canvas = surface->getCanvas();
39 canvas->translate((float) padLeft, (float) padTop);
40
41 SkRect r = SkRect::MakeWH(SkIntToScalar(kSize), SkIntToScalar(kSize));
42 const SkScalar strokeWidth = SkIntToScalar(6);
43 const SkScalar radius = SkIntToScalar(kCap) - strokeWidth/2;
44
45 xDivs[0] = kCap + padLeft;
46 yDivs[0] = kCap + padTop;
47 xDivs[1] = kCap + kMid + padLeft;
48 yDivs[1] = kCap + kMid + padTop;
49 xDivs[2] = kCap + 2 * kMid + padLeft;
50 yDivs[2] = kCap + 2 * kMid + padTop;
51 xDivs[3] = kCap + 3 * kMid + padLeft;
52 yDivs[3] = kCap + 3 * kMid + padTop;
53
54 SkPaint paint;
55 paint.setAntiAlias(true);
56
57 paint.setColor(0xFFFFFF00);
58 canvas->drawRoundRect(r, radius, radius, paint);
59
60 r.setXYWH(SkIntToScalar(kCap), 0, SkIntToScalar(kMid), SkIntToScalar(kSize));
61 paint.setColor(0x8800FF00);
62 canvas->drawRect(r, paint);
63 r.setXYWH(SkIntToScalar(kCap + kMid), 0, SkIntToScalar(kMid), SkIntToScalar(kSize));
64 paint.setColor(0x880000FF);
65 canvas->drawRect(r, paint);
66 r.setXYWH(SkIntToScalar(kCap + 2*kMid), 0, SkIntToScalar(kMid), SkIntToScalar(kSize));
67 paint.setColor(0x88FF00FF);
68 canvas->drawRect(r, paint);
69
70 r.setXYWH(0, SkIntToScalar(kCap), SkIntToScalar(kSize), SkIntToScalar(kMid));
71 paint.setColor(0x8800FF00);
72 canvas->drawRect(r, paint);
73 r.setXYWH(0, SkIntToScalar(kCap + kMid), SkIntToScalar(kSize), SkIntToScalar(kMid));
74 paint.setColor(0x880000FF);
75 canvas->drawRect(r, paint);
76 r.setXYWH(0, SkIntToScalar(kCap + 2*kMid), SkIntToScalar(kSize), SkIntToScalar(kMid));
77 paint.setColor(0x88FF00FF);
78 canvas->drawRect(r, paint);
79
80 return surface->makeImageSnapshot();
81 }
82
image_to_bitmap(const SkImage * image,SkBitmap * bm)83 static void image_to_bitmap(const SkImage* image, SkBitmap* bm) {
84 SkImageInfo info = SkImageInfo::MakeN32Premul(image->width(), image->height());
85 bm->allocPixels(info);
86 image->readPixels(info, bm->getPixels(), bm->rowBytes(), 0, 0);
87 }
88
89 /**
90 * This is similar to NinePatchStretchGM, but it also tests "ninepatch" images with more
91 * than nine patches.
92 */
93 class LatticeGM : public skiagm::GM {
94 public:
LatticeGM()95 LatticeGM() {}
96
97 protected:
onShortName()98 SkString onShortName() override {
99 return SkString("lattice");
100 }
101
onISize()102 SkISize onISize() override {
103 return SkISize::Make(800, 800);
104 }
105
onDrawHelper(SkCanvas * canvas,int padLeft,int padTop,int padRight,int padBottom)106 void onDrawHelper(SkCanvas* canvas, int padLeft, int padTop, int padRight, int padBottom) {
107 canvas->save();
108
109 int xDivs[5];
110 int yDivs[5];
111 xDivs[0] = padLeft;
112 yDivs[0] = padTop;
113
114 SkBitmap bitmap;
115 sk_sp<SkImage> image = make_image(canvas, xDivs + 1, yDivs + 1, padLeft, padTop,
116 padRight, padBottom);
117 image_to_bitmap(image.get(), &bitmap);
118
119 const SkSize size[] = {
120 { 50, 50, }, // shrink in both axes
121 { 50, 200, }, // shrink in X
122 { 200, 50, }, // shrink in Y
123 { 200, 200, },
124 };
125
126 canvas->drawImage(image, 10, 10, nullptr);
127
128 SkScalar x = SkIntToScalar(100);
129 SkScalar y = SkIntToScalar(100);
130
131 SkCanvas::Lattice lattice;
132 lattice.fXCount = 4;
133 lattice.fXDivs = xDivs + 1;
134 lattice.fYCount = 4;
135 lattice.fYDivs = yDivs + 1;
136 lattice.fRectTypes = nullptr;
137 lattice.fColors = nullptr;
138
139 SkIRect bounds = SkIRect::MakeLTRB(padLeft, padTop,
140 image->width() - padRight, image->height() - padBottom);
141 lattice.fBounds = (bounds == SkIRect::MakeWH(image->width(), image->height())) ?
142 nullptr : &bounds;
143
144 for (int iy = 0; iy < 2; ++iy) {
145 for (int ix = 0; ix < 2; ++ix) {
146 int i = ix * 2 + iy;
147 SkRect r = SkRect::MakeXYWH(x + ix * 60, y + iy * 60,
148 size[i].width(), size[i].height());
149 canvas->drawBitmapLattice(bitmap, lattice, r);
150 }
151 }
152
153 // Provide hints about 3 solid color rects. These colors match
154 // what was already in the bitmap.
155 int fixedColorX[3] = {2, 4, 1};
156 int fixedColorY[3] = {1, 1, 2};
157 SkColor fixedColor[3] = {SK_ColorBLACK, SK_ColorBLACK, SK_ColorBLACK};
158 const SkImageInfo info = SkImageInfo::Make(1, 1, kBGRA_8888_SkColorType,
159 kUnpremul_SkAlphaType);
160 for (int rectNum = 0; rectNum < 3; rectNum++) {
161 int srcX = xDivs[fixedColorX[rectNum]-1];
162 int srcY = yDivs[fixedColorY[rectNum]-1];
163 image->readPixels(info, &fixedColor[rectNum], 4, srcX, srcY);
164 }
165
166 // Include the degenerate first div. While normally the first patch is "scalable",
167 // this will mean that the first non-degenerate patch is "fixed".
168 lattice.fXCount = 5;
169 lattice.fXDivs = xDivs;
170 lattice.fYCount = 5;
171 lattice.fYDivs = yDivs;
172
173 // Let's skip a few rects.
174 SkCanvas::Lattice::RectType flags[36];
175 sk_bzero(flags, 36 * sizeof(SkCanvas::Lattice::RectType));
176 flags[4] = SkCanvas::Lattice::kTransparent;
177 flags[9] = SkCanvas::Lattice::kTransparent;
178 flags[12] = SkCanvas::Lattice::kTransparent;
179 flags[19] = SkCanvas::Lattice::kTransparent;
180 for (int rectNum = 0; rectNum < 3; rectNum++) {
181 flags[fixedColorY[rectNum]*6 + fixedColorX[rectNum]]
182 = SkCanvas::Lattice::kFixedColor;
183 }
184 lattice.fRectTypes = flags;
185
186 SkColor colors[36];
187 sk_bzero(colors, 36 * sizeof(SkColor));
188 for (int rectNum = 0; rectNum < 3; rectNum++) {
189 colors[fixedColorY[rectNum]*6 + fixedColorX[rectNum]]
190 = fixedColor[rectNum];
191 }
192
193 lattice.fColors = colors;
194
195 canvas->translate(400, 0);
196 for (int iy = 0; iy < 2; ++iy) {
197 for (int ix = 0; ix < 2; ++ix) {
198 int i = ix * 2 + iy;
199 SkRect r = SkRect::MakeXYWH(x + ix * 60, y + iy * 60,
200 size[i].width(), size[i].height());
201 canvas->drawImageLattice(image.get(), lattice, r);
202 }
203 }
204
205 canvas->restore();
206 }
207
onDraw(SkCanvas * canvas)208 void onDraw(SkCanvas* canvas) override {
209 this->onDrawHelper(canvas, 0, 0, 0, 0);
210 canvas->translate(0.0f, 400.0f);
211 this->onDrawHelper(canvas, 3, 7, 4, 11);
212 }
213
214 private:
215 typedef skiagm::GM INHERITED;
216 };
217 DEF_GM( return new LatticeGM; )
218
219
220 // LatticeGM2 exercises code paths that draw fixed color and 1x1 rectangles.
221 class LatticeGM2 : public skiagm::GM {
222 public:
LatticeGM2()223 LatticeGM2() {}
onShortName()224 SkString onShortName() override {
225 return SkString("lattice2");
226 }
227
onISize()228 SkISize onISize() override {
229 return SkISize::Make(800, 800);
230 }
231
makeImage(SkCanvas * root,int padLeft,int padTop,int padRight,int padBottom)232 sk_sp<SkImage> makeImage(SkCanvas* root, int padLeft, int padTop, int padRight, int padBottom) {
233 const int kSize = 80;
234 auto surface(make_surface(root, kSize, padLeft, padTop, padRight, padBottom));
235 SkCanvas* canvas = surface->getCanvas();
236 SkPaint paint;
237 paint.setAntiAlias(false);
238 SkRect r;
239
240 //first line
241 r.setXYWH(0, 0, 4, 1); //4x1 green rect
242 paint.setColor(0xFF00FF00);
243 canvas->drawRect(r, paint);
244
245 r.setXYWH(4, 0, 1, 1); //1x1 blue pixel -> draws as rectangle
246 paint.setColor(0xFF0000FF);
247 canvas->drawRect(r, paint);
248
249 r.setXYWH(5, 0, kSize-5, 1); //the rest of the line is red
250 paint.setColor(0xFFFF0000);
251 canvas->drawRect(r, paint);
252
253
254 //second line -> draws as fixed color rectangles
255 r.setXYWH(0, 1, 4, 1); //4x1 red rect
256 paint.setColor(0xFFFF0000);
257 canvas->drawRect(r, paint);
258
259 r.setXYWH(4, 1, 1, 1); //1x1 blue pixel with alpha
260 paint.setColor(0x880000FF);
261 canvas->drawRect(r, paint);
262
263 r.setXYWH(5, 1, kSize-5, 1); //the rest of the line is green
264 paint.setColor(0xFF00FF00);
265 canvas->drawRect(r, paint);
266
267
268 //third line - does not draw, because it is transparent
269 r.setXYWH(0, 2, 4, kSize-2); //4x78 green rect
270 paint.setColor(0xFF00FF00);
271 canvas->drawRect(r, paint);
272
273 r.setXYWH(4, 2, 1, kSize-2); //1x78 red pixel with alpha
274 paint.setColor(0x88FF0000);
275 canvas->drawRect(r, paint);
276
277 r.setXYWH(5, 2, kSize-5, kSize-2); //the rest of the image is blue
278 paint.setColor(0xFF0000FF);
279 canvas->drawRect(r, paint);
280
281 return surface->makeImageSnapshot();
282 }
283
onDrawHelper(SkCanvas * canvas,int padLeft,int padTop,int padRight,int padBottom,SkPaint & paint)284 void onDrawHelper(SkCanvas* canvas, int padLeft, int padTop, int padRight, int padBottom,
285 SkPaint& paint) {
286 int xDivs[2] = {4, 5};
287 int yDivs[2] = {1, 2};
288
289 canvas->save();
290
291 sk_sp<SkImage> image = makeImage(canvas, padLeft, padTop, padRight, padBottom);
292
293 canvas->drawImage(image, 10, 10, nullptr);
294
295 SkCanvas::Lattice lattice;
296 lattice.fXCount = 2;
297 lattice.fXDivs = xDivs;
298 lattice.fYCount = 2;
299 lattice.fYDivs = yDivs;
300 lattice.fBounds = nullptr;
301
302 SkCanvas::Lattice::RectType flags[9];
303 sk_bzero(flags, 9 * sizeof(SkCanvas::Lattice::RectType));
304 flags[3] = SkCanvas::Lattice::kFixedColor;
305 flags[4] = SkCanvas::Lattice::kFixedColor;
306 flags[5] = SkCanvas::Lattice::kFixedColor;
307
308 flags[6] = SkCanvas::Lattice::kTransparent;
309 flags[7] = SkCanvas::Lattice::kTransparent;
310 flags[8] = SkCanvas::Lattice::kTransparent;
311 lattice.fRectTypes = flags;
312
313 SkColor colors[9] = {SK_ColorBLACK, SK_ColorBLACK, SK_ColorBLACK,
314 0xFFFF0000, 0x880000FF, 0xFF00FF00,
315 SK_ColorBLACK, SK_ColorBLACK, SK_ColorBLACK};
316 lattice.fColors = colors;
317 paint.setColor(0xFFFFFFFF);
318 canvas->drawImageLattice(image.get(), lattice,
319 SkRect::MakeXYWH(100, 100, 200, 200), &paint);
320
321 //draw the same content with alpha
322 canvas->translate(400, 0);
323 paint.setColor(0x80000FFF);
324 canvas->drawImageLattice(image.get(), lattice,
325 SkRect::MakeXYWH(100, 100, 200, 200), &paint);
326
327 canvas->restore();
328 }
329
onDraw(SkCanvas * canvas)330 void onDraw(SkCanvas* canvas) override {
331
332 //draw a rectangle in the background with transparent pixels
333 SkPaint paint;
334 paint.setColor(0x7F123456);
335 paint.setBlendMode(SkBlendMode::kSrc);
336 canvas->drawRect( SkRect::MakeXYWH(300, 0, 300, 800), paint);
337
338 //draw image lattice with kSrcOver blending
339 paint.setBlendMode(SkBlendMode::kSrcOver);
340 this->onDrawHelper(canvas, 0, 0, 0, 0, paint);
341
342 //draw image lattice with kSrcATop blending
343 canvas->translate(0.0f, 400.0f);
344 paint.setBlendMode(SkBlendMode::kSrcATop);
345 this->onDrawHelper(canvas, 0, 0, 0, 0, paint);
346 }
347
348 private:
349 typedef skiagm::GM INHERITED;
350 };
351 DEF_GM( return new LatticeGM2; )
352
353 // Code paths that incorporate the paint color when drawing the lattice (using an alpha image)
354 DEF_SIMPLE_GM_BG(lattice_alpha, canvas, 120, 120, SK_ColorWHITE) {
355 auto surface = ToolUtils::makeSurface(canvas, SkImageInfo::MakeA8(100, 100));
356 surface->getCanvas()->clear(0);
357 surface->getCanvas()->drawCircle(50, 50, 50, SkPaint());
358 auto image = surface->makeImageSnapshot();
359
360 int divs[] = { 20, 40, 60, 80 };
361
362 SkCanvas::Lattice lattice;
363 lattice.fXCount = 4;
364 lattice.fXDivs = divs;
365 lattice.fYCount = 4;
366 lattice.fYDivs = divs;
367 lattice.fRectTypes = nullptr;
368 lattice.fColors = nullptr;
369 lattice.fBounds = nullptr;
370
371 SkPaint paint;
372 paint.setColor(SK_ColorMAGENTA);
373 canvas->drawImageLattice(image.get(), lattice, SkRect::MakeWH(120, 120), &paint);
374 }
375