SkSGRenderEffect.h

Go to the documentation of this file.

/*
 * Copyright 2019 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
#ifndef SkSGRenderEffect_DEFINED
#define SkSGRenderEffect_DEFINED
 
#include "include/core/SkBlendMode.h"
#include "include/core/SkBlender.h"
#include "include/core/SkColor.h"
#include "include/core/SkImageFilter.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkShader.h"
#include "include/core/SkTileMode.h"
#include "include/effects/SkImageFilters.h"
#include "include/private/base/SkAssert.h"
#include "include/private/base/SkPoint_impl.h"
#include "modules/sksg/include/SkSGEffectNode.h"
#include "modules/sksg/include/SkSGNode.h"
 
#include <optional>
 
class SkCanvas;
class SkMatrix;
 
// TODO: merge EffectNode.h with this header
 
namespace sksg {
class InvalidationController;
class RenderNode;
 
/**
 * Shader base class.
 */
class Shader : public Node {
public:
    ~Shader() override;
 
    const sk_sp<SkShader>& getShader() const {
        SkASSERT(!this->hasInval());
        return fShader;
    }
 
protected:
    Shader();
 
    SkRect onRevalidate(InvalidationController*, const SkMatrix&) final;
 
    virtual sk_sp<SkShader> onRevalidateShader() = 0;
 
private:
    sk_sp<SkShader> fShader;
 
    using INHERITED = Node;
};
 
/**
 * Attaches a shader to the render DAG.
 */
class ShaderEffect final : public EffectNode {
public:
    ~ShaderEffect() override;
 
    static sk_sp<ShaderEffect> Make(sk_sp<RenderNode> child, sk_sp<Shader> shader = nullptr);
 
    void setShader(sk_sp<Shader>);
 
protected:
    void onRender(SkCanvas*, const RenderContext*) const override;
 
    SkRect onRevalidate(InvalidationController*, const SkMatrix&) override;
 
private:
    ShaderEffect(sk_sp<RenderNode> child, sk_sp<Shader> shader);
 
    sk_sp<Shader> fShader;
 
    using INHERITED = EffectNode;
};
 
/**
 * Attaches a mask shader to the render DAG.
 */
class MaskShaderEffect final : public EffectNode {
public:
    static sk_sp<MaskShaderEffect> Make(sk_sp<RenderNode>, sk_sp<SkShader> = nullptr);
 
    SG_ATTRIBUTE(Shader, sk_sp<SkShader>, fShader)
 
protected:
    void onRender(SkCanvas*, const RenderContext*) const override;
 
private:
    MaskShaderEffect(sk_sp<RenderNode>, sk_sp<SkShader>);
 
    sk_sp<SkShader> fShader;
 
    using INHERITED = EffectNode;
};
 
/**
 * ImageFilter base class.
 */
class ImageFilter : public Node {
public:
    ~ImageFilter() override;
 
    const sk_sp<SkImageFilter>& getFilter() const {
        SkASSERT(!this->hasInval());
        return fFilter;
    }
 
    SG_ATTRIBUTE(CropRect, SkImageFilters::CropRect, fCropRect)
 
protected:
    ImageFilter();
 
    SkRect onRevalidate(InvalidationController*, const SkMatrix&) final;
 
    virtual sk_sp<SkImageFilter> onRevalidateFilter() = 0;
 
private:
    sk_sp<SkImageFilter>     fFilter;
    SkImageFilters::CropRect fCropRect = std::nullopt;
 
    using INHERITED = Node;
};
 
/**
 * Attaches an ImageFilter (chain) to the render DAG.
 */
class ImageFilterEffect final : public EffectNode {
public:
    ~ImageFilterEffect() override;
 
    static sk_sp<RenderNode> Make(sk_sp<RenderNode> child, sk_sp<ImageFilter> filter);
 
    enum class Cropping {
        kNone,    // Doesn't use a crop rect.
        kContent, // Uses the content bounding box as a crop rect.
    };
 
    SG_ATTRIBUTE(Cropping, Cropping, fCropping)
 
protected:
    void onRender(SkCanvas*, const RenderContext*) const override;
    const RenderNode* onNodeAt(const SkPoint&)     const override;
 
    SkRect onRevalidate(InvalidationController*, const SkMatrix&) override;
 
private:
    ImageFilterEffect(sk_sp<RenderNode> child, sk_sp<ImageFilter> filter);
 
    sk_sp<ImageFilter> fImageFilter;
    Cropping           fCropping = Cropping::kNone;
 
    using INHERITED = EffectNode;
};
 
/**
 * Wrapper for externally-managed SkImageFilters.
 */
class ExternalImageFilter final : public ImageFilter {
public:
    ~ExternalImageFilter() override;
 
    static sk_sp<ExternalImageFilter> Make() {
        return sk_sp<ExternalImageFilter>(new ExternalImageFilter());
    }
 
    SG_ATTRIBUTE(ImageFilter, sk_sp<SkImageFilter>, fImageFilter)
 
private:
    ExternalImageFilter();
 
    sk_sp<SkImageFilter> onRevalidateFilter() override { return fImageFilter; }
 
    sk_sp<SkImageFilter> fImageFilter;
};
 
/**
 * SkDropShadowImageFilter node.
 */
class DropShadowImageFilter final : public ImageFilter {
public:
    ~DropShadowImageFilter() override;
 
    static sk_sp<DropShadowImageFilter> Make();
 
    enum class Mode { kShadowAndForeground, kShadowOnly };
 
    SG_ATTRIBUTE(Offset, SkVector, fOffset)
    SG_ATTRIBUTE(Sigma , SkVector, fSigma )
    SG_ATTRIBUTE(Color , SkColor , fColor )
    SG_ATTRIBUTE(Mode  , Mode    , fMode  )
 
protected:
    sk_sp<SkImageFilter> onRevalidateFilter() override;
 
private:
    explicit DropShadowImageFilter();
 
    SkVector             fOffset = { 0, 0 },
                         fSigma  = { 0, 0 };
    SkColor              fColor  = SK_ColorBLACK;
    Mode                 fMode   = Mode::kShadowAndForeground;
 
    using INHERITED = ImageFilter;
};
 
/**
 * SkBlurImageFilter node.
 */
class BlurImageFilter final : public ImageFilter {
public:
    ~BlurImageFilter() override;
 
    static sk_sp<BlurImageFilter> Make();
 
    SG_ATTRIBUTE(Sigma   , SkVector  , fSigma   )
    SG_ATTRIBUTE(TileMode, SkTileMode, fTileMode)
 
protected:
    sk_sp<SkImageFilter> onRevalidateFilter() override;
 
private:
    explicit BlurImageFilter();
 
    SkVector   fSigma    = { 0, 0 };
    SkTileMode fTileMode = SkTileMode::kDecal;
 
    using INHERITED = ImageFilter;
};
 
/**
 * Applies an SkBlender to descendant render nodes.
 */
class BlenderEffect final : public EffectNode {
public:
    ~BlenderEffect() override;
 
    static sk_sp<BlenderEffect> Make(sk_sp<RenderNode> child, sk_sp<SkBlender> = nullptr);
 
    SG_ATTRIBUTE(Blender, sk_sp<SkBlender>, fBlender)
 
protected:
    void onRender(SkCanvas*, const RenderContext*) const override;
    const RenderNode* onNodeAt(const SkPoint&)     const override;
 
private:
    BlenderEffect(sk_sp<RenderNode>, sk_sp<SkBlender>);
 
    sk_sp<SkBlender> fBlender;
 
    using INHERITED = EffectNode;
};
 
class LayerEffect final : public EffectNode {
public:
    ~LayerEffect() override;
 
    static sk_sp<LayerEffect> Make(sk_sp<RenderNode> child,
                                   SkBlendMode mode = SkBlendMode::kSrcOver);
 
    SG_ATTRIBUTE(Mode, SkBlendMode, fMode)
 
private:
    LayerEffect(sk_sp<RenderNode> child, SkBlendMode mode);
 
    void onRender(SkCanvas*, const RenderContext*) const override;
 
    SkBlendMode fMode;
 
    using INHERITED = EffectNode;
};
 
} // namespace sksg
 
#endif // SkSGRenderEffect_DEFINED