blob: d63aa536858ae6d555ae40dc724ab1431930cab7 [file] [log] [blame]
* Copyright 2006 The Android Open Source Project
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
#include "include/core/SkColorFilter.h"
#include "include/core/SkFlattenable.h"
#include "include/core/SkString.h"
#include "include/effects/SkRuntimeEffect.h"
#include "include/private/SkColorData.h"
#include "src/core/SkArenaAlloc.h"
#include "src/core/SkBlendModePriv.h"
#include "src/core/SkBlenderBase.h"
#include "src/core/SkRasterPipeline.h"
#include "src/core/SkReadBuffer.h"
#include "src/core/SkRuntimeEffectPriv.h"
#include "src/core/SkVM.h"
#include "src/core/SkWriteBuffer.h"
#include "src/shaders/SkShaderBase.h"
#include "src/core/SkKeyHelpers.h"
#include "src/core/SkPaintParamsKey.h"
namespace {
struct LocalMatrixStageRec final : public SkStageRec {
LocalMatrixStageRec(const SkStageRec& rec, const SkMatrix& lm)
: INHERITED(rec) {
if (!lm.isIdentity()) {
if (fLocalM) {
fStorage = SkShaderBase::ConcatLocalMatrices(*rec.fLocalM, lm);
fLocalM = fStorage.isIdentity() ? nullptr : &fStorage;
} else {
fLocalM = &lm;
SkMatrix fStorage;
using INHERITED = SkStageRec;
} // namespace
class SkShader_Blend final : public SkShaderBase {
SkShader_Blend(SkBlendMode mode, sk_sp<SkShader> dst, sk_sp<SkShader> src)
: fDst(std::move(dst))
, fSrc(std::move(src))
, fMode(mode) {}
std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(const GrFPArgs&) const override;
void addToKey(const SkKeyContext&,
SkPipelineDataGatherer*) const override;
void flatten(SkWriteBuffer&) const override;
bool onAppendStages(const SkStageRec&) const override;
skvm::Color onProgram(skvm::Builder*, skvm::Coord device, skvm::Coord local, skvm::Color paint,
const SkMatrixProvider&, const SkMatrix* localM, const SkColorInfo& dst,
skvm::Uniforms*, SkArenaAlloc*) const override;
friend void ::SkRegisterComposeShaderFlattenable();
sk_sp<SkShader> fDst;
sk_sp<SkShader> fSrc;
SkBlendMode fMode;
using INHERITED = SkShaderBase;
sk_sp<SkFlattenable> SkShader_Blend::CreateProc(SkReadBuffer& buffer) {
sk_sp<SkShader> dst(buffer.readShader());
sk_sp<SkShader> src(buffer.readShader());
if (!buffer.validate(dst && src)) {
return nullptr;
unsigned mode = buffer.read32();
if (mode == kCustom_SkBlendMode) {
sk_sp<SkBlender> blender = buffer.readBlender();
if (buffer.validate(blender != nullptr)) {
return SkShaders::Blend(std::move(blender), std::move(dst), std::move(src));
} else {
if (buffer.validate(mode <= (unsigned)SkBlendMode::kLastMode)) {
return SkShaders::Blend(static_cast<SkBlendMode>(mode), std::move(dst), std::move(src));
return nullptr;
void SkShader_Blend::flatten(SkWriteBuffer& buffer) const {
// Returns the output of e0, and leaves the output of e1 in r,g,b,a
static float* append_two_shaders(const SkStageRec& rec, SkShader* s0, SkShader* s1) {
struct Storage {
float fRes0[4 * SkRasterPipeline_kMaxStride];
auto storage = rec.fAlloc->make<Storage>();
if (!as_SB(s0)->appendStages(rec)) {
return nullptr;
rec.fPipeline->append(SkRasterPipeline::store_src, storage->fRes0);
if (!as_SB(s1)->appendStages(rec)) {
return nullptr;
return storage->fRes0;
bool SkShader_Blend::onAppendStages(const SkStageRec& orig_rec) const {
const LocalMatrixStageRec rec(orig_rec, this->getLocalMatrix());
float* res0 = append_two_shaders(rec, fDst.get(), fSrc.get());
if (!res0) {
return false;
rec.fPipeline->append(SkRasterPipeline::load_dst, res0);
SkBlendMode_AppendStages(fMode, rec.fPipeline);
return true;
skvm::Color SkShader_Blend::onProgram(skvm::Builder* p,
skvm::Coord device, skvm::Coord local, skvm::Color paint,
const SkMatrixProvider& mats, const SkMatrix* localM,
const SkColorInfo& cinfo,
skvm::Uniforms* uniforms, SkArenaAlloc* alloc) const {
skvm::Color d,s;
if ((d = as_SB(fDst)->program(p, device,local, paint, mats,localM, cinfo, uniforms,alloc)) &&
(s = as_SB(fSrc)->program(p, device,local, paint, mats,localM, cinfo, uniforms,alloc))) {
return p->blend(fMode, s,d);
return {};
#include "include/gpu/GrRecordingContext.h"
#include "src/gpu/ganesh/GrFPArgs.h"
#include "src/gpu/ganesh/GrFragmentProcessor.h"
#include "src/gpu/ganesh/effects/GrBlendFragmentProcessor.h"
std::unique_ptr<GrFragmentProcessor> SkShader_Blend::asFragmentProcessor(
const GrFPArgs& orig_args) const {
GrFPArgs::ConcatLocalMatrix args(orig_args, this->getLocalMatrix());
auto fpA = as_SB(fDst)->asFragmentProcessor(args);
auto fpB = as_SB(fSrc)->asFragmentProcessor(args);
if (!fpA || !fpB) {
// This is unexpected. Both src and dst shaders should be valid. Just fail.
return nullptr;
return GrBlendFragmentProcessor::Make(std::move(fpB), std::move(fpA), fMode);
#include "src/gpu/Blend.h"
void SkShader_Blend::addToKey(const SkKeyContext& keyContext,
SkPaintParamsKeyBuilder* builder,
SkPipelineDataGatherer* gatherer) const {
SkSpan<const float> porterDuffConstants = skgpu::GetPorterDuffBlendConstants(fMode);
if (!porterDuffConstants.empty()) {
PorterDuffBlendShaderBlock::BeginBlock(keyContext, builder, gatherer,
} else {
BlendShaderBlock::BeginBlock(keyContext, builder, gatherer, {fMode});
as_SB(fSrc)->addToKey(keyContext, builder, gatherer);
as_SB(fDst)->addToKey(keyContext, builder, gatherer);
sk_sp<SkShader> SkShaders::Blend(SkBlendMode mode, sk_sp<SkShader> dst, sk_sp<SkShader> src) {
if (!src || !dst) {
return nullptr;
switch (mode) {
case SkBlendMode::kClear: return Color(0);
case SkBlendMode::kDst: return dst;
case SkBlendMode::kSrc: return src;
default: break;
return sk_sp<SkShader>(new SkShader_Blend(mode, std::move(dst), std::move(src)));
sk_sp<SkShader> SkShaders::Blend(sk_sp<SkBlender> blender,
sk_sp<SkShader> dst,
sk_sp<SkShader> src) {
if (!src || !dst) {
return nullptr;
if (!blender) {
return SkShaders::Blend(SkBlendMode::kSrcOver, std::move(dst), std::move(src));
if (std::optional<SkBlendMode> mode = as_BB(blender)->asBlendMode()) {
return sk_make_sp<SkShader_Blend>(mode.value(), std::move(dst), std::move(src));
// This isn't a built-in blend mode; we might as well use a runtime effect to evaluate it.
static SkRuntimeEffect* sBlendEffect = SkMakeRuntimeEffect(SkRuntimeEffect::MakeForShader,
"uniform blender b;"
"uniform shader d, s;"
"half4 main(float2 xy) {"
"return b.eval(s.eval(xy), d.eval(xy));"
SkRuntimeEffect::ChildPtr children[] = {std::move(blender), std::move(dst), std::move(src)};
return sBlendEffect->makeShader(/*uniforms=*/{}, children);
// We need SkSL to render this blend.
return nullptr;
void SkRegisterComposeShaderFlattenable() {