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);
+                GrGLInstalledGeoProc* geometryProcessor,
+                GrGLInstalledFragProcs* fragmentProcessors);
 
     // Sets the texture units for samplers.
     void initSamplerUniforms();
-    void initSamplers(GrGLInstalledProcessors* processors, int* texUnitIdx);
+    void initSamplers(GrGLInstalledProc*, 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) {
-        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();
-            installedProcessors->fGLProcessors[e]->setData(fProgramDataManager, effect);
-            this->setTransformData(*effectStages[e], e, installedProcessors);
-            this->bindTextures(installedProcessors, effect, e);
-        }
-    }
-    virtual void setTransformData(const GrProcessorStage& effectStage,
-                                  int effectIdx,
-                                  GrGLInstalledProcessors* pe);
-    void bindTextures(const GrGLInstalledProcessors*, const GrProcessor&, int effectIdx);
+    void setFragmentData(const GrOptDrawState&);
+    virtual void setTransformData(const GrFragmentStage& effectStage, GrGLInstalledFragProc* pe);
+    void bindTextures(const GrGLInstalledProc*, const GrProcessor&);
 
     /*
      * 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&);
 
     // these reflect the current values of uniforms (GL uniform values travel with program)
     MatrixState fMatrixState;
     GrColor fColor;
     GrColor fCoverage;
     int fDstCopyTexUnit;
     BuiltinUniformHandles fBuiltinUniformHandles;
     GrGLuint fProgramID;
 
     // the installed effects
-    SkAutoTUnref<GrGLInstalledProcessors> fGeometryProcessor;
-    SkAutoTUnref<GrGLInstalledProcessors> fColorEffects;
-    SkAutoTUnref<GrGLInstalledProcessors> fCoverageEffects;
+    SkAutoTDelete<GrGLInstalledGeoProc> fGeometryProcessor;
+    SkAutoTUnref<GrGLInstalledFragProcs> fFragmentProcessors;
 
     GrGLProgramDesc fDesc;
     GrGpuGL* fGpu;
     GrGLProgramDataManager fProgramDataManager;
 
     friend class GrGLProgramBuilder;
 
     typedef SkRefCnt INHERITED;
 };
 
 /*
  * Below are slight specializations of the program object for the different types of programs
  * The default GrGL programs consist of at the very least a vertex and fragment shader.
  * Legacy Nvpr only has a fragment shader, 1.3+ Nvpr ignores the vertex shader, but both require
  * specialized methods for setting transform data. Both types of NVPR also require setting the
  * projection matrix through a special function call
  */
 class GrGLNvprProgramBase : public GrGLProgram {
 protected:
     GrGLNvprProgramBase(GrGpuGL*,
                         const GrGLProgramDesc&,
                         const BuiltinUniformHandles&,
                         GrGLuint programID,
                         const UniformInfoArray&,
-                        GrGLInstalledProcessors* colorProcessors,
-                        GrGLInstalledProcessors* coverageProcessors);
+                        GrGLInstalledFragProcs* fragmentProcessors);
     virtual void onSetMatrixAndRenderTargetHeight(GrGpu::DrawType, const GrOptDrawState&);
 
     typedef GrGLProgram INHERITED;
 };
 
 class GrGLNvprProgram : public GrGLNvprProgramBase {
 public:
       virtual bool hasVertexShader() const SK_OVERRIDE { return true; }
 
 private:
     typedef GrGLNvprProgramBuilder::SeparableVaryingInfo SeparableVaryingInfo;
     typedef GrGLNvprProgramBuilder::SeparableVaryingInfoArray SeparableVaryingInfoArray;
     GrGLNvprProgram(GrGpuGL*,
                     const GrGLProgramDesc&,
                     const BuiltinUniformHandles&,
                     GrGLuint programID,
                     const UniformInfoArray&,
-                    GrGLInstalledProcessors* colorProcessors,
-                    GrGLInstalledProcessors* coverageProcessors,
+                    GrGLInstalledFragProcs* fragmentProcessors,
                     const SeparableVaryingInfoArray& separableVaryings);
     virtual void didSetData(GrGpu::DrawType) SK_OVERRIDE;
-    virtual void setTransformData(const GrProcessorStage&,
-                                  int effectIdx,
-                                  GrGLInstalledProcessors*) SK_OVERRIDE;
+    virtual void setTransformData(const GrFragmentStage&, GrGLInstalledFragProc*) SK_OVERRIDE;
 
     struct Varying {
         GrGLint     fLocation;
         SkDEBUGCODE(
             GrSLType    fType;
         );
     };
     SkTArray<Varying, true> fVaryings;
 
     friend class GrGLNvprProgramBuilder;
 
     typedef GrGLNvprProgramBase INHERITED;
 };
 
 class GrGLLegacyNvprProgram : public GrGLNvprProgramBase {
 public:
     virtual bool hasVertexShader() const SK_OVERRIDE { return false; }
 
 private:
     GrGLLegacyNvprProgram(GrGpuGL* gpu,
                           const GrGLProgramDesc& desc,
                           const BuiltinUniformHandles&,
                           GrGLuint programID,
                           const UniformInfoArray&,
-                          GrGLInstalledProcessors* colorProcessors,
-                          GrGLInstalledProcessors* coverageProcessors,
+                          GrGLInstalledFragProcs* fragmentProcessors,
                           int texCoordSetCnt);
     virtual void didSetData(GrGpu::DrawType) SK_OVERRIDE;
-    virtual void setTransformData(const GrProcessorStage&,
-                                  int effectIdx,
-                                  GrGLInstalledProcessors*) SK_OVERRIDE;
+    virtual void setTransformData(const GrFragmentStage&, GrGLInstalledFragProc*) SK_OVERRIDE;
 
     int fTexCoordSetCnt;
 
     friend class GrGLLegacyNvprProgramBuilder;
 
     typedef GrGLNvprProgramBase INHERITED;
 };
 
 #endif