chromium/third_party/skia/modules/skottie/src/Skottie.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/skottie/include/Skottie.h"

#include "include/core/SkCanvas.h"
#include "include/core/SkData.h"
#include "include/core/SkFontMgr.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkRect.h"
#include "include/core/SkStream.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkFloatingPoint.h"
#include "include/private/base/SkTPin.h"
#include "include/private/base/SkTo.h"
#include "modules/skottie/include/ExternalLayer.h"
#include "modules/skottie/include/SkottieProperty.h"
#include "modules/skottie/include/SlotManager.h"
#include "modules/skottie/src/Adapter.h"
#include "modules/skottie/src/Composition.h"
#include "modules/skottie/src/SkottieJson.h"
#include "modules/skottie/src/SkottiePriv.h"
#include "modules/skottie/src/SkottieValue.h"
#include "modules/skottie/src/Transform.h"  // IWYU pragma: keep
#include "modules/skottie/src/animator/Animator.h"
#include "modules/skottie/src/text/TextAdapter.h"
#include "modules/sksg/include/SkSGOpacityEffect.h"
#include "modules/sksg/include/SkSGRenderNode.h"
#include "modules/skshaper/include/SkShaper_factory.h"
#include "src/core/SkTHash.h"
#include "src/core/SkTraceEvent.h"
#include "src/utils/SkJSON.h"

#include <algorithm>
#include <chrono>
#include <cmath>
#include <cstdarg>
#include <cstdio>
#include <cstring>
#include <functional>
#include <memory>
#include <ratio>
#include <utility>

#if !defined(SK_DISABLE_LEGACY_SHAPER_FACTORY)
#include "modules/skshaper/utils/FactoryHelpers.h"
#endif

namespace sksg {
class Color;
}

namespace skottie {

namespace internal {

void SceneGraphRevalidator::setRoot(sk_sp<sksg::RenderNode> root) { … }

void SceneGraphRevalidator::revalidate() { … }

void AnimationBuilder::log(Logger::Level lvl, const skjson::Value* json,
                           const char fmt[], ...) const { … }

class OpacityAdapter final : public DiscardableAdapterBase<OpacityAdapter, sksg::OpacityEffect> { … };


sk_sp<sksg::RenderNode> AnimationBuilder::attachOpacity(const skjson::ObjectValue& jobject,
                                                        sk_sp<sksg::RenderNode> child_node) const { … }

AnimationBuilder::AnimationBuilder(sk_sp<ResourceProvider> rp, sk_sp<SkFontMgr> fontmgr,
                                   sk_sp<PropertyObserver> pobserver, sk_sp<Logger> logger,
                                   sk_sp<MarkerObserver> mobserver, sk_sp<PrecompInterceptor> pi,
                                   sk_sp<ExpressionManager> expressionmgr,
                                   sk_sp<SkShapers::Factory> shapingFactory,
                                   Animation::Builder::Stats* stats,
                                   const SkSize& comp_size, float duration, float framerate,
                                   uint32_t flags)
    : … { … }

AnimationBuilder::AnimationInfo AnimationBuilder::parse(const skjson::ObjectValue& jroot) { … }

void AnimationBuilder::parseAssets(const skjson::ArrayValue* jassets) { … }

void AnimationBuilder::dispatchMarkers(const skjson::ArrayValue* jmarkers) const { … }

bool AnimationBuilder::dispatchColorProperty(const sk_sp<sksg::Color>& c) const { … }

bool AnimationBuilder::dispatchOpacityProperty(const sk_sp<sksg::OpacityEffect>& o) const { … }

bool AnimationBuilder::dispatchTextProperty(const sk_sp<TextAdapter>& t,
                                            const skjson::ObjectValue* jtext) const { … }

bool AnimationBuilder::dispatchTransformProperty(const sk_sp<TransformAdapter2D>& t) const { … }

sk_sp<ExpressionManager> AnimationBuilder::expression_manager() const { … }

void AnimationBuilder::AutoPropertyTracker::updateContext(PropertyObserver* observer,
                                                          const skjson::ObjectValue& obj) { … }

} // namespace internal

Animation::Builder::Builder(uint32_t flags) : … { … }
Animation::Builder::Builder(const Builder&) = default;
Animation::Builder::Builder(Builder&&) = default;
Animation::Builder::~Builder() = default;

Animation::Builder& Animation::Builder::setResourceProvider(sk_sp<ResourceProvider> rp) { … }

Animation::Builder& Animation::Builder::setFontManager(sk_sp<SkFontMgr> fmgr) { … }

Animation::Builder& Animation::Builder::setPropertyObserver(sk_sp<PropertyObserver> pobserver) { … }

Animation::Builder& Animation::Builder::setLogger(sk_sp<Logger> logger) { … }

Animation::Builder& Animation::Builder::setMarkerObserver(sk_sp<MarkerObserver> mobserver) { … }

Animation::Builder& Animation::Builder::setPrecompInterceptor(sk_sp<PrecompInterceptor> pi) { … }

Animation::Builder& Animation::Builder::setExpressionManager(sk_sp<ExpressionManager> em) { … }

Animation::Builder& Animation::Builder::setTextShapingFactory(sk_sp<SkShapers::Factory> factory) { … }

sk_sp<Animation> Animation::Builder::make(SkStream* stream) { … }

sk_sp<Animation> Animation::Builder::make(const char* data, size_t data_len) { … }

sk_sp<Animation> Animation::Builder::makeFromFile(const char path[]) { … }

Animation::Animation(sk_sp<sksg::RenderNode> scene_root,
                     std::vector<sk_sp<internal::Animator>>&& animators,
                     SkString version, const SkSize& size,
                     double inPoint, double outPoint, double duration, double fps, uint32_t flags)
    : … { … }

Animation::~Animation() = default;

void Animation::render(SkCanvas* canvas, const SkRect* dstR) const { … }

void Animation::render(SkCanvas* canvas, const SkRect* dstR, RenderFlags renderFlags) const { … }

void Animation::seekFrame(double t, sksg::InvalidationController* ic) { … }

void Animation::seekFrameTime(double t, sksg::InvalidationController* ic) { … }

sk_sp<Animation> Animation::Make(const char* data, size_t length) { … }

sk_sp<Animation> Animation::Make(SkStream* stream) { … }

sk_sp<Animation> Animation::MakeFromFile(const char path[]) { … }

} // namespace skottie