Rename GrGLUniformManager to GrGLUniform and ref GrGLUniforms directly

src/gpu/gl/GrGLShaderBuilder.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gl/GrGLShaderBuilder.h"
 #include "gl/GrGLProgram.h"
-#include "gl/GrGLUniformHandle.h"
 #include "GrDrawEffect.h"
 #include "GrTexture.h"
 
 // number of each input/output type in a single allocation block
 static const int kVarsPerBlock = 8;
 
 // except FS outputs where we expect 2 at most.
 static const int kMaxFSOutputs = 2;
 
 // ES2 FS only guarantees mediump and lowp support
 static const GrGLShaderVar::Precision kDefaultFragmentPrecision = GrGLShaderVar::kMedium_Precision;
 
-typedef GrGLUniformManager::UniformHandle UniformHandle;
 ///////////////////////////////////////////////////////////////////////////////
 
 namespace {
 
 inline const char* sample_function_name(GrSLType type, GrGLSLGeneration glslGen) {
     if (kVec2f_GrSLType == type) {
         return glslGen >= k130_GrGLSLGeneration ? "texture" : "texture2D";
     } else {
         GrAssert(kVec3f_GrSLType == type);
         return glslGen >= k130_GrGLSLGeneration ? "textureProj" : "texture2DProj";
@@ skipping 51 matching lines @@
     }
 }
 
 }
 
 static const char kDstCopyColorName[] = "_dstColor";
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrGLShaderBuilder::GrGLShaderBuilder(const GrGLContextInfo& ctxInfo,
-                                     GrGLUniformManager& uniformManager,
+                                     GrGLProgram& program,
                                      const GrGLProgramDesc& desc)
     : fUniforms(kVarsPerBlock)
     , fVSAttrs(kVarsPerBlock)
     , fVSOutputs(kVarsPerBlock)
     , fGSInputs(kVarsPerBlock)
     , fGSOutputs(kVarsPerBlock)
     , fFSInputs(kVarsPerBlock)
     , fFSOutputs(kMaxFSOutputs)
     , fCtxInfo(ctxInfo)
-    , fUniformManager(uniformManager)
+    , fProgram(program)
     , fFSFeaturesAddedMask(0)
 #if GR_GL_EXPERIMENTAL_GS
     , fUsesGS(SkToBool(desc.getHeader().fExperimentalGS))
 #else
     , fUsesGS(false)
 #endif
     , fSetupFragPosition(false)
-    , fRTHeightUniform(GrGLUniformManager::kInvalidUniformHandle)
-    , fDstCopyTopLeftUniform (GrGLUniformManager::kInvalidUniformHandle)
-    , fDstCopyScaleUniform (GrGLUniformManager::kInvalidUniformHandle)
+    , fRTHeightUniform(NULL)
+    , fDstCopyTopLeftUniform(NULL)
+    , fDstCopyScaleUniform(NULL)
     , fTopLeftFragPosRead(kTopLeftFragPosRead_FragPosKey == desc.getHeader().fFragPosKey) {
 
     const GrGLProgramDesc::KeyHeader& header = desc.getHeader();
 
     fPositionVar = &fVSAttrs.push_back();
     fPositionVar->set(kVec2f_GrSLType, GrGLShaderVar::kAttribute_TypeModifier, "aPosition");
     if (-1 != header.fLocalCoordAttributeIndex) {
         fLocalCoordsVar = &fVSAttrs.push_back();
         fLocalCoordsVar->set(kVec2f_GrSLType,
                              GrGLShaderVar::kAttribute_TypeModifier,
@@ skipping 11 matching lines @@
         if (SkToBool(kUseAlphaConfig_DstReadKeyBit & header.fDstReadKey)) {
             configMask = kA_GrColorComponentFlag;
         } else {
             configMask = kRGBA_GrColorComponentFlags;
         }
         fDstCopySampler.init(this, configMask, "rgba", 0);
 
         fDstCopyTopLeftUniform = this->addUniform(kFragment_ShaderType,
                                                   kVec2f_GrSLType,
                                                   "DstCopyUpperLeft",
-                                                  &dstCopyTopLeftName);
+                                                  &dstCopyTopLeftName)->glUniform();
         fDstCopyScaleUniform     = this->addUniform(kFragment_ShaderType,
                                                     kVec2f_GrSLType,
                                                     "DstCopyCoordScale",
-                                                    &dstCopyCoordScaleName);
+                                                    &dstCopyCoordScaleName)->glUniform();
         const char* fragPos = this->fragmentPosition();
         this->fsCodeAppend("\t// Read color from copy of the destination.\n");
         this->fsCodeAppendf("\tvec2 _dstTexCoord = (%s.xy - %s) * %s;\n",
                             fragPos, dstCopyTopLeftName, dstCopyCoordScaleName);
         if (!topDown) {
             this->fsCodeAppend("\t_dstTexCoord.y = 1.0 - _dstTexCoord.y;\n");
         }
         this->fsCodeAppendf("\tvec4 %s = ", kDstCopyColorName);
         this->appendTextureLookup(kFragment_ShaderType, fDstCopySampler, "_dstTexCoord");
         this->fsCodeAppend(";\n\n");
@@ skipping 131 matching lines @@
 }
 
 void GrGLShaderBuilder::appendTextureLookup(SkString* out,
                                             const GrGLShaderBuilder::TextureSampler& sampler,
                                             const char* coordName,
                                             GrSLType varyingType) const {
     GrAssert(NULL != coordName);
 
     out->appendf("%s(%s, %s)",
                  sample_function_name(varyingType, fCtxInfo.glslGeneration()),
-                 this->getUniformCStr(sampler.fSamplerUniform),
+                 sampler.fSamplerUniform->c_str(),
                  coordName);
     append_swizzle(out, sampler, *fCtxInfo.caps());
 }
 
 void GrGLShaderBuilder::appendTextureLookup(ShaderType type,
                                             const GrGLShaderBuilder::TextureSampler& sampler,
                                             const char* coordName,
                                             GrSLType varyingType) {
     GrAssert(kFragment_ShaderType == type);
     this->appendTextureLookup(&fFSCode, sampler, coordName, varyingType);
@@ skipping 59 matching lines @@
             static const GrGLenum gAlphaSmear[] = { GR_GL_ALPHA, GR_GL_ALPHA,
                                                     GR_GL_ALPHA, GR_GL_ALPHA };
             return gAlphaSmear;
         }
     } else {
         static const GrGLenum gStraight[] = { GR_GL_RED, GR_GL_GREEN, GR_GL_BLUE, GR_GL_ALPHA };
         return gStraight;
     }
 }
 
-GrGLUniformManager::UniformHandle GrGLShaderBuilder::addUniformArray(uint32_t visibility,
-                                                                     GrSLType type,
-                                                                     const char* name,
-                                                                     int count,
-                                                                     const char** outName) {
+GrGLShaderBuilder::Uniform* GrGLShaderBuilder::addUniformArray(uint32_t visibility,
+                                                               GrSLType type,
+                                                               const char* name,
+                                                               int count,
+                                                               const char** outName) {
     GrAssert(name && strlen(name));
     SkDEBUGCODE(static const uint32_t kVisibilityMask = kVertex_ShaderType | kFragment_ShaderType);
     GrAssert(0 == (~kVisibilityMask & visibility));
     GrAssert(0 != visibility);
 
-    BuilderUniform& uni = fUniforms.push_back();
-    UniformHandle h = index_to_handle(fUniforms.count() - 1);
-    GR_DEBUGCODE(UniformHandle h2 =)
-    fUniformManager.appendUniform(type, count);
-    // We expect the uniform manager to initially have no uniforms and that all uniforms are added
-    // by this function. Therefore, the handles should match.
-    GrAssert(h2 == h);
+    Uniform& uni = fUniforms.push_back();
+    uni.fGLUniform = fProgram.appendUniform();
+    GR_DEBUGCODE(uni.fGLUniform->initType(count, type));
+
     uni.fVariable.setType(type);
     uni.fVariable.setTypeModifier(GrGLShaderVar::kUniform_TypeModifier);
     this->nameVariable(uni.fVariable.accessName(), 'u', name);
     uni.fVariable.setArrayCount(count);
     uni.fVisibility = visibility;
 
     // If it is visible in both the VS and FS, the precision must match.
     // We declare a default FS precision, but not a default VS. So set the var
     // to use the default FS precision.
     if ((kVertex_ShaderType | kFragment_ShaderType) == visibility) {
         // the fragment and vertex precisions must match
         uni.fVariable.setPrecision(kDefaultFragmentPrecision);
     }
 
     if (NULL != outName) {
         *outName = uni.fVariable.c_str();
     }
 
-    return h;
-}
-
-const GrGLShaderVar& GrGLShaderBuilder::getUniformVariable(UniformHandle u) const {
-    return fUniforms[handle_to_index(u)].fVariable;
+    return &uni;
 }
 
 bool GrGLShaderBuilder::addAttribute(GrSLType type,
                                      const char* name) {
     for (int i = 0; i < fVSAttrs.count(); ++i) {
         const GrGLShaderVar& attr = fVSAttrs[i];
         // if attribute already added, don't add it again
         if (attr.getName().equals(name)) {
             GrAssert(attr.getType() == type);
             return false;
@@ skipping 72 matching lines @@
                                       GrGLShaderVar::kUpperLeft_Origin);
             fSetupFragPosition = true;
         }
         return "gl_FragCoord";
     } else {
         static const char* kCoordName = "fragCoordYDown";
         if (!fSetupFragPosition) {
             // temporarily change the stage index because we're inserting non-stage code.
             CodeStage::AutoStageRestore csar(&fCodeStage, NULL);
 
-            GrAssert(GrGLUniformManager::kInvalidUniformHandle == fRTHeightUniform);
+            GrAssert(NULL == fRTHeightUniform);
             const char* rtHeightName;
 
             fRTHeightUniform = this->addUniform(kFragment_ShaderType,
                                                 kFloat_GrSLType,
                                                 "RTHeight",
-                                                &rtHeightName);
+                                                &rtHeightName)->glUniform();
 
             this->fFSCode.prependf("\tvec4 %s = vec4(gl_FragCoord.x, %s - gl_FragCoord.y, gl_FragCoord.zw);\n",
                                    kCoordName, rtHeightName);
             fSetupFragPosition = true;
         }
-        GrAssert(GrGLUniformManager::kInvalidUniformHandle != fRTHeightUniform);
+        GrAssert(NULL != fRTHeightUniform);
         return kCoordName;
     }
 }
 
 
 void GrGLShaderBuilder::emitFunction(ShaderType shader,
                                      GrSLType returnType,
                                      const char* name,
                                      int argCnt,
                                      const GrGLShaderVar* args,
@@ skipping 95 matching lines @@
             GrAssert(k110_GrGLSLGeneration != fCtxInfo.glslGeneration() || fFSOutputs.empty());
             this->appendDecls(fFSOutputs, shaderStr);
             shaderStr->append(fFSFunctions);
             shaderStr->append("void main() {\n");
             shaderStr->append(fFSCode);
             shaderStr->append("}\n");
             break;
     }
  }
 
-void GrGLShaderBuilder::finished(GrGLuint programID) {
-    fUniformManager.getUniformLocations(programID, fUniforms);
+void GrGLShaderBuilder::finished(const GrGLContext& context, GrGLuint programID) {
+    int count = fUniforms.count();
+    for (int i = 0; i < count; ++i) {
+        fUniforms[i].glUniform()->initLocations(context, programID, fUniforms[i].c_str(), fUniforms[i].fVisibility);
+    }
 }
 
 void GrGLShaderBuilder::emitEffects(
                         const GrEffectStage* effectStages[],
                         const GrBackendEffectFactory::EffectKey effectKeys[],
                         int effectCnt,
                         SkString* fsInOutColor,
                         GrSLConstantVec* fsInOutColorKnownValue,
-                        SkTArray<GrGLUniformManager::UniformHandle, true>* effectSamplerHandles[],
+                        SkTArray<GrGLUniform*, true>* effectSamplerHandles[],
                         GrGLEffect* glEffects[]) {
     bool effectEmitted = false;
 
     SkString inColor = *fsInOutColor;
     SkString outColor;
 
     for (int e = 0; e < effectCnt; ++e) {
         GrAssert(NULL != effectStages[e] && NULL != effectStages[e]->getEffect());
         const GrEffectStage& stage = *effectStages[e];
         const GrEffectRef& effect = *stage.getEffect();
 
         CodeStage::AutoStageRestore csar(&fCodeStage, &stage);
 
         int numTextures = effect->numTextures();
         SkSTArray<8, GrGLShaderBuilder::TextureSampler> textureSamplers;
         textureSamplers.push_back_n(numTextures);
         for (int t = 0; t < numTextures; ++t) {
             textureSamplers[t].init(this, &effect->textureAccess(t), t);
-            effectSamplerHandles[e]->push_back(textureSamplers[t].fSamplerUniform);
+            effectSamplerHandles[e]->push_back(textureSamplers[t].fSamplerUniform->glUniform());
         }
         GrDrawEffect drawEffect(stage, this->hasExplicitLocalCoords());
 
         int numAttributes = stage.getVertexAttribIndexCount();
         const int* attributeIndices = stage.getVertexAttribIndices();
         SkSTArray<GrEffect::kMaxVertexAttribs, SkString> attributeNames;
         for (int a = 0; a < numAttributes; ++a) {
             // TODO: Make addAttribute mangle the name.
             SkString attributeName("aAttr");
             attributeName.appendS32(attributeIndices[a]);
@@ skipping 44 matching lines @@
     for (const AttributePair* attrib = this->getEffectAttributes().begin();
          attrib != attribEnd;
          ++attrib) {
         if (attrib->fIndex == attributeIndex) {
             return &attrib->fName;
         }
     }
 
     return NULL;
 }
+
+