SkBlendModePriv.h File Reference

#include "include/core/SkBlendMode.h"
#include "include/core/SkColor.h"
#include "include/private/SkColorData.h"

Go to the source code of this file.

Enumerations
enum class	SkBlendFastPath { kNormal , kSrcOver , kSkipDrawing }

Functions
bool	SkBlendMode_SupportsCoverageAsAlpha (SkBlendMode)
static bool	SkBlendMode_CaresAboutRBOrder (SkBlendMode mode)
bool	SkBlendMode_ShouldPreScaleCoverage (SkBlendMode, bool rgb_coverage)
void	SkBlendMode_AppendStages (SkBlendMode, SkRasterPipeline *)
SkPMColor4f	SkBlendMode_Apply (SkBlendMode, const SkPMColor4f &src, const SkPMColor4f &dst)
SkBlendFastPath	CheckFastPath (const SkPaint &, bool dstIsOpaque)

Variables
constexpr uint8_t	kCustom_SkBlendMode = 0xFF

Enumeration Type Documentation

SkBlendFastPath

enum class SkBlendFastPath

strong

Enumerator
kNormal
kSrcOver
kSkipDrawing

Definition at line 36 of file SkBlendModePriv.h.

                           {
    kNormal,      // draw normally
    kSrcOver,     //< draw as if in srcover mode
    kSkipDrawing  //< draw nothing
};

Function Documentation

CheckFastPath()

SkBlendFastPath CheckFastPath	(	const SkPaint &	paint,
		bool	dstIsOpaque
	)

Given a paint, determine whether the paint's blend mode can be replaced with kSrcOver or not drawn at all. This can inform drawing optimizations.

Definition at line 208 of file SkBlendMode.cpp.

                                                                      {
    const auto bm = paint.asBlendMode();
    if (!bm) {
        return SkBlendFastPath::kNormal;
    }
    switch (bm.value()) {
        case SkBlendMode::kSrcOver:
            return SkBlendFastPath::kSrcOver;
        case SkBlendMode::kSrc:
            if (just_solid_color(paint)) {
                return SkBlendFastPath::kSrcOver;
            }
            return SkBlendFastPath::kNormal;
        case SkBlendMode::kDst:
            return SkBlendFastPath::kSkipDrawing;
        case SkBlendMode::kDstOver:
            if (dstIsOpaque) {
                return SkBlendFastPath::kSkipDrawing;
            }
            return SkBlendFastPath::kNormal;
        case SkBlendMode::kSrcIn:
            if (dstIsOpaque && just_solid_color(paint)) {
                return SkBlendFastPath::kSrcOver;
            }
            return SkBlendFastPath::kNormal;
        case SkBlendMode::kDstIn:
            if (just_solid_color(paint)) {
                return SkBlendFastPath::kSkipDrawing;
            }
            return SkBlendFastPath::kNormal;
        default:
            return SkBlendFastPath::kNormal;
    }
}

SkBlendMode_AppendStages()

void SkBlendMode_AppendStages	(	SkBlendMode	mode,
		SkRasterPipeline *	p
	)

Definition at line 97 of file SkBlendMode.cpp.

                                                                     {
    auto stage = SkRasterPipelineOp::srcover;
    switch (mode) {
        case SkBlendMode::kClear:    stage = SkRasterPipelineOp::clear; break;
        case SkBlendMode::kSrc:      return;  // This stage is a no-op.
        case SkBlendMode::kDst:      stage = SkRasterPipelineOp::move_dst_src; break;
        case SkBlendMode::kSrcOver:  stage = SkRasterPipelineOp::srcover; break;
        case SkBlendMode::kDstOver:  stage = SkRasterPipelineOp::dstover; break;
        case SkBlendMode::kSrcIn:    stage = SkRasterPipelineOp::srcin; break;
        case SkBlendMode::kDstIn:    stage = SkRasterPipelineOp::dstin; break;
        case SkBlendMode::kSrcOut:   stage = SkRasterPipelineOp::srcout; break;
        case SkBlendMode::kDstOut:   stage = SkRasterPipelineOp::dstout; break;
        case SkBlendMode::kSrcATop:  stage = SkRasterPipelineOp::srcatop; break;
        case SkBlendMode::kDstATop:  stage = SkRasterPipelineOp::dstatop; break;
        case SkBlendMode::kXor:      stage = SkRasterPipelineOp::xor_; break;
        case SkBlendMode::kPlus:     stage = SkRasterPipelineOp::plus_; break;
        case SkBlendMode::kModulate: stage = SkRasterPipelineOp::modulate; break;
 
        case SkBlendMode::kScreen:     stage = SkRasterPipelineOp::screen; break;
        case SkBlendMode::kOverlay:    stage = SkRasterPipelineOp::overlay; break;
        case SkBlendMode::kDarken:     stage = SkRasterPipelineOp::darken; break;
        case SkBlendMode::kLighten:    stage = SkRasterPipelineOp::lighten; break;
        case SkBlendMode::kColorDodge: stage = SkRasterPipelineOp::colordodge; break;
        case SkBlendMode::kColorBurn:  stage = SkRasterPipelineOp::colorburn; break;
        case SkBlendMode::kHardLight:  stage = SkRasterPipelineOp::hardlight; break;
        case SkBlendMode::kSoftLight:  stage = SkRasterPipelineOp::softlight; break;
        case SkBlendMode::kDifference: stage = SkRasterPipelineOp::difference; break;
        case SkBlendMode::kExclusion:  stage = SkRasterPipelineOp::exclusion; break;
        case SkBlendMode::kMultiply:   stage = SkRasterPipelineOp::multiply; break;
 
        case SkBlendMode::kHue:        stage = SkRasterPipelineOp::hue; break;
        case SkBlendMode::kSaturation: stage = SkRasterPipelineOp::saturation; break;
        case SkBlendMode::kColor:      stage = SkRasterPipelineOp::color; break;
        case SkBlendMode::kLuminosity: stage = SkRasterPipelineOp::luminosity; break;
    }
    p->append(stage);
}

SkBlendMode_Apply()

SkPMColor4f SkBlendMode_Apply	(	SkBlendMode	mode,
		const SkPMColor4f &	src,
		const SkPMColor4f &	dst
	)

Definition at line 135 of file SkBlendMode.cpp.

                                                                                                {
    // special-case simple/common modes...
    switch (mode) {
        case SkBlendMode::kClear:   return SK_PMColor4fTRANSPARENT;
        case SkBlendMode::kSrc:     return src;
        case SkBlendMode::kDst:     return dst;
        case SkBlendMode::kSrcOver: {
            SkPMColor4f r;
            (skvx::float4::Load(src.vec()) + skvx::float4::Load(dst.vec()) * (1-src.fA)).store(&r);
            return r;
        }
        default:
            break;
    }
 
    SkRasterPipeline_<256> p;
    SkPMColor4f            src_storage = src,
                           dst_storage = dst,
                           res_storage;
    SkRasterPipeline_MemoryCtx src_ctx = { &src_storage, 0 },
                               dst_ctx = { &dst_storage, 0 },
                               res_ctx = { &res_storage, 0 };
 
    p.append(SkRasterPipelineOp::load_f32, &dst_ctx);
    p.append(SkRasterPipelineOp::move_src_dst);
    p.append(SkRasterPipelineOp::load_f32, &src_ctx);
    SkBlendMode_AppendStages(mode, &p);
    p.append(SkRasterPipelineOp::store_f32, &res_ctx);
    p.run(0,0, 1,1);
    return res_storage;
}

SkBlendMode_CaresAboutRBOrder()

static bool SkBlendMode_CaresAboutRBOrder ( SkBlendMode  mode )

inlinestatic

Definition at line 27 of file SkBlendModePriv.h.

                                                                   {
    return (mode > SkBlendMode::kLastSeparableMode);
}

SkBlendMode_ShouldPreScaleCoverage()

bool SkBlendMode_ShouldPreScaleCoverage	(	SkBlendMode	mode,
		bool	rgb_coverage
	)

Definition at line 21 of file SkBlendMode.cpp.

                                                                             {
    // The most important things we do here are:
    //   1) never pre-scale with rgb coverage if the blend mode involves a source-alpha term;
    //   2) always pre-scale Plus.
    //
    // When we pre-scale with rgb coverage, we scale each of source r,g,b, with a distinct value,
    // and source alpha with one of those three values.  This process destructively updates the
    // source-alpha term, so we can't evaluate blend modes that need its original value.
    //
    // Plus always requires pre-scaling as a specific quirk of its implementation in
    // SkRasterPipeline.  This lets us put the clamp inside the blend mode itself rather
    // than as a separate stage that'd come after the lerp.
    //
    // This function is a finer-grained breakdown of SkBlendMode_SupportsCoverageAsAlpha().
    switch (mode) {
        case SkBlendMode::kDst:        // d              --> no sa term, ok!
        case SkBlendMode::kDstOver:    // d + s*inv(da)  --> no sa term, ok!
        case SkBlendMode::kPlus:       // clamp(s+d)     --> no sa term, ok!
            return true;
 
        case SkBlendMode::kDstOut:     // d * inv(sa)
        case SkBlendMode::kSrcATop:    // s*da + d*inv(sa)
        case SkBlendMode::kSrcOver:    // s + d*inv(sa)
        case SkBlendMode::kXor:        // s*inv(da) + d*inv(sa)
            return !rgb_coverage;
 
        default: break;
    }
    return false;
}

SkBlendMode_SupportsCoverageAsAlpha()

bool SkBlendMode_SupportsCoverageAsAlpha

(

SkBlendMode

mode

)

Definition at line 53 of file SkBlendMode.cpp.

                                                           {
    return SkBlendMode_ShouldPreScaleCoverage(mode, false);
}

Variable Documentation

kCustom_SkBlendMode

constexpr uint8_t kCustom_SkBlendMode = 0xFF

constexpr

Sentinel value for SkBlendMode enum.

Will never be a valid enum value, but will be storable in a byte.

Definition at line 23 of file SkBlendModePriv.h.