GrBatchPrototype

src/gpu/GrOptDrawState.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrOptDrawState.h"
 
+#include "GrBatch.h"
 #include "GrDrawState.h"
 #include "GrDrawTargetCaps.h"
 #include "GrGpu.h"
 #include "GrProcOptInfo.h"
 #include "GrXferProcessor.h"
 
 GrOptDrawState::GrOptDrawState(const GrDrawState& drawState,
                                const GrPrimitiveProcessor* primProc,
                                const GrDrawTargetCaps& caps,
                                const GrScissorState& scissorState,
                                const GrDeviceCoordTexture* dstCopy,
                                GrGpu::DrawType drawType)
-    : fFinalized(false) {
-    fDrawType = drawType;
-
+    : fDrawType(drawType)
+    , fFinalized(false) {
     fPrimitiveProcessor.reset(primProc);
 
-
     const GrProcOptInfo& colorPOI = drawState.colorProcInfo(fPrimitiveProcessor);
     const GrProcOptInfo& coveragePOI = drawState.coverageProcInfo(fPrimitiveProcessor);
 
+    GrGeometryProcessor::InitBT init;
+    this->internalConstructor(&init, drawState, colorPOI, coveragePOI, caps, scissorState, dstCopy);
+
+    fPrimitiveProcessor->initBatchTracker(&fBatchTracker, init);
+}
+
+GrOptDrawState::GrOptDrawState(GrBatch* batch,
+                               const GrDrawState& drawState,
+                               const GrDrawTargetCaps& caps,
+                               const GrScissorState& scissorState,
+                               const GrDeviceCoordTexture* dstCopy,
+                               GrGpu::DrawType drawType)
+    : fDrawType(drawType)
+    , fFinalized(false){
+    GrBatchOpt batchOpt;
+    batchOpt.fCanTweakAlphaForCoverage = drawState.canTweakAlphaForCoverage();
+    batch->initBatchOpt(batchOpt);
+    const GrProcOptInfo& colorPOI = drawState.colorProcInfo(batch);
+    const GrProcOptInfo& coveragePOI = drawState.coverageProcInfo(batch);
+
+    GrGeometryProcessor::InitBT init;
+    this->internalConstructor(&init, drawState, colorPOI, coveragePOI, caps, scissorState, dstCopy);
+
+    batch->initBatchTracker(init);
+}
+
+void GrOptDrawState::internalConstructor(GrGeometryProcessor::InitBT* init,
+                                         const GrDrawState& drawState,
+                                         const GrProcOptInfo& colorPOI,
+                                         const GrProcOptInfo& coveragePOI,
+                                         const GrDrawTargetCaps& caps,
+                                         const GrScissorState& scissorState,
+                                         const GrDeviceCoordTexture* dstCopy) {
     // Create XferProcessor from DS's XPFactory
     SkAutoTUnref<GrXferProcessor> xferProcessor(
         drawState.getXPFactory()->createXferProcessor(colorPOI, coveragePOI));
 
     GrColor overrideColor = GrColor_ILLEGAL;
     if (colorPOI.firstEffectiveStageIndex() != 0) {
         overrideColor = colorPOI.inputColorToEffectiveStage();
     }
 
     GrXferProcessor::OptFlags optFlags;
@@ skipping 62 matching lines @@
     fNumColorStages = fFragmentStages.count();
     for (int i = firstCoverageStageIdx; i < drawState.numCoverageStages(); ++i) {
         SkNEW_APPEND_TO_TARRAY(&fFragmentStages,
                                GrPendingFragmentStage,
                                (drawState.fCoverageStages[i]));
         usesLocalCoords = usesLocalCoords ||
                           drawState.fCoverageStages[i].processor()->usesLocalCoords();
     }
 
     // let the GP init the batch tracker
-    GrGeometryProcessor::InitBT init;
-    init.fColorIgnored = SkToBool(optFlags & GrXferProcessor::kIgnoreColor_OptFlag);
-    init.fOverrideColor = init.fColorIgnored ? GrColor_ILLEGAL : overrideColor;
-    init.fCoverageIgnored = SkToBool(optFlags & GrXferProcessor::kIgnoreCoverage_OptFlag);
-    init.fUsesLocalCoords = usesLocalCoords;
-    fPrimitiveProcessor->initBatchTracker(&fBatchTracker, init);
+    init->fColorIgnored = SkToBool(optFlags & GrXferProcessor::kIgnoreColor_OptFlag);
+    init->fOverrideColor = init->fColorIgnored ? GrColor_ILLEGAL : overrideColor;
+    init->fCoverageIgnored = SkToBool(optFlags & GrXferProcessor::kIgnoreCoverage_OptFlag);
+    init->fUsesLocalCoords = usesLocalCoords;
 }
 
 void GrOptDrawState::adjustProgramFromOptimizations(const GrDrawState& ds,
                                                     GrXferProcessor::OptFlags flags,
                                                     const GrProcOptInfo& colorPOI,
                                                     const GrProcOptInfo& coveragePOI,
                                                     int* firstColorStageIdx,
                                                     int* firstCoverageStageIdx) {
     fDescInfo.fReadsDst = false;
     fDescInfo.fReadsFragPosition = false;
@@ skipping 22 matching lines @@
     }
 }
 
 void GrOptDrawState::finalize(GrGpu* gpu) {
     gpu->buildProgramDesc(*this, fDescInfo, fDrawType, &fDesc);
     fFinalized = true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-bool GrOptDrawState::combineIfPossible(const GrOptDrawState& that) {
+bool GrOptDrawState::combineIfPossible(GrOptDrawState& that) {
     if (fDescInfo != that.fDescInfo) {
         return false;
     }
 
     if (this->getRenderTarget() != that.getRenderTarget() ||
         this->fFragmentStages.count() != that.fFragmentStages.count() ||
         this->fNumColorStages != that.fNumColorStages ||
         this->fScissorState != that.fScissorState ||
         this->fDrawType != that.fDrawType ||
         this->fFlags != that.fFlags ||
         this->fStencilSettings != that.fStencilSettings ||
         this->fDrawFace != that.fDrawFace ||
         this->fDstCopy.texture() != that.fDstCopy.texture()) {
         return false;
     }
 
-    if (!this->getPrimitiveProcessor()->canMakeEqual(fBatchTracker,
-                                                     *that.getPrimitiveProcessor(),
-                                                     that.getBatchTracker())) {
+    // TODO remove this when we have Batch.  This is confusing because some OptStates have primitive
+    // processors and some are associated with batches
+    if (SkToBool(this->getPrimitiveProcessor()) != SkToBool(that.getPrimitiveProcessor())) {
+           return false;
+    }
+
+    if (this->getPrimitiveProcessor() && that.getPrimitiveProcessor() &&
+        !this->getPrimitiveProcessor()->canMakeEqual(fBatchTracker,
+                                                         *that.getPrimitiveProcessor(),
+                                                         that.getBatchTracker())) {
         return false;
     }
 
     if (!this->getXferProcessor()->isEqual(*that.getXferProcessor())) {
         return false;
     }
 
     // The program desc comparison should have already assured that the stage counts match.
     SkASSERT(this->numFragmentStages() == that.numFragmentStages());
     for (int i = 0; i < this->numFragmentStages(); i++) {
 
         if (this->getFragmentStage(i) != that.getFragmentStage(i)) {
             return false;
         }
     }
-
-    // Now update the GrPrimitiveProcessor's batch tracker
-    fPrimitiveProcessor->makeEqual(&fBatchTracker, that.getBatchTracker());
     return true;
 }