Expose coord transforms from GrPipeline

src/gpu/GrPipeline.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrPipeline.h"
 
 #include "GrCaps.h"
@@ skipping 69 matching lines @@
     // GrPipelineBuilder's coverageProcInfo (like color above) to set this initial information.
     int firstCoverageStageIdx = 0;
 
     this->adjustProgramFromOptimizations(pipelineBuilder, optFlags, colorPOI, coveragePOI,
                                          &firstColorStageIdx, &firstCoverageStageIdx);
 
     bool usesLocalCoords = false;
 
     // Copy Stages from PipelineBuilder to Pipeline
     for (int i = firstColorStageIdx; i < pipelineBuilder.numColorFragmentStages(); ++i) {
-        SkNEW_APPEND_TO_TARRAY(&fFragmentStages,
-                               GrPendingFragmentStage,
-                               (pipelineBuilder.fColorStages[i]));
-        usesLocalCoords = usesLocalCoords ||
-                          pipelineBuilder.fColorStages[i].processor()->usesLocalCoords();
+        const GrFragmentStage& fps = pipelineBuilder.fColorStages[i];
+        const GrFragmentProcessor* fp = fps.processor();

[bsalomon, 2015/08/05 17:22:12]

does this all work for the nested case?

[joshualitt, 2015/08/05 17:46:21]

good catch

+        SkNEW_APPEND_TO_TARRAY(&fFragmentStages, GrPendingFragmentStage, (fps));
+        usesLocalCoords = usesLocalCoords || fp->usesLocalCoords();
+        for (int t = 0; t < fp->numTransforms(); t++) {
+            fCoordTransforms.push_back(&fp->coordTransform(t));
+        }
     }
 
     fNumColorStages = fFragmentStages.count();
     for (int i = firstCoverageStageIdx; i < pipelineBuilder.numCoverageFragmentStages(); ++i) {
-        SkNEW_APPEND_TO_TARRAY(&fFragmentStages,
-                               GrPendingFragmentStage,
-                               (pipelineBuilder.fCoverageStages[i]));
-        usesLocalCoords = usesLocalCoords ||
-                          pipelineBuilder.fCoverageStages[i].processor()->usesLocalCoords();
+        const GrFragmentStage& fps = pipelineBuilder.fCoverageStages[i];
+        const GrFragmentProcessor* fp = fps.processor();
+        SkNEW_APPEND_TO_TARRAY(&fFragmentStages, GrPendingFragmentStage, (fps));
+        usesLocalCoords = usesLocalCoords || fp->usesLocalCoords();
+        for (int t = 0; t < fp->numTransforms(); t++) {
+            fCoordTransforms.push_back(&fp->coordTransform(t));
+        }
     }
 
     // Setup info we need to pass to GrPrimitiveProcessors that are used with this GrPipeline.
     fInfoForPrimitiveProcessor.fFlags = 0;
     if (!SkToBool(optFlags & GrXferProcessor::kIgnoreColor_OptFlag)) {
         fInfoForPrimitiveProcessor.fFlags |= GrPipelineInfo::kReadsColor_GrPipelineInfoFlag;
     }
     if (GrColor_ILLEGAL != overrideColor) {
         fInfoForPrimitiveProcessor.fFlags |= GrPipelineInfo::kUseOverrideColor_GrPipelineInfoFlag;
         fInfoForPrimitiveProcessor.fOverrideColor = overrideColor;
@@ skipping 31 matching lines @@
         *firstCoverageStageIdx = pipelineBuilder.numCoverageFragmentStages();
     } else {
         if (coveragePOI.readsFragPosition()) {
             fReadsFragPosition = true;
         }
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-bool GrPipeline::isEqual(const GrPipeline& that) const {
+bool GrPipeline::isEqual(const GrPipeline& that, bool ignoreCoordTransforms) const {
     // If we point to the same pipeline, then we are necessarily equal
     if (this == &that) {
         return true;
     }
 
     if (this->getRenderTarget() != that.getRenderTarget() ||
         this->fFragmentStages.count() != that.fFragmentStages.count() ||
         this->fNumColorStages != that.fNumColorStages ||
         this->fScissorState != that.fScissorState ||
         this->fFlags != that.fFlags ||
         this->fStencilSettings != that.fStencilSettings ||
         this->fDrawFace != that.fDrawFace) {
         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)) {
+        if (!this->getFragmentStage(i).processor()->isEqual(*that.getFragmentStage(i).processor(),
+                                                            ignoreCoordTransforms)) {
             return false;
         }
     }
     return true;
 }