Move all code generation from GrGLProgram to GrGLShaderBuilder

src/gpu/gl/GrGLShaderBuilder.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLShaderBuilder_DEFINED
 #define GrGLShaderBuilder_DEFINED
 
@@ skipping 23 matching lines @@
     typedef GrGLProgramEffects::TextureSampler TextureSampler;
     typedef GrGLProgramEffects::TransformedCoordsArray TransformedCoordsArray;
     typedef GrGLUniformManager::BuilderUniform BuilderUniform;
 
     enum ShaderVisibility {
         kVertex_Visibility   = 0x1,
         kGeometry_Visibility = 0x2,
         kFragment_Visibility = 0x4,
     };
 
-    GrGLShaderBuilder(GrGpuGL*, GrGLUniformManager&, const GrGLProgramDesc&);
+    typedef GrGLUniformManager::UniformHandle UniformHandle;
+
+    // Handles for program uniforms (other than per-effect uniforms)
+    struct UniformHandles {
+        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;
+    };
+
+    struct GenProgramOutput {
+        GrGLProgramEffects* fColorEffects;
+        GrGLProgramEffects* fCoverageEffects;
+        UniformHandles fUniformHandles;
+        bool fHasVS;
+        int fNumTexCoordSets;
+        GrGLuint fProgramID;
+    };
+
+    static bool GenProgram(GrGpuGL* gpu,
+                           GrGLUniformManager& uman,
+                           const GrGLProgramDesc& desc,
+                           const GrEffectStage* inColorStages[],
+                           const GrEffectStage* inCoverageStages[],
+                           GenProgramOutput* output);
+
     virtual ~GrGLShaderBuilder() {}
 
     /**
      * Use of these features may require a GLSL extension to be enabled. Shaders may not compile
      * if code is added that uses one of these features without calling enableFeature()
      */
     enum GLSLFeature {
         kStandardDerivatives_GLSLFeature = 0,
 
         kLastGLSLFeature = kStandardDerivatives_GLSLFeature
@@ skipping 166 matching lines @@
         }
 
         ~FSBlock() {
             fBuilder->fsCodeAppend("\t}\n");
         }
     private:
         GrGLShaderBuilder* fBuilder;
     };
 
 protected:
+    GrGLShaderBuilder(GrGpuGL*, GrGLUniformManager&, const GrGLProgramDesc&);
+
     GrGpuGL* gpu() const { return fGpu; }
 
+    const GrGLProgramDesc& desc() const { return fDesc; }
+
     void setInputColor(const GrGLSLExpr4& inputColor) { fInputColor = inputColor; }
     void setInputCoverage(const GrGLSLExpr4& inputCoverage) { fInputCoverage = inputCoverage; }
 
     /** Add input/output variable declarations (i.e. 'varying') to the fragment shader. */
     GrGLShaderVar& fsInputAppend() { return fFSInputs.push_back(); }
 
     // 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);
@@ skipping 56 matching lines @@
             int                     fSavedIndex;
             const GrEffectStage*    fSavedEffectStage;
         };
     private:
         void validate() const { SkASSERT((NULL == fEffectStage) == (-1 == fCurrentIndex)); }
         int                     fNextIndex;
         int                     fCurrentIndex;
         const GrEffectStage*    fEffectStage;
     } fCodeStage;
 
+    bool genProgram(const GrEffectStage* colorStages[],
+                    const GrEffectStage* coverageStages[],
+                    GenProgramOutput* output);
+
     /**
      * Features that should only be enabled by GrGLShaderBuilder itself.
      */
     enum GLSLPrivateFeature {
         kFragCoordConventions_GLSLPrivateFeature = kLastGLSLFeature + 1,
         kEXTShaderFramebufferFetch_GLSLPrivateFeature,
         kNVShaderFramebufferFetch_GLSLPrivateFeature,
     };
     bool enablePrivateFeature(GLSLPrivateFeature);
 
     // If we ever have VS/GS features we can expand this to take a bitmask of ShaderVisibility and
     // track the enables separately for each shader.
     void addFSFeature(uint32_t featureBit, const char* extensionName);
 
     // Interpretation of DstReadKey when generating code
     enum {
         kNoDstRead_DstReadKey         = 0,
         kYesDstRead_DstReadKeyBit     = 0x1, // Set if we do a dst-copy-read.
         kUseAlphaConfig_DstReadKeyBit = 0x2, // Set if dst-copy config is alpha only.
         kTopLeftOrigin_DstReadKeyBit  = 0x4, // Set if dst-copy origin is top-left.
     };
 
     enum {
         kNoFragPosRead_FragPosKey           = 0,  // The fragment positition will not be needed.
         kTopLeftFragPosRead_FragPosKey      = 0x1,// Read frag pos relative to top-left.
         kBottomLeftFragPosRead_FragPosKey   = 0x2,// Read frag pos relative to bottom-left.
     };
 
+    const GrGLProgramDesc&                  fDesc;
     GrGpuGL*                                fGpu;
     GrGLUniformManager&                     fUniformManager;
     uint32_t                                fFSFeaturesAddedMask;
     SkString                                fFSFunctions;
     SkString                                fFSExtensions;
     VarArray                                fFSInputs;
     VarArray                                fFSOutputs;
     GrGLUniformManager::BuilderUniformArray fUniforms;
 
     SkString                                fFSCode;
@@ skipping 79 matching lines @@
 
     GrGLUniformManager::UniformHandle getRTAdjustmentVecUniform() const {
         return fRTAdustmentVecUniform;
     }
 
 protected:
     virtual bool compileAndAttachShaders(GrGLuint programId, SkTDArray<GrGLuint>* shaderIds) const SK_OVERRIDE;
     virtual void bindProgramLocations(GrGLuint programId) const SK_OVERRIDE;
 
 private:
-    const GrGLProgramDesc&              fDesc;
     VarArray                            fVSAttrs;
     VarArray                            fVSOutputs;
     VarArray                            fGSInputs;
     VarArray                            fGSOutputs;
 
     SkString                            fVSCode;
 
     struct AttributePair {
         void set(int index, const SkString& name) {
             fIndex = index; fName = name;
@@ skipping 26 matching lines @@
                 int effectCnt,
                 GrGLSLExpr4* inOutFSColor) SK_OVERRIDE;
 
 private:
     int fNumTexCoordSets;
 
     typedef GrGLShaderBuilder INHERITED;
 };
 
 #endif