xbintsc 0.5.37 → 0.5.41

package/runtime/ext_gui/image.cpp

@@ -64,9 +64,71 @@ std::string normalizePath(const std::string &input) {
   return out;
 }
 
+/** Decode a `data:` URL's base64 payload (the only encoding the engine emits
+ * and the common one a page assigns). */
+bool decodeDataUrl(const std::string &url, std::vector<unsigned char> *out) {
+  const size_t comma = url.find(',');
+  if (comma == std::string::npos) return false;
+  const std::string header = url.substr(0, comma);
+  if (header.find(";base64") == std::string::npos) return false;
+  static const signed char kDecode[128] = {
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
+      52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
+      -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+      15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
+      -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+      41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1};
+  out->clear();
+  out->reserve((url.size() - comma) * 3 / 4 + 4);
+  uint32_t accumulator = 0;
+  int bits = 0;
+  for (size_t i = comma + 1; i < url.size(); i++) {
+    const unsigned char c = (unsigned char)url[i];
+    if (c == '=' || c == '\n' || c == '\r' || c == ' ') continue;
+    if (c >= 128) return false;
+    const int value = kDecode[c];
+    if (value < 0) return false;
+    accumulator = (accumulator << 6) | (uint32_t)value;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out->push_back((unsigned char)((accumulator >> bits) & 0xFF));
+    }
+  }
+  return !out->empty();
+}
+
 }  // namespace
 
 const Image *xt_image_load(const std::string &raw_path, int target_width, int target_height) {
+  /* A `data:` URL carries its bytes inline (a canvas used as a CSS
+   * `background-image` reaches this path through `toDataURL()`). */
+  if (raw_path.rfind("data:", 0) == 0) {
+    auto &cache = imageCache();
+    auto found = cache.find(raw_path);
+    if (found != cache.end()) {
+      return found->second.width > 0 ? &found->second : nullptr;
+    }
+    Image image;
+    std::vector<unsigned char> bytes;
+    if (decodeDataUrl(raw_path, &bytes)) {
+      int width = 0;
+      int height = 0;
+      int channels = 0;
+      unsigned char *data = stbi_load_from_memory(bytes.data(), (int)bytes.size(), &width, &height,
+                                                  &channels, 4);
+      if (data != nullptr) {
+        image.width = width;
+        image.height = height;
+        image.pixels.assign(data, data + (size_t)width * (size_t)height * 4);
+        stbi_image_free(data);
+      }
+    }
+    auto inserted = cache.emplace(raw_path, std::move(image));
+    return inserted.first->second.width > 0 ? &inserted.first->second : nullptr;
+  }
   std::string path = normalizePath(raw_path);
   bool svg = xt_svg_is_svg(path);
   /* Raster formats always decode at their intrinsic resolution, so their cache
@@ -102,6 +164,13 @@ const Image *xt_image_load(const std::string &raw_path, int target_width, int ta
 }
 
 bool xt_image_size(const std::string &raw_path, int *width, int *height) {
+  if (raw_path.rfind("data:", 0) == 0) {
+    const Image *image = xt_image_load(raw_path);
+    if (image == nullptr) return false;
+    if (width != nullptr) *width = image->width;
+    if (height != nullptr) *height = image->height;
+    return true;
+  }
   std::string path = normalizePath(raw_path);
   if (xt_svg_is_svg(path)) return xt_svg_size(path, width, height);
   auto &cache = sizeCache();

package/runtime/ext_gui/image_bitmap_browser.cpp

@@ -15,6 +15,7 @@
 #include <vector>
 
 #include "image_bitmap.h"
+#include "canvas.h"
 #include "webgl.h"
 
 namespace {
@@ -47,6 +48,16 @@ bool source_pixels(xt_value source, xtgui::Image *out) {
     return true;
   }
 
+  if (XT_IS_OBJECT(source)) {
+    xt_value canvas_id = xt_object_get_cstr(source, "__xt_gui_canvas");
+    if (XT_IS_NUMBER(canvas_id)) {
+      xtgui::Canvas2D *canvas = xtgui::xt_canvas_by_id((uint64_t)xt_to_number(canvas_id));
+      if (canvas == nullptr || canvas->image().width <= 0) return false;
+      *out = canvas->image();
+      return true;
+    }
+  }
+
   XtGuiWindow *win = nullptr;
   xtgui::Node *node = domapi::resolve_node(source, &win);
   if (node == nullptr || !node->isElement()) return false;

package/runtime/ext_gui/layout.cpp

@@ -20,6 +20,7 @@
 
 #include "image.h"
 #include "inline_svg.h"
+#include "perf.h"
 #include "style_internal.h"
 
 namespace xtgui {
@@ -172,6 +173,8 @@ std::string dumpBox(const LayoutBox *box, int depth) {
 void LayoutTree::compute(const Node *root, const std::unordered_map<const Node *, XtStyle> &styles,
                          float viewportWidth, float viewportHeight, const MediaSizeMap *media,
                          const CanvasInfoMap *canvases) {
+  PerfScope perf_scope(&g_perf_frame_ms.layout);
+  g_perf_frame.layouts += 1;
   root_.reset();
   index_.clear();
   root_style_ = xt_style_initial();
@@ -214,6 +217,7 @@ void LayoutTree::compute(const Node *root, const std::unordered_map<const Node *
     const LayoutBox *box = stack.back();
     stack.pop_back();
     if (box->node != nullptr) index_[box->node] = box;
+    g_perf_frame.layoutBoxes += 1;
     for (const std::unique_ptr<LayoutBox> &child : box->children) stack.push_back(child.get());
   }
 }

package/runtime/ext_gui/paint.cpp

@@ -101,7 +101,26 @@ PaintClip clipForChildren(const LayoutBox *box, const PaintClip &parent) {
 void paintChildren(const LayoutBox *box, DisplayList &out, const PaintClip &clip,
                    const paint_detail::FilterChain &chain, float viewportWidth,
                    float viewportHeight) {
+  /* Fast path: with no stacking child the painter order *is* document order, so
+   * skip the temporary vector and the sort (they used to be allocated and run
+   * for every parent, every repaint). */
+  bool stacked = false;
+  for (const std::unique_ptr<LayoutBox> &child : box->children) {
+    if (child->display == Display::None || child->style == nullptr) continue;
+    if (zIndexOf(child.get()) != 0) {
+      stacked = true;
+      break;
+    }
+  }
+  if (!stacked) {
+    for (const std::unique_ptr<LayoutBox> &child : box->children) {
+      if (child->display == Display::None || child->style == nullptr) continue;
+      paintBox(child.get(), out, clip, chain, viewportWidth, viewportHeight);
+    }
+    return;
+  }
   std::vector<const LayoutBox *> children;
+  children.reserve(box->children.size());
   for (const std::unique_ptr<LayoutBox> &child : box->children) {
     if (child->display == Display::None || child->style == nullptr) continue;
     children.push_back(child.get());

package/runtime/ext_gui/paint_background.cpp

@@ -200,6 +200,21 @@ void paintRadial(const LayoutBox &box, const XtStyle &style, const BackgroundLay
   addEllipse(out, cx, cy, 0.6f, 0.6f, center, clip, box.world);
 }
 
+void paintImage(const LayoutBox &box, const BackgroundLayer &layer, const FilterChain &chain,
+                const PaintClip &clip, DisplayList &out) {
+  if (layer.image_src.empty() || box.width <= 0.0f || box.height <= 0.0f) return;
+  /* A `background-image: url(...)` layer fills the box. (CSS `background-size`
+   * is not modelled, so the intrinsic-size/tiling default becomes a stretch.) */
+  PaintImage image;
+  image.x = box.x;
+  image.y = box.y;
+  image.width = box.width;
+  image.height = box.height;
+  image.src = layer.image_src;
+  image.transform = box.world;
+  addImage(out, image, clip, chain);
+}
+
 }  // namespace
 
 void paintBackgrounds(DisplayList &out, const LayoutBox &box, const XtStyle &style,
@@ -219,8 +234,10 @@ void paintBackgrounds(DisplayList &out, const LayoutBox &box, const XtStyle &sty
     const BackgroundLayer &layer = style.background_layers[i];
     if (layer.kind == BackgroundKind::Linear) {
       paintLinear(box, layer, chain, layerClip, out);
-    } else {
+    } else if (layer.kind == BackgroundKind::Radial) {
       paintRadial(box, style, layer, chain, layerClip, viewportWidth, viewportHeight, out);
+    } else {
+      paintImage(box, layer, chain, layerClip, out);
     }
   }
 }

package/runtime/ext_gui/perf.cpp

@@ -0,0 +1,171 @@
+/*
+ * xbintsc GUI engine — frame timing implementation (see `perf.h`).
+ */
+
+#include "perf.h"
+
+#include <SDL3/SDL.h>
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+namespace xtgui {
+
+PerfCounters g_perf_frame;
+PerfCounters g_perf_total;
+PerfTimings g_perf_frame_ms;
+PerfTimings g_perf_last;
+
+namespace {
+
+int g_perf_mode = -1;  // -1 = not read yet, 0 = disabled, N = every N frames
+uint64_t g_frame_start = 0;
+/** Accumulator for `XT_GUI_PERF=<N>` (N > 1). */
+PerfTimings g_agg_ms;
+PerfCounters g_agg_counters;
+uint64_t g_agg_frames = 0;
+
+void readMode() {
+  if (g_perf_mode >= 0) return;
+  const char *value = SDL_getenv("XT_GUI_PERF");
+  if (value == nullptr || value[0] == '\0' || std::strcmp(value, "0") == 0) {
+    g_perf_mode = 0;
+    return;
+  }
+  int every = std::atoi(value);
+  g_perf_mode = every > 1 ? every : 1;
+}
+
+void addCounters(PerfCounters *target, const PerfCounters &value) {
+  target->frames += value.frames;
+  target->presents += value.presents;
+  target->exposes += value.exposes;
+  target->deferred += value.deferred;
+  target->starvedFrames += value.starvedFrames;
+  target->skippedFrames += value.skippedFrames;
+  target->restyles += value.restyles;
+  target->restyleNodes += value.restyleNodes;
+  target->rulesEvaluated += value.rulesEvaluated;
+  target->mediaEvaluated += value.mediaEvaluated;
+  target->layouts += value.layouts;
+  target->layoutBoxes += value.layoutBoxes;
+  target->textShapeCalls += value.textShapeCalls;
+  target->textShapeHits += value.textShapeHits;
+  target->paints += value.paints;
+  target->paintOps += value.paintOps;
+  target->drawRuns += value.drawRuns;
+  target->drawCalls += value.drawCalls;
+  target->uploadSubmits += value.uploadSubmits;
+  target->vertices += value.vertices;
+  target->syncNodes += value.syncNodes;
+  target->transitionFrames += value.transitionFrames;
+  target->canvasDraws += value.canvasDraws;
+  target->canvasUploads += value.canvasUploads;
+  target->canvasUploadBytes += value.canvasUploadBytes;
+  target->webglDraws += value.webglDraws;
+  target->webglPasses += value.webglPasses;
+  target->webglPipelineMisses += value.webglPipelineMisses;
+  target->webglBufferUploadBytes += value.webglBufferUploadBytes;
+}
+
+void addTimings(PerfTimings *target, const PerfTimings &value) {
+  target->frame += value.frame;
+  target->restyle += value.restyle;
+  target->layout += value.layout;
+  target->paint += value.paint;
+  target->upload += value.upload;
+  target->draw += value.draw;
+}
+
+void printLine(uint64_t frames, const PerfTimings &ms, const PerfCounters &counters) {
+  double divisor = frames > 0 ? (double)frames : 1.0;
+  std::fprintf(stderr,
+               "xt_gui perf frames=%llu ms=%.3f restyle=%.3f layout=%.3f paint=%.3f "
+               "upload=%.3f draw=%.3f restyles=%llu nodes=%llu rules=%llu media=%llu "
+               "layouts=%llu boxes=%llu text=%llu textHit=%llu ops=%llu runs=%llu "
+               "draws=%llu uploads=%llu verts=%llu sync=%llu presents=%llu exposes=%llu "
+               "deferred=%llu starved=%llu skip=%llu "
+               "cdraw=%llu cups=%llu cbytes=%llu gldraw=%llu passes=%llu gmiss=%llu "
+               "gbytes=%llu\n",
+               (unsigned long long)frames, ms.frame / divisor, ms.restyle / divisor,
+               ms.layout / divisor, ms.paint / divisor, ms.upload / divisor, ms.draw / divisor,
+               (unsigned long long)counters.restyles, (unsigned long long)counters.restyleNodes,
+               (unsigned long long)counters.rulesEvaluated,
+               (unsigned long long)counters.mediaEvaluated, (unsigned long long)counters.layouts,
+               (unsigned long long)counters.layoutBoxes,
+               (unsigned long long)counters.textShapeCalls,
+               (unsigned long long)counters.textShapeHits, (unsigned long long)counters.paintOps,
+               (unsigned long long)counters.drawRuns, (unsigned long long)counters.drawCalls,
+               (unsigned long long)counters.uploadSubmits, (unsigned long long)counters.vertices,
+               (unsigned long long)counters.syncNodes, (unsigned long long)counters.presents,
+               (unsigned long long)counters.exposes,
+               (unsigned long long)counters.deferred,
+               (unsigned long long)counters.starvedFrames,
+               (unsigned long long)counters.skippedFrames,
+               (unsigned long long)counters.canvasDraws,
+               (unsigned long long)counters.canvasUploads,
+               (unsigned long long)counters.canvasUploadBytes,
+               (unsigned long long)counters.webglDraws,
+               (unsigned long long)counters.webglPasses,
+               (unsigned long long)counters.webglPipelineMisses,
+               (unsigned long long)counters.webglBufferUploadBytes);
+}
+
+}  // namespace
+
+bool xt_perf_active() {
+  readMode();
+  return g_perf_mode != 0;
+}
+
+uint64_t xt_perf_counter() { return SDL_GetPerformanceCounter(); }
+
+double xt_perf_ms_since(uint64_t start) {
+  uint64_t frequency = SDL_GetPerformanceFrequency();
+  if (frequency == 0 || start == 0) return 0.0;
+  return (double)(SDL_GetPerformanceCounter() - start) * 1000.0 / (double)frequency;
+}
+
+PerfScope::PerfScope(double *slot) {
+  /* Always time the phases: five counter pairs per frame are free, and
+   * `win.stats()` is then useful without the environment variable (which only
+   * controls printing). */
+  slot_ = slot;
+  if (slot_ != nullptr) start_ = SDL_GetPerformanceCounter();
+}
+
+PerfScope::~PerfScope() {
+  if (slot_ == nullptr) return;
+  *slot_ += xt_perf_ms_since(start_);
+}
+
+void xt_perf_frame_begin() {
+  g_perf_frame = PerfCounters();
+  g_perf_frame_ms = PerfTimings();
+  g_frame_start = SDL_GetPerformanceCounter();
+}
+
+void xt_perf_frame_end() {
+  g_perf_frame_ms.frame = xt_perf_ms_since(g_frame_start);
+  g_perf_last = g_perf_frame_ms;
+  g_perf_frame.frames = 1;
+  addCounters(&g_perf_total, g_perf_frame);
+
+  readMode();
+  if (g_perf_mode == 0) return;
+  if (g_perf_mode == 1) {
+    printLine(1, g_perf_frame_ms, g_perf_frame);
+    return;
+  }
+  addTimings(&g_agg_ms, g_perf_frame_ms);
+  addCounters(&g_agg_counters, g_perf_frame);
+  g_agg_frames += 1;
+  if (g_agg_frames < (uint64_t)g_perf_mode) return;
+  printLine(g_agg_frames, g_agg_ms, g_agg_counters);
+  g_agg_ms = PerfTimings();
+  g_agg_counters = PerfCounters();
+  g_agg_frames = 0;
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/perf.h

@@ -0,0 +1,127 @@
+/*
+ * xbintsc GUI engine — frame counters and phase timings.
+ *
+ * The engine is a single-threaded UI loop, so one process-wide record is
+ * enough. `xt_gui_render_window` brackets every frame with
+ * `xt_perf_frame_begin()` / `xt_perf_frame_end()`; the rest of the engine only
+ * bumps counters or wraps a phase in `PerfScope`. `win.stats()` exposes the
+ * last frame plus the cumulative totals, which is what
+ * `tests/e2e/gui-perf.test.ts` asserts on (wall-clock times are informational
+ * only, so the suite also runs on a software GPU in CI).
+ *
+ * Set `XT_GUI_PERF=1` to print one line per frame, or `XT_GUI_PERF=<N>` to
+ * print an aggregated line every N frames (average of the timings, sums of the
+ * counters). The counters and phase timings are always recorded (a few counter
+ * reads per frame), so `win.stats()` is useful without the variable; the
+ * environment variable only controls the stderr printing.
+ */
+#ifndef XT_GUI_PERF_H
+#define XT_GUI_PERF_H
+
+#include <cstdint>
+
+namespace xtgui {
+
+/** Counters for one frame; the same layout is reused for cumulative totals. */
+struct PerfCounters {
+  uint64_t frames = 0;
+  uint64_t presents = 0;
+  /** Presents the *window system* asked for (a map/expose/restore event), not
+   * the page. They are real work — the compositor lost the contents — but a
+   * quiet page must not be blamed for them: a window server sends its first
+   * `Expose` whenever it gets around to mapping the window, which on a busy CI
+   * runner can land long after the first frames. At most one is charged per
+   * frame (the events coalesce into a single present), so
+   * `presents - exposes - deferred` counts the presents only the page asked
+   * for. */
+  uint64_t exposes = 0;
+  /** Presents a starved frame had to defer: no swapchain image was available
+   * then (the GPU still held it, or the window was minimized), so the frame's
+   * paint was presented on a later frame. Those presents replay work built in
+   * an earlier frame, so they are not this frame's page work either. */
+  uint64_t deferred = 0;
+  /** Frames that asked to present and got no drawable target at all: SDL's
+   * non-blocking swapchain acquire had no image (the GPU still held it) or the
+   * device gave no command buffer. The invalidation stays pending (see
+   * `deferred`), so the content is presented on a later frame rather than lost;
+   * a climbing value means the compositor keeps refusing images and the window
+   * is not being updated. */
+  uint64_t starvedFrames = 0;
+  uint64_t skippedFrames = 0;
+  uint64_t restyles = 0;
+  uint64_t restyleNodes = 0;
+  uint64_t rulesEvaluated = 0;
+  uint64_t mediaEvaluated = 0;
+  uint64_t layouts = 0;
+  uint64_t layoutBoxes = 0;
+  uint64_t textShapeCalls = 0;
+  uint64_t textShapeHits = 0;
+  uint64_t paints = 0;
+  uint64_t paintOps = 0;
+  uint64_t drawRuns = 0;
+  uint64_t drawCalls = 0;
+  uint64_t uploadSubmits = 0;
+  uint64_t vertices = 0;
+  uint64_t syncNodes = 0;
+  uint64_t transitionFrames = 0;
+  /* Canvas 2D: CPU draws, texture uploads and the bytes they move. A canvas
+   * that is only redrawn in a small region should show a small `bytes` count. */
+  uint64_t canvasDraws = 0;
+  uint64_t canvasUploads = 0;
+  uint64_t canvasUploadBytes = 0;
+  /* WebGL: draw calls, render passes actually opened (a draw that has nothing
+   * to upload must not open a new pass), pipeline-cache misses and the bytes
+   * buffer updates copy to the GPU. */
+  uint64_t webglDraws = 0;
+  uint64_t webglPasses = 0;
+  uint64_t webglPipelineMisses = 0;
+  uint64_t webglBufferUploadBytes = 0;
+};
+
+/** Wall-clock phase timings in milliseconds. */
+struct PerfTimings {
+  double frame = 0;
+  double restyle = 0;
+  double layout = 0;
+  double paint = 0;
+  double upload = 0;
+  double draw = 0;
+};
+
+/** The frame being recorded; reset by `xt_perf_frame_begin`. */
+extern PerfCounters g_perf_frame;
+/** Every frame since startup. */
+extern PerfCounters g_perf_total;
+/** Phase timings of the frame being recorded. */
+extern PerfTimings g_perf_frame_ms;
+/** Phase timings of the last completed frame. */
+extern PerfTimings g_perf_last;
+
+/** True when `XT_GUI_PERF` asks for timings/printing. Cached after first use. */
+bool xt_perf_active();
+
+/** Raw performance counter, for `PerfScope` / ad-hoc measurements. */
+uint64_t xt_perf_counter();
+/** Milliseconds elapsed since `start` (from `xt_perf_counter`). */
+double xt_perf_ms_since(uint64_t start);
+
+void xt_perf_frame_begin();
+void xt_perf_frame_end();
+
+/** Accumulate elapsed milliseconds into `*slot` while in scope. A no-op (beyond
+ * one branch) when `XT_GUI_PERF` is unset. */
+class PerfScope {
+ public:
+  explicit PerfScope(double *slot);
+  ~PerfScope();
+  PerfScope(const PerfScope &) = delete;
+  PerfScope &operator=(const PerfScope &) = delete;
+
+ private:
+  double *slot_ = nullptr;
+  uint64_t start_ = 0;
+};
+
+}  // namespace xtgui
+
+#endif  // XT_GUI_PERF_H