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