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 24constexpr static SkIRect kDeviceRect = {0, 0, 600, 600}; 25constexpr static SkIRect kCoverRect = {50, 50, 550, 550}; 26 27namespace skiagm { 28 29//////////////////////////////////////////////////////////////////////////////////////////////////// 30 31class WindowRectanglesBaseGM : public GM { 32protected: 33 virtual void onCoverClipStack(const SkClipStack&, SkCanvas*) = 0; 34 35private: 36 SkISize onISize() override { return SkISize::Make(kDeviceRect.width(), kDeviceRect.height()); } 37 void onDraw(SkCanvas*) final; 38}; 39 40void 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 */ 68class WindowRectanglesGM : public WindowRectanglesBaseGM { 69private: 70 SkString onShortName() final { return SkString("windowrectangles"); } 71 void onCoverClipStack(const SkClipStack&, SkCanvas*) final; 72}; 73 74void 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 102DEF_GM( return new WindowRectanglesGM(); ) 103 104//////////////////////////////////////////////////////////////////////////////////////////////////// 105 106#if SK_SUPPORT_GPU 107 108constexpr 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 */ 122class WindowRectanglesMaskGM : public WindowRectanglesBaseGM { 123private: 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 */ 136class MaskOnlyClipBase : public GrClip { 137private: 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 */ 151class AlphaOnlyClip final : public MaskOnlyClipBase { 152public: 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 } 158private: 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 */ 170class StencilOnlyClip final : public MaskOnlyClipBase { 171private: 172 bool apply(GrContext*, GrRenderTargetContext*, bool, bool, GrAppliedClip* out, 173 SkRect* bounds) const override { 174 out->addStencilClip(); 175 return true; 176 } 177}; 178 179void 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 200void 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->makeRenderTargetContextWithFallback(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 234void 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 252void 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 275void 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->drawText(errorMsg.c_str(), errorMsg.size(), SkIntToScalar(kCoverRect.centerX()), 288 SkIntToScalar(kCoverRect.centerY() - 10), paint); 289} 290 291DEF_GM( return new WindowRectanglesMaskGM(); ) 292 293#endif 294 295} 296