index_at()

MAYAFLUX_API size_t MayaFlux::Portal::Text::index_at	(	std::string_view	text,
		const LayoutResult &	layout,
		GlyphAtlas &	atlas,
		float	x,
		float	y,
		float	pen_x = 0.F,
		float	pen_y = 0.F,
		uint32_t	wrap_w = 0,
		uint32_t	tab_width = 4
	)

Byte offset of the codepoint boundary nearest a screen-space point.

Scans layout.quads for the line whose quads sit closest to y, then within that line for the ink quad x falls into (resolving to its left or right half), or, failing that, for the two quads bracketing x. lay_out() never emits a quad for a space, tab, or newline, so a point landing in the gap between two quads - or before the first / after the last quad on a line - has no ink to test against directly: that gap is resolved exactly by walking its few codepoint boundaries through x_at() (same pen_x/pen_y/wrap_w/tab_width as the original lay_out() call) and keeping whichever pen position lands closest to x, rather than guessing from ink edges that were never meant to mark it.

A line with no quads at all (blank, or entirely whitespace) has nothing for the first scan to anchor on and is still not distinguishable from an adjacent line by this function - a real, if narrower, residual gap. Empty layout.quads (the whole text is blank or all-whitespace) returns 0.

Parameters

text	Source UTF-8 string layout was produced from.
layout	LayoutResult to hit-test against.
atlas	GlyphAtlas layout was produced with.
x	Screen-space x coordinate, same space as layout's quads.
y	Screen-space y coordinate, same space as layout's quads.
pen_x	Pen origin x, matching the original lay_out() call.
pen_y	Pen origin y, matching the original lay_out() call.
wrap_w	Wrap column, matching the original lay_out() call.
tab_width	Tab stop width, matching the original lay_out() call.

Returns

Byte offset of the nearest codepoint boundary.

Definition at line 242 of file TypeSetter.cpp.

{
    if (layout.quads.empty()) {
        return 0;
    }
 
    const auto line_h = static_cast<float>(atlas.line_height());
 
    float line_y = layout.quads.front().y0;
    float best_line_dy = abs_f(line_y - y);
    for (const auto& q : layout.quads) {
        const float dy = abs_f(q.y0 - y);
        if (dy < best_line_dy) {
            best_line_dy = dy;
            line_y = q.y0;
        }
    }
 
    const GlyphQuad* left = nullptr;
    const GlyphQuad* right = nullptr;
 
    for (const auto& q : layout.quads) {
        if (abs_f(q.y0 - line_y) > line_h * 0.5F) {
            continue;
        }
 
        if (x >= q.x0 && x <= q.x1) {
            return x > (q.x0 + q.x1) * 0.5F
                ? next_codepoint_offset(text, q.byte_offset)
                : q.byte_offset;
        }
        if (q.x1 <= x && (!left || q.x1 > left->x1)) {
            left = &q;
        }
        if (q.x0 >= x && (!right || q.x0 < right->x0)) {
            right = &q;
        }
    }
 
    const GlyphQuad* anchor = left ? left : right;
    const float pen_line_y = x_at(text, atlas, anchor->byte_offset, pen_x, pen_y, wrap_w, tab_width).y;
 
    const auto same_line = [&](size_t offset) {
        return x_at(text, atlas, offset, pen_x, pen_y, wrap_w, tab_width).y == pen_line_y;
    };
 
    size_t bracket_start = 0;
    if (left) {
        bracket_start = next_codepoint_offset(text, left->byte_offset);
    } else {
        bracket_start = right->byte_offset;
        while (bracket_start > 0) {
            const size_t prev = previous_codepoint_offset(text, bracket_start);
            if (!same_line(prev)) {
                break;
            }
            bracket_start = prev;
        }
    }
 
    size_t bracket_end = text.size();
    if (right) {
        bracket_end = right->byte_offset;
    } else {
        bracket_end = next_codepoint_offset(text, left->byte_offset);
        while (bracket_end < text.size()) {
            const size_t next = next_codepoint_offset(text, bracket_end);
            if (!same_line(next)) {
                break;
            }
            bracket_end = next;
        }
    }
 
    if (bracket_start >= bracket_end) {
        return bracket_start;
    }
 
    size_t best_offset = bracket_start;
    float best_dx = abs_f(x_at(text, atlas, bracket_start, pen_x, pen_y, wrap_w, tab_width).x - x);
 
    for (size_t off = bracket_start; off < bracket_end;) {
        const size_t next = next_codepoint_offset(text, off);
        const float dx = abs_f(x_at(text, atlas, next, pen_x, pen_y, wrap_w, tab_width).x - x);
        if (dx < best_dx) {
            best_dx = dx;
            best_offset = next;
        }
        off = next;
    }
 
    return best_offset;
}

References MayaFlux::Portal::Text::GlyphQuad::byte_offset, MayaFlux::Portal::Text::GlyphAtlas::line_height(), next_codepoint_offset(), offset, previous_codepoint_offset(), q, MayaFlux::Portal::Text::LayoutResult::quads, MayaFlux::Portal::Text::GlyphQuad::x0, MayaFlux::Portal::Text::GlyphQuad::x1, x_at(), and MayaFlux::Portal::Text::PenPosition::y.

Referenced by MayaFlux::Portal::Text::TextRun::index_at().

Here is the call graph for this function:

Here is the caller graph for this function: