blob: 73c8a0e0b9f4bd1386caaace9f903a5790260d4d [file] [log] [blame]
djsollen@google.com5587ac02013-08-29 20:20:40 +00001/*
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
scroggo24519372014-07-22 12:38:55 -07008#include "CanvasStateHelpers.h"
djsollen@google.com5587ac02013-08-29 20:20:40 +00009#include "SkCanvas.h"
Mike Reedebfce6d2016-12-12 10:02:12 -050010#include "SkClipOpPriv.h"
djsollen@google.com5587ac02013-08-29 20:20:40 +000011#include "SkCanvasStateUtils.h"
scroggo24519372014-07-22 12:38:55 -070012#include "SkCommandLineFlags.h"
djsollen@google.com5587ac02013-08-29 20:20:40 +000013#include "SkDrawFilter.h"
14#include "SkPaint.h"
Mike Reed84dd8572017-03-08 22:21:00 -050015#include "SkRegion.h"
djsollen@google.com5587ac02013-08-29 20:20:40 +000016#include "SkRRect.h"
tfarina@chromium.org8f6884a2014-01-24 20:56:26 +000017#include "SkRect.h"
fmalita55b29b22016-01-20 11:17:39 -080018#include "SkTLazy.h"
tfarina@chromium.org8f6884a2014-01-24 20:56:26 +000019#include "Test.h"
djsollen@google.com5587ac02013-08-29 20:20:40 +000020
scroggo24519372014-07-22 12:38:55 -070021// dlopen and the library flag are only used for tests which require this flag.
reed@google.comb93ba452014-03-10 19:47:58 +000022#ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
scroggo24519372014-07-22 12:38:55 -070023#include <dlfcn.h>
24
25DEFINE_string(library, "", "Support library to use for CanvasState test. If empty (the default), "
26 "the test will be run without crossing a library boundary. Otherwise, "
27 "it is expected to be a full path to a shared library file, which will"
28 " be dynamically loaded. Functions from the library will be called to "
29 "test SkCanvasState. Instructions for generating the library are in "
30 "gyp/canvas_state_lib.gyp");
31
32
33// This class calls dlopen on the library passed in to the command line flag library, and handles
34// calling dlclose when it goes out of scope.
35class OpenLibResult {
36public:
37 // If the flag library was passed to this run of the test, attempt to open it using dlopen and
38 // report whether it succeeded.
39 OpenLibResult(skiatest::Reporter* reporter) {
40 if (FLAGS_library.count() == 1) {
41 fHandle = dlopen(FLAGS_library[0], RTLD_LAZY | RTLD_LOCAL);
halcanary96fcdcc2015-08-27 07:41:13 -070042 REPORTER_ASSERT_MESSAGE(reporter, fHandle != nullptr, "Failed to open library!");
scroggo24519372014-07-22 12:38:55 -070043 } else {
halcanary96fcdcc2015-08-27 07:41:13 -070044 fHandle = nullptr;
scroggo24519372014-07-22 12:38:55 -070045 }
46 }
47
48 // Automatically call dlclose when going out of scope.
49 ~OpenLibResult() {
50 if (fHandle) {
51 dlclose(fHandle);
52 }
53 }
54
55 // Pointer to the shared library object.
56 void* handle() { return fHandle; }
57
58private:
59 void* fHandle;
60};
61
62DEF_TEST(CanvasState_test_complex_layers, reporter) {
djsollen@google.com5587ac02013-08-29 20:20:40 +000063 const int WIDTH = 400;
64 const int HEIGHT = 400;
65 const int SPACER = 10;
66
djsollen@google.com20146b32013-08-29 20:36:22 +000067 SkRect rect = SkRect::MakeXYWH(SkIntToScalar(SPACER), SkIntToScalar(SPACER),
68 SkIntToScalar(WIDTH-(2*SPACER)),
69 SkIntToScalar((HEIGHT-(2*SPACER)) / 7));
djsollen@google.com5587ac02013-08-29 20:20:40 +000070
commit-bot@chromium.orgfa9e5fa2014-02-13 22:00:04 +000071 const SkColorType colorTypes[] = {
commit-bot@chromium.org28fcae22014-04-11 17:15:40 +000072 kRGB_565_SkColorType, kN32_SkColorType
djsollen@google.com5587ac02013-08-29 20:20:40 +000073 };
djsollen@google.com5587ac02013-08-29 20:20:40 +000074
75 const int layerAlpha[] = { 255, 255, 0 };
fmalita55b29b22016-01-20 11:17:39 -080076 const SkCanvas::SaveLayerFlags flags[] = {
77 static_cast<SkCanvas::SaveLayerFlags>(SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag),
78 0,
79 static_cast<SkCanvas::SaveLayerFlags>(SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag),
djsollen@google.com5587ac02013-08-29 20:20:40 +000080 };
81 REPORTER_ASSERT(reporter, sizeof(layerAlpha) == sizeof(flags));
scroggo24519372014-07-22 12:38:55 -070082
83 bool (*drawFn)(SkCanvasState* state, float l, float t,
84 float r, float b, int32_t s);
85
86 OpenLibResult openLibResult(reporter);
halcanary96fcdcc2015-08-27 07:41:13 -070087 if (openLibResult.handle() != nullptr) {
scroggo24519372014-07-22 12:38:55 -070088 *(void**) (&drawFn) = dlsym(openLibResult.handle(),
89 "complex_layers_draw_from_canvas_state");
90 } else {
91 drawFn = complex_layers_draw_from_canvas_state;
92 }
93
94 REPORTER_ASSERT(reporter, drawFn);
95 if (!drawFn) {
96 return;
97 }
djsollen@google.com5587ac02013-08-29 20:20:40 +000098
scroggoecce60b2014-07-09 07:26:40 -070099 for (size_t i = 0; i < SK_ARRAY_COUNT(colorTypes); ++i) {
djsollen@google.com5587ac02013-08-29 20:20:40 +0000100 SkBitmap bitmaps[2];
101 for (int j = 0; j < 2; ++j) {
commit-bot@chromium.orgfa9e5fa2014-02-13 22:00:04 +0000102 bitmaps[j].allocPixels(SkImageInfo::Make(WIDTH, HEIGHT,
103 colorTypes[i],
104 kPremul_SkAlphaType));
djsollen@google.com5587ac02013-08-29 20:20:40 +0000105
106 SkCanvas canvas(bitmaps[j]);
107
108 canvas.drawColor(SK_ColorRED);
109
scroggo24519372014-07-22 12:38:55 -0700110 for (size_t k = 0; k < SK_ARRAY_COUNT(layerAlpha); ++k) {
fmalita55b29b22016-01-20 11:17:39 -0800111 SkTLazy<SkPaint> paint;
112 if (layerAlpha[k] != 0xFF) {
113 paint.init()->setAlpha(layerAlpha[k]);
114 }
115
djsollen@google.com5587ac02013-08-29 20:20:40 +0000116 // draw a rect within the layer's bounds and again outside the layer's bounds
fmalita55b29b22016-01-20 11:17:39 -0800117 canvas.saveLayer(SkCanvas::SaveLayerRec(&rect, paint.getMaybeNull(), flags[k]));
djsollen@google.com5587ac02013-08-29 20:20:40 +0000118
djsollen@google.com5587ac02013-08-29 20:20:40 +0000119 if (j) {
scroggo24519372014-07-22 12:38:55 -0700120 // Capture from the first Skia.
121 SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
djsollen@google.com5587ac02013-08-29 20:20:40 +0000122 REPORTER_ASSERT(reporter, state);
scroggo24519372014-07-22 12:38:55 -0700123
124 // And draw to it in the second Skia.
125 bool success = complex_layers_draw_from_canvas_state(state,
126 rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, SPACER);
127 REPORTER_ASSERT(reporter, success);
128
129 // And release it in the *first* Skia.
130 SkCanvasStateUtils::ReleaseCanvasState(state);
djsollen@google.com5587ac02013-08-29 20:20:40 +0000131 } else {
scroggo24519372014-07-22 12:38:55 -0700132 // Draw in the first Skia.
133 complex_layers_draw(&canvas, rect.fLeft, rect.fTop,
134 rect.fRight, rect.fBottom, SPACER);
djsollen@google.com5587ac02013-08-29 20:20:40 +0000135 }
136
djsollen@google.com5587ac02013-08-29 20:20:40 +0000137 canvas.restore();
138
139 // translate the canvas for the next iteration
140 canvas.translate(0, 2*(rect.height() + SPACER));
141 }
142 }
143
144 // now we memcmp the two bitmaps
145 REPORTER_ASSERT(reporter, bitmaps[0].getSize() == bitmaps[1].getSize());
146 REPORTER_ASSERT(reporter, !memcmp(bitmaps[0].getPixels(),
147 bitmaps[1].getPixels(),
148 bitmaps[0].getSize()));
149 }
150}
scroggo24519372014-07-22 12:38:55 -0700151#endif
djsollen@google.com5587ac02013-08-29 20:20:40 +0000152
153////////////////////////////////////////////////////////////////////////////////
154
reed@google.comb93ba452014-03-10 19:47:58 +0000155#ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
scroggo24519372014-07-22 12:38:55 -0700156DEF_TEST(CanvasState_test_complex_clips, reporter) {
djsollen@google.com339e79f2013-09-04 17:16:00 +0000157 const int WIDTH = 400;
158 const int HEIGHT = 400;
djsollen@google.com1037c7b2013-09-04 18:20:30 +0000159 const int SPACER = 10;
djsollen@google.com339e79f2013-09-04 17:16:00 +0000160
djsollen@google.com1037c7b2013-09-04 18:20:30 +0000161 SkIRect layerRect = SkIRect::MakeWH(WIDTH, HEIGHT / 4);
djsollen@google.com339e79f2013-09-04 17:16:00 +0000162 layerRect.inset(2*SPACER, 2*SPACER);
163
djsollen@google.com1037c7b2013-09-04 18:20:30 +0000164 SkIRect clipRect = layerRect;
djsollen@google.com339e79f2013-09-04 17:16:00 +0000165 clipRect.fRight = clipRect.fLeft + (clipRect.width() / 2) - (2*SPACER);
166 clipRect.outset(SPACER, SPACER);
167
djsollen@google.com1037c7b2013-09-04 18:20:30 +0000168 SkIRect regionBounds = clipRect;
djsollen@google.com339e79f2013-09-04 17:16:00 +0000169 regionBounds.offset(clipRect.width() + (2*SPACER), 0);
170
171 SkIRect regionInterior = regionBounds;
172 regionInterior.inset(SPACER*3, SPACER*3);
173
174 SkRegion clipRegion;
175 clipRegion.setRect(regionBounds);
176 clipRegion.op(regionInterior, SkRegion::kDifference_Op);
177
178
179 const SkRegion::Op clipOps[] = { SkRegion::kIntersect_Op,
180 SkRegion::kIntersect_Op,
181 SkRegion::kReplace_Op,
182 };
fmalita55b29b22016-01-20 11:17:39 -0800183 const SkCanvas::SaveLayerFlags flags[] = {
184 static_cast<SkCanvas::SaveLayerFlags>(SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag),
185 0,
186 static_cast<SkCanvas::SaveLayerFlags>(SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag),
djsollen@google.com339e79f2013-09-04 17:16:00 +0000187 };
188 REPORTER_ASSERT(reporter, sizeof(clipOps) == sizeof(flags));
scroggo24519372014-07-22 12:38:55 -0700189
190 bool (*drawFn)(SkCanvasState* state, int32_t l, int32_t t,
191 int32_t r, int32_t b, int32_t clipOp,
192 int32_t regionRects, int32_t* rectCoords);
193
194 OpenLibResult openLibResult(reporter);
halcanary96fcdcc2015-08-27 07:41:13 -0700195 if (openLibResult.handle() != nullptr) {
scroggo24519372014-07-22 12:38:55 -0700196 *(void**) (&drawFn) = dlsym(openLibResult.handle(),
197 "complex_clips_draw_from_canvas_state");
198 } else {
199 drawFn = complex_clips_draw_from_canvas_state;
200 }
201
202 REPORTER_ASSERT(reporter, drawFn);
203 if (!drawFn) {
204 return;
205 }
djsollen@google.com339e79f2013-09-04 17:16:00 +0000206
207 SkBitmap bitmaps[2];
208 for (int i = 0; i < 2; ++i) {
commit-bot@chromium.orgfa9e5fa2014-02-13 22:00:04 +0000209 bitmaps[i].allocN32Pixels(WIDTH, HEIGHT);
djsollen@google.com339e79f2013-09-04 17:16:00 +0000210
211 SkCanvas canvas(bitmaps[i]);
212
213 canvas.drawColor(SK_ColorRED);
214
215 SkRegion localRegion = clipRegion;
216
fmalita55b29b22016-01-20 11:17:39 -0800217 SkPaint paint;
218 paint.setAlpha(128);
scroggo24519372014-07-22 12:38:55 -0700219 for (size_t j = 0; j < SK_ARRAY_COUNT(flags); ++j) {
djsollen@google.com1037c7b2013-09-04 18:20:30 +0000220 SkRect layerBounds = SkRect::Make(layerRect);
fmalita55b29b22016-01-20 11:17:39 -0800221 canvas.saveLayer(SkCanvas::SaveLayerRec(&layerBounds, &paint, flags[j]));
djsollen@google.com339e79f2013-09-04 17:16:00 +0000222
djsollen@google.com339e79f2013-09-04 17:16:00 +0000223 if (i) {
scroggo24519372014-07-22 12:38:55 -0700224 SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
djsollen@google.com339e79f2013-09-04 17:16:00 +0000225 REPORTER_ASSERT(reporter, state);
scroggo24519372014-07-22 12:38:55 -0700226
227 SkRegion::Iterator iter(localRegion);
228 SkTDArray<int32_t> rectCoords;
229 for (; !iter.done(); iter.next()) {
230 const SkIRect& rect = iter.rect();
231 *rectCoords.append() = rect.fLeft;
232 *rectCoords.append() = rect.fTop;
233 *rectCoords.append() = rect.fRight;
234 *rectCoords.append() = rect.fBottom;
235 }
236 bool success = drawFn(state, clipRect.fLeft, clipRect.fTop,
237 clipRect.fRight, clipRect.fBottom, clipOps[j],
238 rectCoords.count() / 4, rectCoords.begin());
239 REPORTER_ASSERT(reporter, success);
240
241 SkCanvasStateUtils::ReleaseCanvasState(state);
djsollen@google.com339e79f2013-09-04 17:16:00 +0000242 } else {
scroggo24519372014-07-22 12:38:55 -0700243 complex_clips_draw(&canvas, clipRect.fLeft, clipRect.fTop,
244 clipRect.fRight, clipRect.fBottom, clipOps[j],
245 localRegion);
djsollen@google.com339e79f2013-09-04 17:16:00 +0000246 }
247
djsollen@google.com339e79f2013-09-04 17:16:00 +0000248 canvas.restore();
249
250 // translate the canvas and region for the next iteration
djsollen@google.com1037c7b2013-09-04 18:20:30 +0000251 canvas.translate(0, SkIntToScalar(2*(layerRect.height() + (SPACER))));
djsollen@google.com339e79f2013-09-04 17:16:00 +0000252 localRegion.translate(0, 2*(layerRect.height() + SPACER));
253 }
254 }
255
256 // now we memcmp the two bitmaps
257 REPORTER_ASSERT(reporter, bitmaps[0].getSize() == bitmaps[1].getSize());
258 REPORTER_ASSERT(reporter, !memcmp(bitmaps[0].getPixels(),
259 bitmaps[1].getPixels(),
260 bitmaps[0].getSize()));
261}
scroggo24519372014-07-22 12:38:55 -0700262#endif
djsollen@google.com339e79f2013-09-04 17:16:00 +0000263
264////////////////////////////////////////////////////////////////////////////////
265
benjaminwagner1c2729c2016-01-22 09:45:14 -0800266#ifdef SK_SUPPORT_LEGACY_DRAWFILTER
267
djsollen@google.com5587ac02013-08-29 20:20:40 +0000268class TestDrawFilter : public SkDrawFilter {
269public:
mtklein36352bf2015-03-25 18:17:31 -0700270 bool filter(SkPaint*, Type) override { return true; }
djsollen@google.com5587ac02013-08-29 20:20:40 +0000271};
272
scroggo24519372014-07-22 12:38:55 -0700273DEF_TEST(CanvasState_test_draw_filters, reporter) {
djsollen@google.com5587ac02013-08-29 20:20:40 +0000274 TestDrawFilter drawFilter;
commit-bot@chromium.org15a14052014-02-16 00:59:25 +0000275 SkBitmap bitmap;
276 bitmap.allocN32Pixels(10, 10);
277 SkCanvas canvas(bitmap);
djsollen@google.com5587ac02013-08-29 20:20:40 +0000278
279 canvas.setDrawFilter(&drawFilter);
280
281 SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
282 REPORTER_ASSERT(reporter, state);
Mike Reed5df49342016-11-12 08:06:55 -0600283 std::unique_ptr<SkCanvas> tmpCanvas = SkCanvasStateUtils::MakeFromCanvasState(state);
djsollen@google.com5587ac02013-08-29 20:20:40 +0000284 REPORTER_ASSERT(reporter, tmpCanvas);
285
bsalomon49f085d2014-09-05 13:34:00 -0700286 REPORTER_ASSERT(reporter, canvas.getDrawFilter());
halcanary96fcdcc2015-08-27 07:41:13 -0700287 REPORTER_ASSERT(reporter, nullptr == tmpCanvas->getDrawFilter());
djsollen@google.com5587ac02013-08-29 20:20:40 +0000288
djsollen@google.com5587ac02013-08-29 20:20:40 +0000289 SkCanvasStateUtils::ReleaseCanvasState(state);
290}
291
benjaminwagner1c2729c2016-01-22 09:45:14 -0800292#endif
293
djsollen@google.com5587ac02013-08-29 20:20:40 +0000294////////////////////////////////////////////////////////////////////////////////
295
scroggo24519372014-07-22 12:38:55 -0700296DEF_TEST(CanvasState_test_soft_clips, reporter) {
commit-bot@chromium.org15a14052014-02-16 00:59:25 +0000297 SkBitmap bitmap;
298 bitmap.allocN32Pixels(10, 10);
299 SkCanvas canvas(bitmap);
djsollen@google.com5587ac02013-08-29 20:20:40 +0000300
301 SkRRect roundRect;
302 roundRect.setOval(SkRect::MakeWH(5, 5));
303
Mike Reedc1f77742016-12-09 09:00:50 -0500304 canvas.clipRRect(roundRect, kIntersect_SkClipOp, true);
djsollen@google.com5587ac02013-08-29 20:20:40 +0000305
306 SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
307 REPORTER_ASSERT(reporter, !state);
308}
309
scroggo24519372014-07-22 12:38:55 -0700310DEF_TEST(CanvasState_test_saveLayer_clip, reporter) {
Mike Reed3726a4a2017-01-19 11:36:41 -0500311 const uint32_t dontSaveFlag = 1 << 31; // secret flag for don't save
312#ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
313 static_assert(SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag == dontSaveFlag, "");
314#endif
senorblanco@chromium.org89f077c2014-02-24 15:16:42 +0000315 const int WIDTH = 100;
316 const int HEIGHT = 100;
317 const int LAYER_WIDTH = 50;
318 const int LAYER_HEIGHT = 50;
319
320 SkBitmap bitmap;
321 bitmap.allocN32Pixels(WIDTH, HEIGHT);
322 SkCanvas canvas(bitmap);
323
324 SkRect bounds = SkRect::MakeWH(SkIntToScalar(LAYER_WIDTH), SkIntToScalar(LAYER_HEIGHT));
325 canvas.clipRect(SkRect::MakeWH(SkIntToScalar(WIDTH), SkIntToScalar(HEIGHT)));
326
Mike Reed3726a4a2017-01-19 11:36:41 -0500327 SkIRect devClip;
328 // Check that saveLayer without the kClipToLayer_SaveFlag leaves the clip unchanged.
329 canvas.saveLayer(SkCanvas::SaveLayerRec(&bounds, nullptr, dontSaveFlag));
Mike Reed918e1442017-01-23 11:39:45 -0500330 devClip = canvas.getDeviceClipBounds();
Mike Reed3726a4a2017-01-19 11:36:41 -0500331 REPORTER_ASSERT(reporter, canvas.isClipRect());
332 REPORTER_ASSERT(reporter, devClip.width() == WIDTH);
333 REPORTER_ASSERT(reporter, devClip.height() == HEIGHT);
senorblanco@chromium.org89f077c2014-02-24 15:16:42 +0000334 canvas.restore();
335
336 // Check that saveLayer with the kClipToLayer_SaveFlag sets the clip
337 // stack to the layer bounds.
fmalita55b29b22016-01-20 11:17:39 -0800338 canvas.saveLayer(&bounds, nullptr);
Mike Reed918e1442017-01-23 11:39:45 -0500339 devClip = canvas.getDeviceClipBounds();
Mike Reed3726a4a2017-01-19 11:36:41 -0500340 REPORTER_ASSERT(reporter, canvas.isClipRect());
341 REPORTER_ASSERT(reporter, devClip.width() == LAYER_WIDTH);
342 REPORTER_ASSERT(reporter, devClip.height() == LAYER_HEIGHT);
senorblanco@chromium.org89f077c2014-02-24 15:16:42 +0000343 canvas.restore();
scroggo24519372014-07-22 12:38:55 -0700344}