Repurpose GrGLCoordTransform as GrGLEffectArray

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 30 matching lines @@
 : fGpu(gpu)
 , fUniformManager(gpu) {
     fDesc = desc;
     fProgramID = 0;
 
     fDstCopyTexUnit = -1;
 
     fColor = GrColor_ILLEGAL;
     fColorFilterColor = GrColor_ILLEGAL;
 
-    fColorEffects.reset(desc.numColorEffects());
-    fCoverageEffects.reset(desc.numCoverageEffects());
-
     this->genProgram(colorStages, coverageStages);
 }
 
 GrGLProgram::~GrGLProgram() {
     if (fProgramID) {
         GL_CALL(DeleteProgram(fProgramID));
     }
 }
 
 void GrGLProgram::abandon() {
@@ skipping 164 matching lines @@
     // Get the coeffs for the Mode-based color filter, determine if color is needed.
     SkXfermode::Coeff colorCoeff;
     SkXfermode::Coeff filterColorCoeff;
     SkAssertResult(
         SkXfermode::ModeAsCoeff(header.fColorFilterXfermode,
                                 &filterColorCoeff,
                                 &colorCoeff));
     bool needColor, needFilterColor;
     need_blend_inputs(filterColorCoeff, colorCoeff, &needFilterColor, &needColor);
 
-    // used in order for builder to return the per-stage uniform handles.
-    typedef SkTArray<GrGLCoordTransform, false>* CoordTransformArrayPtr;
-    typedef SkTArray<GrGLUniformManager::UniformHandle, true>* UniHandleArrayPtr;
-    int maxColorOrCovEffectCnt = GrMax(fDesc.numColorEffects(), fDesc.numCoverageEffects());
-    SkAutoTArray<CoordTransformArrayPtr> effectCoordTransformArrays(maxColorOrCovEffectCnt);
-    SkAutoTArray<UniHandleArrayPtr> effectUniformArrays(maxColorOrCovEffectCnt);
-    SkAutoTArray<GrGLEffect*> glEffects(maxColorOrCovEffectCnt);
-
-    if (needColor) {
-        for (int e = 0; e < fDesc.numColorEffects(); ++e) {
-            effectCoordTransformArrays[e] = &fColorEffects[e].fCoordTransforms;
-            effectUniformArrays[e] = &fColorEffects[e].fSamplerUnis;
-        }
-
-        builder.emitEffects(colorStages,
-                            fDesc.effectKeys(),
-                            fDesc.numColorEffects(),
-                            &inColor,
-                            &knownColorValue,
-                            effectCoordTransformArrays.get(),
-                            effectUniformArrays.get(),
-                            glEffects.get());
-
-        for (int e = 0; e < fDesc.numColorEffects(); ++e) {
-            fColorEffects[e].fGLEffect = glEffects[e];
-        }
-    }
+    fColorEffects.reset(builder.emitEffects(colorStages,

[bsalomon, 2013/10/02 20:17:06]

this is nice

+                                            fDesc.effectKeys(),
+                                            needColor ? fDesc.numColorEffects() : 0,
+                                            &inColor,
+                                            &knownColorValue));
 
     // 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_Visibility,
                                                              kVec4f_GrSLType, "FilterColor",
                                                              &colorFilterColorUniName);
 
         builder.fsCodeAppend("\tvec4 filteredColor;\n");
         const char* color;
         // add_color_filter requires a real input string.
         if (knownColorValue == kOnes_GrSLConstantVec) {
             color = GrGLSLOnesVecf(4);
         } else if (knownColorValue == kZeros_GrSLConstantVec) {
             color = GrGLSLZerosVecf(4);
         } else {
             color = inColor.c_str();
         }
         add_color_filter(&builder, "filteredColor", filterColorCoeff,
                          colorCoeff, colorFilterColorUniName, color);
         inColor = "filteredColor";
     }
 
     ///////////////////////////////////////////////////////////////////////////
     // compute the partial coverage
     SkString inCoverage = builder.getInputCoverage();
     GrSLConstantVec knownCoverageValue = builder.getKnownCoverageValue();
 
-    for (int e = 0; e < fDesc.numCoverageEffects(); ++e) {
-        effectCoordTransformArrays[e] = &fCoverageEffects[e].fCoordTransforms;
-        effectUniformArrays[e] = &fCoverageEffects[e].fSamplerUnis;
-    }
-
-    builder.emitEffects(coverageStages,
-                        fDesc.getEffectKeys() + fDesc.numColorEffects(),
-                        fDesc.numCoverageEffects(),
-                        &inCoverage,
-                        &knownCoverageValue,
-                        effectCoordTransformArrays.get(),
-                        effectUniformArrays.get(),
-                        glEffects.get());
-    for (int e = 0; e < fDesc.numCoverageEffects(); ++e) {
-        fCoverageEffects[e].fGLEffect = glEffects[e];
-    }
+    fCoverageEffects.reset(builder.emitEffects(coverageStages,
+                                               fDesc.getEffectKeys() + fDesc.numColorEffects(),
+                                               fDesc.numCoverageEffects(),
+                                               &inCoverage,
+                                               &knownCoverageValue));
 
     // 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 95 matching lines @@
     return true;
 }
 
 void GrGLProgram::initSamplerUniforms() {
     GL_CALL(UseProgram(fProgramID));
     GrGLint texUnitIdx = 0;
     if (fUniformHandles.fDstCopySamplerUni.isValid()) {
         fUniformManager.setSampler(fUniformHandles.fDstCopySamplerUni, texUnitIdx);
         fDstCopyTexUnit = texUnitIdx++;
     }
-
-    for (int e = 0; e < fColorEffects.count(); ++e) {
-        this->initEffectSamplerUniforms(&fColorEffects[e], &texUnitIdx);
-    }
-
-    for (int e = 0; e < fCoverageEffects.count(); ++e) {
-        this->initEffectSamplerUniforms(&fCoverageEffects[e], &texUnitIdx);
-    }
-}
-
-void GrGLProgram::initEffectSamplerUniforms(EffectAndSamplers* effect, int* texUnitIdx) {
-    int numSamplers = effect->fSamplerUnis.count();
-    effect->fTextureUnits.reset(numSamplers);
-    for (int s = 0; s < numSamplers; ++s) {
-        UniformHandle handle = effect->fSamplerUnis[s];
-        if (handle.isValid()) {
-            fUniformManager.setSampler(handle, *texUnitIdx);
-            effect->fTextureUnits[s] = (*texUnitIdx)++;
-        }
-    }
+    fColorEffects->initSamplers(fUniformManager, &texUnitIdx);
+    fCoverageEffects->initSamplers(fUniformManager, &texUnitIdx);

[Chris Dalton, 2013/10/02 19:57:32]

I considered making these null when empty, instead of 0-length arrays, but in
the end decided to stick with this approach.

 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void GrGLProgram::setEffectData(const GrEffectStage& stage,
-                                EffectAndSamplers& effect) {
-
-    // Let the GrGLEffect set its data.
-    bool explicitLocalCoords = -1 != fDesc.getHeader().fLocalCoordAttributeIndex;
-    GrDrawEffect drawEffect(stage, explicitLocalCoords);
-    effect.fGLEffect->setData(fUniformManager, drawEffect);
-
-    // Set the effect's coord transform matrices.
-    int numTransforms = effect.fCoordTransforms.count();
-    SkASSERT((*stage.getEffect())->numTransforms() == numTransforms);
-    for (int c = 0; c < numTransforms; ++c) {
-        effect.fCoordTransforms[c].setData(fUniformManager, drawEffect, c);
-    }
-
-    // Bind the texures for the effect.
-    int numSamplers = effect.fSamplerUnis.count();
-    SkASSERT((*stage.getEffect())->numTextures() == numSamplers);
-    for (int s = 0; s < numSamplers; ++s) {
-        UniformHandle handle = effect.fSamplerUnis[s];
-        if (handle.isValid()) {
-            const GrTextureAccess& access = (*stage.getEffect())->textureAccess(s);
-            GrGLTexture* texture = static_cast<GrGLTexture*>(access.getTexture());
-            int unit = effect.fTextureUnits[s];
-            fGpu->bindTexture(unit, access.getParams(), texture);
-        }
-    }
-}
-
 void GrGLProgram::setData(GrDrawState::BlendOptFlags blendOpts,
                           const GrEffectStage* colorStages[],
                           const GrEffectStage* coverageStages[],
                           const GrDeviceCoordTexture* dstCopy,
                           SharedGLState* sharedState) {
     const GrDrawState& drawState = fGpu->getDrawState();
 
     GrColor color;
     GrColor coverage;
     if (blendOpts & GrDrawState::kEmitTransBlack_BlendOptFlag) {
@@ skipping 34 matching lines @@
         } else {
             SkASSERT(!fUniformHandles.fDstCopyScaleUni.isValid());
             SkASSERT(!fUniformHandles.fDstCopySamplerUni.isValid());
         }
     } else {
         SkASSERT(!fUniformHandles.fDstCopyTopLeftUni.isValid());
         SkASSERT(!fUniformHandles.fDstCopyScaleUni.isValid());
         SkASSERT(!fUniformHandles.fDstCopySamplerUni.isValid());
     }
 
-    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 != fColorEffects[e].fGLEffect) {
-            this->setEffectData(*colorStages[e], fColorEffects[e]);
-        }
-    }
-
-    for (int e = 0; e < fCoverageEffects.count(); ++e) {
-        if (NULL != fCoverageEffects[e].fGLEffect) {
-            this->setEffectData(*coverageStages[e], fCoverageEffects[e]);
-        }
-    }
+    fColorEffects->setData(fGpu, fUniformManager, colorStages);
+    fCoverageEffects->setData(fGpu, fUniformManager, coverageStages);
 }
 
 void GrGLProgram::setColor(const GrDrawState& drawState,
                            GrColor color,
                            SharedGLState* sharedState) {
     const GrGLProgramDesc::KeyHeader& header = fDesc.getHeader();
     if (!drawState.hasColorVertexAttribute()) {
         switch (header.fColorInput) {
             case GrGLProgramDesc::kAttribute_ColorInput:
                 SkASSERT(-1 != header.fColorAttributeIndex);
@@ skipping 85 matching lines @@
 
         fMatrixState.fViewMatrix = drawState.getViewMatrix();
         fMatrixState.fRenderTargetSize = size;
         fMatrixState.fRenderTargetOrigin = rt->origin();
 
         GrGLfloat viewMatrix[3 * 3];
         fMatrixState.getGLMatrix<3>(viewMatrix);
         fUniformManager.setMatrix3f(fUniformHandles.fViewMatrixUni, viewMatrix);
     }
 }