Make GrGLShaderBuilder store a GenProgramOutput

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 43 matching lines @@
         // 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 {
+        GenProgramOutput()
+            : fColorEffects(NULL)
+            , fCoverageEffects(NULL)
+            , fHasVertexShader(false)
+            , fTexCoordSetCnt(0)
+            , fProgramID(0) {}
+
         GrGLProgramEffects* fColorEffects;
         GrGLProgramEffects* fCoverageEffects;
-        UniformHandles fUniformHandles;
-        bool fHasVS;
-        int fNumTexCoordSets;
-        GrGLuint fProgramID;
+        UniformHandles      fUniformHandles;
+        bool                fHasVertexShader;
+        int                 fTexCoordSetCnt;
+        GrGLuint            fProgramID;
     };
 
     static bool GenProgram(GrGpuGL* gpu,

[robertphillips, 2014/05/29 21:12:25]

Are we no longer aligning the parameters (here and appendTextureLookup &
fsAppendTextureLookup) ?

[bsalomon, 2014/05/29 21:15:11]

Visual Studio 2013 is driving me bananas reformatting everything.

-                           GrGLUniformManager* uman,
-                           const GrGLProgramDesc& desc,
-                           const GrEffectStage* inColorStages[],
-                           const GrEffectStage* inCoverageStages[],
-                           GenProgramOutput* output);
+        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,
 
@@ skipping 15 matching lines @@
         fFSCode.appendVAList(format, args);
         va_end(args);
     }
 
     void fsCodeAppend(const char* str) { fFSCode.append(str); }
 
     /** Appends a 2D texture sample with projection if necessary. coordType must either be Vec2f or
         Vec3f. The latter is interpreted as projective texture coords. The vec length and swizzle
         order of the result depends on the GrTextureAccess associated with the TextureSampler. */
     void appendTextureLookup(SkString* out,
-                             const TextureSampler&,
-                             const char* coordName,
-                             GrSLType coordType = kVec2f_GrSLType) const;
+        const TextureSampler&,
+        const char* coordName,
+        GrSLType coordType = kVec2f_GrSLType) const;
 
     /** Version of above that appends the result to the fragment shader code instead.*/
     void fsAppendTextureLookup(const TextureSampler&,
-                               const char* coordName,
-                               GrSLType coordType = kVec2f_GrSLType);
+        const char* coordName,
+        GrSLType coordType = kVec2f_GrSLType);
 
 
     /** Does the work of appendTextureLookup and modulates the result by modulation. The result is
         always a vec4. modulation and the swizzle specified by TextureSampler must both be vec4 or
         float. If modulation is "" or NULL it this function acts as though appendTextureLookup were
         called. */
     void fsAppendTextureLookupAndModulate(const char* modulation,
                                           const TextureSampler&,
                                           const char* coordName,
                                           GrSLType coordType = kVec2f_GrSLType);
@@ skipping 21 matching lines @@
 
     /** If texture swizzling is available using tex parameters then it is preferred over mangling
         the generated shader code. This potentially allows greater reuse of cached shaders. */
     static const GrGLenum* GetTexParamSwizzle(GrPixelConfig config, const GrGLCaps& caps);
 
     /** Add a uniform variable to the current program, that has visibility in one or more shaders.
         visibility is a bitfield of ShaderVisibility values indicating from which shaders the
         uniform should be accessible. At least one bit must be set. Geometry shader uniforms are not
         supported at this time. The actual uniform name will be mangled. If outName is not NULL then
         it will refer to the final uniform name after return. Use the addUniformArray variant to add
-        an array of uniforms.
-    */
+        an array of uniforms. */
     GrGLUniformManager::UniformHandle addUniform(uint32_t visibility,
                                                  GrSLType type,
                                                  const char* name,
                                                  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,
@@ skipping 54 matching lines @@
     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*,
-                               const GrEffectStage* effectStages[],
-                               const EffectKey effectKeys[],
-                               int effectCnt,
-                               GrGLSLExpr4* inOutFSColor);
+                              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);
 
     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;
 
+    const GenProgramOutput& getOutput() const { return fOutput; }
+

[robertphillips, 2014/05/29 21:12:25]

Is this supposed to be out here?

[bsalomon, 2014/05/29 21:15:11]

Yeah, it's in protected so that subclasses can set some of the fields.

+    GenProgramOutput fOutput;
+
 private:
     class CodeStage : SkNoncopyable {
     public:
         CodeStage() : fNextIndex(0), fCurrentIndex(-1), fEffectStage(NULL) {}
 
         bool inStageCode() const {
             this->validate();
             return NULL != fEffectStage;
         }
 
@@ skipping 32 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);
+    bool genProgram(const GrEffectStage* colorStages[], const GrEffectStage* coverageStages[]);
 
     /**
     * 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);
+    /**
+     * Compiles all the shaders, links them into a program, and writes the program id to the output
+     * struct.
+     **/
+    bool finish();
 
     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 {

[robertphillips, 2014/05/29 21:12:25]

I kind of liked the aligned enum values ...

[bsalomon, 2014/05/29 21:15:11]

Argh, yes, I agree.

-        kNoDstRead_DstReadKey         = 0,
-        kYesDstRead_DstReadKeyBit     = 0x1, // Set if we do a dst-copy-read.
+        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.
+        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.
+        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;
     SkAutoTUnref<GrGLUniformManager>        fUniformManager;
     uint32_t                                fFSFeaturesAddedMask;
     SkString                                fFSFunctions;
     SkString                                fFSExtensions;
     VarArray                                fFSInputs;
     VarArray                                fFSOutputs;
     GrGLUniformManager::BuilderUniformArray fUniforms;
 
     SkString                                fFSCode;
 
     bool                                    fSetupFragPosition;
-    GrGLUniformManager::UniformHandle       fDstCopySamplerUniform;
+    bool                                    fTopLeftFragPosRead;
 
     GrGLSLExpr4                             fInputColor;
     GrGLSLExpr4                             fInputCoverage;
 
     bool                                    fHasCustomColorOutput;
     bool                                    fHasSecondaryOutput;
-
-    GrGLUniformManager::UniformHandle       fRTHeightUniform;
-    GrGLUniformManager::UniformHandle       fDstCopyTopLeftUniform;
-    GrGLUniformManager::UniformHandle       fDstCopyScaleUniform;
-    GrGLUniformManager::UniformHandle       fColorUniform;
-    GrGLUniformManager::UniformHandle       fCoverageUniform;
-
-    bool                                    fTopLeftFragPosRead;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 class GrGLFullShaderBuilder : public GrGLShaderBuilder {
 public:
     GrGLFullShaderBuilder(GrGpuGL*, GrGLUniformManager*, const GrGLProgramDesc&);
 
     /**
      * Called by GrGLEffects to add code to one of the shaders.
@@ skipping 30 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;
 
-    /**
-     * 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;
-    }
-
 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;
 
     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&);
 
-    int getNumTexCoordSets() const { return fNumTexCoordSets; }
     int addTexCoordSets(int count);
 
 private:
 
     virtual GrGLProgramEffects* createAndEmitEffects(const GrEffectStage* effectStages[],
                                                      const EffectKey effectKeys[],
                                                      int effectCnt,
                                                      GrGLSLExpr4* inOutFSColor) SK_OVERRIDE;
 
-    int fNumTexCoordSets;
-
     typedef GrGLShaderBuilder INHERITED;
 };
 
 #endif