Add addFragPosUniform to GrGLrogramBuilder

src/gpu/gl/builders/GrGLProgramBuilder.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLProgramBuilder.h"
 
 #include "GrAutoLocaleSetter.h"
@@ skipping 38 matching lines @@
 
     return pb->finalize();
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 GrGLProgramBuilder::GrGLProgramBuilder(GrGLGpu* gpu, const DrawArgs& args)
     : fVS(this)
     , fGS(this)
     , fFS(this, args.fDesc->header().fFragPosKey)
-    , fOutOfStage(true)
     , fStageIndex(-1)
     , fGeometryProcessor(nullptr)
     , fXferProcessor(nullptr)
     , fArgs(args)
     , fGpu(gpu)
     , fUniforms(kVarsPerBlock)
     , fSamplerUniforms(4)
     , fSeparableVaryingInfos(kVarsPerBlock) {
 }
 
@@ skipping 30 matching lines @@
              fArgs.fPrimitiveProcessor->isPathRendering() &&
              !fArgs.fPrimitiveProcessor->willUseGeoShader() &&
              fArgs.fPrimitiveProcessor->numAttribs() == 0);
     this->addVarying(name, v, fsPrecision);
     SeparableVaryingInfo& varyingInfo = fSeparableVaryingInfos.push_back();
     varyingInfo.fVariable = this->getFragmentShaderBuilder()->fInputs.back();
     varyingInfo.fLocation = fSeparableVaryingInfos.count() - 1;
     return SeparableVaryingHandle(varyingInfo.fLocation);
 }
 
-void GrGLProgramBuilder::nameVariable(SkString* out, char prefix, const char* name) {
+void GrGLProgramBuilder::nameVariable(SkString* out, char prefix, const char* name, bool mangle) {
     if ('\0' == prefix) {
         *out = name;
     } else {
         out->printf("%c%s", prefix, name);
     }
-    if (!fOutOfStage) {
+    if (mangle) {
         if (out->endsWith('_')) {
             // Names containing "__" are reserved.
             out->append("x");
         }
         out->appendf("_Stage%d%s", fStageIndex, fFS.getMangleString().c_str());
     }
 }
 
-GrGLSLProgramDataManager::UniformHandle GrGLProgramBuilder::addUniformArray(
+GrGLSLProgramDataManager::UniformHandle GrGLProgramBuilder::internalAddUniformArray(
                                                                 uint32_t visibility,
                                                                 GrSLType type,
                                                                 GrSLPrecision precision,
                                                                 const char* name,
+                                                                bool mangleName,
                                                                 int count,
                                                                 const char** outName) {
     SkASSERT(name && strlen(name));
     SkDEBUGCODE(static const uint32_t kVisibilityMask = kVertex_Visibility | kFragment_Visibility);
     SkASSERT(0 == (~kVisibilityMask & visibility));
     SkASSERT(0 != visibility);
     SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeIsFloatType(type));
 
     UniformInfo& uni = fUniforms.push_back();
     uni.fVariable.setType(type);
     uni.fVariable.setTypeModifier(GrGLSLShaderVar::kUniform_TypeModifier);
     // TODO this is a bit hacky, lets think of a better way.  Basically we need to be able to use
     // the uniform view matrix name in the GP, and the GP is immutable so it has to tell the PB
     // exactly what name it wants to use for the uniform view matrix.  If we prefix anythings, then
     // the names will mismatch.  I think the correct solution is to have all GPs which need the
     // uniform view matrix, they should upload the view matrix in their setData along with regular
     // uniforms.
     char prefix = 'u';
     if ('u' == name[0]) {
         prefix = '\0';
     }
-    this->nameVariable(uni.fVariable.accessName(), prefix, name);
+    this->nameVariable(uni.fVariable.accessName(), prefix, name, mangleName);
     uni.fVariable.setArrayCount(count);
     uni.fVisibility = visibility;
     uni.fVariable.setPrecision(precision);
 
     if (outName) {
         *outName = uni.fVariable.c_str();
     }
     return GrGLSLProgramDataManager::UniformHandle(fUniforms.count() - 1);
 }
 
@@ skipping 382 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLInstalledFragProcs::~GrGLInstalledFragProcs() {
     int numProcs = fProcs.count();
     for (int i = 0; i < numProcs; ++i) {
         delete fProcs[i];
     }
 }