Implement support for KHR_blend_equation_advanced

include/gpu/GrXferProcessor.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 GrXferProcessor_DEFINED
 #define GrXferProcessor_DEFINED
 
 #include "GrColor.h"
 #include "GrProcessor.h"
 #include "GrTexture.h"
 #include "GrTypes.h"
 #include "SkXfermode.h"
 
 class GrDrawTargetCaps;
 class GrGLCaps;
 class GrGLXferProcessor;
 class GrProcOptInfo;
 
 /**
+ * Equations for alpha-blending.
+ */
+enum GrBlendEquation {
+    kInvalid_GrBlendEquation = -1,
+
+    // Basic blend equations.
+    kAdd_GrBlendEquation,             //<! Cs*S + Cd*D
+    kSubtract_GrBlendEquation,        //<! Cs*S - Cd*D
+    kReverseSubtract_GrBlendEquation, //<! Cd*D - Cs*S
+
+    kLastBasicGrBlendEquation = kReverseSubtract_GrBlendEquation,
+
+    // Advanced blend equations. These are described in the SVG and PDF specs.
+    kScreen_GrBlendEquation,
+    kOverlay_GrBlendEquation,
+    kDarken_GrBlendEquation,
+    kLighten_GrBlendEquation,
+    kColorDodge_GrBlendEquation,
+    kColorBurn_GrBlendEquation,
+    kHardLight_GrBlendEquation,
+    kSoftLight_GrBlendEquation,
+    kDifference_GrBlendEquation,
+    kExclusion_GrBlendEquation,
+    kMultiply_GrBlendEquation,
+    kHSLHue_GrBlendEquation,
+    kHSLSaturation_GrBlendEquation,
+    kHSLColor_GrBlendEquation,
+    kHSLLuminosity_GrBlendEquation,
+
+    kTotalGrBlendEquationCount
+};
+
+bool constexpr GrBlendEquationIsAdvanced(GrBlendEquation equation) {
+    return equation > kLastBasicGrBlendEquation;
+}
+
+/**
  * Coeffecients for alpha-blending.
  */
 enum GrBlendCoeff {
     kInvalid_GrBlendCoeff = -1,
 
     kZero_GrBlendCoeff,    //<! 0
     kOne_GrBlendCoeff,     //<! 1
     kSC_GrBlendCoeff,      //<! src color
     kISC_GrBlendCoeff,     //<! one minus src color
     kDC_GrBlendCoeff,      //<! dst color
     kIDC_GrBlendCoeff,     //<! one minus dst color
     kSA_GrBlendCoeff,      //<! src alpha
     kISA_GrBlendCoeff,     //<! one minus src alpha
     kDA_GrBlendCoeff,      //<! dst alpha
     kIDA_GrBlendCoeff,     //<! one minus dst alpha
     kConstC_GrBlendCoeff,  //<! constant color
     kIConstC_GrBlendCoeff, //<! one minus constant color
     kConstA_GrBlendCoeff,  //<! constant color alpha
     kIConstA_GrBlendCoeff, //<! one minus constant color alpha
     kS2C_GrBlendCoeff,
     kIS2C_GrBlendCoeff,
     kS2A_GrBlendCoeff,
     kIS2A_GrBlendCoeff,
 
     kTotalGrBlendCoeffCount
 };
 
 /**
+ * Barriers for blending. When a shader reads the dst directly, an Xfer barrier is sometimes
+ * required after a pixel has been written, before it can be safely read again.
+ */
+enum GrXferBarrierType {
+    kTexture_GrXferBarrierType, //<! Required when a shader reads and renders to the same texture.
+    kBlend_GrXferBarrierType,   //<! Required by certain blend extensions.
+};
+
+/**
  * GrXferProcessor is responsible for implementing the xfer mode that blends the src color and dst
  * color. It does this by emitting fragment shader code and controlling the fixed-function blend
  * state. The inputs to its shader code are the final computed src color and fractional pixel
  * coverage. The GrXferProcessor's shader code writes the fragment shader output color that goes
  * into the fixed-function blend. When dual-source blending is available, it may also write a
  * seconday fragment shader output color. When allowed by the backend API, the GrXferProcessor may
  * read the destination color. The GrXferProcessor is responsible for setting the blend coefficients
  * and blend constant color.
  *
  * A GrXferProcessor is never installed directly into our draw state, but instead is created from a
@@ skipping 56 matching lines @@
      * overrideColor will be the required value that should be passed into the XP. 
      * A caller who calls this function on a XP is required to honor the returned OptFlags
      * and color values for its draw.
      */
     virtual OptFlags getOptimizations(const GrProcOptInfo& colorPOI,
                                       const GrProcOptInfo& coveragePOI,
                                       bool doesStencilWrite,
                                       GrColor* overrideColor,
                                       const GrDrawTargetCaps& caps) = 0;
 
+    /**
+     * Returns whether this XP will require an Xfer barrier on the given rt. If true, outBarrierType
+     * is updated to contain the type of barrier needed.
+     */
+    virtual bool willNeedXferBarrier(const GrRenderTarget* rt,
+                                     const GrDrawTargetCaps& caps,
+                                     GrXferBarrierType* outBarrierType) const;
+
     struct BlendInfo {
-        GrBlendCoeff fSrcBlend;
-        GrBlendCoeff fDstBlend;
-        GrColor      fBlendConstant;
-        bool         fWriteColor;
+        GrBlendEquation fEquation;
+        GrBlendCoeff    fSrcBlend;
+        GrBlendCoeff    fDstBlend;
+        GrColor         fBlendConstant;
+        bool            fWriteColor;
     };
 
     void getBlendInfo(BlendInfo* blendInfo) const {
+        blendInfo->fEquation = kAdd_GrBlendEquation;
         blendInfo->fSrcBlend = kOne_GrBlendCoeff;
         blendInfo->fDstBlend = kZero_GrBlendCoeff;
         blendInfo->fBlendConstant = 0;
         blendInfo->fWriteColor = true;
         this->onGetBlendInfo(blendInfo);
     }
 
     bool willReadDstColor() const { return fWillReadDstColor; }
 
     /**
@@ skipping 176 matching lines @@
     enum {
         kIllegalXPFClassID = 0,
     };
     static int32_t gCurrXPFClassID;
 
     typedef GrProgramElement INHERITED;
 };
 
 #endif