Incremental refactoring of GrGLProgram and 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 52 matching lines @@
     struct GenProgramOutput {
         GrGLProgramEffects* fColorEffects;
         GrGLProgramEffects* fCoverageEffects;
         UniformHandles fUniformHandles;
         bool fHasVS;
         int fNumTexCoordSets;
         GrGLuint fProgramID;
     };
 
     static bool GenProgram(GrGpuGL* gpu,
-                           GrGLUniformManager& uman,
+                           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()
@@ skipping 83 matching lines @@
                                                  const char** outName = NULL) {
         return this->addUniformArray(visibility, type, name, GrGLShaderVar::kNonArray, outName);
     }
     GrGLUniformManager::UniformHandle addUniformArray(uint32_t visibility,
                                                       GrSLType type,
                                                       const char* name,
                                                       int arrayCount,
                                                       const char** outName = NULL);
 
     const GrGLShaderVar& getUniformVariable(GrGLUniformManager::UniformHandle u) const {
-        return fUniformManager.getBuilderUniform(fUniforms, u).fVariable;
+        return fUniformManager->getBuilderUniform(fUniforms, u).fVariable;
     }
 
     /**
      * Shortcut for getUniformVariable(u).c_str()
      */
     const char* getUniformCStr(GrGLUniformManager::UniformHandle u) const {
         return this->getUniformVariable(u).c_str();
     }
 
     /**
      * This returns a variable name to access the 2D, perspective correct version of the coords in
      * the fragment shader. If the coordinates at index are 3-dimensional, it immediately emits a
      * perspective divide into the fragment shader (xy / z) to convert them to 2D.
      */
     SkString ensureFSCoords2D(const TransformedCoordsArray&, int index);
 
     /** 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. */
+    /** Returns the variable name that holds 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.
-     */
-    const GrGLSLExpr4& getInputColor() const {
-        return fInputColor;
-    }
-    const GrGLSLExpr4& getInputCoverage() const {
-        return fInputCoverage;
-    }
-
-    /**
-     * Adds code for effects and returns a GrGLProgramEffects* object. The caller is responsible for
-     * deleting it when finished. effectStages contains the effects to add. effectKeys[i] is the key
-     * generated from effectStages[i]. inOutFSColor specifies the input color to the first stage and
-     * is updated to be the output color of the last stage.
-     * The handles to texture samplers for effectStage[i] are added to
-     * effectSamplerHandles[i].
-     */
-    virtual GrGLProgramEffects* createAndEmitEffects(const GrEffectStage* effectStages[],
-                                                     const EffectKey effectKeys[],
-                                                     int effectCnt,
-                                                     GrGLSLExpr4* inOutFSColor) = 0;
-
-    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 fDstCopySamplerUniform;
-    }
-
-    bool finish(GrGLuint* outProgramId);
-
     const GrGLContextInfo& ctxInfo() const;
 
     /**
      * Helper for begining and ending a block in the fragment code. TODO: Make GrGLShaderBuilder
      * aware of all blocks and turn single \t's into the correct number of tabs (or spaces) so that
      * our shaders print pretty without effect writers tracking indentation.
      */
     class FSBlock {
     public:
         FSBlock(GrGLShaderBuilder* builder) : fBuilder(builder) {
             SkASSERT(NULL != builder);
             fBuilder->fsCodeAppend("\t{\n");
         }
 
         ~FSBlock() {
             fBuilder->fsCodeAppend("\t}\n");
         }
     private:
         GrGLShaderBuilder* fBuilder;
     };
 
 protected:
-    GrGLShaderBuilder(GrGpuGL*, GrGLUniformManager&, const GrGLProgramDesc&);
+    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(); }
 
+    // Helper for emitEffects().
+    void createAndEmitEffects(GrGLProgramEffectsBuilder*,

[robertphillips, 2014/05/29 12:24:57]

extra spaces here?

[bsalomon, 2014/05/29 21:22:16]

Done.

+                               const GrEffectStage* effectStages[],
+                               const EffectKey effectKeys[],
+                               int effectCnt,
+                               GrGLSLExpr4* inOutFSColor);
+
     // 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);
 
-    // Helper for emitEffects().
-    void createAndEmitEffects(GrGLProgramEffectsBuilder*,
-                              const GrEffectStage* effectStages[],
-                              const EffectKey effectKeys[],
-                              int effectCnt,
-                              GrGLSLExpr4* inOutFSColor);
+    virtual bool compileAndAttachShaders(GrGLuint programId, SkTDArray<GrGLuint>* shaderIds) const;
 
-    virtual bool compileAndAttachShaders(GrGLuint programId, SkTDArray<GrGLuint>* shaderIds) const;
     virtual void bindProgramLocations(GrGLuint programId) const;
 
     void appendDecls(const VarArray&, SkString*) const;
     void appendUniformDecls(ShaderVisibility, SkString*) const;
 
 private:
     class CodeStage : SkNoncopyable {
     public:
         CodeStage() : fNextIndex(0), fCurrentIndex(-1), fEffectStage(NULL) {}
 
@@ skipping 42 matching lines @@
         int                     fNextIndex;
         int                     fCurrentIndex;
         const GrEffectStage*    fEffectStage;
     } fCodeStage;
 
     bool genProgram(const GrEffectStage* colorStages[],
                     const GrEffectStage* coverageStages[],
                     GenProgramOutput* output);
 
     /**
+    * Adds code for effects and returns a GrGLProgramEffects* object. The caller is responsible for
+    * deleting it when finished. effectStages contains the effects to add. effectKeys[i] is the key
+    * generated from effectStages[i]. inOutFSColor specifies the input color to the first stage and
+    * is updated to be the output color of the last stage.
+    * The handles to texture samplers for effectStage[i] are added to
+    * effectSamplerHandles[i].
+    */
+    virtual GrGLProgramEffects* createAndEmitEffects(const GrEffectStage* effectStages[],
+                                                     const EffectKey effectKeys[],
+                                                     int effectCnt,
+                                                     GrGLSLExpr4* inOutFSColor) = 0;
+
+    /** Enables using the secondary color output and returns the name of the var in which it is
+        to be stored */
+    const char* enableSecondaryOutput();
+    /** Gets the name of the primary color output. */
+    const char* getColorOutputName() const;
+
+    bool finish(GrGLuint* outProgramId);
+
+    const GrGLSLExpr4& getInputColor() const {
+        return fInputColor;
+    }
+
+    const GrGLSLExpr4& getInputCoverage() const {
+        return fInputCoverage;
+    }
+
+    /**
      * 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;
+    SkAutoTUnref<GrGLUniformManager>        fUniformManager;
     uint32_t                                fFSFeaturesAddedMask;
     SkString                                fFSFunctions;
     SkString                                fFSExtensions;
     VarArray                                fFSInputs;
     VarArray                                fFSOutputs;
     GrGLUniformManager::BuilderUniformArray fUniforms;
 
     SkString                                fFSCode;
 
     bool                                    fSetupFragPosition;
@@ skipping 11 matching lines @@
     GrGLUniformManager::UniformHandle       fColorUniform;
     GrGLUniformManager::UniformHandle       fCoverageUniform;
 
     bool                                    fTopLeftFragPosRead;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 class GrGLFullShaderBuilder : public GrGLShaderBuilder {
 public:
-    GrGLFullShaderBuilder(GrGpuGL*, GrGLUniformManager&, const GrGLProgramDesc&);
+    GrGLFullShaderBuilder(GrGpuGL*, GrGLUniformManager*, 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.appendVAList(format, args);
         va_end(args);
     }
@@ skipping 23 matching lines @@
     const GrGLShaderVar& localCoordsAttribute() const { return *fLocalCoordsVar; }
 
     /**
      * Are explicit local coordinates provided as input to the vertex shader.
      */
     bool hasExplicitLocalCoords() const { return (fLocalCoordsVar != fPositionVar); }
 
     bool addEffectAttribute(int attributeIndex, GrSLType type, const SkString& name);
     const SkString* getEffectAttributeName(int attributeIndex) const;
 
-    virtual GrGLProgramEffects* createAndEmitEffects(
-                const GrEffectStage* effectStages[],
-                const EffectKey effectKeys[],
-                int effectCnt,
-                GrGLSLExpr4* inOutFSColor) SK_OVERRIDE;
-
     /**
      * The view matrix uniform is only valid in the VS. It is always mat33.
      */
     GrGLUniformManager::UniformHandle getViewMatrixUniform() const {
         return fViewMatrixUniform;
     }
 
     GrGLUniformManager::UniformHandle getRTAdjustmentVecUniform() const {
         return fRTAdustmentVecUniform;
     }
 
-protected:
-    virtual bool compileAndAttachShaders(GrGLuint programId, SkTDArray<GrGLuint>* shaderIds) const SK_OVERRIDE;
+private:
+    virtual GrGLProgramEffects* createAndEmitEffects(const GrEffectStage* effectStages[],
+                                                     const EffectKey effectKeys[],
+                                                     int effectCnt,
+                                                     GrGLSLExpr4* inOutFSColor) SK_OVERRIDE;
+    virtual bool compileAndAttachShaders(GrGLuint programId,
+                                         SkTDArray<GrGLuint>* shaderIds) const SK_OVERRIDE;
+
     virtual void bindProgramLocations(GrGLuint programId) const SK_OVERRIDE;
 
-private:
     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;
     };
     SkSTArray<10, AttributePair, true>  fEffectAttributes;
 
     GrGLUniformManager::UniformHandle   fViewMatrixUniform;
     GrGLUniformManager::UniformHandle   fRTAdustmentVecUniform;
     GrGLShaderVar*                      fPositionVar;
     GrGLShaderVar*                      fLocalCoordsVar;
 
     typedef GrGLShaderBuilder INHERITED;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 class GrGLFragmentOnlyShaderBuilder : public GrGLShaderBuilder {
 public:
-    GrGLFragmentOnlyShaderBuilder(GrGpuGL*, GrGLUniformManager&, const GrGLProgramDesc&);
+    GrGLFragmentOnlyShaderBuilder(GrGpuGL*, GrGLUniformManager*, const GrGLProgramDesc&);
 
     int getNumTexCoordSets() const { return fNumTexCoordSets; }
     int addTexCoordSets(int count);
 
-    virtual GrGLProgramEffects* createAndEmitEffects(
-                const GrEffectStage* effectStages[],
-                const EffectKey effectKeys[],
-                int effectCnt,
-                GrGLSLExpr4* inOutFSColor) SK_OVERRIDE;
+private:
 
-private:
+    virtual GrGLProgramEffects* createAndEmitEffects(const GrEffectStage* effectStages[],
+                                                     const EffectKey effectKeys[],
+                                                     int effectCnt,
+                                                     GrGLSLExpr4* inOutFSColor) SK_OVERRIDE;
+
     int fNumTexCoordSets;
 
     typedef GrGLShaderBuilder INHERITED;
 };
 
 #endif