Revert of Opt state takes a GP instead of a GeometryStage

src/gpu/gl/builders/GrGLProgramBuilder.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLProgramBuilder_DEFINED
 #define GrGLProgramBuilder_DEFINED
 
 #include "GrGLFragmentShaderBuilder.h"
 #include "GrGLGeometryShaderBuilder.h"
 #include "GrGLVertexShaderBuilder.h"
 #include "../GrGLProgramDataManager.h"
 #include "../GrGLUniformHandle.h"
 
+class GrGLInstalledProcessors;
+
 /*
  * This is the base class for a series of interfaces.  This base class *MUST* remain abstract with
  * NO data members because it is used in multiple interface inheritance.
  * Heirarchy:
  *                      GrGLUniformBuilder
  *                     /                  \
  *                GrGLFPBuilder       GrGLGPBuilder
  *                     \                  /
  *                     GrGLProgramBuilder(internal use only)
  */
@@ skipping 62 matching lines @@
 /* a specializations for FPs. Lets the user add uniforms and FS code */
 class GrGLFPBuilder : public virtual GrGLUniformBuilder {
 public:
     virtual GrGLFPFragmentBuilder* getFragmentShaderBuilder() = 0;
 
     /*
      * *NOTE* NO MEMBERS ALLOWED, MULTIPLE INHERITANCE
      */
 };
 
-struct GrGLInstalledProc;
-struct GrGLInstalledGeoProc;
-struct GrGLInstalledFragProc;
-struct GrGLInstalledFragProcs;
-
 /*
  * Please note - no diamond problems because of virtual inheritance.  Also, both base classes
  * are pure virtual with no data members.  This is the base class for program building.
  * Subclasses are nearly identical but each has their own way of emitting transforms.  State for
  * each of the elements of the shader pipeline, ie vertex, fragment, geometry, etc, lives in those
  * respective builders
 */
 class GrGLProgramBuilder : public GrGLGPBuilder,
                            public GrGLFPBuilder {
 public:
     /** Generates a shader program.
      *
      * The program implements what is specified in the stages given as input.
      * After successful generation, the builder result objects are available
      * to be used.
      * @return true if generation was successful.
      */
     static GrGLProgram* CreateProgram(const GrOptDrawState&,
                                       const GrGLProgramDesc&,
                                       GrGpu::DrawType,
+                                      const GrGeometryStage* inGeometryProcessor,
+                                      const GrFragmentStage* inColorStages[],
+                                      const GrFragmentStage* inCoverageStages[],
                                       GrGpuGL* gpu);
 
     virtual UniformHandle addUniform(uint32_t visibility,
                                      GrSLType type,
                                      const char* name,
                                      const char** outName = NULL) SK_OVERRIDE {
         return this->addUniformArray(visibility, type, name, GrGLShaderVar::kNonArray, outName);
     }
     virtual UniformHandle addUniformArray(uint32_t visibility,
                                           GrSLType type,
                                           const char* name,
                                           int arrayCount,
                                           const char** outName = NULL) SK_OVERRIDE;
 
     virtual const GrGLShaderVar& getUniformVariable(UniformHandle u) const SK_OVERRIDE {
         return fUniforms[u.toShaderBuilderIndex()].fVariable;
     }
 
     virtual const char* getUniformCStr(UniformHandle u) const SK_OVERRIDE {
         return this->getUniformVariable(u).c_str();
     }
 
     virtual const GrGLContextInfo& ctxInfo() const SK_OVERRIDE;
 
     virtual GrGpuGL* gpu() const SK_OVERRIDE { return fGpu; }
 
     virtual GrGLFPFragmentBuilder* getFragmentShaderBuilder() SK_OVERRIDE { return &fFS; }
     virtual GrGLVertexBuilder* getVertexShaderBuilder() SK_OVERRIDE { return &fVS; }
 
-    virtual void addVarying(
-            GrSLType type,
-            const char* name,
-            const char** vsOutName = NULL,
-            const char** fsInName = NULL,
-            GrGLShaderVar::Precision fsPrecision=GrGLShaderVar::kDefault_Precision) SK_OVERRIDE;
+    virtual void addVarying(GrSLType type,
+                            const char* name,
+                            const char** vsOutName = NULL,
+                            const char** fsInName = NULL,
+                            GrGLShaderVar::Precision fsPrecision=GrGLShaderVar::kDefault_Precision);
 
     // Handles for program uniforms (other than per-effect uniforms)
     struct BuiltinUniformHandles {
         UniformHandle       fViewMatrixUni;
         UniformHandle       fRTAdjustmentUni;
         UniformHandle       fColorUni;
         UniformHandle       fCoverageUni;
 
         // We use the render target height to provide a y-down frag coord when specifying
         // origin_upper_left is not supported.
         UniformHandle       fRTHeightUni;
 
         // Uniforms for computing texture coords to do the dst-copy lookup
         UniformHandle       fDstCopyTopLeftUni;
         UniformHandle       fDstCopyScaleUni;
         UniformHandle       fDstCopySamplerUni;
     };
 
 protected:
-    typedef GrGLProgramDesc::ProcKeyProvider ProcKeyProvider;
-    typedef GrGLProgramDataManager::UniformInfo UniformInfo;
-    typedef GrGLProgramDataManager::UniformInfoArray UniformInfoArray;
-
     static GrGLProgramBuilder* CreateProgramBuilder(const GrGLProgramDesc&,
                                                     const GrOptDrawState&,
                                                     GrGpu::DrawType,
                                                     bool hasGeometryProcessor,
                                                     GrGpuGL*);
 
     GrGLProgramBuilder(GrGpuGL*, const GrOptDrawState&, const GrGLProgramDesc&);
 
     const GrOptDrawState& optState() const { return fOptState; }
     const GrGLProgramDesc& desc() const { return fDesc; }
     const GrGLProgramDesc::KeyHeader& header() const { return fDesc.getHeader(); }
 
     // Generates a name for a variable. The generated string will be name prefixed by the prefix
     // char (unless the prefix is '\0'). It also mangles the name to be stage-specific if we're
     // generating stage code.
     void nameVariable(SkString* out, char prefix, const char* name);
     void setupUniformColorAndCoverageIfNeeded(GrGLSLExpr4* inputColor, GrGLSLExpr4* inputCoverage);
-    void emitAndInstallProcs(const GrOptDrawState& optState,
-                             GrGLSLExpr4* inputColor,
-                             GrGLSLExpr4* inputCoverage);
-    void emitAndInstallFragProcs(int procOffset, int numProcs, GrGLSLExpr4* inOut);
-    template <class Proc>
-    void emitAndInstallProc(const Proc&,
-                            int index,
-                            const ProcKeyProvider,
-                            const GrGLSLExpr4& input,
-                            GrGLSLExpr4* output);
-
-    // these emit functions help to keep the createAndEmitProcessors template general
-    void emitAndInstallProc(const GrFragmentStage&,
-                            const GrProcessorKey&,
-                            const char* outColor,
-                            const char* inColor);
-    void emitAndInstallProc(const GrGeometryProcessor&,
-                            const GrProcessorKey&,
-                            const char* outColor,
-                            const char* inColor);
+    void createAndEmitProcessors(const GrGeometryStage* geometryProcessor,
+                                 const GrFragmentStage* colorStages[],
+                                 const GrFragmentStage* coverageStages[],
+                                 GrGLSLExpr4* inputColor,
+                                 GrGLSLExpr4* inputCoverage);
+    template <class ProcessorStage>
+    void createAndEmitProcessors(const ProcessorStage*[],
+                                 int effectCnt,
+                                 const GrGLProgramDesc::EffectKeyProvider&,
+                                 GrGLSLExpr4* fsInOutColor,
+                                 GrGLInstalledProcessors*);
     void verify(const GrGeometryProcessor&);
     void verify(const GrFragmentProcessor&);
     void emitSamplers(const GrProcessor&,
                       GrGLProcessor::TextureSamplerArray* outSamplers,
-                      GrGLInstalledProc*);
+                      GrGLInstalledProcessors*);
 
     // each specific program builder has a distinct transform and must override this function
-    virtual void emitTransforms(const GrFragmentStage&,
+    virtual void emitTransforms(const GrProcessorStage&,
                                 GrGLProcessor::TransformedCoordsArray* outCoords,
-                                GrGLInstalledFragProc*);
+                                GrGLInstalledProcessors*);
     GrGLProgram* finalize();
     void bindUniformLocations(GrGLuint programID);
     bool checkLinkStatus(GrGLuint programID);
     void resolveUniformLocations(GrGLuint programID);
+
     void cleanupProgram(GrGLuint programID, const SkTDArray<GrGLuint>& shaderIDs);
     void cleanupShaders(const SkTDArray<GrGLuint>& shaderIDs);
 
     // Subclasses create different programs
     virtual GrGLProgram* createProgram(GrGLuint programID);
 
     void appendUniformDecls(ShaderVisibility, SkString*) const;
 
     // reset is called by program creator between each processor's emit code.  It increments the
     // stage offset for variable name mangling, and also ensures verfication variables in the
@@ skipping 19 matching lines @@
     public:
         AutoStageAdvance(GrGLProgramBuilder* pb) : fPB(pb) { fPB->reset(); }
         ~AutoStageAdvance() { fPB->exitStage(); }
     private:
         GrGLProgramBuilder* fPB;
     };
     void exitStage() { fOutOfStage = true; }
     void enterStage() { fOutOfStage = false; }
     int stageIndex() const { return fStageIndex; }
 
+    typedef GrGLProgramDesc::EffectKeyProvider EffectKeyProvider;
+    typedef GrGLProgramDataManager::UniformInfo UniformInfo;
+    typedef GrGLProgramDataManager::UniformInfoArray UniformInfoArray;
+
     // number of each input/output type in a single allocation block, used by many builders
     static const int kVarsPerBlock;
 
     BuiltinUniformHandles fUniformHandles;
     GrGLVertexBuilder fVS;
     GrGLGeometryBuilder fGS;
     GrGLFragmentShaderBuilder fFS;
     bool fOutOfStage;
     int fStageIndex;
 
-    GrGLInstalledGeoProc* fGeometryProcessor;
-    SkAutoTUnref<GrGLInstalledFragProcs> fFragmentProcessors;
+    SkAutoTUnref<GrGLInstalledProcessors> fGeometryProcessor;
+    SkAutoTUnref<GrGLInstalledProcessors> fColorEffects;
+    SkAutoTUnref<GrGLInstalledProcessors> fCoverageEffects;
 
     const GrOptDrawState& fOptState;
     const GrGLProgramDesc& fDesc;
     GrGpuGL* fGpu;
     UniformInfoArray fUniforms;
 
     friend class GrGLShaderBuilder;
     friend class GrGLVertexBuilder;
     friend class GrGLFragmentShaderBuilder;
     friend class GrGLGeometryBuilder;
 };
 
 /**
- * The below structs represent processors installed in programs.  All processors can have texture
- * samplers, but only frag processors have coord transforms, hence the need for different structs
+ * This class encapsulates an array of GrGLProcessors and their supporting data (coord transforms
+ * and textures). It is built by GrGLProgramBuilder, then used to manage the necessary GL
+ * state and shader uniforms in GLPrograms.  Its just Plain old data, and as such is entirely public
+ *
+ * TODO We really don't need this class to have an array of processors.  It makes sense for it
+ * to just have one, also break out the transforms
  */
-struct GrGLInstalledProc {
-     typedef GrGLProgramDataManager::UniformHandle UniformHandle;
+class GrGLInstalledProcessors : public SkRefCnt {
+public:
+    GrGLInstalledProcessors(int reserveCount, bool hasExplicitLocalCoords = false)
+        : fGLProcessors(reserveCount)
+        , fSamplers(reserveCount)
+        , fTransforms(reserveCount)
+        , fHasExplicitLocalCoords(hasExplicitLocalCoords) {
+    }
 
-     struct Sampler {
-         SkDEBUGCODE(Sampler() : fTextureUnit(-1) {})
-         UniformHandle  fUniform;
-         int            fTextureUnit;
-     };
-     SkSTArray<4, Sampler, true> fSamplers;
-};
+    virtual ~GrGLInstalledProcessors();
 
-struct GrGLInstalledGeoProc : public GrGLInstalledProc {
-    GrGLGeometryProcessor* fGLProc;
-};
+    typedef GrGLProgramDataManager::UniformHandle UniformHandle;
 
-struct GrGLInstalledFragProc : public GrGLInstalledProc {
-    GrGLInstalledFragProc(bool useLocalCoords) : fGLProc(NULL), fLocalCoordAttrib(useLocalCoords) {}
+    struct Sampler {
+        SkDEBUGCODE(Sampler() : fTextureUnit(-1) {})
+        UniformHandle  fUniform;
+        int            fTextureUnit;
+    };
+
     class ShaderVarHandle {
     public:
         bool isValid() const { return fHandle > -1; }
         ShaderVarHandle() : fHandle(-1) {}
         ShaderVarHandle(int value) : fHandle(value) { SkASSERT(this->isValid()); }
         int handle() const { SkASSERT(this->isValid()); return fHandle; }
         UniformHandle convertToUniformHandle() {
             SkASSERT(this->isValid());
             return GrGLProgramDataManager::UniformHandle::CreateFromUniformIndex(fHandle);
         }
 
     private:
         int fHandle;
     };
 
     struct Transform {
         Transform() : fType(kVoid_GrSLType) { fCurrentValue = SkMatrix::InvalidMatrix(); }
         ShaderVarHandle fHandle;
         SkMatrix       fCurrentValue;
         GrSLType       fType;
     };
 
-    GrGLFragmentProcessor*        fGLProc;
-    SkSTArray<2, Transform, true> fTransforms;
-    bool                          fLocalCoordAttrib;
-};
+    void addEffect(GrGLProcessor* effect) { fGLProcessors.push_back(effect); }
+    SkTArray<Sampler, true>& addSamplers() { return fSamplers.push_back(); }
+    SkTArray<Transform, true>& addTransforms() { return fTransforms.push_back(); }
 
-struct GrGLInstalledFragProcs : public SkRefCnt {
-    ~GrGLInstalledFragProcs();
-    SkSTArray<8, GrGLInstalledFragProc*, true> fProcs;
+    SkTArray<GrGLProcessor*>                 fGLProcessors;
+    SkTArray<SkSTArray<4, Sampler, true> >   fSamplers;
+    SkTArray<SkSTArray<2, Transform, true> > fTransforms;
+    bool                                     fHasExplicitLocalCoords;
+
+    friend class GrGLShaderBuilder;
+    friend class GrGLVertexShaderBuilder;
+    friend class GrGLFragmentShaderBuilder;
+    friend class GrGLGeometryShaderBuilder;
 };
 
 #endif