Rename GrGLUniformManager to GrGLUniform and ref GrGLUniforms directly

src/gpu/gl/GrGLProgram.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLProgram.h"
 
-#include "GrAllocator.h"
 #include "GrEffect.h"
 #include "GrDrawEffect.h"
 #include "GrGLEffect.h"
 #include "GrGpuGL.h"
 #include "GrGLShaderVar.h"
 #include "GrGLSL.h"
 #include "SkTrace.h"
 #include "SkXfermode.h"
 
 #include "SkRTConf.h"
 
 SK_DEFINE_INST_COUNT(GrGLProgram)
 
 #define GL_CALL(X) GR_GL_CALL(fContext.interface(), X)
 #define GL_CALL_RET(R, X) GR_GL_CALL_RET(fContext.interface(), R, X)
 
 SK_CONF_DECLARE(bool, c_PrintShaders, "gpu.printShaders", false,
                 "Print the source code for all shaders generated.");
 
 #define COL_ATTR_NAME "aColor"
 #define COV_ATTR_NAME "aCoverage"
 #define EDGE_ATTR_NAME "aEdge"
 
 namespace {
 inline const char* declared_color_output_name() { return "fsColorOut"; }
 inline const char* dual_source_output_name() { return "dualSourceOut"; }
+enum {
+    // Number of uniforms in a single allocation block.
+    kUniformsPerBlock = 8
+};
 }
 
 GrGLProgram* GrGLProgram::Create(const GrGLContext& gl,
                                  const GrGLProgramDesc& desc,
                                  const GrEffectStage* colorStages[],
                                  const GrEffectStage* coverageStages[]) {
     GrGLProgram* program = SkNEW_ARGS(GrGLProgram, (gl, desc, colorStages, coverageStages));
     if (!program->succeeded()) {
         delete program;
         program = NULL;
     }
     return program;
 }
 
 GrGLProgram::GrGLProgram(const GrGLContext& gl,
                          const GrGLProgramDesc& desc,
                          const GrEffectStage* colorStages[],
                          const GrEffectStage* coverageStages[])
-: fContext(gl)
-, fUniformManager(gl) {
+    : fContext(gl)
+    , fUniforms(kUniformsPerBlock) {
     fDesc = desc;
     fVShaderID = 0;
     fGShaderID = 0;
     fFShaderID = 0;
     fProgramID = 0;
 
     fDstCopyTexUnit = -1;
 
     fColor = GrColor_ILLEGAL;
     fColorFilterColor = GrColor_ILLEGAL;
@@ skipping 157 matching lines @@
         case GrGLProgramDesc::kAttribute_ColorInput: {
             builder->addAttribute(kVec4f_GrSLType, COL_ATTR_NAME);
             const char *vsName, *fsName;
             builder->addVarying(kVec4f_GrSLType, "Color", &vsName, &fsName);
             builder->vsCodeAppendf("\t%s = " COL_ATTR_NAME ";\n", vsName);
             *inColor = fsName;
             return kNone_GrSLConstantVec;
         }
         case GrGLProgramDesc::kUniform_ColorInput: {
             const char* name;
-            fUniformHandles.fColorUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                                                            kVec4f_GrSLType, "Color", &name);
+            fNamedUniforms.fColorUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
+                                                           kVec4f_GrSLType, "Color", &name)->glUniform();
             *inColor = name;
             return kNone_GrSLConstantVec;
         }
         case GrGLProgramDesc::kTransBlack_ColorInput:
             inColor->reset();
             return kZeros_GrSLConstantVec;
         case GrGLProgramDesc::kSolidWhite_ColorInput:
             inColor->reset();
             return kOnes_GrSLConstantVec;
         default:
             GrCrash("Unknown color type.");
             return kNone_GrSLConstantVec;
     }
 }
 
 GrSLConstantVec GrGLProgram::genInputCoverage(GrGLShaderBuilder* builder, SkString* inCoverage) {
     switch (fDesc.getHeader().fCoverageInput) {
         case GrGLProgramDesc::kAttribute_ColorInput: {
             builder->addAttribute(kVec4f_GrSLType, COV_ATTR_NAME);
             const char *vsName, *fsName;
             builder->addVarying(kVec4f_GrSLType, "Coverage", &vsName, &fsName);
             builder->vsCodeAppendf("\t%s = " COV_ATTR_NAME ";\n", vsName);
             *inCoverage = fsName;
             return kNone_GrSLConstantVec;
         }
         case GrGLProgramDesc::kUniform_ColorInput: {
             const char* name;
-            fUniformHandles.fCoverageUni =
+            fNamedUniforms.fCoverageUni =
                 builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                                    kVec4f_GrSLType, "Coverage", &name);
+                                    kVec4f_GrSLType, "Coverage", &name)->glUniform();
             *inCoverage = name;
             return kNone_GrSLConstantVec;
         }
         case GrGLProgramDesc::kTransBlack_ColorInput:
             inCoverage->reset();
             return kZeros_GrSLConstantVec;
         case GrGLProgramDesc::kSolidWhite_ColorInput:
             inCoverage->reset();
             return kOnes_GrSLConstantVec;
         default:
@@ skipping 158 matching lines @@
 
     return true;
 }
 
 bool GrGLProgram::genProgram(const GrEffectStage* colorStages[],
                              const GrEffectStage* coverageStages[]) {
     GrAssert(0 == fProgramID);
 
     const GrGLProgramDesc::KeyHeader& header = fDesc.getHeader();
 
-    GrGLShaderBuilder builder(fContext.info(), fUniformManager, fDesc);
+    GrGLShaderBuilder builder(fContext.info(), *this, fDesc);
 
     // the dual source output has no canonical var name, have to
     // declare an output, which is incompatible with gl_FragColor/gl_FragData.
     bool dualSourceOutputWritten = false;
 
     GrGLShaderVar colorOutput;
     bool isColorDeclared = GrGLSLSetupFSColorOuput(fContext.info().glslGeneration(),
                                                    declared_color_output_name(),
                                                    &colorOutput);
     if (isColorDeclared) {
         builder.fFSOutputs.push_back(colorOutput);
     }
 
     const char* viewMName;
-    fUniformHandles.fViewMatrixUni = builder.addUniform(GrGLShaderBuilder::kVertex_ShaderType,
-                                                        kMat33f_GrSLType, "ViewM", &viewMName);
+    fNamedUniforms.fViewMatrixUni = builder.addUniform(GrGLShaderBuilder::kVertex_ShaderType,
+                                                  kMat33f_GrSLType, "ViewM", &viewMName)->glUniform();
 
 
     builder.vsCodeAppendf("\tvec3 pos3 = %s * vec3(%s, 1);\n"
                           "\tgl_Position = vec4(pos3.xy, 0, pos3.z);\n",
                           viewMName, builder.positionAttribute().getName().c_str());
 
     // incoming color to current stage being processed.
     SkString inColor;
     GrSLConstantVec knownColorValue = this->genInputColor(&builder, &inColor);
 
@@ skipping 10 matching lines @@
     SkXfermode::Coeff colorCoeff;
     SkXfermode::Coeff filterColorCoeff;
     SkAssertResult(
         SkXfermode::ModeAsCoeff(static_cast<SkXfermode::Mode>(header.fColorFilterXfermode),
                                 &filterColorCoeff,
                                 &colorCoeff));
     bool needColor, needFilterColor;
     need_blend_inputs(filterColorCoeff, colorCoeff, &needFilterColor, &needColor);
 
     // used in order for builder to return the per-stage uniform handles.
-    typedef SkTArray<GrGLUniformManager::UniformHandle, true>* UniHandleArrayPtr;
+    typedef SkTArray<GrGLUniform*, true>* UniHandleArrayPtr;
     int maxColorOrCovEffectCnt = GrMax(fDesc.numColorEffects(), fDesc.numCoverageEffects());
     SkAutoTArray<UniHandleArrayPtr> effectUniformArrays(maxColorOrCovEffectCnt);
     SkAutoTArray<GrGLEffect*> glEffects(maxColorOrCovEffectCnt);
 
     if (needColor) {
         for (int e = 0; e < fDesc.numColorEffects(); ++e) {
             effectUniformArrays[e] = &fColorEffects[e].fSamplerUnis;
         }
 
         builder.emitEffects(colorStages,
                             fDesc.effectKeys(),
                             fDesc.numColorEffects(),
                             &inColor,
                             &knownColorValue,
                             effectUniformArrays.get(),
                             glEffects.get());
 
         for (int e = 0; e < fDesc.numColorEffects(); ++e) {
             fColorEffects[e].fGLEffect = glEffects[e];
         }
     }
 
     // Insert the color filter. This will soon be replaced by a color effect.
     if (SkXfermode::kDst_Mode != header.fColorFilterXfermode) {
         const char* colorFilterColorUniName = NULL;
-        fUniformHandles.fColorFilterUni = builder.addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                                                             kVec4f_GrSLType, "FilterColor",
-                                                             &colorFilterColorUniName);
+        fNamedUniforms.fColorFilterUni = builder.addUniform(GrGLShaderBuilder::kFragment_ShaderType,
+                                                       kVec4f_GrSLType, "FilterColor",
+                                                            &colorFilterColorUniName)->glUniform();
 
         builder.fsCodeAppend("\tvec4 filteredColor;\n");
         const char* color;
         // add_color_filter requires a real input string.
         if (knownColorValue == kOnes_GrSLConstantVec) {
             color = GrGLSLOnesVecf(4);
         } else if (knownColorValue == kZeros_GrSLConstantVec) {
             color = GrGLSLZerosVecf(4);
         } else {
             color = inColor.c_str();
@@ skipping 130 matching lines @@
     if (!this->compileShaders(builder)) {
         return false;
     }
 
     if (!this->bindOutputsAttribsAndLinkProgram(builder,
                                                 isColorDeclared,
                                                 dualSourceOutputWritten)) {
         return false;
     }
 
-    builder.finished(fProgramID);
-    fUniformHandles.fRTHeightUni = builder.getRTHeightUniform();
-    fUniformHandles.fDstCopyTopLeftUni = builder.getDstCopyTopLeftUniform();
-    fUniformHandles.fDstCopyScaleUni = builder.getDstCopyScaleUniform();
-    fUniformHandles.fDstCopySamplerUni = builder.getDstCopySamplerUniform();
+    builder.finished(fContext, fProgramID);
+    fNamedUniforms.fRTHeightUni = builder.getRTHeightUniform();
+    fNamedUniforms.fDstCopyTopLeftUni = builder.getDstCopyTopLeftUniform();
+    fNamedUniforms.fDstCopyScaleUni = builder.getDstCopyScaleUniform();
+    fNamedUniforms.fDstCopySamplerUni = builder.getDstCopySamplerUniform();
     // This must be called after we set fDstCopySamplerUni above.
     this->initSamplerUniforms();
 
     return true;
 }
 
 bool GrGLProgram::bindOutputsAttribsAndLinkProgram(const GrGLShaderBuilder& builder,
                                                    bool bindColorOut,
                                                    bool bindDualSrcOut) {
     GL_CALL_RET(fProgramID, CreateProgram());
@@ skipping 61 matching lines @@
         GL_CALL(DeleteProgram(fProgramID));
         fProgramID = 0;
         return false;
     }
     return true;
 }
 
 void GrGLProgram::initSamplerUniforms() {
     GL_CALL(UseProgram(fProgramID));
     GrGLint texUnitIdx = 0;
-    if (GrGLUniformManager::kInvalidUniformHandle != fUniformHandles.fDstCopySamplerUni) {
-        fUniformManager.setSampler(fUniformHandles.fDstCopySamplerUni, texUnitIdx);
+    if (NULL != fNamedUniforms.fDstCopySamplerUni) {
+        fNamedUniforms.fDstCopySamplerUni->setSampler(fContext, texUnitIdx);
         fDstCopyTexUnit = texUnitIdx++;
     }
 
     for (int e = 0; e < fColorEffects.count(); ++e) {
         this->initEffectSamplerUniforms(&fColorEffects[e], &texUnitIdx);
     }
 
     for (int e = 0; e < fCoverageEffects.count(); ++e) {
         this->initEffectSamplerUniforms(&fCoverageEffects[e], &texUnitIdx);
     }
 }
 
 void GrGLProgram::initEffectSamplerUniforms(EffectAndSamplers* effect, int* texUnitIdx) {
     int numSamplers = effect->fSamplerUnis.count();
     effect->fTextureUnits.reset(numSamplers);
     for (int s = 0; s < numSamplers; ++s) {
-        UniformHandle handle = effect->fSamplerUnis[s];
-        if (GrGLUniformManager::kInvalidUniformHandle != handle) {
-            fUniformManager.setSampler(handle, *texUnitIdx);
+        GrGLUniform* handle = effect->fSamplerUnis[s];
+        if (NULL != handle) {
+            handle->setSampler(fContext, *texUnitIdx);
             effect->fTextureUnits[s] = (*texUnitIdx)++;
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrGLProgram::setEffectData(GrGpuGL* gpu,
                                 const GrEffectStage& stage,
                                 const EffectAndSamplers& effect) {
 
     // Let the GrGLEffect set its data.
     bool explicitLocalCoords = -1 != fDesc.getHeader().fLocalCoordAttributeIndex;
     GrDrawEffect drawEffect(stage, explicitLocalCoords);
-    effect.fGLEffect->setData(fUniformManager, drawEffect);
+    effect.fGLEffect->setData(fContext, drawEffect);
 
     // Bind the texures for the effect.
     int numSamplers = effect.fSamplerUnis.count();
     GrAssert((*stage.getEffect())->numTextures() == numSamplers);
     for (int s = 0; s < numSamplers; ++s) {
-        UniformHandle handle = effect.fSamplerUnis[s];
-        if (GrGLUniformManager::kInvalidUniformHandle != handle) {
+        GrGLUniform* handle = effect.fSamplerUnis[s];
+        if (NULL != handle) {
             const GrTextureAccess& access = (*stage.getEffect())->textureAccess(s);
             GrGLTexture* texture = static_cast<GrGLTexture*>(access.getTexture());
             int unit = effect.fTextureUnits[s];
             gpu->bindTexture(unit, access.getParams(), texture);
         }
     }
 }
 
 void GrGLProgram::setData(GrGpuGL* gpu,
                           GrDrawState::BlendOptFlags blendOpts,
@@ skipping 14 matching lines @@
     } else {
         color = drawState.getColor();
         coverage = drawState.getCoverage();
     }
 
     this->setColor(drawState, color, sharedState);
     this->setCoverage(drawState, coverage, sharedState);
     this->setMatrixAndRenderTargetHeight(drawState);
 
     // Setup the SkXfermode::Mode-based colorfilter uniform if necessary
-    if (GrGLUniformManager::kInvalidUniformHandle != fUniformHandles.fColorFilterUni &&
+    if (NULL != fNamedUniforms.fColorFilterUni &&
         fColorFilterColor != drawState.getColorFilterColor()) {
         GrGLfloat c[4];
         GrColorToRGBAFloat(drawState.getColorFilterColor(), c);
-        fUniformManager.set4fv(fUniformHandles.fColorFilterUni, 0, 1, c);
+        fNamedUniforms.fColorFilterUni->set4fv(fContext, 0, 1, c);
         fColorFilterColor = drawState.getColorFilterColor();
     }
 
     if (NULL != dstCopy) {
-        if (GrGLUniformManager::kInvalidUniformHandle != fUniformHandles.fDstCopyTopLeftUni) {
-            GrAssert(GrGLUniformManager::kInvalidUniformHandle != fUniformHandles.fDstCopyScaleUni);
-            GrAssert(GrGLUniformManager::kInvalidUniformHandle !=
-                     fUniformHandles.fDstCopySamplerUni);
-            fUniformManager.set2f(fUniformHandles.fDstCopyTopLeftUni,
+        if (NULL != fNamedUniforms.fDstCopyTopLeftUni) {
+            fNamedUniforms.fDstCopyTopLeftUni->set2f(fContext,
                                   static_cast<GrGLfloat>(dstCopy->offset().fX),
                                   static_cast<GrGLfloat>(dstCopy->offset().fY));
-            fUniformManager.set2f(fUniformHandles.fDstCopyScaleUni,
+            fNamedUniforms.fDstCopyScaleUni->set2f(fContext,
                                   1.f / dstCopy->texture()->width(),
                                   1.f / dstCopy->texture()->height());
             GrGLTexture* texture = static_cast<GrGLTexture*>(dstCopy->texture());
             static GrTextureParams kParams; // the default is clamp, nearest filtering.
             gpu->bindTexture(fDstCopyTexUnit, kParams, texture);
         } else {
-            GrAssert(GrGLUniformManager::kInvalidUniformHandle ==
-                    fUniformHandles.fDstCopyScaleUni);
-            GrAssert(GrGLUniformManager::kInvalidUniformHandle ==
-                    fUniformHandles.fDstCopySamplerUni);
+            GrAssert(NULL == fNamedUniforms.fDstCopyScaleUni);
+            GrAssert(NULL == fNamedUniforms.fDstCopySamplerUni);
         }
     } else {
-        GrAssert(GrGLUniformManager::kInvalidUniformHandle == fUniformHandles.fDstCopyTopLeftUni);
-        GrAssert(GrGLUniformManager::kInvalidUniformHandle == fUniformHandles.fDstCopyScaleUni);
-        GrAssert(GrGLUniformManager::kInvalidUniformHandle == fUniformHandles.fDstCopySamplerUni);
+        GrAssert(NULL == fNamedUniforms.fDstCopyTopLeftUni);
+        GrAssert(NULL == fNamedUniforms.fDstCopyScaleUni);
+        GrAssert(NULL == fNamedUniforms.fDstCopySamplerUni);
     }
 
     for (int e = 0; e < fColorEffects.count(); ++e) {
         // We may have omitted the GrGLEffect because of the color filter logic in genProgram.
         // This can be removed when the color filter is an effect.
         if (NULL != fColorEffects[e].fGLEffect) {
             this->setEffectData(gpu, *colorStages[e], fColorEffects[e]);
         }
     }
 
@@ skipping 20 matching lines @@
                     GL_CALL(VertexAttrib4fv(header.fColorAttributeIndex, c));
                     sharedState->fConstAttribColor = color;
                     sharedState->fConstAttribColorIndex = header.fColorAttributeIndex;
                 }
                 break;
             case GrGLProgramDesc::kUniform_ColorInput:
                 if (fColor != color) {
                     // OpenGL ES doesn't support unsigned byte varieties of glUniform
                     GrGLfloat c[4];
                     GrColorToRGBAFloat(color, c);
-                    GrAssert(GrGLUniformManager::kInvalidUniformHandle !=
-                             fUniformHandles.fColorUni);
-                    fUniformManager.set4fv(fUniformHandles.fColorUni, 0, 1, c);
+                    fNamedUniforms.fColorUni->set4fv(fContext, 0, 1, c);
                     fColor = color;
                 }
                 sharedState->fConstAttribColorIndex = -1;
                 break;
             case GrGLProgramDesc::kSolidWhite_ColorInput:
             case GrGLProgramDesc::kTransBlack_ColorInput:
                 sharedState->fConstAttribColorIndex = -1;
                 break;
             default:
                 GrCrash("Unknown color type.");
@@ skipping 18 matching lines @@
                     GL_CALL(VertexAttrib4fv(header.fCoverageAttributeIndex, c));
                     sharedState->fConstAttribCoverage = coverage;
                     sharedState->fConstAttribCoverageIndex = header.fCoverageAttributeIndex;
                 }
                 break;
             case GrGLProgramDesc::kUniform_ColorInput:
                 if (fCoverage != coverage) {
                     // OpenGL ES doesn't support unsigned byte varieties of glUniform
                     GrGLfloat c[4];
                     GrColorToRGBAFloat(coverage, c);
-                    GrAssert(GrGLUniformManager::kInvalidUniformHandle !=
-                             fUniformHandles.fCoverageUni);
-                    fUniformManager.set4fv(fUniformHandles.fCoverageUni, 0, 1, c);
+                    fNamedUniforms.fCoverageUni->set4fv(fContext, 0, 1, c);
                     fCoverage = coverage;
                 }
                 sharedState->fConstAttribCoverageIndex = -1;
                 break;
             case GrGLProgramDesc::kSolidWhite_ColorInput:
             case GrGLProgramDesc::kTransBlack_ColorInput:
                 sharedState->fConstAttribCoverageIndex = -1;
                 break;
             default:
                 GrCrash("Unknown coverage type.");
         }
     } else {
         sharedState->fConstAttribCoverageIndex = -1;
     }
 }
 
 void GrGLProgram::setMatrixAndRenderTargetHeight(const GrDrawState& drawState) {
     const GrRenderTarget* rt = drawState.getRenderTarget();
     SkISize size;
     size.set(rt->width(), rt->height());
 
     // Load the RT height uniform if it is needed to y-flip gl_FragCoord.
-    if (GrGLUniformManager::kInvalidUniformHandle != fUniformHandles.fRTHeightUni &&
+    if (NULL != fNamedUniforms.fRTHeightUni &&
         fMatrixState.fRenderTargetSize.fHeight != size.fHeight) {
-        fUniformManager.set1f(fUniformHandles.fRTHeightUni, SkIntToScalar(size.fHeight));
+        fNamedUniforms.fRTHeightUni->set1f(fContext, SkIntToScalar(size.fHeight));
     }
 
     if (fMatrixState.fRenderTargetOrigin != rt->origin() ||
         !fMatrixState.fViewMatrix.cheapEqualTo(drawState.getViewMatrix()) ||
         fMatrixState.fRenderTargetSize != size) {
         SkMatrix m;
         if (kBottomLeft_GrSurfaceOrigin == rt->origin()) {
             m.setAll(
                 SkIntToScalar(2) / size.fWidth, 0, -SK_Scalar1,
                 0,-SkIntToScalar(2) / size.fHeight, SK_Scalar1,
@@ skipping 11 matching lines @@
             SkScalarToFloat(m[SkMatrix::kMScaleX]),
             SkScalarToFloat(m[SkMatrix::kMSkewY]),
             SkScalarToFloat(m[SkMatrix::kMPersp0]),
             SkScalarToFloat(m[SkMatrix::kMSkewX]),
             SkScalarToFloat(m[SkMatrix::kMScaleY]),
             SkScalarToFloat(m[SkMatrix::kMPersp1]),
             SkScalarToFloat(m[SkMatrix::kMTransX]),
             SkScalarToFloat(m[SkMatrix::kMTransY]),
             SkScalarToFloat(m[SkMatrix::kMPersp2])
         };
-        fUniformManager.setMatrix3f(fUniformHandles.fViewMatrixUni, mt);
+        fNamedUniforms.fViewMatrixUni->setMatrix3f(fContext, mt);
         fMatrixState.fViewMatrix = drawState.getViewMatrix();
         fMatrixState.fRenderTargetSize = size;
         fMatrixState.fRenderTargetOrigin = rt->origin();
     }
 }