Add a MultiPictureDraw GM to exercise layer clipping

gm/multipicturedraw.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gm.h"
 
 #include "SkColorFilter.h"
 #include "SkMultiPictureDraw.h"
 #include "SkPictureRecorder.h"
 #include "SkSurface.h"
 
 static const SkScalar kRoot3Over2 = 0.86602545f;  // sin(60)
 static const SkScalar kRoot3      = 1.73205081f;
 
 static const int kHexSide = 30;
 static const int kNumHexX = 6;
 static const int kNumHexY = 6;
 static const int kPicWidth = kNumHexX * kHexSide;
 static const int kPicHeight = SkScalarCeilToInt((kNumHexY - 0.5f) * 2 * kHexSide * kRoot3Over2);
 static const SkScalar kInset = 20.0f;
-static const int kNumPictures = 3;
+static const int kNumPictures = 4;
 
 static const int kTriSide = 40;
 
 // Create a hexagon centered at (originX, originY)
 static SkPath make_hex_path(SkScalar originX, SkScalar originY) {
     SkPath hex;
     hex.moveTo(originX-kHexSide, originY);
     hex.rLineTo(SkScalarHalf(kHexSide), kRoot3Over2 * kHexSide);
     hex.rLineTo(SkIntToScalar(kHexSide), 0);
     hex.rLineTo(SkScalarHalf(kHexSide), -kHexSide * kRoot3Over2);
@@ skipping 38 matching lines @@
 
             xPos += 1.5f * kHexSide;
         }
 
         yPos += 2 * kHexSide * kRoot3Over2;
     }
 
     return recorder.endRecording();
 }
 
+// Create a picture that consists of a single large layer that is tiled
+// with hexagons.
+// This is intended to exercise the layer hoisting code's clip handling (in
+// tile mode).
+static const SkPicture* make_single_layer_hex_plane_picture() {
+
+    // Create a hexagon with its center at the origin
+    SkPath hex = make_hex_path(0, 0);
+
+    SkPaint whiteFill;
+    whiteFill.setStyle(SkPaint::kFill_Style);
+    whiteFill.setColor(SK_ColorWHITE);
+
+    SkPaint greyFill;
+    greyFill.setStyle(SkPaint::kFill_Style);
+    greyFill.setColor(SK_ColorLTGRAY);
+
+    SkPaint stroke;
+    stroke.setStyle(SkPaint::kStroke_Style);
+    stroke.setStrokeWidth(3);
+
+    SkPictureRecorder recorder;
+
+    static const SkScalar kBig = 10000.0f;
+    SkCanvas* canvas = recorder.beginRecording(kBig, kBig);
+
+    SkScalar xPos = 0.0f, yPos = 0.0f;
+
+    for (int y = 0; yPos < kBig; ++y) {
+        xPos = 0;
+
+        for (int x = 0; xPos < kBig; ++x) {
+            canvas->save();
+            canvas->translate(xPos, yPos + ((x % 2) ? kRoot3Over2 * kHexSide : 0));
+            // The color of the filled hex is swapped to yield a different
+            // pattern in each tile. This allows an error in layer hoisting (e.g.,
+            // the clip isn't blocking cache reuse) to cause a visual discrepancy.
+            canvas->drawPath(hex, ((x+y) % 3) ? whiteFill : greyFill);
+            canvas->drawPath(hex, stroke);
+            canvas->restore();
+
+            xPos += 1.5f * kHexSide;
+        }
+
+        yPos += 2 * kHexSide * kRoot3Over2;
+    }
+
+    return recorder.endRecording();
+

[egdaniel, 2014/10/02 13:03:34]

extra \n

+}
+
 // Make an equilateral triangle path with its top corner at (originX, originY)
 static SkPath make_tri_path(SkScalar originX, SkScalar originY) {
     SkPath tri;
     tri.moveTo(originX, originY);
     tri.rLineTo(SkScalarHalf(kTriSide), 1.5f * kTriSide / kRoot3);
     tri.rLineTo(-kTriSide, 0);
     tri.close();
     return tri;
 }
 
@@ skipping 165 matching lines @@
 static void sierpinski(SkCanvas* canvas, const SkPicture* pictures[kNumPictures]) {
     canvas->save();
         canvas->drawPicture(pictures[2]);
 
         canvas->rotate(180.0f);
         canvas->translate(-SkIntToScalar(kPicWidth), -SkIntToScalar(kPicHeight));
         canvas->drawPicture(pictures[2]);
     canvas->restore();
 }
 
+static void big_layer(SkCanvas* canvas, const SkPicture* pictures[kNumPictures]) {
+    canvas->drawPicture(pictures[3]);
+}
+
 static const PFContentMtd gContentMthds[] = {
     no_clip,
     rect_clip,
     rrect_clip,
     path_clip,
     invpath_clip,
-    sierpinski
+    sierpinski,
+    big_layer,
 };
 
 static void create_content(SkMultiPictureDraw* mpd, PFContentMtd pfGen,
                            const SkPicture* pictures[kNumPictures],
                            SkCanvas* dest, const SkMatrix& xform) {
     SkAutoTUnref<SkPicture> composite;
 
     {
         SkPictureRecorder recorder;
 
@@ skipping 79 matching lines @@
      */
     class MultiPictureDraw : public GM {
     public:
         enum Content {
             kNoClipSingle_Content,
             kRectClipMulti_Content,
             kRRectClipMulti_Content,
             kPathClipMulti_Content,
             kInvPathClipMulti_Content,
             kSierpinski_Content,
+            kBigLayer_Content,
 
-            kLast_Content = kSierpinski_Content
+            kLast_Content = kBigLayer_Content
         };
 
         static const int kContentCnt = kLast_Content + 1;
 
         enum Layout {
             kSimple_Layout,
             kTiled_Layout,
 
             kLast_Layout = kTiled_Layout
         };
@@ skipping 17 matching lines @@
 
     protected:
         Content          fContent;
         Layout           fLayout;
         const SkPicture* fPictures[kNumPictures];
 
         virtual void onOnceBeforeDraw() SK_OVERRIDE {
             fPictures[0] = make_hex_plane_picture(SK_ColorWHITE);
             fPictures[1] = make_hex_plane_picture(SK_ColorGRAY);
             fPictures[2] = make_sierpinski_picture();
+            fPictures[3] = make_single_layer_hex_plane_picture();
         }
 
         virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
             SkMultiPictureDraw mpd;
             SkTArray<ComposeStep> composeSteps;
 
             // Fill up the MultiPictureDraw
             (*gLayoutMthds[fLayout])(canvas, &mpd,
                                      gContentMthds[fContent],
                                      fPictures, &composeSteps);
 
             mpd.draw();
 
             // Compose all the drawn canvases into the final canvas
             for (int i = 0; i < composeSteps.count(); ++i) {
                 const ComposeStep& step = composeSteps[i];
 
                 SkAutoTUnref<SkImage> image(step.fSurf->newImageSnapshot());
 
                 canvas->drawImage(image, step.fX, step.fY, step.fPaint);
             }
         }
 
         virtual SkISize onISize() SK_OVERRIDE { return SkISize::Make(kPicWidth, kPicHeight); }
 
         virtual SkString onShortName() SK_OVERRIDE {
             static const char* gContentNames[] = {
-                "noclip", "rectclip", "rrectclip", "pathclip", "invpathclip", "sierpinski"
+                "noclip", "rectclip", "rrectclip", "pathclip", 
+                "invpathclip", "sierpinski", "biglayer"
             };
             static const char* gLayoutNames[] = { "simple", "tiled" };
 
             SkASSERT(SK_ARRAY_COUNT(gLayoutNames) == kLayoutCnt);
             SkASSERT(SK_ARRAY_COUNT(gContentNames) == kContentCnt);
 
             SkString name("multipicturedraw_");
 
             name.append(gContentNames[fContent]);
             name.append("_");
@@ skipping 12 matching lines @@
     DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kRectClipMulti_Content,
                                                 MultiPictureDraw::kSimple_Layout));)
     DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kRRectClipMulti_Content,
                                                 MultiPictureDraw::kSimple_Layout));)
     DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kPathClipMulti_Content,
                                                 MultiPictureDraw::kSimple_Layout));)
     DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kInvPathClipMulti_Content,
                                                 MultiPictureDraw::kSimple_Layout));)
     DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kSierpinski_Content,
                                                 MultiPictureDraw::kSimple_Layout));)
+    DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kBigLayer_Content,
+                                                MultiPictureDraw::kSimple_Layout));)
 
     DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kNoClipSingle_Content,
                                                 MultiPictureDraw::kTiled_Layout));)
     DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kRectClipMulti_Content,
                                                 MultiPictureDraw::kTiled_Layout));)
     DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kRRectClipMulti_Content,
                                                 MultiPictureDraw::kTiled_Layout));)
     DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kPathClipMulti_Content,
                                                 MultiPictureDraw::kTiled_Layout));)
     DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kInvPathClipMulti_Content,
                                                 MultiPictureDraw::kTiled_Layout));)
     DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kSierpinski_Content,
                                                 MultiPictureDraw::kTiled_Layout));)
+    DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kBigLayer_Content,
+                                                MultiPictureDraw::kTiled_Layout));)
 }