skottie::internal::TextAdapter Class Reference

#include <TextAdapter.h>

Inheritance diagram for skottie::internal::TextAdapter:

Classes
class	GlyphDecoratorNode
struct	PathInfo

Public Member Functions
	~TextAdapter () override
const sk_sp< sksg::Group > &	node () const
const TextValue &	getText () const
void	setText (const TextValue &)
Public Member Functions inherited from skottie::internal::AnimatablePropertyContainer
template<typename T >
bool	bind (const AnimationBuilder &, const skjson::ObjectValue *, T *)
template<typename T >
bool	bind (const AnimationBuilder &abuilder, const skjson::ObjectValue *jobject, T &v)
bool	bindAutoOrientable (const AnimationBuilder &abuilder, const skjson::ObjectValue *jobject, SkV2 *v, float *orientation)
bool	isStatic () const
template<>
bool	bind (const AnimationBuilder &abuilder, const skjson::ObjectValue *jprop, ScalarValue *v)
template<>
bool	bind (const AnimationBuilder &abuilder, const skjson::ObjectValue *jprop, ShapeValue *v)
template<>
bool	bind (const AnimationBuilder &abuilder, const skjson::ObjectValue *jprop, TextValue *v)
template<>
bool	bind (const AnimationBuilder &abuilder, const skjson::ObjectValue *jprop, Vec2Value *v)
template<>
bool	bind (const AnimationBuilder &abuilder, const skjson::ObjectValue *jprop, VectorValue *v)
template<>
bool	bind (const AnimationBuilder &abuilder, const skjson::ObjectValue *jprop, ColorValue *v)
Public Member Functions inherited from skottie::internal::Animator
StateChanged	seek (float t)
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Static Public Member Functions
static sk_sp< TextAdapter >	Make (const skjson::ObjectValue &, const AnimationBuilder *, sk_sp< SkFontMgr >, sk_sp< CustomFont::GlyphCompMapper >, sk_sp< Logger >, sk_sp<::SkShapers::Factory >)

Protected Member Functions
void	onSync () override
Protected Member Functions inherited from skottie::internal::AnimatablePropertyContainer
void	shrink_to_fit ()
void	attachDiscardableAdapter (sk_sp< AnimatablePropertyContainer >)
Protected Member Functions inherited from skottie::internal::Animator
	Animator ()=default

Additional Inherited Members
Public Types inherited from skottie::internal::Animator
using	StateChanged = bool

Detailed Description

Definition at line 47 of file TextAdapter.h.

Constructor & Destructor Documentation

~TextAdapter()

skottie::internal::TextAdapter::~TextAdapter ( )

overridedefault

Member Function Documentation

getText()

const TextValue & skottie::internal::TextAdapter::getText ( ) const

inline

Definition at line 60 of file TextAdapter.h.

{ return fText.fCurrentValue; }

Make()

sk_sp< TextAdapter > skottie::internal::TextAdapter::Make ( const skjson::ObjectValue &  jlayer, const AnimationBuilder *  abuilder, sk_sp< SkFontMgr >  fontmgr, sk_sp< CustomFont::GlyphCompMapper >  custom_glyph_mapper, sk_sp< Logger >  logger, sk_sp<::SkShapers::Factory >  factory  )

static

Definition at line 297 of file TextAdapter.cpp.

                                                                      {
    // General text node format:
    // "t": {
    //    "a": [], // animators (see TextAnimator)
    //    "d": {
    //        "k": [
    //            {
    //                "s": {
    //                    "f": "Roboto-Regular",
    //                    "fc": [
    //                        0.42,
    //                        0.15,
    //                        0.15
    //                    ],
    //                    "j": 1,
    //                    "lh": 60,
    //                    "ls": 0,
    //                    "s": 50,
    //                    "t": "text align right",
    //                    "tr": 0
    //                },
    //                "t": 0
    //            }
    //        ],
    //        "sid": "optionalSlotID"
    //    },
    //    "m": { // more options
    //           "g": 1,     // Anchor Point Grouping
    //           "a": {...}  // Grouping Alignment
    //         },
    //    "p": { // path options
    //           "a": 0,   // force alignment
    //           "f": {},  // first margin
    //           "l": {},  // last margin
    //           "m": 1,   // mask index
    //           "p": 1,   // perpendicular
    //           "r": 0    // reverse path
    //         }
 
    // },
 
    const skjson::ObjectValue* jt = jlayer["t"];
    const skjson::ObjectValue* jd = jt ? static_cast<const skjson::ObjectValue*>((*jt)["d"])
                                       : nullptr;
    if (!jd) {
        abuilder->log(Logger::Level::kError, &jlayer, "Invalid text layer.");
        return nullptr;
    }
 
    // "More options"
    const skjson::ObjectValue* jm = (*jt)["m"];
    static constexpr AnchorPointGrouping gGroupingMap[] = {
        AnchorPointGrouping::kCharacter, // 'g': 1
        AnchorPointGrouping::kWord,      // 'g': 2
        AnchorPointGrouping::kLine,      // 'g': 3
        AnchorPointGrouping::kAll,       // 'g': 4
    };
    const auto apg = jm
            ? SkTPin<int>(ParseDefault<int>((*jm)["g"], 1), 1, std::size(gGroupingMap))
            : 1;
 
    auto adapter = sk_sp<TextAdapter>(new TextAdapter(std::move(fontmgr),
                                                      std::move(custom_glyph_mapper),
                                                      std::move(logger),
                                                      std::move(factory),
                                                      gGroupingMap[SkToSizeT(apg - 1)]));
 
    adapter->bind(*abuilder, jd, adapter->fText.fCurrentValue);
    if (jm) {
        adapter->bind(*abuilder, (*jm)["a"], adapter->fGroupingAlignment);
    }
 
    // Animators
    if (const skjson::ArrayValue* janimators = (*jt)["a"]) {
        adapter->fAnimators.reserve(janimators->size());
 
        for (const skjson::ObjectValue* janimator : *janimators) {
            if (auto animator = TextAnimator::Make(janimator, abuilder, adapter.get())) {
                adapter->fHasBlurAnimator         |= animator->hasBlur();
                adapter->fRequiresAnchorPoint     |= animator->requiresAnchorPoint();
                adapter->fRequiresLineAdjustments |= animator->requiresLineAdjustments();
 
                adapter->fAnimators.push_back(std::move(animator));
            }
        }
    }
 
    // Optional text path
    const auto attach_path = [&](const skjson::ObjectValue* jpath) -> std::unique_ptr<PathInfo> {
        if (!jpath) {
            return nullptr;
        }
 
        // the actual path is identified as an index in the layer mask stack
        const auto mask_index =
                ParseDefault<size_t>((*jpath)["m"], std::numeric_limits<size_t>::max());
        const skjson::ArrayValue* jmasks = jlayer["masksProperties"];
        if (!jmasks || mask_index >= jmasks->size()) {
            return nullptr;
        }
 
        const skjson::ObjectValue* mask = (*jmasks)[mask_index];
        if (!mask) {
            return nullptr;
        }
 
        auto pinfo = std::make_unique<PathInfo>();
        adapter->bind(*abuilder, (*mask)["pt"], &pinfo->fPath);
        adapter->bind(*abuilder, (*jpath)["f"], &pinfo->fPathFMargin);
        adapter->bind(*abuilder, (*jpath)["l"], &pinfo->fPathLMargin);
        adapter->bind(*abuilder, (*jpath)["p"], &pinfo->fPathPerpendicular);
        adapter->bind(*abuilder, (*jpath)["r"], &pinfo->fPathReverse);
 
        // TODO: force align support
 
        // Historically, these used to be exported as static properties.
        // Attempt parsing both ways, for backward compat.
        skottie::Parse((*jpath)["p"], &pinfo->fPathPerpendicular);
        skottie::Parse((*jpath)["r"], &pinfo->fPathReverse);
 
        // Path positioning requires anchor point info.
        adapter->fRequiresAnchorPoint = true;
 
        return pinfo;
    };
 
    adapter->fPathInfo = attach_path((*jt)["p"]);
    abuilder->dispatchTextProperty(adapter, jd);
 
    return adapter;
}

node()

const sk_sp< sksg::Group > & skottie::internal::TextAdapter::node ( ) const

inline

Definition at line 58 of file TextAdapter.h.

{ return fRoot; }

onSync()

void skottie::internal::TextAdapter::onSync ( )

overrideprotectedvirtual

Implements skottie::internal::AnimatablePropertyContainer.

Definition at line 774 of file TextAdapter.cpp.

                         {
    if (!fText->fHasFill && !fText->fHasStroke) {
        return;
    }
 
    if (fText.hasChanged()) {
        this->reshape();
    }
 
    if (fFragments.empty()) {
        return;
    }
 
    // Update the path contour measure, if needed.
    if (fPathInfo) {
        fPathInfo->updateContourData();
    }
 
    // Seed props from the current text value.
    TextAnimator::ResolvedProps seed_props;
    seed_props.fill_color   = fText->fFillColor;
    seed_props.stroke_color = fText->fStrokeColor;
    seed_props.stroke_width = fText->fStrokeWidth;
 
    TextAnimator::ModulatorBuffer buf;
    buf.resize(fFragments.size(), { seed_props, 0 });
 
    // Apply all animators to the modulator buffer.
    for (const auto& animator : fAnimators) {
        animator->modulateProps(fMaps, buf);
    }
 
    const TextAnimator::DomainMap* grouping_domain = nullptr;
    switch (fAnchorPointGrouping) {
        // for word/line grouping, we rely on domain map info
        case AnchorPointGrouping::kWord: grouping_domain = &fMaps.fWordsMap; break;
        case AnchorPointGrouping::kLine: grouping_domain = &fMaps.fLinesMap; break;
        // remaining grouping modes (character/all) do not need (or have) domain map data
        default: break;
    }
 
    size_t grouping_span_index = 0;
    SkV2   current_line_offset = { 0, 0 }; // cumulative line spacing
 
    auto compute_linewide_props = [this](const TextAnimator::ModulatorBuffer& buf,
                                         const TextAnimator::DomainSpan& line_span) {
        SkV2  total_spacing  = {0,0};
        float total_tracking = 0;
 
        // Only compute these when needed.
        if (fRequiresLineAdjustments && line_span.fCount) {
            for (size_t i = line_span.fOffset; i < line_span.fOffset + line_span.fCount; ++i) {
                const auto& props = buf[i].props;
                total_spacing  += props.line_spacing;
                total_tracking += props.tracking;
            }
 
            // The first glyph does not contribute |before| tracking, and the last one does not
            // contribute |after| tracking.
            total_tracking -= 0.5f * (buf[line_span.fOffset].props.tracking +
                                      buf[line_span.fOffset + line_span.fCount - 1].props.tracking);
        }
 
        return std::make_tuple(total_spacing, total_tracking);
    };
 
    // Finally, push all props to their corresponding fragment.
    for (const auto& line_span : fMaps.fLinesMap) {
        const auto [line_spacing, line_tracking] = compute_linewide_props(buf, line_span);
        const auto align_offset = -line_tracking * align_factor(fText->fHAlign);
 
        // line spacing of the first line is ignored (nothing to "space" against)
        if (&line_span != &fMaps.fLinesMap.front() && line_span.fCount) {
            // For each line, the actual spacing is an average of individual fragment spacing
            // (to preserve the "line").
            current_line_offset += line_spacing / line_span.fCount;
        }
 
        float tracking_acc = 0;
        for (size_t i = line_span.fOffset; i < line_span.fOffset + line_span.fCount; ++i) {
            // Track the grouping domain span in parallel.
            if (grouping_domain && i >= (*grouping_domain)[grouping_span_index].fOffset +
                                        (*grouping_domain)[grouping_span_index].fCount) {
                grouping_span_index += 1;
                SkASSERT(i < (*grouping_domain)[grouping_span_index].fOffset +
                             (*grouping_domain)[grouping_span_index].fCount);
            }
 
            const auto& props = buf[i].props;
            const auto& frag  = fFragments[i];
 
            // AE tracking is defined per glyph, based on two components: |before| and |after|.
            // BodyMovin only exports "balanced" tracking values, where before = after = tracking/2.
            //
            // Tracking is applied as a local glyph offset, and contributes to the line width for
            // alignment purposes.
            //
            // No |before| tracking for the first glyph, nor |after| tracking for the last one.
            const auto track_before = i > line_span.fOffset
                                        ? props.tracking * 0.5f : 0.0f,
                       track_after  = i < line_span.fOffset + line_span.fCount - 1
                                        ? props.tracking * 0.5f : 0.0f;
 
            const auto frag_offset = current_line_offset +
                                     SkV2{align_offset + tracking_acc + track_before, 0};
 
            tracking_acc += track_before + track_after;
 
            this->pushPropsToFragment(props, frag, frag_offset, fGroupingAlignment * .01f, // %
                                      grouping_domain ? &(*grouping_domain)[grouping_span_index]
                                                        : nullptr);
        }
    }
}

setText()

void skottie::internal::TextAdapter::setText

(

const TextValue &

txt

)

Definition at line 636 of file TextAdapter.cpp.

                                              {
    fText.fCurrentValue = txt;
    this->onSync();
}

---

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

• third_party/skia/modules/skottie/src/text/TextAdapter.h
• third_party/skia/modules/skottie/src/text/TextAdapter.cpp