xbintsc 0.5.41 → 0.5.42

package/doc/zh-CN/gui/canvas.md

@@ -166,8 +166,10 @@ canvas 由脚本重绘而不是引擎重绘，因此开销按绘制调用计。
 9 参数（本引擎为**目标优先**：`dx, dy, dw, dh, sx, sy, sw, sh`）。完整的仿射变换
 （旋转/斜切/缩放）会被应用：目标矩形变为平行四边形，每个设备像素反查到源矩形。
 `source` 可以是 `<img>` 元素（经图像模块解码）、另一个 `<canvas>`、
-`OffscreenCanvas` 或 `ImageBitmap`。`imageSmoothingEnabled` 为 `true`（默认）时使用
-双线性采样，为 `false` 时使用最近邻。
+`OffscreenCanvas`、`ImageBitmap`，或——本引擎的扩展——直接传字符串路径/`data:` URL，
+由图像模块解码，因此 SVG 或位图的 data URL 无需 `<img>` 就能绘制。矢量源按目标尺寸
+（`dw`/`dh`）光栅化，放大时 SVG 依然清晰。`imageSmoothingEnabled` 为 `true`（默认）
+时使用双线性采样，为 `false` 时使用最近邻。
 
 测试钩子：`getImageData(x, y, w, h)` 把区域复制为 `{ width, height, data }`，其中
 `data` 是按行主序的 RGBA8 字节数组。越界像素为透明。
@@ -186,8 +188,8 @@ dirtyWidth, dirtyHeight])` 直接把字节写入位图（不受变换、混合
 `OffscreenCanvas.convertToBlob()` 解析为同一形状，`transferToImageBitmap()` 对位图
 做快照。
 
-CSS 背景：`background-image: url(...)` 接受文件路径或 `data:` URL，因此可以先把
-canvas 导出再作为 CSS 背景使用
+CSS 背景：`background-image: url(...)` 接受文件路径或 `data:` URL（位图载荷或 SVG
+文档，base64 或百分号编码均可），因此可以先把 canvas 导出再作为 CSS 背景使用
 （`element.style.backgroundImage = "url(" + canvas.toDataURL() + ")"`）。图像层会拉伸
 到元素的边框盒；`background-size`、`background-position` 与平铺尚未建模。
 

package/doc/zh-CN/gui/known-issues.md

@@ -43,22 +43,25 @@
   `var()` 自定义属性、`inset` 简写、`box-sizing`、`visibility`/`pointer-events`、
   `@media` 查询、生成内容（`::before`/`::after`）、线性/径向多层背景、
   `text-shadow`、`clip-path`（`inset`/`circle`/`ellipse`/`polygon`）以及 `filter`
-  的颜色函数。仍有限制：`mix-blend-mode`、`background-clip`、
-  `background-position`/`size`/`repeat`、重复渐变与 `backdrop-filter` 合成都未实现
-  （`backdrop-filter` 会解析并参与层叠，但采样背景需要离屏图层，因此不绘制）；
+  的颜色函数。仍有限制：`background-clip`、`background-position`/`size`/`repeat`
+  与 `backdrop-filter` 合成都未实现（`backdrop-filter` 会解析并参与层叠，但采样
+  背景需要离屏图层，因此不绘制）；`mix-blend-mode` 与重复渐变已实现（见
+  [渲染](./rendering.md)），但组 `opacity` 是按图形 alpha 近似而非真正的组合成，
+  且 D3D12/DXIL 后端没有混合合成器，那里会退回普通 source-over 绘制；
   `filter: blur()` 是按图形做九次偏移的近似，而不是真正的组模糊，重叠的子元素会加深；
   `drop-shadow` 用盒子轮廓近似；最多只交叉两层嵌套 `clip-path`（更深时保留外侧两层）；
   图像/画布除图像着色器能携带的亮度与透明度染色外不做颜色滤镜。Canvas 纹理使用
-  最近邻采样。背景渐变仍是纯色带（线性 18 条、径向 32 个同心椭圆），柔和渐变可能
-  出现轻微条带。
+  最近邻采样。背景渐变仍是纯色带（线性 18 条、径向 32 个同心椭圆；重复渐变
+  64 条），柔和渐变可能出现轻微条带。
 - **SVG 是 NanoSVG 的子集。** SVG *文件*（`<img src="logo.svg">`）与内联
   `<svg>` 子树共用 vendored 的 NanoSVG 解析/光栅化器（`runtime/ext_gui/svg.cpp`、
   `inline_svg.cpp`），它会渲染 `path`/`rect`/`circle`/`ellipse`/`line`/
   `polyline`/`polygon`、组、`defs` 渐变以及基于 `class` 的 `<style>` 规则。
   `<text>`、`<use>`、滤镜、遮罩与裁剪路径不会渲染，文档层叠的 CSS 也不会进入
-  图像内部（这里的 `fill`/`stroke` 是 SVG 表现属性，不是 CSS 属性）。需要这些
-  能力的矢量美术必须预先光栅化、用盒子绘制，或限制在受支持的语法内。参见
-  [媒体](./media.md#图像m6a)。
+  图像内部（这里的 `fill`/`stroke` 是 SVG 表现属性，不是 CSS 属性）。因此只靠滤镜
+  出图的 SVG（`feTurbulence` 噪声、模糊等）会显示未经过滤的形状——常见情况是一个
+  纯色矩形——而不是滤镜结果。需要这些能力的矢量美术必须预先光栅化、用盒子绘制，
+  或限制在受支持的语法内。参见[媒体](./media.md#图像m6a)。
 - **每次变更仍是整文档重算。** 一次 DOM 变更会重新计算层叠并重新布局整个文档
   （没有增量子树失效），只影响绘制的变更（例如 hover 颜色）同样会重排。带生成
   内容（`::before`/`::after`）的文档没有特殊处理。各阶段的实测开销由

package/doc/zh-CN/gui/media.md

@@ -35,6 +35,13 @@ PNG/JPEG/BMP/GIF/TGA 解码为 RGBA8，并带有解码缓存与仅头文件的
   （最近最少使用），动画文档不会让它无限增长。
 - 解析结果按路径缓存；解析与光栅化器状态在 `xt_svg_shutdown`
   （`xt_image_shutdown`）中释放。
+- `data:` URL 在内存中解码，凡接受路径的地方都可使用：`<img src>`、CSS
+  `background-image` 与 `canvas.drawImage(url, …)`。既支持 `;base64` 形式，也支持
+  百分号编码（或原样）的载荷，`base64` 标志大小写不敏感。MIME 类型只用于分类：
+  `image/svg+xml`（或 MIME 为通用/缺失时按内容嗅探出 SVG）走 NanoSVG——data URL
+  里的 SVG 与 SVG 文件一样按绘制尺寸光栅化；PNG/JPEG/BMP/GIF/TGA 走
+  `stb_image`。NanoSVG 的子集限制仍然生效：只靠 `<filter>`（`feTurbulence` 等）
+  出图的 SVG 能解码、能布局，但滤镜本身会被忽略。
 
 文档 CSS 只作用于 `<svg>` **盒子**——尺寸、外边距、背景、边框、`transform`、
 opacity、`display`——与任何其他元素一样。盒子内部的艺术内容保持 SVG 语义：
@@ -45,8 +52,8 @@ opacity、`display`——与任何其他元素一样。盒子内部的艺术内
 重写艺术内容的程序会为每个变体保留一张纹理；更好的做法是用 `transform`、
 `opacity` 给盒子做动画，或在一小组文档之间切换。
 
-图像仍需完成：CSS `background-image: url(...)`、`data:` URI、`object-fit`、
-九宫格边框。
+图像仍需完成：`object-fit`、九宫格边框。（CSS `background-image: url(...)` 与
+`data:` URL 已支持。）
 
 两种 SVG 都受限于 NanoSVG 的子集：`path`、`rect`、`circle`、`ellipse`、
 `line`、`polyline`、`polygon`、组（`g`）、带线性/径向渐变的 `defs` 以及基于

package/doc/zh-CN/gui/rendering.md

@@ -15,9 +15,10 @@
 顺序都能保留到渲染器。`DisplayList::dump()` 为 `paintList()`/`paintCount()`
 提供数据。
 
-`opacity` 只在两端生效：计算值为 `0` 的盒子（及其整棵子树）不绘制任何内容，
-大于 `0` 的一律按完全不透明绘制。图形只携带其颜色自身的 alpha，因此没有部分
-透明盒子的合成——CSS 解析器接受的 `opacity` 过渡因此也看不到效果。把隐藏态写成
+`opacity` 会乘到该盒子及其后代绘制的每个颜色 alpha 上（沿绘制链逐层相乘），
+因此小数 opacity 以及 CSS 解析器接受的 `opacity` 过渡都能看到效果。这是按图形
+逐个近似的，而不是离屏分组：半透明盒子的重叠子元素会各自合成，浏览器则先把整组
+合成一次再应用 alpha。`opacity: 0` 仍会跳过整棵子树。把隐藏态写成
 `opacity: 0` 来隐藏/显示一层，正是 `examples/gui/pelican-bike` 游戏结束遮罩的做法。
 
 `runtime/ext_gui/renderer.{h,cpp}` 把该列表转换为每个窗口的批处理顶点缓冲
@@ -67,14 +68,20 @@
 `background-color` 与每一条 `background-image` 层都会绘制。逗号分隔的层列表按
 从底到上的顺序绘制（声明中的第一层在最上面），两种渐变均受支持：
 
-- **线性**渐变在 18 个位置采样并输出为纯色矩形；支持 `to <side>`、
-  `deg`/`grad`/`rad`/`turn`、百分比与多色标（色带沿最近轴行走，因此斜角会退化为
+- **线性**渐变在 18 个位置采样（重复渐变 64 个）并输出为纯色矩形；支持
+  `to <side>`、`deg`/`grad`/`rad`/`turn`、百分比或长度（`px`/`em`/…）偏移、
+  `color <start> <end>` 简写与多色标（色带沿最近轴行走，因此斜角会退化为
   最近的轴向）；
-- **径向**渐变是 32 个同心椭圆。每个都是单位半径的圆角矩形，经图形管线的
-  transform 槽映射，因此圆/椭圆仍保留距离场抗锯齿。支持形状/尺寸关键字
-  （`circle`/`ellipse`、`closest-side`/`farthest-side`/`closest-corner`/
+- **径向**渐变是 32 个同心椭圆（重复渐变 64 个）。每个都是单位半径的圆角矩形，
+  经图形管线的 transform 槽映射，因此圆/椭圆仍保留距离场抗锯齿。支持形状/尺寸
+  关键字（`circle`/`ellipse`、`closest-side`/`farthest-side`/`closest-corner`/
   `farthest-corner`、显式半径）与 `at <position>`。
 
+`repeating-linear-gradient()` 与 `repeating-radial-gradient()` 会在整个盒子上
+从 0 平铺到最后一个色标的偏移量；色标列表不会被强制结束在 100%，因此
+`red 0%, blue 10%` 每 10% 重复一次。普通渐变的最后一个色标若小于 100%，则剩余
+区域保持该颜色，与 CSS 一致。
+
 背景色位于所有层下方。若渐变色标带透明度，渐变也会半透明；色带近似可能产生
 轻微条带，非常透明的多色标渐变会出现 alpha 叠加。
 
@@ -96,9 +103,21 @@ shader 改动，但边缘是硬边（没有解析抗锯齿）。支持两层嵌
 **`filter`** 的颜色函数（`brightness`、`contrast`、`grayscale`、`sepia`、
 `invert`、`saturate`、`hue-rotate`、`opacity`）会折进每个绘制颜色，因此盒子与
 其后代都会看到滤镜。`blur()` 与 `drop-shadow()` 是显示列表层面的近似：模糊把每个
-图形展开成九个半透明副本，投影用盒子/文字轮廓。这样保持单渲染通道（没有离屏
-渲染目标），代价是组语义：被模糊/滤镜的组内重叠后代可能加深；`backdrop-filter`
-无法采样元素背后的内容，因此会解析并参与层叠，但不绘制。
+图形展开成九个半透明副本，投影用盒子/文字轮廓。这样普通绘制保持单渲染通道，代价
+是组语义：被模糊/滤镜的组内重叠后代可能加深；`backdrop-filter` 无法采样元素背后
+的内容，因此会解析并参与层叠，但不绘制。
+
+**`mix-blend-mode`** 是唯一真正需要离屏图层的例外。非 `normal` 的盒子会被
+`LayerBegin`/`LayerEnd` 标记包住（在 `paintList()` 中显示为 `layer blend=…` /
+`end-layer`），渲染器把该组绘制到全视口离屏纹理，再用一个小型 GLSL 混合
+shader 合成到场景上。全部十六种 CSS 模式（`multiply`、`screen`、`overlay`、
+`darken`、`lighten`、`color-dodge`、`color-burn`、`hard-light`、`soft-light`、
+`difference`、`exclusion`、`hue`、`saturation`、`color`、`luminosity`）都按
+合成规范公式实现。shader 在运行时由内置 glslang 编译（Vulkan 用 SPIR-V），
+再由 SPIRV-Cross 交叉编译为 MSL（Metal）；每个嵌套层级的两张场景纹理跨帧复用，
+并通过 ping-pong 让背景在写入时仍可采样。既不吃 SPIR-V 也不吃 MSL 的后端
+（这里的 D3D12/DXIL 路径没有 shader 编译器）仍用普通 source-over 混合绘制该组。
+`backdrop-filter` 依旧不绘制。
 
 ## 文本技术栈（M4b）
 

package/doc/zh-CN/gui.md

@@ -12,7 +12,7 @@
 渲染器，因此盒子（以及其中的文本、图像与子元素）可以被平移、缩放与旋转而
 不触发任何重排——再加上 `transition: transform`，这些姿态可以动画（自绘的示例
 `examples/gui/pelican-svg` 正是用它让矢量画动起来）。参见
-[布局](./gui/layout.md#变换m15)与[动画](./gui/animation.md#css-transformm15)。**M17** 增加了真正的 **WebGL 1.0**，**M18** 增加了 **WebGL 2.0**：`<canvas>.getContext("webgl2")` 接受 `#version 300 es` 着色器、顶点数组对象、实例化绘制与采样器对象，全部由内置 glslang 编译为 SPIR-V（Metal 上再由内置 SPIRV-Cross 转成 MSL）并通过 SDL_GPU 渲染，几何、光照、纹理采样与混合都在 GPU 上完成，页面直接合成颜色纹理而无须读回——见 [WebGL](./gui/webgl.md)。**M19** 补齐 CSS 装饰层：`@media` 查询、生成内容（`::before`/`::after`）、线性/径向多层背景、`text-shadow`、`clip-path` 与 `filter` 颜色/阴影效果。`backdrop-filter` 与真正的组模糊需要离屏合成器，仍为有文档说明的近似或未支持——见[绘制](./gui/rendering.md#背景生成内容与特效m19)。**M20** 让大文档保持可交互：`@media` 每条规则只求值一次，布局与绘制共享一个有界的整形缓存，一帧只做（也只提交）变更所要求的工作——见[性能](./gui/rendering.md#性能m20)。本总览记录了锁定决策、架构、里程碑计划与当前进度；引擎本身按功能拆分在以上各页中。
+[布局](./gui/layout.md#变换m15)与[动画](./gui/animation.md#css-transformm15)。**M17** 增加了真正的 **WebGL 1.0**，**M18** 增加了 **WebGL 2.0**：`<canvas>.getContext("webgl2")` 接受 `#version 300 es` 着色器、顶点数组对象、实例化绘制与采样器对象，全部由内置 glslang 编译为 SPIR-V（Metal 上再由内置 SPIRV-Cross 转成 MSL）并通过 SDL_GPU 渲染，几何、光照、纹理采样与混合都在 GPU 上完成，页面直接合成颜色纹理而无须读回——见 [WebGL](./gui/webgl.md)。**M19** 补齐 CSS 装饰层：`@media` 查询、生成内容（`::before`/`::after`）、线性/径向/重复多层背景、`text-shadow`、`clip-path`、`mix-blend-mode`（通过离屏合成器）与 `filter` 颜色/阴影效果。`backdrop-filter` 仍需要背景快照，真正的组模糊也仍是近似——见[绘制](./gui/rendering.md#背景生成内容与特效m19)。**M20** 让大文档保持可交互：`@media` 每条规则只求值一次，布局与绘制共享一个有界的整形缓存，一帧只做（也只提交）变更所要求的工作——见[性能](./gui/rendering.md#性能m20)。本总览记录了锁定决策、架构、里程碑计划与当前进度；引擎本身按功能拆分在以上各页中。
 
 ## 目录
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xbintsc",
-  "version": "0.5.41",
+  "version": "0.5.42",
   "description": "xbintsc - a TypeScript binary compiler (TypeScript -> LLVM IR -> native binary)",
   "type": "module",
   "license": "MIT",
@@ -72,12 +72,12 @@
     "vitest": "^2.1.8"
   },
   "optionalDependencies": {
-    "@xbintsc/linux-x64": "0.5.41",
-    "@xbintsc/linux-arm64": "0.5.41",
-    "@xbintsc/darwin-x64": "0.5.41",
-    "@xbintsc/darwin-arm64": "0.5.41",
-    "@xbintsc/win32-x64": "0.5.41",
-    "@xbintsc/win32-arm64": "0.5.41"
+    "@xbintsc/linux-x64": "0.5.42",
+    "@xbintsc/linux-arm64": "0.5.42",
+    "@xbintsc/darwin-x64": "0.5.42",
+    "@xbintsc/darwin-arm64": "0.5.42",
+    "@xbintsc/win32-x64": "0.5.42",
+    "@xbintsc/win32-arm64": "0.5.42"
   },
   "engines": {
     "node": ">=22"

package/runtime/ext_gui/dom_api_canvas.cpp

@@ -468,41 +468,59 @@ METHOD(canvas_draw_image) {
   (void)env;
   xtgui::Canvas2D *canvas = context_canvas(self);
   if (canvas == nullptr || argc < 3) return XT_UNDEFINED;
+
+  const bool has_destination = argc >= 5;
+  const float dx = (float)number_arg(argc, argv, 1, 0.0);
+  const float dy = (float)number_arg(argc, argv, 2, 0.0);
+  const float destination_width =
+      has_destination ? (float)number_arg(argc, argv, 3, 0.0) : 0.0f;
+  const float destination_height =
+      has_destination ? (float)number_arg(argc, argv, 4, 0.0) : 0.0f;
+  auto raster_target = [](float value) -> int {
+    return value > 0.0f ? (int)(value + 0.5f) : 0;
+  };
+
   XtGuiWindow *win = nullptr;
   xt_value source_value = xt_arg(argc, argv, 0);
   const xtgui::Image *image = nullptr;
-  /* An `OffscreenCanvas` (or a transferred one) has no DOM node; its bitmap is
-   * reachable through the process-wide canvas id. */
-  if (XT_IS_OBJECT(source_value)) {
-    xt_value canvas_id = xt_object_get_cstr(source_value, "__xt_gui_canvas");
-    if (XT_IS_NUMBER(canvas_id)) {
-      xtgui::Canvas2D *offscreen = xtgui::xt_canvas_by_id((uint64_t)xt_to_number(canvas_id));
-      if (offscreen != nullptr) {
-        image = &offscreen->image();
+  if (XT_IS_STRING(source_value)) {
+    /* Engine extension: the source may be a path or a `data:` URL itself, so a
+     * data-URL bitmap/SVG can be drawn without an `<img>` element. */
+    const std::string source_url(xt_string_data(source_value));
+    image = xtgui::xt_image_load(source_url, raster_target(destination_width),
+                                 raster_target(destination_height));
+  } else {
+    /* An `OffscreenCanvas` (or a transferred one) has no DOM node; its bitmap
+     * is reachable through the process-wide canvas id. */
+    if (XT_IS_OBJECT(source_value)) {
+      xt_value canvas_id = xt_object_get_cstr(source_value, "__xt_gui_canvas");
+      if (XT_IS_NUMBER(canvas_id)) {
+        xtgui::Canvas2D *offscreen = xtgui::xt_canvas_by_id((uint64_t)xt_to_number(canvas_id));
+        if (offscreen != nullptr) image = &offscreen->image();
+      }
+    }
+    if (image == nullptr) {
+      xtgui::Node *source = resolve_node(source_value, &win);
+      if (source != nullptr && source->isElement() && source->isTag("img")) {
+        const std::string *src = source->attr("src");
+        if (src != nullptr) {
+          image = xtgui::xt_image_load(*src, raster_target(destination_width),
+                                       raster_target(destination_height));
+        }
+      } else if (source != nullptr) {
+        xtgui::Canvas2D *other = xt_gui_canvas_find(win, source);
+        if (other != nullptr) image = &other->image();
       }
     }
-  }
-  xtgui::Node *source = resolve_node(source_value, &win);
-  if (source != nullptr && source->isElement() && source->isTag("img")) {
-    const std::string *src = source->attr("src");
-    if (src != nullptr) image = xtgui::xt_image_load(*src);
-  } else if (source != nullptr) {
-    xtgui::Canvas2D *other = xt_gui_canvas_find(win, source);
-    if (other != nullptr) image = &other->image();
   }
   if (image == nullptr || image->width <= 0 || image->height <= 0) return XT_UNDEFINED;
-  float dx = (float)number_arg(argc, argv, 1, 0.0);
-  float dy = (float)number_arg(argc, argv, 2, 0.0);
-  float dw = (float)image->width;
-  float dh = (float)image->height;
+
+  const float dw = has_destination ? destination_width : (float)image->width;
+  const float dh = has_destination ? destination_height : (float)image->height;
   float sx = 0.0f;
   float sy = 0.0f;
   float sw = (float)image->width;
   float sh = (float)image->height;
-  if (argc >= 5) {
-    dw = (float)number_arg(argc, argv, 3, (double)dw);
-    dh = (float)number_arg(argc, argv, 4, (double)dh);
-  }
   if (argc >= 9) {
     sx = (float)number_arg(argc, argv, 5, 0.0);
     sy = (float)number_arg(argc, argv, 6, 0.0);

package/runtime/ext_gui/gradient_values.cpp

@@ -134,67 +134,59 @@ bool parseGradientColor(const std::string &token, Color *color, std::string *res
   return true;
 }
 
-/** Parse one `[<percent>]` / `<number>` offset. */
-bool parseGradientOffset(const std::string &raw, float *out) {
+/** Parse one gradient stop offset: a percentage, a length (`px`, `em`, …) or a
+ * bare number (0.5 = 50%, 50 = 50%). */
+bool parseGradientOffset(const std::string &raw, Length *out) {
   std::string text = xt_css_trim(raw);
   if (text.empty()) return false;
-  bool percent = text.back() == '%';
-  if (percent) text.pop_back();
+  if (text.back() == '%') {
+    float value = 0;
+    if (!xt_css_parse_number(text.substr(0, text.size() - 1), &value)) return false;
+    *out = Length{value, Unit::Percent};
+    return true;
+  }
   float value = 0;
-  if (!xt_css_parse_number(text, &value)) return false;
-  if (percent) value /= 100.0f;
-  else if (value > 1.0f) value /= 100.0f;
-  if (value < 0) value = 0;
-  if (value > 1) value = 1;
-  *out = value;
-  return true;
+  if (xt_css_parse_number(text, &value)) {
+    /* Unitless offsets are fractions of the gradient line, matching the old
+     * parser: `0.5` is 50% and `50` is also 50%. */
+    if (value > 1.0f) *out = Length{value, Unit::Percent};
+    else *out = Length{value * 100.0f, Unit::Percent};
+    return true;
+  }
+  Length length = xt_css_parse_length(text);
+  if (length.unit != Unit::Invalid && length.unit != Unit::Auto &&
+      length.unit != Unit::None && length.unit != Unit::Number) {
+    *out = length;
+    return true;
+  }
+  return false;
 }
 
-/** Parse a comma-separated `[color [offset [offset]]]` stop list. */
+/** Parse a comma-separated `[color [offset [offset]]]` stop list. Offsets stay
+ * unresolved here: `px` is resolved against the gradient line in paint. */
 bool parseStops(const std::string &text, std::vector<BackgroundGradientStop> *stops) {
   std::vector<std::string> parts = splitCommas(text);
   if (parts.size() < 2) return false;
-  float last = -1.0f;
   for (const std::string &part : parts) {
     Color color;
     std::string rest;
     if (!parseGradientColor(part, &color, &rest)) continue;
     BackgroundGradientStop stop;
     stop.color = color;
-    stop.offset = -1.0f;
-    if (!rest.empty()) {
-      std::vector<std::string> offsets = splitTokens(rest);
-      if (!offsets.empty()) {
-        float first = 0;
-        if (parseGradientOffset(offsets[0], &first)) {
-          stop.offset = first;
-          if (stop.offset < last) stop.offset = last;
-          last = stop.offset;
-        }
+    std::vector<std::string> offsets = splitTokens(rest);
+    if (!offsets.empty() && parseGradientOffset(offsets[0], &stop.offset)) {
+      /* `color <start> <end>` is shorthand for the same colour at both offsets
+       * (a hard band), so emit the second stop too. */
+      stops->push_back(stop);
+      if (offsets.size() > 1) {
+        BackgroundGradientStop end = stop;
+        if (parseGradientOffset(offsets[1], &end.offset)) stops->push_back(end);
       }
+    } else {
+      stops->push_back(stop);
     }
-    stops->push_back(stop);
-  }
-  if (stops->size() < 2) return false;
-  /* Fill implicit offsets by distributing them between their neighbours. */
-  size_t i = 0;
-  while (i < stops->size()) {
-    if ((*stops)[i].offset >= 0) {
-      i++;
-      continue;
-    }
-    size_t j = i;
-    while (j < stops->size() && (*stops)[j].offset < 0) j++;
-    float before = (i == 0) ? 0.0f : (*stops)[i - 1].offset;
-    float after = (j >= stops->size()) ? 1.0f : (*stops)[j].offset;
-    size_t count = j - i;
-    for (size_t k = 0; k < count; k++)
-      (*stops)[i + k].offset = before + (after - before) * (float)(k + 1) / (float)(count + 1);
-    i = j;
   }
-  stops->front().offset = 0.0f;
-  stops->back().offset = 1.0f;
-  return true;
+  return stops->size() >= 2;
 }
 
 /** CSS gradient direction/angle. Returns true when `text` was a direction. */
@@ -395,14 +387,18 @@ bool parseRadialGradient(const std::string &body, BackgroundLayer *layer) {
 /** Parse one layer, appending it when it is a supported gradient or image. */
 bool parseLayer(const std::string &part, BackgroundLayer *layer) {
   std::string body;
-  if (findCall(part, "linear-gradient", &body) ||
-      findCall(part, "repeating-linear-gradient", &body)) {
+  /* The repeating prefix is checked first: a plain substring search for
+   * `linear-gradient(` would also match inside `repeating-linear-gradient(`. */
+  if (findCall(part, "repeating-linear-gradient", &body)) {
+    layer->repeating = true;
     return parseLinearGradient(body, layer);
   }
-  if (findCall(part, "radial-gradient", &body) ||
-      findCall(part, "repeating-radial-gradient", &body)) {
+  if (findCall(part, "linear-gradient", &body)) return parseLinearGradient(body, layer);
+  if (findCall(part, "repeating-radial-gradient", &body)) {
+    layer->repeating = true;
     return parseRadialGradient(body, layer);
   }
+  if (findCall(part, "radial-gradient", &body)) return parseRadialGradient(body, layer);
   if (findCall(part, "url", &body)) {
     std::string source = xt_css_trim(body);
     if (source.size() >= 2 && (source.front() == '"' || source.front() == '\'') &&

package/runtime/ext_gui/gui_events.cpp

@@ -471,23 +471,26 @@ void xt_gui_render_window(XtGuiWindow *win) {
         }
         win->present_deferred = 0;
         xtgui::g_perf_frame.presents += 1;
-        SDL_GPUColorTargetInfo target;
-        memset(&target, 0, sizeof(target));
-        target.texture = swapchain;
-        target.clear_color.r = win->background[0];
-        target.clear_color.g = win->background[1];
-        target.clear_color.b = win->background[2];
-        target.clear_color.a = win->background[3];
-        target.load_op = SDL_GPU_LOADOP_CLEAR;
-        target.store_op = SDL_GPU_STOREOP_STORE;
-        SDL_GPURenderPass *pass = SDL_BeginGPURenderPass(cmd, &target, 1, NULL);
         if (can_paint) {
           float density = SDL_GetWindowPixelDensity(win->window);
           if (density <= 0.0f) density = 1.0f;
-          xt_gui_renderer_draw(cmd, pass, &win->geometry, &win->text_geometry,
-                               &win->image_geometry, viewport_width, viewport_height, density);
+          xt_gui_renderer_draw(cmd, swapchain, win->background, &win->geometry,
+                               &win->text_geometry, &win->image_geometry,
+                               win->display_list, viewport_width, viewport_height, density);
+        } else {
+          /* No renderer (no usable shader backend): still clear the window. */
+          SDL_GPUColorTargetInfo target;
+          memset(&target, 0, sizeof(target));
+          target.texture = swapchain;
+          target.clear_color.r = win->background[0];
+          target.clear_color.g = win->background[1];
+          target.clear_color.b = win->background[2];
+          target.clear_color.a = win->background[3];
+          target.load_op = SDL_GPU_LOADOP_CLEAR;
+          target.store_op = SDL_GPU_STOREOP_STORE;
+          SDL_GPURenderPass *pass = SDL_BeginGPURenderPass(cmd, &target, 1, NULL);
+          if (pass != NULL) SDL_EndGPURenderPass(pass);
         }
-        SDL_EndGPURenderPass(pass);
         firstFrame = !win->ready;
         win->ready = 1;
       } else {