Create xfer processor backend.

src/gpu/GrProgramDesc.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 GrProgramDesc_DEFINED
 #define GrProgramDesc_DEFINED
 
@@ skipping 37 matching lines @@
 
     bool operator!= (const GrProgramDesc& other) const {
         return !(*this == other);
     }
 
     static bool Less(const GrProgramDesc& a, const GrProgramDesc& b) {
         return memcmp(a.asKey(), b.asKey(), a.keyLength() & ~0x3) < 0;
     }
 
 
-    ///////////////////////////////////////////////////////////////////////////
-    /// @name Stage Output Types
-    ////
-
-    enum PrimaryOutputType {
-        // Modulate color and coverage, write result as the color output.
-        kModulate_PrimaryOutputType,
-        // Combines the coverage, dst, and color as coverage * color + (1 - coverage) * dst. This
-        // can only be set if fDstReadKey is non-zero.
-        kCombineWithDst_PrimaryOutputType,
-
-        kPrimaryOutputTypeCnt,
-    };
-
-    enum SecondaryOutputType {
-        // There is no secondary output
-        kNone_SecondaryOutputType,
-        // Writes coverage as the secondary output. Only set if dual source blending is supported
-        // and primary output is kModulate.
-        kCoverage_SecondaryOutputType,
-        // Writes coverage * (1 - colorA) as the secondary output. Only set if dual source blending
-        // is supported and primary output is kModulate.
-        kCoverageISA_SecondaryOutputType,
-        // Writes coverage * (1 - colorRGBA) as the secondary output. Only set if dual source
-        // blending is supported and primary output is kModulate.
-        kCoverageISC_SecondaryOutputType,
-
-        kSecondaryOutputTypeCnt,
-    };
-
     // Specifies where the initial color comes from before the stages are applied.
     enum ColorInput {
         kAllOnes_ColorInput,
         kAttribute_ColorInput,
         kUniform_ColorInput,
 
         kColorInputCnt
     };
 
     struct KeyHeader {
         uint8_t                     fDstReadKey;   // set by GrGLShaderBuilder if there
                                                    // are effects that must read the dst.
                                                    // Otherwise, 0.
         uint8_t                     fFragPosKey;   // set by GrGLShaderBuilder if there are
                                                    // effects that read the fragment position.
                                                    // Otherwise, 0.
 
         ColorInput                  fColorInput : 8;
         ColorInput                  fCoverageInput : 8;
 
-        PrimaryOutputType           fPrimaryOutputType : 8;
-        SecondaryOutputType         fSecondaryOutputType : 8;
-
         SkBool8                     fHasGeometryProcessor;
         int8_t                      fColorEffectCnt;
         int8_t                      fCoverageEffectCnt;
     };
 
 
     bool hasGeometryProcessor() const {
         return SkToBool(this->header().fHasGeometryProcessor);
     }
 
@@ skipping 12 matching lines @@
 
     // A struct to communicate descriptor information to the program descriptor builder
     struct DescInfo {
         bool operator==(const DescInfo& that) const {
             return fHasVertexColor == that.fHasVertexColor &&
                    fHasVertexCoverage == that.fHasVertexCoverage &&
                    fInputColorIsUsed == that.fInputColorIsUsed &&
                    fInputCoverageIsUsed == that.fInputCoverageIsUsed &&
                    fReadsDst == that.fReadsDst &&
                    fReadsFragPosition == that.fReadsFragPosition &&
-                   fRequiresLocalCoordAttrib == that.fRequiresLocalCoordAttrib &&
-                   fPrimaryOutputType == that.fPrimaryOutputType &&
-                   fSecondaryOutputType == that.fSecondaryOutputType;
-
+                   fRequiresLocalCoordAttrib == that.fRequiresLocalCoordAttrib;
         }
         bool operator!=(const DescInfo& that) const { return !(*this == that); };
         // TODO when GPs control uniform / attribute handling of color / coverage, then we can
         // clean this up
         bool            fHasVertexColor;
         bool            fHasVertexCoverage;
 
         // These flags are needed to protect the code from creating an unused uniform color/coverage
         // which will cause shader compiler errors.
         bool            fInputColorIsUsed;
         bool            fInputCoverageIsUsed;
 
         // These flags give aggregated info on the processor stages that are used when building
         // programs.
         bool            fReadsDst;
         bool            fReadsFragPosition;
         bool            fRequiresLocalCoordAttrib;
 
-        // Fragment shader color outputs
-        GrProgramDesc::PrimaryOutputType  fPrimaryOutputType : 8;
-        GrProgramDesc::SecondaryOutputType  fSecondaryOutputType : 8;
     };
 
 private:
     template<typename T, size_t OFFSET> T* atOffset() {
         return reinterpret_cast<T*>(reinterpret_cast<intptr_t>(fKey.begin()) + OFFSET);
     }
 
     template<typename T, size_t OFFSET> const T* atOffset() const {
         return reinterpret_cast<const T*>(reinterpret_cast<intptr_t>(fKey.begin()) + OFFSET);
     }
@@ skipping 29 matching lines @@
         kPreAllocSize = kHeaderOffset + kHeaderSize +
                         kMaxPreallocProcessors * sizeof(uint32_t) * kIntsPerProcessor,
     };
 
     SkSTArray<kPreAllocSize, uint8_t, true> fKey;
 
     friend class GrGLProgramDescBuilder;
 };
 
 #endif