Revert of removing equality / compute invariant loops from GrGeometryProcessors

src/gpu/GrDefaultGeoProcFactory.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 "GrDefaultGeoProcFactory.h"
 
 #include "GrInvariantOutput.h"
 #include "gl/GrGLGeometryProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 /*
  * The default Geometry Processor simply takes position and multiplies it by the uniform view
  * matrix. It also leaves coverage untouched.  Behind the scenes, we may add per vertex color or
  * local coords.
  */
 typedef GrDefaultGeoProcFactory Flag;
 
 class DefaultGeoProc : public GrGeometryProcessor {
 public:
     static GrGeometryProcessor* Create(uint32_t gpTypeFlags,
                                        GrColor color,
                                        const SkMatrix& viewMatrix,
                                        const SkMatrix& localMatrix,
+                                       bool opaqueVertexColors,
                                        uint8_t coverage) {
         return SkNEW_ARGS(DefaultGeoProc, (gpTypeFlags,
                                            color,
                                            viewMatrix,
                                            localMatrix,
+                                           opaqueVertexColors,
                                            coverage));
     }
 
     const char* name() const override { return "DefaultGeometryProcessor"; }
 
     const Attribute* inPosition() const { return fInPosition; }
     const Attribute* inColor() const { return fInColor; }
     const Attribute* inLocalCoords() const { return fInLocalCoords; }
     const Attribute* inCoverage() const { return fInCoverage; }
     uint8_t coverage() const { return fCoverage; }
 
     void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override {
         BatchTracker* local = bt->cast<BatchTracker>();
         local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init,
                                                    SkToBool(fInColor));
 
         bool hasVertexCoverage = SkToBool(fInCoverage) && !init.fCoverageIgnored;
         bool covIsSolidWhite = !hasVertexCoverage && 0xff == this->coverage();
         if (covIsSolidWhite) {
             local->fInputCoverageType = kAllOnes_GrGPInput;
         } else if (!hasVertexCoverage) {
             local->fInputCoverageType = kUniform_GrGPInput;
             local->fCoverage = this->coverage();
         } else if (hasVertexCoverage) {
             SkASSERT(fInCoverage);
             local->fInputCoverageType = kAttribute_GrGPInput;
         } else {
             local->fInputCoverageType = kIgnored_GrGPInput;
         }
+
         local->fUsesLocalCoords = init.fUsesLocalCoords;
     }
 
+    bool onCanMakeEqual(const GrBatchTracker& m,
+                        const GrGeometryProcessor& that,
+                        const GrBatchTracker& t) const override {
+        const BatchTracker& mine = m.cast<BatchTracker>();
+        const BatchTracker& theirs = t.cast<BatchTracker>();
+        return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
+                                       that, theirs.fUsesLocalCoords) &&
+               CanCombineOutput(mine.fInputColorType, mine.fColor,
+                                theirs.fInputColorType, theirs.fColor) &&
+               CanCombineOutput(mine.fInputCoverageType, mine.fCoverage,
+                                theirs.fInputCoverageType, theirs.fCoverage);
+    }
+
     class GLProcessor : public GrGLGeometryProcessor {
     public:
         GLProcessor(const GrGeometryProcessor& gp, const GrBatchTracker&)
             : fColor(GrColor_ILLEGAL), fCoverage(0xff) {}
 
         void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {
             const DefaultGeoProc& gp = args.fGP.cast<DefaultGeoProc>();
             GrGLGPBuilder* pb = args.fPB;
             GrGLVertexBuilder* vsBuilder = pb->getVertexShaderBuilder();
             GrGLGPFragmentBuilder* fs = args.fPB->getFragmentShaderBuilder();
@@ skipping 86 matching lines @@
     virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt,
                                                      const GrGLCaps&) const override {
         return SkNEW_ARGS(GLProcessor, (*this, bt));
     }
 
 private:
     DefaultGeoProc(uint32_t gpTypeFlags,
                    GrColor color,
                    const SkMatrix& viewMatrix,
                    const SkMatrix& localMatrix,
+                   bool opaqueVertexColors,
                    uint8_t coverage)
-        : INHERITED(color, viewMatrix, localMatrix)
+        : INHERITED(color, viewMatrix, localMatrix, opaqueVertexColors)
         , fInPosition(NULL)
         , fInColor(NULL)
         , fInLocalCoords(NULL)
         , fInCoverage(NULL)
         , fCoverage(coverage)
         , fFlags(gpTypeFlags) {
         this->initClassID<DefaultGeoProc>();
         bool hasColor = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kColor_GPType);
         bool hasLocalCoord = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kLocalCoord_GPType);
         bool hasCoverage = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kCoverage_GPType);
         fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType));
         if (hasColor) {
             fInColor = &this->addVertexAttrib(Attribute("inColor", kVec4ub_GrVertexAttribType));
+            this->setHasVertexColor();
         }
         if (hasLocalCoord) {
             fInLocalCoords = &this->addVertexAttrib(Attribute("inLocalCoord",
                                                                 kVec2f_GrVertexAttribType));
             this->setHasLocalCoords();
         }
         if (hasCoverage) {
             fInCoverage = &this->addVertexAttrib(Attribute("inCoverage",
                                                              kFloat_GrVertexAttribType));
         }
     }
 
+    bool onIsEqual(const GrGeometryProcessor& other) const override {
+        const DefaultGeoProc& gp = other.cast<DefaultGeoProc>();
+        return gp.fFlags == this->fFlags;
+    }
+
+    void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
+        if (fInCoverage) {
+            out->setUnknownSingleComponent();
+        } else {
+            // uniform coverage
+            out->setKnownSingleComponent(this->coverage());
+        }
+    }
+
     struct BatchTracker {
         GrGPInput fInputColorType;
         GrGPInput fInputCoverageType;
         GrColor  fColor;
         GrColor  fCoverage;
         bool fUsesLocalCoords;
     };
 
     const Attribute* fInPosition;
     const Attribute* fInColor;
@@ skipping 21 matching lines @@
         flags |= GrDefaultGeoProcFactory::kCoverage_GPType;
     }
     if (random->nextBool()) {
         flags |= GrDefaultGeoProcFactory::kLocalCoord_GPType;
     }
 
     return DefaultGeoProc::Create(flags,
                                   GrRandomColor(random),
                                   GrProcessorUnitTest::TestMatrix(random),
                                   GrProcessorUnitTest::TestMatrix(random),
+                                  random->nextBool(),
                                   GrRandomCoverage(random));
 }
 
 const GrGeometryProcessor* GrDefaultGeoProcFactory::Create(uint32_t gpTypeFlags,
                                                            GrColor color,
                                                            const SkMatrix& viewMatrix,
                                                            const SkMatrix& localMatrix,
+                                                           bool opaqueVertexColors,
                                                            uint8_t coverage) {
     return DefaultGeoProc::Create(gpTypeFlags,
                                   color,
                                   viewMatrix,
                                   localMatrix,
+                                  opaqueVertexColors,
                                   coverage);
 }