GrPorterDuffXPFactory Class Reference

#include <GrPorterDuffXferProcessor.h>

Inheritance diagram for GrPorterDuffXPFactory:

Static Public Member Functions
static const GrXPFactory *	Get (SkBlendMode blendMode)
static sk_sp< const GrXferProcessor >	MakeSrcOverXferProcessor (const GrProcessorAnalysisColor &, GrProcessorAnalysisCoverage, const GrCaps &)
static sk_sp< const GrXferProcessor >	MakeNoCoverageXP (SkBlendMode)
static const GrXferProcessor &	SimpleSrcOverXP ()
static AnalysisProperties	SrcOverAnalysisProperties (const GrProcessorAnalysisColor &, const GrProcessorAnalysisCoverage &, const GrCaps &, GrClampType)
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)

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

Friends
class	GrPorterDuffTest

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 }
Public Member Functions inherited from GrXPFactory
	GR_DECL_BITFIELD_CLASS_OPS_FRIENDS (AnalysisProperties)
Protected Member Functions inherited from GrXPFactory
constexpr	GrXPFactory ()

Detailed Description

Definition at line 29 of file GrPorterDuffXferProcessor.h.

Member Function Documentation

analysisProperties()

GrXPFactory::AnalysisProperties GrPorterDuffXPFactory::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 460 of file GrPorterDuffXferProcessor.cpp.

                                     {
    return analysis_properties(color, coverage, caps, clampType, fBlendMode);
}

Get()

const GrXPFactory * GrPorterDuffXPFactory::Get ( SkBlendMode  blendMode )

static

Definition at line 309 of file GrPorterDuffXferProcessor.cpp.

                                                                   {
    SkASSERT((unsigned)blendMode <= (unsigned)SkBlendMode::kLastCoeffMode);
 
    static constexpr const GrPorterDuffXPFactory gClearPDXPF(SkBlendMode::kClear);
    static constexpr const GrPorterDuffXPFactory gSrcPDXPF(SkBlendMode::kSrc);
    static constexpr const GrPorterDuffXPFactory gDstPDXPF(SkBlendMode::kDst);
    static constexpr const GrPorterDuffXPFactory gSrcOverPDXPF(SkBlendMode::kSrcOver);
    static constexpr const GrPorterDuffXPFactory gDstOverPDXPF(SkBlendMode::kDstOver);
    static constexpr const GrPorterDuffXPFactory gSrcInPDXPF(SkBlendMode::kSrcIn);
    static constexpr const GrPorterDuffXPFactory gDstInPDXPF(SkBlendMode::kDstIn);
    static constexpr const GrPorterDuffXPFactory gSrcOutPDXPF(SkBlendMode::kSrcOut);
    static constexpr const GrPorterDuffXPFactory gDstOutPDXPF(SkBlendMode::kDstOut);
    static constexpr const GrPorterDuffXPFactory gSrcATopPDXPF(SkBlendMode::kSrcATop);
    static constexpr const GrPorterDuffXPFactory gDstATopPDXPF(SkBlendMode::kDstATop);
    static constexpr const GrPorterDuffXPFactory gXorPDXPF(SkBlendMode::kXor);
    static constexpr const GrPorterDuffXPFactory gPlusPDXPF(SkBlendMode::kPlus);
    static constexpr const GrPorterDuffXPFactory gModulatePDXPF(SkBlendMode::kModulate);
    static constexpr const GrPorterDuffXPFactory gScreenPDXPF(SkBlendMode::kScreen);
 
    switch (blendMode) {
        case SkBlendMode::kClear:
            return &gClearPDXPF;
        case SkBlendMode::kSrc:
            return &gSrcPDXPF;
        case SkBlendMode::kDst:
            return &gDstPDXPF;
        case SkBlendMode::kSrcOver:
            return &gSrcOverPDXPF;
        case SkBlendMode::kDstOver:
            return &gDstOverPDXPF;
        case SkBlendMode::kSrcIn:
            return &gSrcInPDXPF;
        case SkBlendMode::kDstIn:
            return &gDstInPDXPF;
        case SkBlendMode::kSrcOut:
            return &gSrcOutPDXPF;
        case SkBlendMode::kDstOut:
            return &gDstOutPDXPF;
        case SkBlendMode::kSrcATop:
            return &gSrcATopPDXPF;
        case SkBlendMode::kDstATop:
            return &gDstATopPDXPF;
        case SkBlendMode::kXor:
            return &gXorPDXPF;
        case SkBlendMode::kPlus:
            return &gPlusPDXPF;
        case SkBlendMode::kModulate:
            return &gModulatePDXPF;
        case SkBlendMode::kScreen:
            return &gScreenPDXPF;
        default:
            SK_ABORT("Unexpected blend mode.");
    }
}

MakeNoCoverageXP()

sk_sp< const GrXferProcessor > GrPorterDuffXPFactory::MakeNoCoverageXP ( SkBlendMode  blendmode )

static

Returns a simple non-LCD porter duff blend XP with no optimizations or coverage.

Definition at line 547 of file GrPorterDuffXferProcessor.cpp.

                                                                                          {
    BlendFormula formula = skgpu::GetBlendFormula(false, false, blendmode);
    return sk_make_sp<PorterDuffXferProcessor>(formula, GrProcessorAnalysisCoverage::kNone);
}

MakeSrcOverXferProcessor()

sk_sp< const GrXferProcessor > GrPorterDuffXPFactory::MakeSrcOverXferProcessor ( const GrProcessorAnalysisColor &  color, GrProcessorAnalysisCoverage  coverage, const GrCaps &  caps  )

static

Because src-over is so common we special case it for performance reasons. If this returns null then the SimpleSrcOverXP() below should be used.

color.isOpaque() ||

Definition at line 500 of file GrPorterDuffXferProcessor.cpp.

                            {
    // We want to not make an xfer processor if possible. Thus for the simple case where we are not
    // doing lcd blending we will just use our global SimpleSrcOverXP. This slightly differs from
    // the general case where we convert a src-over blend that has solid coverage and an opaque
    // color to src-mode, which allows disabling of blending.
    if (coverage != GrProcessorAnalysisCoverage::kLCD) {
        if (color.isOpaque() && coverage == GrProcessorAnalysisCoverage::kNone &&
            caps.shouldCollapseSrcOverToSrcWhenAble()) {
            BlendFormula blendFormula = skgpu::GetBlendFormula(true, false, SkBlendMode::kSrc);
            return sk_sp<GrXferProcessor>(new PorterDuffXferProcessor(blendFormula, coverage));
        }
        // We return nullptr here, which our caller interprets as meaning "use SimpleSrcOverXP".
        // We don't simply return the address of that XP here because our caller would have to unref
        // it and since it is a global object and GrProgramElement's ref-cnting system is not thread
        // safe.
        return nullptr;
    }
 
    // Currently up the stack Skia is requiring that the dst is opaque or that the client has said
    // the opaqueness doesn't matter. Thus for src-over we don't need to worry about the src color
    // being opaque or not. This allows us to use faster code paths as well as avoid various bugs
    // that occur with dst reads in the shader blending. For now we disable the check for
    // opaqueness, but in the future we should pass down the knowledge about dst opaqueness and make
    // the correct decision here.
    //
    // This also fixes a chrome bug on macs where we are getting random fuzziness when doing
    // blending in the shader for non opaque sources.
    if (color.isConstant() && /*color.isOpaque() &&*/
        !caps.shaderCaps()->fDualSourceBlendingSupport &&
        !caps.shaderCaps()->fDstReadInShaderSupport) {
        // If we don't have dual source blending or in shader dst reads, we fall
        // back to this trick for rendering SrcOver LCD text instead of doing a
        // dst copy.
        return PDLCDXferProcessor::Make(SkBlendMode::kSrcOver, color);
    }
 
    BlendFormula blendFormula = skgpu::GetLCDBlendFormula(SkBlendMode::kSrcOver);
    // See comment above regarding why the opaque check is commented out here.
    if (/*!color.isOpaque() ||*/
        (blendFormula.hasSecondaryOutput() && !caps.shaderCaps()->fDualSourceBlendingSupport)) {
        return sk_sp<GrXferProcessor>(new ShaderPDXferProcessor(SkBlendMode::kSrcOver, coverage));
    }
    return sk_sp<GrXferProcessor>(new PorterDuffXferProcessor(blendFormula, coverage));
}

makeXferProcessor()

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

overrideprivatevirtual

Implements GrXPFactory.

Definition at line 364 of file GrPorterDuffXferProcessor.cpp.

                                                         {
    bool isLCD = coverage == GrProcessorAnalysisCoverage::kLCD;
    // See comment in MakeSrcOverXferProcessor about color.isOpaque here
    if (isLCD &&
        SkBlendMode::kSrcOver == fBlendMode && color.isConstant() && /*color.isOpaque() &&*/
        !caps.shaderCaps()->fDualSourceBlendingSupport &&
        !caps.shaderCaps()->fDstReadInShaderSupport) {
        // If we don't have dual source blending or in shader dst reads, we fall back to this
        // trick for rendering SrcOver LCD text instead of doing a dst copy.
        return PDLCDXferProcessor::Make(fBlendMode, color);
    }
    BlendFormula blendFormula = [&](){
        if (isLCD) {
            return skgpu::GetLCDBlendFormula(fBlendMode);
        }
        if (fBlendMode == SkBlendMode::kSrcOver && color.isOpaque() &&
            coverage == GrProcessorAnalysisCoverage::kNone &&
            caps.shouldCollapseSrcOverToSrcWhenAble())
        {
            return skgpu::GetBlendFormula(true, false, SkBlendMode::kSrc);
        }
        return skgpu::GetBlendFormula(
                color.isOpaque(), GrProcessorAnalysisCoverage::kNone != coverage, fBlendMode);
    }();
 
    // Skia always saturates after the kPlus blend mode, so it requires shader-based blending when
    // pixels aren't guaranteed to automatically be normalized (i.e. any floating point config).
    if ((blendFormula.hasSecondaryOutput() && !caps.shaderCaps()->fDualSourceBlendingSupport) ||
        (isLCD && (SkBlendMode::kSrcOver != fBlendMode /*|| !color.isOpaque()*/)) ||
        (GrClampType::kAuto != clampType && SkBlendMode::kPlus == fBlendMode)) {
        return sk_sp<const GrXferProcessor>(new ShaderPDXferProcessor(fBlendMode, coverage));
    }
    return sk_sp<const GrXferProcessor>(new PorterDuffXferProcessor(blendFormula, coverage));
}

SimpleSrcOverXP()

const GrXferProcessor & GrPorterDuffXPFactory::SimpleSrcOverXP ( )

static

This XP implements non-LCD src-over using hw blend with no optimizations. It is returned by reference because it is global and its ref-cnting methods are not thread safe.

Definition at line 492 of file GrPorterDuffXferProcessor.cpp.

                                                              {
    static BlendFormula kSrcOverBlendFormula = skgpu::GetBlendFormula(
            /*isOpaque=*/false, /*hasCoverage=*/false, SkBlendMode::kSrcOver);
    static PorterDuffXferProcessor gSrcOverXP(kSrcOverBlendFormula,
                                              GrProcessorAnalysisCoverage::kSingleChannel);
    return gSrcOverXP;
}

SrcOverAnalysisProperties()

GrXPFactory::AnalysisProperties GrPorterDuffXPFactory::SrcOverAnalysisProperties ( const GrProcessorAnalysisColor &  color, const GrProcessorAnalysisCoverage &  coverage, const GrCaps &  caps, GrClampType  clampType  )

static

Definition at line 552 of file GrPorterDuffXferProcessor.cpp.

                               {
    return analysis_properties(color, coverage, caps, clampType, SkBlendMode::kSrcOver);
}

Friends And Related Symbol Documentation

GrPorterDuffTest

friend class GrPorterDuffTest

friend

Definition at line 69 of file GrPorterDuffXferProcessor.h.

---

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

• third_party/skia/src/gpu/ganesh/effects/GrPorterDuffXferProcessor.h
• third_party/skia/src/gpu/ganesh/effects/GrPorterDuffXferProcessor.cpp