| /* |
| * Copyright 2015 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "GrDrawingManager.h" |
| #include "GrBackendSemaphore.h" |
| #include "GrContext.h" |
| #include "GrContextPriv.h" |
| #include "GrGpu.h" |
| #include "GrMemoryPool.h" |
| #include "GrOnFlushResourceProvider.h" |
| #include "GrOpList.h" |
| #include "GrRenderTargetContext.h" |
| #include "GrRenderTargetProxy.h" |
| #include "GrResourceAllocator.h" |
| #include "GrResourceProvider.h" |
| #include "GrSoftwarePathRenderer.h" |
| #include "GrSurfaceProxyPriv.h" |
| #include "GrTexture.h" |
| #include "GrTextureContext.h" |
| #include "GrTextureOpList.h" |
| #include "GrTexturePriv.h" |
| #include "GrTextureProxy.h" |
| #include "GrTextureProxyPriv.h" |
| #include "GrTracing.h" |
| #include "SkDeferredDisplayList.h" |
| #include "SkSurface_Gpu.h" |
| #include "SkTTopoSort.h" |
| #include "ccpr/GrCoverageCountingPathRenderer.h" |
| #include "text/GrTextContext.h" |
| |
| GrDrawingManager::OpListDAG::OpListDAG(bool explicitlyAllocating, |
| GrContextOptions::Enable sortOpLists) { |
| if (GrContextOptions::Enable::kNo == sortOpLists) { |
| fSortOpLists = false; |
| } else if (GrContextOptions::Enable::kYes == sortOpLists) { |
| fSortOpLists = true; |
| } else { |
| // By default we always enable sorting when we're explicitly allocating GPU resources |
| fSortOpLists = explicitlyAllocating; |
| } |
| } |
| |
| GrDrawingManager::OpListDAG::~OpListDAG() {} |
| |
| void GrDrawingManager::OpListDAG::gatherIDs(SkSTArray<8, uint32_t, true>* idArray) const { |
| idArray->reset(fOpLists.count()); |
| for (int i = 0; i < fOpLists.count(); ++i) { |
| if (fOpLists[i]) { |
| (*idArray)[i] = fOpLists[i]->uniqueID(); |
| } |
| } |
| } |
| |
| void GrDrawingManager::OpListDAG::reset() { |
| fOpLists.reset(); |
| } |
| |
| void GrDrawingManager::OpListDAG::removeOpList(int index) { |
| if (!fOpLists[index]->unique()) { |
| // TODO: Eventually this should be guaranteed unique: http://skbug.com/7111 |
| fOpLists[index]->endFlush(); |
| } |
| |
| fOpLists[index] = nullptr; |
| } |
| |
| void GrDrawingManager::OpListDAG::removeOpLists(int startIndex, int stopIndex) { |
| for (int i = startIndex; i < stopIndex; ++i) { |
| if (!fOpLists[i]) { |
| continue; |
| } |
| this->removeOpList(i); |
| } |
| } |
| |
| void GrDrawingManager::OpListDAG::add(sk_sp<GrOpList> opList) { |
| fOpLists.emplace_back(std::move(opList)); |
| } |
| |
| void GrDrawingManager::OpListDAG::add(const SkTArray<sk_sp<GrOpList>>& opLists) { |
| fOpLists.push_back_n(opLists.count(), opLists.begin()); |
| } |
| |
| void GrDrawingManager::OpListDAG::swap(SkTArray<sk_sp<GrOpList>>* opLists) { |
| SkASSERT(opLists->empty()); |
| opLists->swap(fOpLists); |
| } |
| |
| void GrDrawingManager::OpListDAG::prepForFlush() { |
| if (fSortOpLists) { |
| SkDEBUGCODE(bool result =) SkTTopoSort<GrOpList, GrOpList::TopoSortTraits>(&fOpLists); |
| SkASSERT(result); |
| } |
| |
| #ifdef SK_DEBUG |
| // This block checks for any unnecessary splits in the opLists. If two sequential opLists |
| // share the same backing GrSurfaceProxy it means the opList was artificially split. |
| if (fOpLists.count()) { |
| GrRenderTargetOpList* prevOpList = fOpLists[0]->asRenderTargetOpList(); |
| for (int i = 1; i < fOpLists.count(); ++i) { |
| GrRenderTargetOpList* curOpList = fOpLists[i]->asRenderTargetOpList(); |
| |
| if (prevOpList && curOpList) { |
| SkASSERT(prevOpList->fTarget.get() != curOpList->fTarget.get()); |
| } |
| |
| prevOpList = curOpList; |
| } |
| } |
| #endif |
| } |
| |
| void GrDrawingManager::OpListDAG::closeAll(const GrCaps* caps) { |
| for (int i = 0; i < fOpLists.count(); ++i) { |
| if (fOpLists[i]) { |
| fOpLists[i]->makeClosed(*caps); |
| } |
| } |
| } |
| |
| void GrDrawingManager::OpListDAG::cleanup(const GrCaps* caps) { |
| for (int i = 0; i < fOpLists.count(); ++i) { |
| if (!fOpLists[i]) { |
| continue; |
| } |
| |
| // no opList should receive a new command after this |
| fOpLists[i]->makeClosed(*caps); |
| |
| // We shouldn't need to do this, but it turns out some clients still hold onto opLists |
| // after a cleanup. |
| // MDB TODO: is this still true? |
| if (!fOpLists[i]->unique()) { |
| // TODO: Eventually this should be guaranteed unique. |
| // https://bugs.chromium.org/p/skia/issues/detail?id=7111 |
| fOpLists[i]->endFlush(); |
| } |
| } |
| |
| fOpLists.reset(); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| GrDrawingManager::GrDrawingManager(GrContext* context, |
| const GrPathRendererChain::Options& optionsForPathRendererChain, |
| const GrTextContext::Options& optionsForTextContext, |
| GrSingleOwner* singleOwner, |
| bool explicitlyAllocating, |
| GrContextOptions::Enable sortOpLists, |
| GrContextOptions::Enable reduceOpListSplitting) |
| : fContext(context) |
| , fOptionsForPathRendererChain(optionsForPathRendererChain) |
| , fOptionsForTextContext(optionsForTextContext) |
| , fSingleOwner(singleOwner) |
| , fAbandoned(false) |
| , fDAG(explicitlyAllocating, sortOpLists) |
| , fTextContext(nullptr) |
| , fPathRendererChain(nullptr) |
| , fSoftwarePathRenderer(nullptr) |
| , fFlushing(false) { |
| if (GrContextOptions::Enable::kNo == reduceOpListSplitting) { |
| fReduceOpListSplitting = false; |
| } else if (GrContextOptions::Enable::kYes == reduceOpListSplitting) { |
| fReduceOpListSplitting = true; |
| } else { |
| // For now, this is only turned on when explicitly enabled. Once mini-flushes are |
| // implemented it should be enabled whenever sorting is enabled. |
| fReduceOpListSplitting = false; // sortOpLists |
| } |
| } |
| |
| void GrDrawingManager::cleanup() { |
| fDAG.cleanup(fContext->contextPriv().caps()); |
| |
| fPathRendererChain = nullptr; |
| fSoftwarePathRenderer = nullptr; |
| |
| fOnFlushCBObjects.reset(); |
| } |
| |
| GrDrawingManager::~GrDrawingManager() { |
| this->cleanup(); |
| } |
| |
| void GrDrawingManager::abandon() { |
| fAbandoned = true; |
| this->cleanup(); |
| } |
| |
| void GrDrawingManager::freeGpuResources() { |
| for (int i = fOnFlushCBObjects.count() - 1; i >= 0; --i) { |
| if (!fOnFlushCBObjects[i]->retainOnFreeGpuResources()) { |
| // it's safe to just do this because we're iterating in reverse |
| fOnFlushCBObjects.removeShuffle(i); |
| } |
| } |
| |
| // a path renderer may be holding onto resources |
| fPathRendererChain = nullptr; |
| fSoftwarePathRenderer = nullptr; |
| } |
| |
| // MDB TODO: make use of the 'proxy' parameter. |
| GrSemaphoresSubmitted GrDrawingManager::flush(GrSurfaceProxy*, |
| int numSemaphores, |
| GrBackendSemaphore backendSemaphores[]) { |
| GR_CREATE_TRACE_MARKER_CONTEXT("GrDrawingManager", "flush", fContext); |
| |
| if (fFlushing || this->wasAbandoned()) { |
| return GrSemaphoresSubmitted::kNo; |
| } |
| SkDEBUGCODE(this->validate()); |
| |
| GrGpu* gpu = fContext->contextPriv().getGpu(); |
| if (!gpu) { |
| return GrSemaphoresSubmitted::kNo; // Can't flush while DDL recording |
| } |
| fFlushing = true; |
| |
| // Semi-usually the GrOpLists are already closed at this point, but sometimes Ganesh |
| // needs to flush mid-draw. In that case, the SkGpuDevice's GrOpLists won't be closed |
| // but need to be flushed anyway. Closing such GrOpLists here will mean new |
| // GrOpLists will be created to replace them if the SkGpuDevice(s) write to them again. |
| fDAG.closeAll(fContext->contextPriv().caps()); |
| fActiveOpList = nullptr; |
| |
| fDAG.prepForFlush(); |
| SkASSERT(SkToBool(fVertexBufferSpace) == SkToBool(fIndexBufferSpace)); |
| if (!fVertexBufferSpace) { |
| fVertexBufferSpace.reset(new char[GrBufferAllocPool::kDefaultBufferSize]()); |
| fIndexBufferSpace.reset(new char[GrBufferAllocPool::kDefaultBufferSize]()); |
| } |
| |
| GrOpFlushState flushState(gpu, fContext->contextPriv().resourceProvider(), &fTokenTracker, |
| fVertexBufferSpace.get(), fIndexBufferSpace.get()); |
| |
| GrOnFlushResourceProvider onFlushProvider(this); |
| // TODO: AFAICT the only reason fFlushState is on GrDrawingManager rather than on the |
| // stack here is to preserve the flush tokens. |
| |
| // Prepare any onFlush op lists (e.g. atlases). |
| if (!fOnFlushCBObjects.empty()) { |
| fDAG.gatherIDs(&fFlushingOpListIDs); |
| |
| SkSTArray<4, sk_sp<GrRenderTargetContext>> renderTargetContexts; |
| for (GrOnFlushCallbackObject* onFlushCBObject : fOnFlushCBObjects) { |
| onFlushCBObject->preFlush(&onFlushProvider, |
| fFlushingOpListIDs.begin(), fFlushingOpListIDs.count(), |
| &renderTargetContexts); |
| for (const sk_sp<GrRenderTargetContext>& rtc : renderTargetContexts) { |
| sk_sp<GrRenderTargetOpList> onFlushOpList = sk_ref_sp(rtc->getRTOpList()); |
| if (!onFlushOpList) { |
| continue; // Odd - but not a big deal |
| } |
| #ifdef SK_DEBUG |
| // OnFlush callbacks are already invoked during flush, and are therefore expected to |
| // handle resource allocation & usage on their own. (No deferred or lazy proxies!) |
| onFlushOpList->visitProxies_debugOnly([](GrSurfaceProxy* p) { |
| SkASSERT(!p->asTextureProxy() || !p->asTextureProxy()->texPriv().isDeferred()); |
| SkASSERT(GrSurfaceProxy::LazyState::kNot == p->lazyInstantiationState()); |
| }); |
| #endif |
| onFlushOpList->makeClosed(*fContext->contextPriv().caps()); |
| onFlushOpList->prepare(&flushState); |
| fOnFlushCBOpLists.push_back(std::move(onFlushOpList)); |
| } |
| renderTargetContexts.reset(); |
| } |
| } |
| |
| #if 0 |
| // Enable this to print out verbose GrOp information |
| for (int i = 0; i < fOpLists.count(); ++i) { |
| SkDEBUGCODE(fOpLists[i]->dump();) |
| } |
| #endif |
| |
| int startIndex, stopIndex; |
| bool flushed = false; |
| |
| { |
| GrResourceAllocator alloc(fContext->contextPriv().resourceProvider(), |
| flushState.deinstantiateProxyTracker()); |
| for (int i = 0; i < fDAG.numOpLists(); ++i) { |
| if (fDAG.opList(i)) { |
| fDAG.opList(i)->gatherProxyIntervals(&alloc); |
| } |
| alloc.markEndOfOpList(i); |
| } |
| |
| GrResourceAllocator::AssignError error = GrResourceAllocator::AssignError::kNoError; |
| int numOpListsExecuted = 0; |
| while (alloc.assign(&startIndex, &stopIndex, &error)) { |
| if (GrResourceAllocator::AssignError::kFailedProxyInstantiation == error) { |
| for (int i = startIndex; i < stopIndex; ++i) { |
| if (fDAG.opList(i) && !fDAG.opList(i)->isFullyInstantiated()) { |
| // If the backing surface wasn't allocated drop the entire opList. |
| fDAG.removeOpList(i); |
| } |
| if (fDAG.opList(i)) { |
| fDAG.opList(i)->purgeOpsWithUninstantiatedProxies(); |
| } |
| } |
| } |
| |
| if (this->executeOpLists(startIndex, stopIndex, &flushState, &numOpListsExecuted)) { |
| flushed = true; |
| } |
| } |
| } |
| |
| #ifdef SK_DEBUG |
| for (int i = 0; i < fDAG.numOpLists(); ++i) { |
| // If there are any remaining opLists at this point, make sure they will not survive the |
| // flush. Otherwise we need to call endFlush() on them. |
| // http://skbug.com/7111 |
| SkASSERT(!fDAG.opList(i) || fDAG.opList(i)->unique()); |
| } |
| #endif |
| fDAG.reset(); |
| |
| #ifdef SK_DEBUG |
| // In non-DDL mode this checks that all the flushed ops have been freed from the memory pool. |
| // When we move to partial flushes this assert will no longer be valid. |
| // In DDL mode this check is somewhat superfluous since the memory for most of the ops/opLists |
| // will be stored in the DDL's GrOpMemoryPools. |
| GrOpMemoryPool* opMemoryPool = fContext->contextPriv().opMemoryPool(); |
| opMemoryPool->isEmpty(); |
| #endif |
| |
| GrSemaphoresSubmitted result = gpu->finishFlush(numSemaphores, backendSemaphores); |
| |
| flushState.deinstantiateProxyTracker()->deinstantiateAllProxies(); |
| |
| // Give the cache a chance to purge resources that become purgeable due to flushing. |
| if (flushed) { |
| fContext->contextPriv().getResourceCache()->purgeAsNeeded(); |
| } |
| for (GrOnFlushCallbackObject* onFlushCBObject : fOnFlushCBObjects) { |
| onFlushCBObject->postFlush(fTokenTracker.nextTokenToFlush(), fFlushingOpListIDs.begin(), |
| fFlushingOpListIDs.count()); |
| } |
| fFlushingOpListIDs.reset(); |
| fFlushing = false; |
| |
| return result; |
| } |
| |
| bool GrDrawingManager::executeOpLists(int startIndex, int stopIndex, GrOpFlushState* flushState, |
| int* numOpListsExecuted) { |
| SkASSERT(startIndex <= stopIndex && stopIndex <= fDAG.numOpLists()); |
| |
| #if GR_FLUSH_TIME_OP_SPEW |
| SkDebugf("Flushing opLists: %d to %d out of [%d, %d]\n", |
| startIndex, stopIndex, 0, fDAG.numOpLists()); |
| for (int i = startIndex; i < stopIndex; ++i) { |
| if (fDAG.opList(i)) { |
| fDAG.opList(i)->dump(true); |
| } |
| } |
| #endif |
| |
| GrResourceProvider* resourceProvider = fContext->contextPriv().resourceProvider(); |
| bool anyOpListsExecuted = false; |
| |
| for (int i = startIndex; i < stopIndex; ++i) { |
| if (!fDAG.opList(i)) { |
| continue; |
| } |
| |
| GrOpList* opList = fDAG.opList(i); |
| |
| if (resourceProvider->explicitlyAllocateGPUResources()) { |
| if (!opList->isFullyInstantiated()) { |
| // If the backing surface wasn't allocated drop the draw of the entire opList. |
| fDAG.removeOpList(i); |
| continue; |
| } |
| } else { |
| if (!opList->instantiate(resourceProvider)) { |
| fDAG.removeOpList(i); |
| continue; |
| } |
| } |
| |
| // TODO: handle this instantiation via lazy surface proxies? |
| // Instantiate all deferred proxies (being built on worker threads) so we can upload them |
| opList->instantiateDeferredProxies(fContext->contextPriv().resourceProvider()); |
| opList->prepare(flushState); |
| } |
| |
| // Upload all data to the GPU |
| flushState->preExecuteDraws(); |
| |
| // For Vulkan, if we have too many oplists to be flushed we end up allocating a lot of resources |
| // for each command buffer associated with the oplists. If this gets too large we can cause the |
| // devices to go OOM. In practice we usually only hit this case in our tests, but to be safe we |
| // put a cap on the number of oplists we will execute before flushing to the GPU to relieve some |
| // memory pressure. |
| static constexpr int kMaxOpListsBeforeFlush = 100; |
| |
| // Execute the onFlush op lists first, if any. |
| for (sk_sp<GrOpList>& onFlushOpList : fOnFlushCBOpLists) { |
| if (!onFlushOpList->execute(flushState)) { |
| SkDebugf("WARNING: onFlushOpList failed to execute.\n"); |
| } |
| SkASSERT(onFlushOpList->unique()); |
| onFlushOpList = nullptr; |
| (*numOpListsExecuted)++; |
| if (*numOpListsExecuted >= kMaxOpListsBeforeFlush) { |
| flushState->gpu()->finishFlush(0, nullptr); |
| *numOpListsExecuted = 0; |
| } |
| } |
| fOnFlushCBOpLists.reset(); |
| |
| // Execute the normal op lists. |
| for (int i = startIndex; i < stopIndex; ++i) { |
| if (!fDAG.opList(i)) { |
| continue; |
| } |
| |
| if (fDAG.opList(i)->execute(flushState)) { |
| anyOpListsExecuted = true; |
| } |
| (*numOpListsExecuted)++; |
| if (*numOpListsExecuted >= kMaxOpListsBeforeFlush) { |
| flushState->gpu()->finishFlush(0, nullptr); |
| *numOpListsExecuted = 0; |
| } |
| } |
| |
| SkASSERT(!flushState->commandBuffer()); |
| SkASSERT(fTokenTracker.nextDrawToken() == fTokenTracker.nextTokenToFlush()); |
| |
| // We reset the flush state before the OpLists so that the last resources to be freed are those |
| // that are written to in the OpLists. This helps to make sure the most recently used resources |
| // are the last to be purged by the resource cache. |
| flushState->reset(); |
| |
| fDAG.removeOpLists(startIndex, stopIndex); |
| |
| return anyOpListsExecuted; |
| } |
| |
| GrSemaphoresSubmitted GrDrawingManager::prepareSurfaceForExternalIO( |
| GrSurfaceProxy* proxy, int numSemaphores, GrBackendSemaphore backendSemaphores[]) { |
| if (this->wasAbandoned()) { |
| return GrSemaphoresSubmitted::kNo; |
| } |
| SkDEBUGCODE(this->validate()); |
| SkASSERT(proxy); |
| |
| GrGpu* gpu = fContext->contextPriv().getGpu(); |
| if (!gpu) { |
| return GrSemaphoresSubmitted::kNo; // Can't flush while DDL recording |
| } |
| |
| GrSemaphoresSubmitted result = GrSemaphoresSubmitted::kNo; |
| if (proxy->priv().hasPendingIO() || numSemaphores) { |
| result = this->flush(proxy, numSemaphores, backendSemaphores); |
| } |
| |
| if (!proxy->instantiate(fContext->contextPriv().resourceProvider())) { |
| return result; |
| } |
| |
| GrSurface* surface = proxy->peekSurface(); |
| if (auto* rt = surface->asRenderTarget()) { |
| gpu->resolveRenderTarget(rt); |
| } |
| if (auto* tex = surface->asTexture()) { |
| if (tex->texturePriv().mipMapped() == GrMipMapped::kYes && |
| tex->texturePriv().mipMapsAreDirty()) { |
| gpu->regenerateMipMapLevels(tex); |
| } |
| } |
| |
| SkDEBUGCODE(this->validate()); |
| return result; |
| } |
| |
| void GrDrawingManager::addOnFlushCallbackObject(GrOnFlushCallbackObject* onFlushCBObject) { |
| fOnFlushCBObjects.push_back(onFlushCBObject); |
| } |
| |
| void GrDrawingManager::moveOpListsToDDL(SkDeferredDisplayList* ddl) { |
| SkDEBUGCODE(this->validate()); |
| |
| // no opList should receive a new command after this |
| fDAG.closeAll(fContext->contextPriv().caps()); |
| fActiveOpList = nullptr; |
| |
| fDAG.swap(&ddl->fOpLists); |
| |
| if (fPathRendererChain) { |
| if (auto ccpr = fPathRendererChain->getCoverageCountingPathRenderer()) { |
| ddl->fPendingPaths = ccpr->detachPendingPaths(); |
| } |
| } |
| |
| SkDEBUGCODE(this->validate()); |
| } |
| |
| void GrDrawingManager::copyOpListsFromDDL(const SkDeferredDisplayList* ddl, |
| GrRenderTargetProxy* newDest) { |
| SkDEBUGCODE(this->validate()); |
| |
| if (fActiveOpList) { |
| // This is a temporary fix for the partial-MDB world. In that world we're not |
| // reordering so ops that (in the single opList world) would've just glommed onto the |
| // end of the single opList but referred to a far earlier RT need to appear in their |
| // own opList. |
| fActiveOpList->makeClosed(*fContext->contextPriv().caps()); |
| fActiveOpList = nullptr; |
| } |
| |
| // Here we jam the proxy that backs the current replay SkSurface into the LazyProxyData. |
| // The lazy proxy that references it (in the copied opLists) will steal its GrTexture. |
| ddl->fLazyProxyData->fReplayDest = newDest; |
| |
| if (ddl->fPendingPaths.size()) { |
| GrCoverageCountingPathRenderer* ccpr = this->getCoverageCountingPathRenderer(); |
| |
| ccpr->mergePendingPaths(ddl->fPendingPaths); |
| } |
| |
| fDAG.add(ddl->fOpLists); |
| |
| SkDEBUGCODE(this->validate()); |
| } |
| |
| #ifdef SK_DEBUG |
| void GrDrawingManager::validate() const { |
| if (fDAG.sortingOpLists() && fReduceOpListSplitting) { |
| SkASSERT(!fActiveOpList); |
| } else { |
| if (fActiveOpList) { |
| SkASSERT(!fDAG.empty()); |
| SkASSERT(!fActiveOpList->isClosed()); |
| SkASSERT(fActiveOpList == fDAG.back()); |
| } |
| |
| for (int i = 0; i < fDAG.numOpLists(); ++i) { |
| if (fActiveOpList != fDAG.opList(i)) { |
| SkASSERT(fDAG.opList(i)->isClosed()); |
| } |
| } |
| |
| if (!fDAG.empty() && !fDAG.back()->isClosed()) { |
| SkASSERT(fActiveOpList == fDAG.back()); |
| } |
| } |
| } |
| #endif |
| |
| sk_sp<GrRenderTargetOpList> GrDrawingManager::newRTOpList(GrRenderTargetProxy* rtp, |
| bool managedOpList) { |
| SkDEBUGCODE(this->validate()); |
| SkASSERT(fContext); |
| |
| if (fDAG.sortingOpLists() && fReduceOpListSplitting) { |
| // In this case we need to close all the opLists that rely on the current contents of |
| // 'rtp'. That is bc we're going to update the content of the proxy so they need to be |
| // split in case they use both the old and new content. (This is a bit of an overkill: |
| // they really only need to be split if they ever reference proxy's contents again but |
| // that is hard to predict/handle). |
| if (GrOpList* lastOpList = rtp->getLastOpList()) { |
| lastOpList->closeThoseWhoDependOnMe(*fContext->contextPriv().caps()); |
| } |
| } else if (fActiveOpList) { |
| // This is a temporary fix for the partial-MDB world. In that world we're not |
| // reordering so ops that (in the single opList world) would've just glommed onto the |
| // end of the single opList but referred to a far earlier RT need to appear in their |
| // own opList. |
| fActiveOpList->makeClosed(*fContext->contextPriv().caps()); |
| fActiveOpList = nullptr; |
| } |
| |
| auto resourceProvider = fContext->contextPriv().resourceProvider(); |
| |
| sk_sp<GrRenderTargetOpList> opList(new GrRenderTargetOpList( |
| resourceProvider, |
| fContext->contextPriv().refOpMemoryPool(), |
| rtp, |
| fContext->contextPriv().getAuditTrail())); |
| SkASSERT(rtp->getLastOpList() == opList.get()); |
| |
| if (managedOpList) { |
| fDAG.add(opList); |
| |
| if (!fDAG.sortingOpLists() || !fReduceOpListSplitting) { |
| fActiveOpList = opList.get(); |
| } |
| } |
| |
| SkDEBUGCODE(this->validate()); |
| return opList; |
| } |
| |
| sk_sp<GrTextureOpList> GrDrawingManager::newTextureOpList(GrTextureProxy* textureProxy) { |
| SkDEBUGCODE(this->validate()); |
| SkASSERT(fContext); |
| |
| if (fDAG.sortingOpLists() && fReduceOpListSplitting) { |
| // In this case we need to close all the opLists that rely on the current contents of |
| // 'texture'. That is bc we're going to update the content of the proxy so they need to |
| // be split in case they use both the old and new content. (This is a bit of an |
| // overkill: they really only need to be split if they ever reference proxy's contents |
| // again but that is hard to predict/handle). |
| if (GrOpList* lastOpList = textureProxy->getLastOpList()) { |
| lastOpList->closeThoseWhoDependOnMe(*fContext->contextPriv().caps()); |
| } |
| } else if (fActiveOpList) { |
| // This is a temporary fix for the partial-MDB world. In that world we're not |
| // reordering so ops that (in the single opList world) would've just glommed onto the |
| // end of the single opList but referred to a far earlier RT need to appear in their |
| // own opList. |
| fActiveOpList->makeClosed(*fContext->contextPriv().caps()); |
| fActiveOpList = nullptr; |
| } |
| |
| sk_sp<GrTextureOpList> opList(new GrTextureOpList(fContext->contextPriv().resourceProvider(), |
| fContext->contextPriv().refOpMemoryPool(), |
| textureProxy, |
| fContext->contextPriv().getAuditTrail())); |
| |
| SkASSERT(textureProxy->getLastOpList() == opList.get()); |
| |
| fDAG.add(opList); |
| if (!fDAG.sortingOpLists() || !fReduceOpListSplitting) { |
| fActiveOpList = opList.get(); |
| } |
| |
| SkDEBUGCODE(this->validate()); |
| return opList; |
| } |
| |
| GrTextContext* GrDrawingManager::getTextContext() { |
| if (!fTextContext) { |
| fTextContext = GrTextContext::Make(fOptionsForTextContext); |
| } |
| |
| return fTextContext.get(); |
| } |
| |
| /* |
| * This method finds a path renderer that can draw the specified path on |
| * the provided target. |
| * Due to its expense, the software path renderer has split out so it can |
| * can be individually allowed/disallowed via the "allowSW" boolean. |
| */ |
| GrPathRenderer* GrDrawingManager::getPathRenderer(const GrPathRenderer::CanDrawPathArgs& args, |
| bool allowSW, |
| GrPathRendererChain::DrawType drawType, |
| GrPathRenderer::StencilSupport* stencilSupport) { |
| |
| if (!fPathRendererChain) { |
| fPathRendererChain.reset(new GrPathRendererChain(fContext, fOptionsForPathRendererChain)); |
| } |
| |
| GrPathRenderer* pr = fPathRendererChain->getPathRenderer(args, drawType, stencilSupport); |
| if (!pr && allowSW) { |
| auto swPR = this->getSoftwarePathRenderer(); |
| if (GrPathRenderer::CanDrawPath::kNo != swPR->canDrawPath(args)) { |
| pr = swPR; |
| } |
| } |
| |
| return pr; |
| } |
| |
| GrPathRenderer* GrDrawingManager::getSoftwarePathRenderer() { |
| if (!fSoftwarePathRenderer) { |
| fSoftwarePathRenderer.reset( |
| new GrSoftwarePathRenderer(fContext->contextPriv().proxyProvider(), |
| fOptionsForPathRendererChain.fAllowPathMaskCaching)); |
| } |
| return fSoftwarePathRenderer.get(); |
| } |
| |
| GrCoverageCountingPathRenderer* GrDrawingManager::getCoverageCountingPathRenderer() { |
| if (!fPathRendererChain) { |
| fPathRendererChain.reset(new GrPathRendererChain(fContext, fOptionsForPathRendererChain)); |
| } |
| return fPathRendererChain->getCoverageCountingPathRenderer(); |
| } |
| |
| void GrDrawingManager::flushIfNecessary() { |
| GrResourceCache* resourceCache = fContext->contextPriv().getResourceCache(); |
| if (resourceCache && resourceCache->requestsFlush()) { |
| this->flush(nullptr, 0, nullptr); |
| resourceCache->purgeAsNeeded(); |
| } |
| } |
| |
| sk_sp<GrRenderTargetContext> GrDrawingManager::makeRenderTargetContext( |
| sk_sp<GrSurfaceProxy> sProxy, |
| sk_sp<SkColorSpace> colorSpace, |
| const SkSurfaceProps* surfaceProps, |
| bool managedOpList) { |
| if (this->wasAbandoned() || !sProxy->asRenderTargetProxy()) { |
| return nullptr; |
| } |
| |
| // SkSurface catches bad color space usage at creation. This check handles anything that slips |
| // by, including internal usage. |
| if (!SkSurface_Gpu::Valid(fContext->contextPriv().caps(), sProxy->config(), colorSpace.get())) { |
| SkDEBUGFAIL("Invalid config and colorspace combination"); |
| return nullptr; |
| } |
| |
| sk_sp<GrRenderTargetProxy> rtp(sk_ref_sp(sProxy->asRenderTargetProxy())); |
| |
| return sk_sp<GrRenderTargetContext>(new GrRenderTargetContext( |
| fContext, this, std::move(rtp), |
| std::move(colorSpace), |
| surfaceProps, |
| fContext->contextPriv().getAuditTrail(), |
| fSingleOwner, managedOpList)); |
| } |
| |
| sk_sp<GrTextureContext> GrDrawingManager::makeTextureContext(sk_sp<GrSurfaceProxy> sProxy, |
| sk_sp<SkColorSpace> colorSpace) { |
| if (this->wasAbandoned() || !sProxy->asTextureProxy()) { |
| return nullptr; |
| } |
| |
| // SkSurface catches bad color space usage at creation. This check handles anything that slips |
| // by, including internal usage. |
| if (!SkSurface_Gpu::Valid(fContext->contextPriv().caps(), sProxy->config(), colorSpace.get())) { |
| SkDEBUGFAIL("Invalid config and colorspace combination"); |
| return nullptr; |
| } |
| |
| // GrTextureRenderTargets should always be using a GrRenderTargetContext |
| SkASSERT(!sProxy->asRenderTargetProxy()); |
| |
| sk_sp<GrTextureProxy> textureProxy(sk_ref_sp(sProxy->asTextureProxy())); |
| |
| return sk_sp<GrTextureContext>(new GrTextureContext(fContext, this, std::move(textureProxy), |
| std::move(colorSpace), |
| fContext->contextPriv().getAuditTrail(), |
| fSingleOwner)); |
| } |
