blob: 8109b477492d089ba471ef2a133b99fc32a45803 [file] [log] [blame]
/*
* Copyright 2019 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "modules/sksg/include/SkSGRenderEffect.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkMaskFilter.h"
#include "include/core/SkShader.h"
#include "src/core/SkMaskFilterBase.h"
namespace sksg {
sk_sp<MaskShaderEffect> MaskShaderEffect::Make(sk_sp<RenderNode> child, sk_sp<SkShader> sh) {
return child ? sk_sp<MaskShaderEffect>(new MaskShaderEffect(std::move(child), std::move(sh)))
: nullptr;
}
MaskShaderEffect::MaskShaderEffect(sk_sp<RenderNode> child, sk_sp<SkShader> sh)
: INHERITED(std::move(child))
, fShader(std::move(sh)) {
}
void MaskShaderEffect::onRender(SkCanvas* canvas, const RenderContext* ctx) const {
const auto local_ctx = ScopedRenderContext(canvas, ctx)
.modulateMaskShader(fShader, canvas->getTotalMatrix());
this->INHERITED::onRender(canvas, local_ctx);
}
sk_sp<ShaderEffect> ShaderEffect::Make(sk_sp<RenderNode> child, sk_sp<Shader> shader) {
return child ? sk_sp<ShaderEffect>(new ShaderEffect(std::move(child), std::move(shader)))
: nullptr;
}
ShaderEffect::ShaderEffect(sk_sp<RenderNode> child, sk_sp<Shader> shader)
: INHERITED(std::move(child))
, fShader(std::move(shader)) {
if (fShader) {
this->observeInval(fShader);
}
}
ShaderEffect::~ShaderEffect() {
if (fShader) {
this->unobserveInval(fShader);
}
}
void ShaderEffect::setShader(sk_sp<Shader> sh) {
if (fShader) {
this->unobserveInval(fShader);
}
fShader = std::move(sh);
if (fShader) {
this->observeInval(fShader);
}
}
SkRect ShaderEffect::onRevalidate(InvalidationController* ic, const SkMatrix& ctm) {
if (fShader) {
fShader->revalidate(ic, ctm);
}
return this->INHERITED::onRevalidate(ic, ctm);
}
void ShaderEffect::onRender(SkCanvas* canvas, const RenderContext* ctx) const {
const auto local_ctx = ScopedRenderContext(canvas, ctx)
.modulateShader(fShader ? fShader->getShader() : nullptr, canvas->getTotalMatrix());
this->INHERITED::onRender(canvas, local_ctx);
}
Shader::Shader() : INHERITED(kBubbleDamage_Trait) {}
Shader::~Shader() = default;
SkRect Shader::onRevalidate(InvalidationController*, const SkMatrix&) {
SkASSERT(this->hasInval());
fShader = this->onRevalidateShader();
return SkRect::MakeEmpty();
}
sk_sp<RenderNode> ImageFilterEffect::Make(sk_sp<RenderNode> child, sk_sp<ImageFilter> filter) {
return filter ? sk_sp<RenderNode>(new ImageFilterEffect(std::move(child), std::move(filter)))
: child;
}
ImageFilterEffect::ImageFilterEffect(sk_sp<RenderNode> child, sk_sp<ImageFilter> filter)
// filters always override descendent damage
: INHERITED(std::move(child), kOverrideDamage_Trait)
, fImageFilter(std::move(filter)) {
this->observeInval(fImageFilter);
}
ImageFilterEffect::~ImageFilterEffect() {
this->unobserveInval(fImageFilter);
}
SkRect ImageFilterEffect::onRevalidate(InvalidationController* ic, const SkMatrix& ctm) {
// FIXME: image filter effects should replace the descendents' damage!
fImageFilter->revalidate(ic, ctm);
const auto& filter = fImageFilter->getFilter();
// Would be nice for this this to stick, but canComputeFastBounds()
// appears to be conservative (false negatives).
// SkASSERT(!filter || filter->canComputeFastBounds());
const auto content_bounds = this->INHERITED::onRevalidate(ic, ctm);
return filter ? filter->computeFastBounds(content_bounds)
: content_bounds;
}
const RenderNode* ImageFilterEffect::onNodeAt(const SkPoint& p) const {
// TODO: map p through the filter DAG and dispatch to descendants?
// For now, image filters occlude hit-testing.
SkASSERT(this->bounds().contains(p.x(), p.y()));
return this;
}
void ImageFilterEffect::onRender(SkCanvas* canvas, const RenderContext* ctx) const {
// Note: we're using the source content bounds for saveLayer, not our local/filtered bounds.
const auto filter_ctx =
ScopedRenderContext(canvas, ctx).setFilterIsolation(this->getChild()->bounds(),
canvas->getTotalMatrix(),
fImageFilter->getFilter());
this->INHERITED::onRender(canvas, filter_ctx);
}
ImageFilter::ImageFilter(sk_sp<ImageFilter> input)
: ImageFilter(input ? std::make_unique<InputsT>(1, std::move(input)) : nullptr) {}
ImageFilter::ImageFilter(std::unique_ptr<InputsT> inputs)
: INHERITED(kBubbleDamage_Trait)
, fInputs(std::move(inputs)) {
if (fInputs) {
for (const auto& input : *fInputs) {
this->observeInval(input);
}
}
}
ImageFilter::~ImageFilter() {
if (fInputs) {
for (const auto& input : *fInputs) {
this->unobserveInval(input);
}
}
}
sk_sp<SkImageFilter> ImageFilter::refInput(size_t i) const {
return (fInputs && i < fInputs->size()) ? (*fInputs)[i]->getFilter() : nullptr;
}
SkRect ImageFilter::onRevalidate(InvalidationController*, const SkMatrix&) {
SkASSERT(this->hasInval());
fFilter = this->onRevalidateFilter();
return SkRect::MakeEmpty();
}
ExternalImageFilter:: ExternalImageFilter() = default;
ExternalImageFilter::~ExternalImageFilter() = default;
sk_sp<DropShadowImageFilter> DropShadowImageFilter::Make(sk_sp<ImageFilter> input) {
return sk_sp<DropShadowImageFilter>(new DropShadowImageFilter(std::move(input)));
}
DropShadowImageFilter::DropShadowImageFilter(sk_sp<ImageFilter> input)
: INHERITED(std::move(input)) {}
DropShadowImageFilter::~DropShadowImageFilter() = default;
sk_sp<SkImageFilter> DropShadowImageFilter::onRevalidateFilter() {
if (fMode == Mode::kShadowOnly) {
return SkImageFilters::DropShadowOnly(fOffset.x(), fOffset.y(), fSigma.x(), fSigma.y(),
fColor, this->refInput(0));
} else {
return SkImageFilters::DropShadow(fOffset.x(), fOffset.y(), fSigma.x(), fSigma.y(),
fColor, this->refInput(0));
}
}
sk_sp<BlurImageFilter> BlurImageFilter::Make(sk_sp<ImageFilter> input) {
return sk_sp<BlurImageFilter>(new BlurImageFilter(std::move(input)));
}
BlurImageFilter::BlurImageFilter(sk_sp<ImageFilter> input)
: INHERITED(std::move(input)) {}
BlurImageFilter::~BlurImageFilter() = default;
sk_sp<SkImageFilter> BlurImageFilter::onRevalidateFilter() {
return SkImageFilters::Blur(fSigma.x(), fSigma.y(), fTileMode, this->refInput(0));
}
sk_sp<BlendModeEffect> BlendModeEffect::Make(sk_sp<RenderNode> child, SkBlendMode mode) {
return child ? sk_sp<BlendModeEffect>(new BlendModeEffect(std::move(child), mode))
: nullptr;
}
BlendModeEffect::BlendModeEffect(sk_sp<RenderNode> child, SkBlendMode mode)
: INHERITED(std::move(child))
, fMode(mode) {}
BlendModeEffect::~BlendModeEffect() = default;
void BlendModeEffect::onRender(SkCanvas* canvas, const RenderContext* ctx) const {
const auto local_ctx = ScopedRenderContext(canvas, ctx).modulateBlendMode(fMode);
this->INHERITED::onRender(canvas, local_ctx);
}
const RenderNode* BlendModeEffect::onNodeAt(const SkPoint& p) const {
// TODO: we likely need to do something more sophisticated than delegate to descendants here.
return this->INHERITED::onNodeAt(p);
}
sk_sp<LayerEffect> LayerEffect::Make(sk_sp<RenderNode> child, SkBlendMode mode) {
return child ? sk_sp<LayerEffect>(new LayerEffect(std::move(child), mode))
: nullptr;
}
LayerEffect::LayerEffect(sk_sp<RenderNode> child, SkBlendMode mode)
: INHERITED(std::move(child))
, fMode(mode) {}
LayerEffect::~LayerEffect() = default;
void LayerEffect::onRender(SkCanvas* canvas, const RenderContext* ctx) const {
SkAutoCanvasRestore acr(canvas, false);
// Commit any potential pending paint effects to their own layer.
const auto local_ctx = ScopedRenderContext(canvas, ctx).setIsolation(this->bounds(),
canvas->getTotalMatrix(),
true);
SkPaint layer_paint;
if (ctx) {
// Apply all optional context overrides upfront.
ctx->modulatePaint(canvas->getTotalMatrix(), &layer_paint);
}
layer_paint.setBlendMode(fMode);
canvas->saveLayer(nullptr, &layer_paint);
this->INHERITED::onRender(canvas, nullptr);
}
} // namespace sksg