Replace fWillReadFragmentPosition with a bitfield

src/gpu/GrProcOptInfo.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 "GrProcOptInfo.h"
 
 #include "GrGeometryProcessor.h"
 
 #include "batches/GrDrawBatch.h"
 
 void GrProcOptInfo::calcWithInitialValues(const GrFragmentProcessor * const processors[],
                                           int cnt,
                                           GrColor startColor,
                                           GrColorComponentFlags flags,
                                           bool areCoverageStages,
                                           bool isLCD) {
     GrInitInvariantOutput out;
     out.fIsSingleComponent = areCoverageStages;
     out.fColor = startColor;
     out.fValidFlags = flags;
     out.fIsLCDCoverage = isLCD;
     fInOut.reset(out);
-    this->internalCalc(processors, cnt, false);
+    this->internalCalc(processors, cnt);
 }
 
 void GrProcOptInfo::initUsingInvariantOutput(GrInitInvariantOutput invOutput) {
     fInOut.reset(invOutput);
 }
 
 void GrProcOptInfo::completeCalculations(const GrFragmentProcessor * const processors[], int cnt) {
-    this->internalCalc(processors, cnt, false);
+    this->internalCalc(processors, cnt);
 }
 
-void GrProcOptInfo::internalCalc(const GrFragmentProcessor* const processors[],
-                                 int cnt,
-                                 bool initWillReadFragmentPosition) {
+void GrProcOptInfo::internalCalc(const GrFragmentProcessor* const processors[], int cnt) {
     fFirstEffectiveProcessorIndex = 0;
     fInputColorIsUsed = true;
     fInputColor = fInOut.color();
-    fReadsFragPosition = initWillReadFragmentPosition;
+    fBuiltInState = GrProcessor::kNone_BuiltInState;
 
     for (int i = 0; i < cnt; ++i) {
         const GrFragmentProcessor* processor = processors[i];
         fInOut.resetWillUseInputColor();
         processor->computeInvariantOutput(&fInOut);
         SkDEBUGCODE(fInOut.validate());
         if (!fInOut.willUseInputColor()) {
             fFirstEffectiveProcessorIndex = i;
             fInputColorIsUsed = false;
-            // Reset these since we don't care if previous stages read these values
-            fReadsFragPosition = initWillReadFragmentPosition;
+            // Reset these since we will be removing any previous stages that read these values.
+            fBuiltInState = GrProcessor::kNone_BuiltInState;
         }
-        if (processor->willReadFragmentPosition()) {
-            fReadsFragPosition = true;
-        }
+        fBuiltInState |= processor->builtInState();
         if (kRGBA_GrColorComponentFlags == fInOut.validFlags()) {
             fFirstEffectiveProcessorIndex = i + 1;
             fInputColor = fInOut.color();
             fInputColorIsUsed = true;
             // Since we are clearing all previous color stages we are in a state where we have found
             // zero stages that don't multiply the inputColor.
             fInOut.resetNonMulStageFound();
-            // Reset these since we don't care if previous stages read these values
-            fReadsFragPosition = initWillReadFragmentPosition;
+            // Reset these since we will be removing all processors.
+            fBuiltInState = GrProcessor::kNone_BuiltInState;

[Chris Dalton, 2016/02/25 19:19:03]

FYI, this is bad news for a processor that modifies the sample mask. We will
need to come up with some way for these sample mask processors to indicate that
they have side effects and can't be removed.

[joshualitt, 2016/02/25 20:50:27]

Yea, we don't actually remove processors from the coverage side of the pipeline,
so I think this isn't an issue, but it does seem fragile.

[bsalomon, 2016/02/25 21:11:03]

Yeah, querying willModifySampleMask could be the indicator.

         }
     }
 }