1 /*
2 * Copyright 2018 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 "GrCCDrawPathsOp.h"
9
10 #include "GrContext.h"
11 #include "GrContextPriv.h"
12 #include "GrMemoryPool.h"
13 #include "GrOpFlushState.h"
14 #include "ccpr/GrCCPathCache.h"
15 #include "ccpr/GrCCPerFlushResources.h"
16 #include "ccpr/GrCoverageCountingPathRenderer.h"
17
has_coord_transforms(const GrPaint & paint)18 static bool has_coord_transforms(const GrPaint& paint) {
19 GrFragmentProcessor::Iter iter(paint);
20 while (const GrFragmentProcessor* fp = iter.next()) {
21 if (!fp->coordTransforms().empty()) {
22 return true;
23 }
24 }
25 return false;
26 }
27
Make(GrContext * context,const SkIRect & clipIBounds,const SkMatrix & m,const GrShape & shape,GrPaint && paint)28 std::unique_ptr<GrCCDrawPathsOp> GrCCDrawPathsOp::Make(
29 GrContext* context, const SkIRect& clipIBounds, const SkMatrix& m, const GrShape& shape,
30 GrPaint&& paint) {
31 SkRect conservativeDevBounds;
32 m.mapRect(&conservativeDevBounds, shape.bounds());
33
34 const SkStrokeRec& stroke = shape.style().strokeRec();
35 float strokeDevWidth = 0;
36 float conservativeInflationRadius = 0;
37 if (!stroke.isFillStyle()) {
38 strokeDevWidth = GrCoverageCountingPathRenderer::GetStrokeDevWidth(
39 m, stroke, &conservativeInflationRadius);
40 conservativeDevBounds.outset(conservativeInflationRadius, conservativeInflationRadius);
41 }
42
43 std::unique_ptr<GrCCDrawPathsOp> op;
44 float conservativeSize = SkTMax(conservativeDevBounds.height(), conservativeDevBounds.width());
45 if (conservativeSize > GrCoverageCountingPathRenderer::kPathCropThreshold) {
46 // The path is too large. Crop it or analytic AA can run out of fp32 precision.
47 SkPath croppedDevPath;
48 shape.asPath(&croppedDevPath);
49 croppedDevPath.transform(m, &croppedDevPath);
50
51 SkIRect cropBox = clipIBounds;
52 GrShape croppedDevShape;
53 if (stroke.isFillStyle()) {
54 GrCoverageCountingPathRenderer::CropPath(croppedDevPath, cropBox, &croppedDevPath);
55 croppedDevShape = GrShape(croppedDevPath);
56 conservativeDevBounds = croppedDevShape.bounds();
57 } else {
58 int r = SkScalarCeilToInt(conservativeInflationRadius);
59 cropBox.outset(r, r);
60 GrCoverageCountingPathRenderer::CropPath(croppedDevPath, cropBox, &croppedDevPath);
61 SkStrokeRec devStroke = stroke;
62 devStroke.setStrokeStyle(strokeDevWidth);
63 croppedDevShape = GrShape(croppedDevPath, GrStyle(devStroke, nullptr));
64 conservativeDevBounds = croppedDevPath.getBounds();
65 conservativeDevBounds.outset(conservativeInflationRadius, conservativeInflationRadius);
66 }
67
68 // FIXME: This breaks local coords: http://skbug.com/8003
69 return InternalMake(context, clipIBounds, SkMatrix::I(), croppedDevShape, strokeDevWidth,
70 conservativeDevBounds, std::move(paint));
71 }
72
73 return InternalMake(context, clipIBounds, m, shape, strokeDevWidth, conservativeDevBounds,
74 std::move(paint));
75 }
76
InternalMake(GrContext * context,const SkIRect & clipIBounds,const SkMatrix & m,const GrShape & shape,float strokeDevWidth,const SkRect & conservativeDevBounds,GrPaint && paint)77 std::unique_ptr<GrCCDrawPathsOp> GrCCDrawPathsOp::InternalMake(
78 GrContext* context, const SkIRect& clipIBounds, const SkMatrix& m, const GrShape& shape,
79 float strokeDevWidth, const SkRect& conservativeDevBounds, GrPaint&& paint) {
80 // The path itself should have been cropped if larger than kPathCropThreshold. If it had a
81 // stroke, that would have further inflated its draw bounds.
82 SkASSERT(SkTMax(conservativeDevBounds.height(), conservativeDevBounds.width()) <
83 GrCoverageCountingPathRenderer::kPathCropThreshold +
84 GrCoverageCountingPathRenderer::kMaxBoundsInflationFromStroke*2 + 1);
85
86 SkIRect shapeConservativeIBounds;
87 conservativeDevBounds.roundOut(&shapeConservativeIBounds);
88
89 SkIRect maskDevIBounds;
90 if (!maskDevIBounds.intersect(clipIBounds, shapeConservativeIBounds)) {
91 return nullptr;
92 }
93
94 GrOpMemoryPool* pool = context->contextPriv().opMemoryPool();
95 return pool->allocate<GrCCDrawPathsOp>(m, shape, strokeDevWidth, shapeConservativeIBounds,
96 maskDevIBounds, conservativeDevBounds, std::move(paint));
97 }
98
GrCCDrawPathsOp(const SkMatrix & m,const GrShape & shape,float strokeDevWidth,const SkIRect & shapeConservativeIBounds,const SkIRect & maskDevIBounds,const SkRect & conservativeDevBounds,GrPaint && paint)99 GrCCDrawPathsOp::GrCCDrawPathsOp(const SkMatrix& m, const GrShape& shape, float strokeDevWidth,
100 const SkIRect& shapeConservativeIBounds,
101 const SkIRect& maskDevIBounds, const SkRect& conservativeDevBounds,
102 GrPaint&& paint)
103 : GrDrawOp(ClassID())
104 , fViewMatrixIfUsingLocalCoords(has_coord_transforms(paint) ? m : SkMatrix::I())
105 , fDraws(m, shape, strokeDevWidth, shapeConservativeIBounds, maskDevIBounds,
106 paint.getColor4f())
107 , fProcessors(std::move(paint)) { // Paint must be moved after fetching its color above.
108 SkDEBUGCODE(fBaseInstance = -1);
109 // FIXME: intersect with clip bounds to (hopefully) improve batching.
110 // (This is nontrivial due to assumptions in generating the octagon cover geometry.)
111 this->setBounds(conservativeDevBounds, GrOp::HasAABloat::kYes, GrOp::IsZeroArea::kNo);
112 }
113
~GrCCDrawPathsOp()114 GrCCDrawPathsOp::~GrCCDrawPathsOp() {
115 if (fOwningPerOpListPaths) {
116 // Remove the list's dangling pointer to this Op before deleting it.
117 fOwningPerOpListPaths->fDrawOps.remove(this);
118 }
119 }
120
SingleDraw(const SkMatrix & m,const GrShape & shape,float strokeDevWidth,const SkIRect & shapeConservativeIBounds,const SkIRect & maskDevIBounds,const SkPMColor4f & color)121 GrCCDrawPathsOp::SingleDraw::SingleDraw(const SkMatrix& m, const GrShape& shape,
122 float strokeDevWidth,
123 const SkIRect& shapeConservativeIBounds,
124 const SkIRect& maskDevIBounds, const SkPMColor4f& color)
125 : fMatrix(m)
126 , fShape(shape)
127 , fStrokeDevWidth(strokeDevWidth)
128 , fShapeConservativeIBounds(shapeConservativeIBounds)
129 , fMaskDevIBounds(maskDevIBounds)
130 , fColor(color) {
131 #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
132 if (fShape.hasUnstyledKey()) {
133 // On AOSP we round view matrix translates to integer values for cachable paths. We do this
134 // to match HWUI's cache hit ratio, which doesn't consider the matrix when caching paths.
135 fMatrix.setTranslateX(SkScalarRoundToScalar(fMatrix.getTranslateX()));
136 fMatrix.setTranslateY(SkScalarRoundToScalar(fMatrix.getTranslateY()));
137 }
138 #endif
139 }
140
finalize(const GrCaps & caps,const GrAppliedClip * clip)141 GrProcessorSet::Analysis GrCCDrawPathsOp::finalize(const GrCaps& caps, const GrAppliedClip* clip) {
142 SkASSERT(1 == fNumDraws); // There should only be one single path draw in this Op right now.
143 return fDraws.head().finalize(caps, clip, &fProcessors);
144 }
145
finalize(const GrCaps & caps,const GrAppliedClip * clip,GrProcessorSet * processors)146 GrProcessorSet::Analysis GrCCDrawPathsOp::SingleDraw::finalize(
147 const GrCaps& caps, const GrAppliedClip* clip, GrProcessorSet* processors) {
148 const GrProcessorSet::Analysis& analysis = processors->finalize(
149 fColor, GrProcessorAnalysisCoverage::kSingleChannel, clip, false, caps,
150 &fColor);
151
152 // Lines start looking jagged when they get thinner than 1px. For thin strokes it looks better
153 // if we can convert them to hairline (i.e., inflate the stroke width to 1px), and instead
154 // reduce the opacity to create the illusion of thin-ness. This strategy also helps reduce
155 // artifacts from coverage dilation when there are self intersections.
156 if (analysis.isCompatibleWithCoverageAsAlpha() &&
157 !fShape.style().strokeRec().isFillStyle() && fStrokeDevWidth < 1) {
158 // Modifying the shape affects its cache key. The draw can't have a cache entry yet or else
159 // our next step would invalidate it.
160 SkASSERT(!fCacheEntry);
161 SkASSERT(SkStrokeRec::kStroke_Style == fShape.style().strokeRec().getStyle());
162
163 SkPath path;
164 fShape.asPath(&path);
165
166 // Create a hairline version of our stroke.
167 SkStrokeRec hairlineStroke = fShape.style().strokeRec();
168 hairlineStroke.setStrokeStyle(0);
169
170 // How transparent does a 1px stroke have to be in order to appear as thin as the real one?
171 float coverage = fStrokeDevWidth;
172
173 fShape = GrShape(path, GrStyle(hairlineStroke, nullptr));
174 fStrokeDevWidth = 1;
175
176 // fShapeConservativeIBounds already accounted for this possibility of inflating the stroke.
177 fColor = fColor * coverage;
178 }
179
180 return analysis;
181 }
182
onCombineIfPossible(GrOp * op,const GrCaps &)183 GrOp::CombineResult GrCCDrawPathsOp::onCombineIfPossible(GrOp* op, const GrCaps&) {
184 GrCCDrawPathsOp* that = op->cast<GrCCDrawPathsOp>();
185 SkASSERT(fOwningPerOpListPaths);
186 SkASSERT(fNumDraws);
187 SkASSERT(!that->fOwningPerOpListPaths || that->fOwningPerOpListPaths == fOwningPerOpListPaths);
188 SkASSERT(that->fNumDraws);
189
190 if (fProcessors != that->fProcessors ||
191 fViewMatrixIfUsingLocalCoords != that->fViewMatrixIfUsingLocalCoords) {
192 return CombineResult::kCannotCombine;
193 }
194
195 fDraws.append(std::move(that->fDraws), &fOwningPerOpListPaths->fAllocator);
196
197 SkDEBUGCODE(fNumDraws += that->fNumDraws);
198 SkDEBUGCODE(that->fNumDraws = 0);
199 return CombineResult::kMerged;
200 }
201
addToOwningPerOpListPaths(sk_sp<GrCCPerOpListPaths> owningPerOpListPaths)202 void GrCCDrawPathsOp::addToOwningPerOpListPaths(sk_sp<GrCCPerOpListPaths> owningPerOpListPaths) {
203 SkASSERT(1 == fNumDraws);
204 SkASSERT(!fOwningPerOpListPaths);
205 fOwningPerOpListPaths = std::move(owningPerOpListPaths);
206 fOwningPerOpListPaths->fDrawOps.addToTail(this);
207 }
208
accountForOwnPaths(GrCCPathCache * pathCache,GrOnFlushResourceProvider * onFlushRP,GrCCPerFlushResourceSpecs * specs)209 void GrCCDrawPathsOp::accountForOwnPaths(GrCCPathCache* pathCache,
210 GrOnFlushResourceProvider* onFlushRP,
211 GrCCPerFlushResourceSpecs* specs) {
212 for (SingleDraw& draw : fDraws) {
213 draw.accountForOwnPath(pathCache, onFlushRP, specs);
214 }
215 }
216
accountForOwnPath(GrCCPathCache * pathCache,GrOnFlushResourceProvider * onFlushRP,GrCCPerFlushResourceSpecs * specs)217 void GrCCDrawPathsOp::SingleDraw::accountForOwnPath(
218 GrCCPathCache* pathCache, GrOnFlushResourceProvider* onFlushRP,
219 GrCCPerFlushResourceSpecs* specs) {
220 using CoverageType = GrCCAtlas::CoverageType;
221
222 SkPath path;
223 fShape.asPath(&path);
224
225 SkASSERT(!fCacheEntry);
226
227 if (pathCache) {
228 fCacheEntry =
229 pathCache->find(onFlushRP, fShape, fMaskDevIBounds, fMatrix, &fCachedMaskShift);
230 }
231
232 if (fCacheEntry) {
233 if (const GrCCCachedAtlas* cachedAtlas = fCacheEntry->cachedAtlas()) {
234 SkASSERT(cachedAtlas->getOnFlushProxy());
235 if (CoverageType::kA8_LiteralCoverage == cachedAtlas->coverageType()) {
236 ++specs->fNumCachedPaths;
237 } else {
238 // Suggest that this path be copied to a literal coverage atlas, to save memory.
239 // (The client may decline this copy via DoCopiesToA8Coverage::kNo.)
240 int idx = (fShape.style().strokeRec().isFillStyle())
241 ? GrCCPerFlushResourceSpecs::kFillIdx
242 : GrCCPerFlushResourceSpecs::kStrokeIdx;
243 ++specs->fNumCopiedPaths[idx];
244 specs->fCopyPathStats[idx].statPath(path);
245 specs->fCopyAtlasSpecs.accountForSpace(fCacheEntry->width(), fCacheEntry->height());
246 fDoCopyToA8Coverage = true;
247 }
248 return;
249 }
250
251 if (this->shouldCachePathMask(onFlushRP->caps()->maxRenderTargetSize())) {
252 fDoCachePathMask = true;
253 // We don't cache partial masks; ensure the bounds include the entire path.
254 fMaskDevIBounds = fShapeConservativeIBounds;
255 }
256 }
257
258 // Plan on rendering this path in a new atlas.
259 int idx = (fShape.style().strokeRec().isFillStyle())
260 ? GrCCPerFlushResourceSpecs::kFillIdx
261 : GrCCPerFlushResourceSpecs::kStrokeIdx;
262 ++specs->fNumRenderedPaths[idx];
263 specs->fRenderedPathStats[idx].statPath(path);
264 specs->fRenderedAtlasSpecs.accountForSpace(fMaskDevIBounds.width(), fMaskDevIBounds.height());
265 }
266
shouldCachePathMask(int maxRenderTargetSize) const267 bool GrCCDrawPathsOp::SingleDraw::shouldCachePathMask(int maxRenderTargetSize) const {
268 SkASSERT(fCacheEntry);
269 SkASSERT(!fCacheEntry->cachedAtlas());
270 if (fCacheEntry->hitCount() <= 1) {
271 return false; // Don't cache a path mask until at least its second hit.
272 }
273
274 int shapeMaxDimension = SkTMax(fShapeConservativeIBounds.height(),
275 fShapeConservativeIBounds.width());
276 if (shapeMaxDimension > maxRenderTargetSize) {
277 return false; // This path isn't cachable.
278 }
279
280 int64_t shapeArea = sk_64_mul(fShapeConservativeIBounds.height(),
281 fShapeConservativeIBounds.width());
282 if (shapeArea < 100*100) {
283 // If a path is small enough, we might as well try to render and cache the entire thing, no
284 // matter how much of it is actually visible.
285 return true;
286 }
287
288 // The hitRect should already be contained within the shape's bounds, but we still intersect it
289 // because it's possible for edges very near pixel boundaries (e.g., 0.999999), to round out
290 // inconsistently, depending on the integer translation values and fp32 precision.
291 SkIRect hitRect = fCacheEntry->hitRect().makeOffset(fCachedMaskShift.x(), fCachedMaskShift.y());
292 hitRect.intersect(fShapeConservativeIBounds);
293
294 // Render and cache the entire path mask if we see enough of it to justify rendering all the
295 // pixels. Our criteria for "enough" is that we must have seen at least 50% of the path in the
296 // past, and in this particular draw we must see at least 10% of it.
297 int64_t hitArea = sk_64_mul(hitRect.height(), hitRect.width());
298 int64_t drawArea = sk_64_mul(fMaskDevIBounds.height(), fMaskDevIBounds.width());
299 return hitArea*2 >= shapeArea && drawArea*10 >= shapeArea;
300 }
301
setupResources(GrCCPathCache * pathCache,GrOnFlushResourceProvider * onFlushRP,GrCCPerFlushResources * resources,DoCopiesToA8Coverage doCopies)302 void GrCCDrawPathsOp::setupResources(
303 GrCCPathCache* pathCache, GrOnFlushResourceProvider* onFlushRP,
304 GrCCPerFlushResources* resources, DoCopiesToA8Coverage doCopies) {
305 SkASSERT(fNumDraws > 0);
306 SkASSERT(-1 == fBaseInstance);
307 fBaseInstance = resources->nextPathInstanceIdx();
308
309 for (SingleDraw& draw : fDraws) {
310 draw.setupResources(pathCache, onFlushRP, resources, doCopies, this);
311 }
312
313 if (!fInstanceRanges.empty()) {
314 fInstanceRanges.back().fEndInstanceIdx = resources->nextPathInstanceIdx();
315 }
316 }
317
setupResources(GrCCPathCache * pathCache,GrOnFlushResourceProvider * onFlushRP,GrCCPerFlushResources * resources,DoCopiesToA8Coverage doCopies,GrCCDrawPathsOp * op)318 void GrCCDrawPathsOp::SingleDraw::setupResources(
319 GrCCPathCache* pathCache, GrOnFlushResourceProvider* onFlushRP,
320 GrCCPerFlushResources* resources, DoCopiesToA8Coverage doCopies, GrCCDrawPathsOp* op) {
321 using DoEvenOddFill = GrCCPathProcessor::DoEvenOddFill;
322
323 SkPath path;
324 fShape.asPath(&path);
325
326 auto doEvenOddFill = DoEvenOddFill(fShape.style().strokeRec().isFillStyle() &&
327 SkPath::kEvenOdd_FillType == path.getFillType());
328 SkASSERT(SkPath::kEvenOdd_FillType == path.getFillType() ||
329 SkPath::kWinding_FillType == path.getFillType());
330
331 if (fCacheEntry) {
332 // Does the path already exist in a cached atlas texture?
333 if (fCacheEntry->cachedAtlas()) {
334 SkASSERT(fCacheEntry->cachedAtlas()->getOnFlushProxy());
335 if (DoCopiesToA8Coverage::kYes == doCopies && fDoCopyToA8Coverage) {
336 resources->upgradeEntryToLiteralCoverageAtlas(pathCache, onFlushRP,
337 fCacheEntry.get(), doEvenOddFill);
338 SkASSERT(fCacheEntry->cachedAtlas());
339 SkASSERT(GrCCAtlas::CoverageType::kA8_LiteralCoverage
340 == fCacheEntry->cachedAtlas()->coverageType());
341 SkASSERT(fCacheEntry->cachedAtlas()->getOnFlushProxy());
342 }
343 #if 0
344 // Simple color manipulation to visualize cached paths.
345 fColor = (GrCCAtlas::CoverageType::kA8_LiteralCoverage
346 == fCacheEntry->cachedAtlas()->coverageType())
347 ? SkPMColor4f{0,0,.25,.25} : SkPMColor4f{0,.25,0,.25};
348 #endif
349 op->recordInstance(fCacheEntry->cachedAtlas()->getOnFlushProxy(),
350 resources->nextPathInstanceIdx());
351 resources->appendDrawPathInstance().set(*fCacheEntry, fCachedMaskShift,
352 SkPMColor4f_toFP16(fColor));
353 return;
354 }
355 }
356
357 // Render the raw path into a coverage count atlas. renderShapeInAtlas() gives us two tight
358 // bounding boxes: One in device space, as well as a second one rotated an additional 45
359 // degrees. The path vertex shader uses these two bounding boxes to generate an octagon that
360 // circumscribes the path.
361 SkRect devBounds, devBounds45;
362 SkIRect devIBounds;
363 SkIVector devToAtlasOffset;
364 if (auto atlas = resources->renderShapeInAtlas(
365 fMaskDevIBounds, fMatrix, fShape, fStrokeDevWidth, &devBounds, &devBounds45,
366 &devIBounds, &devToAtlasOffset)) {
367 op->recordInstance(atlas->textureProxy(), resources->nextPathInstanceIdx());
368 resources->appendDrawPathInstance().set(devBounds, devBounds45, devToAtlasOffset,
369 SkPMColor4f_toFP16(fColor), doEvenOddFill);
370
371 if (fDoCachePathMask) {
372 SkASSERT(fCacheEntry);
373 SkASSERT(!fCacheEntry->cachedAtlas());
374 SkASSERT(fShapeConservativeIBounds == fMaskDevIBounds);
375 fCacheEntry->setCoverageCountAtlas(onFlushRP, atlas, devToAtlasOffset, devBounds,
376 devBounds45, devIBounds, fCachedMaskShift);
377 }
378 }
379 }
380
recordInstance(GrTextureProxy * atlasProxy,int instanceIdx)381 inline void GrCCDrawPathsOp::recordInstance(GrTextureProxy* atlasProxy, int instanceIdx) {
382 if (fInstanceRanges.empty()) {
383 fInstanceRanges.push_back({atlasProxy, instanceIdx});
384 return;
385 }
386 if (fInstanceRanges.back().fAtlasProxy != atlasProxy) {
387 fInstanceRanges.back().fEndInstanceIdx = instanceIdx;
388 fInstanceRanges.push_back({atlasProxy, instanceIdx});
389 return;
390 }
391 }
392
onExecute(GrOpFlushState * flushState,const SkRect & chainBounds)393 void GrCCDrawPathsOp::onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) {
394 SkASSERT(fOwningPerOpListPaths);
395
396 const GrCCPerFlushResources* resources = fOwningPerOpListPaths->fFlushResources.get();
397 if (!resources) {
398 return; // Setup failed.
399 }
400
401 GrPipeline::InitArgs initArgs;
402 initArgs.fCaps = &flushState->caps();
403 initArgs.fResourceProvider = flushState->resourceProvider();
404 initArgs.fDstProxy = flushState->drawOpArgs().fDstProxy;
405 auto clip = flushState->detachAppliedClip();
406 GrPipeline::FixedDynamicState fixedDynamicState(clip.scissorState().rect());
407 GrPipeline pipeline(initArgs, std::move(fProcessors), std::move(clip));
408
409 int baseInstance = fBaseInstance;
410 SkASSERT(baseInstance >= 0); // Make sure setupResources() has been called.
411
412 for (const InstanceRange& range : fInstanceRanges) {
413 SkASSERT(range.fEndInstanceIdx > baseInstance);
414
415 GrCCPathProcessor pathProc(range.fAtlasProxy, fViewMatrixIfUsingLocalCoords);
416 GrTextureProxy* atlasProxy = range.fAtlasProxy;
417 fixedDynamicState.fPrimitiveProcessorTextures = &atlasProxy;
418 pathProc.drawPaths(flushState, pipeline, &fixedDynamicState, *resources, baseInstance,
419 range.fEndInstanceIdx, this->bounds());
420
421 baseInstance = range.fEndInstanceIdx;
422 }
423 }
424