chromium/third_party/skia/modules/sksg/src/SkSGRenderEffect.cpp

/*
 * 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/SkBlender.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkPaint.h"
#include "include/core/SkShader.h"
#include "include/core/SkTileMode.h"
#include "include/effects/SkImageFilters.h"
#include "modules/sksg/include/SkSGRenderNode.h"

#include <utility>

class SkMatrix;

namespace sksg {

sk_sp<MaskShaderEffect> MaskShaderEffect::Make(sk_sp<RenderNode> child, sk_sp<SkShader> sh) { … }

MaskShaderEffect::MaskShaderEffect(sk_sp<RenderNode> child, sk_sp<SkShader> sh)
    : … { … }

void MaskShaderEffect::onRender(SkCanvas* canvas, const RenderContext* ctx) const { … }

sk_sp<ShaderEffect> ShaderEffect::Make(sk_sp<RenderNode> child, sk_sp<Shader> shader) { … }

ShaderEffect::ShaderEffect(sk_sp<RenderNode> child, sk_sp<Shader> shader)
    : … { … }

ShaderEffect::~ShaderEffect() { … }

void ShaderEffect::setShader(sk_sp<Shader> sh) { … }
SkRect ShaderEffect::onRevalidate(InvalidationController* ic, const SkMatrix& ctm) { … }

void ShaderEffect::onRender(SkCanvas* canvas, const RenderContext* ctx) const { … }

Shader::Shader() : … { … }

Shader::~Shader() = default;

SkRect Shader::onRevalidate(InvalidationController*, const SkMatrix&) { … }

sk_sp<RenderNode> ImageFilterEffect::Make(sk_sp<RenderNode> child, sk_sp<ImageFilter> filter) { … }

ImageFilterEffect::ImageFilterEffect(sk_sp<RenderNode> child, sk_sp<ImageFilter> filter)
    // filters always override descendent damage
    : … { … }

ImageFilterEffect::~ImageFilterEffect() { … }

SkRect ImageFilterEffect::onRevalidate(InvalidationController* ic, const SkMatrix& ctm) { … }

const RenderNode* ImageFilterEffect::onNodeAt(const SkPoint& p) const { … }

void ImageFilterEffect::onRender(SkCanvas* canvas, const RenderContext* ctx) const { … }

ImageFilter::ImageFilter() : … { … }

ImageFilter::~ImageFilter() = default;

SkRect ImageFilter::onRevalidate(InvalidationController*, const SkMatrix&) { … }

ExternalImageFilter:: ExternalImageFilter() = default;
ExternalImageFilter::~ExternalImageFilter() = default;

sk_sp<DropShadowImageFilter> DropShadowImageFilter::Make() { … }

DropShadowImageFilter::DropShadowImageFilter()
    : … { … }

DropShadowImageFilter::~DropShadowImageFilter() = default;

sk_sp<SkImageFilter> DropShadowImageFilter::onRevalidateFilter() { … }

sk_sp<BlurImageFilter> BlurImageFilter::Make() { … }

BlurImageFilter::BlurImageFilter()
    : … { … }

BlurImageFilter::~BlurImageFilter() = default;

sk_sp<SkImageFilter> BlurImageFilter::onRevalidateFilter() { … }

sk_sp<BlenderEffect> BlenderEffect::Make(sk_sp<RenderNode> child, sk_sp<SkBlender> blender) { … }

BlenderEffect::BlenderEffect(sk_sp<RenderNode> child, sk_sp<SkBlender> blender)
    : … { … }

BlenderEffect::~BlenderEffect() = default;

void BlenderEffect::onRender(SkCanvas* canvas, const RenderContext* ctx) const { … }

const RenderNode* BlenderEffect::onNodeAt(const SkPoint& p) const { … }

sk_sp<LayerEffect> LayerEffect::Make(sk_sp<RenderNode> child, SkBlendMode mode) { … }

LayerEffect::LayerEffect(sk_sp<RenderNode> child, SkBlendMode mode)
    : … { … }

LayerEffect::~LayerEffect() = default;

void LayerEffect::onRender(SkCanvas* canvas, const RenderContext* ctx) const { … }

} // namespace sksg