Implement NVPR on GLES

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"
@@ skipping 234 matching lines @@
     }
 
     return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrGLShaderBuilder::GrGLShaderBuilder(GrGpuGL* gpu,
                                      GrGLUniformManager* uniformManager,
                                      const GrGLProgramDesc& desc)
-    : fDesc(desc)
+    : fFSInputs(kVarsPerBlock)
+    , fUniformManager(SkRef(uniformManager))
+    , fDesc(desc)
     , fGpu(gpu)
-    , fUniformManager(SkRef(uniformManager))
     , fFSFeaturesAddedMask(0)
-    , fFSInputs(kVarsPerBlock)
     , fFSOutputs(kMaxFSOutputs)
     , fUniforms(kVarsPerBlock)
     , fSetupFragPosition(false)
     , fTopLeftFragPosRead(kTopLeftFragPosRead_FragPosKey == desc.getHeader().fFragPosKey)
     , fHasCustomColorOutput(false)
     , fHasSecondaryOutput(false) {
 }
 
 bool GrGLShaderBuilder::enableFeature(GLSLFeature feature) {
     switch (feature) {
@@ skipping 231 matching lines @@
         fSetupFragPosition = true;
         return "gl_FragCoord";
     } else if (fGpu->glCaps().fragCoordConventionsSupport()) {
         if (!fSetupFragPosition) {
             SkAssertResult(this->enablePrivateFeature(kFragCoordConventions_GLSLPrivateFeature));
             fFSInputs.push_back().set(kVec4f_GrSLType,
                                       GrGLShaderVar::kIn_TypeModifier,
                                       "gl_FragCoord",
                                       GrGLShaderVar::kDefault_Precision,
                                       GrGLShaderVar::kUpperLeft_Origin);
+            fUniformManager->appendFragmentInput();
             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);
 
             SkASSERT(!fOutput.fUniformHandles.fRTHeightUni.isValid());
@@ skipping 147 matching lines @@
     }
 
     SkTDArray<GrGLuint> shadersToDelete;
 
     if (!this->compileAndAttachShaders(fOutput.fProgramID, &shadersToDelete)) {
         GL_CALL(DeleteProgram(fOutput.fProgramID));
         return false;
     }
 
     this->bindProgramLocations(fOutput.fProgramID);
-    if (fUniformManager->isUsingBindUniform()) {
-        fUniformManager->getUniformLocations(fOutput.fProgramID, fUniforms);
-    }
+    fUniformManager->bindProgramResourceLocations(fOutput.fProgramID, fUniforms);
 
     GL_CALL(LinkProgram(fOutput.fProgramID));
 
     // Calling GetProgramiv is expensive in Chromium. Assume success in release builds.
     bool checkLinked = !fGpu->ctxInfo().isChromium();
 #ifdef SK_DEBUG
     checkLinked = true;
 #endif
     if (checkLinked) {
         GrGLint linked = GR_GL_INIT_ZERO;
@@ skipping 12 matching lines @@
                                           (char*)log.get()));
                 GrPrintf((char*)log.get());
             }
             SkDEBUGFAIL("Error linking program");
             GL_CALL(DeleteProgram(fOutput.fProgramID));
             fOutput.fProgramID = 0;
             return false;
         }
     }
 
-    if (!fUniformManager->isUsingBindUniform()) {
-        fUniformManager->getUniformLocations(fOutput.fProgramID, fUniforms);
-    }
+    fUniformManager->resolveProgramResourceLocations(fOutput.fProgramID, fUniforms, fFSInputs);
 
     for (int i = 0; i < shadersToDelete.count(); ++i) {
       GL_CALL(DeleteShader(shadersToDelete[i]));
     }
 
     return true;
 }
 
 // Compiles a GL shader and attaches it to a program. Returns the shader ID if
 // successful, or 0 if not.
@@ skipping 188 matching lines @@
                                                GrSLType type,
                                                const SkString& name) {
     if (!this->addAttribute(type, name.c_str())) {
         return false;
     }
 
     fEffectAttributes.push_back().set(attributeIndex, name);
     return true;
 }
 
-void GrGLFullShaderBuilder::addVarying(GrSLType type,
-                                       const char* name,
-                                       const char** vsOutName,
-                                       const char** fsInName) {
+GrGLUniformManager::FragmentInputHandle GrGLFullShaderBuilder::addVarying(GrSLType type,
+                                                                          const char* name,
+                                                                          const char** vsOutName,
+                                                                          const char** fsInName) {
     fVSOutputs.push_back();
     fVSOutputs.back().setType(type);
     fVSOutputs.back().setTypeModifier(GrGLShaderVar::kVaryingOut_TypeModifier);
     this->nameVariable(fVSOutputs.back().accessName(), 'v', name);
 
     if (vsOutName) {
         *vsOutName = fVSOutputs.back().getName().c_str();
     }
     // input to FS comes either from VS or GS
     const SkString* fsName;
 #if GR_GL_EXPERIMENTAL_GS
     if (this->desc().getHeader().fExperimentalGS) {
         // if we have a GS take each varying in as an array
         // and output as non-array.
         fGSInputs.push_back();
         fGSInputs.back().setType(type);
         fGSInputs.back().setTypeModifier(GrGLShaderVar::kVaryingIn_TypeModifier);
         fGSInputs.back().setUnsizedArray();
         *fGSInputs.back().accessName() = fVSOutputs.back().getName();
         fGSOutputs.push_back();
         fGSOutputs.back().setType(type);
         fGSOutputs.back().setTypeModifier(GrGLShaderVar::kVaryingOut_TypeModifier);
         this->nameVariable(fGSOutputs.back().accessName(), 'g', name);
         fsName = fGSOutputs.back().accessName();
     } else
 #endif
     {
         fsName = fVSOutputs.back().accessName();
     }
-    this->fsInputAppend().set(type, GrGLShaderVar::kVaryingIn_TypeModifier, *fsName);
+    this->fFSInputs.push_back().set(type, GrGLShaderVar::kVaryingIn_TypeModifier, *fsName);
+    GrGLUniformManager::FragmentInputHandle h =
+        GrGLUniformManager::FragmentInputHandle::CreateFromFragmentInputIndex(fFSInputs.count() - 1);
+
+    SkDEBUGCODE(GrGLUniformManager::FragmentInputHandle h2 =)
+    fUniformManager->appendFragmentInput();
+    SkASSERT(h == h2);
+
     if (fsInName) {
         *fsInName = fsName->c_str();
     }
+    return h;
 }
 
 const SkString* GrGLFullShaderBuilder::getEffectAttributeName(int attributeIndex) const {
     const AttributePair* attribEnd = fEffectAttributes.end();
     for (const AttributePair* attrib = fEffectAttributes.begin(); attrib != attribEnd; ++attrib) {
         if (attrib->fIndex == attributeIndex) {
             return &attrib->fName;
         }
     }
 
@@ skipping 125 matching lines @@
 
     GrGLPathTexGenProgramEffectsBuilder pathTexGenEffectsBuilder(this,
                                                                  effectCnt);
     this->INHERITED::createAndEmitEffects(&pathTexGenEffectsBuilder,
                                           effectStages,
                                           effectKeys,
                                           effectCnt,
                                           inOutFSColor);
     return pathTexGenEffectsBuilder.finish();
 }