savelayer.cpp 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471
  1. /*
  2. * Copyright 2017 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. #include "gm/gm.h"
  8. #include "include/core/SkBlendMode.h"
  9. #include "include/core/SkCanvas.h"
  10. #include "include/core/SkColor.h"
  11. #include "include/core/SkColorSpace.h"
  12. #include "include/core/SkFont.h"
  13. #include "include/core/SkImage.h"
  14. #include "include/core/SkImageFilter.h"
  15. #include "include/core/SkImageInfo.h"
  16. #include "include/core/SkMaskFilter.h"
  17. #include "include/core/SkMatrix.h"
  18. #include "include/core/SkPaint.h"
  19. #include "include/core/SkPicture.h"
  20. #include "include/core/SkPictureRecorder.h"
  21. #include "include/core/SkPoint.h"
  22. #include "include/core/SkRect.h"
  23. #include "include/core/SkRefCnt.h"
  24. #include "include/core/SkScalar.h"
  25. #include "include/core/SkShader.h"
  26. #include "include/core/SkSize.h"
  27. #include "include/core/SkString.h"
  28. #include "include/core/SkSurface.h"
  29. #include "include/core/SkTextBlob.h"
  30. #include "include/core/SkTileMode.h"
  31. #include "include/core/SkTypeface.h"
  32. #include "include/core/SkTypes.h"
  33. #include "include/effects/SkBlurImageFilter.h"
  34. #include "include/effects/SkGradientShader.h"
  35. #include "include/effects/SkShaderMaskFilter.h"
  36. #include "include/utils/SkRandom.h"
  37. #include "src/core/SkCanvasPriv.h"
  38. #include "tools/Resources.h"
  39. #include "tools/ToolUtils.h"
  40. #include <string.h>
  41. #include <initializer_list>
  42. // This GM tests out the deprecated Android-specific unclipped saveLayer "feature".
  43. // In particular, it attempts to compare the performance of unclipped saveLayers with alternatives.
  44. static void save_layer_unclipped(SkCanvas* canvas,
  45. SkScalar l, SkScalar t, SkScalar r, SkScalar b) {
  46. SkRect rect = SkRect::MakeLTRB(l, t, r, b);
  47. canvas->saveLayer({ &rect, nullptr, nullptr, nullptr, nullptr,
  48. (SkCanvas::SaveLayerFlags) SkCanvasPriv::kDontClipToLayer_SaveLayerFlag });
  49. }
  50. static void do_draw(SkCanvas* canvas) {
  51. SkPaint paint;
  52. SkRandom rand;
  53. for (int i = 0; i < 20; ++i) {
  54. paint.setColor(ToolUtils::color_to_565(rand.nextU() | (0xFF << 24)));
  55. canvas->drawRect({ 15, 15, 290, 40 }, paint);
  56. canvas->translate(0, 30);
  57. }
  58. }
  59. class UnclippedSaveLayerGM : public skiagm::GM {
  60. public:
  61. enum class Mode {
  62. kClipped,
  63. kUnclipped
  64. };
  65. UnclippedSaveLayerGM(Mode mode) : fMode(mode) { this->setBGColor(SK_ColorWHITE); }
  66. protected:
  67. bool runAsBench() const override { return true; }
  68. SkString onShortName() override {
  69. if (Mode::kClipped == fMode) {
  70. return SkString("savelayer_unclipped");
  71. } else {
  72. SkASSERT(Mode::kUnclipped == fMode);
  73. return SkString("savelayer_clipped");
  74. }
  75. }
  76. SkISize onISize() override { return SkISize::Make(320, 640); }
  77. void onDraw(SkCanvas* canvas) override {
  78. const SkScalar L = 10;
  79. const SkScalar T = 10;
  80. const SkScalar R = 310;
  81. const SkScalar B = 630;
  82. canvas->clipRect({ L, T, R, B });
  83. for (int i = 0; i < 100; ++i) {
  84. SkAutoCanvasRestore acr(canvas, true);
  85. if (Mode::kClipped == fMode) {
  86. save_layer_unclipped(canvas, L, T, R, T + 20);
  87. save_layer_unclipped(canvas, L, B - 20, R, B);
  88. } else {
  89. SkASSERT(Mode::kUnclipped == fMode);
  90. canvas->saveLayer({ L, T, R, B }, nullptr);
  91. }
  92. do_draw(canvas);
  93. }
  94. }
  95. private:
  96. Mode fMode;
  97. typedef skiagm::GM INHERITED;
  98. };
  99. DEF_GM(return new UnclippedSaveLayerGM(UnclippedSaveLayerGM::Mode::kClipped);)
  100. DEF_GM(return new UnclippedSaveLayerGM(UnclippedSaveLayerGM::Mode::kUnclipped);)
  101. DEF_SIMPLE_GM(picture_savelayer, canvas, 320, 640) {
  102. SkPaint paint1, paint2, paint3;
  103. paint1.setAlphaf(0.5f);
  104. paint2.setAlphaf(0.25f);
  105. paint3.setColor(0xFFFF0000);
  106. SkRect rect1{40, 5, 80, 70}, rect2{5, 40, 70, 80}, rect3{10, 10, 70, 70};
  107. // In the future, we might also test the clipped case by allowing i = 0
  108. for(int i = 1; i < 2; ++i) {
  109. canvas->translate(100 * i, 0);
  110. auto flag = i ?
  111. (SkCanvas::SaveLayerFlags) SkCanvasPriv::kDontClipToLayer_SaveLayerFlag : 0;
  112. canvas->saveLayer({ &rect1, &paint1, nullptr, nullptr, nullptr, flag});
  113. canvas->saveLayer({ &rect2, &paint2, nullptr, nullptr, nullptr, flag});
  114. canvas->drawRect(rect3, paint3);
  115. canvas->restore();
  116. canvas->restore();
  117. }
  118. };
  119. // Test kInitWithPrevious_SaveLayerFlag by drawing an image, save a layer with the flag, which
  120. // should seed the layer with the image (from below). Then we punch a hole in the layer and
  121. // restore with kPlus mode, which should show the mandrill super-bright on the outside, but
  122. // normal where we punched the hole.
  123. DEF_SIMPLE_GM(savelayer_initfromprev, canvas, 256, 256) {
  124. canvas->drawImage(GetResourceAsImage("images/mandrill_256.png"), 0, 0, nullptr);
  125. SkCanvas::SaveLayerRec rec;
  126. SkPaint paint;
  127. paint.setBlendMode(SkBlendMode::kPlus);
  128. rec.fSaveLayerFlags = SkCanvas::kInitWithPrevious_SaveLayerFlag;
  129. rec.fPaint = &paint;
  130. canvas->saveLayer(rec);
  131. paint.setBlendMode(SkBlendMode::kClear);
  132. canvas->drawCircle(128, 128, 96, paint);
  133. canvas->restore();
  134. };
  135. static void draw_mask(SkCanvas* canvas, int size) {
  136. const SkScalar cx = size * SK_ScalarHalf,
  137. cy = cx;
  138. const SkColor colors[] = { 0x00000000, 0xffff0000, 0x00000000, 0xffff0000, 0x00000000,
  139. 0xffff0000, 0x00000000, 0xffff0000, 0x00000000 };
  140. SkPaint paint;
  141. paint.setAntiAlias(true);
  142. paint.setShader(SkGradientShader::MakeSweep(cx, cy, colors, nullptr, SK_ARRAY_COUNT(colors)));
  143. canvas->drawPaint(paint);
  144. paint.setShader(SkGradientShader::MakeRadial({cx, cy}, size / 4, colors, nullptr, 2,
  145. SkTileMode::kClamp));
  146. canvas->drawCircle(cx, cy, size / 4, paint);
  147. }
  148. DEF_SIMPLE_GM(savelayer_clipmask, canvas, 1200, 1200) {
  149. static constexpr int kSize = 100;
  150. static constexpr SkRect kLayerBounds = { kSize * 0.25f, kSize * 0.25f,
  151. kSize * 0.75f, kSize * 0.75f };
  152. static constexpr struct {
  153. const SkRect* bounds;
  154. const SkScalar matrix[9];
  155. } kConfigs[] = {
  156. { nullptr, { 1 , 0 , 0, 0 , 1 , 0, 0, 0, 1 } },
  157. { nullptr, { 2 , 0 , 0, 0 , 2 , 0, 0, 0, 1 } },
  158. { nullptr, { 2 , 0 , -50, 0 , 2 , -50, 0, 0, 1 } },
  159. { nullptr, { 0.707f, -0.707f, 50, 0.707f, 0.707f, -20, 0, 0, 1 } },
  160. { nullptr, { 0.5f , 0 , 25, 0 , 0.5f , 25, 0, 0, 1 } },
  161. { &kLayerBounds, { 1 , 0 , 0, 0 , 1 , 0, 0, 0, 1 } },
  162. { &kLayerBounds, { 2 , 0 , 0, 0 , 2 , 0, 0, 0, 1 } },
  163. { &kLayerBounds, { 2 , 0 , -50, 0 , 2 , -50, 0, 0, 1 } },
  164. { &kLayerBounds, { 0.707f, -0.707f, 50, 0.707f, 0.707f, -20, 0, 0, 1 } },
  165. { &kLayerBounds, { 0.5f , 0 , 25, 0 , 0.5f , 25, 0, 0, 1 } },
  166. };
  167. using MaskMakerFunc = sk_sp<SkImage> (*)(int size);
  168. static const MaskMakerFunc kMaskMakers[] = {
  169. [](int size) -> sk_sp<SkImage> {
  170. auto surf = SkSurface::MakeRaster(SkImageInfo::MakeA8(size, size));
  171. draw_mask(surf->getCanvas(), size);
  172. return surf->makeImageSnapshot();
  173. },
  174. [](int size) -> sk_sp<SkImage> {
  175. auto surf = SkSurface::MakeRasterN32Premul(size, size);
  176. draw_mask(surf->getCanvas(), size);
  177. return surf->makeImageSnapshot();
  178. },
  179. [](int size) -> sk_sp<SkImage> {
  180. SkPictureRecorder recorder;
  181. draw_mask(recorder.beginRecording(size, size), size);
  182. return SkImage::MakeFromPicture(recorder.finishRecordingAsPicture(),
  183. SkISize::Make(size, size),
  184. nullptr, nullptr,
  185. SkImage::BitDepth::kU8,
  186. SkColorSpace::MakeSRGB());
  187. }
  188. };
  189. using PaintMakerFunc = SkPaint (*)();
  190. static const PaintMakerFunc kPaintMakers[] = {
  191. []() -> SkPaint { return SkPaint(); },
  192. []() -> SkPaint {
  193. SkPaint p; p.setImageFilter(SkBlurImageFilter::Make(2, 2, nullptr)); return p;
  194. },
  195. []() -> SkPaint { SkPaint p; p.setBlendMode(SkBlendMode::kSrcOut); return p; },
  196. };
  197. canvas->drawColor(0xffcccccc);
  198. SkMatrix clipMatrix;
  199. SkCanvas::SaveLayerRec rec;
  200. rec.fClipMatrix = &clipMatrix;
  201. for (const auto& paintMaker : kPaintMakers) {
  202. auto layerPaint = paintMaker();
  203. rec.fPaint = &layerPaint;
  204. for (const auto& maskMaker : kMaskMakers) {
  205. sk_sp<SkImage> mask = maskMaker(kSize);
  206. rec.fClipMask = mask.get();
  207. canvas->save();
  208. for (const auto cfg : kConfigs) {
  209. rec.fBounds = cfg.bounds;
  210. clipMatrix.set9(cfg.matrix);
  211. canvas->saveLayer(rec);
  212. SkPaint paint;
  213. paint.setColor(0xff0000ff);
  214. canvas->drawRect(SkRect::MakeWH(50, 50), paint);
  215. paint.setColor(0xffff0000);
  216. canvas->drawRect(SkRect::MakeXYWH(50, 0, 50, 50), paint);
  217. paint.setColor(0xff00ff00);
  218. canvas->drawRect(SkRect::MakeXYWH(50, 50, 50, 50), paint);
  219. paint.setColor(0xffffff00);
  220. canvas->drawRect(SkRect::MakeXYWH(0, 50, 50, 50), paint);
  221. canvas->restore();
  222. canvas->translate(120, 0);
  223. }
  224. canvas->restore();
  225. canvas->translate(0, 120);
  226. }
  227. }
  228. }
  229. DEF_SIMPLE_GM(savelayer_coverage, canvas, 500, 500) {
  230. canvas->saveLayer(nullptr, nullptr);
  231. SkRect r = { 0, 0, 200, 200 };
  232. SkPaint layerPaint;
  233. layerPaint.setBlendMode(SkBlendMode::kModulate);
  234. auto image = GetResourceAsImage("images/mandrill_128.png");
  235. auto proc = [layerPaint](SkCanvas* canvas, SkCanvas::SaveLayerRec& rec) {
  236. SkPaint paint;
  237. paint.setColor(SK_ColorRED);
  238. canvas->saveLayer(rec);
  239. canvas->drawCircle(100, 100, 50, paint);
  240. paint.setColor(0x8800FF00);
  241. canvas->drawRect({10, 90, 190, 110}, paint);
  242. canvas->restore();
  243. };
  244. const int yflags[] = { 0, SkCanvas::kInitWithPrevious_SaveLayerFlag };
  245. for (int y = 0; y <= 1; ++y) {
  246. const int xflags[] = { 0, SkCanvas::kMaskAgainstCoverage_EXPERIMENTAL_DONT_USE_SaveLayerFlag };
  247. for (int x = 0; x <= 1; ++x) {
  248. canvas->save();
  249. canvas->translate(x * 200.f, y * 200.f);
  250. SkCanvas::SaveLayerRec rec(&r, &layerPaint, yflags[y] | xflags[x]);
  251. canvas->drawImageRect(image, r, nullptr);
  252. proc(canvas, rec);
  253. canvas->restore();
  254. }
  255. }
  256. canvas->restore();
  257. }
  258. DEF_SIMPLE_GM(savelayer_clipmask_maskfilter, canvas, 500, 500) {
  259. // Offscreen surface for making the clip mask and mask filter images
  260. auto surf = SkSurface::MakeRaster(SkImageInfo::MakeA8(100, 100));
  261. SkPaint maskPaint;
  262. maskPaint.setColor(SK_ColorWHITE);
  263. maskPaint.setAntiAlias(true);
  264. // Draw a centered circle for the mask filter
  265. surf->getCanvas()->clear(SK_ColorTRANSPARENT);
  266. surf->getCanvas()->drawCircle(50.f, 50.f, 50.f, maskPaint);
  267. auto maskFilterImage = surf->makeImageSnapshot();
  268. sk_sp<SkMaskFilter> maskFilter = SkShaderMaskFilter::Make(maskFilterImage->makeShader());
  269. // Cut out a cross for the clip mask
  270. surf->getCanvas()->clear(SK_ColorTRANSPARENT);
  271. surf->getCanvas()->drawRect(SkRect::MakeLTRB(0.f, 0.f, 40.f, 40.f), maskPaint);
  272. surf->getCanvas()->drawRect(SkRect::MakeLTRB(60.f, 0.f, 100.f, 40.f), maskPaint);
  273. surf->getCanvas()->drawRect(SkRect::MakeLTRB(0.f, 60.f, 40.f, 100.f), maskPaint);
  274. surf->getCanvas()->drawRect(SkRect::MakeLTRB(60.f, 60.f, 100.f, 100.f), maskPaint);
  275. auto clipMaskImage = surf->makeImageSnapshot();
  276. SkMatrix clipMatrix = SkMatrix::I();
  277. SkRect clipBounds = SkRect::MakeWH(100, 100);
  278. // On the main canvas, save a 100x100 layer three times, applying clip mask, mask filter, or
  279. // both, translating across the GM for each configuration.
  280. canvas->clear(SK_ColorGRAY);
  281. canvas->translate(25.f, 0.f);
  282. // Clip mask only
  283. SkCanvas::SaveLayerRec rec;
  284. rec.fBounds = &clipBounds;
  285. rec.fClipMask = clipMaskImage.get();
  286. rec.fClipMatrix = &clipMatrix;
  287. canvas->saveLayer(rec);
  288. canvas->clear(SK_ColorWHITE);
  289. canvas->restore();
  290. canvas->translate(125.f, 0.f);
  291. // Mask filter only
  292. maskPaint.setMaskFilter(maskFilter);
  293. rec.fClipMask = nullptr;
  294. rec.fPaint = &maskPaint;
  295. canvas->saveLayer(rec);
  296. canvas->clear(SK_ColorWHITE);
  297. canvas->restore();
  298. canvas->translate(125.f, 0.f);
  299. // Both
  300. rec.fClipMask = clipMaskImage.get();
  301. canvas->saveLayer(rec);
  302. canvas->clear(SK_ColorWHITE);
  303. canvas->restore();
  304. }
  305. static void draw_cell(SkCanvas* canvas, sk_sp<SkTextBlob> blob, SkColor c, SkScalar w, SkScalar h,
  306. bool useDrawBehind) {
  307. SkRect r = SkRect::MakeWH(w, h);
  308. SkPaint p;
  309. p.setColor(c);
  310. p.setBlendMode(SkBlendMode::kSrc);
  311. canvas->drawRect(r, p);
  312. p.setBlendMode(SkBlendMode::kSrcOver);
  313. const SkScalar margin = 80;
  314. r.fLeft = w - margin;
  315. // save the behind image
  316. SkDEBUGCODE(int sc0 =) canvas->getSaveCount();
  317. SkDEBUGCODE(int sc1 =) SkCanvasPriv::SaveBehind(canvas, &r);
  318. SkDEBUGCODE(int sc2 =) canvas->getSaveCount();
  319. SkASSERT(sc0 == sc1);
  320. SkASSERT(sc0 + 1 == sc2);
  321. // draw the foreground (including over the 'behind' section)
  322. p.setColor(SK_ColorBLACK);
  323. canvas->drawTextBlob(blob, 10, 30, p);
  324. // draw the treatment
  325. const SkPoint pts[] = { {r.fLeft,0}, {r.fRight, 0} };
  326. const SkColor colors[] = { 0x88000000, 0x0 };
  327. auto sh = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
  328. p.setShader(sh);
  329. p.setBlendMode(SkBlendMode::kDstIn);
  330. if (useDrawBehind) {
  331. SkCanvasPriv::DrawBehind(canvas, p);
  332. } else {
  333. canvas->drawRect(r, p);
  334. }
  335. // this should restore the behind image
  336. canvas->restore();
  337. SkDEBUGCODE(int sc3 =) canvas->getSaveCount();
  338. SkASSERT(sc3 == sc0);
  339. // just outline where we expect the treatment to appear
  340. p.reset();
  341. p.setStyle(SkPaint::kStroke_Style);
  342. p.setAlphaf(0.25f);
  343. }
  344. static void draw_list(SkCanvas* canvas, sk_sp<SkTextBlob> blob, bool useDrawBehind) {
  345. SkAutoCanvasRestore acr(canvas, true);
  346. SkRandom rand;
  347. SkScalar w = 400;
  348. SkScalar h = 40;
  349. for (int i = 0; i < 8; ++i) {
  350. SkColor c = rand.nextU(); // ensure we're opaque
  351. c = (c & 0xFFFFFF) | 0x80000000;
  352. draw_cell(canvas, blob, c, w, h, useDrawBehind);
  353. canvas->translate(0, h);
  354. }
  355. }
  356. DEF_SIMPLE_GM(save_behind, canvas, 830, 670) {
  357. SkFont font;
  358. font.setTypeface(ToolUtils::create_portable_typeface());
  359. font.setSize(30);
  360. const char text[] = "This is a very long line of text";
  361. auto blob = SkTextBlob::MakeFromText(text, strlen(text), font);
  362. for (bool useDrawBehind : {false, true}) {
  363. canvas->save();
  364. draw_list(canvas, blob, useDrawBehind);
  365. canvas->translate(0, 350);
  366. canvas->saveLayer({0, 0, 400, 320}, nullptr);
  367. draw_list(canvas, blob, useDrawBehind);
  368. canvas->restore();
  369. canvas->restore();
  370. canvas->translate(430, 0);
  371. }
  372. }
  373. #include "include/effects/SkGradientShader.h"
  374. DEF_SIMPLE_GM(savelayer_f16, canvas, 900, 300) {
  375. int n = 15;
  376. SkRect r{0, 0, 300, 300};
  377. SkPaint paint;
  378. const SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorRED };
  379. paint.setShader(SkGradientShader::MakeSweep(r.centerX(), r.centerY(),
  380. colors, nullptr, SK_ARRAY_COUNT(colors)));
  381. canvas->drawOval(r, paint);
  382. paint.setAlphaf(1.0f/n);
  383. paint.setBlendMode(SkBlendMode::kPlus);
  384. for (auto flags : {0, (int)SkCanvas::kF16ColorType}) {
  385. canvas->translate(r.width(), 0);
  386. SkCanvas::SaveLayerRec rec;
  387. rec.fSaveLayerFlags = flags;
  388. canvas->saveLayer(rec);
  389. for (int i = 0; i < n; ++i) {
  390. canvas->drawOval(r, paint);
  391. }
  392. canvas->restore();
  393. }
  394. }