blob: 2e78d158661136bc69d9a8c7739c68e0aefe7125 [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"
Florin Malitaab244f02017-05-03 19:16:58 +00009#include "SkBitmap.h"
djsollen@google.com5587ac02013-08-29 20:20:40 +000010#include "SkCanvas.h"
Ben Wagner1a462bd2018-03-12 13:46:21 -040011#include "SkClipOpPriv.h"
Ben Wagner501c17c2018-03-12 20:04:31 +000012#include "SkCanvasStateUtils.h"
scroggo24519372014-07-22 12:38:55 -070013#include "SkCommandLineFlags.h"
djsollen@google.com5587ac02013-08-29 20:20:40 +000014#include "SkDrawFilter.h"
15#include "SkPaint.h"
Ben Wagner501c17c2018-03-12 20:04:31 +000016#include "SkRegion.h"
djsollen@google.com5587ac02013-08-29 20:20:40 +000017#include "SkRRect.h"
tfarina@chromium.org8f6884a2014-01-24 20:56:26 +000018#include "SkRect.h"
fmalita55b29b22016-01-20 11:17:39 -080019#include "SkTLazy.h"
tfarina@chromium.org8f6884a2014-01-24 20:56:26 +000020#include "Test.h"
djsollen@google.com5587ac02013-08-29 20:20:40 +000021
scroggo24519372014-07-22 12:38:55 -070022// dlopen and the library flag are only used for tests which require this flag.
reed@google.comb93ba452014-03-10 19:47:58 +000023#ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
scroggo24519372014-07-22 12:38:55 -070024#include <dlfcn.h>
25
26DEFINE_string(library, "", "Support library to use for CanvasState test. If empty (the default), "
27 "the test will be run without crossing a library boundary. Otherwise, "
28 "it is expected to be a full path to a shared library file, which will"
29 " be dynamically loaded. Functions from the library will be called to "
30 "test SkCanvasState. Instructions for generating the library are in "
31 "gyp/canvas_state_lib.gyp");
32
33
34// This class calls dlopen on the library passed in to the command line flag library, and handles
35// calling dlclose when it goes out of scope.
36class OpenLibResult {
37public:
38 // If the flag library was passed to this run of the test, attempt to open it using dlopen and
39 // report whether it succeeded.
40 OpenLibResult(skiatest::Reporter* reporter) {
41 if (FLAGS_library.count() == 1) {
42 fHandle = dlopen(FLAGS_library[0], RTLD_LAZY | RTLD_LOCAL);
Brian Salomon1c80e992018-01-29 09:50:47 -050043 REPORTER_ASSERT(reporter, fHandle != nullptr, "Failed to open library!");
scroggo24519372014-07-22 12:38:55 -070044 } else {
halcanary96fcdcc2015-08-27 07:41:13 -070045 fHandle = nullptr;
scroggo24519372014-07-22 12:38:55 -070046 }
47 }
48
49 // Automatically call dlclose when going out of scope.
50 ~OpenLibResult() {
51 if (fHandle) {
52 dlclose(fHandle);
53 }
54 }
55
56 // Pointer to the shared library object.
57 void* handle() { return fHandle; }
58
59private:
60 void* fHandle;
61};
62
63DEF_TEST(CanvasState_test_complex_layers, reporter) {
djsollen@google.com5587ac02013-08-29 20:20:40 +000064 const int WIDTH = 400;
65 const int HEIGHT = 400;
66 const int SPACER = 10;
67
djsollen@google.com20146b32013-08-29 20:36:22 +000068 SkRect rect = SkRect::MakeXYWH(SkIntToScalar(SPACER), SkIntToScalar(SPACER),
69 SkIntToScalar(WIDTH-(2*SPACER)),
70 SkIntToScalar((HEIGHT-(2*SPACER)) / 7));
djsollen@google.com5587ac02013-08-29 20:20:40 +000071
commit-bot@chromium.orgfa9e5fa2014-02-13 22:00:04 +000072 const SkColorType colorTypes[] = {
commit-bot@chromium.org28fcae22014-04-11 17:15:40 +000073 kRGB_565_SkColorType, kN32_SkColorType
djsollen@google.com5587ac02013-08-29 20:20:40 +000074 };
djsollen@google.com5587ac02013-08-29 20:20:40 +000075
76 const int layerAlpha[] = { 255, 255, 0 };
fmalita55b29b22016-01-20 11:17:39 -080077 const SkCanvas::SaveLayerFlags flags[] = {
78 static_cast<SkCanvas::SaveLayerFlags>(SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag),
79 0,
80 static_cast<SkCanvas::SaveLayerFlags>(SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag),
djsollen@google.com5587ac02013-08-29 20:20:40 +000081 };
82 REPORTER_ASSERT(reporter, sizeof(layerAlpha) == sizeof(flags));
scroggo24519372014-07-22 12:38:55 -070083
84 bool (*drawFn)(SkCanvasState* state, float l, float t,
85 float r, float b, int32_t s);
86
87 OpenLibResult openLibResult(reporter);
halcanary96fcdcc2015-08-27 07:41:13 -070088 if (openLibResult.handle() != nullptr) {
scroggo24519372014-07-22 12:38:55 -070089 *(void**) (&drawFn) = dlsym(openLibResult.handle(),
90 "complex_layers_draw_from_canvas_state");
91 } else {
92 drawFn = complex_layers_draw_from_canvas_state;
93 }
94
95 REPORTER_ASSERT(reporter, drawFn);
96 if (!drawFn) {
97 return;
98 }
djsollen@google.com5587ac02013-08-29 20:20:40 +000099
scroggoecce60b2014-07-09 07:26:40 -0700100 for (size_t i = 0; i < SK_ARRAY_COUNT(colorTypes); ++i) {
djsollen@google.com5587ac02013-08-29 20:20:40 +0000101 SkBitmap bitmaps[2];
102 for (int j = 0; j < 2; ++j) {
commit-bot@chromium.orgfa9e5fa2014-02-13 22:00:04 +0000103 bitmaps[j].allocPixels(SkImageInfo::Make(WIDTH, HEIGHT,
104 colorTypes[i],
105 kPremul_SkAlphaType));
djsollen@google.com5587ac02013-08-29 20:20:40 +0000106
107 SkCanvas canvas(bitmaps[j]);
108
109 canvas.drawColor(SK_ColorRED);
110
scroggo24519372014-07-22 12:38:55 -0700111 for (size_t k = 0; k < SK_ARRAY_COUNT(layerAlpha); ++k) {
fmalita55b29b22016-01-20 11:17:39 -0800112 SkTLazy<SkPaint> paint;
113 if (layerAlpha[k] != 0xFF) {
114 paint.init()->setAlpha(layerAlpha[k]);
115 }
116
djsollen@google.com5587ac02013-08-29 20:20:40 +0000117 // draw a rect within the layer's bounds and again outside the layer's bounds
fmalita55b29b22016-01-20 11:17:39 -0800118 canvas.saveLayer(SkCanvas::SaveLayerRec(&rect, paint.getMaybeNull(), flags[k]));
djsollen@google.com5587ac02013-08-29 20:20:40 +0000119
djsollen@google.com5587ac02013-08-29 20:20:40 +0000120 if (j) {
scroggo24519372014-07-22 12:38:55 -0700121 // Capture from the first Skia.
122 SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
djsollen@google.com5587ac02013-08-29 20:20:40 +0000123 REPORTER_ASSERT(reporter, state);
scroggo24519372014-07-22 12:38:55 -0700124
125 // And draw to it in the second Skia.
126 bool success = complex_layers_draw_from_canvas_state(state,
127 rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, SPACER);
128 REPORTER_ASSERT(reporter, success);
129
130 // And release it in the *first* Skia.
131 SkCanvasStateUtils::ReleaseCanvasState(state);
djsollen@google.com5587ac02013-08-29 20:20:40 +0000132 } else {
scroggo24519372014-07-22 12:38:55 -0700133 // Draw in the first Skia.
134 complex_layers_draw(&canvas, rect.fLeft, rect.fTop,
135 rect.fRight, rect.fBottom, SPACER);
djsollen@google.com5587ac02013-08-29 20:20:40 +0000136 }
137
djsollen@google.com5587ac02013-08-29 20:20:40 +0000138 canvas.restore();
139
140 // translate the canvas for the next iteration
141 canvas.translate(0, 2*(rect.height() + SPACER));
142 }
143 }
144
145 // now we memcmp the two bitmaps
Mike Reeddf071d72017-10-09 13:09:55 -0400146 REPORTER_ASSERT(reporter, bitmaps[0].computeByteSize() == bitmaps[1].computeByteSize());
djsollen@google.com5587ac02013-08-29 20:20:40 +0000147 REPORTER_ASSERT(reporter, !memcmp(bitmaps[0].getPixels(),
148 bitmaps[1].getPixels(),
Mike Reeddf071d72017-10-09 13:09:55 -0400149 bitmaps[0].computeByteSize()));
djsollen@google.com5587ac02013-08-29 20:20:40 +0000150 }
151}
scroggo24519372014-07-22 12:38:55 -0700152#endif
djsollen@google.com5587ac02013-08-29 20:20:40 +0000153
154////////////////////////////////////////////////////////////////////////////////
155
reed@google.comb93ba452014-03-10 19:47:58 +0000156#ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
scroggo24519372014-07-22 12:38:55 -0700157DEF_TEST(CanvasState_test_complex_clips, reporter) {
djsollen@google.com339e79f2013-09-04 17:16:00 +0000158 const int WIDTH = 400;
159 const int HEIGHT = 400;
djsollen@google.com1037c7b2013-09-04 18:20:30 +0000160 const int SPACER = 10;
djsollen@google.com339e79f2013-09-04 17:16:00 +0000161
djsollen@google.com1037c7b2013-09-04 18:20:30 +0000162 SkIRect layerRect = SkIRect::MakeWH(WIDTH, HEIGHT / 4);
djsollen@google.com339e79f2013-09-04 17:16:00 +0000163 layerRect.inset(2*SPACER, 2*SPACER);
164
djsollen@google.com1037c7b2013-09-04 18:20:30 +0000165 SkIRect clipRect = layerRect;
djsollen@google.com339e79f2013-09-04 17:16:00 +0000166 clipRect.fRight = clipRect.fLeft + (clipRect.width() / 2) - (2*SPACER);
167 clipRect.outset(SPACER, SPACER);
168
djsollen@google.com1037c7b2013-09-04 18:20:30 +0000169 SkIRect regionBounds = clipRect;
djsollen@google.com339e79f2013-09-04 17:16:00 +0000170 regionBounds.offset(clipRect.width() + (2*SPACER), 0);
171
172 SkIRect regionInterior = regionBounds;
173 regionInterior.inset(SPACER*3, SPACER*3);
174
175 SkRegion clipRegion;
176 clipRegion.setRect(regionBounds);
177 clipRegion.op(regionInterior, SkRegion::kDifference_Op);
178
179
180 const SkRegion::Op clipOps[] = { SkRegion::kIntersect_Op,
181 SkRegion::kIntersect_Op,
182 SkRegion::kReplace_Op,
183 };
fmalita55b29b22016-01-20 11:17:39 -0800184 const SkCanvas::SaveLayerFlags flags[] = {
185 static_cast<SkCanvas::SaveLayerFlags>(SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag),
186 0,
187 static_cast<SkCanvas::SaveLayerFlags>(SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag),
djsollen@google.com339e79f2013-09-04 17:16:00 +0000188 };
189 REPORTER_ASSERT(reporter, sizeof(clipOps) == sizeof(flags));
scroggo24519372014-07-22 12:38:55 -0700190
191 bool (*drawFn)(SkCanvasState* state, int32_t l, int32_t t,
192 int32_t r, int32_t b, int32_t clipOp,
193 int32_t regionRects, int32_t* rectCoords);
194
195 OpenLibResult openLibResult(reporter);
halcanary96fcdcc2015-08-27 07:41:13 -0700196 if (openLibResult.handle() != nullptr) {
scroggo24519372014-07-22 12:38:55 -0700197 *(void**) (&drawFn) = dlsym(openLibResult.handle(),
198 "complex_clips_draw_from_canvas_state");
199 } else {
200 drawFn = complex_clips_draw_from_canvas_state;
201 }
202
203 REPORTER_ASSERT(reporter, drawFn);
204 if (!drawFn) {
205 return;
206 }
djsollen@google.com339e79f2013-09-04 17:16:00 +0000207
208 SkBitmap bitmaps[2];
209 for (int i = 0; i < 2; ++i) {
commit-bot@chromium.orgfa9e5fa2014-02-13 22:00:04 +0000210 bitmaps[i].allocN32Pixels(WIDTH, HEIGHT);
djsollen@google.com339e79f2013-09-04 17:16:00 +0000211
212 SkCanvas canvas(bitmaps[i]);
213
214 canvas.drawColor(SK_ColorRED);
215
216 SkRegion localRegion = clipRegion;
217
fmalita55b29b22016-01-20 11:17:39 -0800218 SkPaint paint;
219 paint.setAlpha(128);
scroggo24519372014-07-22 12:38:55 -0700220 for (size_t j = 0; j < SK_ARRAY_COUNT(flags); ++j) {
djsollen@google.com1037c7b2013-09-04 18:20:30 +0000221 SkRect layerBounds = SkRect::Make(layerRect);
fmalita55b29b22016-01-20 11:17:39 -0800222 canvas.saveLayer(SkCanvas::SaveLayerRec(&layerBounds, &paint, flags[j]));
djsollen@google.com339e79f2013-09-04 17:16:00 +0000223
djsollen@google.com339e79f2013-09-04 17:16:00 +0000224 if (i) {
scroggo24519372014-07-22 12:38:55 -0700225 SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
djsollen@google.com339e79f2013-09-04 17:16:00 +0000226 REPORTER_ASSERT(reporter, state);
scroggo24519372014-07-22 12:38:55 -0700227
228 SkRegion::Iterator iter(localRegion);
229 SkTDArray<int32_t> rectCoords;
230 for (; !iter.done(); iter.next()) {
231 const SkIRect& rect = iter.rect();
232 *rectCoords.append() = rect.fLeft;
233 *rectCoords.append() = rect.fTop;
234 *rectCoords.append() = rect.fRight;
235 *rectCoords.append() = rect.fBottom;
236 }
237 bool success = drawFn(state, clipRect.fLeft, clipRect.fTop,
238 clipRect.fRight, clipRect.fBottom, clipOps[j],
239 rectCoords.count() / 4, rectCoords.begin());
240 REPORTER_ASSERT(reporter, success);
241
242 SkCanvasStateUtils::ReleaseCanvasState(state);
djsollen@google.com339e79f2013-09-04 17:16:00 +0000243 } else {
scroggo24519372014-07-22 12:38:55 -0700244 complex_clips_draw(&canvas, clipRect.fLeft, clipRect.fTop,
245 clipRect.fRight, clipRect.fBottom, clipOps[j],
246 localRegion);
djsollen@google.com339e79f2013-09-04 17:16:00 +0000247 }
248
djsollen@google.com339e79f2013-09-04 17:16:00 +0000249 canvas.restore();
250
251 // translate the canvas and region for the next iteration
djsollen@google.com1037c7b2013-09-04 18:20:30 +0000252 canvas.translate(0, SkIntToScalar(2*(layerRect.height() + (SPACER))));
djsollen@google.com339e79f2013-09-04 17:16:00 +0000253 localRegion.translate(0, 2*(layerRect.height() + SPACER));
254 }
255 }
256
257 // now we memcmp the two bitmaps
Mike Reeddf071d72017-10-09 13:09:55 -0400258 REPORTER_ASSERT(reporter, bitmaps[0].computeByteSize() == bitmaps[1].computeByteSize());
djsollen@google.com339e79f2013-09-04 17:16:00 +0000259 REPORTER_ASSERT(reporter, !memcmp(bitmaps[0].getPixels(),
260 bitmaps[1].getPixels(),
Mike Reeddf071d72017-10-09 13:09:55 -0400261 bitmaps[0].computeByteSize()));
djsollen@google.com339e79f2013-09-04 17:16:00 +0000262}
scroggo24519372014-07-22 12:38:55 -0700263#endif
djsollen@google.com339e79f2013-09-04 17:16:00 +0000264
265////////////////////////////////////////////////////////////////////////////////
266
benjaminwagner1c2729c2016-01-22 09:45:14 -0800267#ifdef SK_SUPPORT_LEGACY_DRAWFILTER
268
djsollen@google.com5587ac02013-08-29 20:20:40 +0000269class TestDrawFilter : public SkDrawFilter {
270public:
mtklein36352bf2015-03-25 18:17:31 -0700271 bool filter(SkPaint*, Type) override { return true; }
djsollen@google.com5587ac02013-08-29 20:20:40 +0000272};
273
scroggo24519372014-07-22 12:38:55 -0700274DEF_TEST(CanvasState_test_draw_filters, reporter) {
djsollen@google.com5587ac02013-08-29 20:20:40 +0000275 TestDrawFilter drawFilter;
commit-bot@chromium.org15a14052014-02-16 00:59:25 +0000276 SkBitmap bitmap;
277 bitmap.allocN32Pixels(10, 10);
278 SkCanvas canvas(bitmap);
djsollen@google.com5587ac02013-08-29 20:20:40 +0000279
280 canvas.setDrawFilter(&drawFilter);
281
282 SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
283 REPORTER_ASSERT(reporter, state);
Mike Reed5df49342016-11-12 08:06:55 -0600284 std::unique_ptr<SkCanvas> tmpCanvas = SkCanvasStateUtils::MakeFromCanvasState(state);
djsollen@google.com5587ac02013-08-29 20:20:40 +0000285 REPORTER_ASSERT(reporter, tmpCanvas);
286
bsalomon49f085d2014-09-05 13:34:00 -0700287 REPORTER_ASSERT(reporter, canvas.getDrawFilter());
halcanary96fcdcc2015-08-27 07:41:13 -0700288 REPORTER_ASSERT(reporter, nullptr == tmpCanvas->getDrawFilter());
djsollen@google.com5587ac02013-08-29 20:20:40 +0000289
djsollen@google.com5587ac02013-08-29 20:20:40 +0000290 SkCanvasStateUtils::ReleaseCanvasState(state);
291}
292
benjaminwagner1c2729c2016-01-22 09:45:14 -0800293#endif
294
djsollen@google.com5587ac02013-08-29 20:20:40 +0000295////////////////////////////////////////////////////////////////////////////////
296
scroggo24519372014-07-22 12:38:55 -0700297DEF_TEST(CanvasState_test_soft_clips, reporter) {
commit-bot@chromium.org15a14052014-02-16 00:59:25 +0000298 SkBitmap bitmap;
299 bitmap.allocN32Pixels(10, 10);
300 SkCanvas canvas(bitmap);
djsollen@google.com5587ac02013-08-29 20:20:40 +0000301
302 SkRRect roundRect;
303 roundRect.setOval(SkRect::MakeWH(5, 5));
304
Mike Reedc1f77742016-12-09 09:00:50 -0500305 canvas.clipRRect(roundRect, kIntersect_SkClipOp, true);
djsollen@google.com5587ac02013-08-29 20:20:40 +0000306
307 SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
308 REPORTER_ASSERT(reporter, !state);
309}
310
scroggo24519372014-07-22 12:38:55 -0700311DEF_TEST(CanvasState_test_saveLayer_clip, reporter) {
Mike Reed3726a4a2017-01-19 11:36:41 -0500312 const uint32_t dontSaveFlag = 1 << 31; // secret flag for don't save
313#ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
314 static_assert(SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag == dontSaveFlag, "");
315#endif
senorblanco@chromium.org89f077c2014-02-24 15:16:42 +0000316 const int WIDTH = 100;
317 const int HEIGHT = 100;
318 const int LAYER_WIDTH = 50;
319 const int LAYER_HEIGHT = 50;
320
321 SkBitmap bitmap;
322 bitmap.allocN32Pixels(WIDTH, HEIGHT);
323 SkCanvas canvas(bitmap);
324
325 SkRect bounds = SkRect::MakeWH(SkIntToScalar(LAYER_WIDTH), SkIntToScalar(LAYER_HEIGHT));
326 canvas.clipRect(SkRect::MakeWH(SkIntToScalar(WIDTH), SkIntToScalar(HEIGHT)));
327
Mike Reed3726a4a2017-01-19 11:36:41 -0500328 SkIRect devClip;
329 // Check that saveLayer without the kClipToLayer_SaveFlag leaves the clip unchanged.
330 canvas.saveLayer(SkCanvas::SaveLayerRec(&bounds, nullptr, dontSaveFlag));
Mike Reed918e1442017-01-23 11:39:45 -0500331 devClip = canvas.getDeviceClipBounds();
Mike Reed3726a4a2017-01-19 11:36:41 -0500332 REPORTER_ASSERT(reporter, canvas.isClipRect());
333 REPORTER_ASSERT(reporter, devClip.width() == WIDTH);
334 REPORTER_ASSERT(reporter, devClip.height() == HEIGHT);
senorblanco@chromium.org89f077c2014-02-24 15:16:42 +0000335 canvas.restore();
336
337 // Check that saveLayer with the kClipToLayer_SaveFlag sets the clip
338 // stack to the layer bounds.
fmalita55b29b22016-01-20 11:17:39 -0800339 canvas.saveLayer(&bounds, nullptr);
Mike Reed918e1442017-01-23 11:39:45 -0500340 devClip = canvas.getDeviceClipBounds();
Mike Reed3726a4a2017-01-19 11:36:41 -0500341 REPORTER_ASSERT(reporter, canvas.isClipRect());
342 REPORTER_ASSERT(reporter, devClip.width() == LAYER_WIDTH);
343 REPORTER_ASSERT(reporter, devClip.height() == LAYER_HEIGHT);
senorblanco@chromium.org89f077c2014-02-24 15:16:42 +0000344 canvas.restore();
scroggo24519372014-07-22 12:38:55 -0700345}