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 }
	)

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, 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.

Parameters

target	Existing TextBuffer to append into.
text	UTF-8 string to composite.
color	RGBA glyph color.

Returns

ImpressResult::Ok or ImpressResult::Overflow.

Definition at line 464 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);
 
    if (layout.quads.empty()) {
        MF_WARN(Journal::Component::Portal, Journal::Context::API,
            "impress: no glyphs produced for '{}'", std::string(text));
        return ImpressResult::Ok;
    }
 
    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 auto full = composite(accumulated, *atlas, color, buf_w, new_h);
        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(buf_bytes, 0);
        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->h;
        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_quads(layout.quads, *atlas, color, 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, 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, MF_WARN, Ok, Overflow, pixels, MayaFlux::Journal::Portal, MayaFlux::Portal::Text::LayoutResult::quads, and rasterize_quads().

Here is the call graph for this function: