123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373 |
- /*
- * Copyright 2017 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
- #include "src/gpu/ccpr/GrCoverageCountingPathRenderer.h"
- #include "include/pathops/SkPathOps.h"
- #include "src/core/SkMakeUnique.h"
- #include "src/gpu/GrCaps.h"
- #include "src/gpu/GrClip.h"
- #include "src/gpu/GrProxyProvider.h"
- #include "src/gpu/ccpr/GrCCClipProcessor.h"
- #include "src/gpu/ccpr/GrCCDrawPathsOp.h"
- #include "src/gpu/ccpr/GrCCPathCache.h"
- using PathInstance = GrCCPathProcessor::Instance;
- bool GrCoverageCountingPathRenderer::IsSupported(const GrCaps& caps, CoverageType* coverageType) {
- const GrShaderCaps& shaderCaps = *caps.shaderCaps();
- if (caps.driverBlacklistCCPR() || !shaderCaps.integerSupport() ||
- !caps.instanceAttribSupport() || !shaderCaps.floatIs32Bits() ||
- GrCaps::kNone_MapFlags == caps.mapBufferFlags() ||
- !caps.isConfigTexturable(kAlpha_8_GrPixelConfig) ||
- !caps.isConfigRenderable(kAlpha_8_GrPixelConfig) ||
- !caps.halfFloatVertexAttributeSupport()) {
- return false;
- }
- if (caps.allowCoverageCounting() &&
- caps.isConfigTexturable(kAlpha_half_GrPixelConfig) &&
- caps.isConfigRenderable(kAlpha_half_GrPixelConfig)) {
- if (coverageType) {
- *coverageType = CoverageType::kFP16_CoverageCount;
- }
- return true;
- }
- if (!caps.driverBlacklistMSAACCPR() &&
- caps.internalMultisampleCount(kAlpha_8_GrPixelConfig) > 1 &&
- caps.sampleLocationsSupport() &&
- shaderCaps.sampleVariablesStencilSupport()) {
- if (coverageType) {
- *coverageType = CoverageType::kA8_Multisample;
- }
- return true;
- }
- return false;
- }
- sk_sp<GrCoverageCountingPathRenderer> GrCoverageCountingPathRenderer::CreateIfSupported(
- const GrCaps& caps, AllowCaching allowCaching, uint32_t contextUniqueID) {
- CoverageType coverageType;
- if (IsSupported(caps, &coverageType)) {
- return sk_sp<GrCoverageCountingPathRenderer>(new GrCoverageCountingPathRenderer(
- coverageType, allowCaching, contextUniqueID));
- }
- return nullptr;
- }
- GrCoverageCountingPathRenderer::GrCoverageCountingPathRenderer(
- CoverageType coverageType, AllowCaching allowCaching, uint32_t contextUniqueID)
- : fCoverageType(coverageType) {
- if (AllowCaching::kYes == allowCaching) {
- fPathCache = skstd::make_unique<GrCCPathCache>(contextUniqueID);
- }
- }
- GrCCPerOpListPaths* GrCoverageCountingPathRenderer::lookupPendingPaths(uint32_t opListID) {
- auto it = fPendingPaths.find(opListID);
- if (fPendingPaths.end() == it) {
- sk_sp<GrCCPerOpListPaths> paths = sk_make_sp<GrCCPerOpListPaths>();
- it = fPendingPaths.insert(std::make_pair(opListID, std::move(paths))).first;
- }
- return it->second.get();
- }
- GrPathRenderer::CanDrawPath GrCoverageCountingPathRenderer::onCanDrawPath(
- const CanDrawPathArgs& args) const {
- const GrShape& shape = *args.fShape;
- // We use "kCoverage", or analytic AA, no mater what the coverage type of our atlas: Even if the
- // atlas is multisampled, that resolves into analytic coverage before we draw the path to the
- // main canvas.
- if (GrAAType::kCoverage != args.fAAType || shape.style().hasPathEffect() ||
- args.fViewMatrix->hasPerspective() || shape.inverseFilled()) {
- return CanDrawPath::kNo;
- }
- SkPath path;
- shape.asPath(&path);
- const SkStrokeRec& stroke = shape.style().strokeRec();
- switch (stroke.getStyle()) {
- case SkStrokeRec::kFill_Style: {
- SkRect devBounds;
- args.fViewMatrix->mapRect(&devBounds, path.getBounds());
- SkIRect clippedIBounds;
- devBounds.roundOut(&clippedIBounds);
- if (!clippedIBounds.intersect(*args.fClipConservativeBounds)) {
- // The path is completely clipped away. Our code will eventually notice this before
- // doing any real work.
- return CanDrawPath::kYes;
- }
- int64_t numPixels = sk_64_mul(clippedIBounds.height(), clippedIBounds.width());
- if (path.countVerbs() > 1000 && path.countPoints() > numPixels) {
- // This is a complicated path that has more vertices than pixels! Let's let the SW
- // renderer have this one: It will probably be faster and a bitmap will require less
- // total memory on the GPU than CCPR instance buffers would for the raw path data.
- return CanDrawPath::kNo;
- }
- if (numPixels > 256 * 256) {
- // Large paths can blow up the atlas fast. And they are not ideal for a two-pass
- // rendering algorithm. Give the simpler direct renderers a chance before we commit
- // to drawing it.
- return CanDrawPath::kAsBackup;
- }
- if (args.fShape->hasUnstyledKey() && path.countVerbs() > 50) {
- // Complex paths do better cached in an SDF, if the renderer will accept them.
- return CanDrawPath::kAsBackup;
- }
- return CanDrawPath::kYes;
- }
- case SkStrokeRec::kStroke_Style:
- if (!args.fViewMatrix->isSimilarity()) {
- // The stroker currently only supports rigid-body transfoms for the stroke lines
- // themselves. This limitation doesn't affect hairlines since their stroke lines are
- // defined relative to device space.
- return CanDrawPath::kNo;
- }
- // fallthru
- case SkStrokeRec::kHairline_Style: {
- if (CoverageType::kFP16_CoverageCount != fCoverageType) {
- // Stroking is not yet supported in MSAA atlas mode.
- return CanDrawPath::kNo;
- }
- float inflationRadius;
- GetStrokeDevWidth(*args.fViewMatrix, stroke, &inflationRadius);
- if (!(inflationRadius <= kMaxBoundsInflationFromStroke)) {
- // Let extremely wide strokes be converted to fill paths and drawn by the CCPR
- // filler instead. (Cast the logic negatively in order to also catch r=NaN.)
- return CanDrawPath::kNo;
- }
- SkASSERT(!SkScalarIsNaN(inflationRadius));
- if (SkPathPriv::ConicWeightCnt(path)) {
- // The stroker does not support conics yet.
- return CanDrawPath::kNo;
- }
- return CanDrawPath::kYes;
- }
- case SkStrokeRec::kStrokeAndFill_Style:
- return CanDrawPath::kNo;
- }
- SK_ABORT("Invalid stroke style.");
- return CanDrawPath::kNo;
- }
- bool GrCoverageCountingPathRenderer::onDrawPath(const DrawPathArgs& args) {
- SkASSERT(!fFlushing);
- SkIRect clipIBounds;
- GrRenderTargetContext* rtc = args.fRenderTargetContext;
- args.fClip->getConservativeBounds(rtc->width(), rtc->height(), &clipIBounds, nullptr);
- auto op = GrCCDrawPathsOp::Make(args.fContext, clipIBounds, *args.fViewMatrix, *args.fShape,
- std::move(args.fPaint));
- this->recordOp(std::move(op), args);
- return true;
- }
- void GrCoverageCountingPathRenderer::recordOp(std::unique_ptr<GrCCDrawPathsOp> op,
- const DrawPathArgs& args) {
- if (op) {
- auto addToOwningPerOpListPaths = [this](GrOp* op, uint32_t opListID) {
- op->cast<GrCCDrawPathsOp>()->addToOwningPerOpListPaths(
- sk_ref_sp(this->lookupPendingPaths(opListID)));
- };
- args.fRenderTargetContext->addDrawOp(*args.fClip, std::move(op), addToOwningPerOpListPaths);
- }
- }
- std::unique_ptr<GrFragmentProcessor> GrCoverageCountingPathRenderer::makeClipProcessor(
- uint32_t opListID, const SkPath& deviceSpacePath, const SkIRect& accessRect,
- const GrCaps& caps) {
- SkASSERT(!fFlushing);
- uint32_t key = deviceSpacePath.getGenerationID();
- if (CoverageType::kA8_Multisample == fCoverageType) {
- // We only need to consider fill rule in MSAA mode. In coverage count mode Even/Odd and
- // Nonzero both reference the same coverage count mask.
- key = (key << 1) | (uint32_t)GrFillRuleForSkPath(deviceSpacePath);
- }
- GrCCClipPath& clipPath =
- this->lookupPendingPaths(opListID)->fClipPaths[key];
- if (!clipPath.isInitialized()) {
- // This ClipPath was just created during lookup. Initialize it.
- const SkRect& pathDevBounds = deviceSpacePath.getBounds();
- if (SkTMax(pathDevBounds.height(), pathDevBounds.width()) > kPathCropThreshold) {
- // The path is too large. Crop it or analytic AA can run out of fp32 precision.
- SkPath croppedPath;
- int maxRTSize = caps.maxRenderTargetSize();
- CropPath(deviceSpacePath, SkIRect::MakeWH(maxRTSize, maxRTSize), &croppedPath);
- clipPath.init(croppedPath, accessRect, fCoverageType, caps);
- } else {
- clipPath.init(deviceSpacePath, accessRect, fCoverageType, caps);
- }
- } else {
- clipPath.addAccess(accessRect);
- }
- auto isCoverageCount = GrCCClipProcessor::IsCoverageCount(
- CoverageType::kFP16_CoverageCount == fCoverageType);
- auto mustCheckBounds = GrCCClipProcessor::MustCheckBounds(
- !clipPath.pathDevIBounds().contains(accessRect));
- return skstd::make_unique<GrCCClipProcessor>(&clipPath, isCoverageCount, mustCheckBounds);
- }
- void GrCoverageCountingPathRenderer::preFlush(GrOnFlushResourceProvider* onFlushRP,
- const uint32_t* opListIDs, int numOpListIDs,
- SkTArray<sk_sp<GrRenderTargetContext>>* out) {
- using DoCopiesToA8Coverage = GrCCDrawPathsOp::DoCopiesToA8Coverage;
- SkASSERT(!fFlushing);
- SkASSERT(fFlushingPaths.empty());
- SkDEBUGCODE(fFlushing = true);
- if (fPathCache) {
- fPathCache->doPreFlushProcessing();
- }
- if (fPendingPaths.empty()) {
- return; // Nothing to draw.
- }
- GrCCPerFlushResourceSpecs specs;
- int maxPreferredRTSize = onFlushRP->caps()->maxPreferredRenderTargetSize();
- specs.fCopyAtlasSpecs.fMaxPreferredTextureSize = SkTMin(2048, maxPreferredRTSize);
- SkASSERT(0 == specs.fCopyAtlasSpecs.fMinTextureSize);
- specs.fRenderedAtlasSpecs.fMaxPreferredTextureSize = maxPreferredRTSize;
- specs.fRenderedAtlasSpecs.fMinTextureSize = SkTMin(512, maxPreferredRTSize);
- // Move the per-opList paths that are about to be flushed from fPendingPaths to fFlushingPaths,
- // and count them up so we can preallocate buffers.
- fFlushingPaths.reserve(numOpListIDs);
- for (int i = 0; i < numOpListIDs; ++i) {
- auto iter = fPendingPaths.find(opListIDs[i]);
- if (fPendingPaths.end() == iter) {
- continue; // No paths on this opList.
- }
- fFlushingPaths.push_back(std::move(iter->second));
- fPendingPaths.erase(iter);
- for (GrCCDrawPathsOp* op : fFlushingPaths.back()->fDrawOps) {
- op->accountForOwnPaths(fPathCache.get(), onFlushRP, &specs);
- }
- for (const auto& clipsIter : fFlushingPaths.back()->fClipPaths) {
- clipsIter.second.accountForOwnPath(&specs);
- }
- }
- if (specs.isEmpty()) {
- return; // Nothing to draw.
- }
- // Determine if there are enough reusable paths from last flush for it to be worth our time to
- // copy them to cached atlas(es).
- int numCopies = specs.fNumCopiedPaths[GrCCPerFlushResourceSpecs::kFillIdx] +
- specs.fNumCopiedPaths[GrCCPerFlushResourceSpecs::kStrokeIdx];
- auto doCopies = DoCopiesToA8Coverage(numCopies > 100 ||
- specs.fCopyAtlasSpecs.fApproxNumPixels > 256 * 256);
- if (numCopies && DoCopiesToA8Coverage::kNo == doCopies) {
- specs.cancelCopies();
- }
- auto resources = sk_make_sp<GrCCPerFlushResources>(onFlushRP, fCoverageType, specs);
- if (!resources->isMapped()) {
- return; // Some allocation failed.
- }
- // Layout the atlas(es) and parse paths.
- for (const auto& flushingPaths : fFlushingPaths) {
- for (GrCCDrawPathsOp* op : flushingPaths->fDrawOps) {
- op->setupResources(fPathCache.get(), onFlushRP, resources.get(), doCopies);
- }
- for (auto& clipsIter : flushingPaths->fClipPaths) {
- clipsIter.second.renderPathInAtlas(resources.get(), onFlushRP);
- }
- }
- if (fPathCache) {
- // Purge invalidated textures from previous atlases *before* calling finalize(). That way,
- // the underlying textures objects can be freed up and reused for the next atlases.
- fPathCache->purgeInvalidatedAtlasTextures(onFlushRP);
- }
- // Allocate resources and then render the atlas(es).
- if (!resources->finalize(onFlushRP, out)) {
- return;
- }
- // Commit flushing paths to the resources once they are successfully completed.
- for (auto& flushingPaths : fFlushingPaths) {
- SkASSERT(!flushingPaths->fFlushResources);
- flushingPaths->fFlushResources = resources;
- }
- }
- void GrCoverageCountingPathRenderer::postFlush(GrDeferredUploadToken, const uint32_t* opListIDs,
- int numOpListIDs) {
- SkASSERT(fFlushing);
- if (!fFlushingPaths.empty()) {
- // In DDL mode these aren't guaranteed to be deleted so we must clear out the perFlush
- // resources manually.
- for (auto& flushingPaths : fFlushingPaths) {
- flushingPaths->fFlushResources = nullptr;
- }
- // We wait to erase these until after flush, once Ops and FPs are done accessing their data.
- fFlushingPaths.reset();
- }
- SkDEBUGCODE(fFlushing = false);
- }
- void GrCoverageCountingPathRenderer::purgeCacheEntriesOlderThan(
- GrProxyProvider* proxyProvider, const GrStdSteadyClock::time_point& purgeTime) {
- if (fPathCache) {
- fPathCache->purgeEntriesOlderThan(proxyProvider, purgeTime);
- }
- }
- void GrCoverageCountingPathRenderer::CropPath(const SkPath& path, const SkIRect& cropbox,
- SkPath* out) {
- SkPath cropboxPath;
- cropboxPath.addRect(SkRect::Make(cropbox));
- if (!Op(cropboxPath, path, kIntersect_SkPathOp, out)) {
- // This can fail if the PathOps encounter NaN or infinities.
- out->reset();
- }
- out->setIsVolatile(true);
- }
- float GrCoverageCountingPathRenderer::GetStrokeDevWidth(const SkMatrix& m,
- const SkStrokeRec& stroke,
- float* inflationRadius) {
- float strokeDevWidth;
- if (stroke.isHairlineStyle()) {
- strokeDevWidth = 1;
- } else {
- SkASSERT(SkStrokeRec::kStroke_Style == stroke.getStyle());
- SkASSERT(m.isSimilarity()); // Otherwise matrixScaleFactor = m.getMaxScale().
- float matrixScaleFactor = SkVector::Length(m.getScaleX(), m.getSkewY());
- strokeDevWidth = stroke.getWidth() * matrixScaleFactor;
- }
- if (inflationRadius) {
- // Inflate for a minimum stroke width of 1. In some cases when the stroke is less than 1px
- // wide, we may inflate it to 1px and instead reduce the opacity.
- *inflationRadius = SkStrokeRec::GetInflationRadius(
- stroke.getJoin(), stroke.getMiter(), stroke.getCap(), SkTMax(strokeDevWidth, 1.f));
- }
- return strokeDevWidth;
- }
|