skottie::internal::AnimatorBuilder Class Reference

#include <KeyframeAnimator.h>

Inheritance diagram for skottie::internal::AnimatorBuilder:

Public Member Functions
virtual	~AnimatorBuilder ()
virtual sk_sp< KeyframeAnimator >	makeFromKeyframes (const AnimationBuilder &, const skjson::ArrayValue &)=0
virtual sk_sp< Animator >	makeFromExpression (ExpressionManager &, const char *)=0
virtual bool	parseValue (const AnimationBuilder &, const skjson::Value &) const =0
Public Member Functions inherited from SkNoncopyable
	SkNoncopyable ()=default
	SkNoncopyable (SkNoncopyable &&)=default
SkNoncopyable &	operator= (SkNoncopyable &&)=default

Protected Member Functions
	AnimatorBuilder (Keyframe::Value::Type ty)
virtual bool	parseKFValue (const AnimationBuilder &, const skjson::ObjectValue &, const skjson::Value &, Keyframe::Value *)=0
bool	parseKeyframes (const AnimationBuilder &, const skjson::ArrayValue &)

Protected Attributes
std::vector< Keyframe >	fKFs
std::vector< SkCubicMap >	fCMs

Detailed Description

Definition at line 118 of file KeyframeAnimator.h.

Constructor & Destructor Documentation

~AnimatorBuilder()

skottie::internal::AnimatorBuilder::~AnimatorBuilder ( )

virtualdefault

AnimatorBuilder()

skottie::internal::AnimatorBuilder::AnimatorBuilder ( Keyframe::Value::Type  ty )

inlineexplicitprotected

Definition at line 130 of file KeyframeAnimator.h.

        : keyframe_type(ty) {}

Member Function Documentation

makeFromExpression()

virtual sk_sp< Animator > skottie::internal::AnimatorBuilder::makeFromExpression ( ExpressionManager &  , const char *    )

pure virtual

Implemented in skottie::internal::VectorAnimatorBuilder.

makeFromKeyframes()

virtual sk_sp< KeyframeAnimator > skottie::internal::AnimatorBuilder::makeFromKeyframes ( const AnimationBuilder &  , const skjson::ArrayValue &    )

pure virtual

Implemented in skottie::internal::VectorAnimatorBuilder.

parseKeyframes()

bool skottie::internal::AnimatorBuilder::parseKeyframes ( const AnimationBuilder &  abuilder, const skjson::ArrayValue &  jkfs  )

protected

Definition at line 94 of file KeyframeAnimator.cpp.

                                                                   {
    // Keyframe format:
    //
    // [                        // array of
    //   {
    //     "t": <float>         // keyframe time
    //     "s": <T>             // keyframe value
    //     "h": <bool>          // optional constant/hold keyframe marker
    //     "i": [<float,float>] // optional "in" Bezier control point
    //     "o": [<float,float>] // optional "out" Bezier control point
    //   },
    //   ...
    // ]
    //
    // Legacy keyframe format:
    //
    // [                        // array of
    //   {
    //     "t": <float>         // keyframe time
    //     "s": <T>             // keyframe start value
    //     "e": <T>             // keyframe end value
    //     "h": <bool>          // optional constant/hold keyframe marker (constant mapping)
    //     "i": [<float,float>] // optional "in" Bezier control point (cubic mapping)
    //     "o": [<float,float>] // optional "out" Bezier control point (cubic mapping)
    //   },
    //   ...
    //   {
    //     "t": <float>         // last keyframe only specifies a t
    //                          // the value is prev. keyframe end value
    //   }
    // ]
    //
    // Note: the legacy format contains duplicates, as normal frames are contiguous:
    //       frame(n).e == frame(n+1).s
 
    const auto parse_value = [&](const skjson::ObjectValue& jkf, size_t i, Keyframe::Value* v) {
        auto parsed = this->parseKFValue(abuilder, jkf, jkf["s"], v);
 
        // A missing value is only OK for the last legacy KF
        // (where it is pulled from prev KF 'end' value).
        if (!parsed && i > 0 && i == jkfs.size() - 1) {
            const skjson::ObjectValue* prev_kf = jkfs[i - 1];
            SkASSERT(prev_kf);
            parsed = this->parseKFValue(abuilder, jkf, (*prev_kf)["e"], v);
        }
 
        return parsed;
    };
 
    bool constant_value = true;
 
    fKFs.reserve(jkfs.size());
 
    for (size_t i = 0; i < jkfs.size(); ++i) {
        const skjson::ObjectValue* jkf = jkfs[i];
        if (!jkf) {
            return false;
        }
 
        float t;
        if (!Parse<float>((*jkf)["t"], &t)) {
            return false;
        }
 
        Keyframe::Value v;
        if (!parse_value(*jkf, i, &v)) {
            return false;
        }
 
        if (i > 0) {
            auto& prev_kf = fKFs.back();
 
            // Ts must be strictly monotonic.
            if (t <= prev_kf.t) {
                return false;
            }
 
            // We can power-reduce the mapping of repeated values (implicitly constant).
            if (v.equals(prev_kf.v, keyframe_type)) {
                prev_kf.mapping = Keyframe::kConstantMapping;
            }
        }
 
        fKFs.push_back({t, v, this->parseMapping(*jkf)});
 
        constant_value = constant_value && (v.equals(fKFs.front().v, keyframe_type));
    }
 
    SkASSERT(fKFs.size() == jkfs.size());
    fCMs.shrink_to_fit();
 
    if (constant_value) {
        // When all keyframes hold the same value, we can discard all but one
        // (interpolation has no effect).
        fKFs.resize(1);
    }
 
#if(DUMP_KF_RECORDS)
    SkDEBUGF("Animator[%p], values: %lu, KF records: %zu\n",
             this, fKFs.back().v_idx + 1, fKFs.size());
    for (const auto& kf : fKFs) {
        SkDEBUGF("  { t: %1.3f, v_idx: %lu, mapping: %lu }\n", kf.t, kf.v_idx, kf.mapping);
    }
#endif
    return true;
}

parseKFValue()

virtual bool skottie::internal::AnimatorBuilder::parseKFValue ( const AnimationBuilder &  , const skjson::ObjectValue &  , const skjson::Value &  , Keyframe::Value *    )

protectedpure virtual

Implemented in skottie::internal::VectorAnimatorBuilder.

parseValue()

virtual bool skottie::internal::AnimatorBuilder::parseValue ( const AnimationBuilder &  , const skjson::Value &    ) const

pure virtual

Implemented in skottie::internal::VectorAnimatorBuilder.

Member Data Documentation

fCMs

std::vector<SkCubicMap> skottie::internal::AnimatorBuilder::fCMs

protected

Definition at line 141 of file KeyframeAnimator.h.

fKFs

std::vector<Keyframe> skottie::internal::AnimatorBuilder::fKFs

protected

Definition at line 140 of file KeyframeAnimator.h.

---

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

• third_party/skia/modules/skottie/src/animator/KeyframeAnimator.h
• third_party/skia/modules/skottie/src/animator/KeyframeAnimator.cpp