Move the GL shader compilation step into 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 87 matching lines @@
 
     typedef SkTArray<TextureSampler> TextureSamplerArray;
     typedef GrTAllocator<GrGLShaderVar> VarArray;
 
     enum ShaderVisibility {
         kVertex_Visibility   = 0x1,
         kGeometry_Visibility = 0x2,
         kFragment_Visibility = 0x4,
     };
 
-    GrGLShaderBuilder(const GrGLContextInfo&,
+    GrGLShaderBuilder(GrGpuGL*,
                       GrGLUniformManager&,
                       const GrGLProgramDesc&,
                       bool needsVertexShader);
 
     /**
      * 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,
@@ skipping 45 matching lines @@
     /** Emits a helper function outside of main() in the fragment shader. */
     void fsEmitFunction(GrSLType returnType,
                         const char* name,
                         int argCnt,
                         const GrGLShaderVar* args,
                         const char* body,
                         SkString* outName);
 
     /** Add input/output variable declarations (i.e. 'varying') to the fragment shader. */
     GrGLShaderVar& fsInputAppend() { return fFSInputs.push_back(); }
-    GrGLShaderVar& fsOutputAppend() { return fFSOutputs.push_back(); }
-    GrGLShaderVar& fsInputAppend(const GrGLShaderVar& var) { return fFSInputs.push_back(var); }
-    GrGLShaderVar& fsOutputAppend(const GrGLShaderVar& var) { return fFSOutputs.push_back(var); }
 
     /** Generates a EffectKey for the shader code based on the texture access parameters and the
         capabilities of the GL context.  This is useful for keying the shader programs that may
         have multiple representations, based on the type/format of textures used. */
     static GrBackendEffectFactory::EffectKey KeyForTextureAccess(const GrTextureAccess&,
                                                                  const GrGLCaps&);
 
     typedef uint8_t DstReadKey;
     typedef uint8_t FragPosKey;
 
@@ skipping 44 matching lines @@
     /** Returns a variable name that represents the position of the fragment in the FS. The position
         is in device space (e.g. 0,0 is the top left and pixel centers are at half-integers). */
     const char* fragmentPosition();
 
     /** Returns the color of the destination pixel. This may be NULL if no effect advertised
         that it will read the destination. */
     const char* dstColor();
 
     /**
      * Interfaces used by GrGLProgram.
      * TODO: Hide these from the GrEffects using friend or splitting this into two related classes.

[bsalomon, 2013/09/18 20:03:25]

Can we change this comment to say:

TODO: These are used by GrGLProgram to insert a mode color filter. Remove these
when the color filter is expressed as a GrEffect.

      * Also, GrGLProgram's shader string construction should be moved to this class.
      */
-
-    /** Called after building is complete to get the final shader string. To acces the vertex
-        and geometry shaders, use the VertexBuilder. */
-    void fsGetShader(SkString*) const;
+    const SkString& getInputColor() const { return fInputColor; }
+    GrSLConstantVec getKnownColorValue() const { return fKnownColorValue; }
+    const SkString& getInputCoverage() const { return fInputCoverage; }
+    GrSLConstantVec getKnownCoverageValue() const { return fKnownCoverageValue; }
 
     /**
      * Adds code for effects. effectStages contains the effects to add. effectKeys[i] is the key
      * generated from effectStages[i]. An entry in effectStages can be NULL, in which case it is
      * skipped. Moreover, if the corresponding key is GrGLEffect::NoEffectKey then it is skipped.
      * inOutFSColor specifies the input color to the first stage and is updated to be the
      * output color of the last stage. fsInOutColorKnownValue specifies whether the input color
      * has a known constant value and is updated to refer to the status of the output color.
      * The handles to texture samplers for effectStage[i] are added to effectSamplerHandles[i]. The
      * glEffects array is updated to contain the GrGLEffect generated for each entry in
      * effectStages.
      */
     void emitEffects(const GrEffectStage* effectStages[],
                      const GrBackendEffectFactory::EffectKey effectKeys[],
                      int effectCnt,
                      SkString*  inOutFSColor,
                      GrSLConstantVec* fsInOutColorKnownValue,
                      SkTArray<GrGLUniformManager::UniformHandle, true>* effectSamplerHandles[],
                      GrGLEffect* glEffects[]);
 
+    const char* getColorOutputName() const;
+    const char* enableSecondaryOutput();
+
     GrGLUniformManager::UniformHandle getRTHeightUniform() const { return fRTHeightUniform; }
     GrGLUniformManager::UniformHandle getDstCopyTopLeftUniform() const {
         return fDstCopyTopLeftUniform;
     }
     GrGLUniformManager::UniformHandle getDstCopyScaleUniform() const {
         return fDstCopyScaleUniform;
     }
+    GrGLUniformManager::UniformHandle getColorUniform() const { return fColorUniform; }
+    GrGLUniformManager::UniformHandle getCoverageUniform() const { return fCoverageUniform; }
     GrGLUniformManager::UniformHandle getDstCopySamplerUniform() const {
         return fDstCopySampler.fSamplerUniform;
     }
 
     /** Helper class used to build the vertex and geometry shaders. This functionality
         is kept separate from the rest of GrGLShaderBuilder to allow for shaders programs
         that only use the fragment shader. */
     class VertexBuilder {
     public:
-        VertexBuilder(GrGLShaderBuilder* parent, const GrGLProgramDesc&);
+        VertexBuilder(GrGLShaderBuilder* parent, GrGpuGL* gpu, const GrGLProgramDesc&);
 
         /**
          * Called by GrGLEffects to add code to one of the shaders.
          */
         void vsCodeAppendf(const char format[], ...) SK_PRINTF_LIKE(2, 3) {
             va_list args;
             va_start(args, format);
             fVSCode.appendf(format, args);
             va_end(args);
         }
 
-        void gsCodeAppendf(const char format[], ...) SK_PRINTF_LIKE(2, 3) {
-            va_list args;
-            va_start(args, format);
-            fGSCode.appendf(format, args);
-            va_end(args);
-        }
-
         void vsCodeAppend(const char* str) { fVSCode.append(str); }
-        void gsCodeAppend(const char* str) { fGSCode.append(str); }
 
        /** Add a vertex attribute to the current program that is passed in from the vertex data.
            Returns false if the attribute was already there, true otherwise. */
         bool addAttribute(GrSLType type, const char* name);
 
        /** Add a varying variable to the current program to pass values between vertex and fragment
             shaders. If the last two parameters are non-NULL, they are filled in with the name
             generated. */
         void addVarying(GrSLType type,
                         const char* name,
                         const char** vsOutName = NULL,
                         const char** fsInName = NULL);
 
         /** Returns a vertex attribute that represents the vertex position in the VS. This is the
             pre-matrix position and is commonly used by effects to compute texture coords via a matrix.
           */
         const GrGLShaderVar& positionAttribute() const { return *fPositionVar; }
 
         /** Returns a vertex attribute that represents the local coords in the VS. This may be the same
             as positionAttribute() or it may not be. It depends upon whether the rendering code
             specified explicit local coords or not in the GrDrawState. */
         const GrGLShaderVar& localCoordsAttribute() const { return *fLocalCoordsVar; }
 
         /**
          * Are explicit local coordinates provided as input to the vertex shader.
          */
         bool hasExplicitLocalCoords() const { return (fLocalCoordsVar != fPositionVar); }
 
-        /** Called after building is complete to get the final shader string. */
-        void vsGetShader(SkString*) const;
-        void gsGetShader(SkString*) const;
+        bool addEffectAttribute(int attributeIndex, GrSLType type, const SkString& name);
+        const SkString* getEffectAttributeName(int attributeIndex) const;
+
+        GrGLUniformManager::UniformHandle getViewMatrixUniform() const {
+            return fViewMatrixUniform;
+        }
+
+        bool compileAndAttachShaders(GrGLuint programId) const;
+        void bindProgramLocations(GrGLuint programId) const;
+
+    private:
+        GrGLShaderBuilder*                  fParent;
+        GrGpuGL*                            fGpu;
+        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;
             }
             int      fIndex;
             SkString fName;
         };
-        const SkTArray<AttributePair, true>& getEffectAttributes() const {
-            return fEffectAttributes;
-        }
-        bool addEffectAttribute(int attributeIndex, GrSLType type, const SkString& name);
-        const SkString* getEffectAttributeName(int attributeIndex) const;
+        SkSTArray<10, AttributePair, true>  fEffectAttributes;
 
-        // TODO: Everything below here private.
-    public:
-
-        VarArray    fVSAttrs;
-        VarArray    fVSOutputs;
-        VarArray    fGSInputs;
-        VarArray    fGSOutputs;
-        SkString    fGSHeader; // layout qualifiers specific to GS
-
-    private:
-        GrGLShaderBuilder*                  fParent;
-
-        bool                                fUsesGS;
-
-        SkString                            fVSCode;
-        SkString                            fGSCode;
-
-        SkSTArray<10, AttributePair, true>  fEffectAttributes;
+        GrGLUniformManager::UniformHandle   fViewMatrixUniform;
 
         GrGLShaderVar*                      fPositionVar;
         GrGLShaderVar*                      fLocalCoordsVar;
     };
 
     /** Gets the vertex builder that is used to construct the vertex and geometry shaders.
         It may be NULL if this shader program is only meant to have a fragment shader. */
     VertexBuilder* getVertexBuilder() const { return fVertexBuilder.get(); }
 
-    // TODO: Make this do all the compiling, linking, etc.
-    void finished(GrGLuint programID);
+    bool finish(GrGLuint* outProgramId);
 
-    const GrGLContextInfo& ctxInfo() const { return fCtxInfo; }
+    const GrGLContextInfo& ctxInfo() const;
 
 private:
     void appendDecls(const VarArray&, SkString*) const;
     void appendUniformDecls(ShaderVisibility, SkString*) const;
 
+    bool compileAndAttachShaders(GrGLuint programId) const;
+    void bindProgramLocations(GrGLuint programId) const;
+
     typedef GrGLUniformManager::BuilderUniform BuilderUniform;
     GrGLUniformManager::BuilderUniformArray fUniforms;
 
 private:
     class CodeStage : public SkNoncopyable {
     public:
         CodeStage() : fNextIndex(0), fCurrentIndex(-1), fEffectStage(NULL) {}
 
         bool inStageCode() const {
             this->validate();
@@ skipping 68 matching lines @@
         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 GrGLContextInfo&              fCtxInfo;
+    GrGpuGL*                            fGpu;
     GrGLUniformManager&                 fUniformManager;
     uint32_t                            fFSFeaturesAddedMask;
     SkString                            fFSFunctions;
     SkString                            fFSExtensions;
     VarArray                            fFSInputs;
     VarArray                            fFSOutputs;
 
     SkString                            fFSCode;
 
     bool                                fSetupFragPosition;
     TextureSampler                      fDstCopySampler;
 
+    SkString                            fInputColor;
+    GrSLConstantVec                     fKnownColorValue;
+    SkString                            fInputCoverage;
+    GrSLConstantVec                     fKnownCoverageValue;
+
+    bool                                fHasCustomColorOutput;
+    bool                                fHasSecondaryOutput;
+
     GrGLUniformManager::UniformHandle   fRTHeightUniform;
     GrGLUniformManager::UniformHandle   fDstCopyTopLeftUniform;
     GrGLUniformManager::UniformHandle   fDstCopyScaleUniform;
+    GrGLUniformManager::UniformHandle   fColorUniform;
+    GrGLUniformManager::UniformHandle   fCoverageUniform;
 
     bool                                fTopLeftFragPosRead;
 
-    SkAutoTDelete<VertexBuilder> fVertexBuilder;
+    SkAutoTDelete<VertexBuilder>        fVertexBuilder;
 };
 
 #endif