1 /* 2 * Copyright 2018 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #ifndef SkSGColorFilter_DEFINED 9 #define SkSGColorFilter_DEFINED 10 11 #include "include/core/SkColorFilter.h" 12 #include "include/core/SkRect.h" 13 #include "include/core/SkRefCnt.h" 14 #include "modules/sksg/include/SkSGEffectNode.h" 15 #include "modules/sksg/include/SkSGNode.h" 16 17 #include <vector> 18 19 class SkCanvas; 20 class SkMatrix; 21 enum class SkBlendMode; 22 struct SkPoint; 23 24 namespace sksg { 25 26 class Color; 27 class InvalidationController; 28 class RenderNode; 29 30 /** 31 * Base class for nodes which apply a color filter when rendering their descendants. 32 */ 33 class ColorFilter : public EffectNode { 34 protected: 35 explicit ColorFilter(sk_sp<RenderNode>); 36 37 void onRender(SkCanvas*, const RenderContext*) const final; 38 const RenderNode* onNodeAt(const SkPoint&) const final; 39 40 SkRect onRevalidate(InvalidationController*, const SkMatrix&) final; 41 42 virtual sk_sp<SkColorFilter> onRevalidateFilter() = 0; 43 44 private: 45 sk_sp<SkColorFilter> fColorFilter; 46 47 using INHERITED = EffectNode; 48 }; 49 50 /** 51 * Wrapper for externally-managed SkColorFilters. 52 * 53 * Allows attaching non-sksg color filters to the render tree. 54 */ 55 class ExternalColorFilter final : public EffectNode { 56 public: 57 static sk_sp<ExternalColorFilter> Make(sk_sp<RenderNode> child); 58 59 ~ExternalColorFilter() override; 60 61 enum class Coverage { 62 kNormal, // the effect applies to the regular content coverage 63 kBoundingBox, // the effect applies to the full content bounding box 64 }; 65 66 SG_ATTRIBUTE(ColorFilter, sk_sp<SkColorFilter>, fColorFilter) 67 SG_ATTRIBUTE(Coverage , Coverage , fCoverage ) 68 69 protected: 70 void onRender(SkCanvas*, const RenderContext*) const override; 71 72 private: 73 explicit ExternalColorFilter(sk_sp<RenderNode>); 74 75 sk_sp<SkColorFilter> fColorFilter; 76 Coverage fCoverage = Coverage::kNormal; 77 78 using INHERITED = EffectNode; 79 }; 80 81 /** 82 * Concrete SkBlendModeColorFilter Effect node. 83 */ 84 class ModeColorFilter final : public ColorFilter { 85 public: 86 ~ModeColorFilter() override; 87 88 static sk_sp<ModeColorFilter> Make(sk_sp<RenderNode> child, 89 sk_sp<Color> color, 90 SkBlendMode mode); 91 92 protected: 93 sk_sp<SkColorFilter> onRevalidateFilter() override; 94 95 private: 96 ModeColorFilter(sk_sp<RenderNode>, sk_sp<Color>, SkBlendMode); 97 98 const sk_sp<Color> fColor; 99 const SkBlendMode fMode; 100 101 using INHERITED = ColorFilter; 102 }; 103 104 /** 105 * Tint/multi-tone color effect: maps RGB colors to the [C0,C1][C1,C2]..[Cn-1,Cn] gradient 106 * based on input luminance (where the colors are evenly distributed across the luminance domain), 107 * then mixes with the input based on weight. Leaves alpha unchanged. 108 */ 109 class GradientColorFilter final : public ColorFilter { 110 public: 111 ~GradientColorFilter() override; 112 113 static sk_sp<GradientColorFilter> Make(sk_sp<RenderNode> child, 114 sk_sp<Color> c0, sk_sp<Color> c1); 115 static sk_sp<GradientColorFilter> Make(sk_sp<RenderNode> child, 116 std::vector<sk_sp<Color>>); 117 118 SG_ATTRIBUTE(Weight, float, fWeight) 119 120 protected: 121 sk_sp<SkColorFilter> onRevalidateFilter() override; 122 123 private: 124 GradientColorFilter(sk_sp<RenderNode>, std::vector<sk_sp<Color>>); 125 126 const std::vector<sk_sp<Color>> fColors; 127 128 float fWeight = 0; 129 130 using INHERITED = ColorFilter; 131 }; 132 133 } // namespace sksg 134 135 #endif // SkSGColorFilter_DEFINED 136