gm/windowrectangles.cpp

   1 /*
   2  * Copyright 2016 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 #include "SkClipStack.h"
  11 #include "SkRRect.h"
  12
  13 #if SK_SUPPORT_GPU
  14 #  include "GrAppliedClip.h"
  15 #  include "GrRenderTargetContext.h"
  16 #  include "GrRenderTargetContextPriv.h"
  17 #  include "GrFixedClip.h"
  18 #  include "GrReducedClip.h"
  19 #  include "GrRenderTargetPriv.h"
  20 #  include "GrResourceProvider.h"
  21 #  include "effects/GrTextureDomain.h"
  22 #endif
  23
  24 constexpr static SkIRect kDeviceRect = {0, 0, 600, 600};
  25 constexpr static SkIRect kCoverRect = {50, 50, 550, 550};
  26
  27 namespace skiagm {
  28
  29 ////////////////////////////////////////////////////////////////////////////////////////////////////
  30
  31 class WindowRectanglesBaseGM : public GM {
  32 protected:
  33     virtual void onCoverClipStack(const SkClipStack&, SkCanvas*) = 0;
  34
  35 private:
  36     SkISize onISize() override { return SkISize::Make(kDeviceRect.width(), kDeviceRect.height()); }
  37     void onDraw(SkCanvas*) final;
  38 };
  39
  40 void WindowRectanglesBaseGM::onDraw(SkCanvas* canvas) {
  41     sk_tool_utils::draw_checkerboard(canvas, 0xffffffff, 0xffc6c3c6, 25);
  42
  43     SkClipStack stack;
  44     stack.clipRect(SkRect::MakeXYWH(370.75, 80.25, 149, 100), SkMatrix::I(),
  45                    kDifference_SkClipOp, false);
  46     stack.clipRect(SkRect::MakeXYWH(80.25, 420.75, 150, 100), SkMatrix::I(),
  47                    kDifference_SkClipOp, true);
  48     stack.clipRRect(SkRRect::MakeRectXY(SkRect::MakeXYWH(200, 200, 200, 200), 60, 45),
  49                     SkMatrix::I(), kDifference_SkClipOp, true);
  50
  51     SkRRect nine;
  52     nine.setNinePatch(SkRect::MakeXYWH(550 - 30.25 - 100, 370.75, 100, 150), 12, 35, 23, 20);
  53     stack.clipRRect(nine, SkMatrix::I(), kDifference_SkClipOp, true);
  54
  55     SkRRect complx;
  56     SkVector complxRadii[4] = {{6, 4}, {8, 12}, {16, 24}, {48, 32}};
  57     complx.setRectRadii(SkRect::MakeXYWH(80.25, 80.75, 100, 149), complxRadii);
  58     stack.clipRRect(complx, SkMatrix::I(), kDifference_SkClipOp, false);
  59
  60     this->onCoverClipStack(stack, canvas);
  61 }
  62
  63 ////////////////////////////////////////////////////////////////////////////////////////////////////
  64
  65 /**
  66  * Draws a clip that will exercise window rectangles if they are supported.
  67  */
  68 class WindowRectanglesGM : public WindowRectanglesBaseGM {
  69 private:
  70     SkString onShortName() final { return SkString("windowrectangles"); }
  71     void onCoverClipStack(const SkClipStack&, SkCanvas*) final;
  72 };
  73
  74 void WindowRectanglesGM::onCoverClipStack(const SkClipStack& stack, SkCanvas* canvas) {
  75     SkPaint paint;
  76     paint.setColor(0xff00aa80);
  77
  78     // Set up the canvas's clip to match our SkClipStack.
  79     SkClipStack::Iter iter(stack, SkClipStack::Iter::kBottom_IterStart);
  80     for (const SkClipStack::Element* element = iter.next(); element; element = iter.next()) {
  81         SkClipOp op = element->getOp();
  82         bool isAA = element->isAA();
  83         switch (element->getType()) {
  84             case SkClipStack::Element::kPath_Type:
  85                 canvas->clipPath(element->getPath(), op, isAA);
  86                 break;
  87             case SkClipStack::Element::kRRect_Type:
  88                 canvas->clipRRect(element->getRRect(), op, isAA);
  89                 break;
  90             case SkClipStack::Element::kRect_Type:
  91                 canvas->clipRect(element->getRect(), op, isAA);
  92                 break;
  93             case SkClipStack::Element::kEmpty_Type:
  94                 canvas->clipRect({ 0, 0, 0, 0 }, kIntersect_SkClipOp, false);
  95                 break;
  96         }
  97     }
  98
  99     canvas->drawRect(SkRect::Make(kCoverRect), paint);
 100 }
 101
 102 DEF_GM( return new WindowRectanglesGM(); )
 103
 104 ////////////////////////////////////////////////////////////////////////////////////////////////////
 105
 106 #if SK_SUPPORT_GPU
 107
 108 constexpr static int kNumWindows = 8;
 109
 110 /**
 111  * Visualizes the mask (alpha or stencil) for a clip with several window rectangles. The purpose of
 112  * this test is to verify that window rectangles are being used during clip mask generation, and to
 113  * visualize where the window rectangles are placed.
 114  *
 115  * We use window rectangles when generating the clip mask because there is no need to invest time
 116  * defining those regions where window rectangles will be in effect during the actual draw anyway.
 117  *
 118  * This test works by filling the entire clip mask with a small checkerboard pattern before drawing
 119  * it, and then covering the mask with a solid color once it has been generated. The regions inside
 120  * window rectangles or outside the scissor should still have the initial checkerboard intact.
 121  */
 122 class WindowRectanglesMaskGM : public WindowRectanglesBaseGM {
 123 private:
 124     constexpr static int kMaskCheckerSize = 5;
 125     SkString onShortName() final { return SkString("windowrectangles_mask"); }
 126     void onCoverClipStack(const SkClipStack&, SkCanvas*) final;
 127     void visualizeAlphaMask(GrContext*, GrRenderTargetContext*, const GrReducedClip&, GrPaint&&);
 128     void visualizeStencilMask(GrContext*, GrRenderTargetContext*, const GrReducedClip&, GrPaint&&);
 129     void stencilCheckerboard(GrRenderTargetContext*, bool flip);
 130     void fail(SkCanvas*);
 131 };
 132
 133 /**
 134  * Base class for GrClips that visualize a clip mask.
 135  */
 136 class MaskOnlyClipBase : public GrClip {
 137 private:
 138     bool quickContains(const SkRect&) const final { return false; }
 139     bool isRRect(const SkRect& rtBounds, SkRRect* rr, GrAA*) const final { return false; }
 140     void getConservativeBounds(int width, int height, SkIRect* rect, bool* iior) const final {
 141         rect->set(0, 0, width, height);
 142         if (iior) {
 143             *iior = false;
 144         }
 145     }
 146 };
 147
 148 /**
 149  * This class clips a cover by an alpha mask. We use it to visualize the alpha clip mask.
 150  */
 151 class AlphaOnlyClip final : public MaskOnlyClipBase {
 152 public:
 153     AlphaOnlyClip(GrResourceProvider* resourceProvider, sk_sp<GrTextureProxy> mask, int x, int y) {
 154         int w = mask->width(), h = mask->height();
 155         fFP = GrDeviceSpaceTextureDecalFragmentProcessor::Make(resourceProvider, std::move(mask),
 156                                                                SkIRect::MakeWH(w, h), {x, y});
 157     }
 158 private:
 159     bool apply(GrContext*, GrRenderTargetContext*, bool, bool, GrAppliedClip* out,
 160                SkRect* bounds) const override {
 161         out->addCoverageFP(fFP);
 162         return true;
 163     }
 164     sk_sp<GrFragmentProcessor> fFP;
 165 };
 166
 167 /**
 168  * This class clips a cover by the stencil clip bit. We use it to visualize the stencil mask.
 169  */
 170 class StencilOnlyClip final : public MaskOnlyClipBase {
 171 private:
 172     bool apply(GrContext*, GrRenderTargetContext*, bool, bool, GrAppliedClip* out,
 173                SkRect* bounds) const override {
 174         out->addStencilClip();
 175         return true;
 176     }
 177 };
 178
 179 void WindowRectanglesMaskGM::onCoverClipStack(const SkClipStack& stack, SkCanvas* canvas) {
 180     GrContext* ctx = canvas->getGrContext();
 181     GrRenderTargetContext* rtc = canvas->internal_private_accessTopLayerRenderTargetContext();
 182
 183     if (!ctx || !rtc || rtc->priv().maxWindowRectangles() < kNumWindows) {
 184         this->fail(canvas);
 185         return;
 186     }
 187
 188     const GrReducedClip reducedClip(stack, SkRect::Make(kCoverRect), kNumWindows);
 189
 190     GrPaint paint;
 191     if (!rtc->isStencilBufferMultisampled()) {
 192         paint.setColor4f(GrColor4f(0, 0.25f, 1, 1));
 193         this->visualizeAlphaMask(ctx, rtc, reducedClip, std::move(paint));
 194     } else {
 195         paint.setColor4f(GrColor4f(1, 0.25f, 0.25f, 1));
 196         this->visualizeStencilMask(ctx, rtc, reducedClip, std::move(paint));
 197     }
 198 }
 199
 200 void WindowRectanglesMaskGM::visualizeAlphaMask(GrContext* ctx, GrRenderTargetContext* rtc,
 201                                                 const GrReducedClip& reducedClip, GrPaint&& paint) {
 202     const int padRight = (kDeviceRect.right() - kCoverRect.right()) / 2;
 203     const int padBottom = (kDeviceRect.bottom() - kCoverRect.bottom()) / 2;
 204     sk_sp<GrRenderTargetContext> maskRTC(
 205         ctx->makeDeferredRenderTargetContextWithFallback(SkBackingFit::kExact,
 206                                                          kCoverRect.width() + padRight,
 207                                                          kCoverRect.height() + padBottom,
 208                                                          kAlpha_8_GrPixelConfig, nullptr));
 209     if (!maskRTC ||
 210         !ctx->resourceProvider()->attachStencilAttachment(maskRTC->accessRenderTarget())) {
 211         return;
 212     }
 213
 214     // Draw a checker pattern into the alpha mask so we can visualize the regions left untouched by
 215     // the clip mask generation.
 216     this->stencilCheckerboard(maskRTC.get(), true);
 217     maskRTC->clear(nullptr, GrColorPackA4(0xff), true);
 218     maskRTC->priv().drawAndStencilRect(StencilOnlyClip(), &GrUserStencilSettings::kUnused,
 219                                        SkRegion::kDifference_Op, false, GrAA::kNo, SkMatrix::I(),
 220                                        SkRect::MakeIWH(maskRTC->width(), maskRTC->height()));
 221     reducedClip.drawAlphaClipMask(maskRTC.get());
 222
 223     int x = kCoverRect.x() - kDeviceRect.x(),
 224         y = kCoverRect.y() - kDeviceRect.y();
 225
 226     // Now visualize the alpha mask by drawing a rect over the area where it is defined. The regions
 227     // inside window rectangles or outside the scissor should still have the initial checkerboard
 228     // intact. (This verifies we didn't spend any time modifying those pixels in the mask.)
 229     AlphaOnlyClip clip(ctx->resourceProvider(), maskRTC->asTextureProxyRef(), x, y);
 230     rtc->drawRect(clip, std::move(paint), GrAA::kYes, SkMatrix::I(),
 231                   SkRect::Make(SkIRect::MakeXYWH(x, y, maskRTC->width(), maskRTC->height())));
 232 }
 233
 234 void WindowRectanglesMaskGM::visualizeStencilMask(GrContext* ctx, GrRenderTargetContext* rtc,
 235                                                   const GrReducedClip& reducedClip,
 236                                                   GrPaint&& paint) {
 237     if (!ctx->resourceProvider()->attachStencilAttachment(rtc->accessRenderTarget())) {
 238         return;
 239     }
 240
 241     // Draw a checker pattern into the stencil buffer so we can visualize the regions left untouched
 242     // by the clip mask generation.
 243     this->stencilCheckerboard(rtc, false);
 244     reducedClip.drawStencilClipMask(ctx, rtc);
 245
 246     // Now visualize the stencil mask by covering the entire render target. The regions inside
 247     // window rectangless or outside the scissor should still have the initial checkerboard intact.
 248     // (This verifies we didn't spend any time modifying those pixels in the mask.)
 249     rtc->drawPaint(StencilOnlyClip(), std::move(paint), SkMatrix::I());
 250 }
 251
 252 void WindowRectanglesMaskGM::stencilCheckerboard(GrRenderTargetContext* rtc, bool flip) {
 253     constexpr static GrUserStencilSettings kSetClip(
 254         GrUserStencilSettings::StaticInit<
 255         0,
 256         GrUserStencilTest::kAlways,
 257         0,
 258         GrUserStencilOp::kSetClipBit,
 259         GrUserStencilOp::kKeep,
 260         0>()
 261     );
 262
 263     rtc->priv().clearStencilClip(GrFixedClip::Disabled(), false);
 264
 265     for (int y = 0; y < kDeviceRect.height(); y += kMaskCheckerSize) {
 266         for (int x = (y & 1) == flip ? 0 : kMaskCheckerSize;
 267              x < kDeviceRect.width(); x += 2 * kMaskCheckerSize) {
 268             SkIRect checker = SkIRect::MakeXYWH(x, y, kMaskCheckerSize, kMaskCheckerSize);
 269             rtc->priv().stencilRect(GrNoClip(), &kSetClip, GrAAType::kNone, SkMatrix::I(),
 270                                     SkRect::Make(checker));
 271         }
 272     }
 273 }
 274
 275 void WindowRectanglesMaskGM::fail(SkCanvas* canvas) {
 276     SkPaint paint;
 277     paint.setAntiAlias(true);
 278     paint.setTextAlign(SkPaint::kCenter_Align);
 279     paint.setTextSize(20);
 280     sk_tool_utils::set_portable_typeface(&paint);
 281
 282     SkString errorMsg;
 283     errorMsg.printf("Requires GPU with %i window rectangles", kNumWindows);
 284
 285     canvas->clipRect(SkRect::Make(kCoverRect));
 286     canvas->clear(SK_ColorWHITE);
 287     canvas->drawString(errorMsg, SkIntToScalar(kCoverRect.centerX()),
 288                      SkIntToScalar(kCoverRect.centerY() - 10), paint);
 289 }
 290
 291 DEF_GM( return new WindowRectanglesMaskGM(); )
 292
 293 #endif
 294
 295 }