impress()

MAYAFLUX_API ImpressResult MayaFlux::Portal::Text::impress	(	const std::shared_ptr< Buffers::TextBuffer > &	target,
		std::string_view	text,
		glm::vec4	color = { 1.F, 1.F, 1.F, 1.F },
		std::span< const StyleSpan >	spans = {}
	)

Append a UTF-8 string into an existing TextBuffer at the current cursor.

Does not clear existing content. Composites the new run into the pre-allocated budget region and advances the cursor. No VKImage reallocation occurs while the run fits within the vertical budget.

When the run would push the cursor past the vertical budget the texture is grown by k_grow_height_multiplier, the full accumulated text is recomposited against target->get_background(), and ImpressResult::Overflow is returned. The caller is responsible for rebuilding prior content after an overflow if accumulated state is not sufficient.

When the cursor would exceed render_bounds_h the run is rejected and ImpressResult::Overflow is returned without reallocation.

The atlas is always the TypeFaceFoundry default. If a non-default atlas was used at press() time, impress() will use the default instead. Mixing atlases on the same TextBuffer is undefined behaviour.

spans is offsets into this call's text, matching the byte_offset lay_out() assigns for this run. On the Overflow-and-regrow path the full accumulated text is recomposited using color and spans from this call alone; prior runs' own colors/spans are not retained, the same pre-existing limitation color already has on that path.

Parameters

target	Existing TextBuffer to append into.
text	UTF-8 string to composite.
color	RGBA glyph color for any byte not covered by spans.
spans	Optional per-byte-range color overrides, offsets into text.

Returns

ImpressResult::Ok or ImpressResult::Overflow.

Definition at line 582 of file InkPress.cpp.

{
    if (!target) {
        MF_ERROR(Journal::Component::Portal, Journal::Context::API,
            "impress: target buffer is null");
        return ImpressResult::Overflow;
    }
 
    GlyphAtlas* atlas = resolve_atlas(nullptr);
    if (!atlas) {
        return ImpressResult::Overflow;
    }
 
    const uint32_t buf_w = target->get_budget_width();
    const uint32_t buf_h = target->get_budget_height();
    const uint32_t bound_h = target->get_render_bounds_h();
    const auto pen_x = static_cast<float>(target->get_cursor_x());
    const auto pen_y = static_cast<float>(target->get_cursor_y());
 
    target->append_accumulated_text(text);
 
    const LayoutResult layout = lay_out(text, *atlas, pen_x, pen_y, buf_w);
 
    const auto pen_y_ceil = static_cast<uint32_t>(std::ceil(layout.final_pen_y));
    const uint32_t new_cursor_y = pen_y_ceil;
    const uint32_t content_h = pen_y_ceil + atlas->line_height();
 
    if (content_h > bound_h) {
        return ImpressResult::Overflow;
    }
 
    if (content_h > buf_h) {
        const uint32_t new_h = std::min(content_h * k_grow_height_multiplier, bound_h);
        const std::string accumulated = target->get_accumulated_text();
        const glm::vec4 background = target->get_background();
 
        const auto full = composite(accumulated, *atlas, color, buf_w, new_h,
            static_cast<float>(atlas->line_height()), spans, background);
        if (!full) {
            return ImpressResult::Overflow;
        }
 
        target->resize_texture(buf_w, new_h);
        target->set_budget(buf_w, new_h);
 
        const size_t buf_bytes = static_cast<size_t>(buf_w) * new_h * 4;
        std::vector<uint8_t> pixels = make_filled(buf_bytes, background);
        const uint32_t copy_h = std::min(full->h, new_h);
        for (uint32_t row = 0; row < copy_h; ++row) {
            std::memcpy(
                pixels.data() + static_cast<size_t>(row) * buf_w * 4,
                full->pixels.data() + static_cast<size_t>(row) * buf_w * 4,
                static_cast<size_t>(buf_w) * 4);
        }
 
        target->set_pixel_data(pixels.data(), buf_bytes);
        target->get_cursor_x() = full->cursor_x;
        target->get_cursor_y() = full->cursor_y;
        target->set_accumulated_text(accumulated);
 
        MF_DEBUG(Journal::Component::Portal, Journal::Context::API,
            "impress: vertical grow -> {}x{}", buf_w, new_h);
 
        return ImpressResult::Overflow;
    }
 
    auto& pixel_data = target->get_pixel_data_mutable();
    rasterize_styled(layout.quads, *atlas, color, spans, pixel_data.data(), buf_w, buf_h);
    target->mark_pixels_dirty();
    target->get_cursor_x() = static_cast<uint32_t>(std::ceil(layout.final_pen_x));
    target->get_cursor_y() = new_cursor_y;
 
    MF_DEBUG(Journal::Component::Portal, Journal::Context::API,
        "impress: '{}' at ({},{}) -> cursor ({},{})",
        std::string(text),
        static_cast<uint32_t>(pen_x), static_cast<uint32_t>(pen_y),
        target->get_cursor_x(), target->get_cursor_y());
 
    return ImpressResult::Ok;
}

References MayaFlux::Journal::API, color, MayaFlux::Portal::Text::LayoutResult::final_pen_x, MayaFlux::Portal::Text::LayoutResult::final_pen_y, lay_out(), MayaFlux::Portal::Text::GlyphAtlas::line_height(), MF_DEBUG, MF_ERROR, Ok, Overflow, pixels, MayaFlux::Journal::Portal, and MayaFlux::Portal::Text::LayoutResult::quads.

Here is the call graph for this function: