1 /*
2 * Copyright 2011 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/SkPaint.h"
14 #include "include/core/SkPoint.h"
15 #include "include/core/SkRect.h"
16 #include "include/core/SkShader.h"
17 #include "include/core/SkSize.h"
18 #include "include/core/SkString.h"
19 #include "include/core/SkSurface.h"
20 #include "include/core/SkTileMode.h"
21 #include "include/core/SkTypes.h"
22 #include "include/effects/SkGradientShader.h"
23
make_image()24 static sk_sp<SkImage> make_image() {
25 auto surf = SkSurface::MakeRasterN32Premul(64, 64);
26 auto canvas = surf->getCanvas();
27
28 canvas->drawColor(SK_ColorRED);
29 SkPaint paint;
30 paint.setAntiAlias(true);
31 const SkPoint pts[] = { { 0, 0 }, { 64, 64 } };
32 const SkColor colors[] = { SK_ColorWHITE, SK_ColorBLUE };
33 paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp));
34 canvas->drawCircle(32, 32, 32, paint);
35
36 return surf->makeImageSnapshot();
37 }
38
39 class DrawBitmapRect2 : public skiagm::GM {
40 bool fUseIRect;
41 public:
DrawBitmapRect2(bool useIRect)42 DrawBitmapRect2(bool useIRect) : fUseIRect(useIRect) {
43 }
44
45 protected:
onShortName()46 SkString onShortName() override {
47 SkString str;
48 str.printf("bitmaprect_%s", fUseIRect ? "i" : "s");
49 return str;
50 }
51
onISize()52 SkISize onISize() override {
53 return SkISize::Make(640, 480);
54 }
55
onDraw(SkCanvas * canvas)56 void onDraw(SkCanvas* canvas) override {
57 canvas->drawColor(0xFFCCCCCC);
58
59 const SkIRect src[] = {
60 { 0, 0, 32, 32 },
61 { 0, 0, 80, 80 },
62 { 32, 32, 96, 96 },
63 { -32, -32, 32, 32, }
64 };
65
66 SkPaint paint;
67 paint.setStyle(SkPaint::kStroke_Style);
68 auto sampling = SkSamplingOptions();
69
70 auto image = make_image();
71
72 SkRect dstR = { 0, 200, 128, 380 };
73
74 canvas->translate(16, 40);
75 for (size_t i = 0; i < SK_ARRAY_COUNT(src); i++) {
76 SkRect srcR;
77 srcR.set(src[i]);
78
79 canvas->drawImage(image, 0, 0, sampling, &paint);
80 if (!fUseIRect) {
81 canvas->drawImageRect(image.get(), srcR, dstR, sampling, &paint,
82 SkCanvas::kStrict_SrcRectConstraint);
83 } else {
84 canvas->drawImageRect(image.get(), SkRect::Make(src[i]), dstR, sampling, &paint,
85 SkCanvas::kStrict_SrcRectConstraint);
86 }
87
88 canvas->drawRect(dstR, paint);
89 canvas->drawRect(srcR, paint);
90
91 canvas->translate(160, 0);
92 }
93 }
94
95 private:
96 using INHERITED = skiagm::GM;
97 };
98
99 //////////////////////////////////////////////////////////////////////////////
100
make_3x3_bitmap(SkBitmap * bitmap)101 static void make_3x3_bitmap(SkBitmap* bitmap) {
102 const int xSize = 3;
103 const int ySize = 3;
104
105 const SkColor textureData[xSize][ySize] = {
106 { SK_ColorRED, SK_ColorWHITE, SK_ColorBLUE },
107 { SK_ColorGREEN, SK_ColorBLACK, SK_ColorCYAN },
108 { SK_ColorYELLOW, SK_ColorGRAY, SK_ColorMAGENTA }
109 };
110
111 bitmap->allocN32Pixels(xSize, ySize, true);
112 SkCanvas canvas(*bitmap);
113 SkPaint paint;
114
115 for (int y = 0; y < ySize; y++) {
116 for (int x = 0; x < xSize; x++) {
117 paint.setColor(textureData[x][y]);
118 canvas.drawIRect(SkIRect::MakeXYWH(x, y, 1, 1), paint);
119 }
120 }
121 }
122
123 // This GM attempts to make visible any issues drawBitmapRect may have
124 // with partial source rects. In this case the eight pixels on the border
125 // should be half the width/height of the central pixel, i.e.:
126 // __|____|__
127 // | |
128 // __|____|__
129 // | |
130 class DrawBitmapRect3 : public skiagm::GM {
131 public:
DrawBitmapRect3()132 DrawBitmapRect3() {
133 this->setBGColor(SK_ColorBLACK);
134 }
135
136 protected:
onShortName()137 SkString onShortName() override {
138 SkString str;
139 str.printf("3x3bitmaprect");
140 return str;
141 }
142
onISize()143 SkISize onISize() override {
144 return SkISize::Make(640, 480);
145 }
146
onDraw(SkCanvas * canvas)147 void onDraw(SkCanvas* canvas) override {
148
149 SkBitmap bitmap;
150 make_3x3_bitmap(&bitmap);
151
152 SkRect srcR = { 0.5f, 0.5f, 2.5f, 2.5f };
153 SkRect dstR = { 100, 100, 300, 200 };
154
155 canvas->drawImageRect(bitmap.asImage(), srcR, dstR, SkSamplingOptions(),
156 nullptr, SkCanvas::kStrict_SrcRectConstraint);
157 }
158
159 private:
160 using INHERITED = skiagm::GM;
161 };
162
163 //////////////////////////////////////////////////////////////////////////////
make_big_bitmap()164 static sk_sp<SkImage> make_big_bitmap() {
165
166 constexpr int gXSize = 4096;
167 constexpr int gYSize = 4096;
168 constexpr int gBorderWidth = 10;
169
170 SkBitmap bitmap;
171 bitmap.allocN32Pixels(gXSize, gYSize);
172 for (int y = 0; y < gYSize; ++y) {
173 for (int x = 0; x < gXSize; ++x) {
174 if (x <= gBorderWidth || x >= gXSize-gBorderWidth ||
175 y <= gBorderWidth || y >= gYSize-gBorderWidth) {
176 *bitmap.getAddr32(x, y) = SkPreMultiplyColor(0x88FFFFFF);
177 } else {
178 *bitmap.getAddr32(x, y) = SkPreMultiplyColor(0x88FF0000);
179 }
180 }
181 }
182 bitmap.setImmutable();
183 return bitmap.asImage();
184 }
185
186 // This GM attempts to reveal any issues we may have when the GPU has to
187 // break up a large texture in order to draw it. The XOR transfer mode will
188 // create stripes in the image if there is imprecision in the destination
189 // tile placement.
190 class DrawBitmapRect4 : public skiagm::GM {
191 bool fUseIRect;
192 sk_sp<SkImage> fBigImage;
193
194 public:
DrawBitmapRect4(bool useIRect)195 DrawBitmapRect4(bool useIRect) : fUseIRect(useIRect) {
196 this->setBGColor(0x88444444);
197 }
198
199 protected:
onShortName()200 SkString onShortName() override {
201 SkString str;
202 str.printf("bigbitmaprect_%s", fUseIRect ? "i" : "s");
203 return str;
204 }
205
onISize()206 SkISize onISize() override {
207 return SkISize::Make(640, 480);
208 }
209
onOnceBeforeDraw()210 void onOnceBeforeDraw() override {
211 fBigImage = make_big_bitmap();
212 }
213
onDraw(SkCanvas * canvas)214 void onDraw(SkCanvas* canvas) override {
215 SkPaint paint;
216 paint.setAlpha(128);
217 paint.setBlendMode(SkBlendMode::kXor);
218 SkSamplingOptions sampling;
219
220 SkRect srcR1 = { 0.0f, 0.0f, 4096.0f, 2040.0f };
221 SkRect dstR1 = { 10.1f, 10.1f, 629.9f, 400.9f };
222
223 SkRect srcR2 = { 4085.0f, 10.0f, 4087.0f, 12.0f };
224 SkRect dstR2 = { 10, 410, 30, 430 };
225
226 if (!fUseIRect) {
227 canvas->drawImageRect(fBigImage, srcR1, dstR1, sampling, &paint,
228 SkCanvas::kStrict_SrcRectConstraint);
229 canvas->drawImageRect(fBigImage, srcR2, dstR2, sampling, &paint,
230 SkCanvas::kStrict_SrcRectConstraint);
231 } else {
232 canvas->drawImageRect(fBigImage, SkRect::Make(srcR1.roundOut()), dstR1, sampling,
233 &paint, SkCanvas::kStrict_SrcRectConstraint);
234 canvas->drawImageRect(fBigImage, SkRect::Make(srcR2.roundOut()), dstR2, sampling,
235 &paint, SkCanvas::kStrict_SrcRectConstraint);
236 }
237 }
238
239 private:
240 using INHERITED = skiagm::GM;
241 };
242
243 class BitmapRectRounding : public skiagm::GM {
244 SkBitmap fBM;
245
246 public:
BitmapRectRounding()247 BitmapRectRounding() {}
248
249 protected:
onShortName()250 SkString onShortName() override {
251 SkString str;
252 str.printf("bitmaprect_rounding");
253 return str;
254 }
255
onISize()256 SkISize onISize() override {
257 return SkISize::Make(640, 480);
258 }
259
onOnceBeforeDraw()260 void onOnceBeforeDraw() override {
261 fBM.allocN32Pixels(10, 10);
262 fBM.eraseColor(SK_ColorBLUE);
263 }
264
265 // This choice of coordinates and matrix land the bottom edge of the clip (and bitmap dst)
266 // at exactly 1/2 pixel boundary. However, drawBitmapRect may lose precision along the way.
267 // If it does, we may see a red-line at the bottom, instead of the bitmap exactly matching
268 // the clip (in which case we should see all blue).
269 // The correct image should be all blue.
onDraw(SkCanvas * canvas)270 void onDraw(SkCanvas* canvas) override {
271 SkPaint paint;
272 paint.setColor(SK_ColorRED);
273
274 const SkRect r = SkRect::MakeXYWH(1, 1, 110, 114);
275 canvas->scale(0.9f, 0.9f);
276
277 // the drawRect shows the same problem as clipRect(r) followed by drawcolor(red)
278 canvas->drawRect(r, paint);
279 canvas->drawImageRect(fBM.asImage(), r, SkSamplingOptions());
280 }
281
282 private:
283 using INHERITED = skiagm::GM;
284 };
285 DEF_GM( return new BitmapRectRounding; )
286
287 //////////////////////////////////////////////////////////////////////////////
288
289 DEF_GM( return new DrawBitmapRect2(false); )
290 DEF_GM( return new DrawBitmapRect2(true); )
291 DEF_GM( return new DrawBitmapRect3(); )
292
293 #ifndef SK_BUILD_FOR_ANDROID
294 DEF_GM( return new DrawBitmapRect4(false); )
295 DEF_GM( return new DrawBitmapRect4(true); )
296 #endif
297