daniel/MontaukOS
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: rudimentary userspace desktop environment

Browse Source
This commit is contained in:
Daniel Hammer
2026-02-20 00:48:51 +01:00
parent 3753ebd4f4
commit 6eebc64863
27 changed files with 5027 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files
programs/include/gui/svg.hpp
+972
View File
@@ -0,0 +1,972 @@
/*
* svg.hpp
* ZenithOS SVG icon parser and scanline rasterizer
* Handles the Flat-Remix symbolic icon subset (path, circle, rect)
* All math uses 16.16 fixed-point -- NO floating point.
* Copyright (c) 2025 Daniel Hammer
*/
#pragma once
#include "gui/gui.hpp"
#include <zenith/syscall.h>
namespace gui {
// ---------------------------------------------------------------------------
// SVG icon result
// ---------------------------------------------------------------------------
struct SvgIcon {
uint32_t* pixels; // ARGB pixel data (heap-allocated)
int width;
int height;
};
// ---------------------------------------------------------------------------
// Edge used by the scanline rasterizer
// ---------------------------------------------------------------------------
struct SvgEdge {
fixed_t x0, y0, x1, y1;
};
// ---------------------------------------------------------------------------
// Constants
// ---------------------------------------------------------------------------
static constexpr int SVG_MAX_EDGES = 4096;
static constexpr int SVG_MAX_PATH_LEN = 4096;
static constexpr int SVG_MAX_FILE_SIZE = 32768;
static constexpr int SVG_BEZIER_STEPS = 8;
// ---------------------------------------------------------------------------
// Fixed-point number parser (NO floating point)
// Parses strings like "3.25", "-0.5", ".1115", "16"
// Returns the number of characters consumed.
// ---------------------------------------------------------------------------
inline int svg_parse_fixed(const char* s, fixed_t* out) {
const char* p = s;
bool neg = false;
if (*p == '-') { neg = true; ++p; }
else if (*p == '+') { ++p; }
// Integer part
int32_t integer = 0;
while (*p >= '0' && *p <= '9') {
integer = integer * 10 + (*p - '0');
++p;
}
// Fractional part
int32_t frac = 0;
int32_t frac_div = 1;
if (*p == '.') {
++p;
while (*p >= '0' && *p <= '9') {
if (frac_div < 100000) { // prevent overflow
frac = frac * 10 + (*p - '0');
frac_div *= 10;
}
++p;
}
}
fixed_t val = int_to_fixed(integer);
if (frac_div > 1) {
val += (int32_t)(((int64_t)frac << 16) / frac_div);
}
if (neg) val = -val;
*out = val;
return (int)(p - s);
}
// ---------------------------------------------------------------------------
// String helpers (no stdlib)
// ---------------------------------------------------------------------------
inline bool svg_char_is_ws(char c) {
return c == ' ' || c == '\t' || c == '\n' || c == '\r';
}
inline bool svg_char_is_sep(char c) {
return svg_char_is_ws(c) || c == ',';
}
inline bool svg_char_is_num_start(char c) {
return (c >= '0' && c <= '9') || c == '-' || c == '+' || c == '.';
}
inline bool svg_char_is_cmd(char c) {
return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
}
inline int svg_strlen(const char* s) {
int n = 0;
while (s[n]) ++n;
return n;
}
inline bool svg_strncmp(const char* a, const char* b, int n) {
for (int i = 0; i < n; ++i)
if (a[i] != b[i]) return false;
return true;
}
inline void svg_memset(void* dst, uint8_t val, int n) {
auto* d = (uint8_t*)dst;
for (int i = 0; i < n; ++i) d[i] = val;
}
inline void svg_memcpy(void* dst, const void* src, int n) {
auto* d = (uint8_t*)dst;
auto* s = (const uint8_t*)src;
for (int i = 0; i < n; ++i) d[i] = s[i];
}
// ---------------------------------------------------------------------------
// Mini XML attribute extraction
// ---------------------------------------------------------------------------
// Find the next occurrence of needle in haystack (haystack has length hLen).
// Returns pointer to start of match, or nullptr.
inline const char* svg_strstr(const char* haystack, int hLen, const char* needle) {
int nLen = svg_strlen(needle);
if (nLen == 0 || nLen > hLen) return nullptr;
for (int i = 0; i <= hLen - nLen; ++i) {
if (svg_strncmp(haystack + i, needle, nLen))
return haystack + i;
}
return nullptr;
}
// Check if a character can be part of an XML attribute name
inline bool svg_char_is_attrname(char c) {
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
(c >= '0' && c <= '9') || c == '-' || c == '_' || c == ':';
}
// Extract the value of an XML attribute: attr="value"
// The attr string should include a leading space (e.g., " cx") to distinguish
// from substrings of other attribute names.
// Writes into buf (up to maxLen-1 chars), returns length or -1 if not found.
inline int svg_get_attr(const char* tag, int tagLen, const char* attr, char* buf, int maxLen) {
int attrLen = svg_strlen(attr);
const char* search_start = tag;
int search_len = tagLen;
while (search_len > 0) {
const char* p = svg_strstr(search_start, search_len, attr);
if (!p) return -1;
// Ensure this is the exact attribute name, not a prefix of another
// (e.g., " r" should not match " rx" or " ry")
const char* after_name = p + attrLen;
if (after_name < tag + tagLen && svg_char_is_attrname(*after_name)) {
// This is a prefix of a longer attribute name, skip and search again
search_start = after_name;
search_len = tagLen - (int)(search_start - tag);
continue;
}
p = after_name;
// skip whitespace around '='
while (p < tag + tagLen && svg_char_is_ws(*p)) ++p;
if (p >= tag + tagLen || *p != '=') return -1;
++p;
while (p < tag + tagLen && svg_char_is_ws(*p)) ++p;
if (p >= tag + tagLen) return -1;
char quote = *p;
if (quote != '"' && quote != '\'') return -1;
++p;
int len = 0;
while (p < tag + tagLen && *p != quote && len < maxLen - 1) {
buf[len++] = *p++;
}
buf[len] = '\0';
return len;
}
return -1;
}
// Parse an integer from a string (no sign, simple decimal).
inline int svg_parse_int(const char* s) {
int v = 0;
while (*s >= '0' && *s <= '9') {
v = v * 10 + (*s - '0');
++s;
}
return v;
}
// Parse a hex color like "#5c616c" into a Color.
inline Color svg_parse_hex_color(const char* s) {
if (*s == '#') ++s;
auto hexval = [](char c) -> uint8_t {
if (c >= '0' && c <= '9') return c - '0';
if (c >= 'a' && c <= 'f') return 10 + (c - 'a');
if (c >= 'A' && c <= 'F') return 10 + (c - 'A');
return 0;
};
uint8_t r = (hexval(s[0]) << 4) | hexval(s[1]);
uint8_t g = (hexval(s[2]) << 4) | hexval(s[3]);
uint8_t b = (hexval(s[4]) << 4) | hexval(s[5]);
return Color::from_rgb(r, g, b);
}
// ---------------------------------------------------------------------------
// Edge list builder
// ---------------------------------------------------------------------------
struct SvgEdgeList {
SvgEdge* edges;
int count;
int capacity;
void init(int cap) {
edges = (SvgEdge*)zenith::alloc(cap * sizeof(SvgEdge));
count = 0;
capacity = cap;
}
void add(fixed_t x0, fixed_t y0, fixed_t x1, fixed_t y1) {
if (count >= capacity) return;
// skip horizontal edges (they don't contribute to scanline crossings)
if (y0 == y1) return;
edges[count++] = {x0, y0, x1, y1};
}
};
// ---------------------------------------------------------------------------
// Bezier flattening (fixed-point)
// ---------------------------------------------------------------------------
// Cubic bezier: add line segments approximating B(t) for t in [0,1]
inline void svg_flatten_cubic(SvgEdgeList& el,
fixed_t x0, fixed_t y0,
fixed_t x1, fixed_t y1,
fixed_t x2, fixed_t y2,
fixed_t x3, fixed_t y3) {
constexpr int N = SVG_BEZIER_STEPS;
fixed_t px = x0, py = y0;
for (int i = 1; i <= N; ++i) {
// t = i/N in 16.16: (i << 16) / N
fixed_t t = (int32_t)(((int64_t)i << 16) / N);
fixed_t omt = int_to_fixed(1) - t; // 1 - t
// (1-t)^2 and t^2
fixed_t omt2 = fixed_mul(omt, omt);
fixed_t t2 = fixed_mul(t, t);
// (1-t)^3 and t^3
fixed_t omt3 = fixed_mul(omt2, omt);
fixed_t t3 = fixed_mul(t2, t);
// 3*(1-t)^2*t and 3*(1-t)*t^2
fixed_t c1 = fixed_mul(omt2, t) * 3;
fixed_t c2 = fixed_mul(omt, t2) * 3;
fixed_t nx = fixed_mul(omt3, x0) + fixed_mul(c1, x1) + fixed_mul(c2, x2) + fixed_mul(t3, x3);
fixed_t ny = fixed_mul(omt3, y0) + fixed_mul(c1, y1) + fixed_mul(c2, y2) + fixed_mul(t3, y3);
el.add(px, py, nx, ny);
px = nx;
py = ny;
}
}
// Quadratic bezier: add line segments approximating B(t) for t in [0,1]
inline void svg_flatten_quad(SvgEdgeList& el,
fixed_t x0, fixed_t y0,
fixed_t x1, fixed_t y1,
fixed_t x2, fixed_t y2) {
constexpr int N = SVG_BEZIER_STEPS;
fixed_t px = x0, py = y0;
for (int i = 1; i <= N; ++i) {
fixed_t t = (int32_t)(((int64_t)i << 16) / N);
fixed_t omt = int_to_fixed(1) - t;
// (1-t)^2*P0 + 2*(1-t)*t*P1 + t^2*P2
fixed_t omt2 = fixed_mul(omt, omt);
fixed_t t2 = fixed_mul(t, t);
fixed_t c1 = fixed_mul(omt, t) * 2;
fixed_t nx = fixed_mul(omt2, x0) + fixed_mul(c1, x1) + fixed_mul(t2, x2);
fixed_t ny = fixed_mul(omt2, y0) + fixed_mul(c1, y1) + fixed_mul(t2, y2);
el.add(px, py, nx, ny);
px = nx;
py = ny;
}
}
// ---------------------------------------------------------------------------
// Circle to edges: approximate a circle as N line segments
// ---------------------------------------------------------------------------
inline void svg_circle_edges(SvgEdgeList& el, fixed_t cx, fixed_t cy, fixed_t r) {
// Approximate circle with 16 segments using a precomputed sin/cos table
// for angles 0, 22.5, 45, ... 337.5 degrees.
// sin/cos in 16.16 fixed-point for 16 evenly-spaced angles:
static const fixed_t cos16[16] = {
65536, 60547, 46341, 25080, 0, -25080, -46341, -60547,
-65536, -60547, -46341, -25080, 0, 25080, 46341, 60547
};
static const fixed_t sin16[16] = {
0, 25080, 46341, 60547, 65536, 60547, 46341, 25080,
0, -25080, -46341, -60547, -65536, -60547, -46341, -25080
};
fixed_t px = cx + fixed_mul(r, cos16[0]);
fixed_t py = cy + fixed_mul(r, sin16[0]);
for (int i = 1; i <= 16; ++i) {
int idx = i & 15;
fixed_t nx = cx + fixed_mul(r, cos16[idx]);
fixed_t ny = cy + fixed_mul(r, sin16[idx]);
el.add(px, py, nx, ny);
px = nx;
py = ny;
}
}
// ---------------------------------------------------------------------------
// Rounded rect to edges
// ---------------------------------------------------------------------------
inline void svg_rect_edges(SvgEdgeList& el, fixed_t x, fixed_t y, fixed_t w, fixed_t h,
fixed_t rx, fixed_t ry) {
if (rx <= 0 && ry <= 0) {
// Simple rectangle: 4 edges
fixed_t x2 = x + w;
fixed_t y2 = y + h;
el.add(x, y, x2, y); // top
el.add(x2, y, x2, y2); // right
el.add(x2, y2, x, y2); // bottom
el.add(x, y2, x, y); // left
return;
}
// Clamp radii
fixed_t half_w = w >> 1;
fixed_t half_h = h >> 1;
if (rx > half_w) rx = half_w;
if (ry > half_h) ry = half_h;
// Quarter-circle corner with 4 segments per corner.
// cos/sin for 0, 22.5, 45, 67.5, 90 degrees (5 points, 4 segments):
static const fixed_t qcos[5] = { 65536, 60547, 46341, 25080, 0 };
static const fixed_t qsin[5] = { 0, 25080, 46341, 60547, 65536 };
// Corners: top-right, bottom-right, bottom-left, top-left
// Each corner has a center and a quadrant direction for cos/sin application
struct Corner { fixed_t cx, cy; int sx, sy; };
Corner corners[4] = {
{ x + w - rx, y + ry, 1, -1 }, // top-right
{ x + w - rx, y + h - ry, 1, 1 }, // bottom-right
{ x + rx, y + h - ry, -1, 1 }, // bottom-left
{ x + rx, y + ry, -1, -1 }, // top-left
};
for (int c = 0; c < 4; ++c) {
Corner& cn = corners[c];
fixed_t px = cn.cx + fixed_mul(rx, qcos[0]) * cn.sx;
fixed_t py = cn.cy + fixed_mul(ry, qsin[0]) * cn.sy;
for (int i = 1; i <= 4; ++i) {
fixed_t nx = cn.cx + fixed_mul(rx, qcos[i]) * cn.sx;
fixed_t ny = cn.cy + fixed_mul(ry, qsin[i]) * cn.sy;
el.add(px, py, nx, ny);
px = nx;
py = ny;
}
}
// Straight edges between corners
// Top edge: top-left corner end -> top-right corner start
el.add(x + rx, y, x + w - rx, y);
// Right edge: top-right corner end -> bottom-right corner start
el.add(x + w, y + ry, x + w, y + h - ry);
// Bottom edge: bottom-right corner end -> bottom-left corner start
el.add(x + w - rx, y + h, x + rx, y + h);
// Left edge: bottom-left corner end -> top-left corner start
el.add(x, y + h - ry, x, y + ry);
}
// ---------------------------------------------------------------------------
// Path command parser: tokenize the 'd' attribute
// ---------------------------------------------------------------------------
struct SvgPathParser {
const char* data;
int len;
int pos;
void init(const char* d, int l) { data = d; len = l; pos = 0; }
void skip_separators() {
while (pos < len && svg_char_is_sep(data[pos])) ++pos;
}
bool has_more() const { return pos < len; }
// Peek at what's next: command letter, number, or end
bool next_is_number() {
skip_separators();
if (pos >= len) return false;
return svg_char_is_num_start(data[pos]);
}
char read_command() {
skip_separators();
if (pos >= len) return '\0';
if (svg_char_is_cmd(data[pos]) && data[pos] != 'e' && data[pos] != 'E') {
return data[pos++];
}
return '\0';
}
fixed_t read_number() {
skip_separators();
if (pos >= len) return 0;
fixed_t val = 0;
int consumed = svg_parse_fixed(data + pos, &val);
pos += consumed;
return val;
}
};
// ---------------------------------------------------------------------------
// Process an SVG path 'd' attribute into edges
// ---------------------------------------------------------------------------
inline void svg_path_to_edges(SvgEdgeList& el, const char* d, int dLen,
fixed_t scale_x, fixed_t scale_y,
fixed_t off_x, fixed_t off_y) {
SvgPathParser pp;
pp.init(d, dLen);
fixed_t cur_x = 0, cur_y = 0; // current point
fixed_t start_x = 0, start_y = 0; // subpath start
fixed_t last_cx = 0, last_cy = 0; // last control point (for S/T)
char last_cmd = '\0';
auto scale_pt = [&](fixed_t x, fixed_t y, fixed_t* ox, fixed_t* oy) {
*ox = fixed_mul(x - off_x, scale_x);
*oy = fixed_mul(y - off_y, scale_y);
};
while (pp.has_more()) {
char cmd = '\0';
// Try reading a command letter
pp.skip_separators();
if (pp.pos < pp.len && svg_char_is_cmd(pp.data[pp.pos]) &&
pp.data[pp.pos] != 'e' && pp.data[pp.pos] != 'E') {
cmd = pp.data[pp.pos++];
} else if (pp.next_is_number()) {
// Implicit repeat of last command
// After M, implicit repeat is L; after m, implicit repeat is l
if (last_cmd == 'M') cmd = 'L';
else if (last_cmd == 'm') cmd = 'l';
else cmd = last_cmd;
} else {
// Skip unknown character
if (pp.pos < pp.len) pp.pos++;
continue;
}
if (cmd == '\0') break;
switch (cmd) {
case 'M': {
fixed_t x = pp.read_number();
fixed_t y = pp.read_number();
cur_x = x; cur_y = y;
start_x = x; start_y = y;
last_cmd = 'M';
break;
}
case 'm': {
fixed_t dx = pp.read_number();
fixed_t dy = pp.read_number();
cur_x += dx; cur_y += dy;
start_x = cur_x; start_y = cur_y;
last_cmd = 'm';
break;
}
case 'L': {
fixed_t x = pp.read_number();
fixed_t y = pp.read_number();
fixed_t sx0, sy0, sx1, sy1;
scale_pt(cur_x, cur_y, &sx0, &sy0);
scale_pt(x, y, &sx1, &sy1);
el.add(sx0, sy0, sx1, sy1);
cur_x = x; cur_y = y;
last_cmd = 'L';
break;
}
case 'l': {
fixed_t dx = pp.read_number();
fixed_t dy = pp.read_number();
fixed_t nx = cur_x + dx, ny = cur_y + dy;
fixed_t sx0, sy0, sx1, sy1;
scale_pt(cur_x, cur_y, &sx0, &sy0);
scale_pt(nx, ny, &sx1, &sy1);
el.add(sx0, sy0, sx1, sy1);
cur_x = nx; cur_y = ny;
last_cmd = 'l';
break;
}
case 'H': {
fixed_t x = pp.read_number();
fixed_t sx0, sy0, sx1, sy1;
scale_pt(cur_x, cur_y, &sx0, &sy0);
scale_pt(x, cur_y, &sx1, &sy1);
el.add(sx0, sy0, sx1, sy1);
cur_x = x;
last_cmd = 'H';
break;
}
case 'h': {
fixed_t dx = pp.read_number();
fixed_t nx = cur_x + dx;
fixed_t sx0, sy0, sx1, sy1;
scale_pt(cur_x, cur_y, &sx0, &sy0);
scale_pt(nx, cur_y, &sx1, &sy1);
el.add(sx0, sy0, sx1, sy1);
cur_x = nx;
last_cmd = 'h';
break;
}
case 'V': {
fixed_t y = pp.read_number();
fixed_t sx0, sy0, sx1, sy1;
scale_pt(cur_x, cur_y, &sx0, &sy0);
scale_pt(cur_x, y, &sx1, &sy1);
el.add(sx0, sy0, sx1, sy1);
cur_y = y;
last_cmd = 'V';
break;
}
case 'v': {
fixed_t dy = pp.read_number();
fixed_t ny = cur_y + dy;
fixed_t sx0, sy0, sx1, sy1;
scale_pt(cur_x, cur_y, &sx0, &sy0);
scale_pt(cur_x, ny, &sx1, &sy1);
el.add(sx0, sy0, sx1, sy1);
cur_y = ny;
last_cmd = 'v';
break;
}
case 'C': {
fixed_t x1 = pp.read_number(), y1 = pp.read_number();
fixed_t x2 = pp.read_number(), y2 = pp.read_number();
fixed_t x3 = pp.read_number(), y3 = pp.read_number();
fixed_t sx0, sy0, sx1, sy1, sx2, sy2, sx3, sy3;
scale_pt(cur_x, cur_y, &sx0, &sy0);
scale_pt(x1, y1, &sx1, &sy1);
scale_pt(x2, y2, &sx2, &sy2);
scale_pt(x3, y3, &sx3, &sy3);
svg_flatten_cubic(el, sx0, sy0, sx1, sy1, sx2, sy2, sx3, sy3);
last_cx = x2; last_cy = y2;
cur_x = x3; cur_y = y3;
last_cmd = 'C';
break;
}
case 'c': {
fixed_t dx1 = pp.read_number(), dy1 = pp.read_number();
fixed_t dx2 = pp.read_number(), dy2 = pp.read_number();
fixed_t dx3 = pp.read_number(), dy3 = pp.read_number();
fixed_t x1 = cur_x + dx1, y1 = cur_y + dy1;
fixed_t x2 = cur_x + dx2, y2 = cur_y + dy2;
fixed_t x3 = cur_x + dx3, y3 = cur_y + dy3;
fixed_t sx0, sy0, sx1, sy1, sx2, sy2, sx3, sy3;
scale_pt(cur_x, cur_y, &sx0, &sy0);
scale_pt(x1, y1, &sx1, &sy1);
scale_pt(x2, y2, &sx2, &sy2);
scale_pt(x3, y3, &sx3, &sy3);
svg_flatten_cubic(el, sx0, sy0, sx1, sy1, sx2, sy2, sx3, sy3);
last_cx = x2; last_cy = y2;
cur_x = x3; cur_y = y3;
last_cmd = 'c';
break;
}
case 'S': {
// Smooth cubic: reflect last control point
fixed_t rcx = cur_x * 2 - last_cx;
fixed_t rcy = cur_y * 2 - last_cy;
if (last_cmd != 'C' && last_cmd != 'c' && last_cmd != 'S' && last_cmd != 's') {
rcx = cur_x; rcy = cur_y;
}
fixed_t x2 = pp.read_number(), y2 = pp.read_number();
fixed_t x3 = pp.read_number(), y3 = pp.read_number();
fixed_t sx0, sy0, sx1, sy1, sx2, sy2, sx3, sy3;
scale_pt(cur_x, cur_y, &sx0, &sy0);
scale_pt(rcx, rcy, &sx1, &sy1);
scale_pt(x2, y2, &sx2, &sy2);
scale_pt(x3, y3, &sx3, &sy3);
svg_flatten_cubic(el, sx0, sy0, sx1, sy1, sx2, sy2, sx3, sy3);
last_cx = x2; last_cy = y2;
cur_x = x3; cur_y = y3;
last_cmd = 'S';
break;
}
case 's': {
fixed_t rcx = cur_x * 2 - last_cx;
fixed_t rcy = cur_y * 2 - last_cy;
if (last_cmd != 'C' && last_cmd != 'c' && last_cmd != 'S' && last_cmd != 's') {
rcx = cur_x; rcy = cur_y;
}
fixed_t dx2 = pp.read_number(), dy2 = pp.read_number();
fixed_t dx3 = pp.read_number(), dy3 = pp.read_number();
fixed_t x2 = cur_x + dx2, y2 = cur_y + dy2;
fixed_t x3 = cur_x + dx3, y3 = cur_y + dy3;
fixed_t sx0, sy0, sx1, sy1, sx2, sy2, sx3, sy3;
scale_pt(cur_x, cur_y, &sx0, &sy0);
scale_pt(rcx, rcy, &sx1, &sy1);
scale_pt(x2, y2, &sx2, &sy2);
scale_pt(x3, y3, &sx3, &sy3);
svg_flatten_cubic(el, sx0, sy0, sx1, sy1, sx2, sy2, sx3, sy3);
last_cx = x2; last_cy = y2;
cur_x = x3; cur_y = y3;
last_cmd = 's';
break;
}
case 'Q': {
fixed_t x1 = pp.read_number(), y1 = pp.read_number();
fixed_t x2 = pp.read_number(), y2 = pp.read_number();
fixed_t sx0, sy0, sx1, sy1, sx2, sy2;
scale_pt(cur_x, cur_y, &sx0, &sy0);
scale_pt(x1, y1, &sx1, &sy1);
scale_pt(x2, y2, &sx2, &sy2);
svg_flatten_quad(el, sx0, sy0, sx1, sy1, sx2, sy2);
last_cx = x1; last_cy = y1;
cur_x = x2; cur_y = y2;
last_cmd = 'Q';
break;
}
case 'q': {
fixed_t dx1 = pp.read_number(), dy1 = pp.read_number();
fixed_t dx2 = pp.read_number(), dy2 = pp.read_number();
fixed_t x1 = cur_x + dx1, y1 = cur_y + dy1;
fixed_t x2 = cur_x + dx2, y2 = cur_y + dy2;
fixed_t sx0, sy0, sx1, sy1, sx2, sy2;
scale_pt(cur_x, cur_y, &sx0, &sy0);
scale_pt(x1, y1, &sx1, &sy1);
scale_pt(x2, y2, &sx2, &sy2);
svg_flatten_quad(el, sx0, sy0, sx1, sy1, sx2, sy2);
last_cx = x1; last_cy = y1;
cur_x = x2; cur_y = y2;
last_cmd = 'q';
break;
}
case 'A': case 'a': {
// Arc command: consume parameters but approximate as a line
// (arcs are rare in these icons)
fixed_t rx = pp.read_number();
fixed_t ry = pp.read_number();
pp.read_number(); // x-rotation
pp.read_number(); // large-arc-flag
pp.read_number(); // sweep-flag
fixed_t x = pp.read_number();
fixed_t y = pp.read_number();
if (cmd == 'a') { x += cur_x; y += cur_y; }
fixed_t sx0, sy0, sx1, sy1;
scale_pt(cur_x, cur_y, &sx0, &sy0);
scale_pt(x, y, &sx1, &sy1);
el.add(sx0, sy0, sx1, sy1);
cur_x = x; cur_y = y;
last_cmd = cmd;
(void)rx; (void)ry;
break;
}
case 'Z': case 'z': {
if (cur_x != start_x || cur_y != start_y) {
fixed_t sx0, sy0, sx1, sy1;
scale_pt(cur_x, cur_y, &sx0, &sy0);
scale_pt(start_x, start_y, &sx1, &sy1);
el.add(sx0, sy0, sx1, sy1);
}
cur_x = start_x; cur_y = start_y;
last_cmd = 'Z';
break;
}
default:
// Unknown command, skip
break;
}
}
}
// ---------------------------------------------------------------------------
// Scanline rasterizer (even-odd fill rule)
// ---------------------------------------------------------------------------
inline void svg_rasterize(const SvgEdgeList& el, uint32_t* pixels, int w, int h, uint32_t fill) {
// Temporary array for x-intersections on each scanline
// Allocate enough for all edges (each edge can intersect at most once per scanline)
int maxIsect = el.count + 16;
fixed_t* isect = (fixed_t*)zenith::alloc(maxIsect * sizeof(fixed_t));
for (int y = 0; y < h; ++y) {
// Scanline center in fixed-point
fixed_t scanY = int_to_fixed(y) + (1 << 15); // y + 0.5
int isectCount = 0;
// Find intersections with all edges
for (int i = 0; i < el.count; ++i) {
const SvgEdge& e = el.edges[i];
fixed_t ey0 = e.y0, ey1 = e.y1;
// Ensure ey0 <= ey1 for the range check
fixed_t emin = ey0 < ey1 ? ey0 : ey1;
fixed_t emax = ey0 > ey1 ? ey0 : ey1;
// Does this edge cross scanY?
if (scanY < emin || scanY >= emax) continue;
// Compute x at intersection: x = x0 + (scanY - y0) * (x1 - x0) / (y1 - y0)
fixed_t dy = ey1 - ey0;
if (dy == 0) continue; // horizontal, skip
fixed_t dx = e.x1 - e.x0;
fixed_t t_num = scanY - ey0;
// x_intersect = x0 + dx * t_num / dy
fixed_t x_int = e.x0 + (int32_t)(((int64_t)dx * t_num) / dy);
if (isectCount < maxIsect)
isect[isectCount++] = x_int;
}
// Sort intersections (simple insertion sort -- usually very few)
for (int i = 1; i < isectCount; ++i) {
fixed_t key = isect[i];
int j = i - 1;
while (j >= 0 && isect[j] > key) {
isect[j + 1] = isect[j];
--j;
}
isect[j + 1] = key;
}
// Fill between pairs (even-odd rule)
for (int i = 0; i + 1 < isectCount; i += 2) {
int x0 = fixed_to_int(isect[i]);
int x1 = fixed_to_int(isect[i + 1]);
// Clamp to pixel bounds
if (x0 < 0) x0 = 0;
if (x1 > w) x1 = w;
for (int x = x0; x < x1; ++x) {
pixels[y * w + x] = fill;
}
}
}
zenith::free(isect);
}
// ---------------------------------------------------------------------------
// SVG document parser: extract paths, circles, rects and rasterize
// ---------------------------------------------------------------------------
inline SvgIcon svg_render(const char* svg_data, int svg_len, int target_w, int target_h, Color fill_color) {
SvgIcon icon;
icon.width = target_w;
icon.height = target_h;
icon.pixels = (uint32_t*)zenith::alloc(target_w * target_h * sizeof(uint32_t));
// Clear to transparent
svg_memset(icon.pixels, 0, target_w * target_h * sizeof(uint32_t));
uint32_t fill_px = fill_color.to_pixel();
// Parse SVG dimensions: width and height
int svg_w = 16, svg_h = 16;
fixed_t vb_x = 0, vb_y = 0, vb_w = 0, vb_h = 0;
bool has_viewbox = false;
// Find <svg tag
const char* svg_tag = svg_strstr(svg_data, svg_len, "<svg");
if (svg_tag) {
// Find the end of the <svg ...> tag
int tag_offset = (int)(svg_tag - svg_data);
int tag_end = tag_offset;
while (tag_end < svg_len && svg_data[tag_end] != '>') ++tag_end;
int tag_len = tag_end - tag_offset + 1;
char attr_buf[64];
// width
if (svg_get_attr(svg_tag, tag_len, " width", attr_buf, sizeof(attr_buf)) > 0) {
svg_w = svg_parse_int(attr_buf);
}
// height
if (svg_get_attr(svg_tag, tag_len, " height", attr_buf, sizeof(attr_buf)) > 0) {
svg_h = svg_parse_int(attr_buf);
}
// viewBox
if (svg_get_attr(svg_tag, tag_len, " viewBox", attr_buf, sizeof(attr_buf)) > 0) {
has_viewbox = true;
const char* vp = attr_buf;
int c;
c = svg_parse_fixed(vp, &vb_x); vp += c; while (*vp && svg_char_is_sep(*vp)) ++vp;
c = svg_parse_fixed(vp, &vb_y); vp += c; while (*vp && svg_char_is_sep(*vp)) ++vp;
c = svg_parse_fixed(vp, &vb_w); vp += c; while (*vp && svg_char_is_sep(*vp)) ++vp;
svg_parse_fixed(vp, &vb_h);
}
}
if (!has_viewbox) {
vb_x = 0;
vb_y = 0;
vb_w = int_to_fixed(svg_w);
vb_h = int_to_fixed(svg_h);
}
// Compute scale: pixel = (svg_coord - vb_origin) * target_size / vb_size
fixed_t scale_x = vb_w > 0 ? fixed_div(int_to_fixed(target_w), vb_w) : int_to_fixed(1);
fixed_t scale_y = vb_h > 0 ? fixed_div(int_to_fixed(target_h), vb_h) : int_to_fixed(1);
// Edge list
SvgEdgeList el;
el.init(SVG_MAX_EDGES);
// Scan for <path, <circle, <rect elements
const char* p = svg_data;
const char* end = svg_data + svg_len;
while (p < end) {
// Find next '<'
while (p < end && *p != '<') ++p;
if (p >= end) break;
int remaining = (int)(end - p);
// Check for <path
if (remaining > 5 && svg_strncmp(p, "<path", 5) && (svg_char_is_ws(p[5]) || p[5] == '/')) {
// Find end of this element
const char* elem_start = p;
const char* elem_end = p;
while (elem_end < end && *elem_end != '>') ++elem_end;
if (elem_end < end) ++elem_end; // include '>'
int elem_len = (int)(elem_end - elem_start);
// Extract d attribute
char d_buf[SVG_MAX_PATH_LEN];
int d_len = svg_get_attr(elem_start, elem_len, " d", d_buf, SVG_MAX_PATH_LEN);
if (d_len > 0) {
svg_path_to_edges(el, d_buf, d_len, scale_x, scale_y, vb_x, vb_y);
}
p = elem_end;
continue;
}
// Check for <circle
if (remaining > 7 && svg_strncmp(p, "<circle", 7) && (svg_char_is_ws(p[7]) || p[7] == '/')) {
const char* elem_start = p;
const char* elem_end = p;
while (elem_end < end && *elem_end != '>') ++elem_end;
if (elem_end < end) ++elem_end;
int elem_len = (int)(elem_end - elem_start);
char attr_buf[32];
fixed_t cx = 0, cy = 0, r = 0;
if (svg_get_attr(elem_start, elem_len, " cx", attr_buf, sizeof(attr_buf)) > 0)
svg_parse_fixed(attr_buf, &cx);
if (svg_get_attr(elem_start, elem_len, " cy", attr_buf, sizeof(attr_buf)) > 0)
svg_parse_fixed(attr_buf, &cy);
if (svg_get_attr(elem_start, elem_len, " r", attr_buf, sizeof(attr_buf)) > 0)
svg_parse_fixed(attr_buf, &r);
// Scale to target coordinates
fixed_t scx = fixed_mul(cx - vb_x, scale_x);
fixed_t scy = fixed_mul(cy - vb_y, scale_y);
fixed_t srx = fixed_mul(r, scale_x);
fixed_t sry = fixed_mul(r, scale_y);
// Use average of scaled radii
fixed_t sr = (srx + sry) >> 1;
svg_circle_edges(el, scx, scy, sr);
p = elem_end;
continue;
}
// Check for <rect
if (remaining > 5 && svg_strncmp(p, "<rect", 5) && (svg_char_is_ws(p[5]) || p[5] == '/')) {
const char* elem_start = p;
const char* elem_end = p;
while (elem_end < end && *elem_end != '>') ++elem_end;
if (elem_end < end) ++elem_end;
int elem_len = (int)(elem_end - elem_start);
char attr_buf[32];
fixed_t rx_val = 0, ry_val = 0, rw = 0, rh = 0, rrx = 0, rry = 0;
if (svg_get_attr(elem_start, elem_len, " x", attr_buf, sizeof(attr_buf)) > 0)
svg_parse_fixed(attr_buf, &rx_val);
if (svg_get_attr(elem_start, elem_len, " y", attr_buf, sizeof(attr_buf)) > 0)
svg_parse_fixed(attr_buf, &ry_val);
if (svg_get_attr(elem_start, elem_len, " width", attr_buf, sizeof(attr_buf)) > 0)
svg_parse_fixed(attr_buf, &rw);
if (svg_get_attr(elem_start, elem_len, " height", attr_buf, sizeof(attr_buf)) > 0)
svg_parse_fixed(attr_buf, &rh);
if (svg_get_attr(elem_start, elem_len, " rx", attr_buf, sizeof(attr_buf)) > 0)
svg_parse_fixed(attr_buf, &rrx);
if (svg_get_attr(elem_start, elem_len, " ry", attr_buf, sizeof(attr_buf)) > 0)
svg_parse_fixed(attr_buf, &rry);
// Scale all to target pixel space
fixed_t sx = fixed_mul(rx_val - vb_x, scale_x);
fixed_t sy = fixed_mul(ry_val - vb_y, scale_y);
fixed_t sw = fixed_mul(rw, scale_x);
fixed_t sh = fixed_mul(rh, scale_y);
fixed_t srx = fixed_mul(rrx, scale_x);
fixed_t sry = fixed_mul(rry, scale_y);
svg_rect_edges(el, sx, sy, sw, sh, srx, sry);
p = elem_end;
continue;
}
++p;
}
// Rasterize all accumulated edges
if (el.count > 0) {
svg_rasterize(el, icon.pixels, target_w, target_h, fill_px);
}
zenith::free(el.edges);
return icon;
}
// ---------------------------------------------------------------------------
// Load SVG from VFS and render
// ---------------------------------------------------------------------------
inline SvgIcon svg_load(const char* vfs_path, int target_w, int target_h, Color fill_color) {
int fd = zenith::open(vfs_path);
if (fd < 0) {
return {nullptr, 0, 0};
}
uint64_t size = zenith::getsize(fd);
if (size == 0 || size > SVG_MAX_FILE_SIZE) {
zenith::close(fd);
return {nullptr, 0, 0};
}
char* buf = (char*)zenith::alloc(size + 1);
zenith::read(fd, (uint8_t*)buf, 0, size);
zenith::close(fd);
buf[size] = '\0';
SvgIcon icon = svg_render(buf, (int)size, target_w, target_h, fill_color);
zenith::free(buf);
return icon;
}
// ---------------------------------------------------------------------------
// Free icon pixel data
// ---------------------------------------------------------------------------
inline void svg_free(SvgIcon& icon) {
if (icon.pixels) zenith::free(icon.pixels);
icon.pixels = nullptr;
icon.width = 0;
icon.height = 0;
}
} // namespace gui