#ifndef SLUI_RENDER_HPP #define SLUI_RENDER_HPP /* ============================================================================= * SleelaUI software rasterizer. * * The toolkit owns its pixels. Every window keeps one Canvas -- a 32-bit * premultiplied-into-opaque framebuffer -- that widgets paint into, and the * platform backend blits that buffer to the screen. Drawing identical pixels on * every OS is what makes the "Slick Black" look pixel-identical on Windows, * macOS, and Linux/Unix instead of inheriting three native widget themes. * * The rasterizer is deliberately small and original: scanline fills with * analytic edge antialiasing for rounded rectangles, Wu-style AA for hairlines, * vertical gradients, and an 8-bit coverage glyph blitter. Text SHAPING and * glyph COVERAGE come from the backend (it owns the real font files); this * module only composites the coverage the backend hands back, so the geometry * and colour of the UI stay backend-independent. * * Max Rupplin -- MEARVK LLC -- 2026 * ===========================================================================*/ #include "slui_geometry.hpp" #include #include #include #include namespace slui { /* A single-channel coverage bitmap for one laid-out glyph, in device pixels. * The backend's font rasterizer fills `coverage` (8-bit alpha, row-major) and * reports the pen advance so the Canvas can place the next glyph. */ struct GlyphBitmap { int left = 0; /* bearing from pen origin to bitmap left edge */ int top = 0; /* bearing from baseline up to bitmap top edge */ int width = 0; int height = 0; double advance = 0.0; /* horizontal pen advance in pixels */ std::vector coverage; }; class Canvas { public: Canvas() = default; void resize(int w, int h) { if (w < 1) w = 1; if (h < 1) h = 1; if (w == width_ && h == height_) return; width_ = w; height_ = h; pixels_.assign(static_cast(w) * h, 0); clip_ = Rect{0, 0, w, h}; } int width() const { return width_; } int height() const { return height_; } const uint32_t* pixels() const { return pixels_.data(); } uint32_t* pixels() { return pixels_.data(); } /* Stored as 0xAARRGGBB so Win32 (BGRA little-endian), Cocoa, and X11 * (which we feed ZPixmap BGRA) all read the same word order after the * backend's final channel adjust. */ static uint32_t pack(const Color& c) { return (static_cast(c.a) << 24) | (static_cast(c.r) << 16) | (static_cast(c.g) << 8) | static_cast(c.b); } static Color unpack(uint32_t p) { return Color{static_cast((p >> 16) & 0xFF), static_cast((p >> 8) & 0xFF), static_cast(p & 0xFF), static_cast((p >> 24) & 0xFF)}; } void push_clip(const Rect& r) { clip_stack_.push_back(clip_); clip_ = clip_.intersect(r); } void pop_clip() { if (!clip_stack_.empty()) { clip_ = clip_stack_.back(); clip_stack_.pop_back(); } } void clear(const Color& c) { uint32_t p = pack(c.with_alpha(255)); std::fill(pixels_.begin(), pixels_.end(), p); } /* Compositing modes mirrored by the public SLUIBlendMode. */ enum class BlendMode { Over, Copy, Add, Multiply, Screen, Max }; void set_blend(BlendMode m) { blend_mode_ = m; } BlendMode blend_mode() const { return blend_mode_; } void set_opacity(double o) { opacity_ = std::clamp(o, 0.0, 1.0); } double opacity() const { return opacity_; } /* Blend one pixel with coverage [0..1] applied to the source alpha, under * the active blend mode and layer opacity. */ void blend(int x, int y, const Color& src, double coverage) { if (coverage <= 0.0) return; if (!clip_.contains(x, y)) return; double a = src.a * coverage * opacity_; if (a <= 0.0) return; Color s = src; s.a = static_cast(std::clamp(a, 0.0, 255.0) + 0.5); if (s.a == 0) return; size_t idx = static_cast(y) * width_ + x; Color dst = unpack(pixels_[idx]); Color out = composite(s, dst); out.a = 255; /* window buffer is opaque */ pixels_[idx] = pack(out); } /* Read a pixel as straight-alpha (front buffer). */ Color get_pixel(int x, int y) const { if (x < 0 || y < 0 || x >= width_ || y >= height_) return Color{0, 0, 0, 0}; return unpack(pixels_[static_cast(y) * width_ + x]); } void fill_rect(const Rect& r, const Color& c) { Rect a = r.intersect(clip_); for (int y = a.y; y < a.bottom(); ++y) for (int x = a.x; x < a.right(); ++x) blend(x, y, c, 1.0); } /* Antialiased rounded-rectangle fill. Coverage comes from a signed-distance * test against the rounded boundary, sampled at pixel centres. radius is * clamped to half the smaller side. */ void fill_round_rect(const Rect& r, double radius, const Color& c) { if (r.empty()) return; radius = std::clamp(radius, 0.0, std::min(r.w, r.h) / 2.0); Rect a = r.intersect(clip_); double rl = r.x + radius, rt = r.y + radius; double rr = r.right() - radius, rb = r.bottom() - radius; for (int y = a.y; y < a.bottom(); ++y) { double py = y + 0.5; for (int x = a.x; x < a.right(); ++x) { double px = x + 0.5; double cov = round_rect_coverage(px, py, r, radius, rl, rt, rr, rb); blend(x, y, c, cov); } } } /* A 1px (or `thickness`px) hairline border following the rounded outline. */ void stroke_round_rect(const Rect& r, double radius, double thickness, const Color& c) { if (r.empty() || thickness <= 0.0) return; radius = std::clamp(radius, 0.0, std::min(r.w, r.h) / 2.0); Rect a = r.intersect(clip_); double rl = r.x + radius, rt = r.y + radius; double rr = r.right() - radius, rb = r.bottom() - radius; for (int y = a.y; y < a.bottom(); ++y) { double py = y + 0.5; for (int x = a.x; x < a.right(); ++x) { double px = x + 0.5; double d = round_rect_distance(px, py, r, radius, rl, rt, rr, rb); /* d is signed: <0 inside, >0 outside. The stroke is a band * centred on the boundary. */ double half = thickness / 2.0; double cov = 1.0 - smooth_edge(std::fabs(d) - half); blend(x, y, c, cov); } } } /* Vertical top->bottom gradient fill of a rounded rectangle. */ void fill_round_rect_vgrad(const Rect& r, double radius, const Color& top, const Color& bottom) { if (r.empty()) return; radius = std::clamp(radius, 0.0, std::min(r.w, r.h) / 2.0); Rect a = r.intersect(clip_); double rl = r.x + radius, rt = r.y + radius; double rr = r.right() - radius, rb = r.bottom() - radius; for (int y = a.y; y < a.bottom(); ++y) { double py = y + 0.5; double t = r.h > 1 ? (py - r.y) / static_cast(r.h) : 0.0; Color row = lerp(top, bottom, t); for (int x = a.x; x < a.right(); ++x) { double px = x + 0.5; double cov = round_rect_coverage(px, py, r, radius, rl, rt, rr, rb); blend(x, y, row, cov); } } } /* A horizontal or vertical 1px hairline (used for separators). */ void hline(int x0, int x1, int y, const Color& c) { if (x1 < x0) std::swap(x0, x1); for (int x = x0; x <= x1; ++x) blend(x, y, c, 1.0); } void vline(int x, int y0, int y1, const Color& c) { if (y1 < y0) std::swap(y0, y1); for (int y = y0; y <= y1; ++y) blend(x, y, c, 1.0); } /* Composite a glyph coverage bitmap at device position (pen_x, baseline). */ void blit_glyph(const GlyphBitmap& g, int pen_x, int baseline, const Color& c) { int gx = pen_x + g.left; int gy = baseline - g.top; for (int row = 0; row < g.height; ++row) { int y = gy + row; for (int col = 0; col < g.width; ++col) { int x = gx + col; uint8_t a = g.coverage[static_cast(row) * g.width + col]; if (a) blend(x, y, c, a / 255.0); } } } /* ---- Extended primitives for the Draw API ------------------------- */ /* Antialiased thick line (round caps) via per-pixel distance to segment. */ void line(double x0, double y0, double x1, double y1, double thickness, const Color& c) { double half = std::max(thickness, 0.5) / 2.0; int minx = static_cast(std::floor(std::min(x0, x1) - half - 1)); int maxx = static_cast(std::ceil(std::max(x0, x1) + half + 1)); int miny = static_cast(std::floor(std::min(y0, y1) - half - 1)); int maxy = static_cast(std::ceil(std::max(y0, y1) + half + 1)); double dx = x1 - x0, dy = y1 - y0; double len2 = dx * dx + dy * dy; for (int y = miny; y <= maxy; ++y) { for (int x = minx; x <= maxx; ++x) { double px = x + 0.5, py = y + 0.5; double t = len2 > 0 ? ((px - x0) * dx + (py - y0) * dy) / len2 : 0.0; t = std::clamp(t, 0.0, 1.0); double qx = x0 + t * dx, qy = y0 + t * dy; double d = std::sqrt((px - qx) * (px - qx) + (py - qy) * (py - qy)); double cov = 1.0 - smooth_edge(d - half); blend(x, y, c, cov); } } } void fill_circle(double cx, double cy, double r, const Color& c) { if (r <= 0) return; int minx = static_cast(std::floor(cx - r - 1)); int maxx = static_cast(std::ceil(cx + r + 1)); int miny = static_cast(std::floor(cy - r - 1)); int maxy = static_cast(std::ceil(cy + r + 1)); for (int y = miny; y <= maxy; ++y) { for (int x = minx; x <= maxx; ++x) { double d = std::sqrt((x + 0.5 - cx) * (x + 0.5 - cx) + (y + 0.5 - cy) * (y + 0.5 - cy)); blend(x, y, c, 1.0 - smooth_edge(d - r)); } } } void fill_ellipse(double cx, double cy, double rx, double ry, const Color& c) { if (rx <= 0 || ry <= 0) return; int minx = static_cast(std::floor(cx - rx - 1)); int maxx = static_cast(std::ceil(cx + rx + 1)); int miny = static_cast(std::floor(cy - ry - 1)); int maxy = static_cast(std::ceil(cy + ry + 1)); for (int y = miny; y <= maxy; ++y) { for (int x = minx; x <= maxx; ++x) { double nx = (x + 0.5 - cx) / rx; double ny = (y + 0.5 - cy) / ry; double d = std::sqrt(nx * nx + ny * ny); /* ~1 at the edge */ /* scale the smoothstep band to roughly one pixel */ double edge = (d - 1.0) * std::min(rx, ry); blend(x, y, c, 1.0 - smooth_edge(edge)); } } } void stroke_circle(double cx, double cy, double r, double thickness, const Color& c) { double half = thickness / 2.0; int minx = static_cast(std::floor(cx - r - half - 1)); int maxx = static_cast(std::ceil(cx + r + half + 1)); int miny = static_cast(std::floor(cy - r - half - 1)); int maxy = static_cast(std::ceil(cy + r + half + 1)); for (int y = miny; y <= maxy; ++y) { for (int x = minx; x <= maxx; ++x) { double d = std::sqrt((x + 0.5 - cx) * (x + 0.5 - cx) + (y + 0.5 - cy) * (y + 0.5 - cy)); blend(x, y, c, 1.0 - smooth_edge(std::fabs(d - r) - half)); } } } /* Stroked arc from start to start+sweep (radians), 0 = +x, CW in screen y. */ void arc(double cx, double cy, double r, double start, double sweep, double thickness, const Color& c) { double half = thickness / 2.0; int minx = static_cast(std::floor(cx - r - half - 1)); int maxx = static_cast(std::ceil(cx + r + half + 1)); int miny = static_cast(std::floor(cy - r - half - 1)); int maxy = static_cast(std::ceil(cy + r + half + 1)); double end = start + sweep; for (int y = miny; y <= maxy; ++y) { for (int x = minx; x <= maxx; ++x) { double vx = x + 0.5 - cx, vy = y + 0.5 - cy; double d = std::sqrt(vx * vx + vy * vy); double radial = 1.0 - smooth_edge(std::fabs(d - r) - half); if (radial <= 0.0) continue; double ang = std::atan2(vy, vx); /* normalise ang into [start, start+2pi) and test the sweep */ double rel = ang - start; while (rel < 0) rel += 2.0 * 3.14159265358979323846; while (rel >= 2.0 * 3.14159265358979323846) rel -= 2.0 * 3.14159265358979323846; double s = std::fabs(sweep); double inside = (rel <= s) ? 1.0 : 0.0; /* soften the two angular ends by ~1px worth of arc */ double soft = r > 0 ? 1.5 / r : 0.0; if (rel > s && rel < s + soft) inside = 1.0 - (rel - s) / soft; (void)end; blend(x, y, c, radial * inside); } } } void fill_triangle(double x0, double y0, double x1, double y1, double x2, double y2, const Color& c) { int minx = static_cast(std::floor(std::min({x0, x1, x2}))); int maxx = static_cast(std::ceil(std::max({x0, x1, x2}))); int miny = static_cast(std::floor(std::min({y0, y1, y2}))); int maxy = static_cast(std::ceil(std::max({y0, y1, y2}))); auto edge = [](double ax, double ay, double bx, double by, double px, double py) { return (px - ax) * (by - ay) - (py - ay) * (bx - ax); }; double area = edge(x0, y0, x1, y1, x2, y2); if (area == 0) return; for (int y = miny; y <= maxy; ++y) { for (int x = minx; x <= maxx; ++x) { double px = x + 0.5, py = y + 0.5; double w0 = edge(x1, y1, x2, y2, px, py); double w1 = edge(x2, y2, x0, y0, px, py); double w2 = edge(x0, y0, x1, y1, px, py); bool inside = (area > 0) ? (w0 >= 0 && w1 >= 0 && w2 >= 0) : (w0 <= 0 && w1 <= 0 && w2 <= 0); if (inside) blend(x, y, c, 1.0); } } } void radial_gradient(double cx, double cy, double r, const Color& inner, const Color& outer) { if (r <= 0) return; int minx = static_cast(std::floor(cx - r)); int maxx = static_cast(std::ceil(cx + r)); int miny = static_cast(std::floor(cy - r)); int maxy = static_cast(std::ceil(cy + r)); for (int y = miny; y <= maxy; ++y) { for (int x = minx; x <= maxx; ++x) { double d = std::sqrt((x + 0.5 - cx) * (x + 0.5 - cx) + (y + 0.5 - cy) * (y + 0.5 - cy)); if (d > r + 1) continue; double t = std::clamp(d / r, 0.0, 1.0); Color col = lerp(inner, outer, t); double cov = 1.0 - smooth_edge(d - r); blend(x, y, col, cov); } } } /* Copy another canvas's pixels at (dx,dy) under the active blend/opacity. */ void blit(const Canvas& src, int dx, int dy, const Rect& srcRect) { for (int sy = srcRect.y; sy < srcRect.bottom(); ++sy) { for (int sx = srcRect.x; sx < srcRect.right(); ++sx) { Color s = src.get_pixel(sx, sy); if (s.a == 0) continue; blend(dx + (sx - srcRect.x), dy + (sy - srcRect.y), s, s.a / 255.0 == 0 ? 0.0 : 1.0); } } } private: /* Composite src OVER/into dst under the active blend mode. */ Color composite(const Color& src, const Color& dst) const { switch (blend_mode_) { case BlendMode::Copy: return src; case BlendMode::Add: return Color{ static_cast(std::min(255, dst.r + src.r * src.a / 255)), static_cast(std::min(255, dst.g + src.g * src.a / 255)), static_cast(std::min(255, dst.b + src.b * src.a / 255)), 255}; case BlendMode::Multiply: return Color{static_cast(dst.r * src.r / 255), static_cast(dst.g * src.g / 255), static_cast(dst.b * src.b / 255), 255}; case BlendMode::Screen: return Color{ static_cast(255 - (255 - dst.r) * (255 - src.r) / 255), static_cast(255 - (255 - dst.g) * (255 - src.g) / 255), static_cast(255 - (255 - dst.b) * (255 - src.b) / 255), 255}; case BlendMode::Max: return Color{std::max(dst.r, src.r), std::max(dst.g, src.g), std::max(dst.b, src.b), 255}; case BlendMode::Over: default: return over(src, dst); } } /* Smoothstep edge over a 1px band: 0 well inside, 1 well outside. */ static double smooth_edge(double d) { if (d <= -0.5) return 0.0; if (d >= 0.5) return 1.0; double t = d + 0.5; /* 0..1 */ return t * t * (3.0 - 2.0 * t); } /* Signed distance from (px,py) to the rounded-rect boundary. */ static double round_rect_distance(double px, double py, const Rect& r, double radius, double rl, double rt, double rr, double rb) { if (radius <= 0.0) { double dx = std::max(r.x - px, px - r.right()); double dy = std::max(r.y - py, py - r.bottom()); return std::max(dx, dy); } double cx = std::clamp(px, rl, rr); double cy = std::clamp(py, rt, rb); double dx = px - cx, dy = py - cy; return std::sqrt(dx * dx + dy * dy) - radius; } static double round_rect_coverage(double px, double py, const Rect& r, double radius, double rl, double rt, double rr, double rb) { double d = round_rect_distance(px, py, r, radius, rl, rt, rr, rb); return 1.0 - smooth_edge(d); } int width_ = 1; int height_ = 1; std::vector pixels_{0}; Rect clip_{0, 0, 1, 1}; std::vector clip_stack_; BlendMode blend_mode_ = BlendMode::Over; double opacity_ = 1.0; }; } // namespace slui #endif /* SLUI_RENDER_HPP */