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