separate arrays for color and coverage effects.

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"
@@ skipping 20 matching lines @@
 #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"; }
 }
 
 GrGLProgram* GrGLProgram::Create(const GrGLContext& gl,
                                  const GrGLProgramDesc& desc,
-                                 const GrEffectStage* stages[]) {
-    GrGLProgram* program = SkNEW_ARGS(GrGLProgram, (gl, desc, stages));
+                                 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* stages[])
+                         const GrEffectStage* colorStages[],
+                         const GrEffectStage* coverageStages[])
 : fContext(gl)
 , fUniformManager(gl) {
     fDesc = desc;
     fVShaderID = 0;
     fGShaderID = 0;
     fFShaderID = 0;
     fProgramID = 0;
 
     fDstCopyTexUnit = -1;
 
     fColor = GrColor_ILLEGAL;
     fColorFilterColor = GrColor_ILLEGAL;
 
-    fEffectStates.reset(desc.numTotalEffects());
+    fColorEffects.reset(desc.numColorEffects());
+    fCoverageEffects.reset(desc.numCoverageEffects());
 
-    this->genProgram(stages);
+    this->genProgram(colorStages, coverageStages);
 }
 
 GrGLProgram::~GrGLProgram() {
     if (fVShaderID) {
         GL_CALL(DeleteShader(fVShaderID));
     }
     if (fGShaderID) {
         GL_CALL(DeleteShader(fGShaderID));
     }
     if (fFShaderID) {
@@ skipping 346 matching lines @@
         GrPrintf(shader.c_str());
         GrPrintf("\n");
     }
     if (!(fFShaderID = compile_shader(fContext, GR_GL_FRAGMENT_SHADER, shader))) {
         return false;
     }
 
     return true;
 }
 
-bool GrGLProgram::genProgram(const GrEffectStage* stages[]) {
+bool GrGLProgram::genProgram(const GrEffectStage* colorStages[],
+                             const GrEffectStage* coverageStages[]) {
     GrAssert(0 == fProgramID);
 
     const GrGLProgramDesc::KeyHeader& header = fDesc.getHeader();
 
     GrGLShaderBuilder builder(fContext.info(), fUniformManager, 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;
 
@@ skipping 38 matching lines @@
     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;
     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] = &fEffectStates[e].fSamplerUnis;
+            effectUniformArrays[e] = &fColorEffects[e].fSamplerUnis;
         }
 
-        builder.emitEffects(stages,
+        builder.emitEffects(colorStages,
                             fDesc.effectKeys(),
                             fDesc.numColorEffects(),
                             &inColor,
                             &knownColorValue,
                             effectUniformArrays.get(),
                             glEffects.get());
 
         for (int e = 0; e < fDesc.numColorEffects(); ++e) {
-            fEffectStates[e].fGLEffect = glEffects[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);
 
@@ skipping 11 matching lines @@
                          colorCoeff, colorFilterColorUniName, color);
         inColor = "filteredColor";
     }
 
     ///////////////////////////////////////////////////////////////////////////
     // compute the partial coverage
     SkString inCoverage;
     GrSLConstantVec knownCoverageValue = this->genInputCoverage(&builder, &inCoverage);
 
     for (int e = 0; e < fDesc.numCoverageEffects(); ++e) {
-        effectUniformArrays[e] = &fEffectStates[e + fDesc.numColorEffects()].fSamplerUnis;
+        effectUniformArrays[e] = &fCoverageEffects[e].fSamplerUnis;
     }
 
-    builder.emitEffects(stages + fDesc.numColorEffects(),
+    builder.emitEffects(coverageStages,
                         fDesc.getEffectKeys() + fDesc.numColorEffects(),
                         fDesc.numCoverageEffects(),
                         &inCoverage,
                         &knownCoverageValue,
                         effectUniformArrays.get(),
                         glEffects.get());
     for (int e = 0; e < fDesc.numCoverageEffects(); ++e) {
-        fEffectStates[e + fDesc.numColorEffects()].fGLEffect = glEffects[e];
+        fCoverageEffects[e].fGLEffect = glEffects[e];
     }
 
     // discard if coverage is zero
     if (header.fDiscardIfZeroCoverage && kOnes_GrSLConstantVec != knownCoverageValue) {
         if (kZeros_GrSLConstantVec == knownCoverageValue) {
             // This is unfortunate.
             builder.fsCodeAppend("\tdiscard;\n");
         } else {
             builder.fsCodeAppendf("\tif (all(lessThanEqual(%s, vec4(0.0)))) {\n\t\tdiscard;\n\t}\n",
                                   inCoverage.c_str());
@@ skipping 186 matching lines @@
     return true;
 }
 
 void GrGLProgram::initSamplerUniforms() {
     GL_CALL(UseProgram(fProgramID));
     GrGLint texUnitIdx = 0;
     if (GrGLUniformManager::kInvalidUniformHandle != fUniformHandles.fDstCopySamplerUni) {
         fUniformManager.setSampler(fUniformHandles.fDstCopySamplerUni, texUnitIdx);
         fDstCopyTexUnit = texUnitIdx++;
     }
 

[robertphillips, 2013/06/06 19:38:15]

sub-routine for these two?

[bsalomon, 2013/06/06 20:07:40]

yeah, will do

-    for (int e = 0; e < fEffectStates.count(); ++e) {
-        int numSamplers = fEffectStates[e].fSamplerUnis.count();
-        fEffectStates[e].fTextureUnits.reset(numSamplers);
+    for (int e = 0; e < fColorEffects.count(); ++e) {
+        int numSamplers = fColorEffects[e].fSamplerUnis.count();
+        fColorEffects[e].fTextureUnits.reset(numSamplers);
         for (int s = 0; s < numSamplers; ++s) {
-            UniformHandle handle = fEffectStates[e].fSamplerUnis[s];
+            UniformHandle handle = fColorEffects[e].fSamplerUnis[s];
             if (GrGLUniformManager::kInvalidUniformHandle != handle) {
                 fUniformManager.setSampler(handle, texUnitIdx);
-                fEffectStates[e].fTextureUnits[s] = texUnitIdx++;
+                fColorEffects[e].fTextureUnits[s] = texUnitIdx++;
             }
         }
     }
+
+    for (int e = 0; e < fCoverageEffects.count(); ++e) {
+        int numSamplers = fCoverageEffects[e].fSamplerUnis.count();
+        fCoverageEffects[e].fTextureUnits.reset(numSamplers);
+        for (int s = 0; s < numSamplers; ++s) {
+            UniformHandle handle = fCoverageEffects[e].fSamplerUnis[s];
+            if (GrGLUniformManager::kInvalidUniformHandle != handle) {
+                fUniformManager.setSampler(handle, texUnitIdx);
+                fCoverageEffects[e].fTextureUnits[s] = texUnitIdx++;
+            }
+        }
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+void GrGLProgram::setEffectData(GrGpuGL* gpu,
+                                const GrEffectStage& stage,
+                                const EffectAndSamplers& effect) {
+
+    // Let the GrGLEffect set its data.

[bsalomon, 2013/06/06 19:13:02]

This is the removed block below, split out into its own function so that it can
be called from two loops.

+    bool explicitLocalCoords = -1 != fDesc.getHeader().fLocalCoordAttributeIndex;
+    GrDrawEffect drawEffect(stage, explicitLocalCoords);
+    effect.fGLEffect->setData(fUniformManager, 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) {
+            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,
-                          const GrEffectStage* stages[],
+                          const GrEffectStage* colorStages[],
+                          const GrEffectStage* coverageStages[],
                           const GrDeviceCoordTexture* dstCopy,
                           SharedGLState* sharedState) {
     const GrDrawState& drawState = gpu->getDrawState();
 
     GrColor color;
     GrColor coverage;
     if (blendOpts & GrDrawState::kEmitTransBlack_BlendOptFlag) {
         color = 0;
         coverage = 0;
     } else if (blendOpts & GrDrawState::kEmitCoverage_BlendOptFlag) {
@@ skipping 36 matching lines @@
                     fUniformHandles.fDstCopyScaleUni);
             GrAssert(GrGLUniformManager::kInvalidUniformHandle ==
                     fUniformHandles.fDstCopySamplerUni);
         }
     } else {
         GrAssert(GrGLUniformManager::kInvalidUniformHandle == fUniformHandles.fDstCopyTopLeftUni);
         GrAssert(GrGLUniformManager::kInvalidUniformHandle == fUniformHandles.fDstCopyScaleUni);
         GrAssert(GrGLUniformManager::kInvalidUniformHandle == fUniformHandles.fDstCopySamplerUni);
     }
 
-    int numEffects = fDesc.numTotalEffects();
-    for (int e = 0; e < numEffects; ++e) {
-        GrAssert(NULL != stages[e]);
+    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 != fEffectStates[e].fGLEffect) {
-            bool explicitLocalCoords = -1 != fDesc.getHeader().fLocalCoordAttributeIndex;
-            GrDrawEffect drawEffect(*stages[e], explicitLocalCoords);
-            fEffectStates[e].fGLEffect->setData(fUniformManager, drawEffect);
-            int numSamplers = fEffectStates[e].fSamplerUnis.count();
-            GrAssert((*stages[e]->getEffect())->numTextures() == numSamplers);
-            for (int s = 0; s < numSamplers; ++s) {
-                UniformHandle handle = fEffectStates[e].fSamplerUnis[s];
-                if (GrGLUniformManager::kInvalidUniformHandle != handle) {
-                    const GrTextureAccess& access = (*stages[e]->getEffect())->textureAccess(s);
-                    GrGLTexture* texture = static_cast<GrGLTexture*>(access.getTexture());
-                    int unit = fEffectStates[e].fTextureUnits[s];
-                    gpu->bindTexture(unit, access.getParams(), texture);
-                }
-            }
+        if (NULL != fColorEffects[e].fGLEffect) {
+            this->setEffectData(gpu, *colorStages[e], fColorEffects[e]);
+        }
+    }
+
+    for (int e = 0; e < fCoverageEffects.count(); ++e) {
+        if (NULL != fCoverageEffects[e].fGLEffect) {
+            this->setEffectData(gpu, *coverageStages[e], fCoverageEffects[e]);
         }
     }
 }
 
 void GrGLProgram::setColor(const GrDrawState& drawState,
                            GrColor color,
                            SharedGLState* sharedState) {
     const GrGLProgramDesc::KeyHeader& header = fDesc.getHeader();
     if (!drawState.hasColorVertexAttribute()) {
         switch (header.fColorInput) {
@@ skipping 113 matching lines @@
             SkScalarToFloat(m[SkMatrix::kMTransX]),
             SkScalarToFloat(m[SkMatrix::kMTransY]),
             SkScalarToFloat(m[SkMatrix::kMPersp2])
         };
         fUniformManager.setMatrix3f(fUniformHandles.fViewMatrixUni, mt);
         fMatrixState.fViewMatrix = drawState.getViewMatrix();
         fMatrixState.fRenderTargetSize = size;
         fMatrixState.fRenderTargetOrigin = rt->origin();
     }
 }