/* ============================================================================= * SleelaUI Font & Font-effect implementation. * * Backs sleela_ui_font.h. A font is a face (family/size/weight/slant/spacing) * plus an ordered stack of effects. Rendering is a two-stage pipeline over the * toolkit's rasterizer: * * 1. COVERAGE. We rasterize the string once into an 8-bit coverage MASK (a * little scratch bitmap) via the shared text backend -- the union of every * glyph's coverage, with letter spacing and a synthetic oblique shear if * requested. Measuring the mask once lets every effect reuse it. * 2. COMPOSITE. Effects are drawn back-to-front into the draw context from the * mask: drop/inner shadows (offset + box-blurred dark copies), a soft glow * (blurred, additive, coloured halo), an outline (the mask dilated by the * stroke width), a relief emboss/engrave (shade the mask by a lighting * normal built from the coverage gradient), a gradient or flat FILL, and a * directional light sheen on the glyph face. An EMITTER effect doesn't draw * -- it radiates into a light scene (reserving nothing, or binding as a * source on an anchor) exactly like the Lighting layer's emitters. * * Quality (draft..ultra) scales the blur taps and the outline/relief angular * samples, so a developer can dial richness up or down per font. * * All pixels come from the toolkit's own rasterizer, so a styled string is * identical on every backend. * * Max Rupplin -- MEARVK LLC -- 2026 * ===========================================================================*/ #include "sleela_ui_font.h" #include "sleela_ui_light.h" #include "slui_backend.hpp" #include "slui_render.hpp" #include #include #include #include #include using slui::Backend; using slui::Color; using slui::GlyphBitmap; /* ---- UTF-8 decode (one scalar) ------------------------------------------ */ static uint32_t next_scalar(const std::string& s, size_t& i) { unsigned char c = static_cast(s[i]); uint32_t cp; int extra; if (c < 0x80) { cp = c; extra = 0; } else if ((c >> 5) == 0x6) { cp = c & 0x1F; extra = 1; } else if ((c >> 4) == 0xE) { cp = c & 0x0F; extra = 2; } else if ((c >> 3) == 0x1E) { cp = c & 0x07; extra = 3; } else { cp = 0xFFFD; extra = 0; } ++i; for (int k = 0; k < extra && i < s.size(); ++k, ++i) cp = (cp << 6) | (static_cast(s[i]) & 0x3F); return cp; } /* ---- SLUIFont ----------------------------------------------------------- */ struct SLUIFont { std::string family = "system"; double size = 11.0; SLUIFontWeight weight = SLUI_FONT_REGULAR; SLUIFontSlant slant = SLUI_SLANT_UPRIGHT; double letter_spacing = 0.0; double line_height_mult = 1.3; SLUIFontQuality quality = SLUI_QUALITY_MEDIUM; std::vector effects; }; /* A single-channel coverage mask with an origin offset so effects know where * the baseline/pen sits inside it. */ struct Mask { int w = 0, h = 0; int ox = 0, oy = 0; /* pen origin (x,baseline) inside the mask */ std::vector a; uint8_t at(int x, int y) const { if (x < 0 || y < 0 || x >= w || y >= h) return 0; return a[static_cast(y) * w + x]; } }; static Color decode(SLUIColor c) { return Color{static_cast((c >> 24) & 0xFF), static_cast((c >> 16) & 0xFF), static_cast((c >> 8) & 0xFF), static_cast(c & 0xFF)}; } static double clampd(double v, double lo, double hi) { return v < lo ? lo : (v > hi ? hi : v); } static void apply_face(Backend* be, SLUIFont* f) { be->set_font(f->family, static_cast(f->size + 0.5)); } /* Rasterize `utf8` to a coverage mask with padding `pad` around it. */ static Mask build_mask(Backend* be, SLUIFont* f, const std::string& utf8, int pad) { apply_face(be, f); double asc = be->font_ascent(), desc = be->font_descent(); /* First pass: total advance. */ double adv = 0; for (size_t i = 0; i < utf8.size();) { uint32_t cp = next_scalar(utf8, i); adv += be->glyph_advance(cp) + f->letter_spacing; } int tw = static_cast(adv + 0.5); if (tw < 1) tw = 1; int th = static_cast(asc + desc + 0.5); if (th < 1) th = 1; Mask m; m.w = tw + pad * 2; m.h = th + pad * 2; m.ox = pad; m.oy = pad + static_cast(asc + 0.5); /* baseline row */ m.a.assign(static_cast(m.w) * m.h, 0); /* Synthetic oblique shear slope (used when slant requested; a real italic * face would already shear, but we add a gentle extra for OBLIQUE). */ double shear = (f->slant == SLUI_SLANT_OBLIQUE) ? 0.22 : 0.0; double pen = 0; for (size_t i = 0; i < utf8.size();) { uint32_t cp = next_scalar(utf8, i); GlyphBitmap g; if (be->rasterize_glyph(cp, &g)) { int gx = m.ox + static_cast(pen + 0.5) + g.left; int gy = m.oy - g.top; for (int row = 0; row < g.height; ++row) { int sh = static_cast(shear * (g.top - row)); for (int colp = 0; colp < g.width; ++colp) { uint8_t cov = g.coverage[static_cast(row) * g.width + colp]; if (!cov) continue; int x = gx + colp + sh; int y = gy + row; if (x < 0 || y < 0 || x >= m.w || y >= m.h) continue; uint8_t& dst = m.a[static_cast(y) * m.w + x]; dst = std::max(dst, cov); /* union of glyph coverage */ } } pen += g.advance + f->letter_spacing; } else { pen += be->glyph_advance(cp) + f->letter_spacing; } } /* Faux-bold: dilate the coverage by 1px for heavy weights. */ if (f->weight >= SLUI_FONT_BOLD) { std::vector src = m.a; for (int y = 0; y < m.h; ++y) for (int x = 0; x < m.w; ++x) { uint8_t mx = src[static_cast(y) * m.w + x]; if (x + 1 < m.w) mx = std::max(mx, src[static_cast(y) * m.w + x + 1]); m.a[static_cast(y) * m.w + x] = mx; } } return m; } /* Separable box blur of a coverage mask, `radius` px, `taps` passes. Returns a * new float field (0..1) the caller composites. */ static std::vector blur_mask(const Mask& m, double radius, int taps) { std::vector cur(static_cast(m.w) * m.h); for (size_t i = 0; i < cur.size(); ++i) cur[i] = m.a[i] / 255.0; int r = std::max(1, static_cast(radius + 0.5)); for (int pass = 0; pass < taps; ++pass) { std::vector tmp(cur.size(), 0.0); /* horizontal */ for (int y = 0; y < m.h; ++y) { for (int x = 0; x < m.w; ++x) { double s = 0; int n = 0; for (int k = -r; k <= r; ++k) { int xx = x + k; if (xx < 0 || xx >= m.w) continue; s += cur[static_cast(y) * m.w + xx]; ++n; } tmp[static_cast(y) * m.w + x] = n ? s / n : 0; } } /* vertical */ for (int x = 0; x < m.w; ++x) { for (int y = 0; y < m.h; ++y) { double s = 0; int n = 0; for (int k = -r; k <= r; ++k) { int yy = y + k; if (yy < 0 || yy >= m.h) continue; s += tmp[static_cast(yy) * m.w + x]; ++n; } cur[static_cast(y) * m.w + x] = n ? s / n : 0; } } } return cur; } static int quality_taps(SLUIFontQuality q) { switch (q) { case SLUI_QUALITY_DRAFT: return 1; case SLUI_QUALITY_LOW: return 1; case SLUI_QUALITY_MEDIUM: return 2; case SLUI_QUALITY_HIGH: return 3; case SLUI_QUALITY_ULTRA: return 4; default: return 2; } } static int quality_angles(SLUIFontQuality q) { switch (q) { case SLUI_QUALITY_DRAFT: return 4; case SLUI_QUALITY_LOW: return 6; case SLUI_QUALITY_MEDIUM: return 8; case SLUI_QUALITY_HIGH: return 16; case SLUI_QUALITY_ULTRA: return 32; default: return 8; } } /* Composite a blurred float field tinted `c` at offset (dx,dy) into dc. */ static void composite_field(SLUIDrawContext* dc, const Mask& m, const std::vector& field, int base_x, int base_y, double dx, double dy, Color c, double opacity, SLUIBlendMode mode) { SLUIBlendMode prev = slui_draw_get_blend(dc); slui_draw_set_blend(dc, mode); for (int y = 0; y < m.h; ++y) { for (int x = 0; x < m.w; ++x) { double a = field[static_cast(y) * m.w + x]; if (a <= 0.003) continue; int px = base_x + (x - m.ox) + static_cast(dx + 0.5); int py = base_y + (y - m.oy) + static_cast(dy + 0.5); SLUIColor word = slui_rgba(c.r, c.g, c.b, 255); slui_draw_blend_pixel(dc, px, py, word, clampd(a * opacity, 0.0, 1.0)); } } slui_draw_set_blend(dc, prev); } /* ========================================================================== * Effect builders * ========================================================================== */ extern "C" { static SLUIFontEffect fx_zero(SLUIFontEffectType t) { SLUIFontEffect e; std::memset(&e, 0, sizeof(e)); e.type = t; e.opacity = 1.0; e.intensity = 1.0; e.reserved_anchor = -1; return e; } SLUIFontEffect slui_fx_drop_shadow(double dx, double dy, double blur, SLUIColor color) { SLUIFontEffect e = fx_zero(SLUI_FX_DROP_SHADOW); e.dx = dx; e.dy = dy; e.blur = blur; e.color = color; e.opacity = 0.6; return e; } SLUIFontEffect slui_fx_inner_shadow(double dx, double dy, double blur, SLUIColor color) { SLUIFontEffect e = fx_zero(SLUI_FX_INNER_SHADOW); e.dx = dx; e.dy = dy; e.blur = blur; e.color = color; e.opacity = 0.7; return e; } SLUIFontEffect slui_fx_glow(double radius, double intensity, SLUIColor color) { SLUIFontEffect e = fx_zero(SLUI_FX_GLOW); e.blur = radius; e.intensity = intensity; e.color = color; return e; } SLUIFontEffect slui_fx_light(double dx, double dy, double intensity, SLUIColor color) { SLUIFontEffect e = fx_zero(SLUI_FX_LIGHT); e.dx = dx; e.dy = dy; e.intensity = intensity; e.color = color; return e; } SLUIFontEffect slui_fx_emitter(double radius, double intensity, SLUIColor color, int anchor) { SLUIFontEffect e = fx_zero(SLUI_FX_EMITTER); e.size = radius; e.intensity = intensity; e.color = color; e.reserved_anchor = anchor; return e; } SLUIFontEffect slui_fx_outline(double width, SLUIColor color) { SLUIFontEffect e = fx_zero(SLUI_FX_OUTLINE); e.size = width; e.color = color; return e; } SLUIFontEffect slui_fx_relief(SLUIFontRelief relief, double depth, double intensity) { SLUIFontEffect e = fx_zero(SLUI_FX_RELIEF); e.relief = relief; e.size = depth; e.intensity = intensity; return e; } SLUIFontEffect slui_fx_gradient_fill(SLUIColor top, SLUIColor bottom) { SLUIFontEffect e = fx_zero(SLUI_FX_GRADIENT_FILL); e.color = top; e.color2 = bottom; return e; } /* ========================================================================== * Font lifecycle * ========================================================================== */ SLUIFont* slui_font_create(const char* family, double size_pt) { auto* f = new (std::nothrow) SLUIFont(); if (!f) return nullptr; if (family && family[0]) f->family = family; if (size_pt > 0) f->size = size_pt; return f; } void slui_font_destroy(SLUIFont* f) { delete f; } SLUIFont* slui_font_clone(const SLUIFont* f) { if (!f) return nullptr; return new (std::nothrow) SLUIFont(*f); } void slui_font_set_family(SLUIFont* f, const char* family) { if (f && family) f->family = family; } void slui_font_set_size(SLUIFont* f, double s) { if (f && s > 0) f->size = s; } void slui_font_set_weight(SLUIFont* f, SLUIFontWeight w) { if (f) f->weight = w; } void slui_font_set_slant(SLUIFont* f, SLUIFontSlant s) { if (f) f->slant = s; } void slui_font_set_letter_spacing(SLUIFont* f, double px) { if (f) f->letter_spacing = px; } void slui_font_set_line_height(SLUIFont* f, double mult) { if (f && mult > 0) f->line_height_mult = mult; } void slui_font_set_quality(SLUIFont* f, SLUIFontQuality q) { if (f) f->quality = q; } double slui_font_size(const SLUIFont* f) { return f ? f->size : 0; } SLUIFontQuality slui_font_quality(const SLUIFont* f) { return f ? f->quality : SLUI_QUALITY_MEDIUM; } void slui_font_add_effect(SLUIFont* f, SLUIFontEffect e) { if (f) f->effects.push_back(e); } void slui_font_clear_effects(SLUIFont* f) { if (f) f->effects.clear(); } int slui_font_effect_count(const SLUIFont* f) { return f ? static_cast(f->effects.size()) : 0; } /* ========================================================================== * Measuring * ========================================================================== */ double slui_font_measure(SLUIFont* f, const char* utf8) { if (!f || !utf8) return 0; Backend* be = slui::shared_text_backend(); if (!be) return 0; apply_face(be, f); double adv = 0; std::string s(utf8); for (size_t i = 0; i < s.size();) { uint32_t cp = next_scalar(s, i); adv += be->glyph_advance(cp) + f->letter_spacing; } return adv; } double slui_font_ascent(SLUIFont* f) { Backend* be = slui::shared_text_backend(); if (!f || !be) return 0; apply_face(be, f); return be->font_ascent(); } double slui_font_descent(SLUIFont* f) { Backend* be = slui::shared_text_backend(); if (!f || !be) return 0; apply_face(be, f); return be->font_descent(); } double slui_font_line_height(SLUIFont* f) { Backend* be = slui::shared_text_backend(); if (!f || !be) return 0; apply_face(be, f); return be->font_line_height() * f->line_height_mult; } /* ========================================================================== * Drawing * ========================================================================== */ void slui_font_draw(SLUIDrawContext* dc, SLUIFont* f, const char* utf8, int x, int baseline, SLUIColor color) { if (!dc || !f || !utf8) return; Backend* be = slui::shared_text_backend(); if (!be) return; /* Pad enough for the largest shadow/glow/outline. */ int pad = 2; for (const auto& e : f->effects) { int need = static_cast(std::ceil( std::fabs(e.dx) + std::fabs(e.dy) + e.blur * 3 + e.size + 2)); pad = std::max(pad, need); } Mask m = build_mask(be, f, std::string(utf8), pad); int taps = quality_taps(f->quality); /* ---- back layer: drop shadows (under the glyph) ---- */ for (const auto& e : f->effects) { if (e.type != SLUI_FX_DROP_SHADOW) continue; auto field = blur_mask(m, std::max(0.5, e.blur), taps); composite_field(dc, m, field, x, baseline, e.dx, e.dy, decode(e.color), e.opacity, SLUI_BLEND_OVER); } /* ---- glow (soft additive halo, under/around the glyph) ---- */ for (const auto& e : f->effects) { if (e.type != SLUI_FX_GLOW) continue; auto field = blur_mask(m, std::max(1.0, e.blur), taps + 1); for (auto& v : field) v = clampd(v * (1.0 + e.intensity), 0.0, 1.0); composite_field(dc, m, field, x, baseline, 0, 0, decode(e.color), e.opacity, SLUI_BLEND_ADD); } /* ---- outline (dilate the mask by the stroke width) ---- */ for (const auto& e : f->effects) { if (e.type != SLUI_FX_OUTLINE) continue; int r = std::max(1, static_cast(e.size + 0.5)); int angles = quality_angles(f->quality); std::vector ring(static_cast(m.w) * m.h, 0.0); for (int ai = 0; ai < angles; ++ai) { double a = ai * 2.0 * 3.14159265358979323846 / angles; int ox = static_cast(std::cos(a) * r + 0.5); int oy = static_cast(std::sin(a) * r + 0.5); for (int y = 0; y < m.h; ++y) for (int xx = 0; xx < m.w; ++xx) { double v = m.at(xx - ox, y - oy) / 255.0; double& d = ring[static_cast(y) * m.w + xx]; if (v > d) d = v; } } composite_field(dc, m, ring, x, baseline, 0, 0, decode(e.color), e.opacity, SLUI_BLEND_OVER); } /* ---- the glyph fill (flat, gradient, or relieved) ---- */ bool have_gradient = false, have_relief = false; SLUIFontEffect grad{}, relief{}; for (const auto& e : f->effects) { if (e.type == SLUI_FX_GRADIENT_FILL) { have_gradient = true; grad = e; } if (e.type == SLUI_FX_RELIEF) { have_relief = true; relief = e; } } Color fillc = decode(color); for (int y = 0; y < m.h; ++y) { for (int xx = 0; xx < m.w; ++xx) { double cov = m.a[static_cast(y) * m.w + xx] / 255.0; if (cov <= 0.003) continue; Color c = fillc; if (have_gradient) { /* vertical gradient across the glyph band */ double t = m.h > 1 ? (y - (m.oy - slui_font_ascent(f))) / std::max(1.0, slui_font_ascent(f) + slui_font_descent(f)) : 0.0; c = slui::lerp(decode(grad.color), decode(grad.color2), clampd(t, 0.0, 1.0)); } if (have_relief) { /* normal from the coverage gradient; light from top-left */ double hl = m.at(xx - 1, y) / 255.0; double hr = m.at(xx + 1, y) / 255.0; double hu = m.at(xx, y - 1) / 255.0; double hd = m.at(xx, y + 1) / 255.0; double nx = (hl - hr) * relief.size; double ny = (hu - hd) * relief.size; double nz = 1.0; double L = std::sqrt(nx * nx + ny * ny + nz * nz); /* light direction top-left (engraved flips it) */ double lx = (relief.relief == SLUI_FONT_ENGRAVED) ? 0.5 : -0.5; double ly = (relief.relief == SLUI_FONT_ENGRAVED) ? 0.5 : -0.5; double lz = 0.8; double ndotl = (nx * lx + ny * ly + nz * lz) / (L * 1.07); double shade = clampd(0.6 + relief.intensity * ndotl, 0.2, 1.6); c = Color{static_cast(clampd(c.r * shade, 0, 255)), static_cast(clampd(c.g * shade, 0, 255)), static_cast(clampd(c.b * shade, 0, 255)), 255}; } int px = x + (xx - m.ox); int py = baseline + (y - m.oy); slui_draw_blend_pixel(dc, px, py, slui_rgb(c.r, c.g, c.b), cov); } } /* ---- inner shadow (darken the inside toward one edge) ---- */ for (const auto& e : f->effects) { if (e.type != SLUI_FX_INNER_SHADOW) continue; auto field = blur_mask(m, std::max(0.5, e.blur), taps); for (int y = 0; y < m.h; ++y) for (int xx = 0; xx < m.w; ++xx) { double cov = m.a[static_cast(y) * m.w + xx] / 255.0; if (cov <= 0.003) continue; /* shadow = coverage minus the offset-blurred coverage */ int sx = xx - static_cast(e.dx + 0.5); int sy = y - static_cast(e.dy + 0.5); double inner = (sx >= 0 && sy >= 0 && sx < m.w && sy < m.h) ? field[static_cast(sy) * m.w + sx] : 0.0; double dark = clampd(cov - inner, 0.0, 1.0) * e.opacity; if (dark <= 0.003) continue; int px = x + (xx - m.ox); int py = baseline + (y - m.oy); Color sc = decode(e.color); slui_draw_blend_pixel(dc, px, py, slui_rgb(sc.r, sc.g, sc.b), dark); } } /* ---- directional light sheen on the glyph face (on top) ---- */ for (const auto& e : f->effects) { if (e.type != SLUI_FX_LIGHT) continue; double lx = e.dx, ly = e.dy; double Ln = std::sqrt(lx * lx + ly * ly); if (Ln < 1e-6) { lx = -1; ly = -1; Ln = std::sqrt(2.0); } lx /= Ln; ly /= Ln; for (int y = 0; y < m.h; ++y) for (int xx = 0; xx < m.w; ++xx) { double cov = m.a[static_cast(y) * m.w + xx] / 255.0; if (cov <= 0.02) continue; double hl = m.at(xx - 1, y) / 255.0; double hr = m.at(xx + 1, y) / 255.0; double hu = m.at(xx, y - 1) / 255.0; double hd = m.at(xx, y + 1) / 255.0; double gx = hr - hl, gy = hd - hu; double sheen = clampd(-(gx * lx + gy * ly), 0.0, 1.0); sheen = std::pow(sheen, 1.5) * e.intensity * cov; if (sheen <= 0.01) continue; int px = x + (xx - m.ox); int py = baseline + (y - m.oy); Color lc = decode(e.color); SLUIBlendMode prev = slui_draw_get_blend(dc); slui_draw_set_blend(dc, SLUI_BLEND_ADD); slui_draw_blend_pixel(dc, px, py, slui_rgb(lc.r, lc.g, lc.b), clampd(sheen, 0.0, 1.0)); slui_draw_set_blend(dc, prev); } } } void slui_font_draw_in(SLUIDrawContext* dc, SLUIFont* f, const char* utf8, SLUIRect area, int halign, SLUIColor color) { if (!dc || !f || !utf8) return; double tw = slui_font_measure(f, utf8); double asc = slui_font_ascent(f), desc = slui_font_descent(f); int x = area.x; if (halign == 1) x = area.x + static_cast((area.w - tw) / 2.0); else if (halign == 2) x = area.x + static_cast(area.w - tw); int baseline = area.y + static_cast((area.h - (asc + desc)) / 2.0 + asc + 0.5); slui_font_draw(dc, f, utf8, x, baseline, color); } int slui_font_emit_into_scene(SLUIFont* f, void* light_scene, int x, int baseline, const char* utf8) { if (!f || !light_scene) return SLUI_ERR_INVALID; auto* scene = static_cast(light_scene); const SLUIFontEffect* em = nullptr; for (const auto& e : f->effects) if (e.type == SLUI_FX_EMITTER) { em = &e; break; } if (!em) return 1; /* no emitter effect */ double tw = slui_font_measure(f, utf8); double asc = slui_font_ascent(f); double cx = x + tw / 2.0; double cy = baseline - asc / 2.0; SLUILight light = slui_light_point(cx, cy, em->size > 0 ? em->size : tw, em->intensity, em->color); if (em->reserved_anchor >= 0) { /* bind as a SOURCE reserving the anchor */ return slui_light_scene_add_source(scene, em->reserved_anchor, light); } /* a pure emitter: reserves nothing */ return slui_light_scene_add_emitter(scene, light); } } /* extern "C" */ /* ========================================================================== * Widget integration (needs the C++ widget type). * ========================================================================== */ #include "slui_widget.hpp" extern "C" void slui_widget_set_font(SLUIWidget* widget, SLUIFont* font) { if (!widget) return; auto* w = reinterpret_cast(widget); w->set_styled_font(font); } namespace slui { /* Render a styled run into a scratch draw context, then composite it into the * window canvas. Falls back to plain draw_text when no font is set. */ void draw_text_styled(PaintContext& ctx, void* font, const std::string& utf8, int x, int baseline, const Color& color) { SLUIFont* f = static_cast(font); if (!f || f->effects.empty()) { draw_text(ctx, utf8, x, baseline, color); return; } Backend* be = slui::shared_text_backend(); if (!be || !ctx.canvas) { draw_text(ctx, utf8, x, baseline, color); return; } /* Size a scratch context around the run + effect padding. */ double tw = slui_font_measure(f, utf8.c_str()); double asc = slui_font_ascent(f), desc = slui_font_descent(f); int pad = 4; for (const auto& e : f->effects) { int need = static_cast(std::ceil(std::fabs(e.dx) + std::fabs(e.dy) + e.blur * 3 + e.size + 2)); pad = std::max(pad, need); } int cw = static_cast(tw + 0.5) + pad * 2; int ch = static_cast(asc + desc + 0.5) + pad * 2; if (cw < 1 || ch < 1) return; SLUIDrawContext* dc = slui_draw_create(cw, ch, SLUI_BUFFER_SINGLE); if (!dc) { draw_text(ctx, utf8, x, baseline, color); return; } /* transparent scratch */ slui_draw_clear(dc, 0x00000000u); slui_font_draw(dc, f, utf8.c_str(), pad, pad + static_cast(asc + 0.5), color.to_abi()); /* Composite the scratch (which is opaque where it cleared black) by reading * pixels and blending only the non-background ones. Because clear made it * black-opaque, we instead track coverage by comparing to the cleared * colour would be lossy -- so draw into a transparent-friendly path: the * Canvas is opaque, so we blend every pixel that differs from pure black * weighted by its luminance distance. For crisp text we simply OVER-blend * the scratch's RGB using per-pixel alpha derived from how far it is from * the transparent clear. */ int dstx = x - pad; int dsty = baseline - (pad + static_cast(asc + 0.5)); for (int yy = 0; yy < ch; ++yy) { for (int xx = 0; xx < cw; ++xx) { SLUIColor word = slui_draw_get_pixel(dc, xx, yy); Color px = Color::from_abi(word); /* the scratch was cleared to transparent-black; any drawn pixel has * non-zero rgb. Use max channel as coverage so AA edges carry. */ double cov = std::max({px.r, px.g, px.b}) / 255.0; if (cov <= 0.004) continue; ctx.canvas->blend(dstx + xx, dsty + yy, Color{px.r, px.g, px.b, 255}, cov); } } slui_draw_destroy(dc); } } // namespace slui