CustomXPFactory Class Reference

Inheritance diagram for CustomXPFactory:

Public Member Functions
constexpr	CustomXPFactory (SkBlendMode mode)
Public Member Functions inherited from GrXPFactory
	GR_DECL_BITFIELD_CLASS_OPS_FRIENDS (AnalysisProperties)

Private Member Functions
sk_sp< const GrXferProcessor >	makeXferProcessor (const GrProcessorAnalysisColor &, GrProcessorAnalysisCoverage, const GrCaps &, GrClampType) const override
AnalysisProperties	analysisProperties (const GrProcessorAnalysisColor &, const GrProcessorAnalysisCoverage &, const GrCaps &, GrClampType) const override

Additional Inherited Members
Public Types inherited from GrXPFactory
enum class	AnalysisProperties : unsigned {   kNone = 0x0 , kReadsDstInShader = 0x1 , kCompatibleWithCoverageAsAlpha = 0x2 , kIgnoresInputColor = 0x4 ,   kRequiresDstTexture = 0x10 , kRequiresNonOverlappingDraws = 0x20 , kUsesNonCoherentHWBlending = 0x40 , kUnaffectedByDstValue = 0x80 }
Static Public Member Functions inherited from GrXPFactory
static sk_sp< const GrXferProcessor >	MakeXferProcessor (const GrXPFactory *, const GrProcessorAnalysisColor &, GrProcessorAnalysisCoverage, const GrCaps &caps, GrClampType)
static AnalysisProperties	GetAnalysisProperties (const GrXPFactory *, const GrProcessorAnalysisColor &, const GrProcessorAnalysisCoverage &, const GrCaps &, GrClampType)
static const GrXPFactory *	FromBlendMode (SkBlendMode)
Protected Member Functions inherited from GrXPFactory
constexpr	GrXPFactory ()

Detailed Description

Definition at line 214 of file GrCustomXfermode.cpp.

Constructor & Destructor Documentation

CustomXPFactory()

constexpr CustomXPFactory::CustomXPFactory ( SkBlendMode  mode )

inlineconstexpr

Definition at line 216 of file GrCustomXfermode.cpp.

            : fMode(mode), fHWBlendEquation(hw_blend_equation(mode)) {}

Member Function Documentation

analysisProperties()

GrXPFactory::AnalysisProperties CustomXPFactory::analysisProperties ( const GrProcessorAnalysisColor &  , const GrProcessorAnalysisCoverage &  , const GrCaps &  , GrClampType    ) const

overrideprivatevirtual

Subclass analysis implementation. This should not return kNeedsDstInTexture as that will be inferred by the base class based on kReadsDstInShader and the caps.

Implements GrXPFactory.

Definition at line 256 of file GrCustomXfermode.cpp.

                                                         {
    /*
      The general SVG blend equation is defined in the spec as follows:
 
        Dca' = B(Sc, Dc) * Sa * Da + Y * Sca * (1-Da) + Z * Dca * (1-Sa)
        Da'  = X * Sa * Da + Y * Sa * (1-Da) + Z * Da * (1-Sa)
 
      (Note that Sca, Dca indicate RGB vectors that are premultiplied by alpha,
       and that B(Sc, Dc) is a mode-specific function that accepts non-multiplied
       RGB colors.)
 
      For every blend mode supported by this class, i.e. the "advanced" blend
      modes, X=Y=Z=1 and this equation reduces to the PDF blend equation.
 
      It can be shown that when X=Y=Z=1, these equations can modulate alpha for
      coverage.
 
 
      == Color ==
 
      We substitute Y=Z=1 and define a blend() function that calculates Dca' in
      terms of premultiplied alpha only:
 
        blend(Sca, Dca, Sa, Da) = {Dca : if Sa == 0,
                                   Sca : if Da == 0,
                                   B(Sca/Sa, Dca/Da) * Sa * Da + Sca * (1-Da) + Dca * (1-Sa) : if
      Sa,Da != 0}
 
      And for coverage modulation, we use a post blend src-over model:
 
        Dca'' = f * blend(Sca, Dca, Sa, Da) + (1-f) * Dca
 
      (Where f is the fractional coverage.)
 
      Next we show that canTweakAlphaForCoverage() is true by proving the
      following relationship:
 
        blend(f*Sca, Dca, f*Sa, Da) == f * blend(Sca, Dca, Sa, Da) + (1-f) * Dca
 
      General case (f,Sa,Da != 0):
 
        f * blend(Sca, Dca, Sa, Da) + (1-f) * Dca
          = f * (B(Sca/Sa, Dca/Da) * Sa * Da + Sca * (1-Da) + Dca * (1-Sa)) + (1-f) * Dca  [Sa,Da !=
      0, definition of blend()]
          = B(Sca/Sa, Dca/Da) * f*Sa * Da + f*Sca * (1-Da) + f*Dca * (1-Sa) + Dca - f*Dca
          = B(Sca/Sa, Dca/Da) * f*Sa * Da + f*Sca - f*Sca * Da + f*Dca - f*Dca * Sa + Dca - f*Dca
          = B(Sca/Sa, Dca/Da) * f*Sa * Da + f*Sca - f*Sca * Da - f*Dca * Sa + Dca
          = B(Sca/Sa, Dca/Da) * f*Sa * Da + f*Sca * (1-Da) - f*Dca * Sa + Dca
          = B(Sca/Sa, Dca/Da) * f*Sa * Da + f*Sca * (1-Da) + Dca * (1 - f*Sa)
          = B(f*Sca/f*Sa, Dca/Da) * f*Sa * Da + f*Sca * (1-Da) + Dca * (1 - f*Sa)  [f!=0]
          = blend(f*Sca, Dca, f*Sa, Da)  [definition of blend()]
 
      Corner cases (Sa=0, Da=0, and f=0):
 
        Sa=0: f * blend(Sca, Dca, Sa, Da) + (1-f) * Dca
                = f * Dca + (1-f) * Dca  [Sa=0, definition of blend()]
                = Dca
                = blend(0, Dca, 0, Da)  [definition of blend()]
                = blend(f*Sca, Dca, f*Sa, Da)  [Sa=0]
 
        Da=0: f * blend(Sca, Dca, Sa, Da) + (1-f) * Dca
                = f * Sca + (1-f) * Dca  [Da=0, definition of blend()]
                = f * Sca  [Da=0]
                = blend(f*Sca, 0, f*Sa, 0)  [definition of blend()]
                = blend(f*Sca, Dca, f*Sa, Da)  [Da=0]
 
        f=0: f * blend(Sca, Dca, Sa, Da) + (1-f) * Dca
               = Dca  [f=0]
               = blend(0, Dca, 0, Da)  [definition of blend()]
               = blend(f*Sca, Dca, f*Sa, Da)  [f=0]
 
      == Alpha ==
 
      We substitute X=Y=Z=1 and define a blend() function that calculates Da':
 
        blend(Sa, Da) = Sa * Da + Sa * (1-Da) + Da * (1-Sa)
                      = Sa * Da + Sa - Sa * Da + Da - Da * Sa
                      = Sa + Da - Sa * Da
 
      We use the same model for coverage modulation as we did with color:
 
        Da'' = f * blend(Sa, Da) + (1-f) * Da
 
      And show that canTweakAlphaForCoverage() is true by proving the following
      relationship:
 
        blend(f*Sa, Da) == f * blend(Sa, Da) + (1-f) * Da
 
 
        f * blend(Sa, Da) + (1-f) * Da
          = f * (Sa + Da - Sa * Da) + (1-f) * Da
          = f*Sa + f*Da - f*Sa * Da + Da - f*Da
          = f*Sa - f*Sa * Da + Da
          = f*Sa + Da - f*Sa * Da
          = blend(f*Sa, Da)
    */
    if (can_use_hw_blend_equation(fHWBlendEquation, coverage, caps)) {
        if (caps.blendEquationSupport() == GrCaps::kAdvancedCoherent_BlendEquationSupport) {
            return AnalysisProperties::kCompatibleWithCoverageAsAlpha;
        } else {
            return AnalysisProperties::kCompatibleWithCoverageAsAlpha |
                   AnalysisProperties::kRequiresNonOverlappingDraws |
                   AnalysisProperties::kUsesNonCoherentHWBlending;
        }
    }
    return AnalysisProperties::kCompatibleWithCoverageAsAlpha |
           AnalysisProperties::kReadsDstInShader;
}

makeXferProcessor()

sk_sp< const GrXferProcessor > CustomXPFactory::makeXferProcessor ( const GrProcessorAnalysisColor &  , GrProcessorAnalysisCoverage  coverage, const GrCaps &  caps, GrClampType  clampType  ) const

overrideprivatevirtual

Implements GrXPFactory.

Definition at line 244 of file GrCustomXfermode.cpp.

                                     {
    SkASSERT(GrCustomXfermode::IsSupportedMode(fMode));
    if (can_use_hw_blend_equation(fHWBlendEquation, coverage, caps)) {
        return sk_sp<GrXferProcessor>(new CustomXP(fMode, fHWBlendEquation));
    }
    return sk_sp<GrXferProcessor>(new CustomXP(fMode, coverage));
}

---

The documentation for this class was generated from the following file:

• third_party/skia/src/gpu/ganesh/effects/GrCustomXfermode.cpp