Create fragment processor for performing input color blend with child processor

include/gpu/GrBlend.h

 
 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
-#include "GrTypes.h"
-#include "../private/SkTLogic.h"
-
 #ifndef GrBlend_DEFINED
 #define GrBlend_DEFINED
 
+#include "GrColor.h"
+#include "../private/SkTLogic.h"
+
 /**
  * Equations for alpha-blending.
  */
 enum GrBlendEquation {
     // Basic blend equations.
     kAdd_GrBlendEquation,             //<! Cs*S + Cd*D
     kSubtract_GrBlendEquation,        //<! Cs*S - Cd*D
     kReverseSubtract_GrBlendEquation, //<! Cd*D - Cs*S
 
     // Advanced blend equations. These are described in the SVG and PDF specs.
@@ skipping 14 matching lines @@
     kHSLLuminosity_GrBlendEquation,
 
     kFirstAdvancedGrBlendEquation = kScreen_GrBlendEquation,
     kLast_GrBlendEquation = kHSLLuminosity_GrBlendEquation
 };
 
 static const int kGrBlendEquationCnt = kLast_GrBlendEquation + 1;
 
 
 /**
- * Coeffecients for alpha-blending.
+ * Coefficients for alpha-blending.
  */
 enum GrBlendCoeff {
     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,
 
     kLast_GrBlendCoeff = kIS2A_GrBlendCoeff
 };
 
 static const int kGrBlendCoeffCnt = kLast_GrBlendCoeff + 1;
 
+/**
+ * Given a known blend equation in the form of srcCoeff * srcColor + dstCoeff * dstColor where
+ * there may be partial knowledge of the srcColor and dstColor component values, determine what
+ * components of the blended output color are known. This only works for 
+ */
+void GrGetCoeffBlendKnownComponents(GrBlendCoeff srcCoeff, GrBlendCoeff dstCoeff,
+                                    GrColor srcColor,
+                                    GrColorComponentFlags srcColorFlags,
+                                    GrColor dstColor,
+                                    GrColorComponentFlags dstColorFlags,
+                                    GrColor* outColor,
+                                    GrColorComponentFlags* outFlags);
 
 template<GrBlendCoeff Coeff>
 struct GrTBlendCoeffRefsSrc : skstd::bool_constant<kSC_GrBlendCoeff == Coeff ||
                                                    kISC_GrBlendCoeff == Coeff ||
                                                    kSA_GrBlendCoeff == Coeff ||
                                                    kISA_GrBlendCoeff == Coeff> {};
 
 #define GR_BLEND_COEFF_REFS_SRC(COEFF) \
     GrTBlendCoeffRefsSrc<COEFF>::value
 
 inline bool GrBlendCoeffRefsSrc(GrBlendCoeff coeff) {
     switch (coeff) {
         case kSC_GrBlendCoeff:
         case kISC_GrBlendCoeff:
         case kSA_GrBlendCoeff:
         case kISA_GrBlendCoeff:
             return true;
         default:
             return false;
     }
 }
 
-
 template<GrBlendCoeff Coeff>
 struct GrTBlendCoeffRefsDst : skstd::bool_constant<kDC_GrBlendCoeff == Coeff ||
                                                    kIDC_GrBlendCoeff == Coeff ||
                                                    kDA_GrBlendCoeff == Coeff ||
                                                    kIDA_GrBlendCoeff == Coeff> {};
 
 #define GR_BLEND_COEFF_REFS_DST(COEFF) \
     GrTBlendCoeffRefsDst<COEFF>::value
 
 inline bool GrBlendCoeffRefsDst(GrBlendCoeff coeff) {
@@ skipping 98 matching lines @@
     ((kAdd_GrBlendEquation == Equation || kReverseSubtract_GrBlendEquation == Equation) &&
       !GR_BLEND_COEFF_REFS_SRC(SrcCoeff) &&
       (kOne_GrBlendCoeff == DstCoeff ||
        kISC_GrBlendCoeff == DstCoeff ||
        kISA_GrBlendCoeff == DstCoeff))> {};
 
 #define GR_BLEND_CAN_TWEAK_ALPHA_FOR_COVERAGE(EQUATION, SRC_COEFF, DST_COEFF) \
     GrTBlendCanTweakAlphaForCoverage<EQUATION, SRC_COEFF, DST_COEFF>::value
 
 #endif