Make GrGLProgram be available to GrGLProgramDataManager

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 15 matching lines @@
 
 /**
   Contains all the incremental state of a shader as it is being built,as well as helpers to
   manipulate that state.
 */
 class GrGLShaderBuilder {
 public:
     typedef GrTAllocator<GrGLShaderVar> VarArray;
     typedef GrGLProgramEffects::TextureSampler TextureSampler;
     typedef GrGLProgramEffects::TransformedCoordsArray TransformedCoordsArray;
-    typedef GrGLProgramDataManager::BuilderUniform BuilderUniform;
 
     enum ShaderVisibility {
         kVertex_Visibility   = 0x1,
         kGeometry_Visibility = 0x2,
         kFragment_Visibility = 0x4,
     };
 
     typedef GrGLProgramDataManager::UniformHandle UniformHandle;
 
     // Handles for program uniforms (other than per-effect uniforms)
-    struct UniformHandles {
+    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;
     };
 
-    struct GenProgramOutput {
-        GenProgramOutput()
-            : fColorEffects(NULL)
-            , fCoverageEffects(NULL)
-            , fHasVertexShader(false)
-            , fTexCoordSetCnt(0)
-            , fProgramID(0) {}
-
-        GenProgramOutput(const GenProgramOutput& other) {
-            *this = other;
-        }
-
-        GenProgramOutput& operator=(const GenProgramOutput& other) {
-            fColorEffects.reset(SkRef(other.fColorEffects.get()));
-            fCoverageEffects.reset(SkRef(other.fCoverageEffects.get()));
-            fUniformHandles = other.fUniformHandles;
-            fHasVertexShader = other.fHasVertexShader;
-            fTexCoordSetCnt = other.fTexCoordSetCnt;
-            fProgramID = other.fProgramID;
-            return *this;
-        }
-
-        SkAutoTUnref<GrGLProgramEffects> fColorEffects;
-        SkAutoTUnref<GrGLProgramEffects> fCoverageEffects;
-        UniformHandles                   fUniformHandles;
-        bool                             fHasVertexShader;
-        int                              fTexCoordSetCnt;
-        GrGLuint                         fProgramID;
+    struct UniformInfo {
+        GrGLShaderVar fVariable;
+        uint32_t      fVisibility;
+        GrGLint       fLocation;
     };
 
-    static bool GenProgram(GrGpuGL* gpu,
-                           GrGLProgramDataManager* pdman,
-                           const GrGLProgramDesc& desc,
-                           const GrEffectStage* inColorStages[],
-                           const GrEffectStage* inCoverageStages[],
-                           GenProgramOutput* output);
+    // This uses an allocator rather than array so that the GrGLShaderVars don't move in memory
+    // after they are inserted. Users of GrGLShaderBuilder get refs to the vars and ptrs to their
+    // name strings. Otherwise, we'd have to hand out copies.
+    typedef GrTAllocator<UniformInfo> UniformInfoArray;
+
+    /** 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.
+     */
+    bool genProgram(const GrEffectStage* inColorStages[],
+                    const GrEffectStage* inCoverageStages[]);
+
+    // Below are the results of the shader generation.
+
+    GrGLProgramEffects* getColorEffects() const { SkASSERT(fProgramID); return fColorEffects.get(); }
+    GrGLProgramEffects* getCoverageEffects() const { SkASSERT(fProgramID); return fCoverageEffects.get(); }
+    const BuiltinUniformHandles& getBuiltinUniformHandles() const {
+        SkASSERT(fProgramID);
+        return fUniformHandles;
+    }
+    GrGLuint getProgramID() const { SkASSERT(fProgramID); return fProgramID; }
+    int hasVertexShader() const { SkASSERT(fProgramID); return fHasVertexShader; }
+    int getTexCoordSetCount() const { SkASSERT(fProgramID); return fTexCoordSetCnt; }
+    const UniformInfoArray& getUniformInfos() const { return fUniforms; }
 
     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 78 matching lines @@
                                                      const char** outName = NULL) {
         return this->addUniformArray(visibility, type, name, GrGLShaderVar::kNonArray, outName);
     }
     GrGLProgramDataManager::UniformHandle addUniformArray(uint32_t visibility,
                                                           GrSLType type,
                                                           const char* name,
                                                           int arrayCount,
                                                           const char** outName = NULL);
 
     const GrGLShaderVar& getUniformVariable(GrGLProgramDataManager::UniformHandle u) const {
-        return fProgramDataManager->getBuilderUniform(fUniforms, u).fVariable;
+        return fUniforms[u.toShaderBuilderIndex()].fVariable;
     }
 
     /**
      * Shortcut for getUniformVariable(u).c_str()
      */
     const char* getUniformCStr(GrGLProgramDataManager::UniformHandle u) const {
         return this->getUniformVariable(u).c_str();
     }
 
     /**
@@ skipping 26 matching lines @@
         }
 
         ~FSBlock() {
             fBuilder->fsCodeAppend("\t}\n");
         }
     private:
         GrGLShaderBuilder* fBuilder;
     };
 
 protected:
-    GrGLShaderBuilder(GrGpuGL*, GrGLProgramDataManager*, const GrGLProgramDesc&);
+    GrGLShaderBuilder(GrGpuGL*, const GrGLProgramDesc&);
 
     GrGpuGL* gpu() const { return fGpu; }
 
     const GrGLProgramDesc& desc() const { return fDesc; }
 
     /** 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[],
                               int effectCnt,
                               const GrGLProgramDesc::EffectKeyProvider&,
                               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;
+    virtual void bindProgramLocations(GrGLuint programId);
+    void resolveProgramLocations(GrGLuint programId);
 
     void appendDecls(const VarArray&, SkString*) const;
     void appendUniformDecls(ShaderVisibility, SkString*) const;
 
-    const GenProgramOutput& getOutput() const { return fOutput; }
-
-    GenProgramOutput fOutput;
-
+    SkAutoTUnref<GrGLProgramEffects> fColorEffects;
+    SkAutoTUnref<GrGLProgramEffects> fCoverageEffects;
+    BuiltinUniformHandles            fUniformHandles;
+    bool                             fHasVertexShader;
+    int                              fTexCoordSetCnt;
+    GrGLuint                         fProgramID;
 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[]);
-
     /**
      * The base class will emit the fragment code that precedes the per-effect code and then call
      * this function. The subclass can use it to insert additional fragment code that should
      * execute before the effects' code and/or emit other shaders (e.g. geometry, vertex).
      *
      * The subclass can modify the initial color or coverage 
      */
     virtual void emitCodeBeforeEffects(GrGLSLExpr4* color, GrGLSLExpr4* coverage) = 0;
 
     /**
@@ skipping 49 matching lines @@
     };
 
     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;
-    SkAutoTUnref<GrGLProgramDataManager>    fProgramDataManager;
     uint32_t                                fFSFeaturesAddedMask;
     SkString                                fFSFunctions;
     SkString                                fFSExtensions;
     VarArray                                fFSInputs;
     VarArray                                fFSOutputs;
-    GrGLProgramDataManager::BuilderUniformArray fUniforms;
+    UniformInfoArray                        fUniforms;
 
     SkString                                fFSCode;
 
     bool                                    fSetupFragPosition;
     bool                                    fTopLeftFragPosRead;
 
     bool                                    fHasCustomColorOutput;
     bool                                    fHasSecondaryOutput;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 class GrGLFullShaderBuilder : public GrGLShaderBuilder {
 public:
-    GrGLFullShaderBuilder(GrGpuGL*, GrGLProgramDataManager*, const GrGLProgramDesc&);
+    GrGLFullShaderBuilder(GrGpuGL*, 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 36 matching lines @@
     virtual GrGLProgramEffects* createAndEmitEffects(const GrEffectStage* effectStages[],
                                                      int effectCnt,
                                                      const GrGLProgramDesc::EffectKeyProvider&,
                                                      GrGLSLExpr4* inOutFSColor) SK_OVERRIDE;
 
     virtual void emitCodeAfterEffects() SK_OVERRIDE;
 
     virtual bool compileAndAttachShaders(GrGLuint programId,
                                          SkTDArray<GrGLuint>* shaderIds) const SK_OVERRIDE;
 
-    virtual void bindProgramLocations(GrGLuint programId) const SK_OVERRIDE;
+    virtual void bindProgramLocations(GrGLuint programId) 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;
 
     GrGLShaderVar*                      fPositionVar;
     GrGLShaderVar*                      fLocalCoordsVar;
 
     typedef GrGLShaderBuilder INHERITED;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 class GrGLFragmentOnlyShaderBuilder : public GrGLShaderBuilder {
 public:
-    GrGLFragmentOnlyShaderBuilder(GrGpuGL*, GrGLProgramDataManager*, const GrGLProgramDesc&);
+    GrGLFragmentOnlyShaderBuilder(GrGpuGL*, const GrGLProgramDesc&);
 
     int addTexCoordSets(int count);
 
 private:
     virtual void emitCodeBeforeEffects(GrGLSLExpr4* color, GrGLSLExpr4* coverage) SK_OVERRIDE {}
 
     virtual GrGLProgramEffects* createAndEmitEffects(const GrEffectStage* effectStages[],
                                                      int effectCnt,
                                                      const GrGLProgramDesc::EffectKeyProvider&,
                                                      GrGLSLExpr4* inOutFSColor) SK_OVERRIDE;
 
     virtual void emitCodeAfterEffects() SK_OVERRIDE {}
 
     typedef GrGLShaderBuilder INHERITED;
 };
 
 #endif