Move VertexBuilder to a GrGLFullShaderBuilder subclass

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 "GrCoordTransform.h"
 #include "GrDrawEffect.h"
 #include "GrGpuGL.h"
 #include "GrTexture.h"
 #include "SkRTConf.h"
 #include "SkTrace.h"
 
-#define GL_CALL(X) GR_GL_CALL(fGpu->glInterface(), X)
-#define GL_CALL_RET(R, X) GR_GL_CALL_RET(fGpu->glInterface(), R, X)
+#define GL_CALL(X) GR_GL_CALL(this->gpu()->glInterface(), X)
+#define GL_CALL_RET(R, X) GR_GL_CALL_RET(this->gpu()->glInterface(), R, X)
 
 // 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;
 
@@ skipping 54 matching lines @@
 }
 
 }
 
 static const char kDstCopyColorName[] = "_dstColor";
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrGLShaderBuilder::GrGLShaderBuilder(GrGpuGL* gpu,
                                      GrGLUniformManager& uniformManager,
-                                     const GrGLProgramDesc& desc,
-                                     bool needsVertexShader)
-    : fUniforms(kVarsPerBlock)
-    , fGpu(gpu)
+                                     const GrGLProgramDesc& desc)
+    : fGpu(gpu)
     , fUniformManager(uniformManager)
     , fFSFeaturesAddedMask(0)
     , fFSInputs(kVarsPerBlock)
     , fFSOutputs(kMaxFSOutputs)
+    , fUniforms(kVarsPerBlock)
     , fSetupFragPosition(false)
-    , fKnownColorValue(kNone_GrSLConstantVec)
-    , fKnownCoverageValue(kNone_GrSLConstantVec)
+    , fKnownColorValue(GrGLProgramDesc::KnownColorInputValue(desc.getHeader().fColorInput))
+    , fKnownCoverageValue(GrGLProgramDesc::KnownColorInputValue(desc.getHeader().fCoverageInput))
     , fHasCustomColorOutput(false)
     , fHasSecondaryOutput(false)
     , fTopLeftFragPosRead(kTopLeftFragPosRead_FragPosKey == desc.getHeader().fFragPosKey) {
 
     const GrGLProgramDesc::KeyHeader& header = desc.getHeader();
 
-    if (needsVertexShader) {
-        fVertexBuilder.reset(SkNEW_ARGS(VertexBuilder, (this, fGpu, desc)));
-    }
-
     // Emit code to read the dst copy textue if necessary.
     if (kNoDstRead_DstReadKey != header.fDstReadKey &&
         GrGLCaps::kNone_FBFetchType == fGpu->glCaps().fbFetchType()) {
         bool topDown = SkToBool(kTopLeftOrigin_DstReadKeyBit & header.fDstReadKey);
         const char* dstCopyTopLeftName;
         const char* dstCopyCoordScaleName;
         uint32_t configMask;
         if (SkToBool(kUseAlphaConfig_DstReadKeyBit & header.fDstReadKey)) {
             configMask = kA_GrColorComponentFlag;
         } else {
@@ skipping 20 matching lines @@
         this->fsCodeAppendf("\tvec4 %s = ", kDstCopyColorName);
         append_texture_lookup(&fFSCode,
                               fGpu,
                               this->getUniformCStr(fDstCopySamplerUniform),
                               "_dstTexCoord",
                               configMask,
                               "rgba");
         this->fsCodeAppend(";\n\n");
     }
 
-    switch (header.fColorInput) {
-        case GrGLProgramDesc::kAttribute_ColorInput: {
-            SkASSERT(NULL != fVertexBuilder.get());
-            fVertexBuilder->addAttribute(kVec4f_GrSLType, color_attribute_name());
-            const char *vsName, *fsName;
-            fVertexBuilder->addVarying(kVec4f_GrSLType, "Color", &vsName, &fsName);
-            fVertexBuilder->vsCodeAppendf("\t%s = %s;\n", vsName, color_attribute_name());
-            fInputColor = fsName;
-            break;
-        }
-        case GrGLProgramDesc::kUniform_ColorInput: {
-            const char* name;
-            fColorUniform = this->addUniform(GrGLShaderBuilder::kFragment_Visibility,
-                                             kVec4f_GrSLType, "Color", &name);
-            fInputColor = name;
-            break;
-        }
-        case GrGLProgramDesc::kTransBlack_ColorInput:
-            fKnownColorValue = kZeros_GrSLConstantVec;
-            break;
-        case GrGLProgramDesc::kSolidWhite_ColorInput:
-            fKnownColorValue = kOnes_GrSLConstantVec;
-            break;
-        default:
-            GrCrash("Unknown color type.");
+    if (GrGLProgramDesc::kUniform_ColorInput == header.fColorInput) {
+        const char* name;
+        fColorUniform = this->addUniform(GrGLShaderBuilder::kFragment_Visibility,
+                                         kVec4f_GrSLType, "Color", &name);
+        fInputColor = name;
     }
 
-    switch (header.fCoverageInput) {
-        case GrGLProgramDesc::kAttribute_ColorInput: {
-            SkASSERT(NULL != fVertexBuilder.get());
-            fVertexBuilder->addAttribute(kVec4f_GrSLType, coverage_attribute_name());
-            const char *vsName, *fsName;
-            fVertexBuilder->addVarying(kVec4f_GrSLType, "Coverage", &vsName, &fsName);
-            fVertexBuilder->vsCodeAppendf("\t%s = %s;\n", vsName, coverage_attribute_name());
-            fInputCoverage = fsName;
-            break;
-        }
-        case GrGLProgramDesc::kUniform_ColorInput: {
-            const char* name;
-            fCoverageUniform = this->addUniform(GrGLShaderBuilder::kFragment_Visibility,
-                                                kVec4f_GrSLType, "Coverage", &name);
-            fInputCoverage = name;
-            break;
-        }
-        case GrGLProgramDesc::kTransBlack_ColorInput:
-            fKnownCoverageValue = kZeros_GrSLConstantVec;
-            break;
-        case GrGLProgramDesc::kSolidWhite_ColorInput:
-            fKnownCoverageValue = kOnes_GrSLConstantVec;
-            break;
-        default:
-            GrCrash("Unknown coverage type.");
+    if (GrGLProgramDesc::kUniform_ColorInput == header.fCoverageInput) {
+        const char* name;
+        fCoverageUniform = this->addUniform(GrGLShaderBuilder::kFragment_Visibility,
+                                            kVec4f_GrSLType, "Coverage", &name);
+        fInputCoverage = name;
     }
 
     if (k110_GrGLSLGeneration != fGpu->glslGeneration()) {
         fFSOutputs.push_back().set(kVec4f_GrSLType,
                                    GrGLShaderVar::kOut_TypeModifier,
                                    declared_color_output_name());
         fHasCustomColorOutput = true;
     }
 }
 
@@ skipping 327 matching lines @@
 void GrGLShaderBuilder::appendUniformDecls(ShaderVisibility visibility,
                                            SkString* out) const {
     for (int i = 0; i < fUniforms.count(); ++i) {
         if (fUniforms[i].fVisibility & visibility) {
             fUniforms[i].fVariable.appendDecl(this->ctxInfo(), out);
             out->append(";\n");
         }
     }
 }
 
-GrGLEffectArray* GrGLShaderBuilder::emitEffects(const GrEffectStage* effectStages[],
-                                                const EffectKey effectKeys[],
-                                                int effectCnt,
-                                                SkString* fsInOutColor,
-                                                GrSLConstantVec* fsInOutColorKnownValue) {
-    GrGLEffectArrayBuilder effectArrayBuilder(this, effectCnt);
+void GrGLShaderBuilder::emitEffects(GrGLEffectArrayBuilder* effectArrayBuilder,
+                                    const GrEffectStage* effectStages[],
+                                    const EffectKey effectKeys[],
+                                    int effectCnt,
+                                    SkString* fsInOutColor,
+                                    GrSLConstantVec* fsInOutColorKnownValue) {
     bool effectEmitted = false;
 
     SkString inColor = *fsInOutColor;
     SkString outColor;
 
     for (int e = 0; e < effectCnt; ++e) {
         SkASSERT(NULL != effectStages[e] && NULL != effectStages[e]->getEffect());
         const GrEffectStage& stage = *effectStages[e];
 
         CodeStage::AutoStageRestore csar(&fCodeStage, &stage);
 
         if (kZeros_GrSLConstantVec == *fsInOutColorKnownValue) {
             // Effects have no way to communicate zeros, they treat an empty string as ones.
             this->nameVariable(&inColor, '\0', "input");
             this->fsCodeAppendf("\tvec4 %s = %s;\n", inColor.c_str(), GrGLSLZerosVecf(4));
         }
 
         // create var to hold stage result
         this->nameVariable(&outColor, '\0', "output");
         this->fsCodeAppendf("\tvec4 %s;\n", outColor.c_str());
 
-        effectArrayBuilder.emitEffect(stage,
-                                      effectKeys[e],
-                                      outColor.c_str(),
-                                      inColor.isEmpty() ? NULL : inColor.c_str(),
-                                      fCodeStage.stageIndex());
+        effectArrayBuilder->emitEffect(stage,
+                                       effectKeys[e],
+                                       outColor.c_str(),
+                                       inColor.isEmpty() ? NULL : inColor.c_str(),
+                                       fCodeStage.stageIndex());
 
         inColor = outColor;
         *fsInOutColorKnownValue = kNone_GrSLConstantVec;
         effectEmitted = true;
     }
 
     if (effectEmitted) {
         *fsInOutColor = outColor;
     }
-
-    return effectArrayBuilder.finish();
 }
 
 const char* GrGLShaderBuilder::getColorOutputName() const {
     return fHasCustomColorOutput ? declared_color_output_name() : "gl_FragColor";
 }
 
 const char* GrGLShaderBuilder::enableSecondaryOutput() {
     if (!fHasSecondaryOutput) {
         fFSOutputs.push_back().set(kVec4f_GrSLType,
                                    GrGLShaderVar::kOut_TypeModifier,
@@ skipping 90 matching lines @@
     }
 
     GR_GL_CALL(gli, AttachShader(programId, shaderId));
     GR_GL_CALL(gli, DeleteShader(shaderId));
     return true;
 }
 
 }
 
 bool GrGLShaderBuilder::compileAndAttachShaders(GrGLuint programId) const {
-    if (NULL != fVertexBuilder.get() && !fVertexBuilder->compileAndAttachShaders(programId)) {
-        return false;
-    }
-
     SkString fragShaderSrc(GrGetGLSLVersionDecl(this->ctxInfo()));
     fragShaderSrc.append(fFSExtensions);
     append_default_precision_qualifier(kDefaultFragmentPrecision,
                                        fGpu->glBinding(),
                                        &fragShaderSrc);
     this->appendUniformDecls(kFragment_Visibility, &fragShaderSrc);
     this->appendDecls(fFSInputs, &fragShaderSrc);
     // We shouldn't have declared outputs on 1.10
     SkASSERT(k110_GrGLSLGeneration != fGpu->glslGeneration() || fFSOutputs.empty());
     this->appendDecls(fFSOutputs, &fragShaderSrc);
     fragShaderSrc.append(fFSFunctions);
     fragShaderSrc.append("void main() {\n");
     fragShaderSrc.append(fFSCode);
     fragShaderSrc.append("}\n");
     if (!attach_shader(fGpu->glInterface(), programId, GR_GL_FRAGMENT_SHADER, fragShaderSrc)) {
         return false;
     }
 
     return true;
 }
 
 void GrGLShaderBuilder::bindProgramLocations(GrGLuint programId) const {
-    if (NULL != fVertexBuilder.get()) {
-        fVertexBuilder->bindProgramLocations(programId);
-    }
-
     if (fHasCustomColorOutput) {
         GL_CALL(BindFragDataLocation(programId, 0, declared_color_output_name()));
     }
     if (fHasSecondaryOutput) {
         GL_CALL(BindFragDataLocationIndexed(programId, 0, 1, dual_source_output_name()));
     }
 }
 
 const GrGLContextInfo& GrGLShaderBuilder::ctxInfo() const {
     return fGpu->ctxInfo();
 }
 
-////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
-GrGLShaderBuilder::VertexBuilder::VertexBuilder(GrGLShaderBuilder* parent,
-                                                GrGpuGL* gpu,
-                                                const GrGLProgramDesc& desc)
-    : fParent(parent)
-    , fGpu(gpu)
+GrGLFullShaderBuilder::GrGLFullShaderBuilder(GrGpuGL* gpu,
+                                             GrGLUniformManager& uniformManager,
+                                             const GrGLProgramDesc& desc)
+    : INHERITED(gpu, uniformManager, desc)
     , fDesc(desc)
     , fVSAttrs(kVarsPerBlock)
     , fVSOutputs(kVarsPerBlock)
     , fGSInputs(kVarsPerBlock)
     , fGSOutputs(kVarsPerBlock) {
 
     const GrGLProgramDesc::KeyHeader& header = fDesc.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,
                              "aLocalCoords");
     } else {
         fLocalCoordsVar = fPositionVar;
     }
 
     const char* viewMName;
-    fViewMatrixUniform = fParent->addUniform(GrGLShaderBuilder::kVertex_Visibility,
-                                             kMat33f_GrSLType, "ViewM", &viewMName);
+    fViewMatrixUniform = this->addUniform(GrGLShaderBuilder::kVertex_Visibility,
+                                          kMat33f_GrSLType, "ViewM", &viewMName);
 
     this->vsCodeAppendf("\tvec3 pos3 = %s * vec3(%s, 1);\n"
                         "\tgl_Position = vec4(pos3.xy, 0, pos3.z);\n",
                         viewMName, fPositionVar->c_str());
 
     // we output point size in the GS if present
     if (header.fEmitsPointSize
 #if GR_GL_EXPERIMENTAL_GS
         && !header.fExperimentalGS
 #endif
         ) {
         this->vsCodeAppend("\tgl_PointSize = 1.0;\n");
     }
+
+    if (GrGLProgramDesc::kAttribute_ColorInput == header.fColorInput) {
+        this->addAttribute(kVec4f_GrSLType, color_attribute_name());
+        const char *vsName, *fsName;
+        this->addVarying(kVec4f_GrSLType, "Color", &vsName, &fsName);
+        this->vsCodeAppendf("\t%s = %s;\n", vsName, color_attribute_name());
+        this->setInputColor(fsName);
+    }
+
+    if (GrGLProgramDesc::kAttribute_ColorInput == header.fCoverageInput) {
+        this->addAttribute(kVec4f_GrSLType, coverage_attribute_name());
+        const char *vsName, *fsName;
+        this->addVarying(kVec4f_GrSLType, "Coverage", &vsName, &fsName);
+        this->vsCodeAppendf("\t%s = %s;\n", vsName, coverage_attribute_name());
+        this->setInputCoverage(fsName);
+    }
 }
 
-bool GrGLShaderBuilder::VertexBuilder::addAttribute(GrSLType type,
-                                                    const char* name) {
+bool GrGLFullShaderBuilder::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)) {
             SkASSERT(attr.getType() == type);
             return false;
         }
     }
     fVSAttrs.push_back().set(type,
                              GrGLShaderVar::kAttribute_TypeModifier,
                              name);
     return true;
 }
 
-bool GrGLShaderBuilder::VertexBuilder::addEffectAttribute(int attributeIndex,
-                                                          GrSLType type,
-                                                          const SkString& name) {
+bool GrGLFullShaderBuilder::addEffectAttribute(int attributeIndex,
+                                               GrSLType type,
+                                               const SkString& name) {
     if (!this->addAttribute(type, name.c_str())) {
         return false;
     }
 
     fEffectAttributes.push_back().set(attributeIndex, name);
     return true;
 }
 
-void GrGLShaderBuilder::VertexBuilder::addVarying(GrSLType type,
-                                                  const char* name,
-                                                  const char** vsOutName,
-                                                  const char** fsInName) {
+void 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);
-    fParent->nameVariable(fVSOutputs.back().accessName(), 'v', name);
+    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 (fDesc.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);
-        fParent->nameVariable(fGSOutputs.back().accessName(), 'g', name);
+        this->nameVariable(fGSOutputs.back().accessName(), 'g', name);
         fsName = fGSOutputs.back().accessName();
     } else
 #endif
     {
         fsName = fVSOutputs.back().accessName();
     }
-    fParent->fsInputAppend().set(type,
-                                 GrGLShaderVar::kVaryingIn_TypeModifier,
-                                 *fsName);
+    this->fsInputAppend().set(type, GrGLShaderVar::kVaryingIn_TypeModifier, *fsName);
     if (fsInName) {
         *fsInName = fsName->c_str();
     }
 }
 
-const SkString* GrGLShaderBuilder::VertexBuilder::getEffectAttributeName(int attributeIndex) const {
+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;
 }
 
-bool GrGLShaderBuilder::VertexBuilder::compileAndAttachShaders(GrGLuint programId) const {
-    SkString vertShaderSrc(GrGetGLSLVersionDecl(fParent->ctxInfo()));
-    fParent->appendUniformDecls(kVertex_Visibility, &vertShaderSrc);
-    fParent->appendDecls(fVSAttrs, &vertShaderSrc);
-    fParent->appendDecls(fVSOutputs, &vertShaderSrc);
+GrGLEffectArray* GrGLFullShaderBuilder::emitEffects(const GrEffectStage* effectStages[],
+                                                    const EffectKey effectKeys[],
+                                                    int effectCnt,
+                                                    SkString*  inOutFSColor,
+                                                    GrSLConstantVec* fsInOutColorKnownValue) {
+    GrGLVertexEffectArrayBuilder effectArrayBuilder(this, effectCnt);
+    this->INHERITED::emitEffects(&effectArrayBuilder,
+                                 effectStages,
+                                 effectKeys,
+                                 effectCnt,
+                                 inOutFSColor,
+                                 fsInOutColorKnownValue);
+    return effectArrayBuilder.finish();
+}
+
+bool GrGLFullShaderBuilder::compileAndAttachShaders(GrGLuint programId) const {
+    const GrGLInterface* glInterface = this->gpu()->glInterface();
+    SkString vertShaderSrc(GrGetGLSLVersionDecl(this->ctxInfo()));
+    this->appendUniformDecls(kVertex_Visibility, &vertShaderSrc);
+    this->appendDecls(fVSAttrs, &vertShaderSrc);
+    this->appendDecls(fVSOutputs, &vertShaderSrc);
     vertShaderSrc.append("void main() {\n");
     vertShaderSrc.append(fVSCode);
     vertShaderSrc.append("}\n");
-    if (!attach_shader(fGpu->glInterface(), programId, GR_GL_VERTEX_SHADER, vertShaderSrc)) {
+    if (!attach_shader(glInterface, programId, GR_GL_VERTEX_SHADER, vertShaderSrc)) {
         return false;
     }
 
 #if GR_GL_EXPERIMENTAL_GS
     if (fDesc.getHeader().fExperimentalGS) {
-        SkASSERT(fGpu->glslGeneration() >= k150_GrGLSLGeneration);
-        SkString geomShaderSrc(GrGetGLSLVersionDecl(fParent->ctxInfo()));
+        SkASSERT(this->ctxInfo().glslGeneration() >= k150_GrGLSLGeneration);
+        SkString geomShaderSrc(GrGetGLSLVersionDecl(this->ctxInfo()));
         geomShaderSrc.append("layout(triangles) in;\n"
                              "layout(triangle_strip, max_vertices = 6) out;\n");
-        fParent->appendDecls(fGSInputs, &geomShaderSrc);
-        fParent->appendDecls(fGSOutputs, &geomShaderSrc);
+        this->appendDecls(fGSInputs, &geomShaderSrc);
+        this->appendDecls(fGSOutputs, &geomShaderSrc);
         geomShaderSrc.append("void main() {\n");
         geomShaderSrc.append("\tfor (int i = 0; i < 3; ++i) {\n"
                              "\t\tgl_Position = gl_in[i].gl_Position;\n");
         if (fDesc.getHeader().fEmitsPointSize) {
             geomShaderSrc.append("\t\tgl_PointSize = 1.0;\n");
         }
         SkASSERT(fGSInputs.count() == fGSOutputs.count());
         for (int i = 0; i < fGSInputs.count(); ++i) {
             geomShaderSrc.appendf("\t\t%s = %s[i];\n",
                                   fGSOutputs[i].getName().c_str(),
                                   fGSInputs[i].getName().c_str());
         }
         geomShaderSrc.append("\t\tEmitVertex();\n"
                              "\t}\n"
                              "\tEndPrimitive();\n");
         geomShaderSrc.append("}\n");
-        if (!attach_shader(fGpu->glInterface(), programId, GR_GL_GEOMETRY_SHADER, geomShaderSrc)) {
+        if (!attach_shader(glInterface, programId, GR_GL_GEOMETRY_SHADER, geomShaderSrc)) {
             return false;
         }
     }
 #endif
 
-    return true;
+    return this->INHERITED::compileAndAttachShaders(programId);
 }
 
-void GrGLShaderBuilder::VertexBuilder::bindProgramLocations(GrGLuint programId) const {
+void GrGLFullShaderBuilder::bindProgramLocations(GrGLuint programId) const {
+    this->INHERITED::bindProgramLocations(programId);
+
     const GrGLProgramDesc::KeyHeader& header = fDesc.getHeader();
 
     // Bind the attrib locations to same values for all shaders
     SkASSERT(-1 != header.fPositionAttributeIndex);
     GL_CALL(BindAttribLocation(programId,
                                header.fPositionAttributeIndex,
                                fPositionVar->c_str()));
     if (-1 != header.fLocalCoordAttributeIndex) {
         GL_CALL(BindAttribLocation(programId,
                                    header.fLocalCoordAttributeIndex,
                                    fLocalCoordsVar->c_str()));
     }
     if (-1 != header.fColorAttributeIndex) {
         GL_CALL(BindAttribLocation(programId,
                                    header.fColorAttributeIndex,
                                    color_attribute_name()));
     }
     if (-1 != header.fCoverageAttributeIndex) {
         GL_CALL(BindAttribLocation(programId,
                                    header.fCoverageAttributeIndex,
                                    coverage_attribute_name()));
     }
 
     const AttributePair* attribEnd = fEffectAttributes.end();
     for (const AttributePair* attrib = fEffectAttributes.begin(); attrib != attribEnd; ++attrib) {
          GL_CALL(BindAttribLocation(programId, attrib->fIndex, attrib->fName.c_str()));
     }
 }