Clean up SkTLogic.

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"
@@ skipping 57 matching lines @@
     kS2A_GrBlendCoeff,
     kIS2A_GrBlendCoeff,
 
     kLast_GrBlendCoeff = kIS2A_GrBlendCoeff
 };
 
 static const int kGrBlendCoeffCnt = kLast_GrBlendCoeff + 1;
 
 
 template<GrBlendCoeff Coeff>
-struct GrTBlendCoeffRefsSrc : SkTBool<kSC_GrBlendCoeff == Coeff ||
-                                      kISC_GrBlendCoeff == Coeff ||
-                                      kSA_GrBlendCoeff == Coeff ||
-                                      kISA_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 : SkTBool<kDC_GrBlendCoeff == Coeff ||
-                                      kIDC_GrBlendCoeff == Coeff ||
-                                      kDA_GrBlendCoeff == Coeff ||
-                                      kIDA_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) {
     switch (coeff) {
         case kDC_GrBlendCoeff:
         case kIDC_GrBlendCoeff:
         case kDA_GrBlendCoeff:
         case kIDA_GrBlendCoeff:
             return true;
         default:
             return false;
     }
 }
 
 
 template<GrBlendCoeff Coeff>
-struct GrTBlendCoeffRefsSrc2 : SkTBool<kS2C_GrBlendCoeff == Coeff ||
-                                       kIS2C_GrBlendCoeff == Coeff ||
-                                       kS2A_GrBlendCoeff == Coeff ||
-                                       kIS2A_GrBlendCoeff == Coeff> {};
+struct GrTBlendCoeffRefsSrc2 : skstd::bool_constant<kS2C_GrBlendCoeff == Coeff ||
+                                                    kIS2C_GrBlendCoeff == Coeff ||
+                                                    kS2A_GrBlendCoeff == Coeff ||
+                                                    kIS2A_GrBlendCoeff == Coeff> {};
 
 #define GR_BLEND_COEFF_REFS_SRC2(COEFF) \
     GrTBlendCoeffRefsSrc2<COEFF>::value
 
 inline bool GrBlendCoeffRefsSrc2(GrBlendCoeff coeff) {
     switch (coeff) {
         case kS2C_GrBlendCoeff:
         case kIS2C_GrBlendCoeff:
         case kS2A_GrBlendCoeff:
         case kIS2A_GrBlendCoeff:
             return true;
         default:
             return false;
     }
 }
 
 
 template<GrBlendCoeff SrcCoeff, GrBlendCoeff DstCoeff>
-struct GrTBlendCoeffsUseSrcColor : SkTBool<kZero_GrBlendCoeff != SrcCoeff ||
-                                           GR_BLEND_COEFF_REFS_SRC(DstCoeff)> {};
+struct GrTBlendCoeffsUseSrcColor : skstd::bool_constant<kZero_GrBlendCoeff != SrcCoeff ||
+                                                        GR_BLEND_COEFF_REFS_SRC(DstCoeff)> {};
 
 #define GR_BLEND_COEFFS_USE_SRC_COLOR(SRC_COEFF, DST_COEFF) \
     GrTBlendCoeffsUseSrcColor<SRC_COEFF, DST_COEFF>::value
 
 
 template<GrBlendCoeff SrcCoeff, GrBlendCoeff DstCoeff>
-struct GrTBlendCoeffsUseDstColor : SkTBool<GR_BLEND_COEFF_REFS_DST(SrcCoeff) ||
-                                           kZero_GrBlendCoeff != DstCoeff> {};
+struct GrTBlendCoeffsUseDstColor : skstd::bool_constant<GR_BLEND_COEFF_REFS_DST(SrcCoeff) ||
+                                                        kZero_GrBlendCoeff != DstCoeff> {};
 
 #define GR_BLEND_COEFFS_USE_DST_COLOR(SRC_COEFF, DST_COEFF) \
     GrTBlendCoeffsUseDstColor<SRC_COEFF, DST_COEFF>::value
 
 
 template<GrBlendEquation Equation>
-struct GrTBlendEquationIsAdvanced : SkTBool<Equation >= kFirstAdvancedGrBlendEquation> {};
+struct GrTBlendEquationIsAdvanced : skstd::bool_constant<Equation >= kFirstAdvancedGrBlendEquation> {};
 
 #define GR_BLEND_EQUATION_IS_ADVANCED(EQUATION) \
     GrTBlendEquationIsAdvanced<EQUATION>::value
 
 inline bool GrBlendEquationIsAdvanced(GrBlendEquation equation) {
     return equation >= kFirstAdvancedGrBlendEquation;
 }
 
 
 template<GrBlendEquation BlendEquation, GrBlendCoeff SrcCoeff, GrBlendCoeff DstCoeff>
-struct GrTBlendModifiesDst : SkTBool<(kAdd_GrBlendEquation != BlendEquation &&
-                                      kReverseSubtract_GrBlendEquation != BlendEquation) ||
-                                     kZero_GrBlendCoeff != SrcCoeff ||
-                                     kOne_GrBlendCoeff != DstCoeff> {};
+struct GrTBlendModifiesDst : skstd::bool_constant<
+    (kAdd_GrBlendEquation != BlendEquation && kReverseSubtract_GrBlendEquation != BlendEquation) ||
+     kZero_GrBlendCoeff != SrcCoeff ||
+     kOne_GrBlendCoeff != DstCoeff> {};
 
 #define GR_BLEND_MODIFIES_DST(EQUATION, SRC_COEFF, DST_COEFF) \
     GrTBlendModifiesDst<EQUATION, SRC_COEFF, DST_COEFF>::value
 
 
 /**
  * Advanced blend equations can always tweak alpha for coverage. (See GrCustomXfermode.cpp)
  *
  * For "add" and "reverse subtract" the blend equation with f=coverage is:
  *
@@ skipping 10 matching lines @@
  * It's easy to see this works for the src term as long as srcCoeff' == srcCoeff (meaning srcCoeff
  * does not reference S). For the dst term, this will work as long as the following is true:
  *|
  *   dstCoeff' == f * dstCoeff + (1 - f)
  *   dstCoeff' == 1 - f * (1 - dstCoeff)
  *
  * By inspection we can see this will work as long as dstCoeff has a 1, and any other term in
  * dstCoeff references S.
  */
 template<GrBlendEquation Equation, GrBlendCoeff SrcCoeff, GrBlendCoeff DstCoeff>
-struct GrTBlendCanTweakAlphaForCoverage : SkTBool<GR_BLEND_EQUATION_IS_ADVANCED(Equation) ||
-                                                  ((kAdd_GrBlendEquation == Equation ||
-                                                    kReverseSubtract_GrBlendEquation == Equation) &&
-                                                   !GR_BLEND_COEFF_REFS_SRC(SrcCoeff) &&
-                                                   (kOne_GrBlendCoeff == DstCoeff ||
-                                                    kISC_GrBlendCoeff == DstCoeff ||
-                                                    kISA_GrBlendCoeff == DstCoeff))> {};
+struct GrTBlendCanTweakAlphaForCoverage : skstd::bool_constant<
+    GR_BLEND_EQUATION_IS_ADVANCED(Equation) ||
+    ((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