blob: 7ff7e8dd508ae7f3cbefb1c02d6d0d272edffd28 [file] [log] [blame]
/*
* Copyright 2013 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "include/core/SkShader.h"
#include "include/core/SkString.h"
#include "src/base/SkArenaAlloc.h"
#include "src/core/SkColorFilterBase.h"
#include "src/core/SkRasterPipeline.h"
#include "src/core/SkReadBuffer.h"
#include "src/core/SkVM.h"
#include "src/core/SkWriteBuffer.h"
#include "src/shaders/SkColorFilterShader.h"
#if defined(SK_GANESH)
#include "src/gpu/ganesh/GrFPArgs.h"
#include "src/gpu/ganesh/GrFragmentProcessor.h"
#endif
#if defined(SK_GRAPHITE)
#include "src/gpu/graphite/KeyHelpers.h"
#include "src/gpu/graphite/PaintParamsKey.h"
#endif
SkColorFilterShader::SkColorFilterShader(sk_sp<SkShader> shader,
float alpha,
sk_sp<SkColorFilter> filter)
: fShader(std::move(shader))
, fFilter(as_CFB_sp(std::move(filter)))
, fAlpha (alpha)
{
SkASSERT(fShader);
SkASSERT(fFilter);
}
sk_sp<SkFlattenable> SkColorFilterShader::CreateProc(SkReadBuffer& buffer) {
auto shader = buffer.readShader();
auto filter = buffer.readColorFilter();
if (!shader || !filter) {
return nullptr;
}
return sk_make_sp<SkColorFilterShader>(shader, 1.0f, filter);
}
bool SkColorFilterShader::isOpaque() const {
return fShader->isOpaque() && fAlpha == 1.0f && as_CFB(fFilter)->isAlphaUnchanged();
}
void SkColorFilterShader::flatten(SkWriteBuffer& buffer) const {
buffer.writeFlattenable(fShader.get());
SkASSERT(fAlpha == 1.0f); // Not exposed in public API SkShader::makeWithColorFilter().
buffer.writeFlattenable(fFilter.get());
}
bool SkColorFilterShader::appendStages(const SkStageRec& rec, const MatrixRec& mRec) const {
if (!as_SB(fShader)->appendStages(rec, mRec)) {
return false;
}
if (fAlpha != 1.0f) {
rec.fPipeline->append(SkRasterPipelineOp::scale_1_float, rec.fAlloc->make<float>(fAlpha));
}
if (!fFilter->appendStages(rec, fShader->isOpaque())) {
return false;
}
return true;
}
skvm::Color SkColorFilterShader::program(skvm::Builder* p,
skvm::Coord device,
skvm::Coord local,
skvm::Color paint,
const MatrixRec& mRec,
const SkColorInfo& dst,
skvm::Uniforms* uniforms,
SkArenaAlloc* alloc) const {
// Run the shader.
skvm::Color c = as_SB(fShader)->program(p, device, local, paint, mRec, dst, uniforms, alloc);
if (!c) {
return {};
}
// Scale that by alpha.
if (fAlpha != 1.0f) {
skvm::F32 A = p->uniformF(uniforms->pushF(fAlpha));
c.r *= A;
c.g *= A;
c.b *= A;
c.a *= A;
}
// Finally run that through the color filter.
return fFilter->program(p,c, dst, uniforms,alloc);
}
#if defined(SK_GANESH)
/////////////////////////////////////////////////////////////////////
std::unique_ptr<GrFragmentProcessor>
SkColorFilterShader::asFragmentProcessor(const GrFPArgs& args, const MatrixRec& mRec) const {
auto shaderFP = as_SB(fShader)->asFragmentProcessor(args, mRec);
if (!shaderFP) {
return nullptr;
}
// TODO I guess, but it shouldn't come up as used today.
SkASSERT(fAlpha == 1.0f);
auto [success, fp] = fFilter->asFragmentProcessor(std::move(shaderFP), args.fContext,
*args.fDstColorInfo, args.fSurfaceProps);
// If the filter FP could not be created, we still want to return the shader FP, so checking
// success can be omitted here.
return std::move(fp);
}
#endif
///////////////////////////////////////////////////////////////////////////////////////////////////
#if defined(SK_GRAPHITE)
void SkColorFilterShader::addToKey(const skgpu::graphite::KeyContext& keyContext,
skgpu::graphite::PaintParamsKeyBuilder* builder,
skgpu::graphite::PipelineDataGatherer* gatherer) const {
using namespace skgpu::graphite;
ColorFilterShaderBlock::BeginBlock(keyContext, builder, gatherer);
as_SB(fShader)->addToKey(keyContext, builder, gatherer);
as_CFB(fFilter)->addToKey(keyContext, builder, gatherer);
builder->endBlock();
}
#endif // SK_ENABLE_SKSL
///////////////////////////////////////////////////////////////////////////////////////////////////
sk_sp<SkShader> SkShader::makeWithColorFilter(sk_sp<SkColorFilter> filter) const {
SkShader* base = const_cast<SkShader*>(this);
if (!filter) {
return sk_ref_sp(base);
}
return sk_make_sp<SkColorFilterShader>(sk_ref_sp(base), 1.0f, std::move(filter));
}