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)

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

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));
}

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 Function 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