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

/*
 * Copyright 2017 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/SkSGRenderNode.h"

#include "include/core/SkBlendMode.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkImageFilter.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/effects/SkImageFilters.h"
#include "include/private/base/SkAssert.h"
#include "include/private/base/SkFloatingPoint.h"
#include "include/private/base/SkTo.h"
#include "modules/sksg/src/SkSGNodePriv.h"

namespace sksg {

namespace {

enum Flags : uint8_t { … };

} // namespace

RenderNode::RenderNode(uint32_t inval_traits) : … { … }

bool RenderNode::isVisible() const { … }

void RenderNode::setVisible(bool v) { … }

void RenderNode::render(SkCanvas* canvas, const RenderContext* ctx) const { … }

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

static SkAlpha ScaleAlpha(SkAlpha alpha, float opacity) { … }

static sk_sp<SkShader> LocalShader(const sk_sp<SkShader>& shader,
                                   const SkMatrix& base,
                                   const SkMatrix& ctm) { … }

bool RenderNode::RenderContext::requiresIsolation() const { … }

void RenderNode::RenderContext::modulatePaint(const SkMatrix& ctm, SkPaint* paint,
                                              bool is_layer_paint) const { … }

RenderNode::ScopedRenderContext::ScopedRenderContext(SkCanvas* canvas, const RenderContext* ctx)
    : … { … }

RenderNode::ScopedRenderContext::~ScopedRenderContext() { … }

RenderNode::ScopedRenderContext&&
RenderNode::ScopedRenderContext::modulateOpacity(float opacity) { … }

RenderNode::ScopedRenderContext&&
RenderNode::ScopedRenderContext::modulateColorFilter(sk_sp<SkColorFilter> cf) { … }

RenderNode::ScopedRenderContext&&
RenderNode::ScopedRenderContext::modulateShader(sk_sp<SkShader> sh, const SkMatrix& shader_ctm) { … }

RenderNode::ScopedRenderContext&&
RenderNode::ScopedRenderContext::modulateMaskShader(sk_sp<SkShader> ms, const SkMatrix& ctm) { … }

RenderNode::ScopedRenderContext&&
RenderNode::ScopedRenderContext::modulateBlender(sk_sp<SkBlender> blender) { … }

RenderNode::ScopedRenderContext&&
RenderNode::ScopedRenderContext::setIsolation(const SkRect& bounds, const SkMatrix& ctm,
                                              bool isolation) { … }

RenderNode::ScopedRenderContext&&
RenderNode::ScopedRenderContext::setFilterIsolation(const SkRect& bounds, const SkMatrix& ctm,
                                                    sk_sp<SkImageFilter> filter) { … }

CustomRenderNode::CustomRenderNode(std::vector<sk_sp<RenderNode>>&& children)
    : … { … }

CustomRenderNode::~CustomRenderNode() { … }

bool CustomRenderNode::hasChildrenInval() const { … }

} // namespace sksg