#include <SkottiePriv.h>

Inheritance diagram for skottie::internal::AnimationBuilder:

Classes
struct	AnimationInfo

struct	AttachShapeContext

class	AutoPropertyTracker

class	AutoScope

struct	FontInfo

Public Member Functions
	AnimationBuilder (sk_sp< ResourceProvider >, sk_sp< SkFontMgr >, sk_sp< PropertyObserver >, sk_sp< Logger >, sk_sp< MarkerObserver >, sk_sp< PrecompInterceptor >, sk_sp< ExpressionManager >, sk_sp< SkShapers::Factory >, Animation::Builder::Stats *, const SkSize &comp_size, float duration, float framerate, uint32_t flags)

AnimationInfo	parse (const skjson::ObjectValue &)

const FontInfo *	findFont (const SkString &name) const

void	log (Logger::Level, const skjson::Value *, const char fmt[],...) const SK_PRINTF_LIKE(4

void sk_sp< sksg::Transform >	attachMatrix2D (const skjson::ObjectValue &, sk_sp< sksg::Transform >, bool auto_orient=false) const

sk_sp< sksg::Transform >	attachMatrix3D (const skjson::ObjectValue &, sk_sp< sksg::Transform >, bool auto_orient=false) const

sk_sp< sksg::Transform >	attachCamera (const skjson::ObjectValue &jlayer, const skjson::ObjectValue &jtransform, sk_sp< sksg::Transform >, const SkSize &) const

sk_sp< sksg::RenderNode >	attachOpacity (const skjson::ObjectValue &, sk_sp< sksg::RenderNode >) const

sk_sp< sksg::Path >	attachPath (const skjson::Value &) const

bool	hasNontrivialBlending () const

template<typename T >
void	attachDiscardableAdapter (sk_sp< T > adapter) const

template<typename T , typename... Args>
auto	attachDiscardableAdapter (Args &&... args) const -> typename std::decay< decltype(T::Make(std::forward< Args >(args)...) ->node())>::type

bool	dispatchColorProperty (const sk_sp< sksg::Color > &) const

bool	dispatchOpacityProperty (const sk_sp< sksg::OpacityEffect > &) const

bool	dispatchTextProperty (const sk_sp< TextAdapter > &, const skjson::ObjectValue *jtext) const

bool	dispatchTransformProperty (const sk_sp< TransformAdapter2D > &) const

sk_sp< ExpressionManager >	expression_manager () const

const skjson::ObjectValue *	getSlotsRoot () const

void	parseFonts (const skjson::ObjectValue jfonts, const skjson::ArrayValue jchars)

Public Member Functions inherited from SkNoncopyable
	SkNoncopyable ()=default

	SkNoncopyable (SkNoncopyable &&)=default

SkNoncopyable &	operator= (SkNoncopyable &&)=default

Friends
class	CompositionBuilder

class	CustomFont

class	LayerBuilder

class	AnimatablePropertyContainer

Detailed Description

Definition at line 66 of file SkottiePriv.h.

Constructor & Destructor Documentation

◆ AnimationBuilder()

skottie::internal::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
	)

Definition at line 140 of file Skottie.cpp.

    : fResourceProvider(std::move(rp))
    , fFontMgr(std::move(fontmgr))
    , fPropertyObserver(std::move(pobserver))
    , fLogger(std::move(logger))
    , fMarkerObserver(std::move(mobserver))
    , fPrecompInterceptor(std::move(pi))
    , fExpressionManager(std::move(expressionmgr))
    , fShapingFactory(std::move(shapingFactory))
    , fRevalidator(sk_make_sp<SceneGraphRevalidator>())
    , fSlotManager(sk_make_sp<SlotManager>(fRevalidator))
    , fStats(stats)
    , fCompSize(comp_size)
    , fDuration(duration)
    , fFrameRate(framerate)
    , fFlags(flags)
    , fHasNontrivialBlending(false) {}

Member Function Documentation

◆ attachCamera()

sk_sp< sksg::Transform > skottie::internal::AnimationBuilder::attachCamera	(	const skjson::ObjectValue &	jlayer,
		const skjson::ObjectValue &	jtransform,
		sk_sp< sksg::Transform >	parent,
		const SkSize &	viewport_size
	)		const

Definition at line 124 of file Camera.cpp.

                                                                                         {
    auto adapter = sk_make_sp<CameraAdaper>(jlayer, jtransform, *this, viewport_size);
 
    if (adapter->isStatic()) {
        adapter->seek(0);
    } else {
        fCurrentAnimatorScope->push_back(adapter);
    }
 
    return sksg::Transform::MakeConcat(adapter->node(), std::move(parent));
}

◆ attachDiscardableAdapter() [1/2]

template<typename T , typename... Args>

auto skottie::internal::AnimationBuilder::attachDiscardableAdapter ( Args &&... args ) const -> typename std::decay<decltype(T::Make(std::forward<Args>(args)...)->node())>::type

inline

Definition at line 149 of file SkottiePriv.h.

    {
        using NodeType =
        typename std::decay<decltype(T::Make(std::forward<Args>(args)...)->node())>::type;
 
        NodeType node;
        if (auto adapter = T::Make(std::forward<Args>(args)...)) {
            node = adapter->node();
            this->attachDiscardableAdapter(std::move(adapter));
        }
        return node;
    }

◆ attachDiscardableAdapter() [2/2]

template<typename T >

void skottie::internal::AnimationBuilder::attachDiscardableAdapter ( sk_sp< T > adapter ) const

inline

Definition at line 139 of file SkottiePriv.h.

                                                          {
        if (adapter->isStatic()) {
            // Fire off a synthetic tick to force a single SG sync before discarding.
            adapter->seek(0);
        } else {
            fCurrentAnimatorScope->push_back(std::move(adapter));
        }
    }

◆ attachMatrix2D()

sk_sp< sksg::Transform > skottie::internal::AnimationBuilder::attachMatrix2D	(	const skjson::ObjectValue &	jtransform,
		sk_sp< sksg::Transform >	parent,
		bool	auto_orient = `false`
	)		const

Definition at line 114 of file Transform.cpp.

                                                                                {
    const auto* jrotation = &jtransform["r"];
    if (jrotation->is<skjson::NullValue>()) {
        // Some 2D rotations are disguised as 3D...
        jrotation = &jtransform["rz"];
    }
 
    auto adapter = TransformAdapter2D::Make(*this,
                                            jtransform["a"],
                                            jtransform["p"],
                                            jtransform["s"],
                                            *jrotation,
                                            jtransform["sk"],
                                            jtransform["sa"],
                                            auto_orient);
    SkASSERT(adapter);
 
    const auto dispatched = this->dispatchTransformProperty(adapter);
 
    if (adapter->isStatic()) {
        if (!dispatched && adapter->totalMatrix().isIdentity()) {
            // The transform has no observable effects - we can discard.
            return parent;
        }
        adapter->seek(0);
    } else {
        fCurrentAnimatorScope->push_back(adapter);
    }
 
    return sksg::Transform::MakeConcat(std::move(parent), adapter->node());
}

◆ attachMatrix3D()

sk_sp< sksg::Transform > skottie::internal::AnimationBuilder::attachMatrix3D	(	const skjson::ObjectValue &	jtransform,
		sk_sp< sksg::Transform >	parent,
		bool	auto_orient = `false`
	)		const

Definition at line 197 of file Transform.cpp.

                                                                      {
    auto adapter = TransformAdapter3D::Make(jtransform, *this);
    SkASSERT(adapter);
 
    if (adapter->isStatic()) {
        // TODO: SkM44::isIdentity?
        if (adapter->totalMatrix() == SkM44()) {
            // The transform has no observable effects - we can discard.
            return parent;
        }
        adapter->seek(0);
    } else {
        fCurrentAnimatorScope->push_back(adapter);
    }
 
    return sksg::Transform::MakeConcat(std::move(parent), adapter->node());
}

◆ attachOpacity()

sk_sp< sksg::RenderNode > skottie::internal::AnimationBuilder::attachOpacity	(	const skjson::ObjectValue &	jobject,
		sk_sp< sksg::RenderNode >	child_node
	)		const

Definition at line 118 of file Skottie.cpp.

                                                                                                {
    if (!child_node)
        return nullptr;
 
    auto adapter = OpacityAdapter::Make(jobject, child_node, *this);
    if (adapter->isStatic()) {
        adapter->seek(0);
    }
    auto dispatched = this->dispatchOpacityProperty(adapter->node());
    if (adapter->isStatic()) {
        if (!dispatched && adapter->node()->getOpacity() >= 1) {
            // No obeservable effects - we can discard.
            return child_node;
        }
    } else {
        fCurrentAnimatorScope->push_back(adapter);
    }
 
    return adapter->node();
}

◆ attachPath()

sk_sp< sksg::Path > skottie::internal::AnimationBuilder::attachPath ( const skjson::Value & jpath ) const

Definition at line 50 of file Path.cpp.

                                                                           {
    return this->attachDiscardableAdapter<PathAdapter>(jpath, *this);
}

◆ dispatchColorProperty()

bool skottie::internal::AnimationBuilder::dispatchColorProperty ( const sk_sp< sksg::Color > & c ) const

Definition at line 228 of file Skottie.cpp.

                                                                            {
    bool dispatched = false;
    if (fPropertyObserver) {
        const char * node_name = fPropertyObserverContext;
        fPropertyObserver->onColorProperty(node_name,
            [&]() {
                dispatched = true;
                return std::make_unique<ColorPropertyHandle>(c, fRevalidator);
            });
    }
 
    return dispatched;
}

◆ dispatchOpacityProperty()

bool skottie::internal::AnimationBuilder::dispatchOpacityProperty ( const sk_sp< sksg::OpacityEffect > & o ) const

Definition at line 242 of file Skottie.cpp.

                                                                                      {
    bool dispatched = false;
 
    if (fPropertyObserver) {
        fPropertyObserver->onOpacityProperty(fPropertyObserverContext,
            [&]() {
                dispatched = true;
                return std::make_unique<OpacityPropertyHandle>(o, fRevalidator);
            });
    }
 
    return dispatched;
}

◆ dispatchTextProperty()

bool skottie::internal::AnimationBuilder::dispatchTextProperty	(	const sk_sp< TextAdapter > &	t,
		const skjson::ObjectValue *	jtext
	)		const

Definition at line 256 of file Skottie.cpp.

                                                                                  {
    bool dispatched = false;
 
    if (jtext) {
        if (const skjson::StringValue* slotID = (*jtext)["sid"]) {
            fSlotManager->trackTextValue(SkString(slotID->begin()), t);
            dispatched = true;
        }
    }
 
    if (fPropertyObserver) {
        fPropertyObserver->onTextProperty(fPropertyObserverContext,
            [&]() {
                dispatched = true;
                return std::make_unique<TextPropertyHandle>(t, fRevalidator);
            });
    }
 
    return dispatched;
}

◆ dispatchTransformProperty()

bool skottie::internal::AnimationBuilder::dispatchTransformProperty ( const sk_sp< TransformAdapter2D > & t ) const

Definition at line 278 of file Skottie.cpp.

                                                                                         {
    bool dispatched = false;
 
    if (fPropertyObserver) {
        fPropertyObserver->onTransformProperty(fPropertyObserverContext,
            [&]() {
                dispatched = true;
                return std::make_unique<TransformPropertyHandle>(t, fRevalidator);
            });
    }
 
    return dispatched;
}

◆ expression_manager()

sk_sp< ExpressionManager > skottie::internal::AnimationBuilder::expression_manager ( ) const

Definition at line 292 of file Skottie.cpp.

                                                                    {
    return fExpressionManager;
}

◆ findFont()

const AnimationBuilder::FontInfo * skottie::internal::AnimationBuilder::findFont ( const SkString & name ) const

Definition at line 349 of file TextLayer.cpp.

                                                                                          {
    return fFonts.find(font_name);
}

◆ getSlotsRoot()

const skjson::ObjectValue * skottie::internal::AnimationBuilder::getSlotsRoot ( ) const

inline

Definition at line 197 of file SkottiePriv.h.

                                                  {
        return fSlotsRoot;
    }

◆ hasNontrivialBlending()

bool skottie::internal::AnimationBuilder::hasNontrivialBlending ( ) const

inline

Definition at line 110 of file SkottiePriv.h.

110{ return fHasNontrivialBlending; }

◆ log()

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

Definition at line 71 of file Skottie.cpp.

                                                        {
    if (!fLogger) {
        return;
    }
 
    char buff[1024];
    va_list va;
    va_start(va, fmt);
    const auto len = vsnprintf(buff, sizeof(buff), fmt, va);
    va_end(va);
 
    if (len < 0) {
        SkDebugf("!! Could not format log message !!\n");
        return;
    }
 
    if (len >= SkToInt(sizeof(buff))) {
        static constexpr char kEllipsesStr[] = "...";
        strcpy(buff + sizeof(buff) - sizeof(kEllipsesStr), kEllipsesStr);
    }
 
    SkString jsonstr = json ? json->toString() : SkString();
 
    fLogger->log(lvl, buff, jsonstr.c_str());
}

◆ parse()

AnimationBuilder::AnimationInfo skottie::internal::AnimationBuilder::parse ( const skjson::ObjectValue & jroot )

Definition at line 165 of file Skottie.cpp.

                                                                                    {
    this->dispatchMarkers(jroot["markers"]);
 
    AutoScope ascope(this);
    AutoPropertyTracker apt(this, jroot, PropertyObserver::NodeType::COMPOSITION);
 
    this->parseAssets(jroot["assets"]);
    this->parseFonts(jroot["fonts"], jroot["chars"]);
    fSlotsRoot = jroot["slots"];
 
    auto root = CompositionBuilder(*this, fCompSize, jroot).build(*this);
 
    auto animators = ascope.release();
    fStats->fAnimatorCount = animators.size();
 
    // Point the revalidator to our final root, and perform initial revalidation.
    fRevalidator->setRoot(root);
    fRevalidator->revalidate();
 
    return { std::move(root), std::move(animators), std::move(fSlotManager)};
}

◆ parseFonts()

void skottie::internal::AnimationBuilder::parseFonts	(	const skjson::ObjectValue *	jfonts,
		const skjson::ArrayValue *	jchars
	)

Definition at line 115 of file TextLayer.cpp.

                                                                  {
    // Optional array of font entries, referenced (by name) from text layer document nodes. E.g.
    // "fonts": {
    //        "list": [
    //            {
    //                "ascent": 75,
    //                "fClass": "",
    //                "fFamily": "Roboto",
    //                "fName": "Roboto-Regular",
    //                "fPath": "https://fonts.googleapis.com/css?family=Roboto",
    //                "fPath": "",
    //                "fStyle": "Regular",
    //                "fWeight": "",
    //                "origin": 1
    //            }
    //        ]
    //    },
    const skjson::ArrayValue* jlist = jfonts
            ? static_cast<const skjson::ArrayValue*>((*jfonts)["list"])
            : nullptr;
    if (!jlist) {
        return;
    }
 
    // First pass: collect font info.
    for (const skjson::ObjectValue* jfont : *jlist) {
        if (!jfont) {
            continue;
        }
 
        const skjson::StringValue* jname   = (*jfont)["fName"];
        const skjson::StringValue* jfamily = (*jfont)["fFamily"];
        const skjson::StringValue* jstyle  = (*jfont)["fStyle"];
        const skjson::StringValue* jpath   = (*jfont)["fPath"];
 
        if (!jname   || !jname->size() ||
            !jfamily || !jfamily->size() ||
            !jstyle) {
            this->log(Logger::Level::kError, jfont, "Invalid font.");
            continue;
        }
 
        fFonts.set(SkString(jname->begin(), jname->size()),
                  {
                      SkString(jfamily->begin(), jfamily->size()),
                      SkString( jstyle->begin(),  jstyle->size()),
                      jpath ? SkString(  jpath->begin(),   jpath->size()) : SkString(),
                      ParseDefault((*jfont)["ascent"] , 0.0f),
                      nullptr, // placeholder
                      CustomFont::Builder()
                  });
    }
 
    const auto has_comp_glyphs = [](const skjson::ArrayValue* jchars) {
        if (!jchars) {
            return false;
        }
 
        for (const skjson::ObjectValue* jchar : *jchars) {
            if (!jchar) {
                continue;
            }
            if (ParseDefault<int>((*jchar)["t"], 0) == 1) {
                return true;
            }
        }
 
        return false;
    };
 
    // Historically, Skottie has been loading native fonts before embedded glyphs, unless
    // the opposite is explicitly requested via kPreferEmbeddedFonts.  That's mostly because
    // embedded glyphs used to be just a path representation of system fonts at export time,
    // (and thus lower quality).
    //
    // OTOH embedded glyph *compositions* must be prioritized, as they are presumably more
    // expressive than the system font equivalent.
    const auto prioritize_embedded_fonts =
            (fFlags & Animation::Builder::kPreferEmbeddedFonts) || has_comp_glyphs(jchars);
 
    // Optional pass.
    if (jchars && prioritize_embedded_fonts && this->resolveEmbeddedTypefaces(*jchars)) {
        return;
    }
 
    // Native typeface resolution.
    if (this->resolveNativeTypefaces()) {
        return;
    }
 
    // Embedded typeface fallback.
    if (jchars && !prioritize_embedded_fonts) {
        this->resolveEmbeddedTypefaces(*jchars);
    }
}

Friends And Related Function Documentation

◆ AnimatablePropertyContainer

friend class AnimatablePropertyContainer

friend

Definition at line 207 of file SkottiePriv.h.

◆ CompositionBuilder

friend class CompositionBuilder

friend

Definition at line 204 of file SkottiePriv.h.

◆ CustomFont

friend class CustomFont

friend

Definition at line 205 of file SkottiePriv.h.

◆ LayerBuilder

friend class LayerBuilder

friend

Definition at line 206 of file SkottiePriv.h.

The documentation for this class was generated from the following files:

third_party/skia/modules/skottie/src/SkottiePriv.h
third_party/skia/modules/skottie/src/BlendModes.cpp
third_party/skia/modules/skottie/src/Camera.cpp
third_party/skia/modules/skottie/src/layers/AudioLayer.cpp
third_party/skia/modules/skottie/src/layers/FootageLayer.cpp
third_party/skia/modules/skottie/src/layers/NullLayer.cpp
third_party/skia/modules/skottie/src/layers/PrecompLayer.cpp
third_party/skia/modules/skottie/src/layers/shapelayer/ShapeLayer.cpp
third_party/skia/modules/skottie/src/layers/SolidLayer.cpp
third_party/skia/modules/skottie/src/layers/TextLayer.cpp
third_party/skia/modules/skottie/src/Path.cpp
third_party/skia/modules/skottie/src/Skottie.cpp
third_party/skia/modules/skottie/src/Transform.cpp

Classes

Public Member Functions

Friends

Detailed Description

Constructor & Destructor Documentation

◆ AnimationBuilder()

Member Function Documentation

◆ attachCamera()

◆ attachDiscardableAdapter() [1/2]

◆ attachDiscardableAdapter() [2/2]

◆ attachMatrix2D()

◆ attachMatrix3D()

◆ attachOpacity()

◆ attachPath()

◆ dispatchColorProperty()

◆ dispatchOpacityProperty()

◆ dispatchTextProperty()

◆ dispatchTransformProperty()

◆ expression_manager()

◆ findFont()

◆ getSlotsRoot()

◆ hasNontrivialBlending()

◆ log()

◆ parse()

◆ parseFonts()

Friends And Related Function Documentation

◆ AnimatablePropertyContainer

◆ CompositionBuilder

◆ CustomFont

◆ LayerBuilder