Create xfer processor backend.

src/gpu/gl/builders/GrGLProgramBuilder.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLProgramBuilder.h"
 #include "gl/GrGLProgram.h"
 #include "gl/GrGLSLPrettyPrint.h"
 #include "gl/GrGLUniformHandle.h"
+#include "../GrGLXferProcessor.h"
 #include "../GrGpuGL.h"
 #include "GrCoordTransform.h"
 #include "GrGLLegacyNvprProgramBuilder.h"
 #include "GrGLNvprProgramBuilder.h"
 #include "GrGLProgramBuilder.h"
 #include "GrTexture.h"
 #include "SkRTConf.h"
 #include "SkTraceEvent.h"
 
 #define GL_CALL(X) GR_GL_CALL(this->gpu()->glInterface(), X)
@@ skipping 26 matching lines @@
 
     // TODO: Once all stages can handle taking a float or vec4 and correctly handling them we can
     // remove this cast to a vec4.
     GrGLSLExpr4 inputCoverageVec4;
     if (inputCoverage.isValid()) {
         inputCoverageVec4 = GrGLSLExpr4::VectorCast(inputCoverage);
     }
 
     pb->emitAndInstallProcs(&inputColor, &inputCoverageVec4);
 
-    // write the secondary color output if necessary
-    if (GrProgramDesc::kNone_SecondaryOutputType != header.fSecondaryOutputType) {
-        pb->fFS.enableSecondaryOutput(inputColor, inputCoverageVec4);
-    }
-
-    pb->fFS.combineColorAndCoverage(inputColor, inputCoverageVec4);
-
     return pb->finalize();
 }
 
-GrGLProgramBuilder*
-GrGLProgramBuilder::CreateProgramBuilder(const GrOptDrawState& optState,
-                                         bool hasGeometryProcessor,
-                                         GrGpuGL* gpu) {
+GrGLProgramBuilder* GrGLProgramBuilder::CreateProgramBuilder(const GrOptDrawState& optState,
+                                                             bool hasGeometryProcessor,
+                                                             GrGpuGL* gpu) {
     const GrProgramDesc& desc = optState.programDesc();
     if (GrGLProgramDescBuilder::GetHeader(desc).fUseNvpr) {
         SkASSERT(gpu->glCaps().pathRenderingSupport());
         SkASSERT(GrProgramDesc::kAttribute_ColorInput != desc.header().fColorInput);
         SkASSERT(GrProgramDesc::kAttribute_ColorInput != desc.header().fCoverageInput);
         SkASSERT(!hasGeometryProcessor);
         if (gpu->glPathRendering()->texturingMode() ==
             GrGLPathRendering::FixedFunction_TexturingMode) {
             return SkNEW_ARGS(GrGLLegacyNvprProgramBuilder, (gpu, optState));
         } else {
             return SkNEW_ARGS(GrGLNvprProgramBuilder, (gpu, optState));
         }
     } else {
         return SkNEW_ARGS(GrGLProgramBuilder, (gpu, optState));
     }
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 GrGLProgramBuilder::GrGLProgramBuilder(GrGpuGL* gpu, const GrOptDrawState& optState)
     : fVS(this)
     , fGS(this)
     , fFS(this, optState.programDesc().header().fFragPosKey)
     , fOutOfStage(true)
     , fStageIndex(-1)
     , fGeometryProcessor(NULL)
+    , fXferProcessor(NULL)
     , fOptState(optState)
     , fDesc(optState.programDesc())
     , fGpu(gpu)
     , fUniforms(kVarsPerBlock) {
 }
 
 void GrGLProgramBuilder::addVarying(const char* name,
                                     GrGLVarying* varying,
                                     GrGLShaderVar::Precision fsPrecision) {
     SkASSERT(varying);
@@ skipping 147 matching lines @@
     }
 
     fFragmentProcessors.reset(SkNEW(GrGLInstalledFragProcs));
     int numProcs = fOptState.numFragmentStages();
     this->emitAndInstallFragProcs(0, fOptState.numColorStages(), inputColor);
     this->emitAndInstallFragProcs(fOptState.numColorStages(), numProcs,  inputCoverage);
 
     if (fOptState.hasGeometryProcessor()) {
         fVS.transformToNormalizedDeviceSpace();
     }
+
+    this->emitAndInstallXferProc(*fOptState.getXferProcessor(), *inputColor, *inputCoverage);
 }
 
 void GrGLProgramBuilder::emitAndInstallFragProcs(int procOffset,
                                                  int numProcs,
                                                  GrGLSLExpr4* inOut) {
     for (int e = procOffset; e < numProcs; ++e) {
         GrGLSLExpr4 output;
         const GrPendingFragmentStage& stage = fOptState.getFragmentStage(e);
         this->emitAndInstallProc(stage, e, *inOut, &output);
         *inOut = output;
@@ skipping 88 matching lines @@
     this->emitSamplers(gp, &samplers, fGeometryProcessor);
 
     GrGLGeometryProcessor::EmitArgs args(this, gp, bt, outColor, outCoverage, samplers);
     fGeometryProcessor->fGLProc->emitCode(args);
 
     // We have to check that effects and the code they emit are consistent, ie if an effect
     // asks for dst color, then the emit code needs to follow suit
     verify(gp);
 }
 
+void GrGLProgramBuilder::emitAndInstallXferProc(const GrXferProcessor& xp,
+                                                const GrGLSLExpr4& colorIn,
+                                                const GrGLSLExpr4& coverageIn) {
+    // Program builders have a bit of state we need to clear with each effect
+    AutoStageAdvance adv(this);
+
+    SkASSERT(!fXferProcessor);
+    fXferProcessor = SkNEW(GrGLInstalledXferProc);
+
+    fXferProcessor->fGLProc.reset(xp.createGLInstance());
+
+    // Enable dual source secondary output if we have one
+    if (xp.hasSecondaryOutput()) {
+        fFS.enableSecondaryOutput();
+    }
+
+    // On any post 1.10 GLSL supporting GPU, we declare custom output
+    if (k110_GrGLSLGeneration != fFS.fProgramBuilder->gpu()->glslGeneration()) {
+        fFS.enableCustomOutput();
+    }
+
+    SkString openBrace;
+    openBrace.printf("{ // Xfer Processor: %s\n", xp.name());
+    fFS.codeAppend(openBrace.c_str());
+
+    SkSTArray<4, GrGLProcessor::TextureSampler> samplers(xp.numTextures());
+    this->emitSamplers(xp, &samplers, fXferProcessor);
+
+    GrGLXferProcessor::EmitArgs args(this, xp, colorIn.c_str(), coverageIn.c_str(),
+                                     fFS.getPrimaryColorOutputName(),
+                                     fFS.getSecondaryColorOutputName(), samplers);
+    fXferProcessor->fGLProc->emitCode(args);
+
+    // We have to check that effects and the code they emit are consistent, ie if an effect
+    // asks for dst color, then the emit code needs to follow suit
+    verify(xp);
+    fFS.codeAppend("}");
+}
+
 void GrGLProgramBuilder::verify(const GrGeometryProcessor& gp) {
     SkASSERT(fFS.hasReadFragmentPosition() == gp.willReadFragmentPosition());
 }
 
+void GrGLProgramBuilder::verify(const GrXferProcessor& xp) {
+    // TODO: Once will readDst is only xp enable this assert and remove it from the
+    // FragmentProcessor verify()
+    //SkASSERT(fFS.hasReadDstColor() == xp.willReadDstColor());
+}
+
 void GrGLProgramBuilder::verify(const GrFragmentProcessor& fp) {
     SkASSERT(fFS.hasReadFragmentPosition() == fp.willReadFragmentPosition());
     SkASSERT(fFS.hasReadDstColor() == fp.willReadDstColor());
 }
 
 void GrGLProgramBuilder::emitTransforms(const GrPendingFragmentStage& stage,
                                         GrGLProcessor::TransformedCoordsArray* outCoords,
                                         GrGLInstalledFragProc* ifp) {
     const GrFragmentProcessor* processor = stage.getProcessor();
     int numTransforms = processor->numTransforms();
@@ skipping 148 matching lines @@
     cleanupShaders(shaderIDs);
 }
 void GrGLProgramBuilder::cleanupShaders(const SkTDArray<GrGLuint>& shaderIDs) {
     for (int i = 0; i < shaderIDs.count(); ++i) {
       GL_CALL(DeleteShader(shaderIDs[i]));
     }
 }
 
 GrGLProgram* GrGLProgramBuilder::createProgram(GrGLuint programID) {
     return SkNEW_ARGS(GrGLProgram, (fGpu, fDesc, fUniformHandles, programID, fUniforms,
-                                    fGeometryProcessor, fFragmentProcessors.get()));
+                                    fGeometryProcessor, fXferProcessor, fFragmentProcessors.get()));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLInstalledFragProcs::~GrGLInstalledFragProcs() {
     int numProcs = fProcs.count();
     for (int e = 0; e < numProcs; ++e) {
         SkDELETE(fProcs[e]);
     }
 }