rasterize_quads()

MAYAFLUX_API void MayaFlux::Portal::Text::rasterize_quads	(	std::span< const GlyphQuad >	quads,
		GlyphAtlas &	atlas,
		glm::vec4	color,
		uint8_t *	dst,
		uint32_t	buf_w,
		uint32_t	buf_h
	)

Write glyph quads into a caller-provided RGBA8 pixel buffer.

Applies coverage-multiplied alpha blend per glyph cell, compositing over whatever is already in dst rather than overwriting it - a glyph's bounding box includes its own zero-coverage interior (the hole in an 'o' or 'e'), so composited blending is what keeps a pre-filled background intact under that hole instead of a low-coverage pixel punching it transparent. The destination buffer must be row-major RGBA8 with stride == buf_w * 4 bytes. Quads that fall outside [0, buf_w) x [0, buf_h) are clipped per pixel.

The typical usage pattern is:

auto layout = lay_out(text, atlas, 0.F, 0.F, wrap_w);
for (auto& q : layout.quads) { ... } // per-character transforms
rasterize_quads(layout.quads, atlas, color, pixels, w, h);

Parameters

quads	Quads produced by lay_out(), optionally mutated by the caller.
atlas	Source atlas for coverage bitmaps.
color	RGBA glyph color in [0, 1].
dst	Destination RGBA8 buffer. Stride is buf_w * 4 bytes.
buf_w	Buffer width in pixels.
buf_h	Buffer height in pixels.

Definition at line 244 of file InkPress.cpp.

{
    const uint8_t cr = static_cast<uint8_t>(std::clamp(color.r, 0.F, 1.F) * 255.F);
    const uint8_t cg = static_cast<uint8_t>(std::clamp(color.g, 0.F, 1.F) * 255.F);
    const uint8_t cb = static_cast<uint8_t>(std::clamp(color.b, 0.F, 1.F) * 255.F);
    const uint8_t ca = static_cast<uint8_t>(std::clamp(color.a, 0.F, 1.F) * 255.F);
 
    const Kakshya::TextureContainer& atlas_tex = atlas.texture();
    const std::span<const uint8_t> atlas_pixels = atlas_tex.pixel_bytes(0);
    const uint32_t atlas_size = atlas.atlas_size();
 
    for (const auto& q : quads) {
        const auto gx = static_cast<int32_t>(std::floor(q.x0));
        const auto gy = static_cast<int32_t>(std::floor(q.y0));
        const auto gw = static_cast<uint32_t>(std::ceil(q.x1 - q.x0));
        const auto gh = static_cast<uint32_t>(std::ceil(q.y1 - q.y0));
 
        const auto src_x = static_cast<uint32_t>(q.uv_x0 * static_cast<float>(atlas_size));
        const auto src_y = static_cast<uint32_t>(q.uv_y0 * static_cast<float>(atlas_size));
 
        for (uint32_t row = 0; row < gh; ++row) {
            const int32_t dst_row = gy + static_cast<int32_t>(row);
            if (dst_row < 0 || static_cast<uint32_t>(dst_row) >= buf_h) {
                continue;
            }
 
            const uint8_t* src_row = atlas_pixels.data()
                + static_cast<size_t>(src_y + row) * atlas_size + src_x;
            uint8_t* dst_row_ptr = dst + static_cast<size_t>(dst_row) * buf_w * 4;
 
            for (uint32_t col = 0; col < gw; ++col) {
                const int32_t dst_col = gx + static_cast<int32_t>(col);
                if (dst_col < 0 || static_cast<uint32_t>(dst_col) >= buf_w) {
                    continue;
                }
 
                const uint8_t coverage = src_row[col];
                const uint32_t src_a = (static_cast<uint32_t>(coverage) * static_cast<uint32_t>(ca)) / 255U;
 
                uint8_t* px = dst_row_ptr + static_cast<size_t>(dst_col) * 4;
 
                const uint32_t dst_a = px[3];
                const uint32_t blended_dst_a = (dst_a * (255U - src_a)) / 255U;
                const uint32_t out_a = src_a + blended_dst_a;
 
                if (out_a == 0U) {
                    px[0] = 0;
                    px[1] = 0;
                    px[2] = 0;
                    px[3] = 0;
                } else {
                    px[0] = static_cast<uint8_t>((cr * src_a + px[0] * blended_dst_a) / out_a);
                    px[1] = static_cast<uint8_t>((cg * src_a + px[1] * blended_dst_a) / out_a);
                    px[2] = static_cast<uint8_t>((cb * src_a + px[2] * blended_dst_a) / out_a);
                    px[3] = static_cast<uint8_t>(out_a);
                }
            }
        }
    }
}

References MayaFlux::Portal::Text::GlyphAtlas::atlas_size(), color, dst, MayaFlux::Kakshya::TextureContainer::pixel_bytes(), px, q, src_x, src_y, and MayaFlux::Portal::Text::GlyphAtlas::texture().

Referenced by ink_quads().

Here is the call graph for this function:

Here is the caller graph for this function: