gm/multipicturedraw.cpp

   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.h"
   9 #include "sk_tool_utils.h"
  10
  11 #include "SkColorFilter.h"
  12 #include "SkMultiPictureDraw.h"
  13 #include "SkPath.h"
  14 #include "SkPictureRecorder.h"
  15 #include "SkSurface.h"
  16
  17 constexpr SkScalar kRoot3Over2 = 0.86602545f;  // sin(60)
  18 constexpr SkScalar kRoot3      = 1.73205081f;
  19
  20 constexpr int kHexSide = 30;
  21 constexpr int kNumHexX = 6;
  22 constexpr int kNumHexY = 6;
  23 constexpr int kPicWidth = kNumHexX * kHexSide;
  24 constexpr int kPicHeight = (int)((kNumHexY - 0.5f) * 2 * kHexSide * kRoot3Over2 + 0.5f);
  25 constexpr SkScalar kInset = 20.0f;
  26 constexpr int kNumPictures = 4;
  27
  28 constexpr int kTriSide = 40;
  29
  30 // Create a hexagon centered at (originX, originY)
  31 static SkPath make_hex_path(SkScalar originX, SkScalar originY) {
  32     SkPath hex;
  33     hex.moveTo(originX-kHexSide, originY);
  34     hex.rLineTo(SkScalarHalf(kHexSide), kRoot3Over2 * kHexSide);
  35     hex.rLineTo(SkIntToScalar(kHexSide), 0);
  36     hex.rLineTo(SkScalarHalf(kHexSide), -kHexSide * kRoot3Over2);
  37     hex.rLineTo(-SkScalarHalf(kHexSide), -kHexSide * kRoot3Over2);
  38     hex.rLineTo(-SkIntToScalar(kHexSide), 0);
  39     hex.close();
  40     return hex;
  41 }
  42
  43 // Make a picture that is a tiling of the plane with stroked hexagons where
  44 // each hexagon is in its own layer. The layers are to exercise Ganesh's
  45 // layer hoisting.
  46 static sk_sp<SkPicture> make_hex_plane_picture(SkColor fillColor) {
  47
  48     // Create a hexagon with its center at the origin
  49     SkPath hex = make_hex_path(0, 0);
  50
  51     SkPaint fill;
  52     fill.setStyle(SkPaint::kFill_Style);
  53     fill.setColor(fillColor);
  54
  55     SkPaint stroke;
  56     stroke.setStyle(SkPaint::kStroke_Style);
  57     stroke.setStrokeWidth(3);
  58
  59     SkPictureRecorder recorder;
  60     SkRTreeFactory bbhFactory;
  61
  62     SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(kPicWidth),
  63                                                SkIntToScalar(kPicHeight),
  64                                                &bbhFactory);
  65
  66     SkScalar xPos, yPos = 0;
  67
  68     for (int y = 0; y < kNumHexY; ++y) {
  69         xPos = 0;
  70
  71         for (int x = 0; x < kNumHexX; ++x) {
  72             canvas->saveLayer(nullptr, nullptr);
  73             canvas->translate(xPos, yPos + ((x % 2) ? kRoot3Over2 * kHexSide : 0));
  74             canvas->drawPath(hex, fill);
  75             canvas->drawPath(hex, stroke);
  76             canvas->restore();
  77
  78             xPos += 1.5f * kHexSide;
  79         }
  80
  81         yPos += 2 * kHexSide * kRoot3Over2;
  82     }
  83
  84     return recorder.finishRecordingAsPicture();
  85 }
  86
  87 // Create a picture that consists of a single large layer that is tiled
  88 // with hexagons.
  89 // This is intended to exercise the layer hoisting code's clip handling (in
  90 // tile mode).
  91 static sk_sp<SkPicture> make_single_layer_hex_plane_picture() {
  92
  93     // Create a hexagon with its center at the origin
  94     SkPath hex = make_hex_path(0, 0);
  95
  96     SkPaint whiteFill;
  97     whiteFill.setStyle(SkPaint::kFill_Style);
  98     whiteFill.setColor(SK_ColorWHITE);
  99
 100     SkPaint greyFill;
 101     greyFill.setStyle(SkPaint::kFill_Style);
 102     greyFill.setColor(sk_tool_utils::color_to_565(SK_ColorLTGRAY));
 103
 104     SkPaint stroke;
 105     stroke.setStyle(SkPaint::kStroke_Style);
 106     stroke.setStrokeWidth(3);
 107
 108     SkPictureRecorder recorder;
 109     SkRTreeFactory bbhFactory;
 110
 111     constexpr SkScalar kBig = 10000.0f;
 112     SkCanvas* canvas = recorder.beginRecording(kBig, kBig, &bbhFactory);
 113
 114     canvas->saveLayer(nullptr, nullptr);
 115
 116     SkScalar xPos = 0.0f, yPos = 0.0f;
 117
 118     for (int y = 0; yPos < kBig; ++y) {
 119         xPos = 0;
 120
 121         for (int x = 0; xPos < kBig; ++x) {
 122             canvas->save();
 123             canvas->translate(xPos, yPos + ((x % 2) ? kRoot3Over2 * kHexSide : 0));
 124             // The color of the filled hex is swapped to yield a different
 125             // pattern in each tile. This allows an error in layer hoisting (e.g.,
 126             // the clip isn't blocking cache reuse) to cause a visual discrepancy.
 127             canvas->drawPath(hex, ((x+y) % 3) ? whiteFill : greyFill);
 128             canvas->drawPath(hex, stroke);
 129             canvas->restore();
 130
 131             xPos += 1.5f * kHexSide;
 132         }
 133
 134         yPos += 2 * kHexSide * kRoot3Over2;
 135     }
 136
 137     canvas->restore();
 138
 139     return recorder.finishRecordingAsPicture();
 140 }
 141
 142 // Make an equilateral triangle path with its top corner at (originX, originY)
 143 static SkPath make_tri_path(SkScalar originX, SkScalar originY) {
 144     SkPath tri;
 145     tri.moveTo(originX, originY);
 146     tri.rLineTo(SkScalarHalf(kTriSide), 1.5f * kTriSide / kRoot3);
 147     tri.rLineTo(-kTriSide, 0);
 148     tri.close();
 149     return tri;
 150 }
 151
 152 static sk_sp<SkPicture> make_tri_picture() {
 153     SkPath tri = make_tri_path(SkScalarHalf(kTriSide), 0);
 154
 155     SkPaint fill;
 156     fill.setStyle(SkPaint::kFill_Style);
 157     fill.setColor(sk_tool_utils::color_to_565(SK_ColorLTGRAY));
 158
 159     SkPaint stroke;
 160     stroke.setStyle(SkPaint::kStroke_Style);
 161     stroke.setStrokeWidth(3);
 162
 163     SkPictureRecorder recorder;
 164     SkRTreeFactory bbhFactory;
 165
 166     SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(kPicWidth),
 167                                                SkIntToScalar(kPicHeight),
 168                                                &bbhFactory);
 169     SkRect r = tri.getBounds();
 170     r.outset(2.0f, 2.0f);       // outset for stroke
 171     canvas->clipRect(r);
 172     // The saveLayer/restore block is to exercise layer hoisting
 173     canvas->saveLayer(nullptr, nullptr);
 174         canvas->drawPath(tri, fill);
 175         canvas->drawPath(tri, stroke);
 176     canvas->restore();
 177
 178     return recorder.finishRecordingAsPicture();
 179 }
 180
 181 static sk_sp<SkPicture> make_sub_picture(const SkPicture* tri) {
 182     SkPictureRecorder recorder;
 183     SkRTreeFactory bbhFactory;
 184
 185     SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(kPicWidth),
 186                                                SkIntToScalar(kPicHeight),
 187                                                &bbhFactory);
 188
 189     canvas->scale(1.0f/2.0f, 1.0f/2.0f);
 190
 191     canvas->save();
 192     canvas->translate(SkScalarHalf(kTriSide), 0);
 193     canvas->drawPicture(tri);
 194     canvas->restore();
 195
 196     canvas->save();
 197     canvas->translate(SkIntToScalar(kTriSide), 1.5f * kTriSide / kRoot3);
 198     canvas->drawPicture(tri);
 199     canvas->restore();
 200
 201     canvas->save();
 202     canvas->translate(0, 1.5f * kTriSide / kRoot3);
 203     canvas->drawPicture(tri);
 204     canvas->restore();
 205
 206     return recorder.finishRecordingAsPicture();
 207 }
 208
 209 // Create a Sierpinkski-like picture that starts with a top row with a picture
 210 // that just contains a triangle. Subsequent rows take the prior row's picture,
 211 // shrinks it and replicates it 3 times then draws and appropriate number of
 212 // copies of it.
 213 static sk_sp<SkPicture> make_sierpinski_picture() {
 214     sk_sp<SkPicture> pic(make_tri_picture());
 215
 216     SkPictureRecorder recorder;
 217     SkRTreeFactory bbhFactory;
 218
 219     SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(kPicWidth),
 220                                                SkIntToScalar(kPicHeight),
 221                                                &bbhFactory);
 222
 223     constexpr int kNumLevels = 4;
 224     for (int i = 0; i < kNumLevels; ++i) {
 225         canvas->save();
 226             canvas->translate(kPicWidth/2 - (i+1) * (kTriSide/2.0f), 0.0f);
 227             for (int j = 0; j < i+1; ++j) {
 228                 canvas->drawPicture(pic);
 229                 canvas->translate(SkIntToScalar(kTriSide), 0);
 230             }
 231         canvas->restore();
 232
 233         pic = make_sub_picture(pic.get());
 234
 235         canvas->translate(0, 1.5f * kTriSide / kRoot3);
 236     }
 237
 238     return recorder.finishRecordingAsPicture();
 239 }
 240
 241 static sk_sp<SkSurface> create_compat_surface(SkCanvas* canvas, int width, int height) {
 242     SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
 243
 244     auto surface = canvas->makeSurface(info);
 245     if (nullptr == surface) {
 246         // picture canvas returns nullptr so fall back to raster
 247         surface = SkSurface::MakeRaster(info);
 248     }
 249     return surface;
 250 }
 251
 252 // This class stores the information required to compose all the result
 253 // fragments potentially generated by the MultiPictureDraw object
 254 class ComposeStep {
 255 public:
 256     ComposeStep() : fX(0.0f), fY(0.0f), fPaint(nullptr) { }
 257     ~ComposeStep() {
 258         delete fPaint;
 259     }
 260
 261     sk_sp<SkSurface> fSurf;
 262     SkScalar   fX;
 263     SkScalar   fY;
 264     SkPaint*   fPaint;
 265 };
 266
 267 typedef void (*PFContentMtd)(SkCanvas* canvas, const SkPicture* pictures[kNumPictures]);
 268
 269 // Just a single picture with no clip
 270 static void no_clip(SkCanvas* canvas, const SkPicture* pictures[kNumPictures]) {
 271     canvas->drawPicture(pictures[0]);
 272 }
 273
 274 // Two pictures with a rect clip on the second one
 275 static void rect_clip(SkCanvas* canvas, const SkPicture* pictures[kNumPictures]) {
 276     canvas->drawPicture(pictures[0]);
 277
 278     SkRect rect = pictures[0]->cullRect();
 279     rect.inset(kInset, kInset);
 280
 281     canvas->clipRect(rect);
 282
 283     canvas->drawPicture(pictures[1]);
 284 }
 285
 286 // Two pictures with a round rect clip on the second one
 287 static void rrect_clip(SkCanvas* canvas, const SkPicture* pictures[kNumPictures]) {
 288     canvas->drawPicture(pictures[0]);
 289
 290     SkRect rect = pictures[0]->cullRect();
 291     rect.inset(kInset, kInset);
 292
 293     SkRRect rrect;
 294     rrect.setRectXY(rect, kInset, kInset);
 295
 296     canvas->clipRRect(rrect);
 297
 298     canvas->drawPicture(pictures[1]);
 299 }
 300
 301 // Two pictures with a clip path on the second one
 302 static void path_clip(SkCanvas* canvas, const SkPicture* pictures[kNumPictures]) {
 303     canvas->drawPicture(pictures[0]);
 304
 305     // Create a hexagon centered on the middle of the hex grid
 306     SkPath hex = make_hex_path((kNumHexX / 2.0f) * kHexSide, kNumHexY * kHexSide * kRoot3Over2);
 307
 308     canvas->clipPath(hex);
 309
 310     canvas->drawPicture(pictures[1]);
 311 }
 312
 313 // Two pictures with an inverse clip path on the second one
 314 static void invpath_clip(SkCanvas* canvas, const SkPicture* pictures[kNumPictures]) {
 315     canvas->drawPicture(pictures[0]);
 316
 317     // Create a hexagon centered on the middle of the hex grid
 318     SkPath hex = make_hex_path((kNumHexX / 2.0f) * kHexSide, kNumHexY * kHexSide * kRoot3Over2);
 319     hex.setFillType(SkPath::kInverseEvenOdd_FillType);
 320
 321     canvas->clipPath(hex);
 322
 323     canvas->drawPicture(pictures[1]);
 324 }
 325
 326 // Reuse a single base (triangular) picture a _lot_ (rotated, scaled and translated).
 327 static void sierpinski(SkCanvas* canvas, const SkPicture* pictures[kNumPictures]) {
 328     canvas->save();
 329         canvas->drawPicture(pictures[2]);
 330
 331         canvas->rotate(180.0f);
 332         canvas->translate(-SkIntToScalar(kPicWidth), -SkIntToScalar(kPicHeight));
 333         canvas->drawPicture(pictures[2]);
 334     canvas->restore();
 335 }
 336
 337 static void big_layer(SkCanvas* canvas, const SkPicture* pictures[kNumPictures]) {
 338     canvas->drawPicture(pictures[3]);
 339 }
 340
 341 constexpr PFContentMtd gContentMthds[] = {
 342     no_clip,
 343     rect_clip,
 344     rrect_clip,
 345     path_clip,
 346     invpath_clip,
 347     sierpinski,
 348     big_layer,
 349 };
 350
 351 static void create_content(SkMultiPictureDraw* mpd, PFContentMtd pfGen,
 352                            const SkPicture* pictures[kNumPictures],
 353                            SkCanvas* dest, const SkMatrix& xform) {
 354     sk_sp<SkPicture> composite;
 355
 356     {
 357         SkPictureRecorder recorder;
 358         SkRTreeFactory bbhFactory;
 359
 360         SkCanvas* pictureCanvas = recorder.beginRecording(SkIntToScalar(kPicWidth),
 361                                                           SkIntToScalar(kPicHeight),
 362                                                           &bbhFactory);
 363
 364         (*pfGen)(pictureCanvas, pictures);
 365
 366         composite = recorder.finishRecordingAsPicture();
 367     }
 368
 369     mpd->add(dest, composite.get(), &xform);
 370 }
 371
 372 typedef void(*PFLayoutMtd)(SkCanvas* finalCanvas, SkMultiPictureDraw* mpd,
 373                            PFContentMtd pfGen, const SkPicture* pictures[kNumPictures],
 374                            SkTArray<ComposeStep>* composeSteps);
 375
 376 // Draw the content into a single canvas
 377 static void simple(SkCanvas* finalCanvas, SkMultiPictureDraw* mpd,
 378                    PFContentMtd pfGen,
 379                    const SkPicture* pictures[kNumPictures],
 380                    SkTArray<ComposeStep> *composeSteps) {
 381
 382     ComposeStep& step = composeSteps->push_back();
 383
 384     step.fSurf = create_compat_surface(finalCanvas, kPicWidth, kPicHeight);
 385
 386     SkCanvas* subCanvas = step.fSurf->getCanvas();
 387
 388     create_content(mpd, pfGen, pictures, subCanvas, SkMatrix::I());
 389 }
 390
 391 // Draw the content into multiple canvases/tiles
 392 static void tiled(SkCanvas* finalCanvas, SkMultiPictureDraw* mpd,
 393                   PFContentMtd pfGen,
 394                   const SkPicture* pictures[kNumPictures],
 395                   SkTArray<ComposeStep> *composeSteps) {
 396     const int kNumTilesX = 2;
 397     const int kNumTilesY = 2;
 398     const int kTileWidth = kPicWidth / kNumTilesX;
 399     const int kTileHeight = kPicHeight / kNumTilesY;
 400
 401     SkASSERT(kPicWidth == kNumTilesX * kTileWidth);
 402     SkASSERT(kPicHeight == kNumTilesY * kTileHeight);
 403
 404     const SkColor colors[kNumTilesX][kNumTilesY] = {
 405         { SK_ColorCYAN,   SK_ColorMAGENTA },
 406         { SK_ColorYELLOW, SK_ColorGREEN   }
 407     };
 408
 409     for (int y = 0; y < kNumTilesY; ++y) {
 410         for (int x = 0; x < kNumTilesX; ++x) {
 411             ComposeStep& step = composeSteps->push_back();
 412
 413             step.fX = SkIntToScalar(x*kTileWidth);
 414             step.fY = SkIntToScalar(y*kTileHeight);
 415             step.fPaint = new SkPaint;
 416             step.fPaint->setColorFilter(
 417                 SkColorFilter::MakeModeFilter(colors[x][y], SkBlendMode::kModulate));
 418
 419             step.fSurf = create_compat_surface(finalCanvas, kTileWidth, kTileHeight);
 420
 421             SkCanvas* subCanvas = step.fSurf->getCanvas();
 422
 423             const SkMatrix trans = SkMatrix::MakeTrans(-SkIntToScalar(x*kTileWidth),
 424                                                        -SkIntToScalar(y*kTileHeight));
 425
 426             create_content(mpd, pfGen, pictures, subCanvas, trans);
 427         }
 428     }
 429 }
 430
 431 constexpr PFLayoutMtd gLayoutMthds[] = { simple, tiled };
 432
 433 namespace skiagm {
 434     /**
 435      * This GM exercises the SkMultiPictureDraw object. It tests the
 436      * cross product of:
 437      *      tiled vs. all-at-once rendering (e.g., into many or just 1 canvas)
 438      *      different clips (e.g., none, rect, rrect)
 439      *      single vs. multiple pictures (e.g., normal vs. picture-pile-style content)
 440      */
 441     class MultiPictureDraw : public GM {
 442     public:
 443         enum Content {
 444             kNoClipSingle_Content,
 445             kRectClipMulti_Content,
 446             kRRectClipMulti_Content,
 447             kPathClipMulti_Content,
 448             kInvPathClipMulti_Content,
 449             kSierpinski_Content,
 450             kBigLayer_Content,
 451
 452             kLast_Content = kBigLayer_Content
 453         };
 454
 455         const int kContentCnt = kLast_Content + 1;
 456
 457         enum Layout {
 458             kSimple_Layout,
 459             kTiled_Layout,
 460
 461             kLast_Layout = kTiled_Layout
 462         };
 463
 464         const int kLayoutCnt = kLast_Layout + 1;
 465
 466         MultiPictureDraw(Content content, Layout layout) : fContent(content), fLayout(layout) {
 467             SkASSERT(SK_ARRAY_COUNT(gLayoutMthds) == kLayoutCnt);
 468             SkASSERT(SK_ARRAY_COUNT(gContentMthds) == kContentCnt);
 469
 470             for (int i = 0; i < kNumPictures; ++i) {
 471                 fPictures[i] = nullptr;
 472             }
 473         }
 474
 475         ~MultiPictureDraw() override {
 476             for (int i = 0; i < kNumPictures; ++i) {
 477                 SkSafeUnref(fPictures[i]);
 478             }
 479         }
 480
 481     protected:
 482         Content          fContent;
 483         Layout           fLayout;
 484         const SkPicture* fPictures[kNumPictures];
 485
 486         void onOnceBeforeDraw() override {
 487             fPictures[0] = make_hex_plane_picture(SK_ColorWHITE).release();
 488             fPictures[1] = make_hex_plane_picture(sk_tool_utils::color_to_565(SK_ColorGRAY)).release();
 489             fPictures[2] = make_sierpinski_picture().release();
 490             fPictures[3] = make_single_layer_hex_plane_picture().release();
 491         }
 492
 493         void onDraw(SkCanvas* canvas) override {
 494             SkMultiPictureDraw mpd;
 495             SkTArray<ComposeStep> composeSteps;
 496
 497             // Fill up the MultiPictureDraw
 498             (*gLayoutMthds[fLayout])(canvas, &mpd,
 499                                      gContentMthds[fContent],
 500                                      fPictures, &composeSteps);
 501
 502             mpd.draw();
 503
 504             // Compose all the drawn canvases into the final canvas
 505             for (int i = 0; i < composeSteps.count(); ++i) {
 506                 const ComposeStep& step = composeSteps[i];
 507
 508                 canvas->drawImage(step.fSurf->makeImageSnapshot().get(),
 509                                   step.fX, step.fY, step.fPaint);
 510             }
 511         }
 512
 513         SkISize onISize() override { return SkISize::Make(kPicWidth, kPicHeight); }
 514
 515         SkString onShortName() override {
 516             const char* gContentNames[] = {
 517                 "noclip", "rectclip", "rrectclip", "pathclip",
 518                 "invpathclip", "sierpinski", "biglayer"
 519             };
 520             const char* gLayoutNames[] = { "simple", "tiled" };
 521
 522             SkASSERT(SK_ARRAY_COUNT(gLayoutNames) == kLayoutCnt);
 523             SkASSERT(SK_ARRAY_COUNT(gContentNames) == kContentCnt);
 524
 525             SkString name("multipicturedraw_");
 526
 527             name.append(gContentNames[fContent]);
 528             name.append("_");
 529             name.append(gLayoutNames[fLayout]);
 530             return name;
 531         }
 532
 533         bool runAsBench() const override { return true; }
 534
 535     private:
 536         typedef GM INHERITED;
 537     };
 538
 539     DEF_GM(return new MultiPictureDraw(MultiPictureDraw::kNoClipSingle_Content,
 540                                        MultiPictureDraw::kSimple_Layout);)
 541     DEF_GM(return new MultiPictureDraw(MultiPictureDraw::kRectClipMulti_Content,
 542                                        MultiPictureDraw::kSimple_Layout);)
 543     DEF_GM(return new MultiPictureDraw(MultiPictureDraw::kRRectClipMulti_Content,
 544                                        MultiPictureDraw::kSimple_Layout);)
 545     DEF_GM(return new MultiPictureDraw(MultiPictureDraw::kPathClipMulti_Content,
 546                                        MultiPictureDraw::kSimple_Layout);)
 547     DEF_GM(return new MultiPictureDraw(MultiPictureDraw::kInvPathClipMulti_Content,
 548                                        MultiPictureDraw::kSimple_Layout);)
 549     DEF_GM(return new MultiPictureDraw(MultiPictureDraw::kSierpinski_Content,
 550                                        MultiPictureDraw::kSimple_Layout);)
 551     DEF_GM(return new MultiPictureDraw(MultiPictureDraw::kBigLayer_Content,
 552                                        MultiPictureDraw::kSimple_Layout);)
 553
 554     DEF_GM(return new MultiPictureDraw(MultiPictureDraw::kNoClipSingle_Content,
 555                                        MultiPictureDraw::kTiled_Layout);)
 556     DEF_GM(return new MultiPictureDraw(MultiPictureDraw::kRectClipMulti_Content,
 557                                        MultiPictureDraw::kTiled_Layout);)
 558     DEF_GM(return new MultiPictureDraw(MultiPictureDraw::kRRectClipMulti_Content,
 559                                        MultiPictureDraw::kTiled_Layout);)
 560     DEF_GM(return new MultiPictureDraw(MultiPictureDraw::kPathClipMulti_Content,
 561                                        MultiPictureDraw::kTiled_Layout);)
 562     DEF_GM(return new MultiPictureDraw(MultiPictureDraw::kInvPathClipMulti_Content,
 563                                        MultiPictureDraw::kTiled_Layout);)
 564     DEF_GM(return new MultiPictureDraw(MultiPictureDraw::kSierpinski_Content,
 565                                        MultiPictureDraw::kTiled_Layout);)
 566     DEF_GM(return new MultiPictureDraw(MultiPictureDraw::kBigLayer_Content,
 567                                        MultiPictureDraw::kTiled_Layout);)
 568 }