Solo gp

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 "GrDrawState.h"
@@ skipping 21 matching lines @@
 
     memcpy(fFixedFunctionVertexAttribIndices,
             drawState.getFixedFunctionVertexAttribIndices(),
             sizeof(fFixedFunctionVertexAttribIndices));
 
 
     fInputColorIsUsed = true;
     fInputCoverageIsUsed = true;
 
     if (drawState.hasGeometryProcessor()) {
-        fGeometryProcessor.reset(SkNEW_ARGS(GrEffectStage, (*drawState.getGeometryProcessor())));
+        fGeometryProcessor.reset(SkNEW_ARGS(GrGeometryStage, (*drawState.getGeometryProcessor())));
     } else {
         fGeometryProcessor.reset(NULL);
     }
 
     this->copyEffectiveColorStages(drawState);
     this->copyEffectiveCoverageStages(drawState);
     this->adjustFromBlendOpts();
     this->getStageStats();
     this->setOutputStateInfo(caps);
 };
@@ skipping 124 matching lines @@
         if (ds.vertexColorsAreOpaque()) {
             color = 0xFF << GrColor_SHIFT_A;
             validComponentFlags = kA_GrColorComponentFlag;
         } else {
             validComponentFlags = 0;
             color = 0; // not strictly necessary but we get false alarms from tools about uninit.
         }
     }
 
     for (int i = 0; i < ds.numColorStages(); ++i) {
-        const GrEffect* effect = ds.getColorStage(i).getEffect();
-        if (!effect->willUseInputColor()) {
+        const GrFragmentProcessor* fp = ds.getColorStage(i).getFragmentProcessor();
+        if (!fp->willUseInputColor()) {
             firstColorStage = i;
             fInputColorIsUsed = false;
         }
-        effect->getConstantColorComponents(&color, &validComponentFlags);
+        fp->getConstantColorComponents(&color, &validComponentFlags);
         if (kRGBA_GrColorComponentFlags == validComponentFlags) {
             firstColorStage = i + 1;
             fColor = color;
             fInputColorIsUsed = true;
             this->removeFixedFunctionVertexAttribs(0x1 << kColor_GrVertexAttribBinding);
         }
     }
     if (firstColorStage < ds.numColorStages()) {
         fColorStages.reset(&ds.getColorStage(firstColorStage),
                            ds.numColorStages() - firstColorStage);
     } else {
         fColorStages.reset();
     }
 }
 
 void GrOptDrawState::copyEffectiveCoverageStages(const GrDrawState& ds) {
     int firstCoverageStage = 0;
 
     // We do not try to optimize out constantColor coverage effects here. It is extremely rare
     // to have a coverage effect that returns a constant value for all four channels. Thus we
     // save having to make extra virtual calls by not checking for it.
 
     // Don't do any optimizations on coverage stages. It should not be the case where we do not use
     // input coverage in an effect
 #ifdef OptCoverageStages
     for (int i = 0; i < ds.numCoverageStages(); ++i) {
-        const GrEffect* effect = ds.getCoverageStage(i).getEffect();
-        if (!effect->willUseInputColor()) {
+        const GrProcessor* processor = ds.getCoverageStage(i).getProcessor();
+        if (!processor->willUseInputColor()) {
             firstCoverageStage = i;
             fInputCoverageIsUsed = false;
         }
     }
 #endif
     if (ds.numCoverageStages() > 0) {
         fCoverageStages.reset(&ds.getCoverageStage(firstCoverageStage),
                               ds.numCoverageStages() - firstCoverageStage);
     } else {
         fCoverageStages.reset();
     }
 }
 
-static void get_stage_stats(const GrEffectStage& stage, bool* readsDst, bool* readsFragPosition) {
-    if (stage.getEffect()->willReadDstColor()) {
+static void get_stage_stats(const GrFragmentStage& stage, bool* readsDst, bool* readsFragPosition) {
+    if (stage.getFragmentProcessor()->willReadDstColor()) {
         *readsDst = true;
     }
-    if (stage.getEffect()->willReadFragmentPosition()) {
+    if (stage.getFragmentProcessor()->willReadFragmentPosition()) {
         *readsFragPosition = true;
     }
 }
+
 void GrOptDrawState::getStageStats() {
     // We will need a local coord attrib if there is one currently set on the optState and we are
     // actually generating some effect code
     fRequiresLocalCoordAttrib = this->hasLocalCoordAttribute() && this->numTotalStages() > 0;
 
     // if 1 == fVACount then that VA must be position, otherwise it contains some attribute which
     // will require a vertexShader
     fRequiresVertexShader = fVACount > 1;
 
     fReadsDst = false;
     fReadsFragPosition = false;
 
     for (int s = 0; s < this->numColorStages(); ++s) {
-        const GrEffectStage& stage = this->getColorStage(s);
+        const GrFragmentStage& stage = this->getColorStage(s);
         get_stage_stats(stage, &fReadsDst, &fReadsFragPosition);
     }
     for (int s = 0; s < this->numCoverageStages(); ++s) {
-        const GrEffectStage& stage = this->getCoverageStage(s);
+        const GrFragmentStage& stage = this->getCoverageStage(s);
         get_stage_stats(stage, &fReadsDst, &fReadsFragPosition);
     }
     if (this->hasGeometryProcessor()) {
-        const GrEffectStage& stage = *this->getGeometryProcessor();
-        get_stage_stats(stage, &fReadsDst, &fReadsFragPosition);
+        const GrGeometryStage& stage = *this->getGeometryProcessor();
+        fReadsFragPosition = fReadsFragPosition || stage.getProcessor()->willReadFragmentPosition();
         SkASSERT(fRequiresVertexShader);
     }
 }
 
 bool GrOptDrawState::operator== (const GrOptDrawState& that) const {
     return this->isEqual(that);
 }