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 214 matching lines @@
     return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrGLShaderBuilder::GrGLShaderBuilder(GrGpuGL* gpu,
                                      const GrGLProgramDesc& desc)
     : fHasVertexShader(false)
     , fTexCoordSetCnt(0)
     , fProgramID(0)
+    , fFSInputs(kVarsPerBlock)
+    , fSeparableVaryingInfos(kVarsPerBlock)
     , fDesc(desc)
     , fGpu(gpu)
     , 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 519 matching lines @@
     bool usingBindUniform = fGpu->glInterface()->fFunctions.fBindUniformLocation != NULL;
     if (!usingBindUniform) {
         int count = fUniforms.count();
         for (int i = 0; i < count; ++i) {
             GrGLint location;
             GL_CALL_RET(location,
                         GetUniformLocation(programId, fUniforms[i].fVariable.c_str()));
             fUniforms[i].fLocation = location;
         }
     }
+
+    int count = fSeparableVaryingInfos.count();
+    for (int i = 0; i < count; ++i) {
+        GrGLint location;
+        GL_CALL_RET(location,
+                    GetProgramResourceLocation(programId,
+                                               GR_GL_FRAGMENT_INPUT,
+                                               fSeparableVaryingInfos[i].fVariable.c_str()));
+        fSeparableVaryingInfos[i].fLocation = location;
+    }
 }
 
 const GrGLContextInfo& GrGLShaderBuilder::ctxInfo() const {
     return fGpu->ctxInfo();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrGLFullShaderBuilder::GrGLFullShaderBuilder(GrGpuGL* gpu,
                                              const GrGLProgramDesc& desc)
@@ skipping 119 matching lines @@
         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);
     if (fsInName) {
         *fsInName = fsName->c_str();
     }
 }
 
+GrGLFullShaderBuilder::VaryingHandle
+GrGLFullShaderBuilder::addSeparableVarying(GrSLType type,
+                                        const char* name,
+                                        const char** vsOutName,
+                                        const char** fsInName) {
+    addVarying(type, name, vsOutName, fsInName);
+    SeparableVaryingInfo& varying = fSeparableVaryingInfos.push_back();
+    varying.fVariable = fFSInputs.back();
+    return VaryingHandle::CreateFromSeparableVaryingIndex(fSeparableVaryingInfos.count() - 1);
+}
+
 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;
         }
     }
 
     return NULL;
 }
@@ skipping 94 matching lines @@
     for (const AttributePair* attrib = fEffectAttributes.begin(); attrib != attribEnd; ++attrib) {
          GL_CALL(BindAttribLocation(programId, attrib->fIndex, attrib->fName.c_str()));
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrGLFragmentOnlyShaderBuilder::GrGLFragmentOnlyShaderBuilder(GrGpuGL* gpu,
                                                              const GrGLProgramDesc& desc)
     : INHERITED(gpu, desc) {
-    SkASSERT(!desc.getHeader().fHasVertexCode);
+    SkASSERT(!desc.getHeader().fRequiresVertexShader);
     SkASSERT(gpu->glCaps().pathRenderingSupport());
     SkASSERT(GrGLProgramDesc::kAttribute_ColorInput != desc.getHeader().fColorInput);
     SkASSERT(GrGLProgramDesc::kAttribute_ColorInput != desc.getHeader().fCoverageInput);
 }
 
 int GrGLFragmentOnlyShaderBuilder::addTexCoordSets(int count) {
     int firstFreeCoordSet = fTexCoordSetCnt;
     fTexCoordSetCnt += count;
     SkASSERT(gpu()->glCaps().maxFixedFunctionTextureCoords() >= fTexCoordSetCnt);
     return firstFreeCoordSet;
 }
 
 GrGLProgramEffects* GrGLFragmentOnlyShaderBuilder::createAndEmitEffects(
         const GrEffectStage* effectStages[],
         int effectCnt,
         const GrGLProgramDesc::EffectKeyProvider& keyProvider,
         GrGLSLExpr4* inOutFSColor) {
 
     GrGLPathTexGenProgramEffectsBuilder pathTexGenEffectsBuilder(this,
                                                                  effectCnt);
     this->INHERITED::createAndEmitEffects(&pathTexGenEffectsBuilder,
                                           effectStages,
                                           effectCnt,
                                           keyProvider,
                                           inOutFSColor);
     return pathTexGenEffectsBuilder.finish();
 }