/* * Copyright 2016 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/GrOpList.h" #include "include/gpu/GrContext.h" #include "src/gpu/GrDeferredProxyUploader.h" #include "src/gpu/GrMemoryPool.h" #include "src/gpu/GrRenderTargetPriv.h" #include "src/gpu/GrStencilAttachment.h" #include "src/gpu/GrSurfaceProxy.h" #include "src/gpu/GrTextureProxyPriv.h" #include uint32_t GrOpList::CreateUniqueID() { static std::atomic nextID{1}; uint32_t id; do { id = nextID++; } while (id == SK_InvalidUniqueID); return id; } GrOpList::GrOpList(sk_sp opMemoryPool, sk_sp surfaceProxy, GrAuditTrail* auditTrail) : fOpMemoryPool(std::move(opMemoryPool)) , fAuditTrail(auditTrail) , fUniqueID(CreateUniqueID()) , fFlags(0) { SkASSERT(fOpMemoryPool); fTarget = std::move(surfaceProxy); fTarget->setLastOpList(this); } GrOpList::~GrOpList() { if (fTarget && this == fTarget->getLastOpList()) { // Ensure the target proxy doesn't keep hold of a dangling back pointer. fTarget->setLastOpList(nullptr); } } void GrOpList::endFlush() { if (fTarget && this == fTarget->getLastOpList()) { fTarget->setLastOpList(nullptr); } fTarget.reset(); fDeferredProxies.reset(); fAuditTrail = nullptr; } #ifdef SK_DEBUG bool GrOpList::deferredProxiesAreInstantiated() const { for (int i = 0; i < fDeferredProxies.count(); ++i) { if (!fDeferredProxies[i]->isInstantiated()) { return false; } } return true; } #endif void GrOpList::prepare(GrOpFlushState* flushState) { for (int i = 0; i < fDeferredProxies.count(); ++i) { fDeferredProxies[i]->texPriv().scheduleUpload(flushState); } this->onPrepare(flushState); } // Add a GrOpList-based dependency void GrOpList::addDependency(GrOpList* dependedOn) { SkASSERT(!dependedOn->dependsOn(this)); // loops are bad if (this->dependsOn(dependedOn)) { return; // don't add duplicate dependencies } fDependencies.push_back(dependedOn); dependedOn->addDependent(this); SkDEBUGCODE(this->validate()); } // Convert from a GrSurface-based dependency to a GrOpList one void GrOpList::addDependency(GrSurfaceProxy* dependedOn, const GrCaps& caps) { if (dependedOn->getLastOpList()) { // If it is still receiving dependencies, this GrOpList shouldn't be closed SkASSERT(!this->isClosed()); GrOpList* opList = dependedOn->getLastOpList(); if (opList == this) { // self-read - presumably for dst reads. We can't make it closed in the self-read case. } else { this->addDependency(opList); // We are closing 'opList' here bc the current contents of it are what 'this' opList // depends on. We need a break in 'opList' so that the usage of that state has a // chance to execute. opList->makeClosed(caps); } } if (GrTextureProxy* textureProxy = dependedOn->asTextureProxy()) { if (textureProxy->texPriv().isDeferred()) { fDeferredProxies.push_back(textureProxy); } } } bool GrOpList::dependsOn(const GrOpList* dependedOn) const { for (int i = 0; i < fDependencies.count(); ++i) { if (fDependencies[i] == dependedOn) { return true; } } return false; } void GrOpList::addDependent(GrOpList* dependent) { fDependents.push_back(dependent); } #ifdef SK_DEBUG bool GrOpList::isDependedent(const GrOpList* dependent) const { for (int i = 0; i < fDependents.count(); ++i) { if (fDependents[i] == dependent) { return true; } } return false; } void GrOpList::validate() const { // TODO: check for loops and duplicates for (int i = 0; i < fDependencies.count(); ++i) { SkASSERT(fDependencies[i]->isDependedent(this)); } } #endif void GrOpList::closeThoseWhoDependOnMe(const GrCaps& caps) { for (int i = 0; i < fDependents.count(); ++i) { if (!fDependents[i]->isClosed()) { fDependents[i]->makeClosed(caps); } } } bool GrOpList::isInstantiated() const { if (!fTarget->isInstantiated()) { return false; } int minStencilSampleCount = (fTarget->asRenderTargetProxy()) ? fTarget->asRenderTargetProxy()->numStencilSamples() : 0; if (minStencilSampleCount) { GrRenderTarget* rt = fTarget->peekRenderTarget(); SkASSERT(rt); GrStencilAttachment* stencil = rt->renderTargetPriv().getStencilAttachment(); if (!stencil) { return false; } SkASSERT(stencil->numSamples() >= minStencilSampleCount); } GrSurface* surface = fTarget->peekSurface(); if (surface->wasDestroyed()) { return false; } return true; } #ifdef SK_DEBUG static const char* op_to_name(GrLoadOp op) { return GrLoadOp::kLoad == op ? "load" : GrLoadOp::kClear == op ? "clear" : "discard"; } void GrOpList::dump(bool printDependencies) const { SkDebugf("--------------------------------------------------------------\n"); SkDebugf("opListID: %d - proxyID: %d - surfaceID: %d\n", fUniqueID, fTarget ? fTarget->uniqueID().asUInt() : -1, fTarget && fTarget->peekSurface() ? fTarget->peekSurface()->uniqueID().asUInt() : -1); SkDebugf("ColorLoadOp: %s %x StencilLoadOp: %s\n", op_to_name(fColorLoadOp), GrLoadOp::kClear == fColorLoadOp ? fLoadClearColor.toBytes_RGBA() : 0x0, op_to_name(fStencilLoadOp)); if (printDependencies) { SkDebugf("I rely On (%d): ", fDependencies.count()); for (int i = 0; i < fDependencies.count(); ++i) { SkDebugf("%d, ", fDependencies[i]->fUniqueID); } SkDebugf("\n"); SkDebugf("(%d) Rely On Me: ", fDependents.count()); for (int i = 0; i < fDependents.count(); ++i) { SkDebugf("%d, ", fDependents[i]->fUniqueID); } SkDebugf("\n"); } } #endif