Opt state takes a GP instead of a GeometryStage

src/gpu/gl/GrGLProgram.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef GrGLProgram_DEFINED
 #define GrGLProgram_DEFINED
@@ skipping 134 matching lines @@
     };
 
     /**
      * This function uploads uniforms and calls each GrGLProcessor's setData. It is called before a
      * draw occurs using the program after the program has already been bound. It also uses the
      * GrGpuGL object to bind the textures required by the GrGLProcessors. The color and coverage
      * stages come from GrGLProgramDesc::Build().
      */
     void setData(const GrOptDrawState&,
                  GrGpu::DrawType,
-                 const GrGeometryStage* geometryProcessor,
-                 const GrFragmentStage* colorStages[],
-                 const GrFragmentStage* coverageStages[],
                  const GrDeviceCoordTexture* dstCopy, // can be NULL
                  SharedGLState*);
 
 protected:
     typedef GrGLProgramDataManager::UniformHandle UniformHandle;
     typedef GrGLProgramDataManager::UniformInfoArray UniformInfoArray;
 
     GrGLProgram(GrGpuGL*,
                 const GrGLProgramDesc&,
                 const BuiltinUniformHandles&,
                 GrGLuint programID,
                 const UniformInfoArray&,
                 GrGLInstalledProcessors* geometryProcessor,
                 GrGLInstalledProcessors* colorProcessors,
                 GrGLInstalledProcessors* coverageProcessors);
 
     // Sets the texture units for samplers.
     void initSamplerUniforms();
     void initSamplers(GrGLInstalledProcessors* processors, int* texUnitIdx);
 
     // Helper for setData(). Makes GL calls to specify the initial color when there is not
     // per-vertex colors.
     void setColor(const GrOptDrawState&, GrColor color, SharedGLState*);
 
     // Helper for setData(). Makes GL calls to specify the initial coverage when there is not
     // per-vertex coverages.
     void setCoverage(const GrOptDrawState&, GrColor coverage, SharedGLState*);
 
     // A templated helper to loop over effects, set the transforms(via subclass) and bind textures
-    template <class ProcessorStage>
-    void setData(const ProcessorStage* effectStages[],
-                 GrGLInstalledProcessors* installedProcessors) {
+    template <class StageMapper>
+    void setData(const GrOptDrawState& optState, GrGLInstalledProcessors* installedProcessors) {

[bsalomon, 2014/10/09 18:35:45]

Is it useful that this operates on an array? It's getting really convoluted with
StageMapper.. can we just make a simpler non-templated function that is called
once for each processor? Maybe GrODS should just have one array of fragment
processors?

[egdaniel, 2014/10/09 18:52:04]

I can definitely make GrODS have a single FP array if that is request. It would
still have getColorStage(s), getCoverageStage(s), and add getFragmentStage(s).
Would this be suitable interfase or would you want some other type of access?
Also would have a numFragStages() I suppose.

         int numEffects = installedProcessors->fGLProcessors.count();
         SkASSERT(numEffects == installedProcessors->fTransforms.count());
         SkASSERT(numEffects == installedProcessors->fSamplers.count());
         for (int e = 0; e < numEffects; ++e) {
-            const GrProcessor& effect = *effectStages[e]->getProcessor();
+            const GrFragmentStage& stage = StageMapper::GetStage(optState, e);
+            SkASSERT(stage.getProcessor());
+            const GrProcessor& effect = *stage.getProcessor();
             installedProcessors->fGLProcessors[e]->setData(fProgramDataManager, effect);
-            this->setTransformData(*effectStages[e], e, installedProcessors);
-            this->bindTextures(installedProcessors, effect, e);
+            this->setTransformData(stage, e, installedProcessors);
+            this->bindTextures(*installedProcessors, effect, e);
         }
     }
-    virtual void setTransformData(const GrProcessorStage& effectStage,
+    virtual void setTransformData(const GrFragmentStage& effectStage,
                                   int effectIdx,
                                   GrGLInstalledProcessors* pe);
-    void bindTextures(const GrGLInstalledProcessors*, const GrProcessor&, int effectIdx);
+    void bindTextures(const GrGLInstalledProcessors&, const GrProcessor&, int effectIdx);
 
     /*
      * Legacy NVPR needs a hook here to flush path tex gen settings.
      * TODO when legacy nvpr is removed, remove this call.
      */
     virtual void didSetData(GrGpu::DrawType);
 
     // Helper for setData() that sets the view matrix and loads the render target height uniform
     void setMatrixAndRenderTargetHeight(GrGpu::DrawType, const GrOptDrawState&);
     virtual void onSetMatrixAndRenderTargetHeight(GrGpu::DrawType, const GrOptDrawState&);
@@ skipping 50 matching lines @@
     typedef GrGLNvprProgramBuilder::SeparableVaryingInfoArray SeparableVaryingInfoArray;
     GrGLNvprProgram(GrGpuGL*,
                     const GrGLProgramDesc&,
                     const BuiltinUniformHandles&,
                     GrGLuint programID,
                     const UniformInfoArray&,
                     GrGLInstalledProcessors* colorProcessors,
                     GrGLInstalledProcessors* coverageProcessors,
                     const SeparableVaryingInfoArray& separableVaryings);
     virtual void didSetData(GrGpu::DrawType) SK_OVERRIDE;
-    virtual void setTransformData(const GrProcessorStage&,
+    virtual void setTransformData(const GrFragmentStage&,
                                   int effectIdx,
                                   GrGLInstalledProcessors*) SK_OVERRIDE;
 
     struct Varying {
         GrGLint     fLocation;
         SkDEBUGCODE(
             GrSLType    fType;
         );
     };
     SkTArray<Varying, true> fVaryings;
@@ skipping 10 matching lines @@
 private:
     GrGLLegacyNvprProgram(GrGpuGL* gpu,
                           const GrGLProgramDesc& desc,
                           const BuiltinUniformHandles&,
                           GrGLuint programID,
                           const UniformInfoArray&,
                           GrGLInstalledProcessors* colorProcessors,
                           GrGLInstalledProcessors* coverageProcessors,
                           int texCoordSetCnt);
     virtual void didSetData(GrGpu::DrawType) SK_OVERRIDE;
-    virtual void setTransformData(const GrProcessorStage&,
+    virtual void setTransformData(const GrFragmentStage&,
                                   int effectIdx,
                                   GrGLInstalledProcessors*) SK_OVERRIDE;
 
     int fTexCoordSetCnt;
 
     friend class GrGLLegacyNvprProgramBuilder;
 
     typedef GrGLNvprProgramBase INHERITED;
 };
 
 #endif