skia2/modules/sksg/include/SkSGRenderEffect.h
Mike Klein c0bd9f9fe5 rewrite includes to not need so much -Ifoo
Current strategy: everything from the top

Things to look at first are the manual changes:

   - added tools/rewrite_includes.py
   - removed -Idirectives from BUILD.gn
   - various compile.sh simplifications
   - tweak tools/embed_resources.py
   - update gn/find_headers.py to write paths from the top
   - update gn/gn_to_bp.py SkUserConfig.h layout
     so that #include "include/config/SkUserConfig.h" always
     gets the header we want.

No-Presubmit: true
Change-Id: I73a4b181654e0e38d229bc456c0d0854bae3363e
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/209706
Commit-Queue: Mike Klein <mtklein@google.com>
Reviewed-by: Hal Canary <halcanary@google.com>
Reviewed-by: Brian Osman <brianosman@google.com>
Reviewed-by: Florin Malita <fmalita@chromium.org>
2019-04-24 16:27:11 +00:00

212 lines
4.9 KiB
C++

/*
* 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 "modules/sksg/include/SkSGEffectNode.h"
#include "include/core/SkBlendMode.h"
#include "include/core/SkColor.h"
#include "include/effects/SkBlurImageFilter.h"
#include <memory>
#include <vector>
// TODO: merge EffectNode.h with this header
class SkImageFilter;
class SkShader;
namespace sksg {
/**
* 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 = 0);
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;
};
/**
* ImageFilter base class.
*/
class ImageFilter : public Node {
public:
~ImageFilter() override;
const sk_sp<SkImageFilter>& getFilter() const {
SkASSERT(!this->hasInval());
return fFilter;
}
protected:
explicit ImageFilter(sk_sp<ImageFilter> input = 0);
using InputsT = std::vector<sk_sp<ImageFilter>>;
explicit ImageFilter(std::unique_ptr<InputsT> inputs);
SkRect onRevalidate(InvalidationController*, const SkMatrix&) final;
virtual sk_sp<SkImageFilter> onRevalidateFilter() = 0;
sk_sp<SkImageFilter> refInput(size_t) const;
private:
const std::unique_ptr<InputsT> fInputs;
sk_sp<SkImageFilter> fFilter;
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);
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;
using INHERITED = EffectNode;
};
/**
* SkDropShadowImageFilter node.
*/
class DropShadowImageFilter final : public ImageFilter {
public:
~DropShadowImageFilter() override;
static sk_sp<DropShadowImageFilter> Make(sk_sp<ImageFilter> input = nullptr);
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(sk_sp<ImageFilter> input);
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(sk_sp<ImageFilter> input = nullptr);
SG_ATTRIBUTE(Sigma , SkVector , fSigma )
SG_ATTRIBUTE(TileMode, SkBlurImageFilter::TileMode, fTileMode)
protected:
sk_sp<SkImageFilter> onRevalidateFilter() override;
private:
explicit BlurImageFilter(sk_sp<ImageFilter> input);
SkVector fSigma = { 0, 0 };
SkBlurImageFilter::TileMode fTileMode = SkBlurImageFilter::kClamp_TileMode;
using INHERITED = ImageFilter;
};
/**
* Applies a SkBlendMode to descendant render nodes.
*/
class BlendModeEffect final : public EffectNode {
public:
~BlendModeEffect() override;
static sk_sp<BlendModeEffect> Make(sk_sp<RenderNode> child,
SkBlendMode = SkBlendMode::kSrcOver);
SG_ATTRIBUTE(Mode, SkBlendMode, fMode)
protected:
void onRender(SkCanvas*, const RenderContext*) const override;
const RenderNode* onNodeAt(const SkPoint&) const override;
private:
BlendModeEffect(sk_sp<RenderNode>, SkBlendMode);
SkBlendMode fMode;
using INHERITED = EffectNode;
};
} // namespace sksg
#endif // SkSGRenderEffect_DEFINED