Create xfer processor backend.

src/gpu/gl/builders/GrGLProgramBuilder.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLProgramBuilder_DEFINED
 #define GrGLProgramBuilder_DEFINED
 
 #include "GrGLFragmentShaderBuilder.h"
 #include "GrGLGeometryShaderBuilder.h"
 #include "GrGLVertexShaderBuilder.h"
 #include "../GrGLProgramDataManager.h"
 #include "../GrGLUniformHandle.h"
 #include "../GrGLGeometryProcessor.h"
+#include "../GrGLXferProcessor.h"
 #include "../../GrOptDrawState.h"
 #include "../../GrPendingFragmentStage.h"
 
 /*
  * This is the base class for a series of interfaces.  This base class *MUST* remain abstract with
  * NO data members because it is used in multiple interface inheritance.
  * Heirarchy:
  *                      GrGLUniformBuilder
  *                     /                  \
  *                GrGLFPBuilder       GrGLGPBuilder
@@ skipping 77 matching lines @@
 
 private:
     GrSLType fType;
     const char* fVsOut;
     const char* fGsIn;
     const char* fGsOut;
     const char* fFsIn;
 
     friend class GrGLVertexBuilder;
     friend class GrGLGeometryBuilder;
+    friend class GrGLXferBuilder;
     friend class GrGLFragmentShaderBuilder;
 };
 
 struct GrGLVertToFrag : public GrGLVarying {
     GrGLVertToFrag(GrSLType type)
         : GrGLVarying(type, kVertToFrag_Varying) {}
 };
 
 struct GrGLVertToGeo : public GrGLVarying {
     GrGLVertToGeo(GrSLType type)
@@ skipping 39 matching lines @@
 /* a specializations for FPs. Lets the user add uniforms and FS code */
 class GrGLFPBuilder : public virtual GrGLUniformBuilder {
 public:
     virtual GrGLFPFragmentBuilder* getFragmentShaderBuilder() = 0;
 
     /*
      * *NOTE* NO MEMBERS ALLOWED, MULTIPLE INHERITANCE
      */
 };
 
+/* a specializations for XPs. Lets the user add uniforms and FS code */
+class GrGLXPBuilder : public virtual GrGLUniformBuilder {
+public:
+    virtual GrGLFPFragmentBuilder* getFragmentShaderBuilder() = 0;
+
+    /*
+     * *NOTE* NO MEMBERS ALLOWED, MULTIPLE INHERITANCE
+     */
+};
 struct GrGLInstalledProc;
 struct GrGLInstalledGeoProc;
+struct GrGLInstalledXferProc;
 struct GrGLInstalledFragProc;
 struct GrGLInstalledFragProcs;
 
 /*
  * Please note - no diamond problems because of virtual inheritance.  Also, both base classes
  * are pure virtual with no data members.  This is the base class for program building.
  * Subclasses are nearly identical but each has their own way of emitting transforms.  State for
  * each of the elements of the shader pipeline, ie vertex, fragment, geometry, etc, lives in those
  * respective builders
 */
 class GrGLProgramBuilder : public GrGLGPBuilder,
-                           public GrGLFPBuilder {
+                           public GrGLFPBuilder,
+                           public GrGLXPBuilder {
 public:
     /** Generates a shader program.
      *
      * The program implements what is specified in the stages given as input.
      * After successful generation, the builder result objects are available
      * to be used.
      * @return true if generation was successful.
      */
     static GrGLProgram* CreateProgram(const GrOptDrawState&, GrGpuGL*);
 
@@ skipping 79 matching lines @@
                             GrGLSLExpr4* outputColor,
                             GrGLSLExpr4* outputCoverage);
 
     // these emit functions help to keep the createAndEmitProcessors template general
     void emitAndInstallProc(const GrPendingFragmentStage&,
                             const char* outColor,
                             const char* inColor);
     void emitAndInstallProc(const GrGeometryProcessor&,
                             const char* outColor,
                             const char* outCoverage);
+    void emitAndInstallXferProc(const GrXferProcessor&,
+                                const GrGLSLExpr4& colorIn,
+                                const GrGLSLExpr4& coverageIn);
 
     void verify(const GrGeometryProcessor&);
+    void verify(const GrXferProcessor&);
     void verify(const GrFragmentProcessor&);
     void emitSamplers(const GrProcessor&,
                       GrGLProcessor::TextureSamplerArray* outSamplers,
                       GrGLInstalledProc*);
 
     // each specific program builder has a distinct transform and must override this function
     virtual void emitTransforms(const GrPendingFragmentStage&,
                                 GrGLProcessor::TransformedCoordsArray* outCoords,
                                 GrGLInstalledFragProc*);
     GrGLProgram* finalize();
@@ skipping 53 matching lines @@
     static const int kVarsPerBlock;
 
     BuiltinUniformHandles fUniformHandles;
     GrGLVertexBuilder fVS;
     GrGLGeometryBuilder fGS;
     GrGLFragmentShaderBuilder fFS;
     bool fOutOfStage;
     int fStageIndex;
 
     GrGLInstalledGeoProc* fGeometryProcessor;
+    GrGLInstalledXferProc* fXferProcessor;
     SkAutoTUnref<GrGLInstalledFragProcs> fFragmentProcessors;
 
     const GrOptDrawState& fOptState;
     const GrProgramDesc& fDesc;
     GrGpuGL* fGpu;
     UniformInfoArray fUniforms;
     SkSTArray<16, TransformVarying, true> fCoordVaryings;
 
     friend class GrGLShaderBuilder;
     friend class GrGLVertexBuilder;
@@ skipping 13 matching lines @@
          UniformHandle  fUniform;
          int            fTextureUnit;
      };
      SkSTArray<4, Sampler, true> fSamplers;
 };
 
 struct GrGLInstalledGeoProc : public GrGLInstalledProc {
     SkAutoTDelete<GrGLGeometryProcessor> fGLProc;
 };
 
+struct GrGLInstalledXferProc : public GrGLInstalledProc {
+    SkAutoTDelete<GrGLXferProcessor> fGLProc;
+};
+
 struct GrGLInstalledFragProc : public GrGLInstalledProc {
     GrGLInstalledFragProc() : fGLProc(NULL) {}
     class ShaderVarHandle {
     public:
         bool isValid() const { return fHandle > -1; }
         ShaderVarHandle() : fHandle(-1) {}
         ShaderVarHandle(int value) : fHandle(value) { SkASSERT(this->isValid()); }
         int handle() const { SkASSERT(this->isValid()); return fHandle; }
         UniformHandle convertToUniformHandle() {
             SkASSERT(this->isValid());
@@ skipping 14 matching lines @@
     SkAutoTDelete<GrGLFragmentProcessor> fGLProc;
     SkSTArray<2, Transform, true>        fTransforms;
 };
 
 struct GrGLInstalledFragProcs : public SkRefCnt {
     virtual ~GrGLInstalledFragProcs();
     SkSTArray<8, GrGLInstalledFragProc*, true> fProcs;
 };
 
 #endif