////////////////////////////////////////////////////////////////////////////////
-GrDrawTarget::GrDrawTarget(GrGpu* gpu, GrResourceProvider* resourceProvider)
+GrDrawTarget::GrDrawTarget(GrRenderTarget* rt, GrGpu* gpu, GrResourceProvider* resourceProvider)
: fGpu(SkRef(gpu))
, fResourceProvider(resourceProvider)
, fFlushState(fGpu, fResourceProvider, 0)
, fFlushing(false)
, fFirstUnpreparedBatch(0)
- , fFlags(0) {
+ , fFlags(0)
+ , fRenderTarget(rt) {
// TODO: Stop extracting the context (currently needed by GrClipMaskManager)
fContext = fGpu->getContext();
fClipMaskManager.reset(new GrClipMaskManager(this));
}
GrDrawTarget::~GrDrawTarget() {
+ if (fRenderTarget && this == fRenderTarget->getLastDrawTarget()) {
+ fRenderTarget->setLastDrawTarget(nullptr);
+ }
+
fGpu->unref();
}
// drawTargets will be created to replace them if the SkGpuDevice(s) write to them again.
this->makeClosed();
- // Loop over all batches and generate geometry
+ // Loop over the batches that haven't yet generated their geometry
for (; fFirstUnpreparedBatch < fBatches.count(); ++fFirstUnpreparedBatch) {
fBatches[fFirstUnpreparedBatch]->prepare(&fFlushState);
}
return;
}
+#ifdef ENABLE_MDB
+ batch->pipeline()->addDependenciesTo(fRenderTarget);
+#endif
+
this->recordBatch(batch);
}
const SkIPoint& dstPoint) {
GrBatch* batch = GrCopySurfaceBatch::Create(dst, src, srcRect, dstPoint);
if (batch) {
+#ifdef ENABLE_MDB
+ this->addDependency(src);
+#endif
+
this->recordBatch(batch);
batch->unref();
}
public:
// The context may not be fully constructed and should not be used during GrDrawTarget
// construction.
- GrDrawTarget(GrGpu* gpu, GrResourceProvider*);
+ GrDrawTarget(GrRenderTarget* rt, GrGpu* gpu, GrResourceProvider*);
~GrDrawTarget() override;
// 'this' drawTarget relies on the output of the drawTargets in 'fDependencies'
SkTDArray<GrDrawTarget*> fDependencies;
+ GrRenderTarget* fRenderTarget;
typedef SkRefCnt INHERITED;
};
}
#endif
- GrDrawTarget* dt = new GrDrawTarget(fContext->getGpu(), fContext->resourceProvider());
+ GrDrawTarget* dt = new GrDrawTarget(rt, fContext->getGpu(), fContext->resourceProvider());
*fDrawTargets.append() = dt;
#include "GrPipeline.h"
#include "GrCaps.h"
+#include "GrDrawTarget.h"
#include "GrGpu.h"
#include "GrPipelineBuilder.h"
#include "GrProcOptInfo.h"
return pipeline;
}
+static void add_dependencies_for_processor(const GrFragmentProcessor* proc, GrRenderTarget* rt) {
+ for (int i = 0; i < proc->numChildProcessors(); ++i) {
+ // need to recurse
+ add_dependencies_for_processor(&proc->childProcessor(i), rt);
+ }
+
+ for (int i = 0; i < proc->numTextures(); ++i) {
+ GrTexture* texture = proc->textureAccess(i).getTexture();
+ SkASSERT(rt->getLastDrawTarget());
+ rt->getLastDrawTarget()->addDependency(texture);
+ }
+}
+
+void GrPipeline::addDependenciesTo(GrRenderTarget* rt) const {
+ for (int i = 0; i < fFragmentProcessors.count(); ++i) {
+ add_dependencies_for_processor(fFragmentProcessors[i].get(), rt);
+ }
+
+ if (fXferProcessor.get()) {
+ const GrXferProcessor* xfer = fXferProcessor.get();
+
+ for (int i = 0; i < xfer->numTextures(); ++i) {
+ GrTexture* texture = xfer->textureAccess(i).getTexture();
+ SkASSERT(rt->getLastDrawTarget());
+ rt->getLastDrawTarget()->addDependency(texture);
+ }
+ }
+}
+
void GrPipeline::adjustProgramFromOptimizations(const GrPipelineBuilder& pipelineBuilder,
GrXferProcessor::OptFlags flags,
const GrProcOptInfo& colorPOI,
///////////////////////////////////////////////////////////////////////////
/// @name GrFragmentProcessors
+ // Make the renderTarget's drawTarget (if it exists) be dependent on any
+ // drawTargets in this pipeline
+ void addDependenciesTo(GrRenderTarget* rt) const;
int numColorFragmentProcessors() const { return fNumColorProcessors; }
int numCoverageFragmentProcessors() const {
void GrRenderTarget::setLastDrawTarget(GrDrawTarget* dt) {
if (fLastDrawTarget) {
+ // The non-MDB world never closes so we can't check this condition
+#ifdef ENABLE_MDB
SkASSERT(fLastDrawTarget->isClosed());
+#endif
}
fLastDrawTarget = dt;