skottie::internal::CustomFont::Builder Class Reference

#include <Font.h>

Inheritance diagram for skottie::internal::CustomFont::Builder:

Public Member Functions
bool	parseGlyph (const AnimationBuilder *, const skjson::ObjectValue &)
std::unique_ptr< CustomFont >	detach ()

Detailed Description

Definition at line 39 of file Font.h.

Member Function Documentation

detach()

std::unique_ptr< CustomFont > skottie::internal::CustomFont::Builder::detach

(

)

Definition at line 200 of file Font.cpp.

                                                    {
    return std::unique_ptr<CustomFont>(new CustomFont(std::move(fGlyphComps),
                                                      fCustomBuilder.detach()));
}

parseGlyph()

bool skottie::internal::CustomFont::Builder::parseGlyph	(	const AnimationBuilder *	abuilder,
		const skjson::ObjectValue &	jchar
	)

Definition at line 26 of file Font.cpp.

                                                                     {
    // Glyph encoding:
    //     {
    //         "ch": "t",
    //         "data": <glyph data>,  // Glyph path or composition data
    //         "size": 50,            // apparently ignored
    //         "w": 32.67,            // width/advance (1/100 units)
    //         "t": 1                 // Marker for composition glyphs only.
    //     }
    const skjson::StringValue* jch   = jchar["ch"];
    const skjson::ObjectValue* jdata = jchar["data"];
    if (!jch || !jdata) {
        return false;
    }
 
    const auto* ch_ptr = jch->begin();
    const auto  ch_len = jch->size();
    if (SkUTF::CountUTF8(ch_ptr, ch_len) != 1) {
        return false;
    }
 
    const auto uni = SkUTF::NextUTF8(&ch_ptr, ch_ptr + ch_len);
    SkASSERT(uni != -1);
    if (!SkTFitsIn<SkGlyphID>(uni)) {
        // Custom font keys are SkGlyphIDs.  We could implement a remapping scheme if needed,
        // but for now direct mapping seems to work well enough.
        return false;
    }
    const auto glyph_id = SkTo<SkGlyphID>(uni);
 
    // Normalize the path and advance for 1pt.
    static constexpr float kPtScale = 0.01f;
    const auto advance = ParseDefault(jchar["w"], 0.0f) * kPtScale;
 
    // Custom glyphs are either compositions...
    SkSize glyph_size;
    if (auto comp_node = ParseGlyphComp(abuilder, *jdata, &glyph_size)) {
        // With glyph comps, we use the SkCustomTypeface only for shaping -- not for rendering.
        // We still need accurate glyph bounds though, for visual alignment.
 
        // TODO: This assumes the glyph origin is always in the lower-left corner.
        // Lottie may need to add an origin property, to allow designers full control over
        // glyph comp positioning.
        const auto glyph_bounds = SkRect::MakeLTRB(0, -glyph_size.fHeight, glyph_size.fWidth, 0);
        fCustomBuilder.setGlyph(glyph_id, advance, SkPath::Rect(glyph_bounds));
 
        // Rendering is handled explicitly, post shaping,
        // based on info tracked in this GlyphCompMap.
        fGlyphComps.set(glyph_id, std::move(comp_node));
 
        return true;
    }
 
    // ... or paths.
    SkPath path;
    if (!ParseGlyphPath(abuilder, *jdata, &path)) {
        return false;
    }
 
    path.transform(SkMatrix::Scale(kPtScale, kPtScale));
 
    fCustomBuilder.setGlyph(glyph_id, advance, path);
 
    return true;
}

---

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

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