| /* | |
| * Copyright 2018 Google Inc. | |
| * | |
| * Use of this source code is governed by a BSD-style license that can be | |
| * found in the LICENSE file. | |
| */ | |
| #include "GrCCDrawPathsOp.h" | |
| #include "GrMemoryPool.h" | |
| #include "GrOpFlushState.h" | |
| #include "GrRecordingContext.h" | |
| #include "GrRecordingContextPriv.h" | |
| #include "ccpr/GrCCPathCache.h" | |
| #include "ccpr/GrCCPerFlushResources.h" | |
| #include "ccpr/GrCoverageCountingPathRenderer.h" | |
| static bool has_coord_transforms(const GrPaint& paint) { | |
| GrFragmentProcessor::Iter iter(paint); | |
| while (const GrFragmentProcessor* fp = iter.next()) { | |
| if (!fp->coordTransforms().empty()) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| std::unique_ptr<GrCCDrawPathsOp> GrCCDrawPathsOp::Make( | |
| GrRecordingContext* context, const SkIRect& clipIBounds, const SkMatrix& m, | |
| const GrShape& shape, GrPaint&& paint) { | |
| SkRect conservativeDevBounds; | |
| m.mapRect(&conservativeDevBounds, shape.bounds()); | |
| const SkStrokeRec& stroke = shape.style().strokeRec(); | |
| float strokeDevWidth = 0; | |
| float conservativeInflationRadius = 0; | |
| if (!stroke.isFillStyle()) { | |
| strokeDevWidth = GrCoverageCountingPathRenderer::GetStrokeDevWidth( | |
| m, stroke, &conservativeInflationRadius); | |
| conservativeDevBounds.outset(conservativeInflationRadius, conservativeInflationRadius); | |
| } | |
| std::unique_ptr<GrCCDrawPathsOp> op; | |
| float conservativeSize = SkTMax(conservativeDevBounds.height(), conservativeDevBounds.width()); | |
| if (conservativeSize > GrCoverageCountingPathRenderer::kPathCropThreshold) { | |
| // The path is too large. Crop it or analytic AA can run out of fp32 precision. | |
| SkPath croppedDevPath; | |
| shape.asPath(&croppedDevPath); | |
| croppedDevPath.transform(m, &croppedDevPath); | |
| SkIRect cropBox = clipIBounds; | |
| GrShape croppedDevShape; | |
| if (stroke.isFillStyle()) { | |
| GrCoverageCountingPathRenderer::CropPath(croppedDevPath, cropBox, &croppedDevPath); | |
| croppedDevShape = GrShape(croppedDevPath); | |
| conservativeDevBounds = croppedDevShape.bounds(); | |
| } else { | |
| int r = SkScalarCeilToInt(conservativeInflationRadius); | |
| cropBox.outset(r, r); | |
| GrCoverageCountingPathRenderer::CropPath(croppedDevPath, cropBox, &croppedDevPath); | |
| SkStrokeRec devStroke = stroke; | |
| devStroke.setStrokeStyle(strokeDevWidth); | |
| croppedDevShape = GrShape(croppedDevPath, GrStyle(devStroke, nullptr)); | |
| conservativeDevBounds = croppedDevPath.getBounds(); | |
| conservativeDevBounds.outset(conservativeInflationRadius, conservativeInflationRadius); | |
| } | |
| // FIXME: This breaks local coords: http://skbug.com/8003 | |
| return InternalMake(context, clipIBounds, SkMatrix::I(), croppedDevShape, strokeDevWidth, | |
| conservativeDevBounds, std::move(paint)); | |
| } | |
| return InternalMake(context, clipIBounds, m, shape, strokeDevWidth, conservativeDevBounds, | |
| std::move(paint)); | |
| } | |
| std::unique_ptr<GrCCDrawPathsOp> GrCCDrawPathsOp::InternalMake( | |
| GrRecordingContext* context, const SkIRect& clipIBounds, const SkMatrix& m, | |
| const GrShape& shape, float strokeDevWidth, const SkRect& conservativeDevBounds, | |
| GrPaint&& paint) { | |
| // The path itself should have been cropped if larger than kPathCropThreshold. If it had a | |
| // stroke, that would have further inflated its draw bounds. | |
| SkASSERT(SkTMax(conservativeDevBounds.height(), conservativeDevBounds.width()) < | |
| GrCoverageCountingPathRenderer::kPathCropThreshold + | |
| GrCoverageCountingPathRenderer::kMaxBoundsInflationFromStroke*2 + 1); | |
| SkIRect shapeConservativeIBounds; | |
| conservativeDevBounds.roundOut(&shapeConservativeIBounds); | |
| SkIRect maskDevIBounds; | |
| if (!maskDevIBounds.intersect(clipIBounds, shapeConservativeIBounds)) { | |
| return nullptr; | |
| } | |
| GrOpMemoryPool* pool = context->priv().opMemoryPool(); | |
| return pool->allocate<GrCCDrawPathsOp>(m, shape, strokeDevWidth, shapeConservativeIBounds, | |
| maskDevIBounds, conservativeDevBounds, std::move(paint)); | |
| } | |
| GrCCDrawPathsOp::GrCCDrawPathsOp(const SkMatrix& m, const GrShape& shape, float strokeDevWidth, | |
| const SkIRect& shapeConservativeIBounds, | |
| const SkIRect& maskDevIBounds, const SkRect& conservativeDevBounds, | |
| GrPaint&& paint) | |
| : GrDrawOp(ClassID()) | |
| , fViewMatrixIfUsingLocalCoords(has_coord_transforms(paint) ? m : SkMatrix::I()) | |
| , fDraws(m, shape, strokeDevWidth, shapeConservativeIBounds, maskDevIBounds, | |
| paint.getColor4f()) | |
| , fProcessors(std::move(paint)) { // Paint must be moved after fetching its color above. | |
| SkDEBUGCODE(fBaseInstance = -1); | |
| // FIXME: intersect with clip bounds to (hopefully) improve batching. | |
| // (This is nontrivial due to assumptions in generating the octagon cover geometry.) | |
| this->setBounds(conservativeDevBounds, GrOp::HasAABloat::kYes, GrOp::IsZeroArea::kNo); | |
| } | |
| GrCCDrawPathsOp::~GrCCDrawPathsOp() { | |
| if (fOwningPerOpListPaths) { | |
| // Remove the list's dangling pointer to this Op before deleting it. | |
| fOwningPerOpListPaths->fDrawOps.remove(this); | |
| } | |
| } | |
| GrCCDrawPathsOp::SingleDraw::SingleDraw(const SkMatrix& m, const GrShape& shape, | |
| float strokeDevWidth, | |
| const SkIRect& shapeConservativeIBounds, | |
| const SkIRect& maskDevIBounds, const SkPMColor4f& color) | |
| : fMatrix(m) | |
| , fShape(shape) | |
| , fStrokeDevWidth(strokeDevWidth) | |
| , fShapeConservativeIBounds(shapeConservativeIBounds) | |
| , fMaskDevIBounds(maskDevIBounds) | |
| , fColor(color) { | |
| #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK | |
| if (fShape.hasUnstyledKey()) { | |
| // On AOSP we round view matrix translates to integer values for cachable paths. We do this | |
| // to match HWUI's cache hit ratio, which doesn't consider the matrix when caching paths. | |
| fMatrix.setTranslateX(SkScalarRoundToScalar(fMatrix.getTranslateX())); | |
| fMatrix.setTranslateY(SkScalarRoundToScalar(fMatrix.getTranslateY())); | |
| } | |
| #endif | |
| } | |
| GrProcessorSet::Analysis GrCCDrawPathsOp::finalize( | |
| const GrCaps& caps, const GrAppliedClip* clip, GrFSAAType fsaaType) { | |
| SkASSERT(1 == fNumDraws); // There should only be one single path draw in this Op right now. | |
| return fDraws.head().finalize(caps, clip, fsaaType, &fProcessors); | |
| } | |
| GrProcessorSet::Analysis GrCCDrawPathsOp::SingleDraw::finalize( | |
| const GrCaps& caps, const GrAppliedClip* clip, GrFSAAType fsaaType, | |
| GrProcessorSet* processors) { | |
| const GrProcessorSet::Analysis& analysis = processors->finalize( | |
| fColor, GrProcessorAnalysisCoverage::kSingleChannel, clip, | |
| &GrUserStencilSettings::kUnused, fsaaType, caps, &fColor); | |
| // Lines start looking jagged when they get thinner than 1px. For thin strokes it looks better | |
| // if we can convert them to hairline (i.e., inflate the stroke width to 1px), and instead | |
| // reduce the opacity to create the illusion of thin-ness. This strategy also helps reduce | |
| // artifacts from coverage dilation when there are self intersections. | |
| if (analysis.isCompatibleWithCoverageAsAlpha() && | |
| !fShape.style().strokeRec().isFillStyle() && fStrokeDevWidth < 1) { | |
| // Modifying the shape affects its cache key. The draw can't have a cache entry yet or else | |
| // our next step would invalidate it. | |
| SkASSERT(!fCacheEntry); | |
| SkASSERT(SkStrokeRec::kStroke_Style == fShape.style().strokeRec().getStyle()); | |
| SkPath path; | |
| fShape.asPath(&path); | |
| // Create a hairline version of our stroke. | |
| SkStrokeRec hairlineStroke = fShape.style().strokeRec(); | |
| hairlineStroke.setStrokeStyle(0); | |
| // How transparent does a 1px stroke have to be in order to appear as thin as the real one? | |
| float coverage = fStrokeDevWidth; | |
| fShape = GrShape(path, GrStyle(hairlineStroke, nullptr)); | |
| fStrokeDevWidth = 1; | |
| // fShapeConservativeIBounds already accounted for this possibility of inflating the stroke. | |
| fColor = fColor * coverage; | |
| } | |
| return analysis; | |
| } | |
| GrOp::CombineResult GrCCDrawPathsOp::onCombineIfPossible(GrOp* op, const GrCaps&) { | |
| GrCCDrawPathsOp* that = op->cast<GrCCDrawPathsOp>(); | |
| SkASSERT(fOwningPerOpListPaths); | |
| SkASSERT(fNumDraws); | |
| SkASSERT(!that->fOwningPerOpListPaths || that->fOwningPerOpListPaths == fOwningPerOpListPaths); | |
| SkASSERT(that->fNumDraws); | |
| if (fProcessors != that->fProcessors || | |
| fViewMatrixIfUsingLocalCoords != that->fViewMatrixIfUsingLocalCoords) { | |
| return CombineResult::kCannotCombine; | |
| } | |
| fDraws.append(std::move(that->fDraws), &fOwningPerOpListPaths->fAllocator); | |
| SkDEBUGCODE(fNumDraws += that->fNumDraws); | |
| SkDEBUGCODE(that->fNumDraws = 0); | |
| return CombineResult::kMerged; | |
| } | |
| void GrCCDrawPathsOp::addToOwningPerOpListPaths(sk_sp<GrCCPerOpListPaths> owningPerOpListPaths) { | |
| SkASSERT(1 == fNumDraws); | |
| SkASSERT(!fOwningPerOpListPaths); | |
| fOwningPerOpListPaths = std::move(owningPerOpListPaths); | |
| fOwningPerOpListPaths->fDrawOps.addToTail(this); | |
| } | |
| void GrCCDrawPathsOp::accountForOwnPaths(GrCCPathCache* pathCache, | |
| GrOnFlushResourceProvider* onFlushRP, | |
| GrCCPerFlushResourceSpecs* specs) { | |
| for (SingleDraw& draw : fDraws) { | |
| draw.accountForOwnPath(pathCache, onFlushRP, specs); | |
| } | |
| } | |
| void GrCCDrawPathsOp::SingleDraw::accountForOwnPath( | |
| GrCCPathCache* pathCache, GrOnFlushResourceProvider* onFlushRP, | |
| GrCCPerFlushResourceSpecs* specs) { | |
| using CoverageType = GrCCAtlas::CoverageType; | |
| SkPath path; | |
| fShape.asPath(&path); | |
| SkASSERT(!fCacheEntry); | |
| if (pathCache) { | |
| fCacheEntry = | |
| pathCache->find(onFlushRP, fShape, fMaskDevIBounds, fMatrix, &fCachedMaskShift); | |
| } | |
| if (fCacheEntry) { | |
| if (const GrCCCachedAtlas* cachedAtlas = fCacheEntry->cachedAtlas()) { | |
| SkASSERT(cachedAtlas->getOnFlushProxy()); | |
| if (CoverageType::kA8_LiteralCoverage == cachedAtlas->coverageType()) { | |
| ++specs->fNumCachedPaths; | |
| } else { | |
| // Suggest that this path be copied to a literal coverage atlas, to save memory. | |
| // (The client may decline this copy via DoCopiesToA8Coverage::kNo.) | |
| int idx = (fShape.style().strokeRec().isFillStyle()) | |
| ? GrCCPerFlushResourceSpecs::kFillIdx | |
| : GrCCPerFlushResourceSpecs::kStrokeIdx; | |
| ++specs->fNumCopiedPaths[idx]; | |
| specs->fCopyPathStats[idx].statPath(path); | |
| specs->fCopyAtlasSpecs.accountForSpace(fCacheEntry->width(), fCacheEntry->height()); | |
| fDoCopyToA8Coverage = true; | |
| } | |
| return; | |
| } | |
| if (this->shouldCachePathMask(onFlushRP->caps()->maxRenderTargetSize())) { | |
| fDoCachePathMask = true; | |
| // We don't cache partial masks; ensure the bounds include the entire path. | |
| fMaskDevIBounds = fShapeConservativeIBounds; | |
| } | |
| } | |
| // Plan on rendering this path in a new atlas. | |
| int idx = (fShape.style().strokeRec().isFillStyle()) | |
| ? GrCCPerFlushResourceSpecs::kFillIdx | |
| : GrCCPerFlushResourceSpecs::kStrokeIdx; | |
| ++specs->fNumRenderedPaths[idx]; | |
| specs->fRenderedPathStats[idx].statPath(path); | |
| specs->fRenderedAtlasSpecs.accountForSpace(fMaskDevIBounds.width(), fMaskDevIBounds.height()); | |
| } | |
| bool GrCCDrawPathsOp::SingleDraw::shouldCachePathMask(int maxRenderTargetSize) const { | |
| SkASSERT(fCacheEntry); | |
| SkASSERT(!fCacheEntry->cachedAtlas()); | |
| if (fCacheEntry->hitCount() <= 1) { | |
| return false; // Don't cache a path mask until at least its second hit. | |
| } | |
| int shapeMaxDimension = SkTMax(fShapeConservativeIBounds.height(), | |
| fShapeConservativeIBounds.width()); | |
| if (shapeMaxDimension > maxRenderTargetSize) { | |
| return false; // This path isn't cachable. | |
| } | |
| int64_t shapeArea = sk_64_mul(fShapeConservativeIBounds.height(), | |
| fShapeConservativeIBounds.width()); | |
| if (shapeArea < 100*100) { | |
| // If a path is small enough, we might as well try to render and cache the entire thing, no | |
| // matter how much of it is actually visible. | |
| return true; | |
| } | |
| // The hitRect should already be contained within the shape's bounds, but we still intersect it | |
| // because it's possible for edges very near pixel boundaries (e.g., 0.999999), to round out | |
| // inconsistently, depending on the integer translation values and fp32 precision. | |
| SkIRect hitRect = fCacheEntry->hitRect().makeOffset(fCachedMaskShift.x(), fCachedMaskShift.y()); | |
| hitRect.intersect(fShapeConservativeIBounds); | |
| // Render and cache the entire path mask if we see enough of it to justify rendering all the | |
| // pixels. Our criteria for "enough" is that we must have seen at least 50% of the path in the | |
| // past, and in this particular draw we must see at least 10% of it. | |
| int64_t hitArea = sk_64_mul(hitRect.height(), hitRect.width()); | |
| int64_t drawArea = sk_64_mul(fMaskDevIBounds.height(), fMaskDevIBounds.width()); | |
| return hitArea*2 >= shapeArea && drawArea*10 >= shapeArea; | |
| } | |
| void GrCCDrawPathsOp::setupResources( | |
| GrCCPathCache* pathCache, GrOnFlushResourceProvider* onFlushRP, | |
| GrCCPerFlushResources* resources, DoCopiesToA8Coverage doCopies) { | |
| SkASSERT(fNumDraws > 0); | |
| SkASSERT(-1 == fBaseInstance); | |
| fBaseInstance = resources->nextPathInstanceIdx(); | |
| for (SingleDraw& draw : fDraws) { | |
| draw.setupResources(pathCache, onFlushRP, resources, doCopies, this); | |
| } | |
| if (!fInstanceRanges.empty()) { | |
| fInstanceRanges.back().fEndInstanceIdx = resources->nextPathInstanceIdx(); | |
| } | |
| } | |
| void GrCCDrawPathsOp::SingleDraw::setupResources( | |
| GrCCPathCache* pathCache, GrOnFlushResourceProvider* onFlushRP, | |
| GrCCPerFlushResources* resources, DoCopiesToA8Coverage doCopies, GrCCDrawPathsOp* op) { | |
| using DoEvenOddFill = GrCCPathProcessor::DoEvenOddFill; | |
| SkPath path; | |
| fShape.asPath(&path); | |
| auto doEvenOddFill = DoEvenOddFill(fShape.style().strokeRec().isFillStyle() && | |
| SkPath::kEvenOdd_FillType == path.getFillType()); | |
| SkASSERT(SkPath::kEvenOdd_FillType == path.getFillType() || | |
| SkPath::kWinding_FillType == path.getFillType()); | |
| if (fCacheEntry) { | |
| // Does the path already exist in a cached atlas texture? | |
| if (fCacheEntry->cachedAtlas()) { | |
| SkASSERT(fCacheEntry->cachedAtlas()->getOnFlushProxy()); | |
| if (DoCopiesToA8Coverage::kYes == doCopies && fDoCopyToA8Coverage) { | |
| resources->upgradeEntryToLiteralCoverageAtlas(pathCache, onFlushRP, | |
| fCacheEntry.get(), doEvenOddFill); | |
| SkASSERT(fCacheEntry->cachedAtlas()); | |
| SkASSERT(GrCCAtlas::CoverageType::kA8_LiteralCoverage | |
| == fCacheEntry->cachedAtlas()->coverageType()); | |
| SkASSERT(fCacheEntry->cachedAtlas()->getOnFlushProxy()); | |
| } | |
| #if 0 | |
| // Simple color manipulation to visualize cached paths. | |
| fColor = (GrCCAtlas::CoverageType::kA8_LiteralCoverage | |
| == fCacheEntry->cachedAtlas()->coverageType()) | |
| ? SkPMColor4f{0,0,.25,.25} : SkPMColor4f{0,.25,0,.25}; | |
| #endif | |
| op->recordInstance(fCacheEntry->cachedAtlas()->getOnFlushProxy(), | |
| resources->nextPathInstanceIdx()); | |
| resources->appendDrawPathInstance().set(*fCacheEntry, fCachedMaskShift, | |
| SkPMColor4f_toFP16(fColor)); | |
| return; | |
| } | |
| } | |
| // Render the raw path into a coverage count atlas. renderShapeInAtlas() gives us two tight | |
| // bounding boxes: One in device space, as well as a second one rotated an additional 45 | |
| // degrees. The path vertex shader uses these two bounding boxes to generate an octagon that | |
| // circumscribes the path. | |
| SkRect devBounds, devBounds45; | |
| SkIRect devIBounds; | |
| SkIVector devToAtlasOffset; | |
| if (auto atlas = resources->renderShapeInAtlas( | |
| fMaskDevIBounds, fMatrix, fShape, fStrokeDevWidth, &devBounds, &devBounds45, | |
| &devIBounds, &devToAtlasOffset)) { | |
| op->recordInstance(atlas->textureProxy(), resources->nextPathInstanceIdx()); | |
| resources->appendDrawPathInstance().set(devBounds, devBounds45, devToAtlasOffset, | |
| SkPMColor4f_toFP16(fColor), doEvenOddFill); | |
| if (fDoCachePathMask) { | |
| SkASSERT(fCacheEntry); | |
| SkASSERT(!fCacheEntry->cachedAtlas()); | |
| SkASSERT(fShapeConservativeIBounds == fMaskDevIBounds); | |
| fCacheEntry->setCoverageCountAtlas(onFlushRP, atlas, devToAtlasOffset, devBounds, | |
| devBounds45, devIBounds, fCachedMaskShift); | |
| } | |
| } | |
| } | |
| inline void GrCCDrawPathsOp::recordInstance(GrTextureProxy* atlasProxy, int instanceIdx) { | |
| if (fInstanceRanges.empty()) { | |
| fInstanceRanges.push_back({atlasProxy, instanceIdx}); | |
| return; | |
| } | |
| if (fInstanceRanges.back().fAtlasProxy != atlasProxy) { | |
| fInstanceRanges.back().fEndInstanceIdx = instanceIdx; | |
| fInstanceRanges.push_back({atlasProxy, instanceIdx}); | |
| return; | |
| } | |
| } | |
| void GrCCDrawPathsOp::onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) { | |
| SkASSERT(fOwningPerOpListPaths); | |
| const GrCCPerFlushResources* resources = fOwningPerOpListPaths->fFlushResources.get(); | |
| if (!resources) { | |
| return; // Setup failed. | |
| } | |
| GrPipeline::InitArgs initArgs; | |
| initArgs.fCaps = &flushState->caps(); | |
| initArgs.fResourceProvider = flushState->resourceProvider(); | |
| initArgs.fDstProxy = flushState->drawOpArgs().fDstProxy; | |
| auto clip = flushState->detachAppliedClip(); | |
| GrPipeline::FixedDynamicState fixedDynamicState(clip.scissorState().rect()); | |
| GrPipeline pipeline(initArgs, std::move(fProcessors), std::move(clip)); | |
| int baseInstance = fBaseInstance; | |
| SkASSERT(baseInstance >= 0); // Make sure setupResources() has been called. | |
| for (const InstanceRange& range : fInstanceRanges) { | |
| SkASSERT(range.fEndInstanceIdx > baseInstance); | |
| GrCCPathProcessor pathProc(range.fAtlasProxy, fViewMatrixIfUsingLocalCoords); | |
| GrTextureProxy* atlasProxy = range.fAtlasProxy; | |
| fixedDynamicState.fPrimitiveProcessorTextures = &atlasProxy; | |
| pathProc.drawPaths(flushState, pipeline, &fixedDynamicState, *resources, baseInstance, | |
| range.fEndInstanceIdx, this->bounds()); | |
| baseInstance = range.fEndInstanceIdx; | |
| } | |
| } |