27 kInvisible_Flag = 1 << 0,
35 return !(fNodeFlags & kInvisible_Flag);
44 fNodeFlags = v ? (fNodeFlags & ~kInvisible_Flag)
45 : (fNodeFlags | kInvisible_Flag);
90 return shader->makeWithLocalMatrix(lm);
102 bool is_layer_paint)
const {
109 paint->setBlender(fBlender);
114 if (!is_layer_paint && fMaskShader) {
117 paint->refShader()));
124 , fRestoreCount(canvas->getSaveCount()) {}
127 if (fRestoreCount >= 0) {
131 mask_paint.
setShader(std::move(fMaskShader));
132 fCanvas->drawPaint(mask_paint);
134 fCanvas->restoreToCount(fRestoreCount);
140 SkASSERT(opacity >= 0 && opacity <= 1);
141 fCtx.fOpacity *= opacity;
142 return std::move(*
this);
148 return std::move(*
this);
155 fCtx.fShader = std::move(sh);
156 fCtx.fShaderCTM = shader_ctm;
159 return std::move(*
this);
164 if (fCtx.fMaskShader) {
172 if (ms && fCtx.fMaskCTM.invert(&invMaskCTM)) {
175 std::move(fCtx.fMaskShader),
176 ms->makeWithLocalMatrix(relative_transform));
179 fCtx.fMaskShader = std::move(ms);
183 return std::move(*
this);
188 fCtx.fBlender = std::move(blender);
189 return std::move(*
this);
195 if (isolation && fCtx.requiresIsolation()) {
197 fCtx.modulatePaint(ctm, &layer_paint,
true);
198 fCanvas->saveLayer(
bounds, &layer_paint);
201 if (fCtx.fMaskShader) {
202 fMaskShader =
LocalShader(fCtx.fMaskShader, fCtx.fMaskCTM, ctm);
206 fCtx.fColorFilter =
nullptr;
207 fCtx.fMaskShader =
nullptr;
208 fCtx.fBlender =
nullptr;
212 return std::move(*
this);
220 fCtx.modulatePaint(ctm, &layer_paint);
224 fCanvas->saveLayer(
bounds, &layer_paint);
228 return std::move(*
this);
233 , fChildren(
std::move(children)) {
234 for (
const auto& child : fChildren) {
240 for (
const auto& child : fChildren) {
246 for (
const auto& child : fChildren) {
constexpr SkAlpha SK_AlphaOPAQUE
#define sk_float_round2int(x)
constexpr uint8_t SkToU8(S x)
static sk_sp< SkColorFilter > Compose(const sk_sp< SkColorFilter > &outer, sk_sp< SkColorFilter > inner)
static SkMatrix Concat(const SkMatrix &a, const SkMatrix &b)
bool invert(SkMatrix *inverse) const
static const SkMatrix & I()
SkMatrix & preConcat(const SkMatrix &other)
void setImageFilter(sk_sp< SkImageFilter > imageFilter)
void setShader(sk_sp< SkShader > shader)
void setBlendMode(SkBlendMode mode)
SkImageFilter * getImageFilter() const
~CustomRenderNode() override
bool hasChildrenInval() const
CustomRenderNode(std::vector< sk_sp< RenderNode > > &&children)
static bool HasInval(const sk_sp< Node > &node)
void observeInval(const sk_sp< Node > &)
void unobserveInval(const sk_sp< Node > &)
const SkRect & bounds() const
void invalidate(bool damage=true)
ScopedRenderContext && setFilterIsolation(const SkRect &bounds, const SkMatrix &ctm, sk_sp< SkImageFilter >)
ScopedRenderContext && modulateOpacity(float opacity)
ScopedRenderContext && modulateMaskShader(sk_sp< SkShader >, const SkMatrix &ms_ctm)
ScopedRenderContext && setIsolation(const SkRect &bounds, const SkMatrix &ctm, bool do_isolate)
ScopedRenderContext(SkCanvas *, const RenderContext *)
ScopedRenderContext && modulateColorFilter(sk_sp< SkColorFilter >)
ScopedRenderContext && modulateBlender(sk_sp< SkBlender >)
ScopedRenderContext && modulateShader(sk_sp< SkShader >, const SkMatrix &shader_ctm)
void render(SkCanvas *, const RenderContext *=nullptr) const
virtual const RenderNode * onNodeAt(const SkPoint &p) const =0
const RenderNode * nodeAt(const SkPoint &point) const
virtual void onRender(SkCanvas *, const RenderContext *) const =0
static sk_sp< SkShader > LocalShader(const sk_sp< SkShader > &shader, const SkMatrix &base, const SkMatrix &ctm)
static SkAlpha ScaleAlpha(SkAlpha alpha, float opacity)
constexpr float x() const
bool contains(SkScalar x, SkScalar y) const
sk_sp< SkBlender > fBlender
sk_sp< SkColorFilter > fColorFilter
void modulatePaint(const SkMatrix &ctm, SkPaint *, bool is_layer_paint=false) const
bool requiresIsolation() const
sk_sp< SkShader > fMaskShader