Solo gp

src/gpu/GrRODrawState.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 "GrRODrawState.h"
 
 #include "GrDrawTargetCaps.h"
@@ skipping 30 matching lines @@
 
     bool usingVertexCoverage = this->hasCoverageVertexAttribute();
     if (!usingVertexCoverage && this->fCoverage != that.fCoverage) {
         return false;
     }
 
     bool explicitLocalCoords = this->hasLocalCoordAttribute();
     if (this->hasGeometryProcessor()) {
         if (!that.hasGeometryProcessor()) {
             return false;
-        } else if (!GrEffectStage::AreCompatible(*this->getGeometryProcessor(),
-                                                 *that.getGeometryProcessor(),
-                                                 explicitLocalCoords)) {
+        } else if (!GrProcessorStage::AreCompatible(*this->getGeometryProcessor(),
+                                                    *that.getGeometryProcessor(),
+                                                    explicitLocalCoords)) {
             return false;
         }
     } else if (that.hasGeometryProcessor()) {
         return false;
     }
 
     for (int i = 0; i < this->numColorStages(); i++) {
-        if (!GrEffectStage::AreCompatible(this->getColorStage(i), that.getColorStage(i),
-                                          explicitLocalCoords)) {
+        if (!GrProcessorStage::AreCompatible(this->getColorStage(i), that.getColorStage(i),
+                                             explicitLocalCoords)) {
             return false;
         }
     }
     for (int i = 0; i < this->numCoverageStages(); i++) {
-        if (!GrEffectStage::AreCompatible(this->getCoverageStage(i), that.getCoverageStage(i),
-                                          explicitLocalCoords)) {
+        if (!GrProcessorStage::AreCompatible(this->getCoverageStage(i), that.getCoverageStage(i),
+                                             explicitLocalCoords)) {
             return false;
         }
     }
 
     SkASSERT(0 == memcmp(this->fFixedFunctionVertexAttribIndices,
                             that.fFixedFunctionVertexAttribIndices,
                             sizeof(this->fFixedFunctionVertexAttribIndices)));
 
     return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrRODrawState::validateVertexAttribs() const {
     // check consistency of effects and attributes
     GrSLType slTypes[kMaxVertexAttribCnt];
     for (int i = 0; i < kMaxVertexAttribCnt; ++i) {
         slTypes[i] = static_cast<GrSLType>(-1);
     }
 
     if (this->hasGeometryProcessor()) {
-        const GrEffectStage& stage = *this->getGeometryProcessor();
-        const GrEffect* effect = stage.getEffect();
-        SkASSERT(effect);
+        const GrGeometryStage& stage = *this->getGeometryProcessor();
+        const GrGeometryProcessor* gp = stage.getGeometryProcessor();
+        SkASSERT(gp);
         // make sure that any attribute indices have the correct binding type, that the attrib
         // type and effect's shader lang type are compatible, and that attributes shared by
         // multiple effects use the same shader lang type.
-        const GrEffect::VertexAttribArray& s = effect->getVertexAttribs();
+        const GrGeometryProcessor::VertexAttribArray& s = gp->getVertexAttribs();
 
         int effectIndex = 0;
         for (int index = 0; index < fVACount; index++) {
-            if (kEffect_GrVertexAttribBinding != fVAPtr[index].fBinding) {
+            if (kGeometryProcessor_GrVertexAttribBinding != fVAPtr[index].fBinding) {
                 // we only care about effect bindings
                 continue;
             }
             SkASSERT(effectIndex < s.count());
             GrSLType effectSLType = s[effectIndex].getType();
             GrVertexAttribType attribType = fVAPtr[index].fType;
             int slVecCount = GrSLTypeVectorCount(effectSLType);
             int attribVecCount = GrVertexAttribTypeVectorCount(attribType);
             if (slVecCount != attribVecCount ||
                 (static_cast<GrSLType>(-1) != slTypes[index] && slTypes[index] != effectSLType)) {
@@ skipping 20 matching lines @@
     // Initialize to an unknown starting coverage if per-vertex coverage is specified.
     if (this->hasCoverageVertexAttribute()) {
         validComponentFlags = 0;
     } else {
         coverage = fCoverage;
         validComponentFlags = kRGBA_GrColorComponentFlags;
     }
 
     // Run through the coverage stages and see if the coverage will be all ones at the end.
     if (this->hasGeometryProcessor()) {
-        const GrEffect* effect = fGeometryProcessor->getEffect();
-        effect->getConstantColorComponents(&coverage, &validComponentFlags);
+        const GrGeometryProcessor* gp = fGeometryProcessor->getGeometryProcessor();
+        gp->getConstantColorComponents(&coverage, &validComponentFlags);
     }
     for (int s = 0; s < this->numCoverageStages(); ++s) {
-        const GrEffect* effect = this->getCoverageStage(s).getEffect();
-        effect->getConstantColorComponents(&coverage, &validComponentFlags);
+        const GrProcessor* processor = this->getCoverageStage(s).getProcessor();
+        processor->getConstantColorComponents(&coverage, &validComponentFlags);
     }
     return (kRGBA_GrColorComponentFlags == validComponentFlags) && (0xffffffff == coverage);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrRODrawState::willEffectReadDstColor() const {
     if (!this->isColorWriteDisabled()) {
         for (int s = 0; s < this->numColorStages(); ++s) {
-            if (this->getColorStage(s).getEffect()->willReadDstColor()) {
+            if (this->getColorStage(s).getFragmentProcessor()->willReadDstColor()) {
                 return true;
             }
         }
     }
     for (int s = 0; s < this->numCoverageStages(); ++s) {
-        if (this->getCoverageStage(s).getEffect()->willReadDstColor()) {
+        if (this->getCoverageStage(s).getFragmentProcessor()->willReadDstColor()) {
             return true;
         }
     }
-    if (this->hasGeometryProcessor()) {
-        if (fGeometryProcessor->getEffect()->willReadDstColor()) {
-            return true;
-        }
-    }
     return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrRODrawState::BlendOptFlags GrRODrawState::getBlendOpts(bool forceCoverage,
                                                          GrBlendCoeff* srcCoeff,
                                                          GrBlendCoeff* dstCoeff) const {
     GrBlendCoeff bogusSrcCoeff, bogusDstCoeff;
     if (NULL == srcCoeff) {
@@ skipping 131 matching lines @@
             validComponentFlags = 0;
             color = 0; // not strictly necessary but we get false alarms from tools about uninit.
         }
     } else {
         validComponentFlags = kRGBA_GrColorComponentFlags;
         color = this->getColor();
     }
 
     // Run through the color stages
     for (int s = 0; s < this->numColorStages(); ++s) {
-        const GrEffect* effect = this->getColorStage(s).getEffect();
-        effect->getConstantColorComponents(&color, &validComponentFlags);
+        const GrProcessor* processor = this->getColorStage(s).getProcessor();
+        processor->getConstantColorComponents(&color, &validComponentFlags);
     }
 
     // Check whether coverage is treated as color. If so we run through the coverage computation.
     if (this->isCoverageDrawing()) {
         // The shader generated for coverage drawing runs the full coverage computation and then
         // makes the shader output be the multiplication of color and coverage. We mirror that here.
         GrColor coverage;
         uint32_t coverageComponentFlags;
         if (this->hasCoverageVertexAttribute()) {
             coverageComponentFlags = 0;
             coverage = 0; // suppresses any warnings.
         } else {
             coverageComponentFlags = kRGBA_GrColorComponentFlags;
             coverage = this->getCoverageColor();
         }
 
         // Run through the coverage stages
         for (int s = 0; s < this->numCoverageStages(); ++s) {
-            const GrEffect* effect = this->getCoverageStage(s).getEffect();
-            effect->getConstantColorComponents(&coverage, &coverageComponentFlags);
+            const GrProcessor* processor = this->getCoverageStage(s).getProcessor();
+            processor->getConstantColorComponents(&coverage, &coverageComponentFlags);
         }
 
         // Since the shader will multiply coverage and color, the only way the final A==1 is if
         // coverage and color both have A==1.
         return (kA_GrColorComponentFlag & validComponentFlags & coverageComponentFlags) &&
                 0xFF == GrColorUnpackA(color) && 0xFF == GrColorUnpackA(coverage);
 
     }
 
     return (kA_GrColorComponentFlag & validComponentFlags) && 0xFF == GrColorUnpackA(color);
 }