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 = 3;
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// Make an equilateral triangle path with its top corner at (originX, originY)
84static 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
93static 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
117static 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.
144static 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
170static 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
184class ComposeStep {
185public:
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
195typedef void (*PFContentMtd)(SkCanvas* canvas, const SkPicture* pictures[kNumPictures]);
196
197// Just a single picture with no clip
198static 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
203static 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
215static 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
230static 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
242static 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).
255static 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
266static const PFContentMtd gContentMthds[] = {
267    no_clip,
268    rect_clip,
269    rrect_clip,
270    path_clip,
271    invpath_clip,
272    sierpinski
273};
274
275static 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
294typedef 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
299static 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
314static 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
353static const PFLayoutMtd gLayoutMthds[] = { simple, tiled };
354
355namespace 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}
485