blob: 43342ede2b406a01cec44cc78c851624cdfa54ea [file] [log] [blame]
robertphillips@google.com1e945b72012-04-16 18:03:03 +00001/*
csmartdaltonc6f411e2016-08-05 22:32:12 -07002 * Copyright 2016 Google Inc.
robertphillips@google.com1e945b72012-04-16 18:03:03 +00003 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
Mike Kleinc0bd9f92019-04-23 12:05:21 -05008#include "include/private/GrTextureProxy.h"
9#include "include/private/SkTo.h"
10#include "src/core/SkClipOpPriv.h"
11#include "src/core/SkMakeUnique.h"
12#include "src/core/SkTaskGroup.h"
13#include "src/core/SkTraceEvent.h"
14#include "src/gpu/GrAppliedClip.h"
15#include "src/gpu/GrClipStackClip.h"
16#include "src/gpu/GrContextPriv.h"
17#include "src/gpu/GrDeferredProxyUploader.h"
18#include "src/gpu/GrDrawingManager.h"
19#include "src/gpu/GrFixedClip.h"
20#include "src/gpu/GrGpuResourcePriv.h"
21#include "src/gpu/GrProxyProvider.h"
22#include "src/gpu/GrRecordingContextPriv.h"
23#include "src/gpu/GrRenderTargetContextPriv.h"
24#include "src/gpu/GrSWMaskHelper.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050025#include "src/gpu/GrStencilAttachment.h"
26#include "src/gpu/GrStyle.h"
27#include "src/gpu/effects/GrConvexPolyEffect.h"
28#include "src/gpu/effects/GrRRectEffect.h"
29#include "src/gpu/effects/GrTextureDomain.h"
Michael Ludwig663afe52019-06-03 16:46:19 -040030#include "src/gpu/geometry/GrShape.h"
bsalomon@google.comc6b3e482012-12-07 20:43:52 +000031
Brian Salomonc3833b42018-07-09 18:23:58 +000032typedef SkClipStack::Element Element;
33typedef GrReducedClip::InitialState InitialState;
34typedef GrReducedClip::ElementList ElementList;
35
36const char GrClipStackClip::kMaskTestTag[] = "clip_mask";
robertphillips976f5f02016-06-03 10:59:20 -070037
csmartdaltonc6f411e2016-08-05 22:32:12 -070038bool GrClipStackClip::quickContains(const SkRect& rect) const {
reed4d2cce42016-08-22 13:03:47 -070039 if (!fStack || fStack->isWideOpen()) {
csmartdaltonc6f411e2016-08-05 22:32:12 -070040 return true;
41 }
Brian Salomon9a767722017-03-13 17:57:28 -040042 return fStack->quickContains(rect);
csmartdaltonc6f411e2016-08-05 22:32:12 -070043}
44
bsalomon7f0d9f32016-08-15 14:49:10 -070045bool GrClipStackClip::quickContains(const SkRRect& rrect) const {
reed4d2cce42016-08-22 13:03:47 -070046 if (!fStack || fStack->isWideOpen()) {
bsalomon7f0d9f32016-08-15 14:49:10 -070047 return true;
48 }
Brian Salomon9a767722017-03-13 17:57:28 -040049 return fStack->quickContains(rrect);
bsalomon7f0d9f32016-08-15 14:49:10 -070050}
51
Brian Salomon0e8fc8b2016-12-09 15:10:07 -050052bool GrClipStackClip::isRRect(const SkRect& origRTBounds, SkRRect* rr, GrAA* aa) const {
bsalomoncb31e512016-08-26 10:48:19 -070053 if (!fStack) {
54 return false;
55 }
56 const SkRect* rtBounds = &origRTBounds;
Brian Salomon0e8fc8b2016-12-09 15:10:07 -050057 bool isAA;
58 if (fStack->isRRect(*rtBounds, rr, &isAA)) {
Chris Dalton3b51df12017-11-27 14:33:06 -070059 *aa = GrAA(isAA);
bsalomoncb31e512016-08-26 10:48:19 -070060 return true;
61 }
62 return false;
63}
64
csmartdaltonc6f411e2016-08-05 22:32:12 -070065void GrClipStackClip::getConservativeBounds(int width, int height, SkIRect* devResult,
66 bool* isIntersectionOfRects) const {
67 if (!fStack) {
68 devResult->setXYWH(0, 0, width, height);
69 if (isIntersectionOfRects) {
70 *isIntersectionOfRects = true;
71 }
72 return;
73 }
74 SkRect devBounds;
Brian Salomon9a767722017-03-13 17:57:28 -040075 fStack->getConservativeBounds(0, 0, width, height, &devBounds, isIntersectionOfRects);
csmartdaltonc6f411e2016-08-05 22:32:12 -070076 devBounds.roundOut(devResult);
77}
78
Chris Daltonc5348082018-03-30 15:59:38 +000079////////////////////////////////////////////////////////////////////////////////
80// set up the draw state to enable the aa clipping mask.
81static std::unique_ptr<GrFragmentProcessor> create_fp_for_mask(sk_sp<GrTextureProxy> mask,
82 const SkIRect& devBound) {
83 SkIRect domainTexels = SkIRect::MakeWH(devBound.width(), devBound.height());
84 return GrDeviceSpaceTextureDecalFragmentProcessor::Make(std::move(mask), domainTexels,
85 {devBound.fLeft, devBound.fTop});
86}
87
88// Does the path in 'element' require SW rendering? If so, return true (and,
89// optionally, set 'prOut' to NULL. If not, return false (and, optionally, set
90// 'prOut' to the non-SW path renderer that will do the job).
Robert Phillips6f0e02f2019-02-13 11:02:28 -050091bool GrClipStackClip::PathNeedsSWRenderer(GrRecordingContext* context,
Chris Daltonc5348082018-03-30 15:59:38 +000092 const SkIRect& scissorRect,
93 bool hasUserStencilSettings,
94 const GrRenderTargetContext* renderTargetContext,
95 const SkMatrix& viewMatrix,
Brian Salomonc3833b42018-07-09 18:23:58 +000096 const Element* element,
Chris Daltonc5348082018-03-30 15:59:38 +000097 GrPathRenderer** prOut,
98 bool needsStencil) {
Brian Salomonc3833b42018-07-09 18:23:58 +000099 if (Element::DeviceSpaceType::kRect == element->getDeviceSpaceType()) {
Chris Daltonc5348082018-03-30 15:59:38 +0000100 // rects can always be drawn directly w/o using the software path
101 // TODO: skip rrects once we're drawing them directly.
102 if (prOut) {
103 *prOut = nullptr;
104 }
105 return false;
106 } else {
107 // We shouldn't get here with an empty clip element.
Brian Salomonc3833b42018-07-09 18:23:58 +0000108 SkASSERT(Element::DeviceSpaceType::kEmpty != element->getDeviceSpaceType());
Chris Daltonc5348082018-03-30 15:59:38 +0000109
110 // the gpu alpha mask will draw the inverse paths as non-inverse to a temp buffer
111 SkPath path;
Brian Salomonc3833b42018-07-09 18:23:58 +0000112 element->asDeviceSpacePath(&path);
Chris Daltonc5348082018-03-30 15:59:38 +0000113 if (path.isInverseFillType()) {
114 path.toggleInverseFillType();
115 }
116
Chris Dalton09e56892019-03-13 00:22:01 -0600117 // We only use this method when rendering coverage clip masks.
118 SkASSERT(GrFSAAType::kNone == renderTargetContext->fsaaType());
119 auto aaTypeFlags = (element->isAA())
120 ? GrPathRenderer::AATypeFlags::kCoverage
121 : GrPathRenderer::AATypeFlags::kNone;
122
Chris Daltonc5348082018-03-30 15:59:38 +0000123 GrPathRendererChain::DrawType type =
124 needsStencil ? GrPathRendererChain::DrawType::kStencilAndColor
125 : GrPathRendererChain::DrawType::kColor;
126
127 GrShape shape(path, GrStyle::SimpleFill());
128 GrPathRenderer::CanDrawPathArgs canDrawArgs;
Robert Phillips9da87e02019-02-04 13:26:26 -0500129 canDrawArgs.fCaps = context->priv().caps();
Chris Daltonc5348082018-03-30 15:59:38 +0000130 canDrawArgs.fClipConservativeBounds = &scissorRect;
131 canDrawArgs.fViewMatrix = &viewMatrix;
132 canDrawArgs.fShape = &shape;
Chris Dalton09e56892019-03-13 00:22:01 -0600133 canDrawArgs.fAATypeFlags = aaTypeFlags;
Greg Danielbe7fc462019-01-03 16:40:42 -0500134 SkASSERT(!renderTargetContext->wrapsVkSecondaryCB());
135 canDrawArgs.fTargetIsWrappedVkSecondaryCB = false;
Chris Daltonc5348082018-03-30 15:59:38 +0000136 canDrawArgs.fHasUserStencilSettings = hasUserStencilSettings;
137
138 // the 'false' parameter disallows use of the SW path renderer
139 GrPathRenderer* pr =
Robert Phillips9da87e02019-02-04 13:26:26 -0500140 context->priv().drawingManager()->getPathRenderer(canDrawArgs, false, type);
Chris Daltonc5348082018-03-30 15:59:38 +0000141 if (prOut) {
142 *prOut = pr;
143 }
144 return SkToBool(!pr);
145 }
146}
147
148/*
149 * This method traverses the clip stack to see if the GrSoftwarePathRenderer
150 * will be used on any element. If so, it returns true to indicate that the
151 * entire clip should be rendered in SW and then uploaded en masse to the gpu.
152 */
Robert Phillips6f0e02f2019-02-13 11:02:28 -0500153bool GrClipStackClip::UseSWOnlyPath(GrRecordingContext* context,
Chris Daltonc5348082018-03-30 15:59:38 +0000154 bool hasUserStencilSettings,
155 const GrRenderTargetContext* renderTargetContext,
156 const GrReducedClip& reducedClip) {
Chris Daltond22a0232018-08-22 17:25:10 +0000157 // TODO: right now it appears that GPU clip masks are strictly slower than software. We may
158 // want to revisit this assumption once we can test with render target sorting.
159 return true;
160
Chris Daltonc5348082018-03-30 15:59:38 +0000161 // TODO: generalize this function so that when
162 // a clip gets complex enough it can just be done in SW regardless
163 // of whether it would invoke the GrSoftwarePathRenderer.
164
Greg Danielbe7fc462019-01-03 16:40:42 -0500165 // If we're avoiding stencils, always use SW. This includes drawing into a wrapped vulkan
166 // secondary command buffer which can't handle stencils.
Robert Phillips9da87e02019-02-04 13:26:26 -0500167 if (context->priv().caps()->avoidStencilBuffers() ||
Greg Danielbe7fc462019-01-03 16:40:42 -0500168 renderTargetContext->wrapsVkSecondaryCB()) {
Chris Daltonc5348082018-03-30 15:59:38 +0000169 return true;
Brian Salomonc7fe0f72018-05-11 10:14:21 -0400170 }
Chris Daltonc5348082018-03-30 15:59:38 +0000171
172 // Set the matrix so that rendered clip elements are transformed to mask space from clip
173 // space.
174 SkMatrix translate;
175 translate.setTranslate(SkIntToScalar(-reducedClip.left()), SkIntToScalar(-reducedClip.top()));
176
177 for (ElementList::Iter iter(reducedClip.maskElements()); iter.get(); iter.next()) {
Brian Salomonc3833b42018-07-09 18:23:58 +0000178 const Element* element = iter.get();
Chris Daltonc5348082018-03-30 15:59:38 +0000179
Brian Salomonc3833b42018-07-09 18:23:58 +0000180 SkClipOp op = element->getOp();
181 bool invert = element->isInverseFilled();
Chris Daltonc5348082018-03-30 15:59:38 +0000182 bool needsStencil = invert ||
183 kIntersect_SkClipOp == op || kReverseDifference_SkClipOp == op;
184
185 if (PathNeedsSWRenderer(context, reducedClip.scissor(), hasUserStencilSettings,
186 renderTargetContext, translate, element, nullptr, needsStencil)) {
187 return true;
188 }
189 }
190 return false;
191}
192
193////////////////////////////////////////////////////////////////////////////////
194// sort out what kind of clip mask needs to be created: alpha, stencil,
195// scissor, or entirely software
Robert Phillips6f0e02f2019-02-13 11:02:28 -0500196bool GrClipStackClip::apply(GrRecordingContext* context, GrRenderTargetContext* renderTargetContext,
Brian Salomon97180af2017-03-14 13:42:58 -0400197 bool useHWAA, bool hasUserStencilSettings, GrAppliedClip* out,
198 SkRect* bounds) const {
Brian Salomon97180af2017-03-14 13:42:58 -0400199 SkRect devBounds = SkRect::MakeIWH(renderTargetContext->width(), renderTargetContext->height());
200 if (!devBounds.intersect(*bounds)) {
csmartdaltoncbecb082016-07-22 08:59:08 -0700201 return false;
202 }
203
Brian Salomon510dd422017-03-16 12:15:22 -0400204 if (!fStack || fStack->isWideOpen()) {
205 return true;
206 }
207
Brian Osman5f5680c2019-06-05 10:17:25 -0400208 // An default count of 4 was chosen because of the common pattern in Blink of:
209 // isect RR
210 // diff RR
211 // isect convex_poly
212 // isect convex_poly
213 // when drawing rounded div borders.
214 constexpr int kMaxAnalyticFPs = 4;
215
Chris Daltona32a3c32017-12-05 10:05:21 -0700216 int maxWindowRectangles = renderTargetContext->priv().maxWindowRectangles();
Brian Osman5f5680c2019-06-05 10:17:25 -0400217 int maxAnalyticFPs = kMaxAnalyticFPs;
Chris Dalton584a79a2017-11-15 13:14:01 -0700218 if (GrFSAAType::kNone != renderTargetContext->fsaaType()) {
219 // With mixed samples (non-msaa color buffer), any coverage info is lost from color once it
220 // hits the color buffer anyway, so we may as well use coverage AA if nothing else in the
221 // pipe is multisampled.
Brian Salomonbdecacf2018-02-02 20:32:49 -0500222 if (renderTargetContext->numColorSamples() > 1 || useHWAA || hasUserStencilSettings) {
Chris Dalton584a79a2017-11-15 13:14:01 -0700223 maxAnalyticFPs = 0;
224 }
Brian Salomonc7fe0f72018-05-11 10:14:21 -0400225 // We disable MSAA when avoiding stencil.
Robert Phillips9da87e02019-02-04 13:26:26 -0500226 SkASSERT(!context->priv().caps()->avoidStencilBuffers());
Chris Dalton584a79a2017-11-15 13:14:01 -0700227 }
Robert Phillips9da87e02019-02-04 13:26:26 -0500228 auto* ccpr = context->priv().drawingManager()->getCoverageCountingPathRenderer();
Chris Dalton584a79a2017-11-15 13:14:01 -0700229
Robert Phillips9da87e02019-02-04 13:26:26 -0500230 GrReducedClip reducedClip(*fStack, devBounds, context->priv().caps(),
Ethan Nicholaseace9352018-10-15 20:09:54 +0000231 maxWindowRectangles, maxAnalyticFPs, ccpr ? maxAnalyticFPs : 0);
Chris Daltona32a3c32017-12-05 10:05:21 -0700232 if (InitialState::kAllOut == reducedClip.initialState() &&
233 reducedClip.maskElements().isEmpty()) {
234 return false;
235 }
bsalomon@google.com4c2443e2012-12-06 20:58:57 +0000236
Chris Dalton79471932017-10-27 01:50:57 -0600237 if (reducedClip.hasScissor() && !GrClip::IsInsideClip(reducedClip.scissor(), devBounds)) {
Chris Daltonbbfd5162017-11-07 13:35:22 -0700238 out->hardClip().addScissor(reducedClip.scissor(), bounds);
cdalton846c0512016-05-13 10:25:00 -0700239 }
cdalton93a379b2016-05-11 13:58:08 -0700240
csmartdaltonbf4a8f92016-09-06 10:01:06 -0700241 if (!reducedClip.windowRectangles().empty()) {
Chris Daltonbbfd5162017-11-07 13:35:22 -0700242 out->hardClip().addWindowRectangles(reducedClip.windowRectangles(),
243 GrWindowRectsState::Mode::kExclusive);
csmartdaltonbf4a8f92016-09-06 10:01:06 -0700244 }
245
Chris Daltona32a3c32017-12-05 10:05:21 -0700246 if (!reducedClip.maskElements().isEmpty()) {
247 if (!this->applyClipMask(context, renderTargetContext, reducedClip, hasUserStencilSettings,
248 out)) {
249 return false;
250 }
251 }
252
253 // The opList ID must not be looked up until AFTER producing the clip mask (if any). That step
254 // can cause a flush or otherwise change which opList our draw is going into.
255 uint32_t opListID = renderTargetContext->getOpList()->uniqueID();
256 int rtWidth = renderTargetContext->width(), rtHeight = renderTargetContext->height();
Chris Dalton4c458b12018-06-16 17:22:59 -0600257 if (auto clipFPs = reducedClip.finishAndDetachAnalyticFPs(ccpr, opListID, rtWidth, rtHeight)) {
Chris Dalton584a79a2017-11-15 13:14:01 -0700258 out->addCoverageFP(std::move(clipFPs));
259 }
260
Chris Daltona32a3c32017-12-05 10:05:21 -0700261 return true;
262}
csmartdaltond211e782016-08-15 11:17:19 -0700263
Robert Phillips6f0e02f2019-02-13 11:02:28 -0500264bool GrClipStackClip::applyClipMask(GrRecordingContext* context,
265 GrRenderTargetContext* renderTargetContext,
Chris Daltona32a3c32017-12-05 10:05:21 -0700266 const GrReducedClip& reducedClip, bool hasUserStencilSettings,
267 GrAppliedClip* out) const {
csmartdalton3affdc12016-10-28 12:01:10 -0700268#ifdef SK_DEBUG
Chris Dalton79471932017-10-27 01:50:57 -0600269 SkASSERT(reducedClip.hasScissor());
Robert Phillips784b7bf2016-12-09 13:35:02 -0500270 SkIRect rtIBounds = SkIRect::MakeWH(renderTargetContext->width(),
271 renderTargetContext->height());
Chris Dalton79471932017-10-27 01:50:57 -0600272 const SkIRect& scissor = reducedClip.scissor();
273 SkASSERT(rtIBounds.contains(scissor)); // Mask shouldn't be larger than the RT.
csmartdalton3affdc12016-10-28 12:01:10 -0700274#endif
csmartdaltond211e782016-08-15 11:17:19 -0700275
cdaltonede75742015-11-11 15:27:57 -0800276 // If the stencil buffer is multisampled we can use it to do everything.
Chris Dalton79471932017-10-27 01:50:57 -0600277 if ((GrFSAAType::kNone == renderTargetContext->fsaaType() && reducedClip.maskRequiresAA()) ||
Robert Phillips9da87e02019-02-04 13:26:26 -0500278 context->priv().caps()->avoidStencilBuffers() ||
Greg Danielbe7fc462019-01-03 16:40:42 -0500279 renderTargetContext->wrapsVkSecondaryCB()) {
Chris Daltonc5348082018-03-30 15:59:38 +0000280 sk_sp<GrTextureProxy> result;
281 if (UseSWOnlyPath(context, hasUserStencilSettings, renderTargetContext, reducedClip)) {
282 // The clip geometry is complex enough that it will be more efficient to create it
283 // entirely in software
284 result = this->createSoftwareClipMask(context, reducedClip, renderTargetContext);
285 } else {
286 result = this->createAlphaClipMask(context, reducedClip);
287 }
288
289 if (result) {
290 // The mask's top left coord should be pinned to the rounded-out top left corner of
291 // the clip's device space bounds.
292 out->addCoverageFP(create_fp_for_mask(std::move(result), reducedClip.scissor()));
robertphillips@google.comf294b772012-04-27 14:29:26 +0000293 return true;
294 }
Eric Karl5c779752017-05-08 12:02:07 -0700295
Chris Daltonc5348082018-03-30 15:59:38 +0000296 // If alpha or software clip mask creation fails, fall through to the stencil code paths,
297 // unless stencils are disallowed.
Robert Phillips9da87e02019-02-04 13:26:26 -0500298 if (context->priv().caps()->avoidStencilBuffers() ||
Greg Danielbe7fc462019-01-03 16:40:42 -0500299 renderTargetContext->wrapsVkSecondaryCB()) {
Chris Dalton584a79a2017-11-15 13:14:01 -0700300 SkDebugf("WARNING: Clip mask requires stencil, but stencil unavailable. "
301 "Clip will be ignored.\n");
Eric Karl5c779752017-05-08 12:02:07 -0700302 return false;
303 }
robertphillips@google.comf294b772012-04-27 14:29:26 +0000304 }
robertphillips@google.comf294b772012-04-27 14:29:26 +0000305
Robert Phillips65048132017-08-10 08:44:49 -0400306 renderTargetContext->setNeedsStencil();
csmartdaltonbde96c62016-08-31 12:54:46 -0700307
Brian Salomonc3833b42018-07-09 18:23:58 +0000308 // This relies on the property that a reduced sub-rect of the last clip will contain all the
309 // relevant window rectangles that were in the last clip. This subtle requirement will go away
310 // after clipping is overhauled.
311 if (renderTargetContext->priv().mustRenderClip(reducedClip.maskGenID(), reducedClip.scissor(),
312 reducedClip.numAnalyticFPs())) {
Ethan Nicholaseace9352018-10-15 20:09:54 +0000313 reducedClip.drawStencilClipMask(context, renderTargetContext);
Brian Salomonc3833b42018-07-09 18:23:58 +0000314 renderTargetContext->priv().setLastClip(reducedClip.maskGenID(), reducedClip.scissor(),
315 reducedClip.numAnalyticFPs());
csmartdaltonbde96c62016-08-31 12:54:46 -0700316 }
Brian Salomonc3833b42018-07-09 18:23:58 +0000317 // GrAppliedClip doesn't need to figure numAnalyticFPs into its key (used by operator==) because
318 // it verifies the FPs are also equal.
319 out->hardClip().addStencilClip(reducedClip.maskGenID());
robertphillips@google.com1e945b72012-04-16 18:03:03 +0000320 return true;
321}
322
robertphillips@google.com6b70a7b2012-05-11 15:32:48 +0000323////////////////////////////////////////////////////////////////////////////////
bsalomon473addf2015-10-02 07:49:05 -0700324// Create a 8-bit clip mask in alpha
325
Brian Salomonc3833b42018-07-09 18:23:58 +0000326static void create_clip_mask_key(uint32_t clipGenID, const SkIRect& bounds, int numAnalyticFPs,
327 GrUniqueKey* key) {
328 static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
329 GrUniqueKey::Builder builder(key, kDomain, 4, GrClipStackClip::kMaskTestTag);
330 builder[0] = clipGenID;
331 // SkToS16 because image filters outset layers to a size indicated by the filter, which can
332 // sometimes result in negative coordinates from device space.
333 builder[1] = SkToS16(bounds.fLeft) | (SkToS16(bounds.fRight) << 16);
334 builder[2] = SkToS16(bounds.fTop) | (SkToS16(bounds.fBottom) << 16);
335 builder[3] = numAnalyticFPs;
336}
337
Robert Phillips6f0e02f2019-02-13 11:02:28 -0500338static void add_invalidate_on_pop_message(GrRecordingContext* context,
Robert Phillips427966a2018-12-20 17:20:43 -0500339 const SkClipStack& stack, uint32_t clipGenID,
340 const GrUniqueKey& clipMaskKey) {
Robert Phillips9da87e02019-02-04 13:26:26 -0500341 GrProxyProvider* proxyProvider = context->priv().proxyProvider();
Robert Phillips427966a2018-12-20 17:20:43 -0500342
Brian Salomon19f0ed52017-01-06 13:54:58 -0500343 SkClipStack::Iter iter(stack, SkClipStack::Iter::kTop_IterStart);
344 while (const Element* element = iter.prev()) {
345 if (element->getGenID() == clipGenID) {
Robert Phillips427966a2018-12-20 17:20:43 -0500346 element->addResourceInvalidationMessage(proxyProvider, clipMaskKey);
Brian Salomon19f0ed52017-01-06 13:54:58 -0500347 return;
348 }
349 }
350 SkDEBUGFAIL("Gen ID was not found in stack.");
351}
352
Robert Phillips6f0e02f2019-02-13 11:02:28 -0500353sk_sp<GrTextureProxy> GrClipStackClip::createAlphaClipMask(GrRecordingContext* context,
Chris Daltonc5348082018-03-30 15:59:38 +0000354 const GrReducedClip& reducedClip) const {
Robert Phillips9da87e02019-02-04 13:26:26 -0500355 GrProxyProvider* proxyProvider = context->priv().proxyProvider();
Brian Salomonc3833b42018-07-09 18:23:58 +0000356 GrUniqueKey key;
357 create_clip_mask_key(reducedClip.maskGenID(), reducedClip.scissor(),
358 reducedClip.numAnalyticFPs(), &key);
359
Chris Daltonc5348082018-03-30 15:59:38 +0000360 sk_sp<GrTextureProxy> proxy(proxyProvider->findOrCreateProxyByUniqueKey(
Robert Phillips5491e822018-06-27 12:54:44 -0400361 key, kTopLeft_GrSurfaceOrigin));
Chris Daltonc5348082018-03-30 15:59:38 +0000362 if (proxy) {
363 return proxy;
364 }
365
Greg Daniel4065d452018-11-16 15:43:41 -0500366 GrBackendFormat format =
Robert Phillips9da87e02019-02-04 13:26:26 -0500367 context->priv().caps()->getBackendFormatFromColorType(kAlpha_8_SkColorType);
Chris Daltonc5348082018-03-30 15:59:38 +0000368 sk_sp<GrRenderTargetContext> rtc(
Robert Phillips9da87e02019-02-04 13:26:26 -0500369 context->priv().makeDeferredRenderTargetContextWithFallback(
Greg Daniel4065d452018-11-16 15:43:41 -0500370 format,
Robert Phillips5491e822018-06-27 12:54:44 -0400371 SkBackingFit::kApprox,
372 reducedClip.width(),
373 reducedClip.height(),
374 kAlpha_8_GrPixelConfig,
375 nullptr, 1,
376 GrMipMapped::kNo,
377 kTopLeft_GrSurfaceOrigin));
Chris Daltonc5348082018-03-30 15:59:38 +0000378 if (!rtc) {
379 return nullptr;
380 }
381
382 if (!reducedClip.drawAlphaClipMask(rtc.get())) {
383 return nullptr;
384 }
385
386 sk_sp<GrTextureProxy> result(rtc->asTextureProxyRef());
387 if (!result) {
388 return nullptr;
389 }
390
Robert Phillips5491e822018-06-27 12:54:44 -0400391 SkASSERT(result->origin() == kTopLeft_GrSurfaceOrigin);
Chris Daltonc5348082018-03-30 15:59:38 +0000392 proxyProvider->assignUniqueKeyToProxy(key, result.get());
Robert Phillips427966a2018-12-20 17:20:43 -0500393 add_invalidate_on_pop_message(context, *fStack, reducedClip.maskGenID(), key);
Chris Daltonc5348082018-03-30 15:59:38 +0000394
395 return result;
396}
397
Brian Osman5d034742017-09-11 13:38:55 -0400398namespace {
Robert Phillips875218e2017-02-24 08:37:13 -0500399
Brian Osman5d034742017-09-11 13:38:55 -0400400/**
Brian Osman099fa0f2017-10-02 16:38:32 -0400401 * Payload class for use with GrTDeferredProxyUploader. The clip mask code renders multiple
Brian Osman5d034742017-09-11 13:38:55 -0400402 * elements, each storing their own AA setting (and already transformed into device space). This
403 * stores all of the information needed by the worker thread to draw all clip elements (see below,
404 * in createSoftwareClipMask).
405 */
406class ClipMaskData {
407public:
408 ClipMaskData(const GrReducedClip& reducedClip)
Chris Dalton79471932017-10-27 01:50:57 -0600409 : fScissor(reducedClip.scissor())
Brian Osman5d034742017-09-11 13:38:55 -0400410 , fInitialState(reducedClip.initialState()) {
Chris Dalton79471932017-10-27 01:50:57 -0600411 for (ElementList::Iter iter(reducedClip.maskElements()); iter.get(); iter.next()) {
Brian Osman5d034742017-09-11 13:38:55 -0400412 fElements.addToTail(*iter.get());
413 }
robertphillips@google.com6b70a7b2012-05-11 15:32:48 +0000414 }
415
Chris Dalton79471932017-10-27 01:50:57 -0600416 const SkIRect& scissor() const { return fScissor; }
Brian Osman5d034742017-09-11 13:38:55 -0400417 InitialState initialState() const { return fInitialState; }
418 const ElementList& elements() const { return fElements; }
bsalomon@google.com4c2443e2012-12-06 20:58:57 +0000419
Brian Osman5d034742017-09-11 13:38:55 -0400420private:
Chris Dalton79471932017-10-27 01:50:57 -0600421 SkIRect fScissor;
Brian Osman5d034742017-09-11 13:38:55 -0400422 InitialState fInitialState;
423 ElementList fElements;
424};
robertphillips@google.com6b70a7b2012-05-11 15:32:48 +0000425
Brian Osman5d034742017-09-11 13:38:55 -0400426}
427
428static void draw_clip_elements_to_mask_helper(GrSWMaskHelper& helper, const ElementList& elements,
Chris Dalton79471932017-10-27 01:50:57 -0600429 const SkIRect& scissor, InitialState initialState) {
Brian Osman5d034742017-09-11 13:38:55 -0400430 // Set the matrix so that rendered clip elements are transformed to mask space from clip space.
joshualitt8059eb92014-12-29 15:10:07 -0800431 SkMatrix translate;
Chris Dalton79471932017-10-27 01:50:57 -0600432 translate.setTranslate(SkIntToScalar(-scissor.left()), SkIntToScalar(-scissor.top()));
joshualitt9853cce2014-11-17 14:22:48 -0800433
Brian Osman5d034742017-09-11 13:38:55 -0400434 helper.clear(InitialState::kAllIn == initialState ? 0xFF : 0x00);
sugoi@google.com12b4e272012-12-06 20:13:11 +0000435
Brian Osman5d034742017-09-11 13:38:55 -0400436 for (ElementList::Iter iter(elements); iter.get(); iter.next()) {
Brian Salomonc3833b42018-07-09 18:23:58 +0000437 const Element* element = iter.get();
438 SkClipOp op = element->getOp();
439 GrAA aa = GrAA(element->isAA());
robertphillips@google.comfa662942012-05-17 12:20:22 +0000440
Mike Reedc1f77742016-12-09 09:00:50 -0500441 if (kIntersect_SkClipOp == op || kReverseDifference_SkClipOp == op) {
bsalomon@google.com4c2443e2012-12-06 20:58:57 +0000442 // Intersect and reverse difference require modifying pixels outside of the geometry
443 // that is being "drawn". In both cases we erase all the pixels outside of the geometry
444 // but leave the pixels inside the geometry alone. For reverse difference we invert all
445 // the pixels before clearing the ones outside the geometry.
Mike Reedc1f77742016-12-09 09:00:50 -0500446 if (kReverseDifference_SkClipOp == op) {
Chris Dalton79471932017-10-27 01:50:57 -0600447 SkRect temp = SkRect::Make(scissor);
robertphillips@google.comfa662942012-05-17 12:20:22 +0000448 // invert the entire scene
Brian Salomon74077562017-08-30 13:55:35 -0400449 helper.drawRect(temp, translate, SkRegion::kXOR_Op, GrAA::kNo, 0xFF);
robertphillips@google.comfa662942012-05-17 12:20:22 +0000450 }
commit-bot@chromium.org5c056392014-02-17 19:50:02 +0000451 SkPath clipPath;
Brian Salomonc3833b42018-07-09 18:23:58 +0000452 element->asDeviceSpacePath(&clipPath);
commit-bot@chromium.org5c056392014-02-17 19:50:02 +0000453 clipPath.toggleInverseFillType();
bsalomon8acedde2016-06-24 10:42:16 -0700454 GrShape shape(clipPath, GrStyle::SimpleFill());
Brian Salomon74077562017-08-30 13:55:35 -0400455 helper.drawShape(shape, translate, SkRegion::kReplace_Op, aa, 0x00);
robertphillips@google.comfa662942012-05-17 12:20:22 +0000456 continue;
457 }
458
459 // The other ops (union, xor, diff) only affect pixels inside
460 // the geometry so they can just be drawn normally
Brian Salomonc3833b42018-07-09 18:23:58 +0000461 if (Element::DeviceSpaceType::kRect == element->getDeviceSpaceType()) {
462 helper.drawRect(element->getDeviceSpaceRect(), translate, (SkRegion::Op)op, aa, 0xFF);
bsalomon@google.com8182fa02012-12-04 14:06:06 +0000463 } else {
commit-bot@chromium.org5c056392014-02-17 19:50:02 +0000464 SkPath path;
Brian Salomonc3833b42018-07-09 18:23:58 +0000465 element->asDeviceSpacePath(&path);
bsalomon8acedde2016-06-24 10:42:16 -0700466 GrShape shape(path, GrStyle::SimpleFill());
Brian Salomon74077562017-08-30 13:55:35 -0400467 helper.drawShape(shape, translate, (SkRegion::Op)op, aa, 0xFF);
robertphillips@google.com6b70a7b2012-05-11 15:32:48 +0000468 }
469 }
Brian Osman5d034742017-09-11 13:38:55 -0400470}
robertphillips@google.com6b70a7b2012-05-11 15:32:48 +0000471
Brian Osman5d034742017-09-11 13:38:55 -0400472sk_sp<GrTextureProxy> GrClipStackClip::createSoftwareClipMask(
Robert Phillips6f0e02f2019-02-13 11:02:28 -0500473 GrRecordingContext* context, const GrReducedClip& reducedClip,
Brian Osman5d034742017-09-11 13:38:55 -0400474 GrRenderTargetContext* renderTargetContext) const {
Brian Salomonc3833b42018-07-09 18:23:58 +0000475 GrUniqueKey key;
476 create_clip_mask_key(reducedClip.maskGenID(), reducedClip.scissor(),
477 reducedClip.numAnalyticFPs(), &key);
robertphillips391395d2016-03-02 09:26:36 -0800478
Robert Phillips9da87e02019-02-04 13:26:26 -0500479 GrProxyProvider* proxyProvider = context->priv().proxyProvider();
Robert Phillips1afd4cd2018-01-08 13:40:32 -0500480
481 sk_sp<GrTextureProxy> proxy(proxyProvider->findOrCreateProxyByUniqueKey(
Brian Osman5d034742017-09-11 13:38:55 -0400482 key, kTopLeft_GrSurfaceOrigin));
483 if (proxy) {
484 return proxy;
485 }
486
487 // The mask texture may be larger than necessary. We round out the clip bounds and pin the top
488 // left corner of the resulting rect to the top left of the texture.
489 SkIRect maskSpaceIBounds = SkIRect::MakeWH(reducedClip.width(), reducedClip.height());
490
Robert Phillips6f0e02f2019-02-13 11:02:28 -0500491 SkTaskGroup* taskGroup = nullptr;
492 if (auto direct = context->priv().asDirectContext()) {
493 taskGroup = direct->priv().getTaskGroup();
494 }
495
Brian Osman5d034742017-09-11 13:38:55 -0400496 if (taskGroup && renderTargetContext) {
497 // Create our texture proxy
498 GrSurfaceDesc desc;
Brian Osman5d034742017-09-11 13:38:55 -0400499 desc.fWidth = maskSpaceIBounds.width();
500 desc.fHeight = maskSpaceIBounds.height();
501 desc.fConfig = kAlpha_8_GrPixelConfig;
Greg Daniel4065d452018-11-16 15:43:41 -0500502
503 GrBackendFormat format =
Robert Phillips9da87e02019-02-04 13:26:26 -0500504 context->priv().caps()->getBackendFormatFromColorType(kAlpha_8_SkColorType);
Greg Daniel4065d452018-11-16 15:43:41 -0500505
Brian Osmand140fe92017-10-03 12:17:26 -0400506 // MDB TODO: We're going to fill this proxy with an ASAP upload (which is out of order wrt
507 // to ops), so it can't have any pending IO.
Greg Daniel4065d452018-11-16 15:43:41 -0500508 proxy = proxyProvider->createProxy(format, desc, kTopLeft_GrSurfaceOrigin,
Robert Phillips10d17212019-04-24 14:09:10 -0400509 SkBackingFit::kApprox, SkBudgeted::kYes);
Brian Osman5d034742017-09-11 13:38:55 -0400510
Brian Osman099fa0f2017-10-02 16:38:32 -0400511 auto uploader = skstd::make_unique<GrTDeferredProxyUploader<ClipMaskData>>(reducedClip);
512 GrTDeferredProxyUploader<ClipMaskData>* uploaderRaw = uploader.get();
Brian Osman5d034742017-09-11 13:38:55 -0400513 auto drawAndUploadMask = [uploaderRaw, maskSpaceIBounds] {
514 TRACE_EVENT0("skia", "Threaded SW Clip Mask Render");
515 GrSWMaskHelper helper(uploaderRaw->getPixels());
516 if (helper.init(maskSpaceIBounds)) {
517 draw_clip_elements_to_mask_helper(helper, uploaderRaw->data().elements(),
Chris Dalton79471932017-10-27 01:50:57 -0600518 uploaderRaw->data().scissor(),
Brian Osman5d034742017-09-11 13:38:55 -0400519 uploaderRaw->data().initialState());
520 } else {
521 SkDEBUGFAIL("Unable to allocate SW clip mask.");
522 }
Brian Osman099fa0f2017-10-02 16:38:32 -0400523 uploaderRaw->signalAndFreeData();
Brian Osman5d034742017-09-11 13:38:55 -0400524 };
525
526 taskGroup->add(std::move(drawAndUploadMask));
Brian Osman099fa0f2017-10-02 16:38:32 -0400527 proxy->texPriv().setDeferredUploader(std::move(uploader));
Brian Osman5d034742017-09-11 13:38:55 -0400528 } else {
529 GrSWMaskHelper helper;
530 if (!helper.init(maskSpaceIBounds)) {
531 return nullptr;
532 }
533
Chris Dalton79471932017-10-27 01:50:57 -0600534 draw_clip_elements_to_mask_helper(helper, reducedClip.maskElements(), reducedClip.scissor(),
Brian Osman5d034742017-09-11 13:38:55 -0400535 reducedClip.initialState());
536
537 proxy = helper.toTextureProxy(context, SkBackingFit::kApprox);
538 }
539
540 SkASSERT(proxy->origin() == kTopLeft_GrSurfaceOrigin);
Robert Phillips1afd4cd2018-01-08 13:40:32 -0500541 proxyProvider->assignUniqueKeyToProxy(key, proxy.get());
Robert Phillips427966a2018-12-20 17:20:43 -0500542 add_invalidate_on_pop_message(context, *fStack, reducedClip.maskGenID(), key);
Brian Osman5d034742017-09-11 13:38:55 -0400543 return proxy;
robertphillips@google.com6b70a7b2012-05-11 15:32:48 +0000544}