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