decompose_glyph() [1/2]

MAYAFLUX_API GlyphOutline MayaFlux::Portal::Text::decompose_glyph	(	FontFace &	face,
		uint32_t	codepoint,
		uint32_t	pixel_size,
		float	tolerance = 0.5F
	)

Decompose a Unicode codepoint into a tessellated polyline outline.

Loads the glyph via FT_LOAD_NO_BITMAP, walks the FT_Outline with FT_Outline_Decompose, and flattens conic and cubic Bezier segments into line segments at the given flatness tolerance.

The returned outline may be empty (points and contour_ends both empty) for whitespace codepoints or when the codepoint has no outline (e.g. space, tab). advance_x is still populated in that case so layout can proceed.

Parameters

face	Loaded FontFace. Must outlive this call.
codepoint	Unicode codepoint.
pixel_size	Glyph size in pixels. Passed to FT_Set_Pixel_Sizes.
tolerance	Flatness tolerance in pixels. Smaller values produce more segments and higher fidelity curves.

Returns

GlyphOutline with pixel-space polyline data.

Definition at line 168 of file GlyphOutline.cpp.

{
    GlyphOutline result;
    result.codepoint = codepoint;
 
    if (!face.is_loaded()) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::API,
            "decompose_glyph: FontFace not loaded");
        return result;
    }
 
    FT_Face ft = face.get_face();
 
    if (const FT_Error err = FT_Set_Pixel_Sizes(ft, 0, pixel_size); err != 0) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::API,
            "decompose_glyph: FT_Set_Pixel_Sizes({}) failed: {}", pixel_size, static_cast<int>(err));
        return result;
    }
 
    const FT_UInt idx = FT_Get_Char_Index(ft, static_cast<FT_ULong>(codepoint));
    if (idx == 0) {
        MF_WARN(Journal::Component::Portal, Journal::Context::API,
            "decompose_glyph: no glyph for U+{:04X}", codepoint);
        return result;
    }
 
    if (const FT_Error err = FT_Load_Glyph(ft, idx, FT_LOAD_NO_BITMAP); err != 0) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::API,
            "decompose_glyph: FT_Load_Glyph({}) failed: {}", idx, static_cast<int>(err));
        return result;
    }
 
    result.advance_x = static_cast<int32_t>(ft->glyph->advance.x >> 6);
 
    if (ft->glyph->format != FT_GLYPH_FORMAT_OUTLINE) {
        return result;
    }
 
    DecomposeCtx ctx {
        .points = &result.points,
        .contour_ends = &result.contour_ends,
        .tolerance = tolerance,
        .current = {}
    };
 
    if (const FT_Error err = FT_Outline_Decompose(&ft->glyph->outline, &k_funcs, &ctx); err != 0) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::API,
            "decompose_glyph: FT_Outline_Decompose failed: {}", static_cast<int>(err));
        result.points.clear();
        result.contour_ends.clear();
        return result;
    }
 
    if (!result.points.empty())
        result.contour_ends.push_back(static_cast<uint32_t>(result.points.size()));
 
    return result;
}

References MayaFlux::Portal::Text::GlyphOutline::advance_x, MayaFlux::Journal::API, MayaFlux::Portal::Text::GlyphOutline::codepoint, MayaFlux::Portal::Text::GlyphOutline::contour_ends, MayaFlux::Portal::Text::FontFace::get_face(), MayaFlux::Portal::Text::FontFace::is_loaded(), MF_ERROR, MF_WARN, MayaFlux::Portal::Text::GlyphOutline::points, MayaFlux::Journal::Portal, and tolerance.

Referenced by decompose_glyph(), and MayaFlux::Nodes::GpuSync::GlyphGeometryNode::rebuild_outlines().

Here is the call graph for this function:

Here is the caller graph for this function: