1 /*
2 * Copyright 2014 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/SkColorSpace.h"
13 #include "include/core/SkFont.h"
14 #include "include/core/SkImage.h"
15 #include "include/core/SkImageInfo.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/SkSurfaceProps.h"
26 #include "include/core/SkTileMode.h"
27 #include "include/core/SkTypeface.h"
28 #include "include/core/SkTypes.h"
29 #include "include/effects/SkGradientShader.h"
30 #include "include/gpu/GrDirectContext.h"
31 #include "include/gpu/GrRecordingContext.h"
32 #include "include/utils/SkTextUtils.h"
33 #include "tools/ToolUtils.h"
34 #include "tools/gpu/BackendSurfaceFactory.h"
35
36 #define W 200
37 #define H 100
38
make_shader()39 static sk_sp<SkShader> make_shader() {
40 int a = 0x99;
41 int b = 0xBB;
42 SkPoint pts[] = { { 0, 0 }, { W, H } };
43 SkColor colors[] = { SkColorSetRGB(a, a, a), SkColorSetRGB(b, b, b) };
44 return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
45 }
46
make_surface(GrRecordingContext * ctx,const SkImageInfo & info,SkPixelGeometry geo)47 static sk_sp<SkSurface> make_surface(GrRecordingContext* ctx,
48 const SkImageInfo& info,
49 SkPixelGeometry geo) {
50 SkSurfaceProps props(0, geo);
51 if (ctx) {
52 return SkSurface::MakeRenderTarget(ctx, SkBudgeted::kNo, info, 0, &props);
53 } else {
54 return SkSurface::MakeRaster(info, &props);
55 }
56 }
57
test_draw(SkCanvas * canvas,const char label[])58 static void test_draw(SkCanvas* canvas, const char label[]) {
59 SkPaint paint;
60
61 paint.setAntiAlias(true);
62 paint.setDither(true);
63
64 paint.setShader(make_shader());
65 canvas->drawRect(SkRect::MakeWH(W, H), paint);
66 paint.setShader(nullptr);
67
68 paint.setColor(SK_ColorWHITE);
69 SkFont font(ToolUtils::create_portable_typeface(), 32);
70 font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
71 SkTextUtils::DrawString(canvas, label, W / 2, H * 3 / 4, font, paint,
72 SkTextUtils::kCenter_Align);
73 }
74
75 class SurfacePropsGM : public skiagm::GM {
76 public:
SurfacePropsGM()77 SurfacePropsGM() {}
78
79 protected:
onShortName()80 SkString onShortName() override {
81 return SkString("surfaceprops");
82 }
83
onISize()84 SkISize onISize() override {
85 return SkISize::Make(W, H * 5);
86 }
87
onDraw(SkCanvas * canvas)88 void onDraw(SkCanvas* canvas) override {
89 auto ctx = canvas->recordingContext();
90
91 // must be opaque to have a hope of testing LCD text
92 const SkImageInfo info = SkImageInfo::MakeN32(W, H, kOpaque_SkAlphaType);
93
94 const struct {
95 SkPixelGeometry fGeo;
96 const char* fLabel;
97 } recs[] = {
98 { kUnknown_SkPixelGeometry, "Unknown" },
99 { kRGB_H_SkPixelGeometry, "RGB_H" },
100 { kBGR_H_SkPixelGeometry, "BGR_H" },
101 { kRGB_V_SkPixelGeometry, "RGB_V" },
102 { kBGR_V_SkPixelGeometry, "BGR_V" },
103 };
104
105 SkScalar x = 0;
106 SkScalar y = 0;
107 for (const auto& rec : recs) {
108 auto surface(make_surface(ctx, info, rec.fGeo));
109 if (!surface) {
110 SkDebugf("failed to create surface! label: %s", rec.fLabel);
111 continue;
112 }
113 test_draw(surface->getCanvas(), rec.fLabel);
114 surface->draw(canvas, x, y);
115 y += H;
116 }
117 }
118
119 private:
120 using INHERITED = GM;
121 };
DEF_GM(return new SurfacePropsGM)122 DEF_GM( return new SurfacePropsGM )
123
124 #ifdef SK_DEBUG
125 static bool equal(const SkSurfaceProps& a, const SkSurfaceProps& b) {
126 return a.flags() == b.flags() && a.pixelGeometry() == b.pixelGeometry();
127 }
128 #endif
129
130 class NewSurfaceGM : public skiagm::GM {
131 public:
NewSurfaceGM()132 NewSurfaceGM() {}
133
134 protected:
onShortName()135 SkString onShortName() override {
136 return SkString("surfacenew");
137 }
138
onISize()139 SkISize onISize() override {
140 return SkISize::Make(300, 140);
141 }
142
drawInto(SkCanvas * canvas)143 static void drawInto(SkCanvas* canvas) {
144 canvas->drawColor(SK_ColorRED);
145 }
146
onDraw(SkCanvas * canvas)147 void onDraw(SkCanvas* canvas) override {
148 SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100);
149
150 auto surf(ToolUtils::makeSurface(canvas, info, nullptr));
151 drawInto(surf->getCanvas());
152
153 sk_sp<SkImage> image(surf->makeImageSnapshot());
154 canvas->drawImage(image, 10, 10);
155
156 auto surf2(surf->makeSurface(info));
157 drawInto(surf2->getCanvas());
158
159 // Assert that the props were communicated transitively through the first image
160 SkASSERT(equal(surf->props(), surf2->props()));
161
162 sk_sp<SkImage> image2(surf2->makeImageSnapshot());
163 canvas->drawImage(image2.get(), 10 + SkIntToScalar(image->width()) + 10, 10);
164 }
165
166 private:
167 using INHERITED = GM;
168 };
169 DEF_GM( return new NewSurfaceGM )
170
171 ///////////////////////////////////////////////////////////////////////////////////////////////////
172
173 // The GPU backend may behave differently when images are snapped from wrapped textures and
174 // render targets compared.
175 namespace {
176 enum SurfaceType {
177 kManaged,
178 kBackendTexture,
179 kBackendRenderTarget
180 };
181 }
182
make_surface(const SkImageInfo & ii,SkCanvas * canvas,SurfaceType type)183 static sk_sp<SkSurface> make_surface(const SkImageInfo& ii, SkCanvas* canvas, SurfaceType type) {
184 GrDirectContext* direct = GrAsDirectContext(canvas->recordingContext());
185 switch (type) {
186 case kManaged:
187 return ToolUtils::makeSurface(canvas, ii);
188 case kBackendTexture:
189 if (!direct) {
190 return nullptr;
191 }
192 return sk_gpu_test::MakeBackendTextureSurface(direct, ii, kTopLeft_GrSurfaceOrigin, 1);
193 case kBackendRenderTarget:
194 return sk_gpu_test::MakeBackendRenderTargetSurface(direct,
195 ii,
196 kTopLeft_GrSurfaceOrigin,
197 1);
198 }
199 return nullptr;
200 }
201
202 using MakeSurfaceFn = std::function<sk_sp<SkSurface>(const SkImageInfo&)>;
203
204 #define DEF_BASIC_SURFACE_TEST(name, canvas, main, W, H) \
205 DEF_SIMPLE_GM(name, canvas, W, H) { \
206 auto make = [canvas](const SkImageInfo& ii) { \
207 return make_surface(ii, canvas, SurfaceType::kManaged); \
208 }; \
209 main(canvas, MakeSurfaceFn(make)); \
210 }
211
212 #define DEF_BACKEND_SURFACE_TEST(name, canvas, main, type, W, H) \
213 DEF_SIMPLE_GM_CAN_FAIL(name, canvas, err_msg, W, H) { \
214 GrDirectContext* direct = GrAsDirectContext(canvas->recordingContext()); \
215 if (!direct || direct->abandoned()) { \
216 *err_msg = "Requires non-abandoned GrDirectContext"; \
217 return skiagm::DrawResult::kSkip; \
218 } \
219 auto make = [canvas](const SkImageInfo& ii) { return make_surface(ii, canvas, type); }; \
220 main(canvas, MakeSurfaceFn(make)); \
221 return skiagm::DrawResult::kOk; \
222 }
223
224 #define DEF_BET_SURFACE_TEST(name, canvas, main, W, H) \
225 DEF_BACKEND_SURFACE_TEST(SK_MACRO_CONCAT(name, _bet), canvas, main, \
226 SurfaceType::kBackendTexture, W, H)
227
228 #define DEF_BERT_SURFACE_TEST(name, canvas, main, W, H) \
229 DEF_BACKEND_SURFACE_TEST(SK_MACRO_CONCAT(name, _bert), canvas, main, \
230 SurfaceType::kBackendRenderTarget, W, H)
231
232 // This makes 3 GMs from the same code, normal, wrapped backend texture, and wrapped backend
233 // render target.
234 #define DEF_SURFACE_TESTS(name, canvas, W, H) \
235 static void SK_MACRO_CONCAT(name, _main)(SkCanvas*, const MakeSurfaceFn&); \
236 DEF_BASIC_SURFACE_TEST(name, canvas, SK_MACRO_CONCAT(name, _main), W, H) \
237 DEF_BET_SURFACE_TEST (name, canvas, SK_MACRO_CONCAT(name, _main), W, H) \
238 DEF_BERT_SURFACE_TEST (name, canvas, SK_MACRO_CONCAT(name, _main), W, H) \
239 static void SK_MACRO_CONCAT(name, _main)(SkCanvas * canvas, const MakeSurfaceFn& make)
240
241 DEF_SURFACE_TESTS(copy_on_write_retain, canvas, 256, 256) {
242 const SkImageInfo info = SkImageInfo::MakeN32Premul(256, 256);
243 sk_sp<SkSurface> surf = make(info);
244
245 surf->getCanvas()->clear(SK_ColorRED);
246 // its important that image survives longer than the next draw, so the surface will see
247 // an outstanding image, and have to decide if it should retain or discard those pixels
248 sk_sp<SkImage> image = surf->makeImageSnapshot();
249
250 // normally a clear+opaque should trigger the discard optimization, but since we have a clip
251 // it should not (we need the previous red pixels).
252 surf->getCanvas()->clipRect(SkRect::MakeWH(128, 256));
253 surf->getCanvas()->clear(SK_ColorBLUE);
254
255 // expect to see two rects: blue | red
256 canvas->drawImage(surf->makeImageSnapshot(), 0, 0);
257 }
258
259 // Like copy_on_write_retain but draws the snapped image back to the surface it was snapped from.
260 DEF_SURFACE_TESTS(copy_on_write_retain2, canvas, 256, 256) {
261 const SkImageInfo info = SkImageInfo::MakeN32Premul(256, 256);
262 sk_sp<SkSurface> surf = make(info);
263
264 surf->getCanvas()->clear(SK_ColorBLUE);
265 // its important that image survives longer than the next draw, so the surface will see
266 // an outstanding image, and have to decide if it should retain or discard those pixels
267 sk_sp<SkImage> image = surf->makeImageSnapshot();
268
269 surf->getCanvas()->clear(SK_ColorRED);
270 // normally a clear+opaque should trigger the discard optimization, but since we have a clip
271 // it should not (we need the previous red pixels).
272 surf->getCanvas()->clipRect(SkRect::MakeWH(128, 256));
273 surf->getCanvas()->drawImage(image, 0, 0);
274
275 // expect to see two rects: blue | red
276 canvas->drawImage(surf->makeImageSnapshot(), 0, 0);
277 }
278
279 DEF_SURFACE_TESTS(simple_snap_image, canvas, 256, 256) {
280 const SkImageInfo info = SkImageInfo::MakeN32Premul(256, 256);
281 sk_sp<SkSurface> surf = make(info);
282
283 surf->getCanvas()->clear(SK_ColorRED);
284 sk_sp<SkImage> image = surf->makeImageSnapshot();
285 // expect to see just red
286 canvas->drawImage(std::move(image), 0, 0);
287 }
288
289 // Like simple_snap_image but the surface dies before the image.
290 DEF_SURFACE_TESTS(simple_snap_image2, canvas, 256, 256) {
291 const SkImageInfo info = SkImageInfo::MakeN32Premul(256, 256);
292 sk_sp<SkSurface> surf = make(info);
293
294 surf->getCanvas()->clear(SK_ColorRED);
295 sk_sp<SkImage> image = surf->makeImageSnapshot();
296 surf.reset();
297 // expect to see just red
298 canvas->drawImage(std::move(image), 0, 0);
299 }
300
301 DEF_SURFACE_TESTS(copy_on_write_savelayer, canvas, 256, 256) {
302 const SkImageInfo info = SkImageInfo::MakeN32Premul(256, 256);
303 sk_sp<SkSurface> surf = make(info);
304 surf->getCanvas()->clear(SK_ColorRED);
305 // its important that image survives longer than the next draw, so the surface will see
306 // an outstanding image, and have to decide if it should retain or discard those pixels
307 sk_sp<SkImage> image = surf->makeImageSnapshot();
308
309 // now draw into a full-screen layer. This should (a) trigger a copy-on-write, but it should
310 // not trigger discard, even tho its alpha (SK_ColorBLUE) is opaque, since it is in a layer
311 // with a non-opaque paint.
312 SkPaint paint;
313 paint.setAlphaf(0.25f);
314 surf->getCanvas()->saveLayer({0, 0, 256, 256}, &paint);
315 surf->getCanvas()->clear(SK_ColorBLUE);
316 surf->getCanvas()->restore();
317
318 // expect to see two rects: blue blended on red
319 canvas->drawImage(surf->makeImageSnapshot(), 0, 0);
320 }
321
322 DEF_SURFACE_TESTS(surface_underdraw, canvas, 256, 256) {
323 SkImageInfo info = SkImageInfo::MakeN32Premul(256, 256, nullptr);
324 auto surf = make(info);
325
326 const SkIRect subset = SkIRect::MakeLTRB(180, 0, 256, 256);
327
328 // noisy background
329 {
330 SkPoint pts[] = {{0, 0}, {40, 50}};
331 SkColor colors[] = {SK_ColorRED, SK_ColorBLUE};
332 auto sh = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kRepeat);
333 SkPaint paint;
334 paint.setShader(sh);
335 surf->getCanvas()->drawPaint(paint);
336 }
337
338 // save away the right-hand strip, then clear it
339 sk_sp<SkImage> saveImg = surf->makeImageSnapshot(subset);
340 {
341 SkPaint paint;
342 paint.setBlendMode(SkBlendMode::kClear);
343 surf->getCanvas()->drawRect(SkRect::Make(subset), paint);
344 }
345
346 // draw the "foreground"
347 {
348 SkPaint paint;
349 paint.setColor(SK_ColorGREEN);
350 SkRect r = { 0, 10, 256, 35 };
351 while (r.fBottom < 256) {
352 surf->getCanvas()->drawRect(r, paint);
353 r.offset(0, r.height() * 2);
354 }
355 }
356
357 // apply the "fade"
358 {
359 SkPoint pts[] = {{SkIntToScalar(subset.left()), 0}, {SkIntToScalar(subset.right()), 0}};
360 SkColor colors[] = {0xFF000000, 0};
361 auto sh = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
362 SkPaint paint;
363 paint.setShader(sh);
364 paint.setBlendMode(SkBlendMode::kDstIn);
365 surf->getCanvas()->drawRect(SkRect::Make(subset), paint);
366 }
367
368 // restore the original strip, drawing it "under" the current foreground
369 {
370 SkPaint paint;
371 paint.setBlendMode(SkBlendMode::kDstOver);
372 surf->getCanvas()->drawImage(saveImg,
373 SkIntToScalar(subset.left()), SkIntToScalar(subset.top()),
374 SkSamplingOptions(), &paint);
375 }
376
377 // show it on screen
378 surf->draw(canvas, 0, 0);
379 }
380