Pass in ProcOptInfos into willNeedDstCopy on XPs

src/gpu/GrInOrderDrawBuffer.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrInOrderDrawBuffer.h"
 
 #include "GrBufferAllocPool.h"
@@ skipping 233 matching lines @@
     return instancesToConcat;
 }
 
 void GrInOrderDrawBuffer::onDraw(const GrPipelineBuilder& pipelineBuilder,
                                  const GrGeometryProcessor* gp,
                                  const DrawInfo& info,
                                  const GrScissorState& scissorState) {
     SkASSERT(info.vertexBuffer() && (!info.isIndexed() || info.indexBuffer()));
     this->closeBatch();
 
-    if (!this->recordStateAndShouldDraw(pipelineBuilder, gp, scissorState, info.getDevBounds())) {
+    if (!this->recordStateAndSetupPipeline(gp, pipelineBuilder, scissorState,
+                                           info.getDevBounds())) {
         return;
     }
 
     Draw* draw;
     if (info.isInstanced()) {
         int instancesConcated = this->concatInstancedDraw(pipelineBuilder, info);
         if (info.instanceCount() > instancesConcated) {
             draw = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, Draw, (info));
             draw->fInfo.adjustInstanceCount(-instancesConcated);
         } else {
             return;
         }
     } else {
         draw = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, Draw, (info));
     }
     this->recordTraceMarkersIfNecessary();
 }
 
 void GrInOrderDrawBuffer::onDrawBatch(GrBatch* batch,
                                       const GrPipelineBuilder& pipelineBuilder,
                                       const GrScissorState& scissorState,
                                       const SkRect* devBounds) {
-    if (!this->recordStateAndShouldDraw(batch, pipelineBuilder, scissorState, devBounds)) {
+    if (!this->recordStateAndSetupPipeline(batch, pipelineBuilder, scissorState, devBounds)) {
         return;
     }
 
     // Check if there is a Batch Draw we can batch with
     if (kDrawBatch_Cmd != strip_trace_bit(fCmdBuffer.back().fType)) {
         fDrawBatch = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawBatch, (batch));
         return;
     }
 
     DrawBatch* draw = static_cast<DrawBatch*>(&fCmdBuffer.back());
@@ skipping 24 matching lines @@
 
 void GrInOrderDrawBuffer::onDrawPath(const GrPipelineBuilder& pipelineBuilder,
                                      const GrPathProcessor* pathProc,
                                      const GrPath* path,
                                      const GrScissorState& scissorState,
                                      const GrStencilSettings& stencilSettings,
                                      const SkRect* devBounds) {
     this->closeBatch();
 
     // TODO: Only compare the subset of GrPipelineBuilder relevant to path covering?
-    if (!this->recordStateAndShouldDraw(pipelineBuilder, pathProc, scissorState, devBounds)) {
+    if (!this->recordStateAndSetupPipeline(pathProc, pipelineBuilder, scissorState, devBounds)) {
         return;
     }
     DrawPath* dp = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawPath, (path));
     dp->fStencilSettings = stencilSettings;
     this->recordTraceMarkersIfNecessary();
 }
 
 void GrInOrderDrawBuffer::onDrawPaths(const GrPipelineBuilder& pipelineBuilder,
                                       const GrPathProcessor* pathProc,
                                       const GrPathRange* pathRange,
                                       const void* indices,
                                       PathIndexType indexType,
                                       const float transformValues[],
                                       PathTransformType transformType,
                                       int count,
                                       const GrScissorState& scissorState,
                                       const GrStencilSettings& stencilSettings,
                                       const SkRect* devBounds) {
     SkASSERT(pathRange);
     SkASSERT(indices);
     SkASSERT(transformValues);
     this->closeBatch();
 
-    if (!this->recordStateAndShouldDraw(pipelineBuilder, pathProc, scissorState, devBounds)) {
+    if (!this->recordStateAndSetupPipeline(pathProc, pipelineBuilder, scissorState, devBounds)) {
         return;
     }
 
     int indexBytes = GrPathRange::PathIndexSizeInBytes(indexType);
     if (int misalign = fPathIndexBuffer.count() % indexBytes) {
         // Add padding to the index buffer so the indices are aligned properly.
         fPathIndexBuffer.append(indexBytes - misalign);
     }
 
     char* savedIndices = fPathIndexBuffer.append(count * indexBytes,
@@ skipping 220 matching lines @@
     if (getGpu()->canCopySurface(dst, src, srcRect, dstPoint)) {
         CopySurface* cs = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, CopySurface, (dst, src));
         cs->fSrcRect = srcRect;
         cs->fDstPoint = dstPoint;
         this->recordTraceMarkersIfNecessary();
         return true;
     }
     return false;
 }
 
-bool GrInOrderDrawBuffer::recordStateAndShouldDraw(const GrPipelineBuilder& pipelineBuilder,
-                                                   const GrPrimitiveProcessor* primProc,
-                                                   const GrScissorState& scissor,
-                                                   const SkRect* devBounds) {
+bool GrInOrderDrawBuffer::recordStateAndSetupPipeline(const GrPrimitiveProcessor* primProc,
+                                                      const GrPipelineBuilder& pipelineBuilder,
+                                                      const GrScissorState& scissor,
+                                                      const SkRect* devBounds) {
+    const GrProcOptInfo& colorPOI = pipelineBuilder.colorProcInfo(primProc);
+    const GrProcOptInfo& coveragePOI = pipelineBuilder.coverageProcInfo(primProc);
+
     GrDeviceCoordTexture dstCopy;
-    if (!this->setupDstReadIfNecessary(pipelineBuilder, &dstCopy, devBounds)) {
+    if (!this->setupDstReadIfNecessary(pipelineBuilder, colorPOI, coveragePOI,
+                                       &dstCopy, devBounds)) {
         return false;
     }
     SetState* ss = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, SetState,
-                                            (pipelineBuilder, primProc, *this->getGpu()->caps(),
-                                             scissor, &dstCopy));
+                                            (pipelineBuilder, colorPOI, coveragePOI,
+                                             *this->getGpu()->caps(), scissor, &dstCopy, primProc));
     if (ss->fPipeline.mustSkip()) {
         fCmdBuffer.pop_back();
         return false;
     }
 
     ss->fPrimitiveProcessor->initBatchTracker(&ss->fBatchTracker,
                                               ss->fPipeline.getInitBatchTracker());
 
     if (fPrevState && fPrevState->fPrimitiveProcessor.get() &&
         fPrevState->fPrimitiveProcessor->canMakeEqual(fPrevState->fBatchTracker,
                                                       *ss->fPrimitiveProcessor,
                                                       ss->fBatchTracker) &&
         fPrevState->fPipeline.isEqual(ss->fPipeline)) {
         fCmdBuffer.pop_back();
     } else {
         fPrevState = ss;
         this->recordTraceMarkersIfNecessary();
     }
     return true;
 }
 
-bool GrInOrderDrawBuffer::recordStateAndShouldDraw(GrBatch* batch,
-                                                   const GrPipelineBuilder& pipelineBuilder,
-                                                   const GrScissorState& scissor,
-                                                   const SkRect* devBounds) {
+bool GrInOrderDrawBuffer::recordStateAndSetupPipeline(GrBatch* batch,
+                                                      const GrPipelineBuilder& pipelineBuilder,
+                                                      const GrScissorState& scissor,
+                                                      const SkRect* devBounds) {
+    GrBatchOpt batchOpt;

[bsalomon, 2015/02/11 15:38:03]

seems weird that we're doing this here.

[egdaniel, 2015/02/11 16:48:08]

So the reason we are doing this here is that we need the batch to be initiated
in order to get the color/coverage ProcOptInfos which are now needed for
setupDstReadIfNecessary. This approach was chosen so we only need to calc these
ProcOptInfos once since they are also needed to construct the pipeline.

Other alternatives would be to recreate a caching system so that we only create
the POIs once. Or we could just eat the time to create them twice. Thoughts?

[bsalomon, 2015/02/11 16:51:23]

It seems to like everything from 628 to 643 should be done by the GrDT base
class. Maybe we should move to a model where the base class has a function that
takes the params necessary to compute a pipeline and placement news it into
memory provided by the subclass.

+    batchOpt.fCanTweakAlphaForCoverage = pipelineBuilder.canTweakAlphaForCoverage();
+    batch->initBatchOpt(batchOpt);
+
+    const GrProcOptInfo& colorPOI = pipelineBuilder.colorProcInfo(batch);
+    const GrProcOptInfo& coveragePOI = pipelineBuilder.coverageProcInfo(batch);
+
     GrDeviceCoordTexture dstCopy;
-    if (!this->setupDstReadIfNecessary(pipelineBuilder, &dstCopy, devBounds)) {
+    if (!this->setupDstReadIfNecessary(pipelineBuilder, colorPOI, coveragePOI,
+                                       &dstCopy, devBounds)) {
         return false;
     }
     // TODO this gets much simpler when we have batches everywhere.
     // If the previous command is also a set state, then we check to see if it has a Batch.  If so,
     // and we can make the two batches equal, and we can combine the states, then we make them equal
     SetState* ss = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, SetState,
-                                            (batch, pipelineBuilder, *this->getGpu()->caps(), scissor,
-                                             &dstCopy));
+                                            (pipelineBuilder, colorPOI, coveragePOI,
+                                             *this->getGpu()->caps(), scissor, &dstCopy));
     if (ss->fPipeline.mustSkip()) {
         fCmdBuffer.pop_back();
         return false;
     }
 
     batch->initBatchTracker(ss->fPipeline.getInitBatchTracker());
 
     if (fPrevState && !fPrevState->fPrimitiveProcessor.get() &&
         fPrevState->fPipeline.isEqual(ss->fPipeline)) {
         fCmdBuffer.pop_back();
@@ skipping 39 matching lines @@
     int vcount = vertexCount;
     int icount = indexCount;
 
     if (!insideGeoPush &&
         !unreleasedVertexSpace &&
         !unreleasedIndexSpace &&
         this->geometryHints(vertexStride, &vcount, &icount)) {
         this->flush();
     }
 }