Rename GrGLUniformManager to GrGLUniform and ref GrGLUniforms directly

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
 
 #include "GrAllocator.h"
 #include "GrBackendEffectFactory.h"
 #include "GrColor.h"
 #include "GrEffect.h"
 #include "gl/GrGLSL.h"
-#include "gl/GrGLUniformManager.h"
+#include "gl/GrGLUniform.h"
 
 #include <stdarg.h>
 
 class GrGLContextInfo;
 class GrEffectStage;
 class GrGLProgramDesc;
+class GrGLProgram;
 
 /**
   Contains all the incremental state of a shader as it is being built,as well as helpers to
   manipulate that state.
 */
 class GrGLShaderBuilder {
 public:
+    /** Structure containing information about a uniform during the program build phase. */
+    class Uniform {
+    public:
+        GrGLUniform* glUniform() const { return fGLUniform; }
+
+        const char* c_str() const { return fVariable.c_str(); }
+
+        void appendArrayAccess(int index, SkString* out) const {
+            fVariable.appendArrayAccess(index, out);
+        }
+
+        void appendArrayAccess(const char* indexName, SkString* out) const {
+            fVariable.appendArrayAccess(indexName, out);
+        }
+
+    private:
+        GrGLShaderVar fVariable;
+        uint32_t      fVisibility;
+        GrGLUniform*  fGLUniform;
+
+        friend class GrGLShaderBuilder;
+    };
+
     /**
      * Passed to GrGLEffects to add texture reads to their shader code.
      */
     class TextureSampler {
     public:
         TextureSampler()
             : fConfigComponentMask(0)
-            , fSamplerUniform(GrGLUniformManager::kInvalidUniformHandle) {
+            , fSamplerUniform(NULL) {
             // we will memcpy the first 4 bytes from passed in swizzle. This ensures the string is
             // terminated.
             fSwizzle[4] = '\0';
         }
 
         TextureSampler(const TextureSampler& other) { *this = other; }
 
         TextureSampler& operator= (const TextureSampler& other) {
             GrAssert(0 == fConfigComponentMask);
-            GrAssert(GrGLUniformManager::kInvalidUniformHandle == fSamplerUniform);
+            GrAssert(NULL == fSamplerUniform);
 
             fConfigComponentMask = other.fConfigComponentMask;
             fSamplerUniform = other.fSamplerUniform;
             return *this;
         }
 
         // bitfield of GrColorComponentFlags present in the texture's config.
         uint32_t configComponentMask() const { return fConfigComponentMask; }
 
         const char* swizzle() const { return fSwizzle; }
 
         bool isInitialized() const { return 0 != fConfigComponentMask; }
 
     private:
         // The idx param is used to ensure multiple samplers within a single effect have unique
         // uniform names. swizzle is a four char max string made up of chars 'r', 'g', 'b', and 'a'.
         void init(GrGLShaderBuilder* builder,
                   uint32_t configComponentMask,
                   const char* swizzle,
                   int idx) {
             GrAssert(!this->isInitialized());
             GrAssert(0 != configComponentMask);
-            GrAssert(GrGLUniformManager::kInvalidUniformHandle == fSamplerUniform);
+            GrAssert(NULL == fSamplerUniform);
 
             GrAssert(NULL != builder);
             SkString name;
             name.printf("Sampler%d", idx);
             fSamplerUniform = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
                                                   kSampler2D_GrSLType,
                                                   name.c_str());
-            GrAssert(GrGLUniformManager::kInvalidUniformHandle != fSamplerUniform);
+            GrAssert(NULL != fSamplerUniform);
 
             fConfigComponentMask = configComponentMask;
             memcpy(fSwizzle, swizzle, 4);
         }
 
         void init(GrGLShaderBuilder* builder, const GrTextureAccess* access, int idx) {
             GrAssert(NULL != access);
             this->init(builder,
                        GrPixelConfigComponentMask(access->getTexture()->config()),
                        access->getSwizzle(),
                        idx);
         }
 
         uint32_t                          fConfigComponentMask;
         char                              fSwizzle[5];
-        GrGLUniformManager::UniformHandle fSamplerUniform;
+        Uniform*                          fSamplerUniform;
 
         friend class GrGLShaderBuilder; // to call init().
     };
 
     typedef SkTArray<TextureSampler> TextureSamplerArray;
 
     enum ShaderType {
         kVertex_ShaderType   = 0x1,
         kGeometry_ShaderType = 0x2,
         kFragment_ShaderType = 0x4,
     };
 
-    GrGLShaderBuilder(const GrGLContextInfo&, GrGLUniformManager&, const GrGLProgramDesc&);
+    GrGLShaderBuilder(const GrGLContextInfo&, GrGLProgram&, const GrGLProgramDesc&);
 
     /**
      * 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 91 matching lines @@
         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 ShaderType 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.
     */
-    GrGLUniformManager::UniformHandle addUniform(uint32_t visibility,
-                                                 GrSLType type,
-                                                 const char* name,
-                                                 const char** outName = NULL) {
+    Uniform* 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,
-                                                      const char** outName = NULL);
-
-    const GrGLShaderVar& getUniformVariable(GrGLUniformManager::UniformHandle) const;
-
-    /**
-     * Shortcut for getUniformVariable(u).c_str()
-     */
-    const char* getUniformCStr(GrGLUniformManager::UniformHandle u) const {
-        return this->getUniformVariable(u).c_str();
-    }
+    Uniform* addUniformArray(uint32_t visibility, GrSLType type, const char* name, int arrayCount,
+                             const char** outName = NULL);
 
    /** 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,
@@ skipping 41 matching lines @@
      * 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[],
+                     SkTArray<GrGLUniform*, true>* effectSamplerHandles[],
                      GrGLEffect* glEffects[]);
 
-    GrGLUniformManager::UniformHandle getRTHeightUniform() const { return fRTHeightUniform; }
-    GrGLUniformManager::UniformHandle getDstCopyTopLeftUniform() const {
+    GrGLUniform* getRTHeightUniform() const { return fRTHeightUniform; }
+    GrGLUniform* getDstCopyTopLeftUniform() const {
         return fDstCopyTopLeftUniform;
     }
-    GrGLUniformManager::UniformHandle getDstCopyScaleUniform() const {
+    GrGLUniform* getDstCopyScaleUniform() const {
         return fDstCopyScaleUniform;
     }
-    GrGLUniformManager::UniformHandle getDstCopySamplerUniform() const {
-        return fDstCopySampler.fSamplerUniform;
+    GrGLUniform* getDstCopySamplerUniform() const {
+        return fDstCopySampler.fSamplerUniform ? fDstCopySampler.fSamplerUniform->glUniform() : NULL;
     }
 
     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;
     }
     const SkString* getEffectAttributeName(int attributeIndex) const;
 
     // TODO: Make this do all the compiling, linking, etc.
-    void finished(GrGLuint programID);
+    void finished(const GrGLContext&, GrGLuint programID);
 
     const GrGLContextInfo& ctxInfo() const { return fCtxInfo; }
 
 private:
     void codeAppendf(ShaderType type, const char format[], va_list args);
     void codeAppend(ShaderType type, const char* str);
 
     typedef GrTAllocator<GrGLShaderVar> VarArray;
 
     void appendDecls(const VarArray&, SkString*) const;
     void appendUniformDecls(ShaderType, SkString*) const;
 
-    typedef GrGLUniformManager::BuilderUniform BuilderUniform;
-    GrGLUniformManager::BuilderUniformArray fUniforms;
+    // 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<Uniform> UniformArray;
+    UniformArray fUniforms;
 
     // TODO: Everything below here private.
 public:
 
     VarArray    fVSAttrs;
     VarArray    fVSOutputs;
     VarArray    fGSInputs;
     VarArray    fGSOutputs;
     VarArray    fFSInputs;
     SkString    fGSHeader; // layout qualifiers specific to GS
@@ skipping 78 matching lines @@
         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;
-    GrGLUniformManager&                 fUniformManager;
+    GrGLProgram&                        fProgram;
     uint32_t                            fFSFeaturesAddedMask;
     SkString                            fFSFunctions;
     SkString                            fFSExtensions;
 
     bool                                fUsesGS;
 
     SkString                            fFSCode;
     SkString                            fVSCode;
     SkString                            fGSCode;
 
     bool                                fSetupFragPosition;
     TextureSampler                      fDstCopySampler;
 
-    GrGLUniformManager::UniformHandle   fRTHeightUniform;
-    GrGLUniformManager::UniformHandle   fDstCopyTopLeftUniform;
-    GrGLUniformManager::UniformHandle   fDstCopyScaleUniform;
+    GrGLUniform*        fRTHeightUniform;
+    GrGLUniform*        fDstCopyTopLeftUniform;
+    GrGLUniform*        fDstCopyScaleUniform;
 
     bool                                fTopLeftFragPosRead;
 
     SkSTArray<10, AttributePair, true>  fEffectAttributes;
 
     GrGLShaderVar*                      fPositionVar;
     GrGLShaderVar*                      fLocalCoordsVar;
 
 };
 
 #endif